@evolu/common 4.1.1 → 5.0.1

package/dist/src/Evolu.js

@@ -1,149 +1,234 @@
+import * as AST from "@effect/schema/AST";
+import { make } from "@effect/schema/Schema";
+import * as Arr from "effect/Array";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import { pipe } from "effect/Function";
-import * as GlobalValue from "effect/GlobalValue";
+import { constVoid, flow, pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
-import * as Match from "effect/Match";
 import * as Number from "effect/Number";
-import * as ReadonlyArray from "effect/ReadonlyArray";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 import * as Kysely from "kysely";
-import { Config, ConfigLive } from "./Config.js";
-import { NanoIdGenerator, NanoIdGeneratorLive } from "./Crypto.js";
-import { RowsStore, RowsStoreLive, emptyRows, queryResultFromRows, schemaToTables, serializeQuery, } from "./Db.js";
-import { DbWorker } from "./DbWorker.js";
+import { Config, createRuntime, defaultConfig } from "./Config.js";
+import { NanoIdGenerator } from "./Crypto.js";
+import { DbFactory, deserializeQuery, emptyRows, queryResultFromRows, serializeQuery, } from "./Db.js";
 import { applyPatches } from "./Diff.js";
-import { makeErrorStore } from "./ErrorStore.js";
-import { OnCompletes, OnCompletesLive } from "./OnCompletes.js";
+import { makeUnexpectedError } from "./Error.js";
 import { AppState, FlushSync } from "./Platform.js";
 import { isSqlMutation, } from "./Sqlite.js";
 import { makeStore } from "./Store.js";
-export const Evolu = Context.GenericTag("@services/Evolu");
-// https://kysely.dev/docs/recipes/splitting-query-building-and-execution
-const kysely = new Kysely.Kysely({
-    dialect: {
-        createAdapter: () => new Kysely.SqliteAdapter(),
-        createDriver: () => new Kysely.DummyDriver(),
-        createIntrospector() {
-            throw "Not implemeneted";
-        },
-        createQueryCompiler: () => new Kysely.SqliteQueryCompiler(),
-    },
-});
-export const createIndex = kysely.schema.createIndex.bind(kysely.schema);
-export const makeCreateQuery = () => (queryCallback, options) => pipe(queryCallback(kysely).compile(), (compiledQuery) => {
-    if (isSqlMutation(compiledQuery.sql))
-        throw new Error("SQL mutation (INSERT, UPDATE, DELETE, etc.) isn't allowed in the Evolu `createQuery` function. Kysely suggests it because there is no read-only Kysely yet, and removing such an API is not possible. For mutations, use Evolu mutation API.");
-    const parameters = compiledQuery.parameters;
-    return {
-        sql: compiledQuery.sql,
-        parameters,
-        ...(options && { options }),
-    };
-}, (query) => serializeQuery(query));
-export const LoadingPromises = Context.GenericTag("@services/LoadingPromises");
-export const LoadingPromiseLive = Layer.effect(LoadingPromises, Effect.gen(function* (_) {
-    const subscribedQueries = yield* _(SubscribedQueries);
-    const promises = new Map();
-    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,
+import { initialSyncState } from "./Sync.js";
+export class EvoluFactory extends Context.Tag("EvoluFactory")() {
+}
+EvoluFactory.Common = Layer.effect(EvoluFactory, Effect.gen(function* () {
+    const flushSync = yield* Effect.map(Effect.serviceOption(FlushSync), Option.getOrElse(() => (callback) => callback()));
+    const context = Context.empty().pipe(Context.add(DbFactory, yield* DbFactory), Context.add(NanoIdGenerator, yield* NanoIdGenerator), Context.add(FlushSync, flushSync), Context.add(AppState, yield* AppState));
+    // For hot/live reloading and future Evolu dynamic import.
+    const instances = new Map();
+    return EvoluFactory.of({
+        createEvolu: (schema, { indexes, initialData, ...config } = {}) => {
+            const runtime = createRuntime(config);
+            const name = config?.name || defaultConfig.name;
+            const dbSchema = {
+                tables: schemaToTables(schema),
+                indexes: indexes || [],
             };
-        },
-        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);
-        },
-        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;
-            });
+            let evolu = instances.get(name);
+            if (evolu == null) {
+                evolu = createEvolu(dbSchema, runtime, initialData).pipe(Effect.provide(context), runtime.runSync);
+                instances.set(name, evolu);
+            }
+            else {
+                evolu.ensureSchema(dbSchema);
+            }
+            return evolu;
         },
     });
 }));
