jazz-tools 0.14.28 → 0.15.1

package/src/browser/tests/LocalStorageKVStore.test.ts

@@ -0,0 +1,67 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it } from "vitest";
+import { LocalStorageKVStore } from "../auth/LocalStorageKVStore";
+
+describe("LocalStorageKVStore", () => {
+  let kvStore: LocalStorageKVStore;
+
+  beforeEach(() => {
+    // Clear localStorage before each test
+    localStorage.clear();
+    kvStore = new LocalStorageKVStore();
+  });
+
+  describe("get", () => {
+    it("should return null for non-existent key", async () => {
+      const value = await kvStore.get("nonexistent");
+      expect(value).toBeNull();
+    });
+
+    it("should return stored value for existing key", async () => {
+      localStorage.setItem("testKey", "testValue");
+      const value = await kvStore.get("testKey");
+      expect(value).toBe("testValue");
+    });
+  });
+
+  describe("set", () => {
+    it("should store value in localStorage", async () => {
+      await kvStore.set("testKey", "testValue");
+      expect(localStorage.getItem("testKey")).toBe("testValue");
+    });
+
+    it("should overwrite existing value", async () => {
+      localStorage.setItem("testKey", "oldValue");
+      await kvStore.set("testKey", "newValue");
+      expect(localStorage.getItem("testKey")).toBe("newValue");
+    });
+  });
+
+  describe("delete", () => {
+    it("should remove item from localStorage", async () => {
+      localStorage.setItem("testKey", "testValue");
+      await kvStore.delete("testKey");
+      expect(localStorage.getItem("testKey")).toBeNull();
+    });
+
+    it("should not throw when deleting non-existent key", async () => {
+      await expect(kvStore.delete("nonexistent")).resolves.not.toThrow();
+    });
+  });
+
+  describe("clearAll", () => {
+    it("should remove all items from localStorage", async () => {
+      localStorage.setItem("key1", "value1");
+      localStorage.setItem("key2", "value2");
+
+      await kvStore.clearAll();
+
+      expect(localStorage.length).toBe(0);
+    });
+
+    it("should work with empty localStorage", async () => {
+      await expect(kvStore.clearAll()).resolves.not.toThrow();
+    });
+  });
+});

package/src/browser/tests/PasskeyAuth.test.ts

