@evolu/common 4.1.0 → 5.0.0

package/dist/src/Db.js

@@ -1,160 +1,131 @@
-import * as AST from "@effect/schema/AST";
 import * as S from "@effect/schema/Schema";
-import { make } from "@effect/schema/Schema";
+import * as Arr from "effect/Array";
+import * as Console from "effect/Console";
 import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
+import { constVoid, pipe } from "effect/Function";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
-import * as ReadonlyArray from "effect/ReadonlyArray";
-import * as ReadonlyRecord from "effect/ReadonlyRecord";
+import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
 import * as String from "effect/String";
-import { initialMerkleTree, makeInitialTimestamp, merkleTreeToString, timestampToString, } from "./Crdt.js";
-import { SqliteBoolean, SqliteDate } from "./Model.js";
-import { makeOwner } from "./Owner.js";
-import { createMessageTable, createMessageTableIndex, createOwnerTable, insertOwner, } from "./Sql.js";
-import { indexEquivalence, Sqlite, isJsonObjectOrArray, } from "./Sqlite.js";
-import { makeStore } from "./Store.js";
-/**
- * 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 const table = (fields) => S.struct(fields).pipe(S.extend(ReservedColumns));
-const ReservedColumns = S.struct({
-    createdAt: SqliteDate,
-    updatedAt: SqliteDate,
-    isDeleted: SqliteBoolean,
+import * as SynchronizedRef from "effect/SynchronizedRef";
+import { Time, diffMerkleTrees, initialMerkleTree, insertIntoMerkleTree, makeInitialTimestamp, makeSyncTimestamp, merkleTreeToString, receiveTimestamp, sendTimestamp, timestampToString, unsafeTimestampFromString, } from "./Crdt.js";
+import { Bip39, NanoIdGenerator } from "./Crypto.js";
+import { makePatches } from "./Diff.js";
+import { ensureTransferableError, makeUnexpectedError, } from "./Error.js";
+import { cast } from "./Model.js";
+import { Owner, makeOwner } from "./Owner.js";
+import { SyncLock } from "./Platform.js";
+import * as Sql from "./Sql.js";
+import { Sqlite, SqliteFactory, drawSqliteQueryPlan, isJsonObjectOrArray, } from "./Sqlite.js";
+import { Sync, SyncFactory, } from "./Sync.js";
+export const Index = S.Struct({
+    name: S.String,
+    sql: S.String,
 });
-/**
- * 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 const database = S.struct;
-// We use queries as keys, hence JSON.stringify.
-export const serializeQuery = ({ sql, parameters = [], options, }) => {
-    const query = {
-        sql,
-        parameters: parameters.map((p) => Predicate.isUint8Array(p)
-            ? Array.from(p)
-            : isJsonObjectOrArray(p)
-                ? { json: p }
-                : p),
-        ...(options && { options }),
-    };
-    return JSON.stringify(query);
-};
-export const deserializeQuery = (query) => {
-    const serializedSqliteQuery = JSON.parse(query);
-    return {
-        ...serializedSqliteQuery,
-        parameters: serializedSqliteQuery.parameters.map((p) => Array.isArray(p)
-            ? new Uint8Array(p)
-            : typeof p === "object" && p != null
-                ? p.json
-                : p),
+export class DbFactory extends Context.Tag("DbFactory")() {
+}
+export const createDb = Effect.gen(function* () {
+    const { createSqlite } = yield* SqliteFactory;
+    const { createSync } = yield* SyncFactory;
+    const initContext = Context.empty().pipe(Context.add(Bip39, yield* Bip39), Context.add(NanoIdGenerator, yield* NanoIdGenerator), Context.add(Time, yield* Time), Context.add(SyncLock, yield* SyncLock));
+    const afterInitContext = yield* Deferred.make();
+    const afterInit = (options) => (effect) => Effect.flatMap(Deferred.await(afterInitContext), (context) => Effect.flatMap(Sqlite, (sqlite) => sqlite.transaction(options.transaction)(effect)).pipe(Effect.provide(context)));
+    const queryRowsRef = yield* SynchronizedRef.make(new Map());
+    const db = {
+        init: (schema, initialData, onError, onSyncStateChange, onReceive) => Effect.gen(function* () {
+            yield* Effect.logDebug(["Db init", { schema }]);
+            const sqlite = yield* createSqlite;
+            const contextWithSqlite = Context.add(initContext, Sqlite, sqlite);
+            const owner = yield* getSchema.pipe(Effect.tap(ensureSchema(schema)), Effect.flatMap((currentSchema) => {
+                if (currentSchema.tables.map((t) => t.name).includes("evolu_owner"))
+                    return readOwner;
+                return createOwner().pipe(Effect.tap(applyMutations(initialData)));
+            }), sqlite.transaction("exclusive"), Effect.provide(contextWithSqlite));
+            const sync = yield* createSync.pipe(Effect.provide(initContext));
+            yield* sync.init(owner);
+            Deferred.unsafeDone(afterInitContext, Effect.succeed(contextWithSqlite.pipe(Context.add(Owner, owner), Context.add(Sync, sync), Context.add(Callbacks, { onError, onSyncStateChange, onReceive }))));
+            return owner;
+        }),
+        loadQueries: (queries) => Effect.logDebug(["Db loadQueries", { queries }]).pipe(Effect.zipRight(loadQueries(queries, queryRowsRef)), afterInit({ transaction: "shared" })),
+        mutate: (mutations, queriesToRefresh) => Effect.gen(function* () {
+            yield* Effect.logDebug(["Db mutate", { mutations, queriesToRefresh }]);
+            const time = yield* Time;
+            const sqlite = yield* Sqlite;
+            const [toSyncMutations, localOnlyMutations] = Arr.partition(mutations, 
+            /** Table name starting with '_' is local only (not synced). */
+            (mutation) => mutation.table.startsWith("_"));
+            for (const mutation of localOnlyMutations) {
+                const isDeleteMutation = mutationToNewMessages(mutation).some(({ column, value }) => column === "isDeleted" && value === 1);
+                if (isDeleteMutation) {
+                    yield* sqlite.exec({
+                        sql: `delete from "${mutation.table}" where "id" = ?;`,
+                        parameters: [mutation.id],
+                    });
+                }
+                else {
+                    const messages = mutationToNewMessages(mutation);
+                    for (const message of messages) {
+                        const now = yield* time.now;
+                        yield* upsertValueIntoTableRowColumn(message, messages, now);
+                    }
+                }
+            }
+            if (toSyncMutations.length > 0) {
+                yield* Effect.tap(applyMutations(toSyncMutations), forkSync);
+            }
+            return yield* loadQueries(queriesToRefresh, queryRowsRef);
+        }).pipe(afterInit({ transaction: "exclusive" })),
+        resetOwner: () => Effect.logTrace("Db resetOwner").pipe(Effect.tap(dropAllTables), afterInit({ transaction: "last" })),
+        restoreOwner: (schema, mnemonic) => Effect.logTrace("Db restoreOwner").pipe(Effect.tap(dropAllTables), Effect.tap(Effect.flatMap(getSchema, ensureSchema(schema))), Effect.tap(createOwner(mnemonic)), afterInit({ transaction: "last" })),
+        ensureSchema: (schema) => getSchema.pipe(Effect.flatMap(ensureSchema(schema)), afterInit({ transaction: "exclusive" })),
+        sync: (queriesToRefresh) => Effect.logDebug(["Db sync", { queriesToRefresh }]).pipe(Effect.zipRight(forkSync()), Effect.zipRight(loadQueries(queriesToRefresh, queryRowsRef)), afterInit({ transaction: "shared" })),
+        // TODO:
+        // dispose: () =>
+        //   Effect.logTrace("Db dispose").pipe(
+        //     Effect.tap(Scope.close(scope, Exit.succeed("Db disposed"))),
+        //     afterInit({ transaction: "last" }),
+        //   ),
     };
