jazz-tools 0.9.23 → 0.10.1

package/src/testing.ts

@@ -1,12 +1,22 @@
 import { AgentSecret, CryptoProvider, LocalNode, Peer } from "cojson";
 import { cojsonInternals } from "cojson";
-import { PureJSCrypto } from "cojson/crypto";
-import { Account, type AccountClass } from "./exports.js";
+import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+import {
+  Account,
+  AccountClass,
+  JazzContextManagerAuthProps,
+} from "./exports.js";
+import {
+  JazzContextManager,
+  JazzContextManagerBaseProps,
+} from "./implementation/ContextManager.js";
 import { activeAccountContext } from "./implementation/activeAccountContext.js";
 import {
   type AnonymousJazzAgent,
   type CoValueClass,
   createAnonymousJazzContext,
+  createJazzContext,
+  randomSessionProvider,
 } from "./internal.js";
 
 const syncServer: { current: LocalNode | null } = { current: null };
@@ -21,9 +31,9 @@ type TestAccountSchema<Acc extends Account> = CoValueClass<Acc> & {
   }) => Promise<Acc>;
 };
 
-class TestJSCrypto extends PureJSCrypto {
+export class TestJSCrypto extends PureJSCrypto {
   static async create() {
-    if ("navigator" in globalThis && navigator.userAgent.includes("jsdom")) {
+    if ("navigator" in globalThis && navigator.userAgent?.includes("jsdom")) {
       // Mocking crypto seal & encrypt to make it work with JSDom. Getting "Error: Uint8Array expected" there
       const crypto = new PureJSCrypto();
 
@@ -44,6 +54,27 @@ class TestJSCrypto extends PureJSCrypto {
   }
 }
 
+export function getPeerConnectedToTestSyncServer() {
+  if (!syncServer.current) {
+    throw new Error("Sync server not initialized");
+  }
+
+  const [aPeer, bPeer] = cojsonInternals.connectedPeers(
+    Math.random().toString(),
+    Math.random().toString(),
+    {
+      peer1role: "server",
+      peer2role: "server",
+    },
+  );
+  syncServer.current.syncManager.addPeer(aPeer);
+
+  return bPeer;
+}
+
+const SecretSeedMap = new Map<string, Uint8Array>();
+let isMigrationActive = false;
+
 export async function createJazzTestAccount<Acc extends Account>(options?: {
   isCurrentActiveAccount?: boolean;
   AccountSchema?: CoValueClass<Acc>;
@@ -53,39 +84,50 @@ export async function createJazzTestAccount<Acc extends Account>(options?: {
     Account) as unknown as TestAccountSchema<Acc>;
   const peers = [];
   if (syncServer.current) {
-    const [aPeer, bPeer] = cojsonInternals.connectedPeers(
-      Math.random().toString(),
-      Math.random().toString(),
-      {
-        peer1role: "server",
-        peer2role: "server",
-      },
-    );
-    syncServer.current.syncManager.addPeer(aPeer);
-    peers.push(bPeer);
+    peers.push(getPeerConnectedToTestSyncServer());
   }
 
+  const crypto = await TestJSCrypto.create();
+  const secretSeed = crypto.newRandomSecretSeed();
+
   const { node } = await LocalNode.withNewlyCreatedAccount({
     creationProps: {
       name: "Test Account",
       ...options?.creationProps,
     },
-    crypto: await TestJSCrypto.create(),
+    initialAgentSecret: crypto.agentSecretFromSecretSeed(secretSeed),
+    crypto,
     peersToLoadFrom: peers,
     migration: async (rawAccount, _node, creationProps) => {
+      if (isMigrationActive) {
+        throw new Error(
+          "It is not possible to create multiple accounts in parallel inside the test environment.",
+        );
+      }
+
+      isMigrationActive = true;
+
       const account = new AccountSchema({
         fromRaw: rawAccount,
       });
 
-      if (options?.isCurrentActiveAccount) {
-        activeAccountContext.set(account);
-      }
+      // We need to set the account as current because the migration
+      // will probably rely on the global me
+      const prevActiveAccount = activeAccountContext.maybeGet();
+      activeAccountContext.set(account);
 
       await account.applyMigration?.(creationProps);
+
+      if (!options?.isCurrentActiveAccount) {
+        activeAccountContext.set(prevActiveAccount);
+      }
+
+      isMigrationActive = false;
     },
   });
 
   const account = AccountSchema.fromNode(node);
+  SecretSeedMap.set(account.id, secretSeed);
 
   if (options?.isCurrentActiveAccount) {
     activeAccountContext.set(account);
@@ -109,24 +151,120 @@ export async function createJazzTestGuest() {
   };
 }
 
-export function getJazzContextShape<Acc extends Account>(
-  account: Acc | { guest: AnonymousJazzAgent },
-) {
-  if ("guest" in account) {
-    return {
-      guest: account.guest,
-      AccountSchema: Account,
-      logOut: () => account.guest.node.gracefulShutdown(),
-      done: () => account.guest.node.gracefulShutdown(),
-    };
+export type TestJazzContextManagerProps<Acc extends Account> =
+  JazzContextManagerBaseProps<Acc> & {
+    defaultProfileName?: string;
+    AccountSchema?: AccountClass<Acc>;
+    isAuthenticated?: boolean;
+  };
+
+export class TestJazzContextManager<
+  Acc extends Account,
+> extends JazzContextManager<Acc, TestJazzContextManagerProps<Acc>> {
+  static fromAccountOrGuest<Acc extends Account>(
+    account?: Acc | { guest: AnonymousJazzAgent },
+    props?: TestJazzContextManagerProps<Acc>,
+  ) {
+    if (account && "guest" in account) {
+      return this.fromGuest<Acc>(account, props);
+    }
+
+    return this.fromAccount<Acc>(account ?? (Account.getMe() as Acc), props);
   }
 
-  return {
-    me: account,
-    AccountSchema: account.constructor as AccountClass<Acc>,
-    logOut: () => account._raw.core.node.gracefulShutdown(),
-    done: () => account._raw.core.node.gracefulShutdown(),
-  };
+  static fromAccount<Acc extends Account>(
+    account: Acc,
+    props?: TestJazzContextManagerProps<Acc>,
+  ) {
+    const context = new TestJazzContextManager<Acc>();
+
+    const provider = props?.isAuthenticated ? "testProvider" : "anonymous";
+    const storage = context.getAuthSecretStorage();
+    const node = account._raw.core.node;
+
+    storage.set({
+      accountID: account.id,
+      accountSecret: node.account.agentSecret,
+      secretSeed: SecretSeedMap.get(account.id),
+      provider,
+    });
+    storage.isAuthenticated = Boolean(props?.isAuthenticated);
+
+    context.updateContext(
+      {
+        AccountSchema: account.constructor as AccountClass<Acc>,
+        ...props,
+      },
+      {
+        me: account,
+        node,
+        done: () => {
+          node.gracefulShutdown();
+        },
+        logOut: async () => {
+          node.gracefulShutdown();
+        },
+      },
+    );
+
+    return context;
+  }
+
+  static fromGuest<Acc extends Account>(
+    { guest }: { guest: AnonymousJazzAgent },
+    props: TestJazzContextManagerProps<Acc> = {},
+  ) {
+    const context = new TestJazzContextManager<Acc>();
+    const node = guest.node;
+
+    context.updateContext(props, {
+      guest,
+      node,
+      done: () => {
+        node.gracefulShutdown();
+      },
+      logOut: async () => {
+        node.gracefulShutdown();
+      },
+    });
+
+    return context;
+  }
+
+  async createContext(
+    props: TestJazzContextManagerProps<Acc>,
+    authProps?: JazzContextManagerAuthProps,
+  ) {
+    this.props = props;
+
+    if (!syncServer.current) {
+      throw new Error(
+        "You need to setup a test sync server with setupJazzTestSync to use the Auth functions",
+      );
+    }
+
+    const context = await createJazzContext<Acc>({
+      credentials: authProps?.credentials,
+      defaultProfileName: props.defaultProfileName,
+      newAccountProps: authProps?.newAccountProps,
+      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      crypto: await TestJSCrypto.create(),
+      sessionProvider: randomSessionProvider,
+      authSecretStorage: this.getAuthSecretStorage(),
+      AccountSchema: props.AccountSchema,
+    });
+
+    this.updateContext(props, {
+      me: context.account,
+      node: context.node,
+      done: () => {
+        context.done();
+      },
+      logOut: () => {
+        return context.logOut();
+      },
+    });
+  }
 }
 
 export function linkAccounts(

package/src/tests/AuthSecretStorage.test.ts

@@ -0,0 +1,275 @@
+// @vitest-environment happy-dom
+
+import { Account } from "jazz-tools";
+import { ID } from "jazz-tools";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AuthSecretStorage } from "../auth/AuthSecretStorage";
+import { InMemoryKVStore } from "../auth/InMemoryKVStore.js";
+import KvStoreContext from "../auth/KvStoreContext";
+
+const kvStore = new InMemoryKVStore();
+KvStoreContext.getInstance().initialize(kvStore);
+
+let authSecretStorage = new AuthSecretStorage();
+
+describe("AuthSecretStorage", () => {
+  beforeEach(() => {
+    kvStore.clearAll();
+    authSecretStorage = new AuthSecretStorage();
+  });
+
+  describe("migrate", () => {
+    it("should migrate demo auth secret", async () => {
+      const demoSecret = JSON.stringify({
+        accountID: "demo123",
+        accountSecret: "secret123",
+      });
+      await kvStore.set("demo-auth-logged-in-secret", demoSecret);
+
+      await authSecretStorage.migrate();
+
+      expect(await kvStore.get("jazz-logged-in-secret")).toBe(demoSecret);
+      expect(await kvStore.get("demo-auth-logged-in-secret")).toBeNull();
+    });
+
+    it("should migrate clerk auth secret", async () => {
+      const clerkSecret = JSON.stringify({
+        accountID: "clerk123",
+        accountSecret: "secret123",
+      });
+      await kvStore.set("jazz-clerk-auth", clerkSecret);
+
+      await authSecretStorage.migrate();
+
+      expect(await kvStore.get("jazz-logged-in-secret")).toBe(clerkSecret);
+      expect(await kvStore.get("jazz-clerk-auth")).toBeNull();
+    });
+  });
+
+  describe("get", () => {
+    it("should return null when no data exists", async () => {
+      expect(await authSecretStorage.get()).toBeNull();
+    });
+
+    it("should return credentials with secretSeed", async () => {
+      const credentials = {
+        accountID: "test123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "secret123",
+        provider: "anonymous",
+      };
+      await kvStore.set("jazz-logged-in-secret", JSON.stringify(credentials));
+
+      const result = await authSecretStorage.get();
+
+      expect(result).toEqual({
+        accountID: "test123",
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "secret123",
+        provider: "anonymous",
+      });
+    });
+
+    it("should return non-anonymous credentials without secretSeed", async () => {
+      const credentials = {
+        accountID: "test123",
+        accountSecret: "secret123",
+        provider: "passphrase",
+      };
+      await kvStore.set("jazz-logged-in-secret", JSON.stringify(credentials));
+
+      const result = await authSecretStorage.get();
+
+      expect(result).toEqual({
+        accountID: "test123",
+        accountSecret: "secret123",
+        provider: "passphrase",
+      });
+    });
+
+    it("should throw error for invalid data", async () => {
+      await kvStore.set(
+        "jazz-logged-in-secret",
+        JSON.stringify({ invalid: "data" }),
+      );
+
+      await expect(authSecretStorage.get()).rejects.toThrow(
+        "Invalid auth secret storage data",
+      );
+    });
+  });
+
+  describe("set", () => {
+    it("should set credentials with secretSeed", async () => {
+      const payload = {
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      };
+
+      await authSecretStorage.set(payload);
+
+      const stored = JSON.parse((await kvStore.get("jazz-logged-in-secret"))!);
+      expect(stored).toEqual({
+        accountID: "test123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "secret123",
+        provider: "passphrase",
+      });
+    });
+
+    it("should set credentials without secretSeed", async () => {
+      const payload = {
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      };
+
+      await authSecretStorage.set(payload);
+
+      const stored = JSON.parse((await kvStore.get("jazz-logged-in-secret"))!);
+      expect(stored).toEqual(payload);
+    });
+
+    it("should emit update event when setting credentials", async () => {
+      const handler = vi.fn();
+      authSecretStorage.onUpdate(handler);
+
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      });
+
+      expect(handler).toHaveBeenCalled();
+    });
+  });
+
+  describe("isAuthenticated", () => {
+    it("should return false when no data exists", async () => {
+      expect(authSecretStorage.isAuthenticated).toBe(false);
+    });
+
+    it("should return false for anonymous credentials", async () => {
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "anonymous",
+      });
+      expect(authSecretStorage.isAuthenticated).toBe(false);
+    });
+
+    it("should return true for non-anonymous credentials", async () => {
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "demo",
+      });
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+    });
+
+    it("should return true when the provider is missing", async () => {
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+      } as any);
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+    });
+  });
+
+  describe("onUpdate", () => {
+    it("should add and remove event listener", () => {
+      const handler = vi.fn();
+
+      const removeListener = authSecretStorage.onUpdate(handler);
+
+      authSecretStorage.emitUpdate({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "demo",
+      });
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      handler.mockClear();
+
+      removeListener();
+      authSecretStorage.emitUpdate({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "anonymous",
+      });
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it("should emit events only when the isAuthenticated state changes", () => {
+      const handler = vi.fn();
+
+      authSecretStorage.onUpdate(handler);
+
+      authSecretStorage.emitUpdate({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "demo",
+      });
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      handler.mockClear();
+
+      authSecretStorage.emitUpdate({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "demo",
+      });
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("clear", () => {
+    it("should remove stored credentials", async () => {
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      });
+
+      await authSecretStorage.clear();
+
+      expect(await authSecretStorage.get()).toBeNull();
+    });
+
+    it("should emit update event when clearing", async () => {
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      });
+
+      const handler = vi.fn();
+      authSecretStorage.onUpdate(handler);
+
+      await authSecretStorage.clear();
+
+      expect(handler).toHaveBeenCalled();
+    });
+  });
+});