@@ -0,0 +1,242 @@
+// @vitest-environment happy-dom
+
+import { AgentSecret } from "cojson";
+import { Account, InMemoryKVStore, KvStoreContext } from "jazz-tools";
+import { ID } from "jazz-tools";
+import { AuthSecretStorage } from "jazz-tools";
+import { createJazzTestAccount } from "jazz-tools/testing";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { BrowserPasskeyAuth } from "../auth/PasskeyAuth";
+
+KvStoreContext.getInstance().initialize(new InMemoryKVStore());
+const authSecretStorage = new AuthSecretStorage();
+
+beforeEach(async () => {
+  await authSecretStorage.clear();
+
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
+describe("BrowserPasskeyAuth", () => {
+  let mockNavigator: any;
+  const mockCrypto = {
+    randomBytes: (l: number) => crypto.getRandomValues(new Uint8Array(l)),
+    newRandomSecretSeed: () => new Uint8Array([1, 2, 3]),
+    agentSecretFromSecretSeed: () => "mock-secret" as AgentSecret,
+  } as any;
+  const mockAuthenticate = vi.fn();
+
+  beforeEach(() => {
+    mockNavigator = {
+      credentials: {
+        create: vi.fn(),
+        get: vi.fn(),
+      },
+    };
+    global.navigator = mockNavigator;
+    mockAuthenticate.mockReset();
+  });
+
+  describe("initialization", () => {
+    it("should initialize with default hostname", () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+      expect(auth.appName).toBe("Test App");
+      expect(auth.appHostname).toBe(window.location.hostname);
+    });
+
+    it("should initialize with custom hostname", () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+        "custom.host",
+      );
+      expect(auth.appHostname).toBe("custom.host");
+    });
+  });
+
+  describe("authentication flows", () => {
+    it("should handle login flow", async () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+
+      mockNavigator.credentials.get.mockResolvedValue({
+        response: {
+          userHandle: new ArrayBuffer(32), // Mocked credential payload
+        },
+      });
+
+      await auth.logIn();
+
+      expect(mockAuthenticate).toHaveBeenCalledWith({
+        accountID: expect.any(String),
+        accountSecret: "mock-secret",
+      });
+
+      expect(await authSecretStorage.get()).toEqual({
+        accountID: expect.any(String),
+        secretSeed: expect.any(Uint8Array),
+        provider: "passkey",
+        accountSecret: "mock-secret",
+      });
+    });
+
+    it("should handle signup flow", async () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+
+      mockNavigator.credentials.create.mockResolvedValue({
+        type: "public-key",
+        id: new Uint8Array([1, 2, 3, 4]),
+      });
+
+      // Set up existing credentials in storage
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "mock-secret" as AgentSecret,
+        provider: "anonymous",
+      });
+
+      await auth.signUp("testuser");
+
+      expect(mockNavigator.credentials.create).toHaveBeenCalledWith({
+        publicKey: expect.objectContaining({
+          rp: {
+            name: "Test App",
+            id: window.location.hostname,
+          },
+          user: expect.objectContaining({
+            displayName: "testuser",
+          }),
+        }),
+      });
+
+      expect(await authSecretStorage.get()).toEqual({
+        accountID: "test123",
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "mock-secret",
+        provider: "passkey",
+      });
+    });
+
+    it("should handle passkey errors during login", async () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+
+      mockNavigator.credentials.get.mockRejectedValue(
+        new Error("User rejected the passkey"),
+      );
+
+      await expect(auth.logIn()).rejects.toThrow("Passkey creation aborted");
+    });
+
+    it("should handle passkey errors during signup", async () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+
+      mockNavigator.credentials.create.mockRejectedValue(
+        new Error("User rejected the passkey"),
+      );
+
+      // Set up existing credentials in storage
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "mock-secret" as AgentSecret,
+        provider: "anonymous",
+      });
+
+      await expect(auth.signUp("testuser")).rejects.toThrow(
+        "Passkey creation aborted",
+      );
+    });
+
+    it("should leave the account profile name unchanged if username is empty", async () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+
+      mockNavigator.credentials.create.mockResolvedValue({
+        type: "public-key",
+        id: new Uint8Array([1, 2, 3, 4]),
+      });
+
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "mock-secret" as AgentSecret,
+        provider: "anonymous",
+      });
+
+      await auth.signUp("");
+
+      const currentAccount = await Account.getMe().ensureLoaded({
+        resolve: {
+          profile: true,
+        },
+      });
+
+      // 'Test Account' is the name provided during account creation (see: `jazz-tools/src/testing.ts`)
+      expect(currentAccount.profile.name).toEqual("Test Account");
+    });
+
+    it("should update the account profile name if username is provided", async () => {
+      const auth = new BrowserPasskeyAuth(
+        mockCrypto,
+        mockAuthenticate,
+        authSecretStorage,
+        "Test App",
+      );
+
+      mockNavigator.credentials.create.mockResolvedValue({
+        type: "public-key",
+        id: new Uint8Array([1, 2, 3, 4]),
+      });
+
+      await authSecretStorage.set({
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "mock-secret" as AgentSecret,
+        provider: "anonymous",
+      });
+
+      await auth.signUp("testuser");
+
+      const currentAccount = await Account.getMe().ensureLoaded({
+        resolve: {
+          profile: true,
+        },
+      });
+
+      expect(currentAccount.profile.name).toEqual("testuser");
+    });
+  });
+});

package/src/browser/tests/createInviteLink.test.ts