-// "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 schemaToTables = (schema) => pipe(getPropertySignatures(schema), Record.toEntries, Arr.map(([name, schema]) => ({
+    name,
+    columns: Object.keys(getPropertySignatures(schema)),
+})));
+// TODO: Simplify.
+// https://discord.com/channels/795981131316985866/1218626687546294386/1218796529725476935
+const getPropertySignatures = (schema) => {
+    const out = {};
+    const propertySignatures = AST.getPropertySignatures(schema.ast);
+    for (let i = 0; i < propertySignatures.length; i++) {
+        const propertySignature = propertySignatures[i];
+        out[propertySignature.name] = make(propertySignature.type);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return out;
 };
-const LoadQuery = Context.GenericTag("@services/LoadQuery");
-const LoadQueryLive = Layer.effect(LoadQuery, Effect.gen(function* (_) {
-    const loadingPromises = yield* _(LoadingPromises);
-    const dbWorker = yield* _(DbWorker);
-    let queries = [];
-    return LoadQuery.of((query) => {
-        const { promise, isNew } = loadingPromises.get(query);
-        if (isNew)
-            queries = [...queries, query];
-        if (queries.length === 1) {
-            queueMicrotask(() => {
-                if (ReadonlyArray.isNonEmptyReadonlyArray(queries))
-                    dbWorker.postMessage({ _tag: "query", queries });
-                queries = [];
+const createEvolu = (schema, runtime, initialData) => Effect.gen(function* () {
+    yield* Effect.logTrace("EvoluFactory createEvolu");
+    const config = yield* Config;
+    const dbFactory = yield* DbFactory;
+    const appState = yield* AppState;
+    const nanoIdGenerator = yield* NanoIdGenerator;
+    const flushSync = yield* FlushSync;
+    const db = yield* dbFactory.createDb;
+    const errorStore = yield* makeStore(null);
+    const ownerStore = yield* makeStore(null);
+    const rowsStore = yield* makeStore(new Map());
+    const syncStateStore = yield* makeStore(initialSyncState);
+    const loadingPromises = new Map();
+    const subscribedQueries = new Map();
+    const handleAllErrors = (effect) => effect.pipe(Effect.catchAllDefect((error) => Effect.fail(makeUnexpectedError(error))), Effect.tapError(Effect.logError), Effect.tapError(errorStore.setState));
+    const runFork = flow(handleAllErrors, runtime.runFork);
+    const runSync = flow(handleAllErrors, runtime.runSync);
+    // const runPromise = flow(handleAllErrors, runtime.runPromise);
+    const initialDataAsMutations = yield* Effect.provideService(initialDataToMutations(initialData), NanoIdGenerator, nanoIdGenerator);
+    const handleDbError = (error) => {
+        Effect.fail(error).pipe(runFork);
+    };
+    const handleSyncStateChange = (state) => {
+        Effect.logDebug(["Evolu handleSyncStateChange", { state }]).pipe(Effect.zipRight(syncStateStore.setState(state)), runFork);
+    };
+    const handleDbReceive = () => {
+        Effect.gen(function* () {
+            yield* Effect.logTrace("Evolu handleDbReceive");
+            releaseUnsubscribedLoadingPromises();
+            const queries = [...subscribedQueries.keys()];
+            if (queries.length > 0) {
+                yield* Effect.flatMap(db.loadQueries(queries), handlePatches());
+            }
+        }).pipe(runFork);
+    };
+    const sync = ({ refreshQueries }) => () => {
+        Effect.flatMap(db.sync(refreshQueries ? [...subscribedQueries.keys()] : []), handlePatches()).pipe(runFork);
+    };
+    db.init(schema, initialDataAsMutations, handleDbError, handleSyncStateChange, handleDbReceive).pipe(Effect.tap(sync({ refreshQueries: false })), Effect.flatMap(ownerStore.setState), Effect.catchTag("NotSupportedPlatformError", () => Effect.void), // no-op
+    runFork);
+    const appStateReset = yield* appState.init({
+        onRequestSync: sync({ refreshQueries: true }),
+        reloadUrl: config.reloadUrl,
+    });
+    const handlePatches = (options) => (patches) => Effect.logDebug(["Evolu handlePatches", { patches }]).pipe(Effect.zipRight(rowsStoreStateFromPatches(patches)), Effect.tap((nextState) => Effect.forEach(patches, ({ query }) => resolveLoadingPromises(query, nextState.get(query) || emptyRows()))), Effect.tap((nextState) => {
+        if (options?.flushSync) {
+            flushSync(() => {
+                rowsStore.setState(nextState).pipe(runSync);
             });
         }
-        return promise;
-    });
-}));
-const OnQuery = Context.GenericTag("@services/OnQuery");
-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 }) => [
+        else {
+            rowsStore.setState(nextState).pipe(runSync);
+        }
+    }));
+    const rowsStoreStateFromPatches = (patches) => Effect.sync(() => {
+        const rowsStoreState = rowsStore.getState();
+        if (patches.length === 0)
+            return rowsStoreState;
+        const queriesRows = Arr.map(patches, ({ query, patches }) => [
             query,
-            applyPatches(patches)(currentState.get(query) || emptyRows()),
-        ]), (map) => new Map([...currentState, ...map]));
-        queriesPatches.forEach(({ query }) => {
-            loadingPromises.resolve(query, nextState.get(query) || emptyRows());
-        });
-        // No mutation is using onComplete, so we don't need flushSync.
-        if (onCompleteIds.length === 0) {
-            yield* _(rowsStore.setState(nextState));
+            applyPatches(patches, rowsStoreState.get(query) || emptyRows()),
+        ]);
+        return new Map([...rowsStoreState, ...queriesRows]);
+    });
+    const resolveLoadingPromises = (query, rows) => Effect.sync(() => {
+        const loadingPromise = loadingPromises.get(query);
+        if (!loadingPromise)
             return;
+        const result = queryResultFromRows(rows);
+        if (loadingPromise.promise.status !== "fulfilled") {
+            loadingPromise.resolve(result);
         }
-        flushSync(() => rowsStore.setState(nextState).pipe(Effect.runSync));
-        yield* _(onCompletes.complete(onCompleteIds));
-    }));
-}));
-export const SubscribedQueries = Context.GenericTag("@services/SubscribedQueries");
-export const SubscribedQueriesLive = Layer.effect(SubscribedQueries, Effect.gen(function* (_) {
-    const rowsStore = yield* _(RowsStore);
-    const subscribedQueries = new Map();
-    return SubscribedQueries.of({
+        else {
+            // A promise can't be fulfilled 2x, so we need a new one.
+            loadingPromise.promise = Promise.resolve(result);
+        }
+        /**
+         * "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
+         */
+        Object.assign(loadingPromise, { status: "fulfilled", value: result });
+        if (loadingPromise.releaseOnResolve) {
+            loadingPromises.delete(query);
+        }
+    });
+    /**
+     * We can't delete loading promises in `resolveLoadingPromises` because they
+     * must be cached, so repeated calls to `loadQuery` will always return the
+     * same promise until the data changes, and we also can't cache them forever
+     * because only subscribed queries are automatically updated (reactivity is
+     * expensive) hence this function must be called manually on any mutation.
+     */
+    const releaseUnsubscribedLoadingPromises = () => {
+        [...loadingPromises.entries()]
+            .filter(([query]) => !subscribedQueries.has(query))
+            .forEach(([query, loadingPromise]) => {
+            if (loadingPromise.promise.status === "fulfilled") {
+                loadingPromises.delete(query);
+            }
+            else {
+                loadingPromise.releaseOnResolve = true;
+            }
+        });
+    };
+    const mutate = (() => {
+        let queue = [];
+        return (table, { id, ...values }, onComplete) => {
+            Effect.logDebug(["Evolu mutate", { table, id, values }]).pipe(runSync);
+            const isInsert = id == null;
+            if (isInsert)
+                id = nanoIdGenerator.rowId.pipe(runSync);
+            queue = [...queue, [{ table, id, values, isInsert }, onComplete]];
+            if (queue.length === 1)
+                queueMicrotask(() => {
+                    const [mutations, onCompletes] = Arr.unzip(queue);
+                    queue = [];
+                    const onCompletesDef = onCompletes.filter(Predicate.isNotUndefined);
+                    releaseUnsubscribedLoadingPromises();
+                    db.mutate(mutations, [...subscribedQueries.keys()]).pipe(Effect.flatMap(handlePatches({ flushSync: onCompletesDef.length > 0 })), Effect.tap(() => {
+                        onCompletesDef.forEach((onComplete) => onComplete());
+                    }), runFork);
+                });
+            return { id };
+        };
+    })();
+    const evolu = {
+        subscribeError: errorStore.subscribe,
+        getError: errorStore.getState,
+        createQuery: (queryCallback, options) => pipe(queryCallback(kysely).compile(), (compiledQuery) => {
+            if (isSqlMutation(compiledQuery.sql))
+                throw new Error("SQL mutation (INSERT, UPDATE, DELETE, etc.) isn't allowed in the Evolu `createQuery` function. Kysely suggests it because there is no read-only Kysely yet, and removing such an API is not possible. For mutations, use Evolu mutation API.");
+            const parameters = compiledQuery.parameters;
+            return {
+                sql: compiledQuery.sql,
+                parameters,
+                ...(options && { options }),
+            };
+        }, (query) => serializeQuery(query)),
+        loadQuery: (() => {
+            let queue = [];
+            return (query) => {
+                Effect.logDebug([
+                    "Evolu loadQuery",
+                    { query: deserializeQuery(query) },
+                ]).pipe(runSync);
+                let loadingPromise = loadingPromises.get(query);
+                if (!loadingPromise) {
+                    let resolve = constVoid;
+                    const promise = new Promise((_resolve) => {
+                        resolve = _resolve;
+                    });
+                    loadingPromise = { resolve, promise, releaseOnResolve: false };
+                    loadingPromises.set(query, loadingPromise);
+                    queue = [...queue, query];
+                    if (queue.length === 1) {
+                        queueMicrotask(() => {
+                            db.loadQueries(Arr.dedupe(queue)).pipe(Effect.flatMap(handlePatches()), runFork);
+                            queue = [];
+                        });
+                    }
+                }
+                return loadingPromise.promise;
+            };
+        })(),
+        loadQueries: (queries) => queries.map(evolu.loadQuery),
         subscribeQuery: (query) => (listener) => {
             subscribedQueries.set(query, Number.increment(subscribedQueries.get(query) ?? 0));
             const unsubscribe = rowsStore.subscribe(listener);
@@ -157,90 +242,6 @@ export const SubscribedQueriesLive = Layer.effect(SubscribedQueries, Effect.gen(
             };
         },
         getQuery: (query) => queryResultFromRows(rowsStore.getState().get(query) || emptyRows()),
-        getSubscribedQueries: () => ReadonlyArray.fromIterable(subscribedQueries.keys()),
-    });
-}));
-export const Mutate = Context.GenericTag("@services/Mutate");
-const MutateLive = Layer.effect(Mutate, Effect.gen(function* (_) {
-    const { nanoid } = yield* _(NanoIdGenerator);
-    const onCompletes = yield* _(OnCompletes);
-    const subscribedQueries = yield* _(SubscribedQueries);
-    const loadingPromises = yield* _(LoadingPromises);
-    const dbWorker = yield* _(DbWorker);
-    let mutations = [];
-    return Mutate.of((table, { id, ...values }, onComplete) => {
-        const isInsert = id == null;
-        if (isInsert)
-            id = Effect.runSync(nanoid);
-        const onCompleteId = onComplete
-            ? onCompletes.add(onComplete).pipe(Effect.runSync)
-            : null;
-        mutations = [
-            ...mutations,
-            {
-                table: table.toString(),
-                id,
-                values,
-                isInsert,
-                onCompleteId,
-            },
-        ];
-        if (mutations.length === 1)
-            queueMicrotask(() => {
-                if (ReadonlyArray.isNonEmptyReadonlyArray(mutations))
-                    dbWorker.postMessage({
-                        _tag: "mutate",
-                        mutations,
-                        queries: subscribedQueries.getSubscribedQueries(),
-                    });
-                loadingPromises.release();
-                mutations = [];
-            });
-        return { id };
-    });
-}));
-/** 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);
-    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 sync = () => {
-        dbWorker.postMessage({ _tag: "sync", queries: getSubscribedQueries() });
-    };
-    appState.init({ onRequestSync: sync });
-    sync();
-    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,
         subscribeSyncState: syncStateStore.subscribe,
@@ -248,34 +249,61 @@ const EvoluCommon = Layer.effect(Evolu, Effect.gen(function* (_) {
         create: mutate,
         update: mutate,
         createOrUpdate: mutate,
-        resetOwner: () => dbWorker.postMessage({ _tag: "reset" }),
-        restoreOwner: (mnemonic) => dbWorker.postMessage({ _tag: "reset", mnemonic }),
-        ensureSchema: (schema, indexes = []) => dbWorker.postMessage({
-            _tag: "ensureSchema",
-            tables: schemaToTables(schema),
-            indexes,
-        }),
-        sync,
-    });
-})).pipe(Layer.provide(Layer.mergeAll(LoadQueryLive, OnQueryLive, MutateLive)), Layer.provide(LoadingPromiseLive), Layer.provide(SubscribedQueriesLive), Layer.provide(Layer.merge(RowsStoreLive, OnCompletesLive)));
-export const EvoluCommonLive = EvoluCommon.pipe(Layer.provide(NanoIdGeneratorLive));
+        resetOwner: () => {
+            db.resetOwner().pipe(Effect.zipRight(appStateReset.reset), runFork);
+        },
+        restoreOwner: (mnemonic) => {
+            db.restoreOwner(schema, mnemonic).pipe(Effect.zipRight(appStateReset.reset), runFork);
+        },
+        ensureSchema: (schema) => {
+            db.ensureSchema(schema).pipe(runFork);
+        },
+    };
+    return evolu;
+});
+const initialDataToMutations = (initialData = constVoid) => Effect.map(NanoIdGenerator, (nanoIdGenerator) => {
+    const mutations = [];
+    const mutate = (table, { id, ...values }) => {
+        if (id == null)
+            id = nanoIdGenerator.rowId.pipe(Effect.runSync);
+        mutations.push({ isInsert: true, id, table: table, values });
+        return { id };
+    };
+    const evolu = {
+        create: mutate,
+        createOrUpdate: mutate,
+    };
+    initialData(evolu);
+    return mutations;
+});
+// https://kysely.dev/docs/recipes/splitting-query-building-and-execution
+const kysely = new Kysely.Kysely({
+    dialect: {
+        createAdapter: () => new Kysely.SqliteAdapter(),
+        createDriver: () => new Kysely.DummyDriver(),
+        createIntrospector() {
+            throw "Not implemeneted";
+        },
+        createQueryCompiler: () => new Kysely.SqliteQueryCompiler(),
+    },
+});
+const createIndex = kysely.schema.createIndex.bind(kysely.schema);
 /**
- * The recipe for creating Evolu for a platform and UI library:
+ * Create SQLite indexes.
  *
- * 1. Export everything from "@evolu/common/public"
- * 2. Export platform-specific parseMnemonic. If the platform supports lazy import,
- *    use it because dictionaries have a few hundred KBs.
- * 3. Export `createEvolu` for a platform. The TS docs must be copy-pasted, and
- *    remember to update the import.
- * 4. Export UI library API code.
+ * See https://www.evolu.dev/docs/indexes
+ *
+ * @example
+ *   const indexes = createIndexes((create) => [
+ *     create("indexTodoCreatedAt").on("todo").column("createdAt"),
+ *     create("indexTodoCategoryCreatedAt")
+ *       .on("todoCategory")
+ *       .column("createdAt"),
+ *   ]);
  */
