jazz-tools 0.9.23 → 0.10.0

package/src/tests/groupsAndAccounts.test.ts

@@ -122,7 +122,7 @@ describe("Group inheritance", () => {
     const mapAsReader = await TestMap.load(mapInChild.id, reader, {});
     expect(mapAsReader?.title).toBe("In Child");
 
-    parentGroup.removeMember(reader);
+    await parentGroup.removeMember(reader);
 
     mapInChild.title = "In Child (updated)";
 
@@ -161,7 +161,7 @@ describe("Group inheritance", () => {
     const mapAsReader = await TestMap.load(mapInGrandChild.id, reader, {});
     expect(mapAsReader?.title).toBe("In Grand Child");
 
-    grandParentGroup.removeMember(reader);
+    await grandParentGroup.removeMember(reader);
 
     mapInGrandChild.title = "In Grand Child (updated)";
 

package/src/tests/subscribe.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, onTestFinished, vi } from "vitest";
+import { beforeEach, describe, expect, it, onTestFinished, vi } from "vitest";
 import {
   Account,
   CoFeed,
@@ -7,12 +7,15 @@ import {
   FileStream,
   Group,
   co,
+  cojsonInternals,
 } from "../index.web.js";
 import {
   type DepthsIn,
+  ID,
   createCoValueObservable,
   subscribeToCoValue,
 } from "../internal.js";
+import { setupJazzTestSync } from "../testing.js";
 import { setupAccount, waitFor } from "./utils.js";
 
 class ChatRoom extends CoMap {
@@ -43,6 +46,15 @@ function createMessage(me: Account | Group, text: string) {
   );
 }
 
+beforeEach(async () => {
+  await setupJazzTestSync();
+});
+
+beforeEach(() => {
+  cojsonInternals.CO_VALUE_LOADING_CONFIG.MAX_RETRIES = 1;
+  cojsonInternals.CO_VALUE_LOADING_CONFIG.TIMEOUT = 1;
+});
+
 describe("subscribeToCoValue", () => {
   it("subscribes to a CoMap", async () => {
     const { me, meOnSecondPeer } = await setupAccount();
@@ -163,7 +175,7 @@ describe("subscribeToCoValue", () => {
     onTestFinished(unsubscribe);
 
     await waitFor(() => {
-      const lastValue = updateFn.mock.lastCall[0];
+      const lastValue = updateFn.mock.lastCall?.[0];
 
       expect(lastValue?.messages?.[0]?.text).toBe(message.text);
     });
@@ -175,7 +187,7 @@ describe("subscribeToCoValue", () => {
       expect(updateFn).toHaveBeenCalled();
     });
 
-    const lastValue = updateFn.mock.lastCall[0];
+    const lastValue = updateFn.mock.lastCall?.[0];
     expect(lastValue?.messages?.[0]?.text).toBe(
       "Nevermind, she was gone to the supermarket",
     );
@@ -212,12 +224,12 @@ describe("subscribeToCoValue", () => {
     onTestFinished(unsubscribe);
 
     await waitFor(() => {
-      const lastValue = updateFn.mock.lastCall[0];
+      const lastValue = updateFn.mock.lastCall?.[0];
 
       expect(lastValue?.messages?.[0]?.text).toBe(message.text);
     });
 
-    const initialValue = updateFn.mock.lastCall[0];
+    const initialValue = updateFn.mock.lastCall?.[0];
     const initialMessagesList = initialValue?.messages;
     const initialMessage1 = initialValue?.messages[0];
     const initialMessage2 = initialValue?.messages[1];
@@ -231,7 +243,7 @@ describe("subscribeToCoValue", () => {
       expect(updateFn).toHaveBeenCalled();
     });
 
-    const lastValue = updateFn.mock.lastCall[0];
+    const lastValue = updateFn.mock.lastCall?.[0];
     expect(lastValue).not.toBe(initialValue);
     expect(lastValue.messages).not.toBe(initialMessagesList);
     expect(lastValue.messages[0]).not.toBe(initialMessage1);
@@ -278,13 +290,13 @@ describe("subscribeToCoValue", () => {
     onTestFinished(unsubscribe);
 
     await waitFor(() => {
-      const lastValue = updateFn.mock.lastCall[0];
+      const lastValue = updateFn.mock.lastCall?.[0];
 
       expect(lastValue?.messages?.[0]?.text).toBe(message.text);
       expect(lastValue?.messages?.[1]?.text).toBe(message2.text);
     });
 
-    const initialValue = updateFn.mock.lastCall[0];
+    const initialValue = updateFn.mock.lastCall?.[0];
     chatRoom.name = "Me and Luigi";
 
     updateFn.mockClear();
@@ -293,7 +305,7 @@ describe("subscribeToCoValue", () => {
       expect(updateFn).toHaveBeenCalled();
     });
 
-    const lastValue = updateFn.mock.lastCall[0];
+    const lastValue = updateFn.mock.lastCall?.[0];
     expect(lastValue).not.toBe(initialValue);
     expect(lastValue.name).toBe("Me and Luigi");
 
@@ -368,4 +380,25 @@ describe("createCoValueObservable", () => {
     unsubscribe();
     expect(observable.getCurrentValue()).toBeUndefined();
   });
+
+  it("should return null if the coValue is not found", async () => {
+    const { meOnSecondPeer } = await setupAccount();
+    const observable = createCoValueObservable<TestMap, DepthsIn<TestMap>>();
+
+    const unsubscribe = observable.subscribe(
+      TestMap,
+      "co_z123" as ID<TestMap>,
+      meOnSecondPeer,
+      {},
+      () => {},
+    );
+
+    expect(observable.getCurrentValue()).toBeUndefined();
+
+    await waitFor(() => {
+      expect(observable.getCurrentValue()).toBeNull();
+    });
+
+    unsubscribe();
+  });
 });

package/src/tests/testing.test.ts

@@ -48,4 +48,60 @@ describe("Jazz Test Sync", () => {
 
     expect(account1.root?.value).toBe("ok");
   });
+
+  test("correctly manages the global me during the migrations", async () => {
+    class MyRoot extends CoMap {
+      value = co.string;
+    }
+
+    class CustomAccount extends Account {
+      root = co.ref(MyRoot);
+
+      migrate() {
+        if (this.root === undefined) {
+          this.root = MyRoot.create({
+            value: "ok",
+          });
+        }
+      }
+    }
+
+    const account1 = await createJazzTestAccount({
+      AccountSchema: CustomAccount,
+      isCurrentActiveAccount: true,
+    });
+
+    const account2 = await createJazzTestAccount({
+      AccountSchema: CustomAccount,
+      isCurrentActiveAccount: false,
+    });
+
+    expect(account1.root?.value).toBe("ok");
+    expect(account2.root?.value).toBe("ok");
+
+    expect(Account.getMe()).toBe(account1);
+  });
+
+  test("throws when running multiple migrations in parallel", async () => {
+    class CustomAccount extends Account {
+      async migrate() {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    }
+
+    const promise = Promise.all([
+      createJazzTestAccount({
+        AccountSchema: CustomAccount,
+        isCurrentActiveAccount: true,
+      }),
+      createJazzTestAccount({
+        AccountSchema: CustomAccount,
+        isCurrentActiveAccount: true,
+      }),
+    ]);
+
+    await expect(promise).rejects.toThrow(
+      "It is not possible to create multiple accounts in parallel inside the test environment.",
+    );
+  });
 });

package/src/tests/utils.ts

@@ -5,8 +5,7 @@ import { cojsonInternals } from "cojson";
 import {
   Account,
   WasmCrypto,
-  createJazzContext,
-  fixedCredentialsAuth,
+  createJazzContextFromExistingCredentials,
   randomSessionProvider,
 } from "../index.web";
 
@@ -31,15 +30,16 @@ export async function setupAccount() {
     throw "me is not a controlled account";
   }
   me._raw.core.node.syncManager.addPeer(secondPeer);
-  const { account: meOnSecondPeer } = await createJazzContext({
-    auth: fixedCredentialsAuth({
-      accountID: me.id,
-      secret: me._raw.agentSecret,
-    }),
-    sessionProvider: randomSessionProvider,
-    peersToLoadFrom: [initialAsPeer],
-    crypto: Crypto,
-  });
+  const { account: meOnSecondPeer } =
+    await createJazzContextFromExistingCredentials({
+      credentials: {
+        accountID: me.id,
+        secret: me._raw.agentSecret,
+      },
+      sessionProvider: randomSessionProvider,
+      peersToLoadFrom: [initialAsPeer],
+      crypto: Crypto,
+    });
 
   return { me, meOnSecondPeer };
 }

package/src/types.ts

@@ -0,0 +1,54 @@
+import type { AgentSecret, LocalNode } from "cojson";
+import type { Account } from "./exports.js";
+import type { AnonymousJazzAgent, ID } from "./internal.js";
+
+export type AuthCredentials = {
+  accountID: ID<Account>;
+  secretSeed?: Uint8Array;
+  accountSecret: AgentSecret;
+  provider?: "anonymous" | "clerk" | "demo" | "passkey" | "passphrase" | string;
+};
+
+export type AuthenticateAccountFunction = (
+  credentials: AuthCredentials,
+) => Promise<void>;
+export type RegisterAccountFunction = (
+  accountSecret: AgentSecret,
+  creationProps: { name: string },
+) => Promise<ID<Account>>;
+
+/** @category Context Creation */
+export type JazzAuthContext<Acc extends Account> = {
+  me: Acc;
+  node: LocalNode;
+  authenticate: AuthenticateAccountFunction;
+  logOut: () => Promise<void>;
+  done: () => void;
+};
+
+export type JazzGuestContext = {
+  guest: AnonymousJazzAgent;
+  node: LocalNode;
+  authenticate: AuthenticateAccountFunction;
+  logOut: () => void;
+  done: () => void;
+};
+
+export type JazzContextType<Acc extends Account> =
+  | JazzAuthContext<Acc>
+  | JazzGuestContext;
+
+export type NewAccountProps = {
+  secret?: AgentSecret;
+  creationProps?: { name: string };
+};
+
+export type SyncConfig =
+  | {
+      peer: `wss://${string}` | `ws://${string}`;
+      when?: "always" | "signedUp";
+    }
+  | {
+      peer?: `wss://${string}` | `ws://${string}`;
+      when: "never";
+    };