@@ -0,0 +1,18 @@
+import { CoMap, co, coField, z } from "jazz-tools";
+import { expect, test } from "vitest";
+import { createInviteLink } from "../index.js";
+import { setupTwoNodes } from "./utils.js";
+
+test("throws an error if the user tried to create an invite from an account owned coValue", async () => {
+  const TestMap = co.map({
+    name: z.string(),
+  });
+
+  const { clientAccount } = await setupTwoNodes();
+
+  const map = TestMap.create({ name: "Alice" }, { owner: clientAccount });
+
+  expect(() =>
+    createInviteLink(map, "admin", { baseURL: "http://localhost:3000" }),
+  ).toThrow("Can't create invite link for object without group");
+});

package/src/browser/tests/storageOptions.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "vitest";
+import { getStorageOptions } from "../storageOptions.js";
+
+describe("getStorageOptions", () => {
+  test("should default to indexedDB only when no storage option is provided", () => {
+    const result = getStorageOptions();
+    expect(result).toEqual({
+      useIndexedDB: true,
+    });
+  });
+
+  test("should enable only indexedDB when 'indexedDB' is provided", () => {
+    const result = getStorageOptions("indexedDB");
+    expect(result).toEqual({
+      useIndexedDB: true,
+    });
+  });
+
+  test("should enable only indexedDB when array with only indexedDB is provided", () => {
+    const result = getStorageOptions(["indexedDB"]);
+    expect(result).toEqual({
+      useIndexedDB: true,
+    });
+  });
+
+  // Type checking tests
+  test("should handle type checking for StorageConfig", () => {
+    // These should compile without type errors
+    getStorageOptions("indexedDB");
+    getStorageOptions(["indexedDB"]);
+    getStorageOptions(undefined);
+  });
+});

package/src/browser/tests/utils.ts

@@ -0,0 +1,93 @@
+import { CoID, LocalNode, RawCoValue } from "cojson";
+import { cojsonInternals } from "cojson";
+import { Account } from "jazz-tools";
+import { TestJSCrypto } from "jazz-tools/testing";
+
+const crypto = await TestJSCrypto.create();
+
+export async function setupTwoNodes() {
+  const [serverAsPeer, clientAsPeer] = cojsonInternals.connectedPeers(
+    "clientToServer",
+    "serverToClient",
+    {
+      peer1role: "server",
+      peer2role: "client",
+    },
+  );
+
+  const client = await LocalNode.withNewlyCreatedAccount({
+    peersToLoadFrom: [serverAsPeer],
+    crypto,
+    creationProps: { name: "Client" },
+    migration: async (rawAccount, _node, creationProps) => {
+      const account = new Account({
+        fromRaw: rawAccount,
+      });
+
+      await account.applyMigration(creationProps);
+    },
+  });
+
+  const server = await LocalNode.withNewlyCreatedAccount({
+    peersToLoadFrom: [clientAsPeer],
+    crypto,
+    creationProps: { name: "Server" },
+    migration: async (rawAccount, _node, creationProps) => {
+      const account = new Account({
+        fromRaw: rawAccount,
+      });
+
+      await account.applyMigration(creationProps);
+    },
+  });
+
+  return {
+    clientNode: client.node,
+    serverNode: server.node,
+    clientAccount: Account.fromRaw(
+      await loadCoValueOrFail(client.node, client.accountID),
+    ),
+    serverAccount: Account.fromRaw(
+      await loadCoValueOrFail(server.node, server.accountID),
+    ),
+  };
+}
+
+export function waitFor(callback: () => boolean | void) {
+  return new Promise<void>((resolve, reject) => {
+    const checkPassed = () => {
+      try {
+        return { ok: callback(), error: null };
+      } catch (error) {
+        return { ok: false, error };
+      }
+    };
+
+    let retries = 0;
+
+    const interval = setInterval(() => {
+      const { ok, error } = checkPassed();
+
+      if (ok !== false) {
+        clearInterval(interval);
+        resolve();
+      }
+
+      if (++retries > 10) {
+        clearInterval(interval);
+        reject(error);
+      }
+    }, 100);
+  });
+}
+
+export async function loadCoValueOrFail<V extends RawCoValue>(
+  node: LocalNode,
+  id: CoID<V>,
+): Promise<V> {
+  const value = await node.load(id);
+  if (value === "unavailable") {
+    throw new Error("CoValue not found");
+  }
+  return value;
+}

