jazz-tools 0.18.5 → 0.18.6

package/src/tools/tests/groupsAndAccounts.test.ts

@@ -1,9 +1,9 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { CoMap, Group, z } from "../exports.js";
-import { Loaded, Ref, co } from "../internal.js";
+import { Account, Loaded, Ref, co } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { loadCoValueOrFail, setupTwoNodes, waitFor } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -272,14 +272,20 @@ describe("Group inheritance", () => {
     const bob = await createJazzTestAccount({});
     await bob.$jazz.waitForAllCoValuesSync();
 
+    const loadedAlice = await Account.load(alice.$jazz.id);
+    const loadedBob = await Account.load(bob.$jazz.id);
+
+    assert(loadedBob);
+    assert(loadedAlice);
+
     const parentGroup = Group.create();
     // `parentGroup` has `alice` as a writer
-    parentGroup.addMember(alice, "writer");
+    parentGroup.addMember(loadedAlice, "writer");
     expect(parentGroup.getRoleOf(alice.$jazz.id)).toBe("writer");
 
     const group = Group.create();
     // `group` has `bob` as a reader
-    group.addMember(bob, "reader");
+    group.addMember(loadedBob, "reader");
     expect(group.getRoleOf(bob.$jazz.id)).toBe("reader");
 
     group.addMember(parentGroup);
@@ -817,24 +823,26 @@ describe("Group.members", () => {
     childGroup.addMember(bob, "reader");
     expect(childGroup.getRoleOf(bob.$jazz.id)).toBe("reader");
 
-    expect(childGroup.members).toEqual([
-      expect.objectContaining({
-        account: expect.objectContaining({
-          $jazz: expect.objectContaining({
-            id: co.account().getMe().$jazz.id,
+    await waitFor(() => {
+      expect(childGroup.members).toEqual([
+        expect.objectContaining({
+          account: expect.objectContaining({
+            $jazz: expect.objectContaining({
+              id: co.account().getMe().$jazz.id,
+            }),
           }),
+          role: "admin",
         }),
-        role: "admin",
-      }),
-      expect.objectContaining({
-        account: expect.objectContaining({
-          $jazz: expect.objectContaining({
-            id: bob.$jazz.id,
+        expect.objectContaining({
+          account: expect.objectContaining({
+            $jazz: expect.objectContaining({
+              id: bob.$jazz.id,
+            }),
           }),
+          role: "reader",
         }),
-        role: "reader",
-      }),
-    ]);
+      ]);
+    });
   });
 
   test("should return the members of the parent group", async () => {
@@ -849,24 +857,26 @@ describe("Group.members", () => {
 
     expect(childGroup.getRoleOf(bob.$jazz.id)).toBe("reader");
 
-    expect(childGroup.members).toEqual([
-      expect.objectContaining({
-        account: expect.objectContaining({
-          $jazz: expect.objectContaining({
-            id: co.account().getMe().$jazz.id,
+    await waitFor(() => {
+      expect(childGroup.members).toEqual([
+        expect.objectContaining({
+          account: expect.objectContaining({
+            $jazz: expect.objectContaining({
+              id: co.account().getMe().$jazz.id,
+            }),
           }),
+          role: "admin",
         }),
-        role: "admin",
-      }),
-      expect.objectContaining({
-        account: expect.objectContaining({
-          $jazz: expect.objectContaining({
-            id: bob.$jazz.id,
+        expect.objectContaining({
+          account: expect.objectContaining({
+            $jazz: expect.objectContaining({
+              id: bob.$jazz.id,
+            }),
           }),
+          role: "reader",
         }),
-        role: "reader",
-      }),
-    ]);
+      ]);
+    });
   });
 
   test("should not return everyone", async () => {
@@ -926,22 +936,24 @@ describe("Group.getDirectMembers", () => {
     childGroup.addMember(parentGroup);
 
     // Child group should inherit bob through parent, but bob is not a direct member
-    expect(childGroup.members).toEqual([
-      expect.objectContaining({
-        account: expect.objectContaining({
-          $jazz: expect.objectContaining({
-            id: co.account().getMe().$jazz.id,
+    await waitFor(() => {
+      expect(childGroup.members).toEqual([
+        expect.objectContaining({
+          account: expect.objectContaining({
+            $jazz: expect.objectContaining({
+              id: co.account().getMe().$jazz.id,
+            }),
           }),
         }),
-      }),
-      expect.objectContaining({
-        account: expect.objectContaining({
-          $jazz: expect.objectContaining({
-            id: bob.$jazz.id,
+        expect.objectContaining({
+          account: expect.objectContaining({
+            $jazz: expect.objectContaining({
+              id: bob.$jazz.id,
+            }),
           }),
         }),
-      }),
-    ]);
+      ]);
+    });
 
     // directMembers should only show the admin, not the inherited bob
     expect(childGroup.getDirectMembers()).toEqual([

package/src/tools/tests/inbox.test.ts

@@ -1,12 +1,29 @@
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { Group, Inbox, InboxSender, z } from "../exports";
-import { Loaded, co, coValueClassFromCoValueClassOrSchema } from "../internal";
+import {
+  Account,
+  Loaded,
+  co,
+  coValueClassFromCoValueClassOrSchema,
+} from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
+import {
+  createJazzTestAccount,
+  getPeerConnectedToTestSyncServer,
+  setupJazzTestSync,
+} from "../testing";
+import { cojsonInternals, LocalNode } from "cojson";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 const Message = co.map({
   text: z.string(),
 });
 
+beforeEach(async () => {
+  await setupJazzTestSync();
+  vi.useRealTimers();
+});
+
 describe("Inbox", () => {
   describe("Private profile", () => {
     it("Should throw if the inbox owner profile is private", async () => {
@@ -211,10 +228,7 @@ describe("Inbox", () => {
 
     unsubscribe();
 
-    expect(errorLogSpy).toHaveBeenCalledWith(
-      "Error processing inbox message",
-      expect.any(Error),
-    );
+    expect(errorLogSpy).toHaveBeenCalledWith(new Error("Failed"));
 
     errorLogSpy.mockRestore();
   });
@@ -298,7 +312,7 @@ describe("Inbox", () => {
     expect(receivedMessages[0]?.text).toBe("Hello");
   });
 
-  it("should retry failed messages", async () => {
+  it("should not retry failed messages", async () => {
     const { clientAccount: sender, serverAccount: receiver } =
       await setupTwoNodes();
 
@@ -320,25 +334,18 @@ describe("Inbox", () => {
     let failures = 0;
 
     // Subscribe to inbox messages
-    const unsubscribe = receiverInbox.subscribe(
-      Message,
-      async () => {
-        failures++;
-        throw new Error("Failed");
-      },
-      { retries: 2 },
-    );
+    const unsubscribe = receiverInbox.subscribe(Message, async () => {
+      failures++;
+      throw new Error("Failed");
+    });
 
     await expect(promise).rejects.toThrow();
-    expect(failures).toBe(3);
+    expect(failures).toBe(1);
     const [failed] = Object.values(receiverInbox.failed.items).flat();
-    expect(failed?.value.errors.length).toBe(3);
+    expect(failed?.value.errors.length).toBe(1);
     unsubscribe();
 
-    expect(errorLogSpy).toHaveBeenCalledWith(
-      "Error processing inbox message",
-      expect.any(Error),
-    );
+    expect(errorLogSpy).toHaveBeenCalledWith(new Error("Failed"));
 
     errorLogSpy.mockRestore();
   });
@@ -357,28 +364,283 @@ describe("Inbox", () => {
     const errorLogSpy = vi.spyOn(console, "error").mockImplementation(() => {});
 
     // Subscribe to inbox messages
-    const unsubscribe = receiverInbox.subscribe(
-      Message,
-      async () => {
-        spy();
-      },
-      { retries: 2 },
-    );
+    const unsubscribe = receiverInbox.subscribe(Message, async () => {
+      spy();
+    });
 
     await waitFor(() => {
       const [failed] = Object.values(receiverInbox.failed.items).flat();
 
-      expect(failed?.value.errors.length).toBe(3);
+      expect(failed?.value.errors.length).toBe(1);
     });
 
     expect(spy).not.toHaveBeenCalled();
     unsubscribe();
 
     expect(errorLogSpy).toHaveBeenCalledWith(
-      "Error processing inbox message",
-      expect.any(Error),
+      new Error("Inbox: message co_z123234 is unavailable"),
     );
 
     errorLogSpy.mockRestore();
   });
+
+  it("should skip processed messages when a large inbox is restarted", async () => {
+    cojsonInternals.setMaxRecommendedTxSize(100);
+
+    const sender = await createJazzTestAccount();
+    const receiver = await createJazzTestAccount();
+
+    await receiver.$jazz.waitForAllCoValuesSync();
+
+    const receiverInbox = await Inbox.load(receiver);
+    const inboxSender = await InboxSender.load(receiver.$jazz.id, sender);
+
+    const group = Group.create({ owner: receiver });
+
+    // This generates 4 chunks on the processed stream
+    for (let i = 0; i < 5; i++) {
+      inboxSender.sendMessage(Message.create({ text: `Hello ${i}` }, group));
+    }
+
+    inboxSender.sendMessage(Message.create({ text: `done` }, group));
+
+    await new Promise((resolve) => {
+      const unsubscribe = receiverInbox.subscribe(Message, async (message) => {
+        if (message.text === "done") {
+          resolve(true);
+          unsubscribe();
+        }
+      });
+    });
+
+    const accountId = receiver.$jazz.id;
+    const accountSecret =
+      receiver.$jazz.localNode.getCurrentAgent().agentSecret;
+    const sessionID = receiver.$jazz.localNode.currentSessionID;
+
+    await receiver.$jazz.waitForAllCoValuesSync();
+    await receiver.$jazz.localNode.gracefulShutdown();
+
+    const node = await LocalNode.withLoadedAccount({
+      accountID: accountId as any,
+      accountSecret: accountSecret,
+      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      crypto: receiver.$jazz.localNode.crypto,
+      sessionID: sessionID,
+    });
+
+    const reloadedInbox = await Inbox.load(Account.fromNode(node));
+
+    const subscribeEmitted = await new Promise((resolve) => {
+      const unsubscribe = reloadedInbox.subscribe(Message, async (message) => {
+        // Got a message
+        resolve(true);
+      });
+      setTimeout(() => {
+        resolve(false);
+        unsubscribe();
+      }, 100);
+    });
+
+    expect(subscribeEmitted).toBe(false);
+  });
+
+  it("should skip failed messages when a large inbox is restarted", async () => {
+    cojsonInternals.setMaxRecommendedTxSize(100);
+
+    const sender = await createJazzTestAccount();
+    const receiver = await createJazzTestAccount();
+
+    await receiver.$jazz.waitForAllCoValuesSync();
+
+    const receiverInbox = await Inbox.load(receiver);
+    const inboxSender = await InboxSender.load(receiver.$jazz.id, sender);
+
+    const group = Group.create({ owner: receiver });
+
+    // This generates 4 chunks on the processed stream
+    for (let i = 0; i < 5; i++) {
+      inboxSender
+        .sendMessage(Message.create({ text: `Hello ${i}` }, group))
+        .catch(() => {});
+    }
+
+    inboxSender
+      .sendMessage(Message.create({ text: `done` }, group))
+      .catch(() => {});
+
+    await new Promise((resolve) => {
+      const unsubscribe = receiverInbox.subscribe(Message, async (message) => {
+        if (message.text === "done") {
+          resolve(true);
+          unsubscribe();
+        }
+
+        throw new Error("Failed");
+      });
+    });
+
+    await waitFor(() => {
+      expect(Object.values(receiverInbox.processed.items).length).toBe(1);
+    });
+
+    const accountId = receiver.$jazz.id;
+    const accountSecret =
+      receiver.$jazz.localNode.getCurrentAgent().agentSecret;
+    const sessionID = receiver.$jazz.localNode.currentSessionID;
+
+    await receiver.$jazz.waitForAllCoValuesSync();
+    await receiver.$jazz.localNode.gracefulShutdown();
+
+    const node = await LocalNode.withLoadedAccount({
+      accountID: accountId as any,
+      accountSecret: accountSecret,
+      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      crypto: receiver.$jazz.localNode.crypto,
+      sessionID: sessionID,
+    });
+
+    const reloadedInbox = await Inbox.load(Account.fromNode(node));
+
+    const subscribeEmitted = await new Promise((resolve) => {
+      const unsubscribe = reloadedInbox.subscribe(Message, async (message) => {
+        // Got a message
+        resolve(true);
+      });
+      setTimeout(() => {
+        resolve(false);
+        unsubscribe();
+      }, 100);
+    });
+
+    expect(subscribeEmitted).toBe(false);
+  });
+
+  describe("Concurrency control", () => {
+    it("should respect concurrency limit of 1", async () => {
+      const { clientAccount: sender, serverAccount: receiver } =
+        await setupTwoNodes();
+
+      const receiverInbox = await Inbox.load(receiver);
+      const inboxSender = await InboxSender.load(receiver.$jazz.id, sender);
+
+      const group = Group.create({ owner: sender });
+
+      const processingOrder: string[] = [];
+
+      const Message = co.map({
+        text: z.string(),
+        value: z.number(),
+      });
+
+      // Create messages that take time to process
+      const messages = Array.from({ length: 5 }, (_, i) =>
+        Message.create({ text: `Message ${i}`, value: i }, group),
+      );
+
+      // Subscribe with concurrency limit of 1
+      const unsubscribe = receiverInbox.subscribe(
+        Message,
+        async (message) => {
+          const messageText = message.text;
+          processingOrder.push(`start-${messageText}`);
+
+          // Simulate processing time
+          await new Promise((resolve) =>
+            setTimeout(resolve, 20 - message.value * 10),
+          );
+
+          processingOrder.push(`end-${messageText}`);
+        },
+        { concurrencyLimit: 1 },
+      );
+
+      // Send all messages at once
+      messages.forEach((message) => {
+        inboxSender.sendMessage(message);
+      });
+
+      // Wait for all messages to be processed
+      await waitFor(() => processingOrder.length === 10); // 5 start + 5 end
+
+      expect(processingOrder).toMatchInlineSnapshot(`
+        [
+          "start-Message 0",
+          "end-Message 0",
+          "start-Message 1",
+          "end-Message 1",
+          "start-Message 2",
+          "end-Message 2",
+          "start-Message 3",
+          "end-Message 3",
+          "start-Message 4",
+          "end-Message 4",
+        ]
+      `);
+      unsubscribe();
+    });
+
+    it("should allow concurrent processing with higher concurrency limit", async () => {
+      const { clientAccount: sender, serverAccount: receiver } =
+        await setupTwoNodes();
+
+      const receiverInbox = await Inbox.load(receiver);
+      const inboxSender = await InboxSender.load(receiver.$jazz.id, sender);
+
+      const group = Group.create({ owner: sender });
+
+      // Track processing order and timing
+      const processingOrder: string[] = [];
+
+      const Message = co.map({
+        text: z.string(),
+        value: z.number(),
+      });
+
+      // Create messages that take time to process
+      const messages = Array.from({ length: 5 }, (_, i) =>
+        Message.create({ text: `Message ${i}`, value: i }, group),
+      );
+
+      // Subscribe with concurrency limit of 1
+      const unsubscribe = receiverInbox.subscribe(
+        Message,
+        async (message) => {
+          const messageText = message.text;
+          processingOrder.push(`start-${messageText}`);
+
+          // Simulate processing time
+          await new Promise((resolve) =>
+            setTimeout(resolve, 20 - message.value * 10),
+          );
+
+          processingOrder.push(`end-${messageText}`);
+        },
+        { concurrencyLimit: 3 },
+      );
+
+      // Send all messages at once
+      messages.forEach((message) => {
+        inboxSender.sendMessage(message);
+      });
+
+      await waitFor(() => processingOrder.length === 10);
+
+      expect(processingOrder).toMatchInlineSnapshot(`
+        [
+          "start-Message 0",
+          "start-Message 1",
+          "start-Message 2",
+          "end-Message 2",
+          "start-Message 3",
+          "end-Message 3",
+          "start-Message 4",
+          "end-Message 4",
+          "end-Message 1",
+          "end-Message 0",
+        ]
+      `);
+      unsubscribe();
+    });
+  });
 });

package/src/worker/index.ts

@@ -11,6 +11,7 @@ import {
   CoValueFromRaw,
   Inbox,
   InstanceOfSchema,
+  Loaded,
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
 } from "jazz-tools";
@@ -26,6 +27,10 @@ type WorkerOptions<
   WebSocket?: AnyWebSocketConstructor;
   AccountSchema?: S;
   crypto?: CryptoProvider;
+  /**
+   * If true, the inbox will not be loaded.
+   */
+  skipInboxLoad?: boolean;
 };
 
 /** @category Context Creation */
@@ -39,6 +44,7 @@ export async function startWorker<
     accountSecret = process.env.JAZZ_WORKER_SECRET,
     syncServer = "wss://cloud.jazz.tools",
     AccountSchema = Account as unknown as S,
+    skipInboxLoad = false,
   } = options;
 
   let node: LocalNode | undefined = undefined;
@@ -93,7 +99,7 @@ export async function startWorker<
     throw new Error("Account has no profile");
   }
 
-  const inbox = await Inbox.load(account);
+  const inbox = skipInboxLoad ? undefined : await Inbox.load(account);
 
   async function done() {
     await context.account.$jazz.waitForAllCoValuesSync();
@@ -102,12 +108,16 @@ export async function startWorker<
     context.done();
   }
 
-  const inboxPublicApi = {
-    subscribe: inbox.subscribe.bind(inbox) as Inbox["subscribe"],
-  };
+  const inboxPublicApi = inbox
+    ? {
+        subscribe: inbox.subscribe.bind(inbox) as Inbox["subscribe"],
+      }
+    : {
+        subscribe: () => {},
+      };
 
   return {
-    worker: context.account as InstanceOfSchema<S>,
+    worker: context.account as Loaded<S>,
     experimental: {
       inbox: inboxPublicApi,
     },

package/tsup.config.ts

@@ -48,7 +48,7 @@ export default defineConfig([
   {
     ...cfg,
     entry: {
-      index: "src/inspector/index.ts",
+      index: "src/inspector/index.tsx",
     },
     outDir: "dist/inspector",
     esbuildOptions: (options) => {