cojson-storage-do-sqlite 0.18.28

package/src/tests/messagesTestUtils.ts

@@ -0,0 +1,72 @@
+import type { CoValueCore, CojsonInternalTypes, SyncMessage } from "cojson";
+
+function simplifySessions(msg: CojsonInternalTypes.CoValueKnownState) {
+  const count = Object.values(msg.sessions).reduce(
+    (acc: number, session: number) => acc + session,
+    0,
+  );
+
+  if (msg.header) {
+    return `header/${count}`;
+  }
+
+  return "empty";
+}
+
+function simplifyNewContent(
+  content: CojsonInternalTypes.NewContentMessage["new"],
+) {
+  if (!content) {
+    return undefined;
+  }
+
+  return Object.values(content)
+    .map((c) => `After: ${c.after} New: ${c.newTransactions.length}`)
+    .join(" | ");
+}
+
+export function toSimplifiedMessages(
+  coValues: Record<string, CoValueCore>,
+  messages: {
+    from: "client" | "server" | "storage";
+    msg: SyncMessage;
+  }[],
+) {
+  function getCoValue(id: string) {
+    for (const [name, coValue] of Object.entries(coValues)) {
+      if (coValue.id === id) {
+        return name;
+      }
+    }
+
+    return `unknown/${id}`;
+  }
+
+  function toDebugString(
+    from: "client" | "server" | "storage",
+    msg: SyncMessage,
+  ) {
+    switch (msg.action) {
+      case "known":
+        return `${from} -> KNOWN ${msg.isCorrection ? "CORRECTION " : ""}${getCoValue(msg.id)} sessions: ${simplifySessions(msg)}`;
+      case "load":
+        return `${from} -> LOAD ${getCoValue(msg.id)} sessions: ${simplifySessions(msg)}`;
+      case "done":
+        return `${from} -> DONE ${getCoValue(msg.id)}`;
+      case "content":
+        return `${from} -> CONTENT ${getCoValue(msg.id)} header: ${Boolean(msg.header)} new: ${simplifyNewContent(msg.new)}`;
+    }
+  }
+
+  return messages.map((m) => toDebugString(m.from, m.msg));
+}
+
+export function debugMessages(
+  coValues: Record<string, CoValueCore>,
+  messages: {
+    from: "client" | "server" | "storage";
+    msg: SyncMessage;
+  }[],
+) {
+  console.log(toSimplifiedMessages(coValues, messages));
+}

package/src/tests/testUtils.ts

@@ -0,0 +1,112 @@
+import type { LocalNode, RawCoID, SyncMessage } from "cojson";
+import { StorageApiSync } from "cojson";
+import { onTestFinished } from "vitest";
+
+export function trackMessages() {
+  const messages: {
+    from: "client" | "server" | "storage";
+    msg: SyncMessage;
+  }[] = [];
+
+  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 as RawCoID,
+        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;
+  };
+
+  onTestFinished(() => {
+    restore();
+  });
+
+  return {
+    messages,
+    restore,
+  };
+}
+export function waitFor(
+  callback: () => boolean | undefined | Promise<boolean | undefined>,
+) {
+  return new Promise<void>((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);
+  });
+}

package/src/tests/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "es2021",
+    /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "lib": ["es2021"],
+    /* Specify what JSX code is generated. */
+    "jsx": "react-jsx",
+
+    /* Specify what module code is generated. */
+    "module": "es2022",
+    /* Specify how TypeScript looks up a file from a given module specifier. */
+    "moduleResolution": "Bundler",
+    /* Specify type package names to be included without being referenced in a source file. */
+    "types": ["worker-configuration.d.ts"],
+    /* Enable importing .json files */
+    "resolveJsonModule": true,
+
+    /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    "allowJs": true,
+    /* Enable error reporting in type-checked JavaScript files. */
+    "checkJs": false,
+
+    /* Disable emitting files from a compilation. */
+    "noEmit": true,
+
+    /* Ensure that each file can be safely transpiled without relying on other imports. */
+    "isolatedModules": true,
+    /* Allow 'import x from y' when a module doesn't have a default export. */
+    "allowSyntheticDefaultImports": true,
+    /* Ensure that casing is correct in imports. */
+    "forceConsistentCasingInFileNames": true,
+
+    /* Enable all strict type-checking options. */
+    "strict": true,
+
+    /* Skip type checking all .d.ts files. */
+    "skipLibCheck": true
+  },
+  "include": ["worker-configuration.d.ts", "../**/*.ts"]
+}

package/src/tests/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineProject } from "vitest/config";
+
+export default defineProject({
+  test: {
+    name: "cloudflare-do-storage",
+    testTimeout: 10_000,
+  },
+});