package/src/browser/utils/export-account-inspector.ts

@@ -0,0 +1,58 @@
+import { AuthSecretStorage } from "jazz-tools";
+
+async function exportAccountToInspector() {
+  const authSecretStorage = new AuthSecretStorage();
+  const localStorageData = await authSecretStorage.get();
+
+  if (!localStorageData) {
+    console.error("No account data found in localStorage");
+    return;
+  }
+
+  const encodedAccountSecret = btoa(localStorageData.accountSecret);
+  window.open(
+    new URL(
+      `#/import/${localStorageData?.accountID}/${encodedAccountSecret}`,
+      "https://inspector.jazz.tools",
+    ).toString(),
+    "_blank",
+  );
+}
+
+function listenForCmdJ() {
+  if (typeof window === "undefined") return;
+
+  const cb = (e: any) => {
+    if (e.metaKey && e.key === "j") {
+      if (
+        confirm(
+          "Are you sure you want to inspect your account using inspector.jazz.tools? This lets anyone with the secret inspector URL read your data and impersonate you.",
+        )
+      ) {
+        exportAccountToInspector();
+      }
+    }
+  };
+
+  window.addEventListener("keydown", cb);
+
+  return () => {
+    window.removeEventListener("keydown", cb);
+  };
+}
+
+/**
+ * Automatically sets up the Cmd+J listener if 'allowJazzInspector' is present in the URL
+ * @returns A cleanup function if the listener was set up, undefined otherwise
+ */
+export function setupInspector() {
+  if (typeof window === "undefined") return;
+
+  const url = new URL(window.location.href);
+  if (
+    url.hash.includes("allowJazzInspector") ||
+    process.env.NODE_ENV === "development"
+  ) {
+    return listenForCmdJ();
+  }
+}

package/src/browser-media-images/index.ts

