jazz-react-native 0.9.23 → 0.10.0

package/src/createWebSocketPeerWithReconnection.ts

@@ -1,79 +0,0 @@
-import NetInfo from "@react-native-community/netinfo";
-import { Peer } from "cojson";
-import { createWebSocketPeer } from "cojson-transport-ws";
-
-export function createWebSocketPeerWithReconnection(
-  peer: string,
-  reconnectionTimeout: number | undefined,
-  addPeer: (peer: Peer) => void,
-) {
-  const firstWsPeer = createWebSocketPeer({
-    websocket: new WebSocket(peer),
-    id: peer,
-    role: "server",
-    onClose: reconnectWebSocket,
-  });
-
-  const initialReconnectionTimeout = reconnectionTimeout || 500;
-  let shouldTryToReconnect = true;
-  let currentReconnectionTimeout = initialReconnectionTimeout;
-
-  const unsubscribeNetworkChange = NetInfo.addEventListener((state) => {
-    if (state.isConnected) {
-      currentReconnectionTimeout = initialReconnectionTimeout;
-    }
-  });
-
-  async function reconnectWebSocket() {
-    if (!shouldTryToReconnect) return;
-
-    console.log(
-      "Websocket disconnected, trying to reconnect in " +
-        currentReconnectionTimeout +
-        "ms",
-    );
-    currentReconnectionTimeout = Math.min(
-      currentReconnectionTimeout * 2,
-      30000,
-    );
-
-    await waitForOnline(currentReconnectionTimeout);
-
-    if (!shouldTryToReconnect) return;
-
-    addPeer(
-      createWebSocketPeer({
-        websocket: new WebSocket(peer),
-        id: peer,
-        role: "server",
-        onClose: reconnectWebSocket,
-      }),
-    );
-  }
-
-  return {
-    peer: firstWsPeer,
-    done: () => {
-      shouldTryToReconnect = false;
-      unsubscribeNetworkChange();
-    },
-  };
-}
-
-function waitForOnline(timeout: number) {
-  return new Promise<void>((resolve) => {
-    const unsubscribeNetworkChange = NetInfo.addEventListener((state) => {
-      if (state.isConnected) {
-        handleTimeoutOrOnline();
-      }
-    });
-
-    function handleTimeoutOrOnline() {
-      clearTimeout(timer);
-      unsubscribeNetworkChange();
-      resolve();
-    }
-
-    const timer = setTimeout(handleTimeoutOrOnline, timeout);
-  });
-}

package/src/tests/DemoAuthMethod.test.ts