-export const makeCreateEvolu = (EvoluLive) => (schema, config) => {
-    // For https://nextjs.org/docs/architecture/fast-refresh etc.
-    const evolu = GlobalValue.globalValue("@evolu/common", () => Evolu.pipe(Effect.provide(EvoluLive), Effect.provide(ConfigLive(config)), Effect.runSync));
-    const indexes = config?.indexes?.map((index) => ({
-        name: index.toOperationNode().name.name,
-        sql: index.compile().sql,
-    }));
-    evolu.ensureSchema(schema, indexes);
-    return evolu;
-};
+export const createIndexes = (callback) => callback(createIndex).map((index) => ({
+    name: index.toOperationNode().name.name,
+    sql: index.compile().sql,
+}));
+/** Create a namespaced lock name. */
+export const getLockName = (name) => Effect.map(Config, (config) => `evolu:${config.name}:${name}`);

package/dist/src/Model.d.ts

@@ -1,4 +1,6 @@
 import * as S from "@effect/schema/Schema";
+import * as Types from "effect/Types";
+import { Value } from "./Sqlite.js";
 /** Branded Id Schema. To create Id Schema for a specific table, use {@link id}. */
 export declare const Id: S.brand<S.Schema<string, string, never>, "Id">;
 export type Id = S.Schema.Type<typeof Id>;
