@evolu/common 1.0.17 → 2.0.0

package/dist/src/Evolu.js

@@ -1,235 +1,249 @@
-import { Context, Effect, Either, Function, Layer, Number, Option, ReadonlyArray, absurd, pipe, } from "effect";
-import { Config, ConfigLive } from "./Config.js";
+import { Context, Effect, Function, Layer, Match, Number, ReadonlyArray, pipe, } from "effect";
+import * as Kysely from "kysely";
+import { Config } from "./Config.js";
 import { Time, TimeLive } from "./Crdt.js";
-import { Bip39, NanoId } from "./Crypto.js";
-import { makeCreateQuery, } from "./Db.js";
-import { DbWorker, } from "./DbWorker.js";
+import { NanoId, NanoIdLive } from "./Crypto.js";
+import { RowsStore, RowsStoreLive, emptyRows, queryResultFromRows, schemaToTables, serializeQuery, } from "./Db.js";
+import { DbWorker } from "./DbWorker.js";
 import { applyPatches } from "./Diff.js";
+import { makeErrorStore } from "./ErrorStore.js";
 import { cast } from "./Model.js";
+import { OnCompletes, OnCompletesLive } from "./OnCompletes.js";
 import { AppState, FlushSync } from "./Platform.js";
 import { makeStore } from "./Store.js";
