jazz-tools 0.18.8 → 0.18.11

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

@@ -540,4 +540,256 @@ describe("ContextManager", () => {
       manager.register(secret, { name: "Test User" }),
     ).rejects.toThrow("Props required");
   });
+
+  describe("Race condition handling", () => {
+    test("prevents concurrent authentication attempts", async () => {
+      const account = await createJazzTestAccount();
+      const onAnonymousAccountDiscarded = vi.fn();
+
+      // Create initial anonymous context
+      await manager.createContext({ onAnonymousAccountDiscarded });
+
+      const credentials = {
+        accountID: account.$jazz.id,
+        accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      };
+
+      // Start multiple concurrent authentication attempts
+      const promises = [];
+      for (let i = 0; i < 5; i++) {
+        promises.push(manager.authenticate(credentials));
+      }
+
+      await Promise.all(promises);
+
+      // onAnonymousAccountDiscarded should only be called once despite multiple authenticate calls
+      expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(1);
+    });
+
+    test("prevents concurrent registration attempts", async () => {
+      const onAnonymousAccountDiscarded = vi.fn();
+      await manager.createContext({ onAnonymousAccountDiscarded });
+
+      const secret = Crypto.newRandomAgentSecret();
+
+      // Start multiple concurrent registration attempts
+      const promises = [];
+      for (let i = 0; i < 3; i++) {
+        promises.push(manager.register(secret, { name: "Test User" }));
+      }
+
+      await Promise.allSettled(promises);
+
+      // onAnonymousAccountDiscarded should only be called once
+      expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(1);
+    });
+
+    test("allows authentication after logout", async () => {
+      const account = await createJazzTestAccount();
+      const onAnonymousAccountDiscarded = vi.fn();
+
+      // Create initial context and authenticate
+      await manager.createContext({ onAnonymousAccountDiscarded });
+
+      await manager.authenticate({
+        accountID: account.$jazz.id,
+        accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      });
+
+      expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(1);
+
+      await manager.logOut();
+
+      // Should be able to authenticate again
+      const account2 = await createJazzTestAccount();
+
+      await manager.authenticate({
+        accountID: account2.$jazz.id,
+        accountSecret: account2.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      });
+
+      // Should be called again since we logged out and reset the migration state
+      expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(2);
+    });
+
+    test("handles authentication in progress correctly", async () => {
+      const account = await createJazzTestAccount();
+      const onAnonymousAccountDiscarded = vi.fn();
+
+      await manager.createContext({ onAnonymousAccountDiscarded });
+
+      const credentials = {
+        accountID: account.$jazz.id,
+        accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      };
+
+      // Start first authentication
+      const firstAuth = manager.authenticate(credentials);
+
+      // Try to authenticate while first is in progress
+      await manager.authenticate(credentials);
+
+      // Wait for first to complete
+      await firstAuth;
+
+      // Should only have been called once
+      expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(1);
+    });
+
+    test("prevents duplicate onAnonymousAccountDiscarded calls during complex migration", async () => {
+      const AccountRoot = co.map({
+        value: z.string(),
+        get transferredRoot(): co.Optional<typeof AccountRoot> {
+          return co.optional(AccountRoot);
+        },
+      });
+
+      const CustomAccount = co
+        .account({
+          root: AccountRoot,
+          profile: co.profile(),
+        })
+        .withMigration(async (account) => {
+          account.$jazz.set(
+            "root",
+            AccountRoot.create(
+              { value: "Hello" },
+              Group.create(this).makePublic(),
+            ),
+          );
+        });
+
+      const customManager = new TestJazzContextManager<
+        InstanceOfSchema<typeof CustomAccount>
+      >();
+
+      const onAnonymousAccountDiscarded = vi
+        .fn()
+        .mockImplementation(async (anonymousAccount) => {
+          // Simulate complex migration work
+          await new Promise((resolve) => setTimeout(resolve, 10));
+
+          const anonymousAccountWithRoot =
+            await anonymousAccount.$jazz.ensureLoaded({
+              resolve: { root: true },
+            });
+
+          const me = await CustomAccount.getMe().$jazz.ensureLoaded({
+            resolve: { root: true },
+          });
+
+          me.root.$jazz.set("transferredRoot", anonymousAccountWithRoot.root);
+        });
+
+      await customManager.createContext({
+        AccountSchema: coValueClassFromCoValueClassOrSchema(CustomAccount),
+        onAnonymousAccountDiscarded,
+      });
+
+      const account = (
+        customManager.getCurrentValue() as JazzAuthContext<
+          InstanceOfSchema<typeof CustomAccount>
+        >
+      ).me;
+
+      // Start multiple concurrent authentication attempts
+      const promises = [];
+      for (let i = 0; i < 3; i++) {
+        promises.push(
+          customManager.authenticate({
+            accountID: account.$jazz.id,
+            accountSecret:
+              account.$jazz.localNode.getCurrentAgent().agentSecret,
+            provider: "test",
+          }),
+        );
+      }
+
+      await Promise.all(promises);
+
+      // Migration should only happen once
+      expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(1);
+
+      const me = await CustomAccount.getMe().$jazz.ensureLoaded({
+        resolve: { root: { transferredRoot: true } },
+      });
+
+      expect(me.root.transferredRoot?.value).toBe("Hello");
+    });
+
+    test("fails fast when trying to authenticate different accounts concurrently", async () => {
+      const account1 = await createJazzTestAccount();
+      const account2 = await createJazzTestAccount();
+
+      await manager.createContext({});
+
+      const credentials1 = {
+        accountID: account1.$jazz.id,
+        accountSecret: account1.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      };
+
+      const credentials2 = {
+        accountID: account2.$jazz.id,
+        accountSecret: account2.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      };
+
+      const auth1Promise = manager.authenticate(credentials1);
+
+      // Try to authenticate account2 while account1 is in progress
+      await expect(manager.authenticate(credentials2)).rejects.toThrow();
+
+      // First authentication should still complete successfully
+      await expect(auth1Promise).resolves.toBeUndefined();
+
+      // After first auth completes, second account should be able to authenticate
+      await expect(manager.authenticate(credentials2)).resolves.toBeUndefined();
+    });
+
+    test("throws error when authenticating with different credentials simultaneously", async () => {
+      const account1 = await createJazzTestAccount();
+      const account2 = await createJazzTestAccount();
+
+      await manager.createContext({});
+
+      const credentials1 = {
+        accountID: account1.$jazz.id,
+        accountSecret: account1.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      };
+
+      const credentials2 = {
+        accountID: account2.$jazz.id,
+        accountSecret: account2.$jazz.localNode.getCurrentAgent().agentSecret,
+        provider: "test",
+      };
+
+      const results = await Promise.allSettled([
+        manager.authenticate(credentials1),
+        manager.authenticate(credentials2),
+      ]);
+
+      // One should succeed and one should fail
+      const successCount = results.filter(
+        (r) => r.status === "fulfilled",
+      ).length;
+      const failureCount = results.filter(
+        (r) => r.status === "rejected",
+      ).length;
+
+      expect(successCount).toBe(1);
+      expect(failureCount).toBe(1);
+
+      // Verify the successful authentication resulted in a valid context
+      const currentAccount = getCurrentValue().me;
+      expect([credentials1.accountID, credentials2.accountID]).toContain(
+        currentAccount.$jazz.id,
+      );
+    });
+  });
 });