@@ -0,0 +1,130 @@
+import ImageBlobReduce from "image-blob-reduce";
+import {
+  Account,
+  FileStream,
+  Group,
+  ImageDefinition,
+  Loaded,
+} from "jazz-tools";
+import Pica from "pica";
+
+let pica: Pica.Pica | undefined;
+
+/** @category Image creation */
+export async function createImage(
+  imageBlobOrFile: Blob | File,
+  options?: {
+    owner?: Group | Account;
+    maxSize?: 256 | 1024 | 2048;
+  },
+): Promise<Loaded<typeof ImageDefinition>> {
+  // Inizialize Pica here to not have module side effects
+  if (!pica) {
+    pica = new Pica();
+  }
+
+  let originalWidth!: number;
+  let originalHeight!: number;
+  const Reducer = new ImageBlobReduce({ pica });
+  Reducer.after("_blob_to_image", (env) => {
+    originalWidth =
+      (env as unknown as { orientation: number }).orientation & 4
+        ? env.image.height
+        : env.image.width;
+    originalHeight =
+      (env as unknown as { orientation: number }).orientation & 4
+        ? env.image.width
+        : env.image.height;
+    return Promise.resolve(env);
+  });
+
+  const placeholderDataURL = (
+    await Reducer.toCanvas(imageBlobOrFile, { max: 8 })
+  ).toDataURL("image/png");
+
+  const imageDefinition = ImageDefinition.create(
+    {
+      originalSize: [originalWidth, originalHeight],
+      placeholderDataURL,
+    },
+    options?.owner,
+  );
+  const owner = imageDefinition._owner;
+
+  const fillImageResolutions = async () => {
+    const max256 = await Reducer.toBlob(imageBlobOrFile, { max: 256 });
+
+    if (originalWidth > 256 || originalHeight > 256) {
+      const width =
+        originalWidth > originalHeight
+          ? 256
+          : Math.round(256 * (originalWidth / originalHeight));
+      const height =
+        originalHeight > originalWidth
+          ? 256
+          : Math.round(256 * (originalHeight / originalWidth));
+
+      const binaryStream = await FileStream.createFromBlob(max256, owner);
+
+      imageDefinition[`${width}x${height}`] = binaryStream;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    if (options?.maxSize === 256) return;
+
+    const max1024 = await Reducer.toBlob(imageBlobOrFile, { max: 1024 });
+
+    if (originalWidth > 1024 || originalHeight > 1024) {
+      const width =
+        originalWidth > originalHeight
+          ? 1024
+          : Math.round(1024 * (originalWidth / originalHeight));
+      const height =
+        originalHeight > originalWidth
+          ? 1024
+          : Math.round(1024 * (originalHeight / originalWidth));
+
+      const binaryStream = await FileStream.createFromBlob(max1024, owner);
+
+      imageDefinition[`${width}x${height}`] = binaryStream;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    if (options?.maxSize === 1024) return;
+
+    const max2048 = await Reducer.toBlob(imageBlobOrFile, { max: 2048 });
+
+    if (originalWidth > 2048 || originalHeight > 2048) {
+      const width =
+        originalWidth > originalHeight
+          ? 2048
+          : Math.round(2048 * (originalWidth / originalHeight));
+      const height =
+        originalHeight > originalWidth
+          ? 2048
+          : Math.round(2048 * (originalHeight / originalWidth));
+
+      const binaryStream = await FileStream.createFromBlob(max2048, owner);
+
+      imageDefinition[`${width}x${height}`] = binaryStream;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    if (options?.maxSize === 2048) return;
+
+    const originalBinaryStream = await FileStream.createFromBlob(
+      imageBlobOrFile,
+      owner,
+    );
+
+    imageDefinition[`${originalWidth}x${originalHeight}`] =
+      originalBinaryStream;
+  };
+
+  await fillImageResolutions();
+
+  return imageDefinition;
+}

package/src/expo/auth/clerk/README.md

@@ -0,0 +1,44 @@
+# `jazz-tools/expo/auth/clerk`
+
+This package import provides a [Clerk-based](https://clerk.com/) authentication strategy for Jazz.
+
+## Usage
+
+The `JazzExpoProviderWithClerk` component is a JazzExpoProvider that automatically handles Clerk authentication.
+
+Once authenticated, authentication will persist across page reloads, even if the device is offline.
+
+See the full [example app](https://github.com/garden-co/jazz/tree/main/examples/clerk) for a complete example.
+
+```tsx
+import { ClerkProvider, useClerk } from "@clerk/clerk-react";
+import { JazzExpoProviderWithClerk } from "jazz-tools/expo";
+
+const PUBLISHABLE_KEY = import.meta.env.VITE_CLERK_PUBLISHABLE_KEY;
+
+function JazzProvider({ children }: { children: React.ReactNode }) {
+  const clerk = useClerk();
+
+  return (
+    <JazzExpoProviderWithClerk
+      clerk={clerk}
+      sync={{
+        peer: "wss://cloud.jazz.tools/?key=chat-rn-expo-clerk-example-jazz@garden.co",
+      }}
+    >
+      {children}
+    </JazzExpoProviderWithClerk>
+  );
+}
+
+
+export default function App() {
+  return (
+    <ClerkProvider publishableKey={PUBLISHABLE_KEY} afterSignOutUrl="/">
+      <JazzProvider>
+        <Slot />
+      </JazzProvider>
+    </ClerkProvider>
+  );
+}
+```