jazz-tools 0.18.5 → 0.18.7

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

@@ -54,6 +54,7 @@ describe("createContext methods", () => {
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       expect(context.node).toBeDefined();
@@ -86,6 +87,7 @@ describe("createContext methods", () => {
         crypto: Crypto,
         AccountSchema: CustomAccount,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       expect(context.account).toBeInstanceOf(
@@ -109,6 +111,7 @@ describe("createContext methods", () => {
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
         onLogOut,
+        asActiveAccount: true,
       });
 
       context.logOut();
@@ -131,6 +134,7 @@ describe("createContext methods", () => {
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       const loadedMap = await loadCoValueOrFail(context.node, coMap.id);
@@ -151,10 +155,30 @@ describe("createContext methods", () => {
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       expect(activeAccountContext.get()).toBe(context.account);
     });
+
+    test("does not set the active account when asActiveAccount is false", async () => {
+      const account = await createJazzTestAccount({
+        isCurrentActiveAccount: false,
+      });
+
+      const context = await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: account.$jazz.id,
+          secret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+        },
+        peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+        crypto: Crypto,
+        sessionProvider: randomSessionProvider,
+        asActiveAccount: false,
+      });
+
+      expect(activeAccountContext.get()).not.toBe(context.account);
+    });
   });
 
   describe("createJazzContextForNewAccount", () => {

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

@@ -57,6 +57,7 @@ describe("Deep loading with depth arg", async () => {
       sessionProvider: randomSessionProvider,
       peersToLoadFrom: [initialAsPeer],
       crypto: Crypto,
+      asActiveAccount: true,
     });
 
   const ownership = { owner: me };
@@ -287,6 +288,7 @@ test("Deep loading a record-like coMap", async () => {
       sessionProvider: randomSessionProvider,
       peersToLoadFrom: [initialAsPeer],
       crypto: Crypto,
+      asActiveAccount: true,
     });
 
   const record = RecordLike.create(

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

@@ -525,7 +525,9 @@ describe("importContentPieces", () => {
       resolve: {
         posts: {
           $each: {
-            comments: true,
+            comments: {
+              $each: true,
+            },
           },
         },
       },

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/tools/tests/patterns/requestToJoin.test.ts

@@ -1,6 +1,10 @@
 import { assert, describe, expect, test } from "vitest";
 import { Account, Group, co, z } from "../../exports";
-import { createJazzTestAccount, linkAccounts } from "../../testing";
+import {
+  createJazzTestAccount,
+  linkAccounts,
+  setupJazzTestSync,
+} from "../../testing";
 
 const RequestToJoin = co.map({
   account: Account,
@@ -24,16 +28,20 @@ const Organization = co.map({
 });
 
 async function setup() {
+  await setupJazzTestSync();
+
   const admin1 = await createJazzTestAccount();
   const admin2 = await createJazzTestAccount();
   const user1 = await createJazzTestAccount();
   const user2 = await createJazzTestAccount();
 
-  await linkAccounts(admin1, admin2);
-  await linkAccounts(admin1, user1);
-  await linkAccounts(admin1, user2);
-  await linkAccounts(admin2, user1);
-  await linkAccounts(admin2, user2);
+  // TODO: with this setting the waitForAllCoValuesSync gets stuck
+  // https://github.com/garden-co/jazz/issues/2874
+  // await linkAccounts(admin1, admin2);
+  // await linkAccounts(admin1, user1);
+  // await linkAccounts(admin1, user2);
+  // await linkAccounts(admin2, user1);
+  // await linkAccounts(admin2, user2);
 
   // The organization info are public
   const adminsGroup = Group.create(admin1);

package/src/tools/tests/utils.ts

@@ -40,6 +40,7 @@ export async function setupAccount() {
       sessionProvider: randomSessionProvider,
       peersToLoadFrom: [initialAsPeer],
       crypto: Crypto,
+      asActiveAccount: true,
     });
 
   return { me, meOnSecondPeer };