@@ -1,309 +0,0 @@
-import { AgentSecret } from "cojson";
-import { Account, ID } from "jazz-tools";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { RNDemoAuth, encodeUsername } from "../auth/DemoAuthMethod";
-import { KvStore, KvStoreContext } from "../storage/kv-store-context";
-
-// Initialize mock storage
-const mockStorage: { [key: string]: string } = {};
-
-function validateKey(key: string) {
-  if (key.includes("+") || key.includes("/") || key.includes("=")) {
-    throw new Error("Invalid key");
-  }
-}
-
-// Mock KvStore implementation
-const mockKvStore: KvStore = {
-  get: vi.fn(async (key: string) => {
-    validateKey(key);
-    return mockStorage[key] || null;
-  }),
-  set: vi.fn(async (key: string, value: string) => {
-    validateKey(key);
-
-    mockStorage[key] = value;
-  }),
-  delete: vi.fn(async (key: string) => {
-    validateKey(key);
-    delete mockStorage[key];
-  }),
-  clearAll: vi.fn(async () => {
-    Object.keys(mockStorage).forEach((key) => delete mockStorage[key]);
-  }),
-};
-
-KvStoreContext.getInstance().initialize(mockKvStore);
-
-beforeEach(() => {
-  mockKvStore.clearAll();
-  vi.clearAllMocks();
-});
-
-function setup() {
-  const mockDriver: RNDemoAuth.Driver = {
-    onReady: vi.fn(),
-    onSignedIn: vi.fn(),
-    onError: vi.fn(),
-  };
-
-  return {
-    mockStorage,
-    mockKvStore,
-    mockDriver,
-  };
-}
-
-describe("RNDemoAuth", () => {
-  describe("initialization", () => {
-    it("should initialize with seed accounts", async () => {
-      const { mockKvStore, mockDriver } = setup();
-
-      const seedAccounts = {
-        testUser: {
-          accountID: "test-account-id" as ID<Account>,
-          accountSecret: "test-secret" as AgentSecret,
-        },
-      };
-
-      await RNDemoAuth.init(mockDriver, seedAccounts);
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users",
-        "testUser",
-      );
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users-" + encodeUsername("testUser"),
-        expect.any(String),
-      );
-    });
-  });
-
-  describe("authentication", () => {
-    it("should handle new user signup", async () => {
-      const { mockDriver } = setup();
-
-      mockDriver.onReady = vi.fn(({ signUp }) => {
-        signUp("testUser");
-      });
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      expect(mockDriver.onReady).toHaveBeenCalled();
-      expect(result.type).toBe("new");
-      expect(result.saveCredentials).toBeDefined();
-    });
-
-    it("should convert unsupported chars from base64 to a valid key", async () => {
-      const { mockDriver } = setup();
-
-      mockDriver.onReady = vi.fn(({ signUp }) => {
-        signUp(atob("+/=="));
-      });
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      expect(mockDriver.onReady).toHaveBeenCalled();
-      expect(result.type).toBe("new");
-      expect(result.saveCredentials).toBeDefined();
-    });
-
-    it("should handle existing user login", async () => {
-      const { mockStorage, mockDriver } = setup();
-
-      // Set up existing user in storage
-      const existingUser = {
-        accountID: "test-account-id" as ID<Account>,
-        accountSecret: "test-secret" as AgentSecret,
-      };
-
-      mockStorage["demo-auth-logged-in-secret"] = JSON.stringify(existingUser);
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      if (result.type !== "existing") {
-        throw new Error("Result is not a existing user");
-      }
-
-      expect(result.type).toBe("existing");
-      expect(result.credentials).toEqual({
-        accountID: existingUser.accountID,
-        secret: existingUser.accountSecret,
-      });
-    });
-
-    it("should handle logout", async () => {
-      const { mockKvStore, mockDriver } = setup();
-
-      mockDriver.onReady = vi.fn(({ signUp }) => {
-        signUp("testUser");
-      });
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      await result.logOut();
-      expect(mockKvStore.delete).toHaveBeenCalledWith(
-        "demo-auth-logged-in-secret",
-      );
-    });
-  });
-
-  describe("user management", () => {
-    it("should signup a new user", async () => {
-      const { mockKvStore, mockDriver } = setup();
-
-      mockDriver.onReady = vi.fn(({ signUp }) => {
-        return signUp("testUser");
-      });
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      if (result.type !== "new") {
-        throw new Error("Result is not a new user");
-      }
-
-      await result.saveCredentials({
-        accountID: "test-account-id" as ID<Account>,
-        secret: "test-secret" as AgentSecret,
-      });
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users-" + encodeUsername("testUser"),
-        expect.any(String),
-      );
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users",
-        "testUser",
-      );
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-logged-in-secret",
-        expect.any(String),
-      );
-    });
-
-    it("should login an existing user", async () => {
-      const { mockStorage, mockKvStore, mockDriver } = setup();
-
-      const credentials = {
-        accountID: "test-account-id" as ID<Account>,
-        accountSecret: "test-secret" as AgentSecret,
-      };
-
-      mockStorage["demo-auth-existing-users-" + encodeUsername("testUser")] =
-        JSON.stringify(credentials);
-
-      mockDriver.onReady = vi.fn(({ logInAs }) => {
-        return logInAs("testUser");
-      });
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      if (result.type !== "existing") {
-        throw new Error("Result is not a existing user");
-      }
-
-      expect(result.credentials).toEqual({
-        accountID: credentials.accountID,
-        secret: credentials.accountSecret,
-      });
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-logged-in-secret",
-        JSON.stringify(credentials),
-      );
-    });
-
-    it("should handle duplicate usernames by adding suffix", async () => {
-      const { mockStorage, mockKvStore, mockDriver } = setup();
-
-      mockDriver.onReady = vi.fn(({ signUp }) => {
-        return signUp("testUser");
-      });
-      mockStorage["demo-auth-existing-users"] = "testUser";
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      if (result.type !== "new") {
-        throw new Error("Result is not a new user");
-      }
-
-      await result.saveCredentials({
-        accountID: "test-account-id" as ID<Account>,
-        secret: "test-secret" as AgentSecret,
-      });
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users-" + encodeUsername("testUser-2"),
-        expect.any(String),
-      );
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users",
-        "testUser,testUser-2",
-      );
-    });
-
-    it("should retrieve existing users", async () => {
-      const { mockStorage, mockDriver } = setup();
-
-      mockDriver.onReady = vi.fn(({ signUp }) => {
-        return signUp("testUser");
-      });
-
-      mockStorage["demo-auth-existing-users"] = "user1,user2,user3";
-
-      const auth = await RNDemoAuth.init(mockDriver);
-      const result = await auth.start();
-
-      if (result.type !== "new") {
-        throw new Error("Result is not a new user");
-      }
-
-      await result.saveCredentials({
-        accountID: "test-account-id" as ID<Account>,
-        secret: "test-secret" as AgentSecret,
-      });
-
-      const onReadyCall = vi.mocked(mockDriver.onReady).mock.calls[0]![0];
-      const existingUsers = await onReadyCall.getExistingUsers();
-
-      expect(existingUsers).toEqual(["user1", "user2", "user3", "testUser"]);
-    });
-
-    it("should migrate legacy user keys to the new format", async () => {
-      const { mockStorage, mockKvStore, mockDriver } = setup();
-
-      const value = JSON.stringify({
-        accountID: "test-account-id" as ID<Account>,
-        accountSecret: "test-secret" as AgentSecret,
-      });
-
-      mockStorage["demo-auth-existing-users"] = "testUser";
-      mockStorage["demo-auth-existing-users-testUser"] = value;
-
-      await RNDemoAuth.init(mockDriver);
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-existing-users-" + encodeUsername("testUser"),
-        value,
-      );
-
-      expect(mockKvStore.set).toHaveBeenCalledWith(
-        "demo-auth-storage-version",
-        "2",
-      );
-
-      expect(mockKvStore.delete).toHaveBeenCalledWith(
-        "demo-auth-existing-users-testUser",
-      );
-    });
-  });
-});

