@evolu/common 6.0.1-preview.19 → 6.0.1-preview.20

package/dist/src/Evolu/Db.js

@@ -1,450 +1,133 @@
 import { isNonEmptyArray } from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
 import { createSymmetricCrypto, } from "../Crypto.js";
-import { eqArrayNumber } from "../Eq.js";
-import { constFalse, exhaustiveCheck } from "../Function.js";
-import { objectToEntries } from "../Object.js";
 import { ok } from "../Result.js";
 import { createSqlite, explainSqliteQueryPlan, sql, } from "../Sqlite.js";
-import { array, object, String } from "../Type.js";
-import { createInitializedWorker, } from "../Worker.js";
+import { SimpleName } from "../Type.js";
+import { createInitializedWorkerWithHandlers, } from "../Worker.js";
 import { makePatches } from "./Diff.js";
-import { createAppOwner } from "./Owner.js";
-import { applyProtocolMessageAsClient, Base64Url256, binaryIdToId, binaryOwnerIdToOwnerId, createProtocolMessageForSync, createProtocolMessageFromCrdtMessages, decryptAndDecodeDbChange, encodeAndEncryptDbChange, idToBinaryId, ownerIdToBinaryOwnerId, protocolVersion, } from "./Protocol.js";
+import { createAppOwner, createOwnerSecret, mnemonicToOwnerSecret, } from "./Owner.js";
+import { protocolVersion } from "./Protocol.js";
 import { createQueryRowsCache, deserializeQuery, emptyRows, } from "./Query.js";