-};
-const _emptyRows = [];
-export const emptyRows = () => _emptyRows;
-const queryResultCache = new WeakMap();
-export const queryResultFromRows = (rows) => {
-    let queryResult = queryResultCache.get(rows);
-    if (queryResult == null) {
-        queryResult = { rows, row: rows[0] };
-        queryResultCache.set(rows, queryResult);
-    }
-    return queryResult;
-};
-// TODO: https://discord.com/channels/795981131316985866/1218626687546294386/1218796529725476935
-// https://github.com/Effect-TS/schema/releases/tag/v0.18.0
-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;
-};
-export const schemaToTables = (schema) => pipe(getPropertySignatures(schema), ReadonlyRecord.toEntries, ReadonlyArray.map(([name, schema]) => ({
-    name,
-    columns: Object.keys(getPropertySignatures(schema)),
-})));
-export const transaction = (effect) => Effect.flatMap(Sqlite, (sqlite) => Effect.acquireUseRelease(sqlite.exec({ sql: "begin" }), () => effect, (_, exit) => Exit.isFailure(exit)
-    ? sqlite.exec({ sql: "rollback" })
-    : sqlite.exec({ sql: "end" })));
-export const SqliteNoSuchTableOrColumnError = S.struct({
-    message: S.union(S.string.pipe(S.includes("no such table")), S.string.pipe(S.includes("no such column")), S.string.pipe(S.includes("has no column"))),
+    return db;
 });