package/src/tests/createWebSocketPeerWithReconnection.test.ts

@@ -1,163 +0,0 @@
-// @vitest-environment happy-dom
-
-import NetInfo, {
-  NetInfoChangeHandler,
-  NetInfoState,
-} from "@react-native-community/netinfo";
-import { createWebSocketPeer } from "cojson-transport-ws";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { createWebSocketPeerWithReconnection } from "../createWebSocketPeerWithReconnection.js";
-
-// Mock WebSocket
-class MockWebSocket {
-  addEventListener = vi.fn();
-  removeEventListener = vi.fn();
-  close = vi.fn();
-  readyState = 1;
-}
-
-vi.mock("@react-native-community/netinfo", async () => {
-  return {
-    default: {
-      addEventListener: vi.fn(),
-    },
-  };
-});
-
-vi.mock("cojson-transport-ws", () => ({
-  createWebSocketPeer: vi.fn().mockImplementation(({ onClose }) => ({
-    id: "test-peer",
-    incoming: { push: vi.fn() },
-    outgoing: { push: vi.fn(), close: vi.fn() },
-    onClose,
-  })),
-}));
-
-let listeners = new Set<NetInfoChangeHandler>();
-let unsubscribe: (() => void) | undefined = undefined;
-
-function mockNetInfo() {
-  listeners.clear();
-  vi.mocked(NetInfo.addEventListener).mockImplementation((listener) => {
-    listeners.add(listener);
-    unsubscribe = vi.fn();
-    return unsubscribe;
-  });
-}
-
-function dispatchNetInfoChange(isConnected: boolean) {
-  listeners.forEach((listener) => listener({ isConnected } as NetInfoState));
-}
-
-describe("createWebSocketPeerWithReconnection", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.stubGlobal("WebSocket", MockWebSocket);
-    mockNetInfo();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  test("should reset reconnection timeout when coming online", async () => {
-    vi.useFakeTimers();
-    const addPeerMock = vi.fn();
-
-    const { done } = createWebSocketPeerWithReconnection(
-      "ws://localhost:8080",
-      500,
-      addPeerMock,
-    );
-
-    // Simulate multiple disconnections to increase timeout
-    const initialPeer = vi.mocked(createWebSocketPeer).mock.results[0]!.value;
-    initialPeer.onClose();
-
-    await vi.advanceTimersByTimeAsync(1000);
-
-    expect(addPeerMock).toHaveBeenCalledTimes(1);
-
-    vi.mocked(createWebSocketPeer).mock.results[1]!.value.onClose();
-    await vi.advanceTimersByTimeAsync(2000);
-
-    expect(addPeerMock).toHaveBeenCalledTimes(2);
-
-    // Resets the timeout to initial value
-    dispatchNetInfoChange(true);
-
-    // Next reconnection should use initial timeout
-    vi.mocked(createWebSocketPeer).mock.results[2]!.value.onClose();
-    await vi.advanceTimersByTimeAsync(1000);
-
-    expect(addPeerMock).toHaveBeenCalledTimes(3);
-
-    done();
-  });
-
-  test("should wait for online event or timeout before reconnecting", async () => {
-    vi.useFakeTimers();
-
-    const addPeerMock = vi.fn();
-    const { done } = createWebSocketPeerWithReconnection(
-      "ws://localhost:8080",
-      500,
-      addPeerMock,
-    );
-
-    const initialPeer = vi.mocked(createWebSocketPeer).mock.results[0]!.value;
-
-    // Simulate offline state
-    vi.stubGlobal("navigator", { onLine: false });
-
-    initialPeer.onClose();
-
-    // Advance timer but not enough to trigger reconnection
-    await vi.advanceTimersByTimeAsync(500);
-    expect(createWebSocketPeer).toHaveBeenCalledTimes(1);
-
-    // Simulate coming back online
-    dispatchNetInfoChange(true);
-
-    // Wait for event loop to settle
-    await Promise.resolve().then();
-
-    // Should reconnect immediately after coming online
-    expect(createWebSocketPeer).toHaveBeenCalledTimes(2);
-
-    done();
-  });
-
-  test("should clean up event listeners when done", () => {
-    const addPeerMock = vi.fn();
-    const { done } = createWebSocketPeerWithReconnection(
-      "ws://localhost:8080",
-      1000,
-      addPeerMock,
-    );
-
-    done();
-
-    expect(unsubscribe).toHaveBeenCalled();
-  });
-
-  test("should not attempt reconnection after done is called", async () => {
-    vi.useFakeTimers();
-
-    const addPeerMock = vi.fn();
-    const { done } = createWebSocketPeerWithReconnection(
-      "ws://localhost:8080",
-      500,
-      addPeerMock,
-    );
-
-    const initialPeer = vi.mocked(createWebSocketPeer).mock.results[0]!.value;
-
-    done();
-
-    initialPeer.onClose();
-    await vi.advanceTimersByTimeAsync(1000);
-
-    expect(createWebSocketPeer).toHaveBeenCalledTimes(1);
-  });
-});