@evolu/common 5.4.7 → 6.0.0

package/dist/src/Evolu/Db.js

@@ -0,0 +1,774 @@
+import { isNonEmptyArray, isNonEmptyReadonlyArray, } 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 { createRef } from "../Ref.js";
+import { err, ok } from "../Result.js";
+import { createSqlite, explainSqliteQueryPlan, sql, } from "../Sqlite.js";
+import { object, String } from "../Type.js";
+import { createInitializedWorker, } from "../Worker.js";
+import { makePatches } from "./Diff.js";
+import { createAppOwner, createOwnerRow, } from "./Owner.js";
+import { applyProtocolMessageAsClient, binaryIdToId, createProtocolMessageForSync, createProtocolMessageFromCrdtMessages, decryptAndDecodeDbChange, encodeAndEncryptDbChange, idToBinaryId, ownerIdToBinaryOwnerId, 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 DbIndex = object({ name: String, sql: String });
+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,
+                    });
+                    deps.sqlite[Symbol.dispose]();
+                    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);
+            }
+        },
+    });
+};
+/**
+ * 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);
+    });
+    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 it to Sqlite.
+export const getDbSnapshot = (deps) => {
+    const schema = getDbSchema(deps)({ allIndexes: true });
+    if (!schema.ok)
+        return schema;
+    const rows = [];
+    for (const table of schema.value.tables) {
+        const result = deps.sqlite.exec(sql `
+      select * from ${sql.identifier(table.name)};
+    `);
+        if (!result.ok)
+            return result;
+        rows.push({
+            rows: result.value.rows,
+            name: table.name,
+        });
+    }
+    return ok({ schema: schema.value, rows });
+};
+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: [],
+            });
+        }
+        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;
+            `);
+            });
+        }
+    });
+    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);
+        if (!result.ok)
+            return result;
+    }
+    return ok();
+};
+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) => {
+    for (const query of [
+        sql `
+        create table evolu_config (
+          "key" text not null primary key,
+          "value" any not null
+        )
+        strict;
+      `,
+        sql `
+        insert into evolu_config ("key", "value")
+        values ('protocolVersion', ${protocolVersion});
+      `,
+        /**
+         * The History table stores all values per timestamp, table, row, and
+         * column. It's required for merging without conflicts. Evolu uses
+         * last-write-win CRDT. In case of last-write-win value isn't what we
+         * want, we can use time travel. The current implementation prefers
+         * performance over storage size. The History table denormalizes Timestamp
+         * and DbChange to leverage a covering index. Hence, every value change
+         * has its timestamp, table, row, and column. In the future, we will
+         * rethink that and store history more efficiently.
+         *
+         * There is no need to use `OwnerId` on the client, because timestamps
+         * (which include a `NodeId`) are globally unique. The relay needs
+         * `OwnerId` because it hosts multiple apps/owners, but client storage
+         * represents one DB, and even when it hosts multiple owners, their
+         * timestamps remain unique.
+         */
+        sql `
+        create table evolu_history (
+          "timestamp" blob not null,
+          "table" text not null,
+          "row" blob not null,
+          "column" text not null,
+          "value" any
+        )
+        strict;
+      `,
+        sql `
+        create index evolu_history_timestamp on evolu_history ("timestamp");
+      `,
+        sql `
+        create unique index evolu_history_row_column_table_timestampDesc on evolu_history (
+          "row",
+          "column",
+          "table",
+          "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}
+        );
+    `);
+    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, options = {}) => {
+    for (const message of messages) {
+        if (!options.isMigrationFromVersion0) {
+            const apply1 = applyMessageToAppTable(deps)(message);
+            if (!apply1.ok)
+                return apply1;
+        }
+        const apply2 = applyMessageToTimestampAndHistoryTables(deps)(message);
+        if (!apply2.ok)
+            return apply2;
+    }
+    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) => (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
+              "row" = ${message.change.id}
+              and "column" = ${column}
+              and "table" = ${message.change.table}
+            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) => (message) => {
+    const timestamp = timestampToBinaryTimestamp(message.timestamp);
+    const ownerId = ownerIdToBinaryOwnerId(deps.ownerRowRef.get().id);
+    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
+          ("timestamp", "table", "row", "column", "value")
+        values
+          (${timestamp}, ${message.change.table}, ${id}, ${column}, ${value})
+        on conflict do nothing;
+      `);
+        if (!result.ok)
+            return result;
+    }
+    return ok();
+};
+const loadQueries = (deps) => (tabId, queries) => {
+    const queriesRows = [];
+    for (const query of queries) {
+        const sqlQuery = deserializeQuery(query);
+        const result = deps.sqlite.exec(sqlQuery);
+        if (!result.ok)
+            return result;
+        queriesRows.push([query, result.value.rows]);
+        if (sqlQuery.options?.logExplainQueryPlan) {
+            explainSqliteQueryPlan(deps)(sqlQuery);
+        }
+    }
+    const queryRowsCache = deps.getQueryRowsCache(tabId);
+    const previousState = queryRowsCache.get();
+    queryRowsCache.set(queriesRows);
+    const currentState = queryRowsCache.get();
+    const queryPatchesArray = queries.map((query) => ({
+        query,
+        patches: makePatches(previousState.get(query), currentState.get(query) ?? emptyRows),
+    }));
+    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", "row", "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.row,
+            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,
+        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", "row", "column", "value"
+          from evolu_history
+          where "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, row } = rows[0];
+            const values = {};
+            for (const r of rows) {
+                assert(r.table === table, "All rows must have the same table");
+                assert(eqArrayNumber(r.row, row), "All rows must have the same Id");
+                values[r.column] = r.value;
+            }
+            const change = {
+                table: rows[0].table,
+                id: binaryIdToId(rows[0].row),
+                values,
+            };
+            const { encryptionKey } = deps.ownerRowRef.get();
+            return encodeAndEncryptDbChange(deps)(change, encryptionKey);
+        },
+    };
+    return ok(storage);
+};