Class AppState
Hierarchy
- TagClassShape<"AppState", {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, this>- AppState
Index
Constructors
Properties
Methods
Properties
Readonly[
[
Id
Id
ReadonlyType
Type: {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}
Static Readonly_op
_op
Static Readonly[
[
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, unknown, AppState>
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, unknown, AppState>
Static Readonly[
[
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, never, AppState>
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, never, AppState>
Static Optional[ignore
[ignore
Static Readonly[
[
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, unknown, never, never, AppState>
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, unknown, never, never, AppState>
Static Readonly[STMType
[STMType
_A: Covariant<{
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>;
_E: Covariant<never>;
_R: Covariant<AppState>;
}
_A: Covariant<{
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>;
_E: Covariant<never>;
_R: Covariant<AppState>;
}
Static Readonly[
[
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, never, AppState>
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}, never, AppState>
Static Readonly[
[
_Identifier: Invariant<AppState>;
_Service: Invariant<{
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>;
}
_Identifier: Invariant<AppState>;
_Service: Invariant<{
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>>
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>>
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Service: {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<AppState, {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>> Returns EffectGenerator<Tag<AppState, {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}>>
Static[
Staticcontext
- context(self): Context<AppState>
Parameters
- self: {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}Readonlyinit: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>)- (options): Effect<AppStateReset, never, never>
Parameters
- options: {
onRequestSync: (() => void);
reloadUrl: string;
}ReadonlyonRequest Sync: (() => void) - (): void
Returns void
ReadonlyreloadUrl: string
Returns Effect<AppStateReset, never, never>
- options: {
Returns Context<AppState>
- self: {
Staticof
- of(self): {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
} Parameters
- self: {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}Readonlyinit: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>)- (options): Effect<AppStateReset, never, never>
Parameters
- options: {
onRequestSync: (() => void);
reloadUrl: string;
}ReadonlyonRequest Sync: (() => void) - (): void
Returns void
ReadonlyreloadUrl: string
Returns Effect<AppStateReset, never, never>
- options: {
Returns {
init: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>);
}Readonlyinit: ((options: {
onRequestSync: (() => void);
reloadUrl: string;
}) => Effect<AppStateReset, never, never>)- (options): Effect<AppStateReset, never, never>
Parameters
- options: {
onRequestSync: (() => void);
reloadUrl: string;
}ReadonlyonRequest Sync: (() => void) - (): void
Returns void
ReadonlyreloadUrl: string
Returns Effect<AppStateReset, never, never>
- options: {
- self: {
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class DbFactory
Hierarchy
- TagClassShape<"DbFactory", {
createDb: Effect<Db, never, never>;
}, this>- DbFactory
Index
Constructors
Properties
Methods
Properties
Readonly[
[
Id
Id
ReadonlyType
Static Readonly_op
_op
Static Readonly[
Static Readonly[
Static Optional[ignore
[ignore
Static Readonly[
Static Readonly[STMType
Static Readonly[
Static Readonly[
Static Optional[type
[type
Static Optional[unify
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
Static[
Staticcontext
Staticof
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class EvoluFactory
Hierarchy
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Evolu Factory(_): EvoluFactory Parameters
- _: never
Returns EvoluFactory
Properties
Readonly[
[
Id
Id
ReadonlyType
Type: {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}
Type declaration
ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Static Readonly_op
_op
Static Readonly[
[
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, unknown, EvoluFactory>
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, unknown, EvoluFactory>
Type declaration
ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Static Readonly[
[
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, never, EvoluFactory>
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, never, EvoluFactory>
Type declaration
ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Static Optional[ignore
[ignore
Static Readonly[
[
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, unknown, never, never, EvoluFactory>
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, unknown, never, never, EvoluFactory>
Type declaration
ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Static Readonly[STMType
[STMType
_A: Covariant<{
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>;
_E: Covariant<never>;
_R: Covariant<EvoluFactory>;
}
_A: Covariant<{
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>;
_E: Covariant<never>;
_R: Covariant<EvoluFactory>;
}
Static Readonly[
[
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, never, EvoluFactory>
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}, never, EvoluFactory>
Type declaration
ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Static Readonly[
[
_Identifier: Invariant<EvoluFactory>;
_Service: Invariant<{
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>;
}
_Identifier: Invariant<EvoluFactory>;
_Service: Invariant<{
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>>
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>>
StaticCommon
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Service: {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}
Type declaration
ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<EvoluFactory, {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>> Returns EffectGenerator<Tag<EvoluFactory, {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}>>
Static[
Staticcontext
- context(self): Context<EvoluFactory>
Parameters
- self: {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Returns Context<EvoluFactory>
- self: {
Staticof
- of(self): {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
} Parameters
- self: {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
Returns {
createEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>);
}ReadonlycreateEvolu: (<T, I>(schema: Schema<T, I, never>, config?: Partial<EvoluConfig<T>>) => Evolu<T>) Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.Example
+ +import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
// The same API for different platforms
// import * as E from "@evolu/react-native";
// import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database); +
- self: {
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class NanoIdGenerator
Hierarchy
- TagClassShape<"NanoIdGenerator", {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, this>- NanoIdGenerator
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Nano Id Generator(_): NanoIdGenerator Parameters
- _: never
Returns NanoIdGenerator
Properties
Readonly[
[
Id
Id
ReadonlyType
Type: {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}
Static Readonly_op
_op
Static Readonly[
[
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, unknown, NanoIdGenerator>
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, unknown, NanoIdGenerator>
Static Readonly[
[
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, never, NanoIdGenerator>
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, never, NanoIdGenerator>
Static Optional[ignore
[ignore
Static Readonly[
[
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, unknown, never, never, NanoIdGenerator>
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, unknown, never, never, NanoIdGenerator>
Static Readonly[STMType
[STMType
_A: Covariant<{
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>;
_E: Covariant<never>;
_R: Covariant<NanoIdGenerator>;
}
_A: Covariant<{
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>;
_E: Covariant<never>;
_R: Covariant<NanoIdGenerator>;
}
Static Readonly[
[
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, never, NanoIdGenerator>
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}, never, NanoIdGenerator>
Static Readonly[
[
_Identifier: Invariant<NanoIdGenerator>;
_Service: Invariant<{
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>;
}
_Identifier: Invariant<NanoIdGenerator>;
_Service: Invariant<{
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>>
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>>
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Service: {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<NanoIdGenerator, {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>> Returns EffectGenerator<Tag<NanoIdGenerator, {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}>>
Static[
Staticcontext
- context(self): Context<NanoIdGenerator>
Parameters
- self: {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}Readonlynanoid: Effect<NanoId, never, never>ReadonlynodeId: Effect<string & Brand<"NodeId">, never, never> ReadonlyrowId: Effect<string & Brand<"Id">, never, never>
Returns Context<NanoIdGenerator>
- self: {
Staticof
- of(self): {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
} Parameters
- self: {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}Readonlynanoid: Effect<NanoId, never, never>ReadonlynodeId: Effect<string & Brand<"NodeId">, never, never> ReadonlyrowId: Effect<string & Brand<"Id">, never, never>
Returns {
nanoid: Effect<NanoId, never, never>;
nodeId: Effect<string & Brand<"NodeId">, never, never>;
rowId: Effect<string & Brand<"Id">, never, never>;
}Readonlynanoid: Effect<NanoId, never, never>ReadonlynodeId: Effect<string & Brand<"NodeId">, never, never> ReadonlyrowId: Effect<string & Brand<"Id">, never, never>
- self: {
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class SecretBox
Hierarchy
- TagClassShape<"SecretBox", {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, this>- SecretBox
Index
Constructors
Properties
Methods
Properties
Readonly[
[
Id
Id
ReadonlyType
Type: {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}
Static Readonly_op
_op
Static Readonly[
[
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, unknown, SecretBox>
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, unknown, SecretBox>
Static Readonly[
[
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, never, SecretBox>
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, never, SecretBox>
Static Optional[ignore
[ignore
Static Readonly[
[
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, unknown, never, never, SecretBox>
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, unknown, never, never, SecretBox>
Static Readonly[STMType
[STMType
_A: Covariant<{
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>;
_E: Covariant<never>;
_R: Covariant<SecretBox>;
}
_A: Covariant<{
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>;
_E: Covariant<never>;
_R: Covariant<SecretBox>;
}
Static Readonly[
[
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, never, SecretBox>
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}, never, SecretBox>
Static Readonly[
[
_Identifier: Invariant<SecretBox>;
_Service: Invariant<{
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>;
}
_Identifier: Invariant<SecretBox>;
_Service: Invariant<{
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>>
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>>
Static ReadonlyIdentifier
Static Readonlykey
key: string
StaticLive
Static ReadonlyService
Service: {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<SecretBox, {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>> Returns EffectGenerator<Tag<SecretBox, {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}>>
Static[
Staticcontext
- context(self): Context<SecretBox>
Parameters
- self: {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}Readonlyopen: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>)- (key, ciphertext): Effect<Uint8Array, never, never>
Parameters
- key: Uint8Array
- ciphertext: Uint8Array
Returns Effect<Uint8Array, never, never>
Readonlyseal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>)- (key, plaintext): Effect<Uint8Array, never, never>
Parameters
- key: Uint8Array
- plaintext: Uint8Array
Returns Effect<Uint8Array, never, never>
Returns Context<SecretBox>
- self: {
Staticof
- of(self): {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
} Parameters
- self: {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}Readonlyopen: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>)- (key, ciphertext): Effect<Uint8Array, never, never>
Parameters
- key: Uint8Array
- ciphertext: Uint8Array
Returns Effect<Uint8Array, never, never>
Readonlyseal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>)- (key, plaintext): Effect<Uint8Array, never, never>
Parameters
- key: Uint8Array
- plaintext: Uint8Array
Returns Effect<Uint8Array, never, never>
Returns {
open: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>);
seal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>);
}Readonlyopen: ((key: Uint8Array, ciphertext: Uint8Array) => Effect<Uint8Array, never, never>)- (key, ciphertext): Effect<Uint8Array, never, never>
Parameters
- key: Uint8Array
- ciphertext: Uint8Array
Returns Effect<Uint8Array, never, never>
Readonlyseal: ((key: Uint8Array, plaintext: Uint8Array) => Effect<Uint8Array, never, never>)- (key, plaintext): Effect<Uint8Array, never, never>
Parameters
- key: Uint8Array
- plaintext: Uint8Array
Returns Effect<Uint8Array, never, never>
- self: {
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class SqliteFactory
Hierarchy
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Sqlite Factory(_): SqliteFactory Parameters
- _: never
Returns SqliteFactory
Properties
Readonly[
[
Id
Id
ReadonlyType
Static Readonly_op
_op
Static Readonly[
[
createSqlite: Effect<Sqlite, never, Config>;
}, unknown, SqliteFactory>
createSqlite: Effect<Sqlite, never, Config>;
}, unknown, SqliteFactory>
Static Readonly[
[
createSqlite: Effect<Sqlite, never, Config>;
}, never, SqliteFactory>
createSqlite: Effect<Sqlite, never, Config>;
}, never, SqliteFactory>
Static Optional[ignore
[ignore
Static Readonly[
[
createSqlite: Effect<Sqlite, never, Config>;
}, unknown, never, never, SqliteFactory>
createSqlite: Effect<Sqlite, never, Config>;
}, unknown, never, never, SqliteFactory>
Static Readonly[STMType
[STMType
_A: Covariant<{
createSqlite: Effect<Sqlite, never, Config>;
}>;
_E: Covariant<never>;
_R: Covariant<SqliteFactory>;
}
_A: Covariant<{
createSqlite: Effect<Sqlite, never, Config>;
}>;
_E: Covariant<never>;
_R: Covariant<SqliteFactory>;
}
Static Readonly[
[
createSqlite: Effect<Sqlite, never, Config>;
}, never, SqliteFactory>
createSqlite: Effect<Sqlite, never, Config>;
}, never, SqliteFactory>
Static Readonly[
[
_Identifier: Invariant<SqliteFactory>;
_Service: Invariant<{
createSqlite: Effect<Sqlite, never, Config>;
}>;
}
_Identifier: Invariant<SqliteFactory>;
_Service: Invariant<{
createSqlite: Effect<Sqlite, never, Config>;
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
createSqlite: Effect<Sqlite, never, Config>;
}>>
createSqlite: Effect<Sqlite, never, Config>;
}>>
StaticCommon
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<SqliteFactory, {
createSqlite: Effect<Sqlite, never, Config>;
}>> Returns EffectGenerator<Tag<SqliteFactory, {
createSqlite: Effect<Sqlite, never, Config>;
}>>
Static[
Staticcontext
- context(self): Context<SqliteFactory>
Parameters
Returns Context<SqliteFactory>
Staticof
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class SyncFactory
Hierarchy
- TagClassShape<"SyncFactory", {
createSync: Effect<Sync, never, never>;
}, this>- SyncFactory
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Sync Factory(_): SyncFactory Parameters
- _: never
Returns SyncFactory
Properties
Readonly[
[
Id
Id
ReadonlyType
Static Readonly_op
_op
Static Readonly[
[
createSync: Effect<Sync, never, never>;
}, unknown, SyncFactory>
createSync: Effect<Sync, never, never>;
}, unknown, SyncFactory>
Static Readonly[
Static Optional[ignore
[ignore
Static Readonly[
[
createSync: Effect<Sync, never, never>;
}, unknown, never, never, SyncFactory>
createSync: Effect<Sync, never, never>;
}, unknown, never, never, SyncFactory>
Static Readonly[STMType
[STMType
_A: Covariant<{
createSync: Effect<Sync, never, never>;
}>;
_E: Covariant<never>;
_R: Covariant<SyncFactory>;
}
_A: Covariant<{
createSync: Effect<Sync, never, never>;
}>;
_E: Covariant<never>;
_R: Covariant<SyncFactory>;
}
Static Readonly[
Static Readonly[
[
_Identifier: Invariant<SyncFactory>;
_Service: Invariant<{
createSync: Effect<Sync, never, never>;
}>;
}
_Identifier: Invariant<SyncFactory>;
_Service: Invariant<{
createSync: Effect<Sync, never, never>;
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
createSync: Effect<Sync, never, never>;
}>>
createSync: Effect<Sync, never, never>;
}>>
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<SyncFactory, {
createSync: Effect<Sync, never, never>;
}>> Returns EffectGenerator<Tag<SyncFactory, {
createSync: Effect<Sync, never, never>;
}>>
Static[
Staticcontext
- context(self): Context<SyncFactory>
Parameters
Returns Context<SyncFactory>
Staticof
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class SyncLock
Hierarchy
- TagClassShape<"SyncLock", {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, this>- SyncLock
Index
Constructors
Properties
Methods
Properties
Readonly[
[
Id
Id
ReadonlyType
Static Readonly_op
_op
Static Readonly[
[
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, unknown, SyncLock>
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, unknown, SyncLock>
Static Readonly[
[
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, never, SyncLock>
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, never, SyncLock>
Static Optional[ignore
[ignore
Static Readonly[
[
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, unknown, never, never, SyncLock>
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, unknown, never, never, SyncLock>
Static Readonly[STMType
[STMType
_A: Covariant<{
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>;
_E: Covariant<never>;
_R: Covariant<SyncLock>;
}
_A: Covariant<{
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>;
_E: Covariant<never>;
_R: Covariant<SyncLock>;
}
Static Readonly[
[
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, never, SyncLock>
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}, never, SyncLock>
Static Readonly[
[
_Identifier: Invariant<SyncLock>;
_Service: Invariant<{
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>;
}
_Identifier: Invariant<SyncLock>;
_Service: Invariant<{
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>>
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>>
Static ReadonlyIdentifier
Static Readonlykey
key: string
Static ReadonlyService
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<SyncLock, {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>> Returns EffectGenerator<Tag<SyncLock, {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}>>
Static[
Staticcontext
- context(self): Context<SyncLock>
Parameters
- self: {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}ReadonlytryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>
Returns Context<SyncLock>
- self: {
Staticof
- of(self): {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
} Parameters
- self: {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}ReadonlytryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>
Returns {
tryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>;
}ReadonlytryAcquire: Effect<SyncLockRelease, SyncLockAlreadySyncingError, Scope | Config>
- self: {
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
Class SyncLockAlreadySyncingError
Index
Constructors
Properties
_tag
+
Constructors
constructor
- new
Sync Lock Already Syncing Error(): SyncLockAlreadySyncingError Returns SyncLockAlreadySyncingError
Class Time
Hierarchy
- TagClassShape<"Time", {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, this>- Time
Index
Constructors
Properties
Methods
Properties
Readonly[
[
Id
Id
ReadonlyType
Static Readonly_op
_op
Static Readonly[
[
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, unknown, Time>
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, unknown, Time>
Static Readonly[
[
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, never, Time>
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, never, Time>
Static Optional[ignore
[ignore
Static Readonly[
[
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, unknown, never, never, Time>
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, unknown, never, never, Time>
Static Readonly[STMType
[STMType
_A: Covariant<{
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>;
_E: Covariant<never>;
_R: Covariant<Time>;
}
_A: Covariant<{
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>;
_E: Covariant<never>;
_R: Covariant<Time>;
}
Static Readonly[
[
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, never, Time>
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}, never, Time>
Static Readonly[
[
_Identifier: Invariant<Time>;
_Service: Invariant<{
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>;
}
_Identifier: Invariant<Time>;
_Service: Invariant<{
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>;
}
Static Optional[type
[type
Static Optional[unify
[unify
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>>
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>>
Static ReadonlyIdentifier
Static Readonlykey
key: string
StaticLive
Static ReadonlyService
Static Optional Readonlystack
stack?: string
Methods
Static[
Static[iterator]
- [iterator](): EffectGenerator<Tag<Time, {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>> Returns EffectGenerator<Tag<Time, {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}>>
Static[
Staticcontext
- context(self): Context<Time>
Parameters
- self: {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}Readonlynow: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>
Returns Context<Time>
- self: {
Staticof
- of(self): {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
} Parameters
- self: {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}Readonlynow: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>
Returns {
now: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>;
}Readonlynow: Effect<number & Brand<"Millis">, TimestampTimeOutOfRangeError, never>
- self: {
Staticpipe
- pipe<A>(this): A
Type Parameters
Parameters
- this: A
Returns A
- pipe<A, B>(this, ab): B
Type Parameters
Returns B
- pipe<A, B, C>(this, ab, bc): C
Type Parameters
Parameters
Returns C
- pipe<A, B, C, D>(this, ab, bc, cd): D
Type Parameters
Parameters
Returns D
- pipe<A, B, C, D, E>(this, ab, bc, cd, de): E
Type Parameters
Parameters
Returns E
- pipe<A, B, C, D, E, F>(this, ab, bc, cd, de, ef): F
Type Parameters
Parameters
Returns F
- pipe<A, B, C, D, E, F, G>(this, ab, bc, cd, de, ef, fg): G
Type Parameters
Parameters
Returns G
- pipe<A, B, C, D, E, F, G, H>(this, ab, bc, cd, de, ef, fg, gh): H
Type Parameters
Parameters
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(this, ab, bc, cd, de, ef, fg, gh, hi): I
Type Parameters
Parameters
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(this, ab, bc, cd, de, ef, fg, gh, hi, ij): J
Type Parameters
Parameters
Returns J
- pipe<A, B, C, D, E, F, G, H, I, J, K>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk): K
Type Parameters
Parameters
Returns K
- pipe<A, B, C, D, E, F, G, H, I, J, K, L>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L
Type Parameters
Parameters
Returns L
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M
Type Parameters
Parameters
Returns M
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N
Type Parameters
Parameters
Returns N
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O
Type Parameters
Parameters
Returns O
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P
Type Parameters
Parameters
Returns P
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q
Type Parameters
Parameters
Returns Q
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R
Type Parameters
Parameters
Returns R
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
Returns S
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
Returns T
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
- pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(this, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st, tu): U
Type Parameters
Parameters
- this: A
- ab: ((_: A) => B)
- bc: ((_: B) => C)
- cd: ((_: C) => D)
- de: ((_: D) => E)
- ef: ((_: E) => F)
- fg: ((_: F) => G)
- gh: ((_: G) => H)
- hi: ((_: H) => I)
- ij: ((_: I) => J)
- jk: ((_: J) => K)
- kl: ((_: K) => L)
- lm: ((_: L) => M)
- mn: ((_: M) => N)
- no: ((_: N) => O)
- op: ((_: O) => P)
- pq: ((_: P) => Q)
- qr: ((_: Q) => R)
- rs: ((_: R) => S)
- st: ((_: S) => T)
- tu: ((_: T) => U)
Returns U
StatictoJSON
Staticto
diff --git a/functions/_evolu_common.areEqual.html b/functions/_evolu_common.areEqual.html
new file mode 100644
index 000000000..b58245ccc
--- /dev/null
+++ b/functions/_evolu_common.areEqual.html
@@ -0,0 +1 @@
+
diff --git a/functions/_evolu_common.cast.html b/functions/_evolu_common.cast.html
new file mode 100644
index 000000000..993032f06
--- /dev/null
+++ b/functions/_evolu_common.cast.html
@@ -0,0 +1,7 @@
+
Function cast
- cast(value): SqliteBoolean
A helper for casting types not supported by SQLite. SQLite doesn't support +Date nor Boolean types, so Evolu emulates them with SqliteBoolean and +SqliteDate.
+Parameters
- value: boolean
Returns SqliteBoolean
- cast(value): boolean
Parameters
- value: (0 | 1) & Brand<"SqliteBoolean">
Returns boolean
- cast(value): SqliteDate
Parameters
- value: Date
Returns SqliteDate
- cast(value): Date
Parameters
- value: string & Brand<"SqliteDate">
Returns Date
Function createIndexes
Create SQLite indexes.
+ +- create
Indexes(callback): readonly {
name: string;
sql: string;
}[] Parameters
- callback: ((create: ((indexName: string) => CreateIndexBuilder<never>)) => readonly CreateIndexBuilder<any>[])
- (create): readonly CreateIndexBuilder<any>[]
Parameters
- create: ((indexName: string) => CreateIndexBuilder<never>)
Returns readonly CreateIndexBuilder<any>[]
Returns readonly {
name: string;
sql: string;
}[]- callback: ((create: ((indexName: string) => CreateIndexBuilder<never>)) => readonly CreateIndexBuilder<any>[])
Function createMnemonic
Mnemonic is a password generated by Evolu in BIP39 format.
+A mnemonic, also known as a "seed phrase," is a set of 12 words in a specific +order chosen from a predefined list. The purpose of the BIP39 mnemonic is to +provide a human-readable way of storing a private key.
+Function createNanoIdGeneratorLive
- create
Nano Id Generator Live(customAlphabet, nanoid): Layer<NanoIdGenerator, never, never> Parameters
- customAlphabet: ((alphabet: string, defaultSize?: number) => ((size?: number) => string))
- (alphabet, defaultSize?): ((size?: number) => string)
Parameters
- alphabet: string
OptionaldefaultSize: number
Returns ((size?: number) => string)
- (size?): string
Parameters
Optionalsize: number
Returns string
- nanoid: ((size?: number) => string)
- (size?): string
Parameters
Optionalsize: number
Returns string
Returns Layer<NanoIdGenerator, never, never>
- customAlphabet: ((alphabet: string, defaultSize?: number) => ((size?: number) => string))
Function createRuntime
Function database
Create database schema.
+Tables with a name prefixed with _ are local-only, which means they are not +synced. Local-only tables are useful for device-specific or temporal data.
+Function deserializeQuery
- deserialize
Query<R>(query): SqliteQuery Type Parameters
- R extends Row
Returns SqliteQuery
Function diffMerkleTrees
- diff
Merkle Trees(tree1, tree2): Option<number & Brand<"Millis">> Parameters
- tree1: MerkleTree
- tree2: MerkleTree
Returns Option<number & Brand<"Millis">>
Function drawSqliteQueryPlan
- draw
Sqlite Query Plan(rows): string Parameters
- rows: SqliteQueryPlanRow[]
Returns string
diff --git a/functions/_evolu_common.getLockName.html b/functions/_evolu_common.getLockName.html
new file mode 100644
index 000000000..2d011748e
--- /dev/null
+++ b/functions/_evolu_common.getLockName.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/_evolu_common.id-2.html b/functions/_evolu_common.id-2.html
new file mode 100644
index 000000000..9c351fcc1
--- /dev/null
+++ b/functions/_evolu_common.id-2.html
@@ -0,0 +1,5 @@
+
diff --git a/functions/_evolu_common.insertIntoMerkleTree.html b/functions/_evolu_common.insertIntoMerkleTree.html
new file mode 100644
index 000000000..e065c8949
--- /dev/null
+++ b/functions/_evolu_common.insertIntoMerkleTree.html
@@ -0,0 +1 @@
+
Function insertIntoMerkleTree
- insert
Into Merkle Tree(tree, timestamp): MerkleTree Parameters
- tree: MerkleTree
- timestamp: Timestamp
Returns MerkleTree
Function isJsonObjectOrArray
- is
Json Object Or Array(a): a is JsonObjectOrArray Parameters
- a: Value
Returns a is JsonObjectOrArray
diff --git a/functions/_evolu_common.makePatches.html b/functions/_evolu_common.makePatches.html
new file mode 100644
index 000000000..3902d31b3
--- /dev/null
+++ b/functions/_evolu_common.makePatches.html
@@ -0,0 +1,6 @@
+
Function makePatches
We detect only changes in the whole result and in-place edits. In the future, +we will add more heuristics. We will probably not implement the Myers diff +algorithm because it's faster to rerender all than to compute many detailed +patches. We will only implement logic a developer would implement manually, +if necessary.
+
diff --git a/functions/_evolu_common.makeSyncTimestamp.html b/functions/_evolu_common.makeSyncTimestamp.html
new file mode 100644
index 000000000..7db4b9a7f
--- /dev/null
+++ b/functions/_evolu_common.makeSyncTimestamp.html
@@ -0,0 +1 @@
+
diff --git a/functions/_evolu_common.makeUnexpectedError.html b/functions/_evolu_common.makeUnexpectedError.html
new file mode 100644
index 000000000..f4696b8cb
--- /dev/null
+++ b/functions/_evolu_common.makeUnexpectedError.html
@@ -0,0 +1 @@
+
Function makeUnexpectedError
- make
Unexpected Error(error): UnexpectedError Parameters
- error: unknown
Returns UnexpectedError
Function maybeLogSqliteQueryExecutionTime
Function maybeParseJson
This function mutates for better performance.
+- maybe
Parse Json(rows): void Parameters
- rows: SqliteRow[]
Returns void
Function merkleTreeToString
- merkle
Tree To String(m): MerkleTreeString Parameters
- m: MerkleTree
Returns MerkleTreeString
diff --git a/functions/_evolu_common.mnemonicToSeed.html b/functions/_evolu_common.mnemonicToSeed.html
new file mode 100644
index 000000000..2696c6ed5
--- /dev/null
+++ b/functions/_evolu_common.mnemonicToSeed.html
@@ -0,0 +1 @@
+
Function mnemonicToSeed
- mnemonic
To Seed(mnemonic): Uint8Array Parameters
- mnemonic: Mnemonic
Returns Uint8Array
diff --git a/functions/_evolu_common.parseMnemonic.html b/functions/_evolu_common.parseMnemonic.html
new file mode 100644
index 000000000..afd0b132d
--- /dev/null
+++ b/functions/_evolu_common.parseMnemonic.html
@@ -0,0 +1,2 @@
+
Function parseMnemonic
Parse a string to Mnemonic.
+- parse
Mnemonic(mnemonic): Effect<Mnemonic, InvalidMnemonicError, never> Parameters
- mnemonic: string
Returns Effect<Mnemonic, InvalidMnemonicError, never>
Function queryResultFromRows
- query
Result From Rows<R>(rows): QueryResult<R> Type Parameters
- R extends Row
Parameters
- rows: readonly R[]
Returns QueryResult<R>
Function receiveTimestamp
- receive
Timestamp(__namedParameters): Effect<Timestamp,
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError, Config | Time> Parameters
Returns Effect<Timestamp,
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError, Config | Time>
Function sendTimestamp
- send
Timestamp(timestamp): Effect<Timestamp, TimestampTimeOutOfRangeError | TimestampDriftError | TimestampCounterOverflowError, Config | Time> Parameters
- timestamp: Timestamp
Returns Effect<Timestamp, TimestampTimeOutOfRangeError | TimestampDriftError | TimestampCounterOverflowError, Config | Time>
diff --git a/functions/_evolu_common.slip21Derive.html b/functions/_evolu_common.slip21Derive.html
new file mode 100644
index 000000000..de759e883
--- /dev/null
+++ b/functions/_evolu_common.slip21Derive.html
@@ -0,0 +1 @@
+
diff --git a/functions/_evolu_common.table-1.html b/functions/_evolu_common.table-1.html
new file mode 100644
index 000000000..38d0bc6e6
--- /dev/null
+++ b/functions/_evolu_common.table-1.html
@@ -0,0 +1,9 @@
+
Function table
Create table schema.
+Supported types are null, string, number, Uint8Array, JSON Object, and JSON +Array. Use SqliteDate for dates and SqliteBoolean for booleans.
+Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added +by default.
+- table<Fields>(fields): ValidateFieldsTypes<Fields> extends true
? ValidateFieldsNames<Fields> extends true
? ValidateFieldsHasId<Fields> extends true
? Schema<Simplify<Type<Fields> & {
createdAt: string & Brand<"SqliteDate">;
isDeleted: (0 | 1) & Brand<"SqliteBoolean">;
updatedAt: string & Brand<"SqliteDate">;
}>, Simplify<{
readonly [K in string | number | symbol as Key<Fields, K>]: Encoded<Fields[K]>
} & {
readonly [K in string | number | symbol as Key<Fields, K>]?: Encoded<Fields[K]>
} & {
createdAt: string;
isDeleted: number;
updatedAt: string;
}>, never>
: EvoluTypeError<"table() called without id column.">
: EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
: EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans."> Type Parameters
Parameters
- fields: Fields
Returns ValidateFieldsTypes<Fields> extends true
? ValidateFieldsNames<Fields> extends true
? ValidateFieldsHasId<Fields> extends true
? Schema<Simplify<Type<Fields> & {
createdAt: string & Brand<"SqliteDate">;
isDeleted: (0 | 1) & Brand<"SqliteBoolean">;
updatedAt: string & Brand<"SqliteDate">;
}>, Simplify<{
readonly [K in string | number | symbol as Key<Fields, K>]: Encoded<Fields[K]>
} & {
readonly [K in string | number | symbol as Key<Fields, K>]?: Encoded<Fields[K]>
} & {
createdAt: string;
isDeleted: number;
updatedAt: string;
}>, never>
: EvoluTypeError<"table() called without id column.">
: EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
: EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans.">
Function timestampToHash
- timestamp
To Hash(t): TimestampHash Parameters
- t: Timestamp
Returns TimestampHash
Function timestampToString
- timestamp
To String(t): TimestampString Parameters
- t: Timestamp
Returns TimestampString
Function unsafeMerkleTreeFromString
- unsafe
Merkle Tree From String(m): MerkleTree Parameters
Returns MerkleTree
diff --git a/functions/_evolu_common.upsertValueIntoTableRowColumn.html b/functions/_evolu_common.upsertValueIntoTableRowColumn.html
new file mode 100644
index 000000000..94e675599
--- /dev/null
+++ b/functions/_evolu_common.upsertValueIntoTableRowColumn.html
@@ -0,0 +1 @@
+
Function upsertValueIntoTableRowColumn
- upsert
Value Into Table Row Column(message, messages, millis): Effect<SqliteExecResult, never, Sqlite> Parameters
- message: NewMessage
- messages: readonly NewMessage[]
- millis: number & Brand<"Millis">
Returns Effect<SqliteExecResult, never, Sqlite>
Function valuesToSqliteValues
- values
To Sqlite Values(values): SqliteValue[] Parameters
- values: readonly Value[]
Returns SqliteValue[]
diff --git a/functions/_evolu_common_react.use.html b/functions/_evolu_common_react.use.html
new file mode 100644
index 000000000..3798c4520
--- /dev/null
+++ b/functions/_evolu_common_react.use.html
@@ -0,0 +1,4 @@
+
Function use
A React 19 use polyfill.
See https://react.dev/reference/react/use. See +https://github.com/acdlite/rfcs/blob/first-class-promises/text/0000-first-class-support-for-promises.md
+Function useEvolu
React Hook returning an instance of Evolu.
+Please don't use it without the generic parameter.
+Function useEvoluError
Subscribe to EvoluError changes.
+- use
Evolu Error(): null | EvoluError Returns null | EvoluError
Function useQueries
The same as useQuery, but for many queries.
+- use
Queries<R, Q, OQ>(queries, options?): [...QueryResultsFromQueries<Q>[], ...QueryResultsFromQueries<OQ>[]] Type Parameters
Parameters
- queries: [...Q[]]
- options: Partial<{
once: [...OQ[]];
promises: [...QueryResultsPromisesFromQueries<Q>[], ...QueryResultsPromisesFromQueries<OQ>[]];
}> = {}
Returns [...QueryResultsFromQueries<Q>[], ...QueryResultsFromQueries<OQ>[]]
Function useQuery
Load and subscribe to the Query, and return an object with rows and row
+properties that are automatically updated when data changes.
Note that useQuery uses React Suspense. It means every usage of +useQuery blocks rendering until loading is completed. To avoid loading +waterfall with more queries, use useQueries.
+Example
// Get all rows.
const { rows } = useQuery(allTodos);
// Get the first row (it can be null).
const { row } = useQuery(todoById(1));
// Get all rows, but without subscribing to changes.
const { rows } = useQuery(allTodos, { once: true });
// Prefetch rows.
const allTodos = evolu.createQuery((db) =>
db.selectFrom("todo").selectAll(),
);
const allTodosPromise = evolu.loadQuery(allTodos);
// Use prefetched rows.
const { rows } = useQuery(allTodos, { promise: allTodosPromise });
+- use
Query<R>(query, options?): QueryResult<R> Type Parameters
- R extends Row
Parameters
- query: Query<R>
- options: Partial<{
once: boolean;
promise: Promise<QueryResult<R>>;
}> = {}
Returns QueryResult<R>
Function useQuerySubscription
Subscribe to Query QueryResult changes.
+- use
Query Subscription<R>(query, options?): QueryResult<R> Type Parameters
- R extends Row
Returns QueryResult<R>
Function createEvolu
Create Evolu from the database schema.
+Tables with a name prefixed with _ are local-only, which means they are
+never synced. It's useful for device-specific or temporal data.
Example
import * as S from "@effect/schema/Schema";
import * as E from "@evolu/common-web";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database);
+
diff --git a/functions/_evolu_react.cast.html b/functions/_evolu_react.cast.html
new file mode 100644
index 000000000..39da6a430
--- /dev/null
+++ b/functions/_evolu_react.cast.html
@@ -0,0 +1,7 @@
+
Function cast
- cast(value): SqliteBoolean
A helper for casting types not supported by SQLite. SQLite doesn't support +Date nor Boolean types, so Evolu emulates them with SqliteBoolean and +SqliteDate.
+Parameters
- value: boolean
Returns SqliteBoolean
- cast(value): boolean
Parameters
- value: (0 | 1) & Brand<"SqliteBoolean">
Returns boolean
- cast(value): SqliteDate
Parameters
- value: Date
Returns SqliteDate
- cast(value): Date
Parameters
- value: string & Brand<"SqliteDate">
Returns Date
Function createEvolu
Create Evolu from the database schema.
+Tables with a name prefixed with _ are local-only, which means they are
+never synced. It's useful for device-specific or temporal data.
Example
import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database);
+Function createIndexes
Create SQLite indexes.
+ +- create
Indexes(callback): readonly {
name: string;
sql: string;
}[] Parameters
- callback: ((create: ((indexName: string) => CreateIndexBuilder<never>)) => readonly CreateIndexBuilder<any>[])
- (create): readonly CreateIndexBuilder<any>[]
Parameters
- create: ((indexName: string) => CreateIndexBuilder<never>)
- (indexName): CreateIndexBuilder<never>
Parameters
- indexName: string
Returns CreateIndexBuilder<never>
Returns readonly CreateIndexBuilder<any>[]
- create: ((indexName: string) => CreateIndexBuilder<never>)
Returns readonly {
name: string;
sql: string;
}[]- callback: ((create: ((indexName: string) => CreateIndexBuilder<never>)) => readonly CreateIndexBuilder<any>[])
Function createMnemonic
Mnemonic is a password generated by Evolu in BIP39 format.
+A mnemonic, also known as a "seed phrase," is a set of 12 words in a specific +order chosen from a predefined list. The purpose of the BIP39 mnemonic is to +provide a human-readable way of storing a private key.
+Function database
Create database schema.
+Tables with a name prefixed with _ are local-only, which means they are not +synced. Local-only tables are useful for device-specific or temporal data.
+
diff --git a/functions/_evolu_react.id-2.html b/functions/_evolu_react.id-2.html
new file mode 100644
index 000000000..181ef407c
--- /dev/null
+++ b/functions/_evolu_react.id-2.html
@@ -0,0 +1,5 @@
+
diff --git a/functions/_evolu_react.jsonArrayFrom.html b/functions/_evolu_react.jsonArrayFrom.html
new file mode 100644
index 000000000..7919d3721
--- /dev/null
+++ b/functions/_evolu_react.jsonArrayFrom.html
@@ -0,0 +1,26 @@
+
Function jsonArrayFrom
- json
Array From<O>(expr): RawBuilder<Simplify<O>[]> A SQLite helper for aggregating a subquery into a JSON array.
+NOTE: This helper only works correctly if you've installed the
+ParseJSONResultsPlugin. +Otherwise the nested selections will be returned as JSON strings.The plugin can be installed like this:
+
+ +const db = new Kysely({
dialect: new SqliteDialect(config),
plugins: [new ParseJSONResultsPlugin()]
}) +Examples
+ +const result = await db
.selectFrom('person')
.select((eb) => [
'id',
jsonArrayFrom(
eb.selectFrom('pet')
.select(['pet.id as pet_id', 'pet.name'])
.whereRef('pet.owner_id', '=', 'person.id')
.orderBy('pet.name')
).as('pets')
])
.execute()
result[0].id
result[0].pets[0].pet_id
result[0].pets[0].name +The generated SQL (SQLite):
+
+ +select "id", ( + select coalesce(json_group_array(json_object( + 'pet_id', "agg"."pet_id", + 'name', "agg"."name" + )), '[]') from ( + select "pet"."id" as "pet_id", "pet"."name" + from "pet" + where "pet"."owner_id" = "person"."id" + order by "pet"."name" + ) as "agg" +) as "pets" +from "person" +Type Parameters
Parameters
- expr: SelectQueryBuilderExpression<O>
Returns RawBuilder<Simplify<O>[]>
Function jsonObjectFrom
- json
Object From<O>(expr): RawBuilder<Simplify<O> | null> A SQLite helper for turning a subquery into a JSON object.
+The subquery must only return one row.
+NOTE: This helper only works correctly if you've installed the
+ParseJSONResultsPlugin. +Otherwise the nested selections will be returned as JSON strings.The plugin can be installed like this:
+
+ +const db = new Kysely({
dialect: new SqliteDialect(config),
plugins: [new ParseJSONResultsPlugin()]
}) +Examples
+ +const result = await db
.selectFrom('person')
.select((eb) => [
'id',
jsonObjectFrom(
eb.selectFrom('pet')
.select(['pet.id as pet_id', 'pet.name'])
.whereRef('pet.owner_id', '=', 'person.id')
.where('pet.is_favorite', '=', true)
).as('favorite_pet')
])
.execute()
result[0].id
result[0].favorite_pet.pet_id
result[0].favorite_pet.name +The generated SQL (SQLite):
+
+ +select "id", ( + select json_object( + 'pet_id', "obj"."pet_id", + 'name', "obj"."name" + ) from ( + select "pet"."id" as "pet_id", "pet"."name" + from "pet" + where "pet"."owner_id" = "person"."id" + and "pet"."is_favorite" = ? + ) as obj +) as "favorite_pet" +from "person"; +Type Parameters
Parameters
- expr: SelectQueryBuilderExpression<O>
Returns RawBuilder<Simplify<O> | null>
Function makeUnexpectedError
- make
Unexpected Error(error): UnexpectedError Parameters
- error: unknown
Returns UnexpectedError
Function parseMnemonic
Parse a string to Mnemonic.
+- parse
Mnemonic(mnemonic): Effect<Mnemonic, InvalidMnemonicError, never> Parameters
- mnemonic: string
Returns Effect<Mnemonic, InvalidMnemonicError, never>
Function sql
- sql<T>(sqlFragments, ...parameters): RawBuilder<T>
Template tag for creating raw SQL snippets and queries.
+
+ +import { sql } from 'kysely'
const id = 123
const snippet = sql<Person[]>`select * from person where id = ${id}` +Substitutions (the things inside
+${}) are automatically passed to the database +as parameters and are never interpolated to the SQL string. There's no need to worry +about SQL injection vulnerabilities. Substitutions can be values, othersql+expressions, queries and almost anything else Kysely can produce and they get +handled correctly. See the examples below.If you need your substitutions to be interpreted as identifiers, value literals or +lists of things, see the Sql.ref, Sql.table, Sql.id, +Sql.lit, Sql.raw and Sql.join functions.
+You can pass sql snippets returned by the
+sqltag pretty much anywhere. Whenever +something can't be done using the Kysely API, you should be able to drop down to +raw SQL using thesqltag. Here's an example query that uses raw sql in a bunch +of methods:
+ +const persons = await db
.selectFrom('person')
.select(
// If you use `sql` in a select statement, remember to call the `as`
// method to give it an alias.
sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
)
.where(sql<boolean>`birthdate between ${date1} and ${date2}`)
// Here we assume we have list of nicknames for the person
// (a list of strings) and we use the PostgreSQL `@>` operator
// to test if all of them are valid nicknames for the user.
.where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
.orderBy(sql<string>`concat(first_name, ' ', last_name)`)
.execute() +The generated SQL (PostgreSQL):
+
+ +select concat(first_name, ' ', last_name) as "full_name" +from "person" +where birthdate between $1 and $2 +and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10] +order by concat(first_name, ' ', last_name) +SQL snippets can be executed by calling the
+executemethod and passing aKysely+instance as the only argument:
+ +const result = await sql<Person[]>`select * from person`.execute(db) +You can merge other
+sqlexpressions and queries using substitutions:
+ +const petName = db.selectFrom('pet').select('name').limit(1)
const fullName = sql<string>`concat(first_name, ' ', last_name)`
sql`
select ${fullName} as full_name, ${petName} as pet_name
from person
` +Substitutions also handle ExpressionBuilder.ref, +DynamicModule.ref and pretty much anything else you +throw at it. Here's an example of calling a function in a +type-safe way:
+
+ +db.selectFrom('person')
.select([
'first_name',
'last_name',
(eb) => {
// The `eb.ref` method is type-safe and only accepts
// column references that are possible.
const firstName = eb.ref('first_name')
const lastName = eb.ref('last_name')
const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
return fullName.as('full_name')
}
]) +don't know if that amount of ceremony is worth the small increase in +type-safety though... But it's possible.
+Type Parameters
Parameters
- sqlFragments: TemplateStringsArray
Rest...parameters: unknown[]
Returns RawBuilder<T>
Methods
id
- id(...ids): RawBuilder<unknown>
This can be used to add arbitrary identifiers to SQL snippets.
+Does the same thing as ref and table +but can also be used for any other identifiers like index names.
+You should use ref and table +instead of this whenever possible as they produce a more sematic +operation node tree.
+WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const indexName = 'person_first_name_index'
sql`create index ${indexName} on person` +The generated SQL (PostgreSQL):
+
+ +create index "person_first_name_index" on person +Multiple identifiers get separated by dots:
+
+ +const schema = 'public'
const columnName = 'first_name'
const table = 'person'
sql`select ${sql.id(schema, table, columnName)}} from ${sql.id(schema, table)}` +The generated SQL (PostgreSQL):
+
+ +select "public"."person"."first_name" from "public"."person" +Parameters
Rest...ids: readonly string[]
Returns RawBuilder<unknown>
join
- join(array, separator?): RawBuilder<unknown>
This can be used to add lists of things to SQL snippets.
+Examples
+ +function findByNicknames(nicknames: string[]): Promise<Person[]> {
return db
.selectFrom('person')
.selectAll()
.where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
.execute()
} +The generated SQL (PostgreSQL):
+
+ +select * from "person" +where "nicknames" @> ARRAY[$1, $2, $3, $4, $5, $6, $7, $8] +The second argument is the joining SQL expression that defaults +to
+
+ +sql`, ` +In addition to values, items in the list can be also sql +expressions, queries or anything else the normal substitutions +support:
+
+ +const things = [
123,
sql`(1 == 1)`,
db.selectFrom('person').selectAll(),
sql.lit(false),
sql.id('first_name')
]
sql`BEFORE ${sql.join(things, sql`::varchar, `)} AFTER` +The generated SQL (PostgreSQL):
+
+ +BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER +Parameters
- array: readonly unknown[]
Optionalseparator: RawBuilder<any>
Returns RawBuilder<unknown>
lit
- lit<V>(value): RawBuilder<V>
This can be used to add literal values to SQL snippets.
+WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way. +You almost always want to use normal substitutions that get sent to the +db as parameters.
+
+ +const firstName = 'first_name'
sql`select * from person where first_name = ${sql.lit(firstName)}` +The generated SQL (PostgreSQL):
+
+ +select * from person where first_name = 'first_name' +As you can see from the example above, the value was added directly to +the SQL string instead of as a parameter. Only use this function when +something can't be sent as a parameter.
+Type Parameters
Parameters
- value: V
Returns RawBuilder<V>
literal
raw
- raw<R>(anySql): RawBuilder<R>
This can be used to add arbitrary runtime SQL to SQL snippets.
+WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const firstName = "'first_name'"
sql`select * from person where first_name = ${sql.raw(firstName)}` +The generated SQL (PostgreSQL):
+
+ +select * from person where first_name = 'first_name' +Note that the difference to
+sql.litis that this function +doesn't assume the inputs are values. The input to this function +can be any sql and it's simply glued to the parent string as-is.Type Parameters
Parameters
- anySql: string
Returns RawBuilder<R>
ref
- ref<R>(columnReference): RawBuilder<R>
This can be used to add runtime column references to SQL snippets.
+By default
+${}substitutions in sql template strings get +transformed into parameters. You can use this function to tell +Kysely to interpret them as column references instead.WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const columnRef = 'first_name'
sql`select ${sql.ref(columnRef)} from person` +The generated SQL (PostgreSQL):
+
+ +select "first_name" from person +The refefences can also include a table name:
+
+ +const columnRef = 'person.first_name'
sql`select ${sql.ref(columnRef)}} from person` +The generated SQL (PostgreSQL):
+
+ +select "person"."first_name" from person +The refefences can also include a schema on supported databases:
+
+ +const columnRef = 'public.person.first_name'
sql`select ${sql.ref(columnRef)}} from person` +The generated SQL (PostgreSQL):
+
+ +select "public"."person"."first_name" from person +Type Parameters
Parameters
- columnReference: string
Returns RawBuilder<R>
table
- table(tableReference): RawBuilder<unknown>
This can be used to add runtime table references to SQL snippets.
+By default
+${}substitutions in sql template strings get +transformed into parameters. You can use this function to tell +Kysely to interpret them as table references instead.WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const table = 'person'
sql`select first_name from ${sql.table(table)}` +The generated SQL (PostgreSQL):
+
+ +select first_name from "person" +The refefences can also include a schema on supported databases:
+
+ +const table = 'public.person'
sql`select first_name from ${sql.table(table)}` +The generated SQL (PostgreSQL):
+
+ +select first_name from "public"."person" +Parameters
- tableReference: string
Returns RawBuilder<unknown>
val
value
Function table
Create table schema.
+Supported types are null, string, number, Uint8Array, JSON Object, and JSON +Array. Use SqliteDate for dates and SqliteBoolean for booleans.
+Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added +by default.
+- table<Fields>(fields): ValidateFieldsTypes<Fields> extends true
? ValidateFieldsNames<Fields> extends true
? ValidateFieldsHasId<Fields> extends true
? Schema<Simplify<Type<Fields> & {
createdAt: string & Brand<"SqliteDate">;
isDeleted: (0 | 1) & Brand<"SqliteBoolean">;
updatedAt: string & Brand<"SqliteDate">;
}>, Simplify<{
readonly [K in string | number | symbol as Key<Fields, K>]: Encoded<Fields[K]>
} & {
readonly [K in string | number | symbol as Key<Fields, K>]?: Encoded<Fields[K]>
} & {
createdAt: string;
isDeleted: number;
updatedAt: string;
}>, never>
: EvoluTypeError<"table() called without id column.">
: EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
: EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans."> Type Parameters
Parameters
- fields: Fields
Returns ValidateFieldsTypes<Fields> extends true
? ValidateFieldsNames<Fields> extends true
? ValidateFieldsHasId<Fields> extends true
? Schema<Simplify<Type<Fields> & {
createdAt: string & Brand<"SqliteDate">;
isDeleted: (0 | 1) & Brand<"SqliteBoolean">;
updatedAt: string & Brand<"SqliteDate">;
}>, Simplify<{
readonly [K in string | number | symbol as Key<Fields, K>]: Encoded<Fields[K]>
} & {
readonly [K in string | number | symbol as Key<Fields, K>]?: Encoded<Fields[K]>
} & {
createdAt: string;
isDeleted: number;
updatedAt: string;
}>, never>
: EvoluTypeError<"table() called without id column.">
: EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
: EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans.">
Function useEvolu
React Hook returning an instance of Evolu.
+Please don't use it without the generic parameter.
+Function useEvoluError
Subscribe to EvoluError changes.
+- use
Evolu Error(): null | EvoluError Returns null | EvoluError
Function useQueries
The same as useQuery, but for many queries.
+- use
Queries<R, Q, OQ>(queries, options?): [...QueryResultsFromQueries<Q>[], ...QueryResultsFromQueries<OQ>[]] Type Parameters
Parameters
- queries: [...Q[]]
Optionaloptions: Partial<{
once: [...OQ[]];
promises: [...QueryResultsPromisesFromQueries<Q>[], ...QueryResultsPromisesFromQueries<OQ>[]];
}>
Returns [...QueryResultsFromQueries<Q>[], ...QueryResultsFromQueries<OQ>[]]
Function useQuery
Load and subscribe to the Query, and return an object with rows and row
+properties that are automatically updated when data changes.
Note that useQuery uses React Suspense. It means every usage of +useQuery blocks rendering until loading is completed. To avoid loading +waterfall with more queries, use useQueries.
+Example
// Get all rows.
const { rows } = useQuery(allTodos);
// Get the first row (it can be null).
const { row } = useQuery(todoById(1));
// Get all rows, but without subscribing to changes.
const { rows } = useQuery(allTodos, { once: true });
// Prefetch rows.
const allTodos = evolu.createQuery((db) =>
db.selectFrom("todo").selectAll(),
);
const allTodosPromise = evolu.loadQuery(allTodos);
// Use prefetched rows.
const { rows } = useQuery(allTodos, { promise: allTodosPromise });
+- use
Query<R>(query, options?): QueryResult<R> Type Parameters
- R extends Row
Parameters
- query: Query<R>
Optionaloptions: Partial<{
once: boolean;
promise: Promise<QueryResult<R>>;
}>
Returns QueryResult<R>
Function useQuerySubscription
Subscribe to Query QueryResult changes.
+- use
Query Subscription<R>(query, options?): QueryResult<R> Type Parameters
- R extends Row
Returns QueryResult<R>
diff --git a/functions/_evolu_react_native.index_native.cast.html b/functions/_evolu_react_native.index_native.cast.html
new file mode 100644
index 000000000..816077970
--- /dev/null
+++ b/functions/_evolu_react_native.index_native.cast.html
@@ -0,0 +1,7 @@
+
Function cast
- cast(value): SqliteBoolean
A helper for casting types not supported by SQLite. SQLite doesn't support +Date nor Boolean types, so Evolu emulates them with SqliteBoolean and +SqliteDate.
+Parameters
- value: boolean
Returns SqliteBoolean
- cast(value): boolean
Parameters
- value: (0 | 1) & Brand<"SqliteBoolean">
Returns boolean
- cast(value): SqliteDate
Parameters
- value: Date
Returns SqliteDate
- cast(value): Date
Parameters
- value: string & Brand<"SqliteDate">
Returns Date
Function createEvolu
Create Evolu from the database schema.
+Tables with a name prefixed with _ are local-only, which means they are
+never synced. It's useful for device-specific or temporal data.
Example
import * as S from "@effect/schema/Schema";
import * as E from "@evolu/react-native";
const TodoId = E.id("Todo");
type TodoId = typeof TodoId.Type;
const TodoTable = E.table({
id: TodoId,
title: E.NonEmptyString1000,
});
type TodoTable = typeof TodoTable.Type;
const Database = E.database({
todo: TodoTable,
// Prefix `_` makes the table local-only (it will not sync)
_todo: TodoTable,
});
type Database = typeof Database.Type;
const evolu = E.createEvolu(Database);
+Function createIndexes
Create SQLite indexes.
+ +- create
Indexes(callback): readonly {
name: string;
sql: string;
}[] Parameters
- callback: ((create: ((indexName: string) => CreateIndexBuilder<never>)) => readonly CreateIndexBuilder<any>[])
- (create): readonly CreateIndexBuilder<any>[]
Parameters
- create: ((indexName: string) => CreateIndexBuilder<never>)
- (indexName): CreateIndexBuilder<never>
Parameters
- indexName: string
Returns CreateIndexBuilder<never>
Returns readonly CreateIndexBuilder<any>[]
- create: ((indexName: string) => CreateIndexBuilder<never>)
Returns readonly {
name: string;
sql: string;
}[]- callback: ((create: ((indexName: string) => CreateIndexBuilder<never>)) => readonly CreateIndexBuilder<any>[])
Function createMnemonic
Mnemonic is a password generated by Evolu in BIP39 format.
+A mnemonic, also known as a "seed phrase," is a set of 12 words in a specific +order chosen from a predefined list. The purpose of the BIP39 mnemonic is to +provide a human-readable way of storing a private key.
+Function database
Create database schema.
+Tables with a name prefixed with _ are local-only, which means they are not +synced. Local-only tables are useful for device-specific or temporal data.
+
diff --git a/functions/_evolu_react_native.index_native.id-2.html b/functions/_evolu_react_native.index_native.id-2.html
new file mode 100644
index 000000000..f09d8425a
--- /dev/null
+++ b/functions/_evolu_react_native.index_native.id-2.html
@@ -0,0 +1,5 @@
+
diff --git a/functions/_evolu_react_native.index_native.jsonArrayFrom.html b/functions/_evolu_react_native.index_native.jsonArrayFrom.html
new file mode 100644
index 000000000..935981c81
--- /dev/null
+++ b/functions/_evolu_react_native.index_native.jsonArrayFrom.html
@@ -0,0 +1,26 @@
+
Function jsonArrayFrom
- json
Array From<O>(expr): RawBuilder<Simplify<O>[]> A SQLite helper for aggregating a subquery into a JSON array.
+NOTE: This helper only works correctly if you've installed the
+ParseJSONResultsPlugin. +Otherwise the nested selections will be returned as JSON strings.The plugin can be installed like this:
+
+ +const db = new Kysely({
dialect: new SqliteDialect(config),
plugins: [new ParseJSONResultsPlugin()]
}) +Examples
+ +const result = await db
.selectFrom('person')
.select((eb) => [
'id',
jsonArrayFrom(
eb.selectFrom('pet')
.select(['pet.id as pet_id', 'pet.name'])
.whereRef('pet.owner_id', '=', 'person.id')
.orderBy('pet.name')
).as('pets')
])
.execute()
result[0].id
result[0].pets[0].pet_id
result[0].pets[0].name +The generated SQL (SQLite):
+
+ +select "id", ( + select coalesce(json_group_array(json_object( + 'pet_id', "agg"."pet_id", + 'name', "agg"."name" + )), '[]') from ( + select "pet"."id" as "pet_id", "pet"."name" + from "pet" + where "pet"."owner_id" = "person"."id" + order by "pet"."name" + ) as "agg" +) as "pets" +from "person" +Type Parameters
Parameters
- expr: SelectQueryBuilderExpression<O>
Returns RawBuilder<Simplify<O>[]>
Function jsonObjectFrom
- json
Object From<O>(expr): RawBuilder<Simplify<O> | null> A SQLite helper for turning a subquery into a JSON object.
+The subquery must only return one row.
+NOTE: This helper only works correctly if you've installed the
+ParseJSONResultsPlugin. +Otherwise the nested selections will be returned as JSON strings.The plugin can be installed like this:
+
+ +const db = new Kysely({
dialect: new SqliteDialect(config),
plugins: [new ParseJSONResultsPlugin()]
}) +Examples
+ +const result = await db
.selectFrom('person')
.select((eb) => [
'id',
jsonObjectFrom(
eb.selectFrom('pet')
.select(['pet.id as pet_id', 'pet.name'])
.whereRef('pet.owner_id', '=', 'person.id')
.where('pet.is_favorite', '=', true)
).as('favorite_pet')
])
.execute()
result[0].id
result[0].favorite_pet.pet_id
result[0].favorite_pet.name +The generated SQL (SQLite):
+
+ +select "id", ( + select json_object( + 'pet_id', "obj"."pet_id", + 'name', "obj"."name" + ) from ( + select "pet"."id" as "pet_id", "pet"."name" + from "pet" + where "pet"."owner_id" = "person"."id" + and "pet"."is_favorite" = ? + ) as obj +) as "favorite_pet" +from "person"; +Type Parameters
Parameters
- expr: SelectQueryBuilderExpression<O>
Returns RawBuilder<Simplify<O> | null>
Function makeUnexpectedError
- make
Unexpected Error(error): UnexpectedError Parameters
- error: unknown
Returns UnexpectedError
Function parseMnemonic
Parse a string to Mnemonic.
+- parse
Mnemonic(mnemonic): Effect<Mnemonic, InvalidMnemonicError, never> Parameters
- mnemonic: string
Returns Effect<Mnemonic, InvalidMnemonicError, never>
Function sql
- sql<T>(sqlFragments, ...parameters): RawBuilder<T>
Template tag for creating raw SQL snippets and queries.
+
+ +import { sql } from 'kysely'
const id = 123
const snippet = sql<Person[]>`select * from person where id = ${id}` +Substitutions (the things inside
+${}) are automatically passed to the database +as parameters and are never interpolated to the SQL string. There's no need to worry +about SQL injection vulnerabilities. Substitutions can be values, othersql+expressions, queries and almost anything else Kysely can produce and they get +handled correctly. See the examples below.If you need your substitutions to be interpreted as identifiers, value literals or +lists of things, see the Sql.ref, Sql.table, Sql.id, +Sql.lit, Sql.raw and Sql.join functions.
+You can pass sql snippets returned by the
+sqltag pretty much anywhere. Whenever +something can't be done using the Kysely API, you should be able to drop down to +raw SQL using thesqltag. Here's an example query that uses raw sql in a bunch +of methods:
+ +const persons = await db
.selectFrom('person')
.select(
// If you use `sql` in a select statement, remember to call the `as`
// method to give it an alias.
sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
)
.where(sql<boolean>`birthdate between ${date1} and ${date2}`)
// Here we assume we have list of nicknames for the person
// (a list of strings) and we use the PostgreSQL `@>` operator
// to test if all of them are valid nicknames for the user.
.where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
.orderBy(sql<string>`concat(first_name, ' ', last_name)`)
.execute() +The generated SQL (PostgreSQL):
+
+ +select concat(first_name, ' ', last_name) as "full_name" +from "person" +where birthdate between $1 and $2 +and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10] +order by concat(first_name, ' ', last_name) +SQL snippets can be executed by calling the
+executemethod and passing aKysely+instance as the only argument:
+ +const result = await sql<Person[]>`select * from person`.execute(db) +You can merge other
+sqlexpressions and queries using substitutions:
+ +const petName = db.selectFrom('pet').select('name').limit(1)
const fullName = sql<string>`concat(first_name, ' ', last_name)`
sql`
select ${fullName} as full_name, ${petName} as pet_name
from person
` +Substitutions also handle ExpressionBuilder.ref, +DynamicModule.ref and pretty much anything else you +throw at it. Here's an example of calling a function in a +type-safe way:
+
+ +db.selectFrom('person')
.select([
'first_name',
'last_name',
(eb) => {
// The `eb.ref` method is type-safe and only accepts
// column references that are possible.
const firstName = eb.ref('first_name')
const lastName = eb.ref('last_name')
const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
return fullName.as('full_name')
}
]) +don't know if that amount of ceremony is worth the small increase in +type-safety though... But it's possible.
+Type Parameters
Parameters
- sqlFragments: TemplateStringsArray
Rest...parameters: unknown[]
Returns RawBuilder<T>
Methods
id
- id(...ids): RawBuilder<unknown>
This can be used to add arbitrary identifiers to SQL snippets.
+Does the same thing as ref and table +but can also be used for any other identifiers like index names.
+You should use ref and table +instead of this whenever possible as they produce a more sematic +operation node tree.
+WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const indexName = 'person_first_name_index'
sql`create index ${indexName} on person` +The generated SQL (PostgreSQL):
+
+ +create index "person_first_name_index" on person +Multiple identifiers get separated by dots:
+
+ +const schema = 'public'
const columnName = 'first_name'
const table = 'person'
sql`select ${sql.id(schema, table, columnName)}} from ${sql.id(schema, table)}` +The generated SQL (PostgreSQL):
+
+ +select "public"."person"."first_name" from "public"."person" +Parameters
Rest...ids: readonly string[]
Returns RawBuilder<unknown>
join
- join(array, separator?): RawBuilder<unknown>
This can be used to add lists of things to SQL snippets.
+Examples
+ +function findByNicknames(nicknames: string[]): Promise<Person[]> {
return db
.selectFrom('person')
.selectAll()
.where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
.execute()
} +The generated SQL (PostgreSQL):
+
+ +select * from "person" +where "nicknames" @> ARRAY[$1, $2, $3, $4, $5, $6, $7, $8] +The second argument is the joining SQL expression that defaults +to
+
+ +sql`, ` +In addition to values, items in the list can be also sql +expressions, queries or anything else the normal substitutions +support:
+
+ +const things = [
123,
sql`(1 == 1)`,
db.selectFrom('person').selectAll(),
sql.lit(false),
sql.id('first_name')
]
sql`BEFORE ${sql.join(things, sql`::varchar, `)} AFTER` +The generated SQL (PostgreSQL):
+
+ +BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER +Parameters
- array: readonly unknown[]
Optionalseparator: RawBuilder<any>
Returns RawBuilder<unknown>
lit
- lit<V>(value): RawBuilder<V>
This can be used to add literal values to SQL snippets.
+WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way. +You almost always want to use normal substitutions that get sent to the +db as parameters.
+
+ +const firstName = 'first_name'
sql`select * from person where first_name = ${sql.lit(firstName)}` +The generated SQL (PostgreSQL):
+
+ +select * from person where first_name = 'first_name' +As you can see from the example above, the value was added directly to +the SQL string instead of as a parameter. Only use this function when +something can't be sent as a parameter.
+Type Parameters
Parameters
- value: V
Returns RawBuilder<V>
literal
raw
- raw<R>(anySql): RawBuilder<R>
This can be used to add arbitrary runtime SQL to SQL snippets.
+WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const firstName = "'first_name'"
sql`select * from person where first_name = ${sql.raw(firstName)}` +The generated SQL (PostgreSQL):
+
+ +select * from person where first_name = 'first_name' +Note that the difference to
+sql.litis that this function +doesn't assume the inputs are values. The input to this function +can be any sql and it's simply glued to the parent string as-is.Type Parameters
Parameters
- anySql: string
Returns RawBuilder<R>
ref
- ref<R>(columnReference): RawBuilder<R>
This can be used to add runtime column references to SQL snippets.
+By default
+${}substitutions in sql template strings get +transformed into parameters. You can use this function to tell +Kysely to interpret them as column references instead.WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const columnRef = 'first_name'
sql`select ${sql.ref(columnRef)} from person` +The generated SQL (PostgreSQL):
+
+ +select "first_name" from person +The refefences can also include a table name:
+
+ +const columnRef = 'person.first_name'
sql`select ${sql.ref(columnRef)}} from person` +The generated SQL (PostgreSQL):
+
+ +select "person"."first_name" from person +The refefences can also include a schema on supported databases:
+
+ +const columnRef = 'public.person.first_name'
sql`select ${sql.ref(columnRef)}} from person` +The generated SQL (PostgreSQL):
+
+ +select "public"."person"."first_name" from person +Type Parameters
Parameters
- columnReference: string
Returns RawBuilder<R>
table
- table(tableReference): RawBuilder<unknown>
This can be used to add runtime table references to SQL snippets.
+By default
+${}substitutions in sql template strings get +transformed into parameters. You can use this function to tell +Kysely to interpret them as table references instead.WARNING! Using this with unchecked inputs WILL lead to SQL injection +vulnerabilities. The input is not checked or escaped by Kysely in any way.
+
+ +const table = 'person'
sql`select first_name from ${sql.table(table)}` +The generated SQL (PostgreSQL):
+
+ +select first_name from "person" +The refefences can also include a schema on supported databases:
+
+ +const table = 'public.person'
sql`select first_name from ${sql.table(table)}` +The generated SQL (PostgreSQL):
+
+ +select first_name from "public"."person" +Parameters
- tableReference: string
Returns RawBuilder<unknown>
val
value
Function table
Create table schema.
+Supported types are null, string, number, Uint8Array, JSON Object, and JSON +Array. Use SqliteDate for dates and SqliteBoolean for booleans.
+Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added +by default.
+- table<Fields>(fields): ValidateFieldsTypes<Fields> extends true
? ValidateFieldsNames<Fields> extends true
? ValidateFieldsHasId<Fields> extends true
? Schema<Simplify<Type<Fields> & {
createdAt: string & Brand<"SqliteDate">;
isDeleted: (0 | 1) & Brand<"SqliteBoolean">;
updatedAt: string & Brand<"SqliteDate">;
}>, Simplify<{
readonly [K in string | number | symbol as Key<Fields, K>]: Encoded<Fields[K]>
} & {
readonly [K in string | number | symbol as Key<Fields, K>]?: Encoded<Fields[K]>
} & {
createdAt: string;
isDeleted: number;
updatedAt: string;
}>, never>
: EvoluTypeError<"table() called without id column.">
: EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
: EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans."> Type Parameters
Parameters
- fields: Fields
Returns ValidateFieldsTypes<Fields> extends true
? ValidateFieldsNames<Fields> extends true
? ValidateFieldsHasId<Fields> extends true
? Schema<Simplify<Type<Fields> & {
createdAt: string & Brand<"SqliteDate">;
isDeleted: (0 | 1) & Brand<"SqliteBoolean">;
updatedAt: string & Brand<"SqliteDate">;
}>, Simplify<{
readonly [K in string | number | symbol as Key<Fields, K>]: Encoded<Fields[K]>
} & {
readonly [K in string | number | symbol as Key<Fields, K>]?: Encoded<Fields[K]>
} & {
createdAt: string;
isDeleted: number;
updatedAt: string;
}>, never>
: EvoluTypeError<"table() called without id column.">
: EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
: EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans.">
Function useEvolu
React Hook returning an instance of Evolu.
+Please don't use it without the generic parameter.
+Function useEvoluError
Subscribe to EvoluError changes.
+- use
Evolu Error(): null | EvoluError Returns null | EvoluError
Function useQueries
The same as useQuery, but for many queries.
+- use
Queries<R, Q, OQ>(queries, options?): [...QueryResultsFromQueries<Q>[], ...QueryResultsFromQueries<OQ>[]] Type Parameters
Parameters
- queries: [...Q[]]
Optionaloptions: Partial<{
once: [...OQ[]];
promises: [...QueryResultsPromisesFromQueries<Q>[], ...QueryResultsPromisesFromQueries<OQ>[]];
}>
Returns [...QueryResultsFromQueries<Q>[], ...QueryResultsFromQueries<OQ>[]]
Function useQuery
Load and subscribe to the Query, and return an object with rows and row
+properties that are automatically updated when data changes.
Note that useQuery uses React Suspense. It means every usage of +useQuery blocks rendering until loading is completed. To avoid loading +waterfall with more queries, use useQueries.
+Example
// Get all rows.
const { rows } = useQuery(allTodos);
// Get the first row (it can be null).
const { row } = useQuery(todoById(1));
// Get all rows, but without subscribing to changes.
const { rows } = useQuery(allTodos, { once: true });
// Prefetch rows.
const allTodos = evolu.createQuery((db) =>
db.selectFrom("todo").selectAll(),
);
const allTodosPromise = evolu.loadQuery(allTodos);
// Use prefetched rows.
const { rows } = useQuery(allTodos, { promise: allTodosPromise });
+- use
Query<R>(query, options?): QueryResult<R> Type Parameters
- R extends Row
Parameters
- query: Query<R>
Optionaloptions: Partial<{
once: boolean;
promise: Promise<QueryResult<R>>;
}>
Returns QueryResult<R>
Function useQuerySubscription
Subscribe to Query QueryResult changes.
+- use
Query Subscription<R>(query, options?): QueryResult<R> Type Parameters
- R extends Row
Returns QueryResult<R>
diff --git a/functions/_evolu_server.createExpressAppWithWebsocket.html b/functions/_evolu_server.createExpressAppWithWebsocket.html
new file mode 100644
index 000000000..3f57d7da0
--- /dev/null
+++ b/functions/_evolu_server.createExpressAppWithWebsocket.html
@@ -0,0 +1 @@
+
Function createExpressAppWithWebsocket
- create
Express App With Websocket(port?): Promise<undefined | {
app: Application;
server: Server;
wss: Server<typeof WebSocket, typeof IncomingMessage>;
}> Parameters
Optionalport: number
Returns Promise<undefined | {
app: Application;
server: Server;
wss: Server<typeof WebSocket, typeof IncomingMessage>;
}>
diff --git a/index.html b/index.html
new file mode 100644
index 000000000..ddae23ec5
--- /dev/null
+++ b/index.html
@@ -0,0 +1,49 @@
+
Evolu
Evolu
Local-first platform designed for privacy, ease of use, and no vendor lock-in
+-
+
- SQLite in all browsers, Electron, and React Native +
- CRDT for merging changes without conflicts +
- End-to-end encrypted sync and backup +
- Free Evolu sync and backup server, or you can run your own +
- Typed database schema (with branded types like
NonEmptyString1000,PositiveInt, etc.)
+ - Typed SQL via Kysely +
- Reactive queries with full React Suspense support +
- Real-time experience via revalidation on focus and network recovery +
- No signup/login, only bitcoin-like mnemonic (12 words) +
- Ad-hoc migration +
- Sqlite JSON support with automatic stringifying and parsing +
- Support for Kysely Relations (loading nested objects and arrays in a single SQL query) +
- Local-only tables (tables with _ prefix are not synced) +
- Evolu Solid/Vue/Svelte soon +
Local-first apps
Local-first apps allow users to own their data by storing them on their devices. Modern browsers provide API designed precisely for that. How is it different from keeping files on disk? Files are not the right abstraction for apps and cannot synchronize among devices. That's why traditional apps use the client-server architecture. But using client-server architecture also means that users' ability to use an app depends on some server that can be offline, temporarily or forever, if a company decides to ban a user or even goes bankrupt. That's unfortunate. Luckily, a way to restore data ownership exists. It's Evolu.
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+API Reference
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Contributing
Evolu monorepo uses pnpm.
+Install the dependencies with:
+pnpm install
+Build Evolu monorepo:
+pnpm build
+Start developing and watch for code changes:
+pnpm dev
+Start iOS developing (pnpm dev must be running too):
+pnpm ios
+Lint and tests:
+pnpm lint test
+Describe changes for release log:
+pnpm changeset
+Interface Callbacks
interface Callbacks {
onError: ((error: EvoluError) => void);
onReceive: (() => void);
onSyncStateChange: ((state: SyncState) => void);
}
onError: ((error: EvoluError) => void);
onReceive: (() => void);
onSyncStateChange: ((state: SyncState) => void);
}
Index
Properties
Interface Config
interface Config {
enableWebsocketConnection?: true;
externalWebsocketConnection?: WebSocket;
maxDrift: number;
minimumLogLevel:
| "none"
| "trace"
| "debug"
| "warning";
name: string;
reloadUrl: string;
syncUrl: string;
}
enableWebsocketConnection?: true;
externalWebsocketConnection?: WebSocket;
maxDrift: number;
minimumLogLevel:
| "none"
| "trace"
| "debug"
| "warning";
name: string;
reloadUrl: string;
syncUrl: string;
}
Hierarchy (view full)
- Config
Index
Properties
Optionalenable
enable
Enables websocket connection
+If set to true runs a websocket connection on the sync url
+Optionalexternal
external
Allows to reuse websocket connections for multiple database setup
+Works INSTEAD of enableWebsocket and if set overrides enableWebsocket this +attaches the database to a connection produced by a call back from another +database that has enableWebsocketConnection
+max
max
Maximum physical clock drift allowed in ms.
+The default value is 5 * 60 * 1000 (5 minutes).
+minimum
minimum
| "none"
| "trace"
| "debug"
| "warning"
| "none"
| "trace"
| "debug"
| "warning"
Setting the minimum log level. The default value is none.
For development, use trace to log all events and debug to log only
+events with values. For production, use warning.
name
name: string
Evolu is multitenant - it can run more instances concurrently. Every Evolu +instance has to have its own unique name. Database files are separated and +invisible to each other.
+The default value is: Evolu.
reload
reload
URL to reload browser tabs after Owner reset or restore.
+The default value is /.
sync
sync
URL for Evolu sync and backup server.
+The default value is https://evolu.world.
Interface Db
interface Db {
ensureSchema: ((schema: DbSchema) => Effect<void, never, never>);
exportDatabase: (() => Effect<Uint8Array, never, never>);
init: ((schema: DbSchema, initialData: readonly Mutation[], onError: ((error: EvoluError) => void), onSyncStateChange: ((state: SyncState) => void), onReceive: (() => void), mnemonic: undefined | Mnemonic) => Effect<Owner,
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| NotSupportedPlatformError, Config>);
loadQueries: ((queries: readonly Query<Row>[]) => Effect<readonly QueryPatches[], never, never>);
mutate: ((mutations: readonly Mutation[], queriesToRefresh: readonly Query<Row>[]) => Effect<readonly QueryPatches[], TimestampTimeOutOfRangeError | TimestampDriftError | TimestampCounterOverflowError, Config>);
resetOwner: (() => Effect<void, never, never>);
restoreOwner: ((schema: DbSchema, mnemonic: Mnemonic) => Effect<void, never, never>);
sync: ((queriesToRefresh: readonly Query<Row>[]) => Effect<readonly QueryPatches[], never, Config>);
}
ensureSchema: ((schema: DbSchema) => Effect<void, never, never>);
exportDatabase: (() => Effect<Uint8Array, never, never>);
init: ((schema: DbSchema, initialData: readonly Mutation[], onError: ((error: EvoluError) => void), onSyncStateChange: ((state: SyncState) => void), onReceive: (() => void), mnemonic: undefined | Mnemonic) => Effect<Owner,
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| NotSupportedPlatformError, Config>);
loadQueries: ((queries: readonly Query<Row>[]) => Effect<readonly QueryPatches[], never, never>);
mutate: ((mutations: readonly Mutation[], queriesToRefresh: readonly Query<Row>[]) => Effect<readonly QueryPatches[], TimestampTimeOutOfRangeError | TimestampDriftError | TimestampCounterOverflowError, Config>);
resetOwner: (() => Effect<void, never, never>);
restoreOwner: ((schema: DbSchema, mnemonic: Mnemonic) => Effect<void, never, never>);
sync: ((queriesToRefresh: readonly Query<Row>[]) => Effect<readonly QueryPatches[], never, Config>);
}
Index
Properties
Properties
Readonlyensure
Readonlyexport
export
Readonlyinit
init: ((schema: DbSchema, initialData: readonly Mutation[], onError: ((error: EvoluError) => void), onSyncStateChange: ((state: SyncState) => void), onReceive: (() => void), mnemonic: undefined | Mnemonic) => Effect<Owner,
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| NotSupportedPlatformError, Config>)
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| NotSupportedPlatformError, Config>)
Readonlyload
Readonlymutate
mutate: ((mutations: readonly Mutation[], queriesToRefresh: readonly Query<Row>[]) => Effect<readonly QueryPatches[], TimestampTimeOutOfRangeError | TimestampDriftError | TimestampCounterOverflowError, Config>)
Readonlyreset
reset
Readonlyrestore
Readonlysync
diff --git a/interfaces/_evolu_common.EncryptedMessage.html b/interfaces/_evolu_common.EncryptedMessage.html
new file mode 100644
index 000000000..8a3ab5af3
--- /dev/null
+++ b/interfaces/_evolu_common.EncryptedMessage.html
@@ -0,0 +1,6 @@
+
Interface Evolu<T>
The Evolu interface provides a type-safe SQL query building and state +management defined by a database schema. It leverages Kysely for creating SQL +queries in TypeScript, enabling operations such as data querying, loading, +subscription to data changes, and mutations (create, update, createOrUpdate). +It also includes functionalities for error handling, syncing state +management, and owner data manipulation. Specifically, Evolu allows:
+-
+
- Subscribing to and getting errors via subscribeError and getError. +
- Creating type-safe SQL queries with createQuery, leveraging Kysely's +capabilities. +
- Loading queries and subscribing to query result changes using loadQuery, +loadQueries, subscribeQuery, and getQuery. +
- Subscribing to and getting the owner's information and sync state changes. +
- Performing mutations on the database with create, update, and createOrUpdate +methods, which include automatic management of common columns like +createdAt, updatedAt, and isDeleted. +
- Managing owner data with resetOwner and restoreOwner. +
- Ensuring the database schema's integrity with ensureSchema. +
interface Evolu<T> {
create: Mutate<T, "create">;
createOrUpdate: Mutate<T, "createOrUpdate">;
createQuery: (<R>(queryCallback: ((db: Pick<Kysely<{
[Table in string | number | symbol]: NullableExceptIdCreatedAtUpdatedAt<{
[Column in string | number | symbol]: T[Table][Column]
}>
} & {
evolu_message: {
column: string;
row: string & Brand<"Id">;
table: keyof T;
timestamp: TimestampString;
value: Value;
};
}>,
| "with"
| "selectFrom"
| "fn"
| "withRecursive">) => SelectQueryBuilder<any, any, R>), options?: SqliteQueryOptions) => Query<R>);
ensureSchema: ((schema: DbSchema) => void);
exportDatabase: (() => Promise<Uint8Array>);
getError: (() => null | EvoluError);
getOwner: (() => null | Owner);
getQuery: (<R>(query: Query<R>) => QueryResult<R>);
getSyncState: (() => SyncState);
loadQueries: (<R, Q>(queries: [...Q[]]) => [...QueryResultsPromisesFromQueries<Q>[]]);
loadQuery: (<R>(query: Query<R>) => Promise<QueryResult<R>>);
reloadApp: (() => void);
resetOwner: ((options?: {
reload: boolean;
}) => Promise<void>);
restoreOwner: ((mnemonic: Mnemonic, options?: {
reload: boolean;
}) => Promise<void>);
socket: Promise<undefined | WebSocket>;
subscribeError: ((listener: Listener) => Unsubscribe);
subscribeOwner: ((listener: Listener) => Unsubscribe);
subscribeQuery: ((query: Query) => ((listener: Listener) => Unsubscribe));
subscribeSyncState: ((listener: Listener) => Unsubscribe);
update: Mutate<T, "update">;
}
create: Mutate<T, "create">;
createOrUpdate: Mutate<T, "createOrUpdate">;
createQuery: (<R>(queryCallback: ((db: Pick<Kysely<{
[Table in string | number | symbol]: NullableExceptIdCreatedAtUpdatedAt<{
[Column in string | number | symbol]: T[Table][Column]
}>
} & {
evolu_message: {
column: string;
row: string & Brand<"Id">;
table: keyof T;
timestamp: TimestampString;
value: Value;
};
}>,
| "with"
| "selectFrom"
| "fn"
| "withRecursive">) => SelectQueryBuilder<any, any, R>), options?: SqliteQueryOptions) => Query<R>);
ensureSchema: ((schema: DbSchema) => void);
exportDatabase: (() => Promise<Uint8Array>);
getError: (() => null | EvoluError);
getOwner: (() => null | Owner);
getQuery: (<R>(query: Query<R>) => QueryResult<R>);
getSyncState: (() => SyncState);
loadQueries: (<R, Q>(queries: [...Q[]]) => [...QueryResultsPromisesFromQueries<Q>[]]);
loadQuery: (<R>(query: Query<R>) => Promise<QueryResult<R>>);
reloadApp: (() => void);
resetOwner: ((options?: {
reload: boolean;
}) => Promise<void>);
restoreOwner: ((mnemonic: Mnemonic, options?: {
reload: boolean;
}) => Promise<void>);
socket: Promise<undefined | WebSocket>;
subscribeError: ((listener: Listener) => Unsubscribe);
subscribeOwner: ((listener: Listener) => Unsubscribe);
subscribeQuery: ((query: Query) => ((listener: Listener) => Unsubscribe));
subscribeSyncState: ((listener: Listener) => Unsubscribe);
update: Mutate<T, "update">;
}
Type Parameters
- T extends EvoluSchema = EvoluSchema
Index
Properties
create
Create a row in the database and returns a new ID. The first argument is +the table name, and the second is an object.
+The third optional argument, the onComplete callback, is generally +unnecessary because creating a row cannot fail. Still, UI libraries can use +it to ensure the DOM is updated if we want to manipulate it, for example, +to focus an element.
+Evolu does not use SQL for mutations to ensure data can be safely and +predictably merged without conflicts.
+Explicit mutations also allow Evolu to automatically add and update a few
+useful columns common to all tables. Those columns are: createdAt,
+updatedAt, and isDeleted.
create
Create or update a row in the database and return the existing ID. The +first argument is the table name, and the second is an object.
+This function is useful when we already have an id and want to create a
+new row or update an existing one.
The third optional argument, the onComplete callback, is generally +unnecessary because updating a row cannot fail. Still, UI libraries can use +it to ensure the DOM is updated if we want to manipulate it, for example, +to focus an element.
+Evolu does not use SQL for mutations to ensure data can be safely and +predictably merged without conflicts.
+Explicit mutations also allow Evolu to automatically add and update a few
+useful columns common to all tables. Those columns are: createdAt,
+updatedAt, and isDeleted.
Readonlycreate
create
[Table in string | number | symbol]: NullableExceptIdCreatedAtUpdatedAt<{
[Column in string | number | symbol]: T[Table][Column]
}>
} & {
evolu_message: {
column: string;
row: string & Brand<"Id">;
table: keyof T;
timestamp: TimestampString;
value: Value;
};
}>,
| "with"
| "selectFrom"
| "fn"
| "withRecursive">) => SelectQueryBuilder<any, any, R>), options?: SqliteQueryOptions) => Query<R>)
[Table in string | number | symbol]: NullableExceptIdCreatedAtUpdatedAt<{
[Column in string | number | symbol]: T[Table][Column]
}>
} & {
evolu_message: {
column: string;
row: string & Brand<"Id">;
table: keyof T;
timestamp: TimestampString;
value: Value;
};
}>,
| "with"
| "selectFrom"
| "fn"
| "withRecursive">) => SelectQueryBuilder<any, any, R>), options?: SqliteQueryOptions) => Query<R>)
Create type-safe SQL Query.
+Evolu uses Kysely - the type-safe SQL query builder for TypeScript. See +https://kysely.dev.
+ +Readonlyensure
Ensure tables and columns defined in EvoluSchema exist in the +database.
+This function is for hot/live reloading.
+Readonlyexport
export
Export SQLite database as Uint8Array.
+Readonlyget
Get EvoluError.
+Readonlyget
Get Owner.
+Readonlyget
Get Query QueryResult.
+Readonlyget
Get SyncState.
+Readonlyload
Load an array of Query queries and return an array of
+QueryResult promises. It's like queries.map(loadQuery) but with
+proper types for returned promises.
Readonlyload
Load Query and return a promise with QueryResult.
+A returned promise always resolves successfully because there is no reason +why loading should fail. All data are local, and the query is typed. A +serious unexpected Evolu error shall be handled with +subscribeError.
+Loading is batched, and returned promises are cached, so there is no need +for an additional cache. Evolu's internal cache is invalidated on +mutation.
+The returned promise is enriched with special status and value properties
+for the upcoming React use Hook, but other UI libraries can also leverage
+them. Speaking of React, there are two essential React Suspense-related
+patterns that every developer should be aware of—passing promises to
+children and caching over mutations.
With promises passed to children, we can load a query as soon as possible, +but we don't have to use the returned promise immediately. That's useful +for prefetching, which is generally not necessary for local-first apps but +can be if a query takes a long time to load.
+Caching over mutation is a pattern that every developer should know. As we +said, Evolu caches promise until a mutation happens. A query loaded after +that will return a new pending promise. That's okay for general usage but +not for UI with React Suspense because a mutation would suspend rerendered +queries on a page, and that's not a good UX.
+We call this pattern "caching over mutation" because it has no globally +accepted name yet. React RFC for React Cache does not exist yet.
+For better UX, a query must be subscribed for updates. This way, instead of +Suspense flashes, the user sees new data immediately because Evolu replaces +cached promises with fresh, already resolved new ones.
+If you are curious why Evolu does not do that for all queries by default, +the answer is simple: performance. Tracking changes is costly and +meaningful only for visible (hence subscribed) queries anyway. To subscribe +to a query, use subscribeQuery.
+Readonlyreload
reload
Reload the app in a platform-specific way. For browsers, this will reload +all tabs using Evolu. For native apps, it will restart the app.
+Readonlyreset
reset
reload: boolean;
}) => Promise<void>)
reload: boolean;
}) => Promise<void>)
Delete Owner and all their data from the current device. After the +deletion, Evolu will purge the application state. For browsers, this will +reload all tabs using Evolu. For native apps, it will restart the app.
+Reloading can be turned off via options if you want to provide a different +UX.
+Readonlyrestore
Restore Owner with all their synced data. It uses resetOwner, +so be careful.
+Readonlysocket
socket: Promise<undefined | WebSocket>
Readonlysubscribe
Subscribe to EvoluError changes.
+Readonlysubscribe
Subscribe to Owner changes.
+Readonlysubscribe
Subscribe to Query QueryResult changes.
+Readonlysubscribe
Subscribe to SyncState changes.
+update
Update a row in the database and return the existing ID. The first argument +is the table name, and the second is an object.
+The third optional argument, the onComplete callback, is generally +unnecessary because updating a row cannot fail. Still, UI libraries can use +it to ensure the DOM is updated if we want to manipulate it, for example, +to focus an element.
+Evolu does not use SQL for mutations to ensure data can be safely and +predictably merged without conflicts.
+Explicit mutations also allow Evolu to automatically add and update a few
+useful columns common to all tables. Those columns are: createdAt,
+updatedAt, and isDeleted.
Example
import * as S from "@effect/schema/Schema";
// Evolu uses the Schema to enforce domain model.
const title = S.decodeSync(Evolu.NonEmptyString1000)("A title");
evolu.update("todo", { id, title });
// To delete a row, set `isDeleted` to true.
evolu.update("todo", { id, isDeleted: true });
+Interface EvoluConfig<T>
interface EvoluConfig<T> {
enableWebsocketConnection?: true;
externalWebsocketConnection?: WebSocket;
indexes: readonly {
name: string;
sql: string;
}[];
initialData: ((evolu: EvoluForInitialData<T>) => void);
maxDrift: number;
minimumLogLevel:
| "none"
| "trace"
| "debug"
| "warning";
mnemonic: Mnemonic;
name: string;
reloadUrl: string;
syncUrl: string;
}
enableWebsocketConnection?: true;
externalWebsocketConnection?: WebSocket;
indexes: readonly {
name: string;
sql: string;
}[];
initialData: ((evolu: EvoluForInitialData<T>) => void);
maxDrift: number;
minimumLogLevel:
| "none"
| "trace"
| "debug"
| "warning";
mnemonic: Mnemonic;
name: string;
reloadUrl: string;
syncUrl: string;
}
Type Parameters
- T extends EvoluSchema = EvoluSchema
Hierarchy (view full)
- Config
- EvoluConfig
Index
Properties
Optionalenable
enable
Enables websocket connection
+If set to true runs a websocket connection on the sync url
+Optionalexternal
external
Allows to reuse websocket connections for multiple database setup
+Works INSTEAD of enableWebsocket and if set overrides enableWebsocket this +attaches the database to a connection produced by a call back from another +database that has enableWebsocketConnection
+indexes
indexes: readonly {
name: string;
sql: string;
}[]
name: string;
sql: string;
}[]
Use the indexes option to define SQLite indexes.
Table and column names are not typed because Kysely doesn't support it.
+https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-indexes-indexes-c4e175f3c346
+initial
Use this option to create initial data (fixtures).
+max
max
Maximum physical clock drift allowed in ms.
+The default value is 5 * 60 * 1000 (5 minutes).
+minimum
minimum
| "none"
| "trace"
| "debug"
| "warning"
| "none"
| "trace"
| "debug"
| "warning"
Setting the minimum log level. The default value is none.
For development, use trace to log all events and debug to log only
+events with values. For production, use warning.
mnemonic
Use this option to create Evolu with the specified mnemonic. If omitted, +the mnemonic will be autogenerated. That should be the default behavior +until special UX requirements are needed (e.g., multitenancy).
+name
name: string
Evolu is multitenant - it can run more instances concurrently. Every Evolu +instance has to have its own unique name. Database files are separated and +invisible to each other.
+The default value is: Evolu.
reload
reload
URL to reload browser tabs after Owner reset or restore.
+The default value is /.
sync
sync
URL for Evolu sync and backup server.
+The default value is https://evolu.world.
diff --git a/interfaces/_evolu_common.MerkleTree.html b/interfaces/_evolu_common.MerkleTree.html
new file mode 100644
index 000000000..8193896a4
--- /dev/null
+++ b/interfaces/_evolu_common.MerkleTree.html
@@ -0,0 +1,7 @@
+
Interface MerkleTree
It's actually not Merkle Tree but a Merkleized prefix tree, aka Merkle Trie. +https://decomposition.al/blog/2019/05/31/how-i-learned-about-merklix-trees-without-having-to-become-a-cryptocurrency-enthusiast
+Interface Message
interface Message {
column: string;
row: string & Brand<"Id">;
table: string;
timestamp: TimestampString;
value: Value;
}
column: string;
row: string & Brand<"Id">;
table: string;
timestamp: TimestampString;
value: Value;
}
Hierarchy (view full)
- NewMessage
- Message
Interface MessageContent
interface MessageContent {
column: string;
row: string & Brand<"Id">;
table: string;
value:
| {
oneofKind: "stringValue";
stringValue: string;
}
| {
numberValue: string;
oneofKind: "numberValue";
}
| {
bytesValue: Uint8Array;
oneofKind: "bytesValue";
}
| {
jsonValue: string;
oneofKind: "jsonValue";
}
| {
oneofKind: undefined;
};
}
column: string;
row: string & Brand<"Id">;
table: string;
value:
| {
oneofKind: "stringValue";
stringValue: string;
}
| {
numberValue: string;
oneofKind: "numberValue";
}
| {
bytesValue: Uint8Array;
oneofKind: "bytesValue";
}
| {
jsonValue: string;
oneofKind: "jsonValue";
}
| {
oneofKind: undefined;
};
}
Properties
column
column: string
row
row: string & Brand<"Id">
table
table: string
value
value:
| {
oneofKind: "stringValue";
stringValue: string;
}
| {
numberValue: string;
oneofKind: "numberValue";
}
| {
bytesValue: Uint8Array;
oneofKind: "bytesValue";
}
| {
jsonValue: string;
oneofKind: "jsonValue";
}
| {
oneofKind: undefined;
}
| {
oneofKind: "stringValue";
stringValue: string;
}
| {
numberValue: string;
oneofKind: "numberValue";
}
| {
bytesValue: Uint8Array;
oneofKind: "bytesValue";
}
| {
jsonValue: string;
oneofKind: "jsonValue";
}
| {
oneofKind: undefined;
}
Type declaration
oneof
Kind: "stringValue" string
Value: string
Type declaration
number
Value: string oneof
Kind: "numberValue"
Type declaration
bytes
Value: Uint8Array oneof
Kind: "bytesValue"
Type declaration
json
Value: string oneof
Kind: "jsonValue"
diff --git a/interfaces/_evolu_common.NetworkError.html b/interfaces/_evolu_common.NetworkError.html
new file mode 100644
index 000000000..5edf44f03
--- /dev/null
+++ b/interfaces/_evolu_common.NetworkError.html
@@ -0,0 +1,2 @@
+
diff --git a/interfaces/_evolu_common.NewMessage.html b/interfaces/_evolu_common.NewMessage.html
new file mode 100644
index 000000000..91049f724
--- /dev/null
+++ b/interfaces/_evolu_common.NewMessage.html
@@ -0,0 +1,5 @@
+
Interface NewMessage
Hierarchy (view full)
- NewMessage
diff --git a/interfaces/_evolu_common.Owner.html b/interfaces/_evolu_common.Owner.html
new file mode 100644
index 000000000..ebb82f775
--- /dev/null
+++ b/interfaces/_evolu_common.Owner.html
@@ -0,0 +1,15 @@
+
Interface Owner
The Owner represents the Evolu database owner, a user. Instead of traditional +email with a password, the Owner uses a mnemonic, also known as a "seed +phrase," which is a set of 12 words in a specific order chosen from a +predefined list.
+The purpose of the BIP39 mnemonic is to provide a human-readable way of +storing a private key.
+Mnemonic is generated safely in the user's device and must not be shared with +anyone.
+ Index
Properties
diff --git a/interfaces/_evolu_common.QueryPatches.html b/interfaces/_evolu_common.QueryPatches.html
new file mode 100644
index 000000000..9727c3ee2
--- /dev/null
+++ b/interfaces/_evolu_common.QueryPatches.html
@@ -0,0 +1,3 @@
+
diff --git a/interfaces/_evolu_common.QueryResult.html b/interfaces/_evolu_common.QueryResult.html
new file mode 100644
index 000000000..7790f7800
--- /dev/null
+++ b/interfaces/_evolu_common.QueryResult.html
@@ -0,0 +1,7 @@
+
Interface QueryResult<R>
An object with rows and row properties.
+interface QueryResult<R> {
row: null | Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>;
rows: readonly Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>[];
}
row: null | Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>;
rows: readonly Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>[];
}
Type Parameters
diff --git a/interfaces/_evolu_common.ReplaceAtPatch.html b/interfaces/_evolu_common.ReplaceAtPatch.html
new file mode 100644
index 000000000..35dd3dc7c
--- /dev/null
+++ b/interfaces/_evolu_common.ReplaceAtPatch.html
@@ -0,0 +1,4 @@
+
diff --git a/interfaces/_evolu_common.ServerError.html b/interfaces/_evolu_common.ServerError.html
new file mode 100644
index 000000000..817d67993
--- /dev/null
+++ b/interfaces/_evolu_common.ServerError.html
@@ -0,0 +1,3 @@
+
diff --git a/interfaces/_evolu_common.Sqlite.html b/interfaces/_evolu_common.Sqlite.html
new file mode 100644
index 000000000..4c9e0cd7e
--- /dev/null
+++ b/interfaces/_evolu_common.Sqlite.html
@@ -0,0 +1,13 @@
+
Interface Sqlite
interface Sqlite {
exec: ((query: SqliteQuery) => Effect<SqliteExecResult, never, never>);
export: (() => Effect<Uint8Array, never, never>);
transaction: ((mode: SqliteTransactionMode) => (<A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Sqlite | R>));
}
exec: ((query: SqliteQuery) => Effect<SqliteExecResult, never, never>);
export: (() => Effect<Uint8Array, never, never>);
transaction: ((mode: SqliteTransactionMode) => (<A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Sqlite | R>));
}
Index
Properties
Properties
Readonlyexec
Readonlyexport
export: (() => Effect<Uint8Array, never, never>)
Readonlytransaction
transaction: ((mode: SqliteTransactionMode) => (<A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Sqlite | R>))
Type declaration
- (mode): (<A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Sqlite | R>)
Parameters
- mode: SqliteTransactionMode
Use
+exclusivefor mutations andsharedfor read-only queries. This +shared/exclusive lock pattern allows multiple simultaneous readers but +only one writer. In Evolu, this pattern also ensures that every write can +be immediately read without waiting to complete. For example, we can add +data on one page and then immediately redirect to another, and the data +will be there.There is also a
+lastmode that ensures no other transaction can run. +It's for Db reset to ensure no data are accidentally saved after database +wipe-out.
Returns (<A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Sqlite | R>)
- mode: SqliteTransactionMode
diff --git a/interfaces/_evolu_common.SqliteQuery.html b/interfaces/_evolu_common.SqliteQuery.html
new file mode 100644
index 000000000..5302b8bdc
--- /dev/null
+++ b/interfaces/_evolu_common.SqliteQuery.html
@@ -0,0 +1,4 @@
+
diff --git a/interfaces/_evolu_common.SqliteQueryOptions.html b/interfaces/_evolu_common.SqliteQueryOptions.html
new file mode 100644
index 000000000..580cdda38
--- /dev/null
+++ b/interfaces/_evolu_common.SqliteQueryOptions.html
@@ -0,0 +1,4 @@
+
diff --git a/interfaces/_evolu_common.Store.html b/interfaces/_evolu_common.Store.html
new file mode 100644
index 000000000..9379c40a3
--- /dev/null
+++ b/interfaces/_evolu_common.Store.html
@@ -0,0 +1,4 @@
+
diff --git a/interfaces/_evolu_common.Sync.html b/interfaces/_evolu_common.Sync.html
new file mode 100644
index 000000000..2d3d91c2f
--- /dev/null
+++ b/interfaces/_evolu_common.Sync.html
@@ -0,0 +1,3 @@
+
Interface Sync
interface Sync {
init: ((owner: Owner) => Effect<void, never, never>);
sync: ((syncData: SyncData) => Effect<SyncResult, SyncStateIsNotSynced, Config>);
}
init: ((owner: Owner) => Effect<void, never, never>);
sync: ((syncData: SyncData) => Effect<SyncResult, SyncStateIsNotSynced, Config>);
}
diff --git a/interfaces/_evolu_common.SyncRequest.html b/interfaces/_evolu_common.SyncRequest.html
new file mode 100644
index 000000000..b93fae05d
--- /dev/null
+++ b/interfaces/_evolu_common.SyncRequest.html
@@ -0,0 +1,10 @@
+
Interface SyncRequest
interface SyncRequest {
merkleTree: MerkleTreeString;
messages: readonly EncryptedMessage[];
nodeId: string & Brand<"NodeId">;
userId: OwnerId;
}
merkleTree: MerkleTreeString;
messages: readonly EncryptedMessage[];
nodeId: string & Brand<"NodeId">;
userId: OwnerId;
}
Index
Properties
diff --git a/interfaces/_evolu_common.SyncStateIsNotSynced.html b/interfaces/_evolu_common.SyncStateIsNotSynced.html
new file mode 100644
index 000000000..5772112c6
--- /dev/null
+++ b/interfaces/_evolu_common.SyncStateIsNotSynced.html
@@ -0,0 +1,3 @@
+
Interface SyncStateIsNotSynced
interface SyncStateIsNotSynced {
_tag: "SyncStateIsNotSynced";
error: NetworkError | ServerError | PaymentRequiredError;
}
_tag: "SyncStateIsNotSynced";
error: NetworkError | ServerError | PaymentRequiredError;
}
diff --git a/interfaces/_evolu_common.SyncStateIsSyncing.html b/interfaces/_evolu_common.SyncStateIsSyncing.html
new file mode 100644
index 000000000..414e38675
--- /dev/null
+++ b/interfaces/_evolu_common.SyncStateIsSyncing.html
@@ -0,0 +1,2 @@
+
diff --git a/interfaces/_evolu_common.Table.html b/interfaces/_evolu_common.Table.html
new file mode 100644
index 000000000..2bf8a30de
--- /dev/null
+++ b/interfaces/_evolu_common.Table.html
@@ -0,0 +1,3 @@
+
diff --git a/interfaces/_evolu_common.Timestamp.html b/interfaces/_evolu_common.Timestamp.html
new file mode 100644
index 000000000..acc5d4d50
--- /dev/null
+++ b/interfaces/_evolu_common.Timestamp.html
@@ -0,0 +1,4 @@
+
diff --git a/interfaces/_evolu_common.TimestampCounterOverflowError.html b/interfaces/_evolu_common.TimestampCounterOverflowError.html
new file mode 100644
index 000000000..532966150
--- /dev/null
+++ b/interfaces/_evolu_common.TimestampCounterOverflowError.html
@@ -0,0 +1,2 @@
+
diff --git a/interfaces/_evolu_common.TimestampDriftError.html b/interfaces/_evolu_common.TimestampDriftError.html
new file mode 100644
index 000000000..f3c1fd9fd
--- /dev/null
+++ b/interfaces/_evolu_common.TimestampDriftError.html
@@ -0,0 +1,4 @@
+
diff --git a/interfaces/_evolu_common.TimestampDuplicateNodeError.html b/interfaces/_evolu_common.TimestampDuplicateNodeError.html
new file mode 100644
index 000000000..797e89092
--- /dev/null
+++ b/interfaces/_evolu_common.TimestampDuplicateNodeError.html
@@ -0,0 +1,3 @@
+
diff --git a/interfaces/_evolu_common.TimestampTimeOutOfRangeError.html b/interfaces/_evolu_common.TimestampTimeOutOfRangeError.html
new file mode 100644
index 000000000..4fc0b84a9
--- /dev/null
+++ b/interfaces/_evolu_common.TimestampTimeOutOfRangeError.html
@@ -0,0 +1,2 @@
+
diff --git a/interfaces/_evolu_common.UnexpectedError.html b/interfaces/_evolu_common.UnexpectedError.html
new file mode 100644
index 000000000..95f19a47b
--- /dev/null
+++ b/interfaces/_evolu_common.UnexpectedError.html
@@ -0,0 +1,5 @@
+
Interface UnexpectedError
UnexpectedError represents errors that can occur unexpectedly anywhere, even +in third-party libraries, because Evolu uses Effect to track all errors.
+
diff --git a/interfaces/_evolu_react.Owner.html b/interfaces/_evolu_react.Owner.html
new file mode 100644
index 000000000..36709e74b
--- /dev/null
+++ b/interfaces/_evolu_react.Owner.html
@@ -0,0 +1,15 @@
+
Interface Owner
The Owner represents the Evolu database owner, a user. Instead of traditional +email with a password, the Owner uses a mnemonic, also known as a "seed +phrase," which is a set of 12 words in a specific order chosen from a +predefined list.
+The purpose of the BIP39 mnemonic is to provide a human-readable way of +storing a private key.
+Mnemonic is generated safely in the user's device and must not be shared with +anyone.
+ Index
Properties
Interface QueryResult<R>
An object with rows and row properties.
+interface QueryResult<R> {
row: null | Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>;
rows: readonly Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>[];
}
row: null | Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>;
rows: readonly Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>[];
}
Type Parameters
diff --git a/interfaces/_evolu_react.UnexpectedError.html b/interfaces/_evolu_react.UnexpectedError.html
new file mode 100644
index 000000000..e8f1cacfc
--- /dev/null
+++ b/interfaces/_evolu_react.UnexpectedError.html
@@ -0,0 +1,5 @@
+
Interface UnexpectedError
UnexpectedError represents errors that can occur unexpectedly anywhere, even +in third-party libraries, because Evolu uses Effect to track all errors.
+
diff --git a/interfaces/_evolu_react_native.index_native.Owner.html b/interfaces/_evolu_react_native.index_native.Owner.html
new file mode 100644
index 000000000..9cf473ae4
--- /dev/null
+++ b/interfaces/_evolu_react_native.index_native.Owner.html
@@ -0,0 +1,15 @@
+
Interface Owner
The Owner represents the Evolu database owner, a user. Instead of traditional +email with a password, the Owner uses a mnemonic, also known as a "seed +phrase," which is a set of 12 words in a specific order chosen from a +predefined list.
+The purpose of the BIP39 mnemonic is to provide a human-readable way of +storing a private key.
+Mnemonic is generated safely in the user's device and must not be shared with +anyone.
+ Index
Properties
Interface QueryResult<R>
An object with rows and row properties.
+interface QueryResult<R> {
row: null | Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>;
rows: readonly Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>[];
}
row: null | Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>;
rows: readonly Readonly<DrainOuterGeneric<{
[K in string | number | symbol]: R[K]
}>>[];
}
Type Parameters
diff --git a/interfaces/_evolu_react_native.index_native.UnexpectedError.html b/interfaces/_evolu_react_native.index_native.UnexpectedError.html
new file mode 100644
index 000000000..84be916e9
--- /dev/null
+++ b/interfaces/_evolu_react_native.index_native.UnexpectedError.html
@@ -0,0 +1,5 @@
+
Interface UnexpectedError
UnexpectedError represents errors that can occur unexpectedly anywhere, even +in third-party libraries, because Evolu uses Effect to track all errors.
+
diff --git a/interfaces/_evolu_server.Database.html b/interfaces/_evolu_server.Database.html
new file mode 100644
index 000000000..0a12dac55
--- /dev/null
+++ b/interfaces/_evolu_server.Database.html
@@ -0,0 +1,4 @@
+
Interface Database
Evolu Server database schema.
+ Index
Properties
Interface Server
interface Server {
initDatabase: Effect<void, never, never>;
sync: ((body: Uint8Array, socketUserMap: {
[key: string]: WebSocket[] | undefined;
}) => Effect<Buffer, BadRequestError, never>);
}
initDatabase: Effect<void, never, never>;
sync: ((body: Uint8Array, socketUserMap: {
[key: string]: WebSocket[] | undefined;
}) => Effect<Buffer, BadRequestError, never>);
}
Index
Properties
init
Properties
Readonlyinit
init
Create database tables and indexes if they do not exist.
+Readonlysync
sync: ((body: Uint8Array, socketUserMap: {
[key: string]: WebSocket[] | undefined;
}) => Effect<Buffer, BadRequestError, never>)
[key: string]: WebSocket[] | undefined;
}) => Effect<Buffer, BadRequestError, never>)
Sync data.
+Module @evolu/common - v5.4.4
Evolu
Local-first platform designed for privacy, ease of use, and no vendor lock-in
+-
+
- SQLite in all browsers, Electron, and React Native +
- CRDT for merging changes without conflicts +
- End-to-end encrypted sync and backup +
- Free Evolu sync and backup server, or you can run your own +
- Typed database schema (with branded types like
NonEmptyString1000,PositiveInt, etc.)
+ - Typed SQL via Kysely +
- Reactive queries with full React Suspense support +
- Real-time experience via revalidation on focus and network recovery +
- No signup/login, only bitcoin-like mnemonic (12 words) +
- Ad-hoc migration +
- Sqlite JSON support with automatic stringifying and parsing +
- Support for Kysely Relations (loading nested objects and arrays in a single SQL query) +
- Local-only tables (tables with _ prefix are not synced) +
- Evolu Solid/Vue/Svelte soon +
Local-first apps
Local-first apps allow users to own their data by storing them on their devices. Modern browsers provide API designed precisely for that. How is it different from keeping files on disk? Files are not the right abstraction for apps and cannot synchronize among devices. That's why traditional apps use the client-server architecture. But using client-server architecture also means that users' ability to use an app depends on some server that can be offline, temporarily or forever, if a company decides to ban a user or even goes bankrupt. That's unfortunate. Luckily, a way to restore data ownership exists. It's Evolu.
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+API Reference
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Contributing
Evolu monorepo uses pnpm.
+Install the dependencies with:
+pnpm install
+Build Evolu monorepo:
+pnpm build
+Start developing and watch for code changes:
+pnpm dev
+Start iOS developing (pnpm dev must be running too):
+pnpm ios
+Lint and tests:
+pnpm lint test
+Describe changes for release log:
+pnpm changeset
+Index
Other
App
constructors
database
+
Module @evolu/common-react - v8.1.0
Evolu Common for React
Common code for Evolu React and Evolu React Native.
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Index
Variables
Functions
Module @evolu/common-web - v8.2.1
Evolu Common for Web
Common code for Evolu React and other UI libraries for the web.
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Index
Variables
Functions
Module @evolu/react - v8.2.0
Evolu for React
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Index
Other
Invalid
constructors
database
+
Module @evolu/react-native - v11.1.0
Evolu for React Native
Evolu for React Native.
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Index
Modules
Module index.native
Index
Other
Invalid
constructors
database
+
Module index.web
Index
References
cast
+create
Functions
References
cast
Re-exports castcreate
Re-exports createIndexescreate
Re-exports createMnemonicdatabase
Re-exports databaseensure
Re-exports ensureTransferableErrorEvolu
Re-exports EvoluContextEvolu
Re-exports EvoluErrorEvolu
Re-exports EvoluProviderExtract
Re-exports ExtractRowid
Re-exports idId
Re-exports IdInvalid
Re-exports InvalidMnemonicErrorjson
Re-exports jsonArrayFromjson
Re-exports jsonObjectFrommake
Re-exports makeUnexpectedErrorMnemonic
Re-exports MnemonicNon
Re-exports NonEmptyString1000Not
Re-exports NotNullOwner
Re-exports OwnerOwner
Re-exports OwnerIdparse
Re-exports parseMnemonicPositive
Re-exports PositiveIntQuery
Re-exports QueryResultsql
Re-exports sqlSqlite
Re-exports SqliteBooleanSqlite
Re-exports SqliteDateString
Re-exports StringString1000
Re-exports String1000Sync
Re-exports SyncStatetable
Re-exports tableTimestamp
Re-exports TimestampTimestamp
Re-exports TimestampErrorUnexpected
Re-exports UnexpectedErroruse
Re-exports useuse
Re-exports useEvoluuse
Re-exports useEvoluErroruse
Re-exports useOwneruse
Re-exports useQueriesuse
Re-exports useQueryuse
Re-exports useQuerySubscriptionuse
Re-exports useSyncStateModule @evolu/server - v7.2.4
Evolu Server
Evolu Server for Evolu library.
+Documentation
For detailed information and usage examples, please visit evolu.dev.
+Community
The Evolu community is on GitHub Discussions, where you can ask questions and voice ideas.
+To chat with other community members, you can join the Evolu Discord.
+
Index
Interfaces
Type Aliases
Db
+
Variables
Functions
Type Alias Counter
Counter: typeof Counter.Type
Type Alias EvoluError
The EvoluError type is used to represent errors that can occur in Evolu.
+
diff --git a/types/_evolu_common.ExtractRow.html b/types/_evolu_common.ExtractRow.html
new file mode 100644
index 000000000..557cf40dd
--- /dev/null
+++ b/types/_evolu_common.ExtractRow.html
@@ -0,0 +1,5 @@
+
diff --git a/types/_evolu_common.FlushSync.html b/types/_evolu_common.FlushSync.html
new file mode 100644
index 000000000..3850685e2
--- /dev/null
+++ b/types/_evolu_common.FlushSync.html
@@ -0,0 +1,5 @@
+
Type Alias FlushSync
Flush
FlushSync is a service for libraries like React to synchronously flush +updates inside the provided callback to ensure the DOM is updated +immediately.
+ +Type Alias Id
Id: typeof Id.Type
Type Alias Index
Index: typeof Index.Type
Type Alias JsonObjectOrArray
Json
Type Alias Listener
Listener: (() => void)
Type Alias MerkleTreeString
Merkle
Type Alias Millis
Millis: typeof Millis.Type
Type Alias Mnemonic
Mnemonic: string & Brand.Brand<"Mnemonic">
Mnemonic is a password generated by Evolu in BIP39 format.
+A mnemonic, also known as a "seed phrase," is a set of 12 words in a specific +order chosen from a predefined list. The purpose of the BIP39 mnemonic is to +provide a human-readable way of storing a private key.
+Type Alias NanoId
Nano
Type Alias NodeId
Node
Type Alias NonEmptyString1000
Non
diff --git a/types/_evolu_common.Patch.html b/types/_evolu_common.Patch.html
new file mode 100644
index 000000000..32481e422
--- /dev/null
+++ b/types/_evolu_common.Patch.html
@@ -0,0 +1 @@
+
Type Alias Patch
Type Alias PositiveInt
Positive
diff --git a/types/_evolu_common.QueryResultsFromQueries.html b/types/_evolu_common.QueryResultsFromQueries.html
new file mode 100644
index 000000000..2dafbd53a
--- /dev/null
+++ b/types/_evolu_common.QueryResultsFromQueries.html
@@ -0,0 +1 @@
+
diff --git a/types/_evolu_common.QueryResultsPromisesFromQueries.html b/types/_evolu_common.QueryResultsPromisesFromQueries.html
new file mode 100644
index 000000000..389c2dd52
--- /dev/null
+++ b/types/_evolu_common.QueryResultsPromisesFromQueries.html
@@ -0,0 +1 @@
+
diff --git a/types/_evolu_common.QueryRowsMap.html b/types/_evolu_common.QueryRowsMap.html
new file mode 100644
index 000000000..82100f165
--- /dev/null
+++ b/types/_evolu_common.QueryRowsMap.html
@@ -0,0 +1 @@
+
Type Alias SqliteBoolean
Sqlite
Type Alias SqliteDate
Sqlite
Type Alias SqliteQueryPlanRow
Sqlite
detail: string;
id: number;
parent: number;
}
detail: string;
id: number;
parent: number;
}
Type Alias SqliteRow
Type Alias SqliteTransactionMode
Sqlite
Type Alias SqliteValue
Sqlite
| null
| string
| number
| Uint8Array
| null
| string
| number
| Uint8Array
Type Alias String
String: typeof String.Type
Type Alias String1000
String1000: typeof String1000.Type
Type Alias SyncState
The SyncState type represents the various states that a synchronization +process can be in.
+Type Alias TimestampError
Timestamp
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError
| TimestampTimeOutOfRangeError
The TimestampError type represents all Timestamp-related errors. If such an +error happens, the device clock is skewed and should be set to the current +time.
+Type Alias TimestampHash
Timestamp
Type Alias TimestampString
Timestamp
Type Alias Unsubscribe
Unsubscribe: (() => void)
Type Alias Value
Type Alias EvoluError
The EvoluError type is used to represent errors that can occur in Evolu.
+
diff --git a/types/_evolu_react.Id.html b/types/_evolu_react.Id.html
new file mode 100644
index 000000000..3a37c7469
--- /dev/null
+++ b/types/_evolu_react.Id.html
@@ -0,0 +1 @@
+
Type Alias Id
Id: typeof Id.Type
Type Alias Mnemonic
Mnemonic: string & Brand.Brand<"Mnemonic">
Mnemonic is a password generated by Evolu in BIP39 format.
+A mnemonic, also known as a "seed phrase," is a set of 12 words in a specific +order chosen from a predefined list. The purpose of the BIP39 mnemonic is to +provide a human-readable way of storing a private key.
+Type Alias NonEmptyString1000
Non
Type Alias NotNull
Not
__notNull__: unique symbol;
}
__notNull__: unique symbol;
}
A type constant for marking a column as not null. Can be used with $narrowPartial.
Example:
+const person = await db.selectFrom('person')
.where('nullable_column', 'is not', null)
.selectAll()
.$narrowType<{ nullable_column: NotNull }>()
.executeTakeFirstOrThrow()
+
diff --git a/types/_evolu_react.PositiveInt.html b/types/_evolu_react.PositiveInt.html
new file mode 100644
index 000000000..e85e5f9fd
--- /dev/null
+++ b/types/_evolu_react.PositiveInt.html
@@ -0,0 +1 @@
+
Type Alias PositiveInt
Positive
Type Alias SqliteBoolean
Sqlite
Type Alias SqliteDate
Sqlite
Type Alias String
String: typeof String.Type
Type Alias String1000
String1000: typeof String1000.Type
Type Alias SyncState
The SyncState type represents the various states that a synchronization +process can be in.
+Type Alias TimestampError
Timestamp
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError
| TimestampTimeOutOfRangeError
The TimestampError type represents all Timestamp-related errors. If such an +error happens, the device clock is skewed and should be set to the current +time.
+Type Alias EvoluError
The EvoluError type is used to represent errors that can occur in Evolu.
+
diff --git a/types/_evolu_react_native.index_native.Id.html b/types/_evolu_react_native.index_native.Id.html
new file mode 100644
index 000000000..7ebe63eff
--- /dev/null
+++ b/types/_evolu_react_native.index_native.Id.html
@@ -0,0 +1 @@
+
Type Alias Id
Id: typeof Id.Type
Type Alias Mnemonic
Mnemonic: string & Brand.Brand<"Mnemonic">
Mnemonic is a password generated by Evolu in BIP39 format.
+A mnemonic, also known as a "seed phrase," is a set of 12 words in a specific +order chosen from a predefined list. The purpose of the BIP39 mnemonic is to +provide a human-readable way of storing a private key.
+Type Alias NonEmptyString1000
Non
Type Alias NotNull
Not
__notNull__: unique symbol;
}
__notNull__: unique symbol;
}
A type constant for marking a column as not null. Can be used with $narrowPartial.
Example:
+const person = await db.selectFrom('person')
.where('nullable_column', 'is not', null)
.selectAll()
.$narrowType<{ nullable_column: NotNull }>()
.executeTakeFirstOrThrow()
+
diff --git a/types/_evolu_react_native.index_native.PositiveInt.html b/types/_evolu_react_native.index_native.PositiveInt.html
new file mode 100644
index 000000000..fc4228711
--- /dev/null
+++ b/types/_evolu_react_native.index_native.PositiveInt.html
@@ -0,0 +1 @@
+
Type Alias PositiveInt
Positive
Type Alias SqliteBoolean
Sqlite
Type Alias SqliteDate
Sqlite
Type Alias String
String: typeof String.Type
Type Alias String1000
String1000: typeof String1000.Type
Type Alias SyncState
The SyncState type represents the various states that a synchronization +process can be in.
+Type Alias TimestampError
Timestamp
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError
| TimestampTimeOutOfRangeError
| TimestampDriftError
| TimestampCounterOverflowError
| TimestampDuplicateNodeError
| TimestampTimeOutOfRangeError
The TimestampError type represents all Timestamp-related errors. If such an +error happens, the device clock is skewed and should be set to the current +time.
+Type Alias Db
Evolu Server Kysely instance. Use only PostgreSQL or SQLite dialects for now. +https://kysely-org.github.io/kysely-apidoc/classes/InsertQueryBuilder.html#onConflict
+Variable AllowedTimeRangeConst
Allowed
greaterThan: number;
lessThan: number;
} = ...
greaterThan: number;
lessThan: number;
} = ...
Variable CounterConst
Counter: brand<filter<Schema<number, number, never>>, "Counter"> = ...
diff --git a/variables/_evolu_common.FlushSync-1.html b/variables/_evolu_common.FlushSync-1.html
new file mode 100644
index 000000000..a38d88147
--- /dev/null
+++ b/variables/_evolu_common.FlushSync-1.html
@@ -0,0 +1 @@
+
Variable IdConst
Id: brand<filter<Schema<string, string, never>>, "Id"> = ...
Branded Id Schema. To create Id Schema for a specific table, use id.
+Variable IndexConst
Index: Struct<{
name: typeof String$;
sql: typeof String$;
}> = ...
name: typeof String$;
sql: typeof String$;
}> = ...
diff --git a/variables/_evolu_common.Millis-1.html b/variables/_evolu_common.Millis-1.html
new file mode 100644
index 000000000..977ea69be
--- /dev/null
+++ b/variables/_evolu_common.Millis-1.html
@@ -0,0 +1,6 @@
+
Variable MillisConst
Millis: brand<filter<Schema<number, number, never>>, "Millis"> = ...
Millis represents a time that is valid for usage with the Merkle tree. It +must be between Apr 13, 1997, and Nov 05, 2051, to ensure MinutesBase3 length +equals 16. We can find diff for two Merkle trees only within this range. If +the device clock is out of range, Evolu will not store data until it's +fixed.
+Variable NodeIdConst
Node
Variable NonEmptyString1000Const
Non
A nonempty string with a maximum length of 1000 characters.
+
diff --git a/variables/_evolu_common.Sqlite-1.html b/variables/_evolu_common.Sqlite-1.html
new file mode 100644
index 000000000..6d363f454
--- /dev/null
+++ b/variables/_evolu_common.Sqlite-1.html
@@ -0,0 +1 @@
+
Variable SqliteBooleanConst
Sqlite
SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead. +Use the cast helper to cast SqliteBoolean from boolean and back. +https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+Variable SqliteDateConst
Sqlite
SQLite doesn't support the Date type, so Evolu uses SqliteDate instead. Use +the cast helper to cast SqliteDate from Date and back. +https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
+Variable StringConst
String: brand<filter<typeof String$>, "String"> = ...
String schema represents a string that is not stringified JSON. Using String +schema for strings stored in SQLite is crucial to ensure a stored string is +not automatically parsed to a JSON object or array when retrieved. Use String +schema for all string-based schemas.
+
diff --git a/variables/_evolu_common.Sync-1.html b/variables/_evolu_common.Sync-1.html
new file mode 100644
index 000000000..4ce4827d1
--- /dev/null
+++ b/variables/_evolu_common.Sync-1.html
@@ -0,0 +1 @@
+
diff --git a/variables/_evolu_common.SyncResponse-1.html b/variables/_evolu_common.SyncResponse-1.html
new file mode 100644
index 000000000..7eff8b883
--- /dev/null
+++ b/variables/_evolu_common.SyncResponse-1.html
@@ -0,0 +1,2 @@
+
diff --git a/variables/_evolu_common.createDb.html b/variables/_evolu_common.createDb.html
new file mode 100644
index 000000000..08c333f01
--- /dev/null
+++ b/variables/_evolu_common.createDb.html
@@ -0,0 +1 @@
+
Variable createDbConst
create
| SqliteFactory
| NanoIdGenerator
| Time
| SyncFactory
| SyncLock> = ...
| SqliteFactory
| NanoIdGenerator
| Time
| SyncFactory
| SyncLock> = ...
Variable defaultConfigConst
Variable initialMerkleTreeConst
Variable initialMillisConst
initial
Variable initialSyncStateConst
Variable makeInitialTimestampConst
Variable notSupportedPlatformWorkerConst
Variable EvoluContextConst
Variable EvoluFactoryWebConst
Variable EvoluContextConst
Evolu
Variable IdConst
Id: S.brand<S.filter<S.Schema<string, string, never>>, "Id">
Branded Id Schema. To create Id Schema for a specific table, use id.
+Variable NonEmptyString1000Const
Non
A nonempty string with a maximum length of 1000 characters.
+
diff --git a/variables/_evolu_react.SqliteBoolean-1.html b/variables/_evolu_react.SqliteBoolean-1.html
new file mode 100644
index 000000000..57513ee28
--- /dev/null
+++ b/variables/_evolu_react.SqliteBoolean-1.html
@@ -0,0 +1,4 @@
+
Variable SqliteBooleanConst
Sqlite
SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead. +Use the cast helper to cast SqliteBoolean from boolean and back. +https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+Variable SqliteDateConst
Sqlite
SQLite doesn't support the Date type, so Evolu uses SqliteDate instead. Use +the cast helper to cast SqliteDate from Date and back. +https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
+Variable StringConst
String: S.brand<S.filter<typeof S.String>, "String">
String schema represents a string that is not stringified JSON. Using String +schema for strings stored in SQLite is crucial to ensure a stored string is +not automatically parsed to a JSON object or array when retrieved. Use String +schema for all string-based schemas.
+
diff --git a/variables/_evolu_react.use.html b/variables/_evolu_react.use.html
new file mode 100644
index 000000000..7d77dd86c
--- /dev/null
+++ b/variables/_evolu_react.use.html
@@ -0,0 +1,4 @@
+
Variable useConst
use: typeof ReactExports.use
A React 19 use polyfill.
See https://react.dev/reference/react/use. See +https://github.com/acdlite/rfcs/blob/first-class-promises/text/0000-first-class-support-for-promises.md
+Variable EvoluContextConst
Evolu
Variable IdConst
Id: S.brand<S.filter<S.Schema<string, string, never>>, "Id">
Branded Id Schema. To create Id Schema for a specific table, use id.
+Variable NonEmptyString1000Const
Non
A nonempty string with a maximum length of 1000 characters.
+
diff --git a/variables/_evolu_react_native.index_native.SqliteBoolean-1.html b/variables/_evolu_react_native.index_native.SqliteBoolean-1.html
new file mode 100644
index 000000000..a8649a212
--- /dev/null
+++ b/variables/_evolu_react_native.index_native.SqliteBoolean-1.html
@@ -0,0 +1,4 @@
+
Variable SqliteBooleanConst
Sqlite
SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead. +Use the cast helper to cast SqliteBoolean from boolean and back. +https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+Variable SqliteDateConst
Sqlite
SQLite doesn't support the Date type, so Evolu uses SqliteDate instead. Use +the cast helper to cast SqliteDate from Date and back. +https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
+Variable StringConst
String: S.brand<S.filter<typeof S.String>, "String">
String schema represents a string that is not stringified JSON. Using String +schema for strings stored in SQLite is crucial to ensure a stored string is +not automatically parsed to a JSON object or array when retrieved. Use String +schema for all string-based schemas.
+
diff --git a/variables/_evolu_react_native.index_native.use.html b/variables/_evolu_react_native.index_native.use.html
new file mode 100644
index 000000000..2777490bc
--- /dev/null
+++ b/variables/_evolu_react_native.index_native.use.html
@@ -0,0 +1,4 @@
+
Variable useConst
use: typeof ReactExports.use
A React 19 use polyfill.
See https://react.dev/reference/react/use. See +https://github.com/acdlite/rfcs/blob/first-class-promises/text/0000-first-class-support-for-promises.md
+
Create Evolu from the database schema.
+Tables with a name prefixed with
+_are local-only, which means they are +never synced. It's useful for device-specific or temporal data.