@evolu/common 6.0.1-preview.8 → 7.0.0

package/dist/src/Evolu/Db.js

@@ -1,442 +1,174 @@
-import { isNonEmptyArray, isNonEmptyReadonlyArray, } from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
+import { isNonEmptyArray } from "../Array.js";
 import { createSymmetricCrypto, } from "../Crypto.js";
-import { eqArrayNumber } from "../Eq.js";
-import { constFalse, exhaustiveCheck } from "../Function.js";
-import { objectToEntries } from "../Object.js";
-import { createRef } from "../Ref.js";
-import { err, ok } from "../Result.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, createOwnerRow, } from "./Owner.js";
-import { applyProtocolMessageAsClient, Base64Url256, binaryIdToId, 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 { Millis, 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),
-});
-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);
-            if (!sqliteResult.ok) {
-                postMessage({ type: "onError", error: sqliteResult.error });
-                return null;
-            }
-            const sqlite = sqliteResult.value;
-            const deps = sqlite.transaction(() => {
-                const currentDbSchema = getDbSchema({ sqlite })();
-                if (!currentDbSchema.ok)
-                    return currentDbSchema;
-                const ensureDbSchemaResult = ensureDbSchema({ sqlite })(initMessage.dbSchema, currentDbSchema.value);
-                if (!ensureDbSchemaResult.ok)
-                    return ensureDbSchemaResult;
-                const maybeMigrateToVersion0Result = maybeMigrateToVersion0({ sqlite })(currentDbSchema.value);
-                if (!maybeMigrateToVersion0Result.ok)
-                    return maybeMigrateToVersion0Result;
-                const ownerExists = currentDbSchema.value.tables.some((table) => table.name === "evolu_owner");
-                const appOwnerAndOwnerRow = ownerExists
-                    ? selectAppOwner({ sqlite })
-                    : initializeDb({ ...platformDeps, sqlite })(maybeMigrateToVersion0Result.value?.mnemonic ??
-                        initMessage.config.mnemonic);
-                if (!appOwnerAndOwnerRow.ok)
-                    return appOwnerAndOwnerRow;
-                const [appOwner, ownerRow] = appOwnerAndOwnerRow.value;
-                const depsWithoutSyncAndStorage = {
-                    ...platformDeps,
-                    postMessage,
-                    sqlite,
-                    timestampConfig: initMessage.config,
-                    symmetricCrypto: createSymmetricCrypto(platformDeps),
-                    getQueryRowsCache,
-                    ownerRowRef: createRef(ownerRow),
-                };
-                const storage = createClientStorage(depsWithoutSyncAndStorage)({
-                    onStorageError: (error) => {
-                        postMessage({ type: "onError", error });
-                    },
-                });
-                if (!storage.ok)
-                    return storage;
-                const depsWithoutSync = {
-                    ...depsWithoutSyncAndStorage,
-                    storage: storage.value,
-                };
-                if (maybeMigrateToVersion0Result.value) {
-                    const result = applyMessages(depsWithoutSync)(maybeMigrateToVersion0Result.value.messages, maybeMigrateToVersion0Result.value.lastTimestamp);
-                    if (!result.ok)
-                        return result;
-                }
-                if (!ownerExists && isNonEmptyReadonlyArray(initMessage.initialData)) {
-                    const result = applyChanges(depsWithoutSync)(initMessage.initialData);
-                    if (!result.ok)
-                        return result;
-                }
-                postMessage({ type: "onInit", owner: appOwner });
-                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 millis = Millis.from(deps.time.now());
-                                if (!millis.ok) {
-                                    return err({
-                                        type: "TimestampTimeOutOfRangeError",
-                                    });
-                                }
-                                const date = new Date(millis.value).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;
-                        const owner = deps.ownerRowRef.get();
-                        // TODO: Check owner whether it's allowed to write, return an
-                        // error if not.
-                        if (owner.writeKey == null) {
-                            return ok();
-                        }
-                        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 initializeDbResult = initializeDb(deps)(message.restore.mnemonic);
-                            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 { createBaseSqliteStorageTables } from "./Storage.js";
+import { applyLocalOnlyChange, createClock, createSync, } from "./Sync.js";
+import { timestampBytesToTimestamp, timestampToTimestampBytes, } 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 })(timestampBytesToTimestamp(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 selectAppOwner = (deps) => {
-    const result = deps.sqlite.exec(sql `
-    select mnemonic, id, createdAt, encryptionKey, writeKey, timestamp
-    from evolu_owner
-    order by createdAt asc
-    limit 1;
-  `);
-    if (!result.ok)
-        return result;
-    const { rows: [ownerRow], } = result.value;
-    assert(ownerRow.writeKey != null, "The writeKey is null");
-    const appOwner = {
-        type: "AppOwner",
-        mnemonic: ownerRow.mnemonic,
-        createdAt: ownerRow.createdAt,
-        id: ownerRow.id,
-        encryptionKey: ownerRow.encryptionKey,
-        writeKey: ownerRow.writeKey,
-    };
-    return ok([appOwner, ownerRow]);
-};
-const initializeDb = (deps) => (mnemonic) => {
+const initializeDb = (deps) => (initialAppOwner, initialClock) => {
     for (const query of [
+        // Never change structure to ensure all versions can read it.
+        sql `
+        create table evolu_version (
+          "protocolVersion" integer not null
+        )
+        strict;
+      `,
+        sql `
+        insert into evolu_version ("protocolVersion")
+        values (${protocolVersion});
+      `,
         sql `
         create table evolu_config (
-          "key" text not null primary key,
-          "value" any not null
+          "clock" blob not null,
+          "appOwnerId" text not null,
+          "appOwnerEncryptionKey" blob not null,
+          "appOwnerWriteKey" blob not null,
+          "appOwnerMnemonic" text
         )
         strict;
       `,
         sql `
-        insert into evolu_config ("key", "value")
-        values ('protocolVersion', ${protocolVersion});
+        insert into evolu_config
+          (
+            "clock",
+            "appOwnerId",
+            "appOwnerEncryptionKey",
+            "appOwnerWriteKey",
+            "appOwnerMnemonic"
+          )
+        values
+          (
+            ${timestampToTimestampBytes(initialClock)},
+            ${initialAppOwner.id},
+            ${initialAppOwner.encryptionKey},
+            ${initialAppOwner.writeKey},
+            ${initialAppOwner.mnemonic ?? null}
+          );
       `,
         /**
          * The History table stores all values per ownerId, timestamp, table, id,
@@ -473,146 +205,149 @@ const initializeDb = (deps) => (mnemonic) => {
           "timestamp" desc
         );
       `,
-        sql `
-        create table evolu_owner (
-          "mnemonic" text not null primary key,
-          "id" text not null,
-          "encryptionKey" blob not null,
-          "createdAt" text not null,
-          "writeKey" blob,
-          "timestamp" text not null
-        )
-        strict;
-      `,
     ]) {
         const result = deps.sqlite.exec(query);
         if (!result.ok)
             return result;
     }
-    const appOwner = createAppOwner(deps)(mnemonic);
-    const ownerRow = createOwnerRow(deps)(appOwner);
-    const result = deps.sqlite.exec(sql `
-      insert into evolu_owner
-        (
-          "mnemonic",
-          "id",
-          "encryptionKey",
-          "createdAt",
-          "writeKey",
-          "timestamp"
-        )
-      values
-        (
-          ${ownerRow.mnemonic},
-          ${ownerRow.id},
-          ${ownerRow.encryptionKey},
-          ${ownerRow.createdAt},
-          ${ownerRow.writeKey},
-          ${ownerRow.timestamp}
-        );
-    `);
+    const result = createBaseSqliteStorageTables(deps);
     if (!result.ok)
         return result;
-    return ok([appOwner, ownerRow]);
-};
-const applyChanges = (deps) => (changes, onChange) => {
-    let lastTimestamp = timestampStringToTimestamp(deps.ownerRowRef.get().timestamp);
-    const messages = [];
-    for (const change of changes) {
-        const nextTimestamp = sendTimestamp(deps)(lastTimestamp);
-        if (!nextTimestamp.ok)
-            return nextTimestamp;
-        lastTimestamp = nextTimestamp.value;
-        messages.push({ timestamp: lastTimestamp, change });
-    }
-    const apply = applyMessages(deps)(messages, lastTimestamp);
-    if (!apply.ok)
-        return apply;
-    if (onChange)
-        onChange();
-    assertNonEmptyReadonlyArray(messages);
-    return ok(messages);
-};
-const applyMessages = (deps) => (messages, lastTimestamp) => {
-    const ownerId = ownerIdToBinaryOwnerId(deps.ownerRowRef.get().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;
-    }
-    const timestamp = timestampToTimestampString(lastTimestamp);
-    deps.ownerRowRef.modify((owner) => ({ ...owner, timestamp }));
-    const saveTimestamp = deps.sqlite.exec(sql.prepared `
-      update evolu_owner set "timestamp" = ${timestamp};
-    `);
-    if (!saveTimestamp.ok)
-        return saveTimestamp;
     return ok();
 };
-const applyMessageToAppTable = (deps) => (ownerId, message) => {
-    const date = new Date(message.timestamp.millis).toISOString();
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    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)}, createdAt, updatedAt)
-        select ${message.change.id}, ${value}, ${date}, ${date}
-        where
-          (select "timestamp" from lastTimestamp) is null
-          or (select "timestamp" from lastTimestamp) < ${timestamp}
-        on conflict ("id") do update
-          set
-            ${sql.identifier(column)} = ${value},
-            updatedAt = ${date}
-          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 = [];
@@ -636,156 +371,3 @@ const loadQueries = (deps) => (tabId, queries) => {
     }));
     return ok(queryPatchesArray);
 };
-export const maybeMigrateToVersion0 = (deps) => (schema) => {
-    // evolu_history is a new table
-    const hasOwnerButNoHistory = schema.tables.some((t) => t.name === "evolu_owner") &&
-        !schema.tables.some((t) => t.name === "evolu_history");
-    if (!hasOwnerButNoHistory) {
-        return ok(null);
-    }
-    const mnemonicAndLastTimestamp = deps.sqlite.exec(sql ` select mnemonic, timestamp from evolu_owner limit 1; `);
-    if (!mnemonicAndLastTimestamp.ok)
-        return mnemonicAndLastTimestamp;
-    const messagesRows = deps.sqlite.exec(sql `
-      select "timestamp", "table", "id", "column", "value" from evolu_message;
-    `);
-    if (!messagesRows.ok)
-        return messagesRows;
-    for (const query of [
-        sql `drop table evolu_owner;`,
-        sql `drop table evolu_message;`,
-    ]) {
-        const result = deps.sqlite.exec(query);
-        if (!result.ok)
-            return result;
-    }
-    const messages = messagesRows.value.rows.map((message) => ({
-        timestamp: timestampStringToTimestamp(message.timestamp),
-        change: {
-            id: message.id,
-            table: message.table,
-            values: { [message.column]: message.value },
-        },
-    }));
-    const { rows: [{ mnemonic, timestamp }], } = mnemonicAndLastTimestamp.value;
-    const lastTimestamp = timestampStringToTimestamp(timestamp);
-    return ok({ messages, mnemonic, lastTimestamp });
-};
-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) => {
-    const ownerId = deps.ownerRowRef.get().id;
-    const message = createProtocolMessageForSync(deps)(ownerId);
-    if (message) {
-        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 { writeKey } = deps.ownerRowRef.get();
-    const output = deps.sqlite.transaction(() => applyProtocolMessageAsClient(deps)(input, {
-        getWriteKey: (_ownerId) => writeKey,
-    }));
-    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) => {
-            // TODO: Get owner by _ownerId when we support more.
-            const owner = deps.ownerRowRef.get();
-            const decodedAndDecryptedMessages = [];
-            for (const message of messages) {
-                const dbChange = decryptAndDecodeDbChange(deps)(message.change, owner.encryptionKey);
-                if (!dbChange.ok) {
-                    deps.postMessage({
-                        type: "onError",
-                        error: dbChange.error,
-                    });
-                    return false;
-                }
-                decodedAndDecryptedMessages.push({
-                    timestamp: message.timestamp,
-                    change: dbChange.value,
-                });
-            }
-            let timestamp = timestampStringToTimestamp(owner.timestamp);
-            for (const message of messages) {
-                const receive = receiveTimestamp(deps)(timestamp, message.timestamp);
-                if (!receive.ok) {
-                    deps.postMessage({ type: "onError", error: receive.error });
-                    return false;
-                }
-                timestamp = receive.value;
-            }
-            const applyMessagesResult = applyMessages({ ...deps, storage })(decodedAndDecryptedMessages, timestamp);
-            if (!applyMessagesResult.ok) {
-                deps.postMessage({
-                    type: "onError",
-                    error: applyMessagesResult.error,
-                });
-                return false;
-            }
-            deps.postMessage({ type: "onReceive" });
-            return true;
-        },
-        readDbChange: (ownerId, timestamp) => {
-            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 change = {
-                table: rows[0].table,
-                id: binaryIdToId(rows[0].id),
-                values,
-            };
-            const { encryptionKey } = deps.ownerRowRef.get();
-            return encodeAndEncryptDbChange(deps)(change, encryptionKey);
-        },
-    };
-    return ok(storage);
-};