cojson-storage-do-sqlite 0.18.28

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> cojson-storage-do-sqlite@0.18.28 build /home/runner/_work/jazz/jazz/packages/cojson-storage-do-sqlite
+> rm -rf ./dist && tsc --sourceMap --outDir dist
+

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# cojson-storage-do-sqlite
+
+## 0.18.28
+
+### Patch Changes
+
+- 46b26f7: Add cojson-storage-do-sqlite to provide storage persistency for worker on DurableObjects
+- Updated dependencies [8f47a9e]
+  - cojson@0.18.32

package/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2025, Garden Computing, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+# CoJSON Storage SQLite for Cloudflare Durable Objects
+
+This implements persistence for CoJSON / Jazz (see
+[jazz.tools](https://jazz.tools)) using Durable Objects SQLite storage.

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { SQLiteDatabaseDriver } from "cojson";
+import type { DurableObjectStorage } from "@cloudflare/workers-types";
+export declare class DurableObjectSqlDriver implements SQLiteDatabaseDriver {
+    private readonly storage;
+    constructor(durableObjectStorage: DurableObjectStorage);
+    run(sql: string, params: unknown[]): void;
+    query<T>(sql: string, params: unknown[]): T[];
+    get<T>(sql: string, params: unknown[]): T | undefined;
+    transaction(callback: () => unknown): unknown;
+    closeDb(): void;
+    getMigrationVersion(): number;
+    saveMigrationVersion(version: number): void;
+}
+export declare function getDurableObjectSqlStorage(durableObjectStorage: DurableObjectStorage): import("cojson").StorageApiSync;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAEnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,qBAAa,sBAAuB,YAAW,oBAAoB;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;gBAEnC,oBAAoB,EAAE,oBAAoB;IAItD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;IAIlC,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE;IAI7C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS;IAQrD,WAAW,CAAC,QAAQ,EAAE,MAAM,OAAO;IAInC,OAAO;IAIP,mBAAmB,IAAI,MAAM;IAa7B,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAG5C;AAED,wBAAgB,0BAA0B,CACxC,oBAAoB,EAAE,oBAAoB,mCAK3C"}

package/dist/index.js

@@ -0,0 +1,37 @@
+import { getSqliteStorage } from "cojson";
+export class DurableObjectSqlDriver {
+    constructor(durableObjectStorage) {
+        this.storage = durableObjectStorage;
+    }
+    run(sql, params) {
+        this.storage.sql.exec(sql, ...params);
+    }
+    query(sql, params) {
+        return this.storage.sql.exec(sql, ...params).toArray();
+    }
+    get(sql, params) {
+        const res = this.storage.sql.exec(sql, ...params);
+        if (res.rowsRead === 0) {
+            return undefined;
+        }
+        return res.one();
+    }
+    transaction(callback) {
+        return this.storage.transactionSync(callback);
+    }
+    closeDb() {
+        return;
+    }
+    getMigrationVersion() {
+        this.run("CREATE TABLE IF NOT EXISTS _migration_version (version INTEGER);", []);
+        return (this.get("SELECT max(version) as version FROM _migration_version;", [])?.version ?? 0);
+    }
+    saveMigrationVersion(version) {
+        this.run("INSERT INTO _migration_version (version) VALUES (?);", [version]);
+    }
+}
+export function getDurableObjectSqlStorage(durableObjectStorage) {
+    const db = new DurableObjectSqlDriver(durableObjectStorage);
+    return getSqliteStorage(db);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAG1C,MAAM,OAAO,sBAAsB;IAGjC,YAAY,oBAA0C;QACpD,IAAI,CAAC,OAAO,GAAG,oBAAoB,CAAC;IACtC,CAAC;IAED,GAAG,CAAC,GAAW,EAAE,MAAiB;QAChC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;IACxC,CAAC;IAED,KAAK,CAAI,GAAW,EAAE,MAAiB;QACrC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,OAAO,EAAS,CAAC;IAChE,CAAC;IAED,GAAG,CAAI,GAAW,EAAE,MAAiB;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;QAClD,IAAI,GAAG,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,CAAC,GAAG,EAAO,CAAC;IACxB,CAAC;IAED,WAAW,CAAC,QAAuB;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAED,OAAO;QACL,OAAO;IACT,CAAC;IAED,mBAAmB;QACjB,IAAI,CAAC,GAAG,CACN,kEAAkE,EAClE,EAAE,CACH,CAAC;QACF,OAAO,CACL,IAAI,CAAC,GAAG,CACN,yDAAyD,EACzD,EAAE,CACH,EAAE,OAAO,IAAI,CAAC,CAChB,CAAC;IACJ,CAAC;IAED,oBAAoB,CAAC,OAAe;QAClC,IAAI,CAAC,GAAG,CAAC,sDAAsD,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9E,CAAC;CACF;AAED,MAAM,UAAU,0BAA0B,CACxC,oBAA0C;IAE1C,MAAM,EAAE,GAAG,IAAI,sBAAsB,CAAC,oBAAoB,CAAC,CAAC;IAE5D,OAAO,gBAAgB,CAAC,EAAE,CAAC,CAAC;AAC9B,CAAC"}

package/dist/tests/dosqlite.d.ts

@@ -0,0 +1,89 @@
+import "jazz-tools/load-edge-wasm";
+import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
+import { SyncMessage } from "cojson";
+export declare function trackMessages(): {
+    messages: {
+        from: "client" | "server" | "storage";
+        msg: SyncMessage;
+    }[];
+    restore: () => void;
+};
+/**
+ * Due to issues with @cloudflare/vitest-pool-workers and loading wasm modules
+ * implementing the test logic in the durable object and running full server
+ * with wrangler.
+ *
+ */
+export declare class DoSqlStoreTest extends DurableObject {
+    /**
+     * Test case from cojson-storage-sqlite: "should sync and load data from storage"
+     */
+    storeLoadTest(): Promise<{
+        messageRes1: string[];
+        messageRes2: string[];
+        map2Hello: import("cojson").JsonValue | undefined;
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "should send an empty content message if there is no content"
+     */
+    storeLoadEmptyTest(): Promise<{
+        messageRes1: string[];
+        messageRes2: string[];
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "should load dependencies correctly (group inheritance)"
+     */
+    loadDependenciesTest(): Promise<{
+        messageRes1: string[];
+        messageRes2: string[];
+        mapLoaded: boolean;
+        groupLoaded: boolean;
+        parentGroupLoaded: boolean;
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "should not send the same dependency value twice"
+     */
+    duplicateDependencyTest(): Promise<{
+        messageRes1: string[];
+        mapLoaded: boolean;
+        mapFromParentLoaded: boolean;
+        groupLoaded: boolean;
+        parentGroupLoaded: boolean;
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "should recover from data loss"
+     */
+    dataLossRecoverTest(): Promise<{
+        messageRes1: string[];
+        messageRes2: string[];
+        mapContent: {
+            [x: string]: import("cojson").JsonValue | undefined;
+        };
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "should recover missing dependencies from storage"
+     */
+    recoverMissingDependenciesTest(): Promise<{
+        mapContent: {
+            [x: string]: import("cojson").JsonValue | undefined;
+        };
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "should sync multiple sessions in a single content message"
+     */
+    multipleSessionsSingleContentMessageTest(): Promise<{
+        messageRes1: string[];
+        map2Hello: import("cojson").JsonValue | undefined;
+        map3Hello: import("cojson").JsonValue | undefined;
+    }>;
+    /**
+     * Test case from cojson-storage-sqlite: "large coValue upload streaming"
+     */
+    largeCoValueUploadTest(): Promise<{
+        messageRes1: string[];
+    }>;
+}
+export default class EntryPoint extends WorkerEntrypoint {
+    fetch(request: Request): Promise<Response>;
+}
+//# sourceMappingURL=dosqlite.d.ts.map

package/dist/tests/dosqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dosqlite.d.ts","sourceRoot":"","sources":["../../src/tests/dosqlite.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC;AACnC,OAAO,EAAO,aAAa,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAIL,WAAW,EAEZ,MAAM,QAAQ,CAAC;AAShB,wBAAgB,aAAa;;cAEnB,QAAQ,GAAG,QAAQ,GAAG,SAAS;aAChC,WAAW;;;EAuEnB;AAgCD;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,aAAa;IAC/C;;OAEG;IACG,aAAa;;;;;IA8DnB;;OAEG;IACG,kBAAkB;;;;IA2DxB;;OAEG;IACG,oBAAoB;;;;;;;IAoE1B;;OAEG;IACG,uBAAuB;;;;;;;IAkE7B;;OAEG;IACG,mBAAmB;;;;;;;IA8EzB;;OAEG;IACG,8BAA8B;;;;;IAmFpC;;OAEG;IACG,wCAAwC;;;;;IA8E9C;;OAEG;IACG,sBAAsB;;;CAqE7B;AAED,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,gBAAgB;IAChD,KAAK,CAAC,OAAO,EAAE,OAAO;CAkD7B"}

package/dist/tests/dosqlite.js

@@ -0,0 +1,489 @@
+import "jazz-tools/load-edge-wasm";
+import { env, DurableObject, WorkerEntrypoint } from "cloudflare:workers";
+import { LocalNode, StorageApiSync, cojsonInternals, } from "cojson";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+import { toSimplifiedMessages } from "./messagesTestUtils.js";
+import { getDurableObjectSqlStorage } from "../index.js";
+const Crypto = await WasmCrypto.create();
+// Adopted from cojson-storage-sqlite/src/tests/testUtils.js
+export function trackMessages() {
+    const messages = [];
+    const originalLoad = StorageApiSync.prototype.load;
+    const originalStore = StorageApiSync.prototype.store;
+    StorageApiSync.prototype.load = async function (id, callback, done) {
+        messages.push({
+            from: "client",
+            msg: {
+                action: "load",
+                id: id,
+                header: false,
+                sessions: {},
+            },
+        });
+        return originalLoad.call(this, id, (msg) => {
+            messages.push({
+                from: "storage",
+                msg,
+            });
+            callback(msg);
+        }, done);
+    };
+    StorageApiSync.prototype.store = function (data, correctionCallback) {
+        messages.push({
+            from: "client",
+            msg: data,
+        });
+        return originalStore.call(this, data, (msg) => {
+            messages.push({
+                from: "storage",
+                msg: {
+                    action: "known",
+                    isCorrection: true,
+                    ...msg,
+                },
+            });
+            const correctionMessages = correctionCallback(msg);
+            if (correctionMessages) {
+                for (const msg of correctionMessages) {
+                    messages.push({
+                        from: "client",
+                        msg,
+                    });
+                }
+            }
+            return correctionMessages;
+        });
+    };
+    const restore = () => {
+        StorageApiSync.prototype.load = originalLoad;
+        StorageApiSync.prototype.store = originalStore;
+        messages.length = 0;
+    };
+    return {
+        messages,
+        restore,
+    };
+}
+function waitFor(callback) {
+    return new Promise((resolve, reject) => {
+        const checkPassed = async () => {
+            try {
+                return { ok: await callback(), error: null };
+            }
+            catch (error) {
+                return { ok: false, error };
+            }
+        };
+        let retries = 0;
+        const interval = setInterval(async () => {
+            const { ok, error } = await checkPassed();
+            if (ok !== false) {
+                clearInterval(interval);
+                resolve();
+            }
+            if (++retries > 10) {
+                clearInterval(interval);
+                reject(error);
+            }
+        }, 100);
+    });
+}
+/**
+ * Due to issues with @cloudflare/vitest-pool-workers and loading wasm modules
+ * implementing the test logic in the durable object and running full server
+ * with wrangler.
+ *
+ */
+export class DoSqlStoreTest extends DurableObject {
+    /**
+     * Test case from cojson-storage-sqlite: "should sync and load data from storage"
+     */
+    async storeLoadTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node1Sync = trackMessages();
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const map = group.createMap();
+        map.set("hello", "world");
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const messageRes1 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node1Sync.messages);
+        node1Sync.restore();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node2Sync = trackMessages();
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        const map2 = await node2.load(map.id);
+        if (map2 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        const messageRes2 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node2Sync.messages);
+        node2Sync.restore();
+        return {
+            messageRes1,
+            messageRes2,
+            map2Hello: map2.get("hello"),
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "should send an empty content message if there is no content"
+     */
+    async storeLoadEmptyTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node1Sync = trackMessages();
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const map = group.createMap();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const messageRes1 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node1Sync.messages);
+        node1Sync.restore();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node2Sync = trackMessages();
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        const map2 = await node2.load(map.id);
+        if (map2 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        const messageRes2 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node2Sync.messages);
+        node2Sync.restore();
+        return {
+            messageRes1,
+            messageRes2,
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "should load dependencies correctly (group inheritance)"
+     */
+    async loadDependenciesTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node1Sync = trackMessages();
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const parentGroup = node1.createGroup();
+        group.extend(parentGroup);
+        const map = group.createMap();
+        map.set("hello", "world");
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const messageRes1 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+            ParentGroup: parentGroup.core,
+        }, node1Sync.messages);
+        node1Sync.restore();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node2Sync = trackMessages();
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        await node2.load(map.id);
+        const mapLoaded = !!node2.expectCoValueLoaded(map.id);
+        const groupLoaded = !!node2.expectCoValueLoaded(group.id);
+        const parentGroupLoaded = !!node2.expectCoValueLoaded(parentGroup.id);
+        const messageRes2 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+            ParentGroup: parentGroup.core,
+        }, node2Sync.messages);
+        return {
+            messageRes1,
+            messageRes2,
+            mapLoaded,
+            groupLoaded,
+            parentGroupLoaded,
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "should not send the same dependency value twice"
+     */
+    async duplicateDependencyTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node1Sync = trackMessages();
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const parentGroup = node1.createGroup();
+        group.extend(parentGroup);
+        const mapFromParent = parentGroup.createMap();
+        const map = group.createMap();
+        map.set("hello", "world");
+        mapFromParent.set("hello", "world");
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        node1Sync.restore();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node2Sync = trackMessages();
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        await node2.load(map.id);
+        await node2.load(mapFromParent.id);
+        const mapLoaded = !!node2.expectCoValueLoaded(map.id);
+        const mapFromParentLoaded = !!node2.expectCoValueLoaded(mapFromParent.id);
+        const groupLoaded = !!node2.expectCoValueLoaded(group.id);
+        const parentGroupLoaded = !!node2.expectCoValueLoaded(parentGroup.id);
+        const messageRes1 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+            ParentGroup: parentGroup.core,
+            MapFromParent: mapFromParent.core,
+        }, node2Sync.messages);
+        return {
+            messageRes1,
+            mapLoaded,
+            mapFromParentLoaded,
+            groupLoaded,
+            parentGroupLoaded,
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "should recover from data loss"
+     */
+    async dataLossRecoverTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node1Sync = trackMessages();
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const map = group.createMap();
+        map.set("0", 0);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const originalStore = StorageApiSync.prototype.store;
+        StorageApiSync.prototype.store = () => false;
+        map.set("1", 1);
+        map.set("2", 2);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        StorageApiSync.prototype.store = originalStore;
+        map.set("3", 3);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const messageRes1 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node1Sync.messages);
+        node1Sync.restore();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node2Sync = trackMessages();
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        const map2 = await node2.load(map.id);
+        if (map2 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        const mapContent = map2.toJSON();
+        const messageRes2 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node2Sync.messages);
+        return {
+            messageRes1,
+            messageRes2,
+            mapContent,
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "should recover missing dependencies from storage"
+     */
+    async recoverMissingDependenciesTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const account = LocalNode.internalCreateAccount({
+            crypto: Crypto,
+        });
+        const node1 = account.core.node;
+        const serverNode = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const [serverPeer, clientPeer] = cojsonInternals.connectedPeers(node1.agentSecret, serverNode.agentSecret, {
+            peer1role: "server",
+            peer2role: "client",
+        });
+        node1.syncManager.addPeer(serverPeer);
+        serverNode.syncManager.addPeer(clientPeer);
+        // manual mock
+        const originalStore = StorageApiSync.prototype.store;
+        StorageApiSync.prototype.store = function (data, correctionCallback) {
+            if ([group.core.id, account.core.id].includes(data.id)) {
+                return false;
+            }
+            return originalStore.call(this, data, correctionCallback);
+        };
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        group.addMember("everyone", "writer");
+        const map = group.createMap();
+        map.set("0", 0);
+        StorageApiSync.prototype.store = originalStore;
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const node2 = new LocalNode(Crypto.newRandomAgentSecret(), Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const [serverPeer2, clientPeer2] = cojsonInternals.connectedPeers(node1.agentSecret, serverNode.agentSecret, {
+            peer1role: "server",
+            peer2role: "client",
+        });
+        node2.syncManager.addPeer(serverPeer2);
+        serverNode.syncManager.addPeer(clientPeer2);
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        const map2 = await node2.load(map.id);
+        if (map2 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        const mapContent = map2.toJSON();
+        return {
+            mapContent,
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "should sync multiple sessions in a single content message"
+     */
+    async multipleSessionsSingleContentMessageTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const map = group.createMap();
+        map.set("hello", "world");
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        node1.gracefulShutdown();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        const map2 = await node2.load(map.id);
+        if (map2 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        const map2Hello = map2.get("hello");
+        map2.set("hello", "world2");
+        await map2.core.waitForSync();
+        node2.gracefulShutdown();
+        const node3 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node3Sync = trackMessages();
+        const storage3 = getDurableObjectSqlStorage(this.ctx.storage);
+        node3.setStorage(storage3);
+        const map3 = await node3.load(map.id);
+        if (map3 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        const map3Hello = map3.get("hello");
+        const messageRes1 = toSimplifiedMessages({
+            Map: map.core,
+            Group: group.core,
+        }, node3Sync.messages);
+        node3Sync.restore();
+        return {
+            messageRes1,
+            map2Hello,
+            map3Hello,
+        };
+    }
+    /**
+     * Test case from cojson-storage-sqlite: "large coValue upload streaming"
+     */
+    async largeCoValueUploadTest() {
+        const agentSecret = Crypto.newRandomAgentSecret();
+        const node1 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const storage1 = getDurableObjectSqlStorage(this.ctx.storage);
+        node1.setStorage(storage1);
+        const group = node1.createGroup();
+        const largeMap = group.createMap();
+        const dataSize = 1 * 1024 * 200;
+        const chunkSize = 1024; // 1KB chunks
+        const chunks = dataSize / chunkSize;
+        const value = "a".repeat(chunkSize);
+        for (let i = 0; i < chunks; i++) {
+            const key = `key${i}`;
+            largeMap.set(key, value, "trusting");
+        }
+        await largeMap.core.waitForSync();
+        node1.gracefulShutdown();
+        const node2 = new LocalNode(agentSecret, Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
+        const node2Sync = trackMessages();
+        const storage2 = getDurableObjectSqlStorage(this.ctx.storage);
+        node2.setStorage(storage2);
+        const largeMapOnNode2 = await node2.load(largeMap.id);
+        if (largeMapOnNode2 === "unavailable") {
+            throw new Error("Map is unavailable");
+        }
+        await waitFor(() => {
+            if (JSON.stringify(largeMapOnNode2.core.knownState()) !==
+                JSON.stringify(largeMap.core.knownState())) {
+                throw new Error("Map states are not equal");
+            }
+            return true;
+        });
+        const messageRes1 = toSimplifiedMessages({
+            Map: largeMap.core,
+            Group: group.core,
+        }, node2Sync.messages);
+        return {
+            messageRes1,
+        };
+    }
+}
+export default class EntryPoint extends WorkerEntrypoint {
+    async fetch(request) {
+        if (request.method !== "POST") {
+            return new Response("Method not allowed", { status: 405 });
+        }
+        const path = new URL(request.url).pathname;
+        const body = await request.json();
+        if (!(typeof body === "object" &&
+            body !== null &&
+            "doId" in body &&
+            typeof body.doId === "string")) {
+            throw new Error("Invalid request body");
+        }
+        const stub = env.DoSqlStoreTest.getByName(body.doId);
+        if (path === "/sync-and-load") {
+            const res = await stub.storeLoadTest();
+            // @ts-expect-error ts2589 the type initiation is too deep
+            return Response.json(res);
+        }
+        else if (path === "/sync-and-load-empty") {
+            const res = await stub.storeLoadEmptyTest();
+            return Response.json(res);
+        }
+        else if (path === "/group-load") {
+            const res = await stub.loadDependenciesTest();
+            return Response.json(res);
+        }
+        else if (path === "/group-load-duplicate") {
+            const res = await stub.duplicateDependencyTest();
+            return Response.json(res);
+        }
+        else if (path === "/data-loss-recovery") {
+            const res = await stub.dataLossRecoverTest();
+            return Response.json(res);
+        }
+        else if (path === "/missing-dependency-recovery") {
+            const res = await stub.recoverMissingDependenciesTest();
+            return Response.json(res);
+        }
+        else if (path === "/multiple-sessions") {
+            const res = await stub.multipleSessionsSingleContentMessageTest();
+            return Response.json(res);
+        }
+        else if (path === "/large-covalue-upload") {
+            const res = await stub.largeCoValueUploadTest();
+            return Response.json(res);
+        }
+        else {
+            return new Response("Invalid test method", { status: 400 });
+        }
+    }
+}
+//# sourceMappingURL=dosqlite.js.map