-export const Evolu = () => Context.Tag("evolu/Evolu");
-const QueryStore = Context.Tag("evolu/QueryStore");
-const Mutate = () => Context.Tag("evolu/Mutate");
-const OwnerActions = Context.Tag("evolu/OwnerActions");
-const SubscribedQueries = Context.Tag("evolu/SubscribedQueries");
-const OnCompletes = Context.Tag("evolu/OnCompletes");
-const LoadingPromises = Context.Tag("evolu/LoadingPromises");
-export const loadingPromisesPromiseProp = "rows";
-const LoadingPromisesLive = Layer.effect(LoadingPromises, Effect.sync(() => {
+export const Evolu = Context.Tag();
+const kysely = new Kysely.Kysely({
+    dialect: {
+        createAdapter: () => new Kysely.SqliteAdapter(),
+        createDriver: () => new Kysely.DummyDriver(),
+        createIntrospector() {
+            throw "Not implemeneted";
+        },
+        createQueryCompiler: () => new Kysely.SqliteQueryCompiler(),
+    },
+});
+export const makeCreateQuery = () => (queryCallback) => pipe(queryCallback(kysely).compile(), ({ sql, parameters }) => ({
+    sql,
+    parameters: parameters,
+}), (query) => serializeQuery(query));
+export const LoadingPromises = Context.Tag();
+export const LoadingPromiseLive = Layer.effect(LoadingPromises, Effect.gen(function* (_) {
+    const subscribedQueries = yield* _(SubscribedQueries);
     const promises = new Map();
-    const getPromise = (query) => {
-        const item = promises.get(query);
-        if (item)
-            return { promise: item.promise, isNew: false };
-        let resolve = Function.constVoid;
-        const promise = new Promise((_resolve) => {
-            resolve = _resolve;
-        });
-        promises.set(query, { promise, resolve });
-        return { promise, isNew: true };
-    };
-    const resolvePromise = (query, rows) => {
-        const item = promises.get(query);
-        if (!item)
-            return;
-        // It's similar to what React will do.
-        void Object.assign(item.promise, { [loadingPromisesPromiseProp]: rows });
-        item.resolve(rows);
-    };
-    const releasePromises = (ignoreQueries) => {
-        [...promises.keys()].forEach((query) => {
-            if (!ignoreQueries.includes(query))
+    return LoadingPromises.of({
+        get(query) {
+            let isNew = false;
+            let promiseWithResolve = promises.get(query);
+            if (!promiseWithResolve) {
+                isNew = true;
+                let resolve = Function.constVoid;
+                const promise = new Promise((_resolve) => {
+                    resolve = _resolve;
+                });
+                promiseWithResolve = { promise, resolve, releaseOnResolve: false };
+                promises.set(query, promiseWithResolve);
+            }
+            return {
+                promise: promiseWithResolve.promise,
+                isNew,
+            };
+        },
+        resolve(query, rows) {
+            const promiseWithResolve = promises.get(query);
+            if (!promiseWithResolve)
+                return;
+            const result = queryResultFromRows(rows);
+            if (promiseWithResolve.promise.status !== "fulfilled")
+                promiseWithResolve.resolve(result);
+            else
+                promiseWithResolve.promise = Promise.resolve(result);
+            setPromiseAsResolved(promiseWithResolve.promise)(result);
+            if (promiseWithResolve.releaseOnResolve)
                 promises.delete(query);
-        });
-    };
-    return { getPromise, resolvePromise, releasePromises };
+        },
+        release() {
+            const keep = subscribedQueries.getSubscribedQueries();
+            promises.forEach((promiseWithResolve, query) => {
+                if (keep.includes(query))
+                    return;
+                if (promiseWithResolve.promise.status === "fulfilled")
+                    promises.delete(query);
+                else
+                    promiseWithResolve.releaseOnResolve = true;
+            });
+        },
+    });
 }));
-const QueryStoreLive = Layer.effect(QueryStore, Effect.gen(function* (_) {
-    const subscribedQueries = yield* _(SubscribedQueries);
+// "For example, a data framework can set the status and value fields on a promise
+// preemptively, before passing to React, so that React can unwrap it without waiting
+// a microtask."
+// https://github.com/acdlite/rfcs/blob/first-class-promises/text/0000-first-class-support-for-promises.md
+const setPromiseAsResolved = (promise) => (value) => {
+    Object.assign(promise, { status: "fulfilled", value });
+};
+const LoadQuery = Context.Tag();
+const LoadQueryLive = Layer.effect(LoadQuery, Effect.gen(function* (_) {
     const loadingPromises = yield* _(LoadingPromises);
     const dbWorker = yield* _(DbWorker);
-    const flushSync = yield* _(FlushSync);
-    const onCompletes = yield* _(OnCompletes);
-    const rowsCacheStore = makeStore(new Map());
-    const queue = new Set();
-    const subscribe = (query) => (listen) => {
-        if (query == null)
-            return Function.constVoid;
-        subscribedQueries.set(query, Number.increment(subscribedQueries.get(query) ?? 0));
-        const unsubscribe = rowsCacheStore.subscribe(listen);
-        return () => {
-            // `as number`, because React mount/unmount are symmetric.
-            const count = subscribedQueries.get(query);
-            if (count > 1)
-                subscribedQueries.set(query, Number.decrement(count));
-            else
-                subscribedQueries.delete(query);
-            unsubscribe();
-        };
-    };
-    const getState = (query) => (query && rowsCacheStore.getState().get(query)) || null;
-    const loadQuery = (query) => {
-        const { promise, isNew } = loadingPromises.getPromise(query);
+    let queries = [];
+    return LoadQuery.of((query) => {
+        const { promise, isNew } = loadingPromises.get(query);
         if (isNew)
-            queue.add(query);
-        if (queue.size === 1) {
+            queries = [...queries, query];
+        if (queries.length === 1) {
             queueMicrotask(() => {
-                const queries = [...queue];
-                queue.clear();
                 if (ReadonlyArray.isNonEmptyReadonlyArray(queries))
                     dbWorker.postMessage({ _tag: "query", queries });
+                queries = [];
             });
         }
         return promise;
-    };
-    const onQuery = ({ queriesPatches, onCompleteIds, }) => {
-        const state = rowsCacheStore.getState();
-        const nextState = pipe(queriesPatches, ReadonlyArray.map(({ query, patches }) => [query, applyPatches(patches)(state.get(query) || [])]), (a) => new Map([...state, ...a]));
-        // Resolve all Promises belonging to queries.
+    });
+}));
+const OnQuery = Context.Tag();
+const OnQueryLive = Layer.effect(OnQuery, Effect.gen(function* (_) {
+    const rowsStore = yield* _(RowsStore);
+    const loadingPromises = yield* _(LoadingPromises);
+    const flushSync = yield* _(FlushSync);
+    const onCompletes = yield* _(OnCompletes);
+    return OnQuery.of(({ queriesPatches, onCompleteIds }) => Effect.gen(function* (_) {
+        const currentState = rowsStore.getState();
+        const nextState = pipe(queriesPatches, ReadonlyArray.map(({ query, patches }) => [
+            query,
+            applyPatches(patches)(currentState.get(query) || emptyRows()),
+        ]), (map) => new Map([...currentState, ...map]));
         queriesPatches.forEach(({ query }) => {
-            const rows = nextState.get(query) || [];
-            loadingPromises.resolvePromise(query, rows);
+            loadingPromises.resolve(query, nextState.get(query) || emptyRows());
         });
         // No mutation is using onComplete, so we don't need flushSync.
         if (onCompleteIds.length === 0) {
-            rowsCacheStore.setState(nextState);
+            yield* _(rowsStore.setState(nextState));
             return;
         }
-        flushSync(() => rowsCacheStore.setState(nextState));
-        ReadonlyArray.filterMap(onCompleteIds, (id) => {
-            const onComplete = onCompletes.get(id);
-            onCompletes.delete(id);
-            return Option.fromNullable(onComplete);
-        }).forEach((onComplete) => onComplete());
-    };
-    return { subscribe, getState, loadQuery, onQuery };
+        flushSync(() => rowsStore.setState(nextState).pipe(Effect.runSync));
+        yield* _(onCompletes.complete(onCompleteIds));
+    }));
 }));
-const MutateLive = () => Layer.effect(Mutate(), Effect.gen(function* (_) {
+export const SubscribedQueries = Context.Tag();
+export const SubscribedQueriesLive = Layer.effect(SubscribedQueries, Effect.gen(function* (_) {
+    const rowsStore = yield* _(RowsStore);
+    const subscribedQueries = new Map();
+    return SubscribedQueries.of({
+        subscribeQuery: (query) => (listener) => {
+            subscribedQueries.set(query, Number.increment(subscribedQueries.get(query) ?? 0));
+            const unsubscribe = rowsStore.subscribe(listener);
+            return () => {
+                const count = subscribedQueries.get(query);
+                if (count != null && count > 1)
+                    subscribedQueries.set(query, Number.decrement(count));
+                else
+                    subscribedQueries.delete(query);
+                unsubscribe();
+            };
+        },
+        getQuery: (query) => queryResultFromRows(rowsStore.getState().get(query) || emptyRows()),
+        getSubscribedQueries: () => ReadonlyArray.fromIterable(subscribedQueries.keys()),
+    });
+}));
+const Mutate = Context.Tag();
+const MutateLive = Layer.effect(Mutate, Effect.gen(function* (_) {
     const nanoid = yield* _(NanoId);
     const onCompletes = yield* _(OnCompletes);
     const time = yield* _(Time);
     const subscribedQueries = yield* _(SubscribedQueries);
     const loadingPromises = yield* _(LoadingPromises);
     const dbWorker = yield* _(DbWorker);
-    const queue = [];
-    return Mutate().of((table, { id, ...values }, onComplete) => {
+    let mutations = [];
+    return Mutate.of((table, { id, ...values }, onComplete) => {
         const isInsert = id == null;
         if (isInsert)
             id = Effect.runSync(nanoid.nanoid);
-        let onCompleteId = null;
-        if (onComplete) {
-            onCompleteId = Effect.runSync(nanoid.nanoid);
-            onCompletes.set(onCompleteId, onComplete);
-        }
-        queue.push({
-            table: table.toString(),
-            id: id,
-            values,
-            isInsert,
-            now: cast(new Date(Effect.runSync(time.now))),
-            onCompleteId,
-        });
-        if (queue.length === 1)
+        const onCompleteId = onComplete
+            ? onCompletes.add(onComplete).pipe(Effect.runSync)
+            : null;
+        mutations = [
+            ...mutations,
+            {
+                table: table.toString(),
+                id,
+                values,
+                isInsert,
+                now: cast(new Date(Effect.runSync(time.now))),
+                onCompleteId,
+            },
+        ];
+        if (mutations.length === 1)
             queueMicrotask(() => {
-                const items = [...queue];
-                queue.length = 0;
-                const queries = Array.from(subscribedQueries.keys());
-                // Just wipe-out LoadingPromises unused queries.
-                loadingPromises.releasePromises(queries);
-                if (ReadonlyArray.isNonEmptyReadonlyArray(items))
-                    dbWorker.postMessage({ _tag: "mutate", items, queries });
+                if (ReadonlyArray.isNonEmptyReadonlyArray(mutations))
+                    dbWorker.postMessage({
+                        _tag: "mutate",
+                        mutations,
+                        queries: subscribedQueries.getSubscribedQueries(),
+                    });
+                loadingPromises.release();
+                mutations = [];
             });
-        return { id: id };
+        return { id };
     });
 }));
-const OwnerActionsLive = Layer.effect(OwnerActions, Effect.gen(function* (_) {
-    const dbWorker = yield* _(DbWorker);
-    const bip39 = yield* _(Bip39);
-    const reset = () => {
-        dbWorker.postMessage({ _tag: "reset" });
-    };
-    const restore = (mnemonic) => bip39.parse(mnemonic).pipe(Effect.flatMap((mnemonic) => Effect.sync(() => {
-        dbWorker.postMessage({ _tag: "reset", mnemonic });
-        return Either.right(undefined);
-    })), Effect.catchTag("InvalidMnemonicError", () => Effect.succeed(Either.left({ _tag: "RestoreOwnerError" }))), Effect.runPromise);
-    return { reset, restore };
-}));
-export const EvoluLive = (tables) => Layer.effect(Evolu(), Effect.gen(function* (_) {
+/** EvoluCommon is without side effects, so it's unit-testable. */
+const EvoluCommon = Layer.effect(Evolu, Effect.gen(function* (_) {
     const dbWorker = yield* _(DbWorker);
+    const errorStore = yield* _(makeErrorStore);
+    const loadQuery = yield* _(LoadQuery);
+    const onQuery = yield* _(OnQuery);
+    const { subscribeQuery, getQuery, getSubscribedQueries } = yield* _(SubscribedQueries);
+    const syncStateStore = yield* _(makeStore({ _tag: "SyncStateInitial" }));
+    const mutate = yield* _(Mutate);
+    const ownerStore = yield* _(makeStore(null));
+    const loadingPromises = yield* _(LoadingPromises);
     const appState = yield* _(AppState);
-    const config = yield* _(Config);
-    const subscribedQueries = new Map();
-    const onCompletes = new Map();
-    const loadingPromises = Effect.provide(LoadingPromises, LoadingPromisesLive).pipe(Effect.runSync);
-    const errorStore = makeStore(null);
-    const ownerStore = makeStore(null);
-    const syncStateStore = makeStore({
-        _tag: "SyncStateInitial",
+    dbWorker.onMessage = (output) => Match.value(output).pipe(Match.tagsExhaustive({
+        onError: ({ error }) => errorStore.setState(error),
+        onQuery,
+        onOwner: ({ owner }) => ownerStore.setState(owner),
+        onSyncState: ({ state }) => syncStateStore.setState(state),
+        onReceive: () => Effect.sync(() => {
+            loadingPromises.release();
+            const queries = getSubscribedQueries();
+            if (ReadonlyArray.isNonEmptyReadonlyArray(queries))
+                dbWorker.postMessage({ _tag: "query", queries });
+        }),
+        onResetOrRestore: () => appState.reset,
+    }), Effect.runSync);
+    dbWorker.postMessage({
+        _tag: "init",
+        config: yield* _(Config),
     });
-    const Layers = Layer.mergeAll(Layer.succeed(DbWorker, dbWorker), Layer.succeed(SubscribedQueries, subscribedQueries), Layer.succeed(OnCompletes, onCompletes), Layer.succeed(LoadingPromises, loadingPromises), Layer.succeed(FlushSync, yield* _(FlushSync)), Layer.succeed(NanoId, yield* _(NanoId)), Layer.succeed(Time, yield* _(Time)), Layer.succeed(Bip39, yield* _(Bip39)));
-    const queryStore = Effect.provide(QueryStore, Layer.use(QueryStoreLive, Layers)).pipe(Effect.runSync);
-    const mutate = Effect.provide(Mutate(), Layer.use(MutateLive(), Layers)).pipe(Effect.runSync);
-    const ownerActions = Effect.provide(OwnerActions, Layer.use(OwnerActionsLive, Layers)).pipe(Effect.runSync);
-    const ensureSchema = (tables) => {
-        dbWorker.postMessage({ _tag: "ensureSchema", tables });
-    };
-    const getSubscribedQueries = () => Array.from(subscribedQueries.keys());
-    dbWorker.onMessage = (output) => {
-        // console.log(output);
-        switch (output._tag) {
-            case "onError":
-                if (process.env.NODE_ENV === "development")
-                    // JSON.stringify, because Expo console needs strings.
-                    // eslint-disable-next-line no-console
-                    console.warn(JSON.stringify(output.error, null, 2));
-                errorStore.setState(output.error);
-                break;
-            case "onOwner":
-                ownerStore.setState(output.owner);
-                break;
-            case "onQuery":
-                queryStore.onQuery(output);
-                break;
-            case "onReceive": {
-                const queries = getSubscribedQueries();
-                if (ReadonlyArray.isNonEmptyReadonlyArray(queries))
-                    dbWorker.postMessage({ _tag: "query", queries });
-                break;
-            }
-            case "onResetOrRestore":
-                Effect.runSync(appState.reset);
-                break;
-            case "onSyncState":
-                syncStateStore.setState(output.state);
-                break;
-            default:
-                absurd(output);
-        }
-    };
-    dbWorker.postMessage({ _tag: "init", config, tables });
-    appState.onFocus(() => {
-        // `queries` to refresh subscribed queries when a tab is changed.
-        dbWorker.postMessage({ _tag: "sync", queries: getSubscribedQueries() });
+    appState.init({
+        onFocus: () => {
+            dbWorker.postMessage({ _tag: "sync", queries: getSubscribedQueries() });
+        },
+        onReconnect: () => {
+            dbWorker.postMessage({ _tag: "sync", queries: [] });
+        },
     });
-    const sync = () => dbWorker.postMessage({ _tag: "sync", queries: [] });
-    appState.onReconnect(sync);
-    sync();
-    return Evolu().of({
+    return Evolu.of({
         subscribeError: errorStore.subscribe,
         getError: errorStore.getState,
+        createQuery: makeCreateQuery(),
+        loadQuery,
+        loadQueries: (queries) => queries.map(loadQuery),
+        subscribeQuery,
+        getQuery,
         subscribeOwner: ownerStore.subscribe,
         getOwner: ownerStore.getState,
-        createQuery: makeCreateQuery(),
-        subscribeQuery: queryStore.subscribe,
-        getQuery: queryStore.getState,
-        loadQuery: queryStore.loadQuery,
         subscribeSyncState: syncStateStore.subscribe,
         getSyncState: syncStateStore.getState,
         create: mutate,
         update: mutate,
-        ownerActions,
-        ensureSchema,
+        resetOwner: () => dbWorker.postMessage({ _tag: "reset" }),
+        restoreOwner: (mnemonic) => dbWorker.postMessage({ _tag: "reset", mnemonic }),
+        ensureSchema: (schema) => dbWorker.postMessage({
+            _tag: "ensureSchema",
+            tables: schemaToTables(schema),
+        }),
     });
-}));
-export const makeEvoluForPlatform = (PlatformLayer, tables, config) => Effect.provide(Evolu(), Layer.use(EvoluLive(tables), Layer.mergeAll(PlatformLayer, ConfigLive(config), TimeLive))).pipe(Effect.runSync);
+})).pipe(Layer.use(Layer.mergeAll(LoadQueryLive, OnQueryLive, MutateLive)), Layer.use(LoadingPromiseLive), Layer.use(SubscribedQueriesLive), Layer.use(Layer.merge(RowsStoreLive, OnCompletesLive)));
+/** EvoluCommonLive has only platform independent side-effects. */
+export const EvoluCommonLive = EvoluCommon.pipe(Layer.use(Layer.merge(TimeLive, NanoIdLive)));

package/dist/src/Model.d.ts

@@ -1,61 +1,54 @@
-import * as Schema from "@effect/schema/Schema";
+import * as S from "@effect/schema/Schema";
 import { Brand } from "effect";
 /**
- * Branded Id Schema for any table Id.
- * To create Id Schema for a specific table, use {@link id}.
+ * Branded Id Schema for any table Id. To create Id Schema for a specific table,
+ * use {@link id}.
  */
-export declare const Id: Schema.BrandSchema<string, string & Brand.Brand<"Id">>;
-export type Id = Schema.Schema.To<typeof Id>;
+export declare const Id: S.BrandSchema<string, string & Brand.Brand<"Id">>;
+export type Id = S.Schema.To<typeof Id>;
 /**
  * A factory function to create {@link Id} Schema for a specific table.
  *
  * ### Example
  *
- * ```
- * import * as Schema from "@effect/schema/Schema";
+ * ```ts
+ * import * as S from "@effect/schema/Schema";
  * import * as Evolu from "@evolu/react";
  *
  * const TodoId = Evolu.id("Todo");
- * type TodoId = Schema.Schema.To<typeof TodoId>;
- *
- * if (!Schema.is(TodoId)(value)) return;
+ * type TodoId = S.Schema.To<typeof TodoId>;
  * ```
  */
-export declare const id: <T extends string>(table: T) => Schema.BrandSchema<string, string & Brand.Brand<"Id"> & Brand.Brand<T>>;
+export declare const id: <T extends string>(table: T) => S.BrandSchema<string, string & Brand.Brand<"Id"> & Brand.Brand<T>>;
 /**
- * SQLite doesn't support the Date type, so Evolu uses SqliteDate instead.
- * Use the {@link cast} helper to cast SqliteDate from Date and back.
+ * SQLite doesn't support the Date type, so Evolu uses SqliteDate instead. Use
+ * the {@link cast} helper to cast SqliteDate from Date and back.
  * https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
  */
-export declare const SqliteDate: Schema.BrandSchema<string, string & Brand.Brand<"SqliteDate">>;
-export type SqliteDate = Schema.Schema.To<typeof SqliteDate>;
+export declare const SqliteDate: S.BrandSchema<string, string & Brand.Brand<"SqliteDate">>;
+export type SqliteDate = S.Schema.To<typeof SqliteDate>;
 /**
  * SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead.
  * Use the {@link cast} helper to cast SqliteBoolean from boolean and back.
  * https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
  */
-export declare const SqliteBoolean: Schema.BrandSchema<number, number & Brand.Brand<"SqliteBoolean">>;
-export type SqliteBoolean = Schema.Schema.To<typeof SqliteBoolean>;
-/**
- * SQLite doesn't support Date nor Boolean types, so Evolu emulates them
- * with {@link SqliteBoolean} and {@link SqliteDate}.
- *
- * For {@link SqliteBoolean}, you can use JavaScript boolean.
- * For {@link SqliteDate}, you can use JavaScript Date.
- */
-export type CastableForMutate<T> = {
-    readonly [K in keyof T]: T[K] extends SqliteBoolean ? boolean | SqliteBoolean : T[K] extends null | SqliteBoolean ? null | boolean | SqliteBoolean : T[K] extends SqliteDate ? Date | SqliteDate : T[K] extends null | SqliteDate ? null | Date | SqliteDate : T[K];
-};
+export declare const SqliteBoolean: S.BrandSchema<number, number & Brand.Brand<"SqliteBoolean">>;
+export type SqliteBoolean = S.Schema.To<typeof SqliteBoolean>;
 /**
- * A helper for casting types not supported by SQLite.
- * SQLite doesn't support Date nor Boolean types, so Evolu emulates them
- * with {@link SqliteBoolean} and {@link SqliteDate}.
+ * A helper for casting types not supported by SQLite. SQLite doesn't support
+ * Date nor Boolean types, so Evolu emulates them with {@link SqliteBoolean} and
+ * {@link SqliteDate}.
  *
  * ### Example
  *
- * ```
- * // isDeleted is SqliteBoolean
- * .where("isDeleted", "is not", cast(true))
+ * ```ts
+ * const allTodosNotDeleted = evolu.createQuery((db) =>
+ *   db
+ *     .selectFrom("todo")
+ *     .selectAll()
+ *     // isDeleted is SqliteBoolean
+ *     .where("isDeleted", "is not", Evolu.cast(true)),
+ * );
  * ```
  */
 export declare function cast(value: boolean): SqliteBoolean;
@@ -63,56 +56,53 @@ export declare function cast(value: SqliteBoolean): boolean;
 export declare function cast(value: Date): SqliteDate;
 export declare function cast(value: SqliteDate): Date;
 /**
- * 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.
+ * 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.
  */
-export declare const String: Schema.BrandSchema<string, string & Brand.Brand<"String">>;
-export type String = Schema.Schema.To<typeof String>;
+export declare const String: S.BrandSchema<string, string & Brand.Brand<"String">>;
+export type String = S.Schema.To<typeof String>;
 /**
  * A string with a maximum length of 1000 characters.
  *
  * ### Example
  *
- * ```
- * import * as Schema from "@effect/schema/Schema";
+ * ```ts
+ * import * as S from "@effect/schema/Schema";
  * import * as Evolu from "@evolu/react";
  *
- * if (!Schema.is(Evolu.String1000)(value)) return;
- * function foo(value: Evolu.String1000) {}
+ * S.parse(Evolu.String1000)(value);
  * ```
  */
-export declare const String1000: Schema.BrandSchema<string, string & Brand.Brand<"String"> & Brand.Brand<"String1000">>;
-export type String1000 = Schema.Schema.To<typeof String1000>;
+export declare const String1000: S.BrandSchema<string, string & Brand.Brand<"String"> & Brand.Brand<"String1000">>;
+export type String1000 = S.Schema.To<typeof String1000>;
 /**
  * A nonempty string with a maximum length of 1000 characters.
  *
  * ### Example
  *
- * ```
- * import * as Schema from "@effect/schema/Schema";
+ * ```ts
+ * import * as S from "@effect/schema/Schema";
  * import * as Evolu from "@evolu/react";
  *
- * if (!Schema.is(Evolu.NonEmptyString1000)(value)) return;
- * function foo(value: Evolu.NonEmptyString1000) {}
+ * S.parse(Evolu.NonEmptyString1000)(value);
  * ```
  */
-export declare const NonEmptyString1000: Schema.BrandSchema<string, string & Brand.Brand<"String"> & Brand.Brand<"NonEmptyString1000">>;
-export type NonEmptyString1000 = Schema.Schema.To<typeof NonEmptyString1000>;
+export declare const NonEmptyString1000: S.BrandSchema<string, string & Brand.Brand<"String"> & Brand.Brand<"NonEmptyString1000">>;
+export type NonEmptyString1000 = S.Schema.To<typeof NonEmptyString1000>;
 /**
  * A positive integer.
  *
  * ### Example
  *
- * ```
- * import * as Schema from "@effect/schema/Schema";
+ * ```ts
+ * import * as S from "@effect/schema/Schema";
  * import * as Evolu from "@evolu/react";
  *
- * if (!Schema.is(Evolu.PositiveInt)(value)) return;
- * function foo(value: Evolu.PositiveInt) {}
+ * S.parse(Evolu.PositiveInt)(value);
  * ```
  */
-export declare const PositiveInt: Schema.BrandSchema<number, number & Brand.Brand<"PositiveInt">>;
-export type PositiveInt = Schema.Schema.To<typeof PositiveInt>;
+export declare const PositiveInt: S.BrandSchema<number, number & Brand.Brand<"PositiveInt">>;
+export type PositiveInt = S.Schema.To<typeof PositiveInt>;
 //# sourceMappingURL=Model.d.ts.map

package/dist/src/Model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../src/Model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAG/B;;;GAGG;AACH,eAAO,MAAM,EAAE,wDAGd,CAAC;AACF,MAAM,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,EAAE,yGAGe,CAAC;AAE/B;;;;GAIG;AACH,eAAO,MAAM,UAAU,gEAGtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,UAAU,CAAC,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,aAAa,mEAIzB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,aAAa,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,aAAa,GAC/C,OAAO,GAAG,aAAa,GACvB,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,aAAa,GACjC,IAAI,GAAG,OAAO,GAAG,aAAa,GAC9B,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACvB,IAAI,GAAG,UAAU,GACjB,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,UAAU,GAC9B,IAAI,GAAG,IAAI,GAAG,UAAU,GACxB,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAAC;AACpD,wBAAgB,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC;AACpD,wBAAgB,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,UAAU,CAAC;AAC9C,wBAAgB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;AAW9C;;;;;GAKG;AACH,eAAO,MAAM,MAAM,4DAclB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,MAAM,CAAC,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,wFAGtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,UAAU,CAAC,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,gGAI9B,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE7E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,iEAIvB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC"}
+{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../src/Model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,uBAAuB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAG/B;;;GAGG;AACH,eAAO,MAAM,EAAE,mDAAyD,CAAC;AACzE,MAAM,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,EAAE,oGAGU,CAAC;AAE1B;;;;GAIG;AACH,eAAO,MAAM,UAAU,2DAGtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,UAAU,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,aAAa,8DAIzB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAAC;AACpD,wBAAgB,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC;AACpD,wBAAgB,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,UAAU,CAAC;AAC9C,wBAAgB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;AAW9C;;;;;GAKG;AACH,eAAO,MAAM,MAAM,uDAclB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,MAAM,CAAC,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,mFAAwD,CAAC;AAChF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,UAAU,CAAC,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,2FAI9B,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAExE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,4DAIvB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC"}