@@ -45,6 +47,55 @@ export declare function cast(value: boolean): SqliteBoolean;
 export declare function cast(value: SqliteBoolean): boolean;
 export declare function cast(value: Date): SqliteDate;
 export declare function cast(value: SqliteDate): Date;
+interface EvoluTypeError<E extends string> {
+    readonly __evoluTypeError__: E;
+}
+/**
+ * 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.
+ *
+ * @example
+ *   const TodoId = id("Todo");
+ *   type TodoId = S.Schema.Type<typeof TodoId>;
+ *
+ *   const TodoTable = table({
+ *     id: TodoId,
+ *     title: NonEmptyString1000,
+ *     isCompleted: S.nullable(SqliteBoolean),
+ *   });
+ *   type TodoTable = S.Schema.Type<typeof TodoTable>;
+ */
+export declare const table: <Fields extends TableFields>(fields: Fields) => ValidateFieldsTypes<Fields> extends true ? ValidateFieldsNames<Fields> extends true ? ValidateFieldsHasId<Fields> extends true ? S.Schema<Types.Simplify<S.Struct.Type<Fields> & S.Schema.Type<typeof ReservedColumns>>, Types.Simplify<S.Struct.Encoded<Fields> & S.Schema.Encoded<typeof ReservedColumns>>> : 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.">;
+declare const ReservedColumns: S.Struct<{
+    createdAt: S.brand<S.Schema<string, string, never>, "SqliteDate">;
+    updatedAt: S.brand<S.Schema<string, string, never>, "SqliteDate">;
+    isDeleted: S.brand<S.Schema<number, number, never>, "SqliteBoolean">;
+}>;
+type TableFields = Record<string, S.Schema<any>>;
+type ValidateFieldsTypes<Fields extends TableFields> = keyof Fields extends infer K ? K extends keyof Fields ? Fields[K] extends TableFields ? ValidateFieldsTypes<Fields[K]> : Fields[K] extends S.Schema<infer A, infer _I> ? A extends Value ? true : false : never : never : never;
+type ValidateFieldsNames<Fields extends TableFields> = keyof Fields extends infer K ? K extends keyof Fields ? K extends "createdAt" | "updatedAt" | "isDeleted" ? false : true : never : never;
+type ValidateFieldsHasId<Fields extends TableFields> = "id" extends keyof Fields ? true : false;
+/**
+ * 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.
+ *
+ * @example
+ *   const Database = database({
+ *     // A local-only table.
+ *     _todo: TodoTable,
+ *     todo: TodoTable,
+ *     todoCategory: TodoCategoryTable,
+ *   });
+ *   type Database = S.Schema.Type<typeof Database>;
+ */
+export declare const database: typeof S.Struct;
 /**
  * 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
@@ -86,4 +137,5 @@ export type NonEmptyString1000 = S.Schema.Type<typeof NonEmptyString1000>;
  */
 export declare const PositiveInt: S.brand<S.Schema<number, number, never>, "PositiveInt">;
 export type PositiveInt = S.Schema.Type<typeof PositiveInt>;
+export {};
 //# 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,CAAC,MAAM,uBAAuB,CAAC;AAG3C,mFAAmF;AACnF,eAAO,MAAM,EAAE,gDAAyD,CAAC;AACzE,MAAM,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,EAAE,4BACN,CAAC,KACP,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CACnC,CAAC;AAE1B;;;;GAIG;AACH,eAAO,MAAM,UAAU,wDAGtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,aAAa,2DAIzB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;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,oDAclB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,CAAC;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,iGAAwD,CAAC;AAChF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE1D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,yGAI9B,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE1E;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,yDAIvB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC"}
+{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../src/Model.ts"],"names":[],"mappings":"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"}