-export const someDefectToNoSuchTableOrColumnError = Effect.catchSomeDefect((error) => S.is(SqliteNoSuchTableOrColumnError)(error)
-    ? Option.some(Effect.fail({
-        _tag: "NoSuchTableOrColumnError",
-    }))
-    : Option.none());
-export const lazyInit = (mnemonic) => Effect.gen(function* (_) {
-    const [owner, sqlite, initialTimestampString] = yield* _(Effect.all([makeOwner(mnemonic), Sqlite, makeInitialTimestamp], {
-        concurrency: "unbounded",
+export const Callbacks = Context.GenericTag("Callbacks");
+const loadQueries = (queries, queryRowsRef) => Effect.gen(function* () {
+    const sqlite = yield* Sqlite;
+    const previousState = yield* SynchronizedRef.getAndUpdateEffect(queryRowsRef, (previousState) => Effect.map(Effect.forEach(queries, (query) => {
+        const sqliteQuery = deserializeQuery(query);
+        return sqlite.exec(sqliteQuery).pipe(Effect.tap(maybeExplainQueryPlan(sqliteQuery)), Effect.map(({ rows }) => [query, rows]));
+    }), (queriesRows) => new Map([...previousState, ...queriesRows])));
+    const currentState = yield* SynchronizedRef.get(queryRowsRef);
+    return queries.map((query) => ({
+        query,
+        patches: makePatches(previousState.get(query), currentState.get(query) || []),
     }));
-    yield* _(Effect.all([
-        sqlite.exec(createMessageTable),
-        sqlite.exec(createMessageTableIndex),
-        sqlite.exec(createOwnerTable),
-        sqlite.exec({
-            ...insertOwner,
-            parameters: [
-                owner.id,
-                owner.mnemonic,
-                owner.encryptionKey,
-                timestampToString(initialTimestampString),
-                merkleTreeToString(initialMerkleTree),
-            ],
-        }),
-    ]));
-    return owner;
 });
+const maybeExplainQueryPlan = (sqliteQuery) => {
+    if (!sqliteQuery.options?.logExplainQueryPlan)
+        return Effect.void;
+    return Sqlite.pipe(Effect.flatMap((sqlite) => sqlite.exec({
+        ...sqliteQuery,
+        sql: `EXPLAIN QUERY PLAN ${sqliteQuery.sql}`,
+    })), Effect.tap(Console.log("ExplainQueryPlan", sqliteQuery)), Effect.tap(({ rows }) => Console.log(drawSqliteQueryPlan(rows))), Effect.map(constVoid));
+};
 const getSchema = Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const tables = yield* _(sqlite.exec({
+    yield* Effect.logTrace("Db getSchema");
+    const sqlite = yield* Sqlite;
+    const tables = yield* Effect.map(sqlite.exec({
         // https://til.simonwillison.net/sqlite/list-all-columns-in-a-database
         sql: `
-          select
-            sqlite_master.name as tableName,
-            table_info.name as columnName
-          from
-            sqlite_master
-            join pragma_table_info(sqlite_master.name) as table_info
-          `.trim(),
-    }), Effect.map(({ rows }) => {
+select
+  sqlite_master.name as tableName,
+  table_info.name as columnName
+from
+  sqlite_master
+  join pragma_table_info(sqlite_master.name) as table_info
+    `.trim(),
+    }), ({ rows }) => {
         const map = new Map();
         rows.forEach((row) => {
             const { tableName, columnName } = row;
@@ -162,22 +133,23 @@ const getSchema = Effect.gen(function* (_) {
                 map.set(tableName, []);
             map.get(tableName)?.push(columnName);
         });
-        return Array.from(map, ([name, columns]) => ({
+        return globalThis.Array.from(map, ([name, columns]) => ({
             name,
             columns,
         }));
-    }));
-    const indexes = yield* _(sqlite.exec({
+    });
+    const indexes = yield* Effect.map(sqlite.exec({
         sql: `
-          select
-            name, sql
-          from
-            sqlite_master
-          where
-            type='index' and
-            name not like 'sqlite_%' and
-            name not like 'index_evolu_%'`,
-    }), Effect.map((result) => ReadonlyArray.map(result.rows, (row) => ({
+select
+  name, sql
+from
+  sqlite_master
+where
+  type='index' and
+  name not like 'sqlite_%' and
+  name not like 'index_evolu_%'
+`.trim(),
+    }), (result) => Arr.map(result.rows, (row) => ({
         name: row.name,
         /**
          * SQLite returns "CREATE INDEX" for "create index" for some reason.
@@ -185,59 +157,285 @@ const getSchema = Effect.gen(function* (_) {
          * for `indexEquivalence` manually.
          */
         sql: row.sql.replace("CREATE INDEX", "create index"),
-    }))));
+    })));
     return { tables, indexes };
 });
-export const ensureSchema = (schema) => Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const currentSchema = yield* _(getSchema);
+const ensureSchema = (newSchema) => (currentSchema) => Effect.gen(function* () {
+    yield* Effect.logTrace("Db ensureSchema");
     const sql = [];
-    schema.tables.forEach((table) => {
+    newSchema.tables.forEach((table) => {
         const currentTable = currentSchema.tables.find((t) => t.name === table.name);
         if (!currentTable) {
             sql.push(`
-          create table ${table.name} (
-            "id" text primary key,
-            ${table.columns
+  create table ${table.name} (
+    "id" text primary key,
+    ${table.columns
                 .filter((c) => c !== "id")
                 // "A column with affinity BLOB does not prefer one storage class over another
                 // and no attempt is made to coerce data from one storage class into another."
                 // https://www.sqlite.org/datatype3.html
                 .map((name) => `"${name}" blob`)
                 .join(", ")}
-            );
-        `);
+  );`.trim());
         }
         else {
-            ReadonlyArray.differenceWith(String.Equivalence)(table.columns, currentTable.columns).forEach((newColumn) => {
+            Arr.differenceWith(String.Equivalence)(table.columns, currentTable.columns).forEach((newColumn) => {
                 sql.push(`alter table "${table.name}" add column "${newColumn}" blob;`);
             });
         }
     });
     // Remove old indexes.
-    ReadonlyArray.differenceWith(indexEquivalence)(currentSchema.indexes, ReadonlyArray.intersectionWith(indexEquivalence)(currentSchema.indexes, schema.indexes)).forEach((indexToDrop) => {
+    Arr.differenceWith(indexEquivalence)(currentSchema.indexes, Arr.intersectionWith(indexEquivalence)(currentSchema.indexes, newSchema.indexes)).forEach((indexToDrop) => {
         sql.push(`drop index "${indexToDrop.name}";`);
     });
     // Add new indexes.
-    ReadonlyArray.differenceWith(indexEquivalence)(schema.indexes, currentSchema.indexes).forEach((newIndex) => {
+    Arr.differenceWith(indexEquivalence)(newSchema.indexes, currentSchema.indexes).forEach((newIndex) => {
         sql.push(`${newIndex.sql};`);
     });
-    if (sql.length > 0)
-        yield* _(sqlite.exec({
-            sql: sql.join(""),
-        }));
+    if (sql.length > 0) {
+        const sqlite = yield* Sqlite;
+        yield* sqlite.exec({ sql: sql.join("\n") });
+    }
+});
+const indexEquivalence = (self, that) => self.name === that.name && self.sql === that.sql;
+const readOwner = Effect.logTrace("Db readOwner").pipe(Effect.zipRight(Sqlite), Effect.flatMap((sqlite) => sqlite.exec(Sql.selectOwner)), Effect.map(({ rows: [row] }) => ({
+    id: row.id,
+    mnemonic: row.mnemonic,
+    encryptionKey: row.encryptionKey,
+})));
+const createOwner = (mnemonic) => Effect.logTrace("Db createOwner").pipe(Effect.zipRight(Effect.all([makeOwner(mnemonic), Sqlite, makeInitialTimestamp])), Effect.tap(([owner, sqlite, initialTimestampString]) => Effect.all([
+    sqlite.exec(Sql.createMessageTable),
+    sqlite.exec(Sql.createMessageTableIndex),
+    sqlite.exec(Sql.createOwnerTable),
+    sqlite.exec({
+        ...Sql.insertOwner,
+        parameters: [
+            owner.id,
+            owner.mnemonic,
+            owner.encryptionKey,
+            timestampToString(initialTimestampString),
+            merkleTreeToString(initialMerkleTree),
+        ],
+    }),
+])), Effect.map(([owner]) => owner));
+const applyMutations = (mutations) => Effect.gen(function* (_) {
+    const { timestamp, merkleTree } = yield* readTimestampAndMerkleTree;
+    const [nextTimestamp, messages] = yield* Effect.mapAccum(mutations.flatMap(mutationToNewMessages), timestamp, (currentTimestamp, newMessage) => Effect.map(sendTimestamp(currentTimestamp), (nextTimestamp) => {
+        const message = {
+            ...newMessage,
+            timestamp: timestampToString(nextTimestamp),
+        };
+        return [nextTimestamp, message];
+    }));
+    const nextMerkleTree = yield* applyMessages(merkleTree, messages);
+    yield* writeTimestampAndMerkleTree(nextTimestamp, nextMerkleTree);
+    return messages;
+});
+const readTimestampAndMerkleTree = Sqlite.pipe(Effect.flatMap((sqlite) => sqlite.exec(Sql.selectOwnerTimestampAndMerkleTree)), Effect.map(({ rows: [{ timestamp, merkleTree }] }) => ({
+    timestamp: unsafeTimestampFromString(timestamp),
+    merkleTree: merkleTree,
+})));
+const mutationToNewMessages = (mutation) => pipe(Object.entries(mutation.values), Arr.filterMap(([column, value]) => 
+// The value can be undefined if exactOptionalPropertyTypes isn't true.
+// Don't insert nulls because null is the default value.
+value === undefined || (mutation.isInsert && value == null)
+    ? Option.none()
+    : Option.some([column, value])), Arr.map(([column, value]) => ({
+    table: mutation.table,
+    row: mutation.id,
+    column,
+    value: typeof value === "boolean"
+        ? cast(value)
+        : value instanceof Date
+            ? cast(value)
+            : value,
+})));
+const applyMessages = (merkleTree, messages) => Effect.gen(function* () {
+    const sqlite = yield* Sqlite;
+    for (const message of messages) {
+        const messageTimestamp = unsafeTimestampFromString(message.timestamp);
+        const lastTimestamp = yield* Effect.map(sqlite.exec({
+            ...Sql.selectLastTimestampForTableRowColumn,
+            parameters: [message.table, message.row, message.column, 1],
+        }), ({ rows }) => rows.length > 0 ? rows[0].timestamp : null);
+        if (lastTimestamp == null || lastTimestamp < message.timestamp) {
+            yield* upsertValueIntoTableRowColumn(message, messages, messageTimestamp.millis);
+        }
+        if (lastTimestamp == null || lastTimestamp !== message.timestamp) {
+            const { changes } = yield* sqlite.exec({
+                ...Sql.insertIntoMessagesIfNew,
+                parameters: [
+                    message.timestamp,
+                    message.table,
+                    message.row,
+                    message.column,
+                    message.value,
+                ],
+            });
+            if (changes === 1)
+                merkleTree = insertIntoMerkleTree(merkleTree, messageTimestamp);
+        }
+    }
+    return merkleTree;
 });
-export const dropAllTables = Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const schema = yield* _(getSchema);
-    const sql = schema.tables
-        // The dropped table is completely removed from the database schema and
-        // the disk file. The table can not be recovered.
-        // All indices and triggers associated with the table are also deleted.
-        // https://sqlite.org/lang_droptable.html
-        .map((table) => `drop table "${table.name}";`)
-        .join("");
-    yield* _(sqlite.exec({ sql }));
+export const upsertValueIntoTableRowColumn = (message, messages, millis) => Sqlite.pipe(Effect.map((sqlite) => {
+    const now = cast(new Date(millis));
+    return sqlite.exec({
+        sql: `
+    insert into
+      "${message.table}" ("id", "${message.column}", "createdAt", "updatedAt")
+    values
+      (?, ?, ?, ?)
+    on conflict do update set
+      "${message.column}" = ?,
+      "updatedAt" = ?
+        `.trim(),
+        parameters: [message.row, message.value, now, now, message.value, now],
+    });
+}), Effect.flatMap((insert) => Effect.catchSomeDefect(insert, (error) => S.is(SqliteNoSuchTableOrColumnError)(error)
+    ? Option.some(
+    // If one message fails, we ensure schema for all messages.
+    ensureSchemaByNewMessages(messages).pipe(Effect.zipRight(insert)))
+    : Option.none())));
+const SqliteNoSuchTableOrColumnError = S.Struct({
+    message: S.Union(S.String.pipe(S.includes("no such table")), S.String.pipe(S.includes("no such column")), S.String.pipe(S.includes("has no column"))),
+});
+const ensureSchemaByNewMessages = (messages) => Effect.gen(function* () {
+    const tablesMap = new Map();
+    messages.forEach((message) => {
+        const table = tablesMap.get(message.table);
+        if (table == null) {
+            tablesMap.set(message.table, {
+                name: message.table,
+                columns: [message.column, "createdAt", "updatedAt"],
+            });
+            return;
+        }
+        if (table.columns.includes(message.column))
+            return;
+        tablesMap.set(message.table, {
+            name: message.table,
+            columns: table.columns.concat(message.column),
+        });
+    });
+    const tables = Arr.fromIterable(tablesMap.values());
+    yield* Effect.flatMap(getSchema, ensureSchema({ tables, indexes: [] }));
+});
+const writeTimestampAndMerkleTree = (timestamp, merkleTree) => Effect.flatMap(Sqlite, (sqlite) => sqlite.exec({
+    ...Sql.updateOwnerTimestampAndMerkleTree,
+    parameters: [
+        merkleTreeToString(merkleTree),
+        timestampToString(timestamp),
+    ],
+}));
+const dropAllTables = Effect.gen(function* () {
+    yield* Effect.logTrace("Db dropAllTables");
+    const sqlite = yield* Sqlite;
+    const schema = yield* getSchema;
+    yield* Effect.forEach(schema.tables, (table) => 
+    // The dropped table is completely removed from the database schema and
+    // the disk file. The table can not be recovered.
+    // All indices and triggers associated with the table are also deleted.
+    // https://sqlite.org/lang_droptable.html
+    sqlite.exec({ sql: `drop table "${table.name}"` }));
+});
+const forkSync = (messages = []) => SyncLock.pipe(Effect.flatMap((syncLock) => syncLock.tryAcquire), Effect.matchEffect({
+    onFailure: () => Effect.void,
+    onSuccess: () => syncLoop(messages),
+}), Effect.scoped, Effect.forkDaemon);
+const syncLoop = (messages = []) => Effect.gen(function* (_) {
+    const sqlite = yield* Sqlite;
+    const sync = yield* Sync;
+    const callbacks = yield* Callbacks;
+    const time = yield* Time;
+    const syncDataRef = yield* readTimestampAndMerkleTree.pipe(sqlite.transaction("shared"), Effect.map((a) => ({ ...a, messages })), Effect.flatMap(Ref.make));
+    callbacks.onSyncStateChange({ _tag: "SyncStateIsSyncing" });
+    yield* Ref.get(syncDataRef).pipe(Effect.flatMap(sync.sync), Effect.flatMap(handleSyncResult), Effect.repeat({
+        // TODO: Schedule.jittered(Schedule.exponential("10 millis"))
+        schedule: Schedule.recurs(50),
+        until: Option.match({
+            onNone: () => Effect.gen(function* () {
+                callbacks.onSyncStateChange({
+                    _tag: "SyncStateIsSynced",
+                    time: yield* time.now,
+                });
+                return true;
+            }),
+            onSome: (syncData) => Effect.gen(function* () {
+                yield* Ref.set(syncDataRef, syncData);
+                return false;
+            }),
+        }),
+    }), Effect.catchAllDefect((error) => 
+    // Db can run in a Web Worker, so we must ensure transferable error.
+    Effect.fail(makeUnexpectedError(ensureTransferableError(error)))), Effect.catchTag("SyncStateIsNotSynced", (state) => Effect.succeed(callbacks.onSyncStateChange(state))), Effect.catchAll((error) => Effect.succeed(callbacks.onError(error))));
 });
-export const RowsStore = Context.GenericTag("@services/RowsStore");
-export const RowsStoreLive = Layer.effect(RowsStore, makeStore(new Map()));
+const handleSyncResult = (result) => Effect.flatMap(Sqlite, (sqlite) => Effect.gen(function* (_) {
+    const { onReceive } = yield* Callbacks;
+    const current = yield* readTimestampAndMerkleTree;
+    const nextTimestamp = yield* Effect.reduce(result.messages, current.timestamp, (local, message) => receiveTimestamp({
+        local,
+        remote: unsafeTimestampFromString(message.timestamp),
+    }));
+    const nextMerkleTree = yield* applyMessages(current.merkleTree, result.messages);
+    if (result.messages.length > 0) {
+        yield* writeTimestampAndMerkleTree(nextTimestamp, nextMerkleTree);
+        onReceive();
+    }
+    return yield* diffMerkleTrees(result.merkleTree, nextMerkleTree).pipe(Effect.flatMap((diff) => sqlite.exec({
+        ...Sql.selectMessagesToSync,
+        parameters: [timestampToString(makeSyncTimestamp(diff))],
+    })), Effect.map(({ rows }) => ({
+        messages: rows,
+        merkleTree: nextMerkleTree,
+        timestamp: nextTimestamp,
+    })), Effect.option);
+}).pipe(sqlite.transaction("exclusive")));
+// We use queries as keys, hence JSON.stringify.
+export const serializeQuery = ({ sql, parameters = [], options, }) => {
+    const query = {
+        sql,
+        parameters: parameters.map((p) => Predicate.isUint8Array(p)
+            ? Arr.fromIterable(p)
+            : isJsonObjectOrArray(p)
+                ? { json: p }
+                : p),
+        ...(options && { options }),
+    };
+    return JSON.stringify(query);
+};
+export const deserializeQuery = (query) => {
+    const serializedSqliteQuery = JSON.parse(query);
+    return {
+        ...serializedSqliteQuery,
+        parameters: serializedSqliteQuery.parameters.map((p) => Arr.isArray(p)
+            ? new Uint8Array(p)
+            : typeof p === "object" && p != null
+                ? p.json
+                : p),
+    };
+};
+// To preserve identity.
+const _emptyRows = [];
+export const emptyRows = () => _emptyRows;
+// To preserve identity.
+const queryResultCache = new WeakMap();
+export const queryResultFromRows = (rows) => {
+    let queryResult = queryResultCache.get(rows);
+    if (queryResult == null) {
+        queryResult = { rows, row: rows[0] };
+        queryResultCache.set(rows, queryResult);
+    }
+    return queryResult;
+};
+export const notSupportedPlatformWorker = {
+    init: () => Effect.fail({
+        _tag: "NotSupportedPlatformError",
+    }),
+    loadQueries: () => Effect.succeed([]),
+    mutate: () => Effect.succeed([]),
+    resetOwner: () => Effect.void,
+    restoreOwner: () => Effect.void,
+    ensureSchema: () => Effect.void,
+    sync: () => Effect.succeed([]),
+};

package/dist/src/Diff.d.ts

@@ -1,5 +1,4 @@
-import * as ReadonlyArray from "effect/ReadonlyArray";
-import { Query, Row } from "./Db.js";
+import type { Query, Row } from "./Db.js";
 import { Value } from "./Sqlite.js";
 export interface QueryPatches {
     readonly query: Query;
@@ -15,7 +14,14 @@ export interface ReplaceAtPatch {
     readonly index: number;
     readonly value: Row;
 }
-export declare const applyPatches: (patches: ReadonlyArray<Patch>) => (current: ReadonlyArray<Row>) => ReadonlyArray<Row>;
+export declare const applyPatches: (patches: ReadonlyArray<Patch>, current: ReadonlyArray<Row>) => ReadonlyArray<Row>;
+/**
+ * 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.
+ */
 export declare const makePatches: (previousRows: ReadonlyArray<Row> | undefined, nextRows: ReadonlyArray<Row>) => readonly Patch[];
 export declare const areEqual: (a: Value | Row | ReadonlyArray<Row>, b: Value | Row | ReadonlyArray<Row>) => boolean;
 //# sourceMappingURL=Diff.d.ts.map