package/src/worker/index.ts

@@ -91,7 +91,6 @@ export async function startWorker<
       secret: accountSecret as AgentSecret,
     },
     AccountSchema,
-    // TODO: locked sessions similar to browser
     sessionProvider: randomSessionProvider,
     peersToLoadFrom,
     crypto: options.crypto ?? (await WasmCrypto.create()),
@@ -123,10 +122,23 @@ export async function startWorker<
       };
 
   return {
+    /**
+     * The worker account instance.
+     */
     worker: context.account as Loaded<S>,
     experimental: {
+      /**
+       * API to subscribe to the inbox messages.
+       *
+       * More info on the Inbox API: https://jazz.tools/docs/react/server-side/inbox
+       */
       inbox: inboxPublicApi,
     },
+    /**
+     * Wait for the connection to the sync server to be established.
+     *
+     * If already connected, it will resolve immediately.
+     */
     waitForConnection() {
       return wsPeer.waitUntilConnected();
     },
@@ -137,6 +149,21 @@ export async function startWorker<
         wsPeer.unsubscribe(listener);
       };
     },
+    /**
+     * Waits for all CoValues to sync and then shuts down the worker.
+     *
+     * To only wait for sync use worker.$jazz.waitForAllCoValuesSync()
+     *
+     * @deprecated Use shutdownWorker
+     */
     done,
+    /**
+     * Waits for all CoValues to sync and then shuts down the worker.
+     *
+     * To only wait for sync use worker.$jazz.waitForAllCoValuesSync()
+     */
+    shutdownWorker() {
+      return done();
+    },
   };
 }