jazz-tools 0.9.23 → 0.10.0

package/src/tests/ContextManager.test.ts

@@ -0,0 +1,256 @@
+import { WasmCrypto } from "cojson";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import {
+  Account,
+  AccountClass,
+  AuthSecretStorage,
+  CoMap,
+  Group,
+  InMemoryKVStore,
+  JazzAuthContext,
+  KvStoreContext,
+  co,
+} from "../exports";
+import {
+  JazzContextManager,
+  JazzContextManagerAuthProps,
+  JazzContextManagerBaseProps,
+} from "../implementation/ContextManager";
+import {
+  createJazzContext,
+  randomSessionProvider,
+} from "../implementation/createContext";
+import {
+  createJazzTestAccount,
+  getPeerConnectedToTestSyncServer,
+  setupJazzTestSync,
+} from "../testing";
+
+const Crypto = await WasmCrypto.create();
+
+class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
+  Acc,
+  JazzContextManagerBaseProps<Acc> & {
+    defaultProfileName?: string;
+    AccountSchema?: AccountClass<Acc>;
+  }
+> {
+  async createContext(
+    props: JazzContextManagerBaseProps<Acc> & {
+      defaultProfileName?: string;
+      AccountSchema?: AccountClass<Acc>;
+    },
+    authProps?: JazzContextManagerAuthProps,
+  ) {
+    const context = await createJazzContext<Acc>({
+      credentials: authProps?.credentials,
+      defaultProfileName: props.defaultProfileName,
+      newAccountProps: authProps?.newAccountProps,
+      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      crypto: Crypto,
+      sessionProvider: randomSessionProvider,
+      authSecretStorage: this.getAuthSecretStorage(),
+      AccountSchema: props.AccountSchema,
+    });
+
+    this.updateContext(props, {
+      me: context.account,
+      node: context.node,
+      done: () => {
+        context.done();
+      },
+      logOut: () => {
+        context.logOut();
+      },
+    });
+  }
+}
+
+describe("ContextManager", () => {
+  let manager: TestJazzContextManager<Account>;
+  let authSecretStorage: AuthSecretStorage;
+
+  function getCurrentValue() {
+    return manager.getCurrentValue() as JazzAuthContext<Account>;
+  }
+
+  beforeEach(async () => {
+    KvStoreContext.getInstance().initialize(new InMemoryKVStore());
+    authSecretStorage = new AuthSecretStorage();
+    await authSecretStorage.clear();
+    await setupJazzTestSync();
+
+    manager = new TestJazzContextManager<Account>();
+  });
+
+  test("creates new context when initialized", async () => {
+    await manager.createContext({});
+
+    const context = getCurrentValue();
+
+    expect(context.me.profile?.name).toBe("Anonymous user");
+    expect(context.node).toBeDefined();
+    expect(manager.getCurrentValue()).toBeDefined();
+  });
+
+  test("creates new context when initialized with default profile name", async () => {
+    await manager.createContext({
+      defaultProfileName: "Test User",
+    });
+
+    const context = getCurrentValue();
+
+    expect(context.me.profile?.name).toBe("Test User");
+    expect(context.node).toBeDefined();
+    expect(manager.getCurrentValue()).toBeDefined();
+  });
+
+  test("handles authentication with credentials", async () => {
+    const account = await createJazzTestAccount();
+
+    // First create an initial context to get credentials
+    await manager.createContext({});
+
+    const credentials = {
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    };
+
+    // Authenticate with those credentials
+    await manager.authenticate(credentials);
+
+    expect(getCurrentValue().me.id).toBe(credentials.accountID);
+  });
+
+  test("calls onLogOut callback when logging out", async () => {
+    const onLogOut = vi.fn();
+    await manager.createContext({ onLogOut });
+
+    await manager.logOut();
+
+    expect(onLogOut).toHaveBeenCalled();
+  });
+
+  test("notifies listeners of context changes", async () => {
+    const listener = vi.fn();
+    manager.subscribe(listener);
+
+    await manager.createContext({});
+
+    expect(listener).toHaveBeenCalled();
+  });
+
+  test("cleans up context when done", async () => {
+    await manager.createContext({});
+
+    const context = manager.getCurrentValue();
+    expect(context).toBeDefined();
+
+    manager.done();
+
+    // Should still have context, just cleaned up
+    expect(manager.getCurrentValue()).toBe(context);
+  });
+
+  test("calls onAnonymousAccountDiscarded when authenticating from anonymous user", async () => {
+    const onAnonymousAccountDiscarded = vi.fn();
+    const account = await createJazzTestAccount();
+
+    // Create initial anonymous context
+    await manager.createContext({ onAnonymousAccountDiscarded });
+    const anonymousAccount = getCurrentValue().me;
+
+    // Authenticate with credentials
+    await manager.authenticate({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    // Verify callback was called with the anonymous account
+    expect(onAnonymousAccountDiscarded).toHaveBeenCalledWith(anonymousAccount);
+  });
+
+  test("does not call onAnonymousAccountDiscarded when authenticating from authenticated user", async () => {
+    const onAnonymousAccountDiscarded = vi.fn();
+    const account = await createJazzTestAccount();
+
+    await manager.getAuthSecretStorage().set({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    // Create initial authenticated context
+    await manager.createContext({ onAnonymousAccountDiscarded });
+
+    // Authenticate with same credentials
+    await manager.authenticate({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    // Verify callback was not called
+    expect(onAnonymousAccountDiscarded).not.toHaveBeenCalled();
+  });
+
+  test("onAnonymousAccountDiscarded should work on transfering data between accounts", async () => {
+    class AccountRoot extends CoMap {
+      value = co.string;
+      transferredRoot = co.optional.ref(AccountRoot);
+    }
+
+    class CustomAccount extends Account {
+      root = co.ref(AccountRoot);
+
+      migrate() {
+        if (this.root === undefined) {
+          this.root = AccountRoot.create({
+            value: "Hello",
+          });
+        }
+      }
+    }
+
+    const onAnonymousAccountDiscarded = async (
+      anonymousAccount: CustomAccount,
+    ) => {
+      const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
+        root: {},
+      });
+
+      const meWithRoot = await CustomAccount.getMe().ensureLoaded({ root: {} });
+
+      const rootToTransfer = anonymousAccountWithRoot.root;
+
+      await rootToTransfer._owner.castAs(Group).addMember(meWithRoot, "admin");
+
+      meWithRoot.root.transferredRoot = rootToTransfer;
+    };
+
+    const customManager = new TestJazzContextManager<CustomAccount>();
+
+    // Create initial anonymous context
+    await customManager.createContext({
+      onAnonymousAccountDiscarded,
+      AccountSchema: CustomAccount,
+    });
+
+    const account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      AccountSchema: CustomAccount,
+    });
+
+    await customManager.authenticate({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    const me = await CustomAccount.getMe().ensureLoaded({ root: {} });
+
+    expect(me.root.transferredRoot?.value).toBe("Hello");
+  });
+});

package/src/tests/DemoAuth.test.ts

@@ -0,0 +1,269 @@
+import { AgentSecret } from "cojson";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { AuthSecretStorage } from "../auth/AuthSecretStorage";
+import { DemoAuth } from "../auth/DemoAuth";
+import { InMemoryKVStore } from "../auth/InMemoryKVStore";
+import { KvStoreContext } from "../auth/KvStoreContext";
+import { Account } from "../coValues/account";
+import { ID } from "../internal";
+import { createJazzTestAccount } from "../testing";
+
+// Initialize KV store for tests
+const kvStore = new InMemoryKVStore();
+KvStoreContext.getInstance().initialize(kvStore);
+
+describe("DemoAuth", () => {
+  let mockAuthenticate: any;
+  let authSecretStorage: AuthSecretStorage;
+  let demoAuth: DemoAuth;
+
+  beforeEach(async () => {
+    // Reset mock authenticate
+    mockAuthenticate = vi.fn();
+
+    // Clear KV store
+    kvStore.clearAll();
+
+    // Create new AuthSecretStorage instance
+    authSecretStorage = new AuthSecretStorage();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    // Create DemoAuth instance
+    demoAuth = new DemoAuth(mockAuthenticate, authSecretStorage);
+  });
+
+  describe("logIn", () => {
+    test("should successfully log in existing user", async () => {
+      const testUser = "testUser";
+
+      const credentials = {
+        accountID: "new-account-id" as ID<Account>,
+        accountSecret: "new-secret" as AgentSecret,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "anonymous",
+      };
+
+      await authSecretStorage.set(credentials);
+
+      await demoAuth.signUp(testUser);
+
+      await demoAuth.logIn(testUser);
+
+      expect(mockAuthenticate).toHaveBeenCalledWith({
+        accountID: credentials.accountID,
+        accountSecret: credentials.accountSecret,
+      });
+
+      const storedData = await authSecretStorage.get();
+      expect(storedData).toEqual({
+        accountID: credentials.accountID,
+        accountSecret: credentials.accountSecret,
+        secretSeed: credentials.secretSeed,
+        provider: "demo",
+      });
+    });
+
+    test("should throw error for non-existent user", async () => {
+      await expect(demoAuth.logIn("nonexistentUser")).rejects.toThrow(
+        "User not found",
+      );
+    });
+  });
+
+  describe("signUp", () => {
+    test("should successfully sign up new user", async () => {
+      const testUser = "newUser";
+      const credentials = {
+        accountID: "new-account-id" as ID<Account>,
+        accountSecret: "new-secret" as AgentSecret,
+        secretSeed: new Uint8Array([1, 2, 3]),
+      };
+
+      await authSecretStorage.set({
+        ...credentials,
+        provider: "anonymous",
+      });
+
+      await demoAuth.signUp(testUser);
+
+      const storedData = await authSecretStorage.get();
+      expect(storedData).toEqual({
+        ...credentials,
+        provider: "demo",
+      });
+    });
+
+    test("should throw error for existing username", async () => {
+      const testUser = "existingUser";
+      await kvStore.set("demo-auth-storage-version", "3");
+      await kvStore.set(
+        "demo-auth-users",
+        JSON.stringify({
+          [testUser]: {
+            accountID: "existing-account-id" as ID<Account>,
+            accountSecret: "existing-secret" as AgentSecret,
+            secretSeed: [1, 2, 3],
+          },
+        }),
+      );
+
+      await expect(demoAuth.signUp(testUser)).rejects.toThrow(
+        "User already registered",
+      );
+    });
+
+    test("should throw error when no credentials found", async () => {
+      await expect(demoAuth.signUp("newUser")).rejects.toThrow(
+        "No credentials found",
+      );
+    });
+  });
+
+  describe("DemoAuth Storage Migration", () => {
+    test("should migrate from version 1 to version 3", async () => {
+      // Set up version 1 data
+      const testUser = "test@example.com";
+      const storageData = {
+        accountID: "test-account-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: [1, 2, 3],
+      };
+
+      // Store data in old format
+      await kvStore.set("demo-auth-existing-users", testUser);
+      await kvStore.set(
+        `demo-auth-existing-users-${testUser}`,
+        JSON.stringify(storageData),
+      );
+
+      // Trigger migration by getting existing users
+      await demoAuth.getExistingUsers();
+
+      // Verify migration
+      const version = await kvStore.get("demo-auth-storage-version");
+      expect(version).toBe("3");
+
+      // Old key should be deleted
+      const oldData = await kvStore.get(`demo-auth-existing-users-${testUser}`);
+      expect(oldData).toBeNull();
+
+      // New encoded key should exist
+      const newData = await kvStore.get("demo-auth-users");
+      expect(JSON.parse(newData!)).toEqual({
+        [testUser]: storageData,
+      });
+    });
+
+    test("should migrate from version 2 to version 3 (new storage format)", async () => {
+      // Set up version 2 data
+      const testUser = "test@example.com";
+      const encodedUsername = btoa(testUser)
+        .replace(/=/g, "-")
+        .replace(/\+/g, "_")
+        .replace(/\//g, ".");
+
+      const storageData = {
+        accountID: "test-account-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: [1, 2, 3],
+      };
+
+      // Store data in version 2 format
+      await kvStore.set("demo-auth-storage-version", "2");
+      await kvStore.set("demo-auth-existing-users", testUser);
+      await kvStore.set(
+        `demo-auth-existing-users-${encodedUsername}`,
+        JSON.stringify(storageData),
+      );
+
+      // Trigger migration by getting existing users
+      await demoAuth.getExistingUsers();
+
+      // Verify migration
+      const version = await kvStore.get("demo-auth-storage-version");
+      expect(version).toBe("3");
+
+      // Old keys should be deleted
+      const oldListData = await kvStore.get("demo-auth-existing-users");
+      expect(oldListData).toBeNull();
+
+      const oldUserData = await kvStore.get(
+        `demo-auth-existing-users-${encodedUsername}`,
+      );
+      expect(oldUserData).toBeNull();
+
+      // New storage format should be used
+      const newData = await kvStore.get("demo-auth-users");
+      expect(JSON.parse(newData!)).toEqual({
+        [testUser]: storageData,
+      });
+    });
+
+    test("should handle new users management after migration", async () => {
+      // Add a test user
+      const testUser = "newuser";
+      await authSecretStorage.set({
+        accountID: "test-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "anonymous",
+      });
+
+      // Sign up new user
+      await demoAuth.signUp(testUser);
+
+      // Verify user is stored in new format
+      const usersData = await kvStore.get("demo-auth-users");
+      const users = JSON.parse(usersData!);
+
+      expect(Object.keys(users)).toContain(testUser);
+      expect(users[testUser]).toEqual({
+        accountID: "test-id",
+        accountSecret: "test-secret",
+        secretSeed: [1, 2, 3],
+      });
+
+      // Verify we can get existing users
+      const existingUsers = await demoAuth.getExistingUsers();
+      expect(existingUsers).toEqual([testUser]);
+
+      // Verify we can log in with the stored user
+      await demoAuth.logIn(testUser);
+      const storedAuth = await authSecretStorage.get();
+      expect(storedAuth).toEqual({
+        accountID: "test-id",
+        accountSecret: "test-secret",
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "demo",
+      });
+    });
+
+    test("should handle multiple users in new storage format", async () => {
+      // Set up initial auth data
+      await authSecretStorage.set({
+        accountID: "test-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        provider: "anonymous",
+      });
+
+      // Add multiple users
+      const users = ["user1", "user2", "user3"];
+      for (const user of users) {
+        await demoAuth.signUp(user);
+      }
+
+      // Verify all users are stored
+      const existingUsers = await demoAuth.getExistingUsers();
+      expect(existingUsers.sort()).toEqual(users.sort());
+
+      // Verify we can't add duplicate users
+      await expect(demoAuth.signUp("user1")).rejects.toThrow(
+        "User already registered",
+      );
+    });
+  });
+});

package/src/tests/PassphraseAuth.test.ts

@@ -0,0 +1,152 @@
+// @vitest-environment happy-dom
+
+import { mnemonicToEntropy } from "@scure/bip39";
+import { AgentSecret } from "cojson";
+import {
+  Account,
+  AuthSecretStorage,
+  ID,
+  InMemoryKVStore,
+  KvStoreContext,
+} from "jazz-tools";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { PassphraseAuth } from "../auth/PassphraseAuth";
+import { createJazzTestAccount } from "../testing";
+import { TestJSCrypto } from "../testing";
+import { testWordlist } from "./fixtures";
+
+// Initialize KV store for tests
+KvStoreContext.getInstance().initialize(new InMemoryKVStore());
+
+describe("PassphraseAuth", () => {
+  let crypto: TestJSCrypto;
+  let mockAuthenticate: any;
+  let authSecretStorage: AuthSecretStorage;
+  let passphraseAuth: PassphraseAuth;
+
+  beforeEach(async () => {
+    // Reset storage
+    KvStoreContext.getInstance().getStorage().clearAll();
+
+    // Set up crypto and mocks
+    crypto = await TestJSCrypto.create();
+    mockAuthenticate = vi.fn();
+    authSecretStorage = new AuthSecretStorage();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    // Create PassphraseAuth instance
+    passphraseAuth = new PassphraseAuth(
+      crypto,
+      mockAuthenticate,
+      authSecretStorage,
+      testWordlist,
+    );
+  });
+
+  describe("logIn", () => {
+    it("should successfully log in with valid passphrase", async () => {
+      const storageData = {
+        accountID: "test-account-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: new Uint8Array([
+          173, 58, 235, 40, 67, 188, 236, 11, 107, 237, 97, 23, 182, 49, 188,
+          63, 237, 52, 27, 84, 142, 66, 244, 149, 243, 114, 203, 164, 115, 239,
+          175, 194,
+        ]),
+        provider: "anonymous",
+      };
+
+      await authSecretStorage.set(storageData);
+
+      // Generate a valid passphrase
+      const passphrase = await passphraseAuth.getCurrentAccountPassphrase();
+
+      await passphraseAuth.logIn(passphrase);
+
+      expect(mockAuthenticate).toHaveBeenCalledWith({
+        accountID: expect.any(String),
+        accountSecret: expect.any(String),
+      });
+
+      const storedData = await authSecretStorage.get();
+      expect(storedData).toEqual({
+        accountID: expect.any(String),
+        accountSecret: expect.any(String),
+        secretSeed: storageData.secretSeed,
+        provider: "passphrase",
+      });
+    });
+
+    it("should throw error with invalid passphrase", async () => {
+      await expect(passphraseAuth.logIn("invalid words here")).rejects.toThrow(
+        "Invalid passphrase",
+      );
+    });
+  });
+
+  describe("signUp", () => {
+    it("should successfully sign up new user", async () => {
+      const storageData = {
+        accountID: "test-account-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: new Uint8Array([
+          173, 58, 235, 40, 67, 188, 236, 11, 107, 237, 97, 23, 182, 49, 188,
+          63, 237, 52, 27, 84, 142, 66, 244, 149, 243, 114, 203, 164, 115, 239,
+          175, 194,
+        ]),
+        provider: "anonymous",
+      };
+
+      await authSecretStorage.set(storageData);
+
+      const passphrase = await passphraseAuth.signUp();
+
+      const storedData = await authSecretStorage.get();
+      expect(storedData).toEqual({
+        accountID: storageData.accountID,
+        accountSecret: storageData.accountSecret,
+        secretSeed: storageData.secretSeed,
+        provider: "passphrase",
+      });
+      expect(passphrase).toMatchInlineSnapshot(
+        `"pudding struggle skate manual solution aisle quick promote bless ranch humor lemon spy asset fall sign virus question syrup nuclear elbow water sample garden"`,
+      );
+    });
+
+    it("should throw error when no credentials found", async () => {
+      await expect(passphraseAuth.signUp()).rejects.toThrow(
+        "No credentials found",
+      );
+    });
+  });
+
+  describe("getCurrentAccountPassphrase", () => {
+    it("should return current user passphrase when credentials exist", async () => {
+      const storageData = {
+        accountID: "test-account-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: crypto.newRandomSecretSeed(),
+        provider: "anonymous",
+      };
+
+      await authSecretStorage.set(storageData);
+
+      // First sign up to create valid credentials
+      const originalPassphrase = await passphraseAuth.signUp();
+
+      // Then get the current passphrase
+      const retrievedPassphrase =
+        await passphraseAuth.getCurrentAccountPassphrase();
+      expect(retrievedPassphrase).toBe(originalPassphrase);
+    });
+
+    it("should throw error when no credentials found", async () => {
+      await expect(
+        passphraseAuth.getCurrentAccountPassphrase(),
+      ).rejects.toThrow("No credentials found");
+    });
+  });
+});