-import { createSqliteStorageBase, } from "./Storage.js";
-import { binaryTimestampToTimestamp, createInitialTimestamp, receiveTimestamp, sendTimestamp, timestampStringToTimestamp, timestampToBinaryTimestamp, timestampToTimestampString, } from "./Timestamp.js";
-export const DbTable = object({
-    name: Base64Url256,
-    columns: array(Base64Url256),
-});
-export const DbIndex = object({ name: String, sql: String });
-export const DbSchema = object({
-    tables: array(DbTable),
-    indexes: array(DbIndex),
-});
-const createClock = (deps) => (initialTimestamp = createInitialTimestamp(deps)) => {
-    let currentTimestamp = initialTimestamp;
-    return {
-        get: () => currentTimestamp,
-        save: (timestamp) => {
-            currentTimestamp = timestamp;
-            const timestampString = timestampToTimestampString(timestamp);
-            const saveTimestamp = deps.sqlite.exec(sql.prepared `
-          update evolu_config set "clock" = ${timestampString};
-        `);
-            if (!saveTimestamp.ok)
-                return saveTimestamp;
-            return ok();
-        },
-    };
-};
-export const createDbWorkerForPlatform = (platformDeps) => {
-    const tabQueryRowsCacheMap = new Map();
-    const getQueryRowsCache = (tabId) => {
-        let cache = tabQueryRowsCacheMap.get(tabId);
-        if (!cache) {
-            cache = createQueryRowsCache();
-            tabQueryRowsCacheMap.set(tabId, cache);
-        }
-        return cache;
-    };
-    return createInitializedWorker({
-        init: async (initMessage, postMessage, safeHandler) => {
-            platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
-            const sqliteResult = await createSqlite(platformDeps)(initMessage.config.name, { memory: initMessage.config.inMemory ?? false });
-            if (!sqliteResult.ok) {
-                postMessage({ type: "onError", error: sqliteResult.error });
-                return null;
-            }
-            const sqlite = sqliteResult.value;
-            const platformDepsWithSqlite = { ...platformDeps, sqlite };
-            const deps = sqlite.transaction(() => {
-                const currentDbSchema = getDbSchema({ sqlite })();
-                if (!currentDbSchema.ok)
-                    return currentDbSchema;
-                let appOwner;
-                let clock;
-                const dbIsInitialized = currentDbSchema.value.tables.some((table) => table.name === "evolu_version");
-                if (dbIsInitialized) {
-                    const versionResult = sqlite.exec(sql `select protocolVersion from evolu_version limit 1;`);
-                    if (!versionResult.ok)
-                        return versionResult;
-                    // TODO: Handle version migrations here if needed
-                    // const [{ protocolVersion }] = protocolVersionResult.value.rows;
-                    // if (protocolVersion < currentProtocolVersion) {
-                    //   const migrateResult = migrateDatabase({ sqlite })(
-                    //     protocolVersion,
-                    //     currentProtocolVersion
-                    //   );
-                    //   if (!migrateResult.ok) return migrateResult;
-                    // }
-                    const configResult = sqlite.exec(sql `
-            select
-              clock,
-              appOwnerId,
-              appOwnerEncryptionKey,
-              appOwnerWriteKey,
-              appOwnerMnemonic
-            from evolu_config
-            limit 1;
-          `);
-                    if (!configResult.ok)
-                        return configResult;
-                    const [config] = configResult.value.rows;
-                    appOwner = {
-                        type: "AppOwner",
-                        id: config.appOwnerId,
-                        encryptionKey: config.appOwnerEncryptionKey,
-                        writeKey: config.appOwnerWriteKey,
-                        mnemonic: config.appOwnerMnemonic,
-                    };
-                    clock = createClock(platformDepsWithSqlite)(timestampStringToTimestamp(config.clock));
-                }
-                else {
-                    appOwner =
-                        initMessage.config.initialAppOwner ??
-                            createAppOwner(platformDeps.createMnemonic());
-                    clock = createClock(platformDepsWithSqlite)();
-                    const initializeDbResult = initializeDb(platformDepsWithSqlite)(appOwner, clock);
-                    if (!initializeDbResult.ok)
-                        return initializeDbResult;
-                }
-                const ensureDbSchemaResult = ensureDbSchema({ sqlite })(initMessage.dbSchema, currentDbSchema.value);
-                if (!ensureDbSchemaResult.ok)
-                    return ensureDbSchemaResult;
-                const owners = new Map();
-                owners.set(appOwner.id, appOwner);
-                const depsWithoutSyncAndStorage = {
-                    ...platformDeps,
-                    postMessage,
-                    sqlite,
-                    timestampConfig: initMessage.config,
-                    symmetricCrypto: createSymmetricCrypto(platformDeps),
-                    getQueryRowsCache,
-                    clock,
-                    owners,
-                };
-                const storage = createClientStorage(depsWithoutSyncAndStorage)({
-                    onStorageError: (error) => {
-                        postMessage({ type: "onError", error });
-                    },
-                });
-                if (!storage.ok)
-                    return storage;
-                const depsWithoutSync = {
-                    ...depsWithoutSyncAndStorage,
-                    storage: storage.value,
-                };
-                postMessage({
-                    type: "onInit",
-                    appOwner,
-                    isFirst: !dbIsInitialized,
-                });
-                const sync = platformDeps.createSync(platformDeps)({
-                    ...initMessage.config,
-                    onOpen: safeHandler(handleSyncOpen(depsWithoutSync)),
-                    onMessage: safeHandler(createHandleSyncMessage(depsWithoutSync)),
-                });
-                return ok({ ...depsWithoutSync, sync });
-            });
-            if (!deps.ok) {
-                postMessage({ type: "onError", error: deps.error });
-                return null;
-            }
-            return deps.value;
-        },
-        onMessage: (deps) => (message) => {
-            switch (message.type) {
-                case "mutate": {
-                    const mutate = deps.sqlite.transaction(() => {
-                        const toSyncChanges = [];
-                        const localOnlyChanges = [];
-                        for (const change of message.changes) {
-                            // Table name starting with '_' is local-only (not synced).
-                            if (change.table.startsWith("_"))
-                                localOnlyChanges.push(change);
-                            else
-                                toSyncChanges.push(change);
-                        }
-                        for (const change of localOnlyChanges) {
-                            if ("isDeleted" in change.values &&
-                                change.values.isDeleted === 1) {
-                                const result = deps.sqlite.exec(sql `
-                  delete from ${sql.identifier(change.table)}
-                  where id = ${change.id};
-                `);
-                                if (!result.ok)
-                                    return result;
-                            }
-                            else {
-                                const date = new Date(deps.time.now()).toISOString();
-                                for (const [column, value] of objectToEntries(change.values)) {
-                                    const result = deps.sqlite.exec(sql.prepared `
-                    insert into ${sql.identifier(change.table)}
-                      ("id", ${sql.identifier(column)}, createdAt, updatedAt)
-                    values (${change.id}, ${value}, ${date}, ${date})
-                    on conflict ("id") do update
-                      set
-                        ${sql.identifier(column)} = ${value},
-                        updatedAt = ${date};
-                  `);
-                                    if (!result.ok)
-                                        return result;
-                                }
-                            }
-                        }
-                        /**
-                         * We don't have to wait for the transaction to end because changes
-                         * are idempotent, so there is no reason why they should fail. We
-                         * want to call onChange ASAP.
-                         */
-                        const onChange = () => {
-                            deps.console.log("[db]", "onChange", {
-                                subscribedQueries: message.subscribedQueries,
-                            });
-                            const patches = loadQueries(deps)(message.tabId, message.subscribedQueries);
-                            if (!patches.ok) {
-                                deps.postMessage({ type: "onError", error: patches.error });
-                                return;
-                            }
-                            // Notify the tab that performed the mutation.
-                            deps.postMessage({
-                                type: "onChange",
-                                tabId: message.tabId,
-                                patches: patches.value,
-                                onCompleteIds: message.onCompleteIds,
-                            });
-                            // Notify other tabs to refresh their queries.
-                            deps.postMessage({ type: "onReceive", tabId: message.tabId });
-                        };
-                        if (!isNonEmptyArray(toSyncChanges)) {
-                            onChange();
-                            return ok();
-                        }
-                        const messages = applyChanges(deps)(toSyncChanges, onChange);
-                        if (!messages.ok)
-                            return messages;
-                        // TODO: Use owner from db change or AppOwner
-                        const owner = Array.from(deps.owners.values())[0];
-                        const protocolMessage = createProtocolMessageFromCrdtMessages(deps)(owner, messages.value);
-                        deps.console.log("[db]", "send data message", messages.value, protocolMessage);
-                        deps.sync.send(protocolMessage);
-                        return ok();
-                    });
-                    if (!mutate.ok) {
-                        deps.postMessage({ type: "onError", error: mutate.error });
-                        return;
-                    }
-                    break;
-                }
-                case "query": {
-                    const patches = loadQueries(deps)(message.tabId, message.queries);
-                    if (!patches.ok) {
-                        deps.postMessage({ type: "onError", error: patches.error });
-                        return;
-                    }
-                    deps.postMessage({
-                        type: "onChange",
-                        tabId: message.tabId,
-                        patches: patches.value,
-                        onCompleteIds: [],
-                    });
-                    break;
-                }
-                case "reset": {
-                    const resetResult = deps.sqlite.transaction(() => {
-                        const dropAllTablesResult = dropAllTables(deps);
-                        if (!dropAllTablesResult.ok)
-                            return dropAllTablesResult;
-                        if (message.restore) {
-                            const dbSchema = getDbSchema(deps)();
-                            if (!dbSchema.ok)
-                                return dbSchema;
-                            const ensureDbSchemaResult = ensureDbSchema(deps)(message.restore.dbSchema, dbSchema.value);
-                            if (!ensureDbSchemaResult.ok)
-                                return ensureDbSchemaResult;
-                            const appOwner = createAppOwner(message.restore.mnemonic);
-                            const clock = createClock(deps)();
-                            const initializeDbResult = initializeDb(deps)(appOwner, clock);
-                            if (!initializeDbResult.ok)
-                                return initializeDbResult;
-                        }
-                        return ok();
-                    });
-                    if (!resetResult.ok) {
-                        deps.postMessage({ type: "onError", error: resetResult.error });
-                        return;
-                    }
-                    deps.postMessage({
-                        type: "onReset",
-                        onCompleteId: message.onCompleteId,
-                        reload: message.reload,
-                    });
-                    break;
-                }
-                case "ensureDbSchema": {
-                    const ensureSchema = deps.sqlite.transaction(() => {
-                        const dbSchema = getDbSchema(deps)();
-                        if (!dbSchema.ok)
-                            return dbSchema;
-                        const ensureDbSchemaResult = ensureDbSchema(deps)(message.dbSchema, dbSchema.value);
-                        if (!ensureDbSchemaResult.ok)
-                            return ensureDbSchemaResult;
-                        return ok();
-                    });
-                    if (!ensureSchema.ok) {
-                        deps.postMessage({ type: "onError", error: ensureSchema.error });
-                        return;
-                    }
-                    break;
-                }
-                case "export": {
-                    const file = deps.sqlite.export();
-                    if (!file.ok) {
-                        deps.postMessage({ type: "onError", error: file.error });
-                        return;
-                    }
-                    deps.postMessage({
-                        type: "onExport",
-                        onCompleteId: message.onCompleteId,
-                        file: file.value,
-                    });
-                    break;
-                }
-                default:
-                    exhaustiveCheck(message);
-            }
-        },
-    });
+import { ensureDbSchema, getDbSchema, } from "./Schema.js";
+import { applyLocalOnlyChange, createClock, createSync, } from "./Sync.js";
+import { timestampStringToTimestamp, timestampToTimestampString, } from "./Timestamp.js";
+export const defaultDbConfig = {
+    name: SimpleName.orThrow("Evolu"),
+    transports: [{ type: "WebSocket", url: "wss://free.evoluhq.com" }],
+    maxDrift: 5 * 60 * 1000,
+    enableLogging: false,
 };
-/**
- * Get the current database schema by reading SQLite metadata.
- *
- * TODO: Refactor out Evolu stuff and move it to Sqlite.
- */
-export const getDbSchema = (deps) => ({ allIndexes = false } = {}) => {
-    const map = new Map();
-    const tableAndColumnInfoRows = deps.sqlite.exec(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;
-    `);
-    if (!tableAndColumnInfoRows.ok)
-        return tableAndColumnInfoRows;
-    tableAndColumnInfoRows.value.rows.forEach((row) => {
-        const { tableName, columnName } = row;
-        if (!map.has(tableName))
-            map.set(tableName, []);
-        map.get(tableName)?.push(columnName);
+export const createDbWorkerForPlatform = (platformDeps) => createInitializedWorkerWithHandlers({ init: createDbWorkerDeps(platformDeps), handlers });
+const createDbWorkerDeps = (platformDeps) => async (initMessage, postMessage) => {
+    platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
+    const sqliteResult = await createSqlite(platformDeps)(initMessage.config.name, {
+        memory: initMessage.config.inMemory ?? false,
+        encryptionKey: initMessage.config.encryptionKey ?? undefined,
     });
-    const tables = Array.from(map, ([name, columns]) => ({ name, columns }));
-    const indexesRows = deps.sqlite.exec(allIndexes
-        ? sql `
-            select name, sql
-            from sqlite_master
-            where type = 'index' and name not like 'sqlite_%';
-          `
-        : sql `
-            select name, sql
-            from sqlite_master
-            where
-              type = 'index'
-              and name not like 'sqlite_%'
-              and name not like 'evolu_%';
-          `);
-    if (!indexesRows.ok)
-        return indexesRows;
-    const indexes = indexesRows.value.rows.map((row) => ({
-        name: row.name,
-        /**
-         * SQLite returns "CREATE INDEX" for "create index" for some reason.
-         * Other keywords remain unchanged. We have to normalize the casing for
-         * {@link indexesAreEqual} manually.
-         */
-        sql: row.sql
-            .replace("CREATE INDEX", "create index")
-            .replace("CREATE UNIQUE INDEX", "create unique index"),
-    }));
-    return ok({ tables, indexes });
-};
-const indexesAreEqual = (self, that) => self.name === that.name && self.sql === that.sql;
-// TODO: Move to test helpers.
-export const getDbSnapshot = (deps) => {
-    const schema = getDbSchema(deps)({ allIndexes: true });
-    assert(schema.ok, "bug");
-    const tables = [];
-    for (const table of schema.value.tables) {
-        const result = deps.sqlite.exec(sql `
-      select * from ${sql.identifier(table.name)};
-    `);
-        assert(result.ok, "bug");
-        tables.push({
-            name: table.name,
-            rows: result.value.rows,
-        });
+    if (!sqliteResult.ok) {
+        postMessage({ type: "onError", error: sqliteResult.error });
+        return null;
     }
-    return { schema: schema.value, tables };
-};
-const ensureDbSchema = (deps) => (newSchema, currentSchema, options) => {
-    const queries = [];
-    newSchema.tables.forEach((newTable) => {
-        const currentTable = currentSchema.tables.find((t) => t.name === newTable.name);
-        if (!currentTable) {
-            queries.push({
-                sql: createAppTable(newTable.name, newTable.columns),
-                parameters: [],
-            });
+    const sqlite = sqliteResult.value;
+    const deps = sqlite.transaction(() => {
+        const currentDbSchema = getDbSchema({ sqlite })();
+        if (!currentDbSchema.ok)
+            return currentDbSchema;
+        let appOwner;
+        let clock;
+        const dbIsInitialized = currentDbSchema.value.tables.some((table) => table.name === "evolu_version");
+        if (dbIsInitialized) {
+            const currentVersion = sqlite.exec(sql `select protocolVersion from evolu_version limit 1;`);
+            if (!currentVersion.ok)
+                return currentVersion;
+            // TODO: Handle version migrations here if needed
+            // const [{ protocolVersion }] = protocolVersionResult.value.rows;
+            // if (protocolVersion < currentProtocolVersion) {
+            //   const migrateResult = migrateDatabase({ sqlite })(
+            //     protocolVersion,
+            //     currentProtocolVersion
+            //   );
+            //   if (!migrateResult.ok) return migrateResult;
+            // }
+            const configResult = sqlite.exec(sql `
+          select
+            clock,
+            appOwnerId,
+            appOwnerEncryptionKey,
+            appOwnerWriteKey,
+            appOwnerMnemonic
+          from evolu_config
+          limit 1;
+        `);
+            if (!configResult.ok)
+                return configResult;
+            const [config] = configResult.value.rows;
+            appOwner = {
+                type: "AppOwner",
+                id: config.appOwnerId,
+                encryptionKey: config.appOwnerEncryptionKey,
+                writeKey: config.appOwnerWriteKey,
+                mnemonic: config.appOwnerMnemonic,
+            };
+            clock = createClock({ ...platformDeps, sqlite })(timestampStringToTimestamp(config.clock));
         }
         else {
-            newTable.columns
-                .filter((newColumn) => !currentTable.columns.includes(newColumn))
-                .forEach((newColumn) => {
-                queries.push(sql `
-              alter table ${sql.identifier(newTable.name)}
-              add column ${sql.identifier(newColumn)} blob;
-            `);
-            });
+            appOwner =
+                initMessage.config.externalAppOwner ??
+                    createAppOwner(createOwnerSecret(platformDeps));
+            clock = createClock({ ...platformDeps, sqlite })();
+            const result = initializeDb({ sqlite })(appOwner, clock.get());
+            if (!result.ok)
+                return result;
         }
-    });
-    if (options?.ignoreIndexes !== true) {
-        // Remove current indexes that are not in the newSchema.
-        currentSchema.indexes
-            .filter((currentIndex) => !newSchema.indexes.some((newIndex) => indexesAreEqual(newIndex, currentIndex)))
-            .forEach((index) => {
-            queries.push(sql `drop index ${sql.identifier(index.name)};`);
-        });
-        // Add new indexes that are not in the currentSchema.
-        newSchema.indexes
-            .filter((newIndex) => !currentSchema.indexes.some((currentIndex) => indexesAreEqual(newIndex, currentIndex)))
-            .forEach((newIndex) => {
-            queries.push({ sql: `${newIndex.sql};`, parameters: [] });
-        });
-    }
-    for (const query of queries) {
-        const result = deps.sqlite.exec(query);
+        const result = ensureDbSchema({ sqlite })(initMessage.dbSchema, currentDbSchema.value);
         if (!result.ok)
             return result;
+        const sync = createSync({
+            ...platformDeps,
+            clock,
+            sqlite,
+            symmetricCrypto: createSymmetricCrypto(platformDeps),
+            timestampConfig: initMessage.config,
+            postMessage,
+        })({
+            appOwner,
+            transports: initMessage.config.transports,
+            onError: (error) => {
+                postMessage({ type: "onError", error });
+            },
+            onReceive: () => {
+                postMessage({ type: "refreshQueries" });
+            },
+        });
+        if (!sync.ok)
+            return sync;
+        sync.value.useOwner(true, appOwner);
+        const tabQueryRowsCacheMap = new Map();
+        const getQueryRowsCache = (tabId) => {
+            let cache = tabQueryRowsCacheMap.get(tabId);
+            if (!cache) {
+                cache = createQueryRowsCache();
+                tabQueryRowsCacheMap.set(tabId, cache);
+            }
+            return cache;
+        };
+        const deps = {
+            ...platformDeps,
+            getQueryRowsCache,
+            postMessage,
+            sqlite,
+            sync: sync.value,
+            appOwner,
+        };
+        return ok(deps);
+    });
+    if (!deps.ok) {
+        postMessage({ type: "onError", error: deps.error });
+        return null;
     }
-    return ok();
+    return deps.value;
 };
-export const createAppTable = (tableName, columns) => `
-    create table ${sql.identifier(tableName).sql} (
-      "id" text primary key,
-      ${columns
-    // Add default columns.
-    .concat(["createdAt", "updatedAt", "isDeleted"])
-    .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) => `${sql.identifier(name).sql} blob`)
-    .join(", ")}
-    );
-  `;
 const initializeDb = (deps) => (initialAppOwner, initialClock) => {
     for (const query of [
         // Never change structure to ensure all versions can read it.
@@ -479,7 +162,7 @@ const initializeDb = (deps) => (initialAppOwner, initialClock) => {
           )
         values
           (
-            ${timestampToTimestampString(initialClock.get())},
+            ${timestampToTimestampString(initialClock)},
             ${initialAppOwner.id},
             ${initialAppOwner.encryptionKey},
             ${initialAppOwner.writeKey},
@@ -528,97 +211,139 @@ const initializeDb = (deps) => (initialAppOwner, initialClock) => {
     }
     return ok();
 };
-const applyChanges = (deps) => (changes, onChange) => {
-    let clockTimestamp = deps.clock.get();
-    const messages = [];
-    for (const change of changes) {
-        const nextTimestamp = sendTimestamp(deps)(clockTimestamp);
-        if (!nextTimestamp.ok)
-            return nextTimestamp;
-        clockTimestamp = nextTimestamp.value;
-        messages.push({ timestamp: clockTimestamp, change });
-    }
-    const apply = applyMessages(deps)(messages, clockTimestamp);
-    if (!apply.ok)
-        return apply;
-    if (onChange)
-        onChange();
-    assertNonEmptyReadonlyArray(messages);
-    return ok(messages);
-};
-const applyMessages = (deps) => (messages, clockTimestamp) => {
-    const ownerId = ownerIdToBinaryOwnerId(Array.from(deps.owners.values())[0].id);
-    for (const message of messages) {
-        const result1 = applyMessageToAppTable(deps)(ownerId, message);
-        if (!result1.ok)
-            return result1;
-        const result2 = applyMessageToTimestampAndHistoryTables(deps)(ownerId, message);
-        if (!result2.ok)
-            return result2;
-    }
-    return deps.clock.save(clockTimestamp);
-};
-const applyMessageToAppTable = (deps) => (ownerId, message) => {
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    const updatedAt = new Date(message.timestamp.millis).toISOString();
-    for (const [column, value] of objectToEntries(message.change.values)) {
-        const result = deps.sqlite.exec(sql.prepared `
-        with
-          lastTimestamp as (
-            select "timestamp"
-            from evolu_history
-            where
-              "ownerId" = ${ownerId}
-              and "table" = ${message.change.table}
-              and "id" = ${message.change.id}
-              and "column" = ${column}
-            order by "timestamp" desc
-            limit 1
-          )
-        insert into ${sql.identifier(message.change.table)}
-          ("id", ${sql.identifier(column)}, updatedAt)
-        select ${message.change.id}, ${value}, ${updatedAt}
-        where
-          (select "timestamp" from lastTimestamp) is null
-          or (select "timestamp" from lastTimestamp) < ${timestamp}
-        on conflict ("id") do update
-          set
-            ${sql.identifier(column)} = ${value},
-            updatedAt = ${updatedAt}
-          where
-            (select "timestamp" from lastTimestamp) is null
-            or (select "timestamp" from lastTimestamp) < ${timestamp};
-      `);
-        if (!result.ok)
-            return result;
-    }
-    return ok();
-};
-export const applyMessageToTimestampAndHistoryTables = (deps) => (ownerId, message) => {
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    const id = idToBinaryId(message.change.id);
-    const result = deps.storage.insertTimestamp(ownerId, timestamp);
-    if (!result.ok)
-        return result;
-    for (const [column, value] of Object.entries(message.change.values)) {
-        const result = deps.sqlite.exec(sql.prepared `
-        insert into evolu_history
-          ("ownerId", "table", "id", "column", "value", "timestamp")
-        values
-          (
-            ${ownerId},
-            ${message.change.table},
-            ${id},
-            ${column},
-            ${value},
-            ${timestamp}
-          )
-        on conflict do nothing;
-      `);
-        if (!result.ok)
-            return result;
-    }
-    return ok();
+const handlers = {
+    getAppOwner: (deps) => () => {
+        deps.postMessage({
+            type: "onGetAppOwner",
+            appOwner: deps.appOwner,
+        });
+    },
+    mutate: (deps) => (message) => {
+        const mutate = deps.sqlite.transaction(() => {
+            const syncChanges = [];
+            for (const change of message.changes) {
+                const isLocalOnlyChange = change.table.startsWith("_");
+                if (isLocalOnlyChange) {
+                    const result = applyLocalOnlyChange(deps)(change);
+                    if (!result.ok)
+                        return result;
+                }
+                else {
+                    syncChanges.push(change);
+                }
+            }
+            if (isNonEmptyArray(syncChanges)) {
+                const result = deps.sync.applyChanges(syncChanges);
+                if (!result.ok)
+                    return result;
+            }
+            // Read writes before commit to update UI ASAP
+            const queryPatches = loadQueries(deps)(message.tabId, message.subscribedQueries);
+            if (!queryPatches.ok)
+                return queryPatches;
+            // Update the tab that performed the mutation.
+            deps.postMessage({
+                type: "onQueryPatches",
+                tabId: message.tabId,
+                queryPatches: queryPatches.value,
+                onCompleteIds: message.onCompleteIds,
+            });
+            // Notify other tabs to refresh their queries.
+            deps.postMessage({ type: "refreshQueries", tabId: message.tabId });
+            return ok();
+        });
+        if (!mutate.ok) {
+            deps.postMessage({ type: "onError", error: mutate.error });
+            return;
+        }
+    },
+    query: (deps) => (message) => {
+        const queryPatches = loadQueries(deps)(message.tabId, message.queries);
+        if (!queryPatches.ok) {
+            deps.postMessage({ type: "onError", error: queryPatches.error });
+            return;
+        }
+        deps.postMessage({
+            type: "onQueryPatches",
+            tabId: message.tabId,
+            queryPatches: queryPatches.value,
+            onCompleteIds: [],
+        });
+    },
+    reset: (deps) => (message) => {
+        const resetResult = deps.sqlite.transaction(() => {
+            const dbSchema = getDbSchema(deps)();
+            if (!dbSchema.ok)
+                return dbSchema;
+            for (const table of dbSchema.value.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
+                 */
+                const result = deps.sqlite.exec(sql `
+          drop table ${sql.identifier(table.name)};
+        `);
+                if (!result.ok)
+                    return result;
+            }
+            if (message.restore) {
+                const dbSchema = getDbSchema(deps)();
+                if (!dbSchema.ok)
+                    return dbSchema;
+                const ensureDbSchemaResult = ensureDbSchema(deps)(message.restore.dbSchema, dbSchema.value);
+                if (!ensureDbSchemaResult.ok)
+                    return ensureDbSchemaResult;
+                const secret = mnemonicToOwnerSecret(message.restore.mnemonic);
+                const appOwner = createAppOwner(secret);
+                const clock = createClock(deps)();
+                const initializeDbResult = initializeDb(deps)(appOwner, clock.get());
+                if (!initializeDbResult.ok)
+                    return initializeDbResult;
+            }
+            return ok();
+        });
+        if (!resetResult.ok) {
+            deps.postMessage({ type: "onError", error: resetResult.error });
+            return;
+        }
+        deps.postMessage({
+            type: "onReset",
+            onCompleteId: message.onCompleteId,
+            reload: message.reload,
+        });
+    },
+    ensureDbSchema: (deps) => (message) => {
+        const ensureSchema = deps.sqlite.transaction(() => {
+            const dbSchema = getDbSchema(deps)();
+            if (!dbSchema.ok)
+                return dbSchema;
+            const ensureDbSchemaResult = ensureDbSchema(deps)(message.dbSchema, dbSchema.value);
+            if (!ensureDbSchemaResult.ok)
+                return ensureDbSchemaResult;
+            return ok();
+        });
+        if (!ensureSchema.ok) {
+            deps.postMessage({ type: "onError", error: ensureSchema.error });
+            return;
+        }
+    },
+    export: (deps) => (message) => {
+        const file = deps.sqlite.export();
+        if (!file.ok) {
+            deps.postMessage({ type: "onError", error: file.error });
+            return;
+        }
+        deps.postMessage({
+            type: "onExport",
+            onCompleteId: message.onCompleteId,
+            file: file.value,
+        });
+    },
+    useOwner: (deps) => (message) => {
+        deps.sync.useOwner(message.use, message.owner);
+    },
 };
 const loadQueries = (deps) => (tabId, queries) => {
     const queriesRows = [];
@@ -642,125 +367,3 @@ const loadQueries = (deps) => (tabId, queries) => {
     }));
     return ok(queryPatchesArray);
 };
-const dropAllTables = (deps) => {
-    const schema = getDbSchema(deps)();
-    if (!schema.ok)
-        return schema;
-    for (const table of schema.value.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
-         */
-        const result = deps.sqlite.exec(sql `
-      drop table ${sql.identifier(table.name)};
-    `);
-        if (!result.ok)
-            return result;
-    }
-    return ok();
-};
-const handleSyncOpen = (deps) => (send) => {
-    for (const [id] of deps.owners) {
-        const message = createProtocolMessageForSync(deps)(id);
-        if (!message)
-            return;
-        deps.console.log("[db]", "send initial sync message", message);
-        send(message);
-    }
-};
-const createHandleSyncMessage = (deps) => (input, send) => {
-    deps.console.log("[db]", "receive sync message", input);
-    const output = deps.sqlite.transaction(() => applyProtocolMessageAsClient(deps)(input, {
-        getWriteKey: (ownerId) => deps.owners.get(ownerId)?.writeKey ?? null,
-    }));
-    if (!output.ok) {
-        deps.postMessage({ type: "onError", error: output.error });
-        return;
-    }
-    if (output.value) {
-        deps.console.log("[db]", "respond sync message", output.value);
-        send(output.value);
-    }
-};
-const createClientStorage = (deps) => (options) => {
-    const sqliteStorageBase = createSqliteStorageBase(deps)(options);
-    if (!sqliteStorageBase.ok)
-        return sqliteStorageBase;
-    const storage = {
-        ...sqliteStorageBase.value,
-        validateWriteKey: constFalse,
-        setWriteKey: constFalse,
-        writeMessages: (ownerId, messages) => {
-            const owner = deps.owners.get(binaryOwnerIdToOwnerId(ownerId));
-            assert(owner, "Missing owner");
-            const decodedAndDecryptedMessages = [];
-            for (const message of messages) {
-                const dbChange = decryptAndDecodeDbChange(deps)(message, owner.encryptionKey);
-                if (!dbChange.ok) {
-                    deps.postMessage({
-                        type: "onError",
-                        error: dbChange.error,
-                    });
-                    return false;
-                }
-                decodedAndDecryptedMessages.push({
-                    timestamp: message.timestamp,
-                    change: dbChange.value,
-                });
-            }
-            let clockTimestamp = deps.clock.get();
-            for (const message of messages) {
-                const receive = receiveTimestamp(deps)(clockTimestamp, message.timestamp);
-                if (!receive.ok) {
-                    deps.postMessage({ type: "onError", error: receive.error });
-                    return false;
-                }
-                clockTimestamp = receive.value;
-            }
-            const applyMessagesResult = applyMessages({ ...deps, storage })(decodedAndDecryptedMessages, clockTimestamp);
-            if (!applyMessagesResult.ok) {
-                deps.postMessage({
-                    type: "onError",
-                    error: applyMessagesResult.error,
-                });
-                return false;
-            }
-            deps.postMessage({ type: "onReceive" });
-            return true;
-        },
-        readDbChange: (ownerId, timestamp) => {
-            const owner = deps.owners.get(binaryOwnerIdToOwnerId(ownerId));
-            assert(owner, "Missing owner");
-            const result = deps.sqlite.exec(sql `
-          select "table", "id", "column", "value"
-          from evolu_history
-          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
-        `);
-            if (!result.ok) {
-                deps.postMessage({ type: "onError", error: result.error });
-                return null;
-            }
-            const { rows } = result.value;
-            assert(rows.length > 0, "Rows must not be empty");
-            const { table, id } = rows[0];
-            const values = {};
-            for (const r of rows) {
-                assert(r.table === table, "All rows must have the same table");
-                assert(eqArrayNumber(r.id, id), "All rows must have the same Id");
-                values[r.column] = r.value;
-            }
-            const message = {
-                timestamp: binaryTimestampToTimestamp(timestamp),
-                change: {
-                    table: rows[0].table,
-                    id: binaryIdToId(rows[0].id),
-                    values,
-                },
-            };
-            return encodeAndEncryptDbChange(deps)(message, owner.encryptionKey);
-        },
-    };
-    return ok(storage);
-};