jazz-tools 0.19.7 → 0.19.10

package/src/tools/tests/deepLoading.test.ts

@@ -1,6 +1,14 @@
 import { cojsonInternals } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { assert, describe, expect, expectTypeOf, test, vi } from "vitest";
+import {
+  assert,
+  beforeEach,
+  describe,
+  expect,
+  expectTypeOf,
+  test,
+  vi,
+} from "vitest";
 import {
   Group,
   ID,
@@ -11,17 +19,17 @@ import {
 } from "../index.js";
 import {
   Account,
-  CoList,
   Loaded,
   MaybeLoaded,
-  NotLoaded,
+  Settled,
   co,
   randomSessionProvider,
   CoValueLoadingState,
-  NotLoadedCoValueState,
+  CoValueErrorState,
 } from "../internal.js";
 import { createJazzTestAccount, linkAccounts } from "../testing.js";
 import { assertLoaded, waitFor } from "./utils.js";
+import { setCustomErrorReporter } from "../config.js";
 
 const Crypto = await WasmCrypto.create();
 const { connectedPeers } = cojsonInternals;
@@ -43,6 +51,15 @@ const TestMap = co.map({
   optionalRef: co.optional(InnermostMap),
 });
 
+let lastError: Error | undefined;
+
+beforeEach(() => {
+  lastError = undefined;
+  setCustomErrorReporter((error) => {
+    lastError = error;
+  });
+});
+
 describe("Deep loading with depth arg", async () => {
   const me = await Account.create({
     creationProps: { name: "Hermes Puggington" },
@@ -345,7 +362,7 @@ test("Deep loading a record-like coMap", async () => {
     },
   });
   expectTypeOf(recordLoaded).branded.toEqualTypeOf<
-    MaybeLoaded<
+    Settled<
       Loaded<typeof RecordLike> & {
         readonly [key: string]: Loaded<typeof TestMap> & {
           readonly list: Loaded<typeof TestList> &
@@ -494,17 +511,14 @@ describe("Deep loading with unauthorized account", async () => {
       CoValueLoadingState.UNAUTHORIZED,
     );
 
-    expect(errorSpy).toHaveBeenCalledWith(
-      `The current user (${alice.$jazz.id}) is not authorized to access this value from ${map.$jazz.id}`,
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${map.$jazz.id}`,
     );
-
-    errorSpy.mockReset();
   });
 
   test("unaccessible list", async () => {
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const map = TestMap.create({ list: TestList.create([], onlyBob) }, group);
+    const innerList = TestList.create([], onlyBob);
+    const map = TestMap.create({ list: innerList }, group);
 
     const mapOnAlice = await TestMap.load(map.$jazz.id, { loadAs: alice });
     expect(mapOnAlice).toBeTruthy();
@@ -518,16 +532,12 @@ describe("Deep loading with unauthorized account", async () => {
       CoValueLoadingState.UNAUTHORIZED,
     );
 
-    expect(errorSpy).toHaveBeenCalledWith(
-      `The current user (${alice.$jazz.id}) is not authorized to access this value from ${map.$jazz.id} on path list`,
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${innerList.$jazz.id}. Subscription starts from ${map.$jazz.id} and the value is on path list`,
     );
-
-    errorSpy.mockReset();
   });
 
   test("unaccessible list element", async () => {
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
     const map = TestMap.create(
       {
         list: TestList.create(
@@ -554,16 +564,12 @@ describe("Deep loading with unauthorized account", async () => {
       CoValueLoadingState.UNAUTHORIZED,
     );
 
-    expect(errorSpy).toHaveBeenCalledWith(
-      `The current user (${alice.$jazz.id}) is not authorized to access this value from ${map.$jazz.id} on path list.0`,
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${map.list[0]!.$jazz.id}. Subscription starts from ${map.$jazz.id} and the value is on path list.0`,
     );
-
-    errorSpy.mockReset();
   });
 
   test("unaccessible optional element", async () => {
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
     const map = TestMap.create(
       {
         list: TestList.create([], group),
@@ -579,11 +585,9 @@ describe("Deep loading with unauthorized account", async () => {
     expect(mapOnAlice.$jazz.loadingState).toBe(
       CoValueLoadingState.UNAUTHORIZED,
     );
-    expect(errorSpy).toHaveBeenCalledWith(
-      `The current user (${alice.$jazz.id}) is not authorized to access this value from ${map.$jazz.id} on path optionalRef`,
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${map.optionalRef!.$jazz.id}. Subscription starts from ${map.$jazz.id} and the value is on path optionalRef`,
     );
-
-    errorSpy.mockReset();
   });
 
   test("unaccessible optional element via autoload", async () => {
@@ -611,17 +615,20 @@ describe("Deep loading with unauthorized account", async () => {
       });
 
     expect(result?.$jazz.loadingState).toBe(CoValueLoadingState.UNAUTHORIZED);
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${map.optionalRef!.$jazz.id}`,
+    );
   });
 
   test("unaccessible stream", async () => {
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const stream = TestFeed.create([], onlyBob);
     const map = TestMap.create(
       {
         list: TestList.create(
           [
             InnerMap.create(
               {
-                stream: TestFeed.create([], onlyBob),
+                stream,
               },
               group,
             ),
@@ -641,16 +648,12 @@ describe("Deep loading with unauthorized account", async () => {
       CoValueLoadingState.UNAUTHORIZED,
     );
 
-    expect(errorSpy).toHaveBeenCalledWith(
-      `The current user (${alice.$jazz.id}) is not authorized to access this value from ${map.$jazz.id} on path list.0.stream`,
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${stream.$jazz.id}. Subscription starts from ${map.$jazz.id} and the value is on path list.0.stream`,
     );
-
-    errorSpy.mockReset();
   });
 
   test("unaccessible stream element", async () => {
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
     const value = InnermostMap.create({ value: "hello" }, onlyBob);
 
     const map = TestMap.create(
@@ -679,11 +682,9 @@ describe("Deep loading with unauthorized account", async () => {
       CoValueLoadingState.UNAUTHORIZED,
     );
 
-    expect(errorSpy).toHaveBeenCalledWith(
-      `The current user (${alice.$jazz.id}) is not authorized to access this value from ${map.$jazz.id} on path list.0.stream.${value.$jazz.id}`,
+    expect(lastError?.message).toBe(
+      `Jazz Authorization Error: The current user (${alice.$jazz.id}) is not authorized to access ${value.$jazz.id}. Subscription starts from ${map.$jazz.id} and the value is on path list.0.stream.${value.$jazz.id}`,
     );
-
-    errorSpy.mockReset();
   });
 
   test("setting undefined via proxy", async () => {
@@ -1229,7 +1230,7 @@ describe("$isLoaded", async () => {
 
   const map = TestMap.create({ list: [] }, { owner: me });
 
-  test("$isLoaded narrows MaybeLoaded to loaded CoValue", async () => {
+  test("$isLoaded narrows a maybe-loaded CoValue to a loaded CoValue", async () => {
     const maybeLoadedMap = await TestMap.load(map.$jazz.id, {
       loadAs: me,
     });
@@ -1244,19 +1245,18 @@ describe("$isLoaded", async () => {
     } else {
       expectTypeOf(
         maybeLoadedMap.$jazz.loadingState,
-      ).toEqualTypeOf<NotLoadedCoValueState>();
+      ).toEqualTypeOf<CoValueErrorState>();
     }
   });
 
-  test("$isLoaded narrows MaybeLoaded to not loaded CoValue", async () => {
+  test("$isLoaded narrows a maybe-loaded CoValue to a not loaded CoValue", async () => {
     const otherAccount = await Account.create({
       creationProps: { name: "Other Account" },
       crypto: Crypto,
     });
-    const unloadedMap: MaybeLoaded<Loaded<typeof TestMap>> = await TestMap.load(
-      map.$jazz.id,
-      { loadAs: otherAccount },
-    );
+    const unloadedMap = await TestMap.load(map.$jazz.id, {
+      loadAs: otherAccount,
+    });
 
     expect(unloadedMap.$isLoaded).toBe(false);
     if (!unloadedMap.$isLoaded) {

package/src/tools/tests/errorReporting.test.ts

@@ -0,0 +1,103 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { Group, z } from "../index.js";
+import { setCustomErrorReporter } from "../config.js";
+import { CoValueLoadingState } from "../internal.js";
+import { createJazzTestAccount, linkAccounts } from "../testing.js";
+import { co } from "../exports.js";
+
+const TestMap = co.map({
+  value: z.string(),
+});
+
+describe("Custom error reporter", () => {
+  beforeEach(() => {
+    // Clean up error reporter before each test
+    setCustomErrorReporter(undefined);
+  });
+
+  test("with custom error reporter enabled, console.error is not called", async () => {
+    const bob = await createJazzTestAccount({
+      creationProps: { name: "Bob" },
+    });
+
+    const alice = await createJazzTestAccount({
+      creationProps: { name: "Alice" },
+    });
+
+    linkAccounts(bob, alice);
+
+    await alice.$jazz.waitForAllCoValuesSync();
+
+    const onlyBob = bob;
+    const group = Group.create(bob);
+
+    group.addMember(alice, "reader");
+
+    let capturedError: Error | undefined;
+    let capturedProps: { jazzError: any } | undefined;
+
+    setCustomErrorReporter((error, props) => {
+      capturedError = error;
+      capturedProps = props;
+    });
+
+    const consoleErrorSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    const map = TestMap.create({ value: "hello" }, onlyBob);
+
+    const mapOnAlice = await TestMap.load(map.$jazz.id, { loadAs: alice });
+
+    // Access the value to trigger error logging
+    expect(mapOnAlice.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
+
+    expect(consoleErrorSpy).not.toHaveBeenCalled();
+    expect(capturedError).toBeDefined();
+    expect(capturedProps).toBeDefined();
+    expect(capturedProps?.jazzError).toBeDefined();
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  test("without custom error reporter, console.error is called", async () => {
+    const bob = await createJazzTestAccount({
+      creationProps: { name: "Bob" },
+    });
+
+    const alice = await createJazzTestAccount({
+      creationProps: { name: "Alice" },
+    });
+
+    linkAccounts(bob, alice);
+
+    await alice.$jazz.waitForAllCoValuesSync();
+
+    const onlyBob = bob;
+    const group = Group.create(bob);
+
+    group.addMember(alice, "reader");
+
+    // Ensure no custom error reporter is set
+    setCustomErrorReporter(undefined);
+
+    const consoleErrorSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    const map = TestMap.create({ value: "hello" }, onlyBob);
+
+    const mapOnAlice = await TestMap.load(map.$jazz.id, { loadAs: alice });
+
+    // Access the value to trigger error logging
+    expect(mapOnAlice.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
+
+    expect(consoleErrorSpy).toHaveBeenCalled();
+
+    consoleErrorSpy.mockRestore();
+  });
+});

package/src/tools/tests/load.test.ts

@@ -1,6 +1,13 @@
 import { cojsonInternals, emptyKnownState } from "cojson";
 import { assert, beforeEach, expect, test } from "vitest";
-import { Account, Group, co, exportCoValue, z } from "../exports.js";
+import {
+  Account,
+  Group,
+  co,
+  exportCoValue,
+  jazzConfig,
+  z,
+} from "../exports.js";
 import { CoValueLoadingState } from "../internal.js";
 import {
   createJazzTestAccount,
@@ -12,6 +19,13 @@ import { assertLoaded, waitFor } from "./utils.js";
 
 cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 10;
 
+let lastError: Error | undefined;
+beforeEach(() => {
+  lastError = undefined;
+  jazzConfig.setCustomErrorReporter((error) => {
+    lastError = error;
+  });
+});
 beforeEach(async () => {
   await setupJazzTestSync();
   await createJazzTestAccount({
@@ -42,6 +56,9 @@ test("return 'unavailable' if id is invalid", async () => {
 
   const john = await Person.load("test");
   expect(john.$jazz.loadingState).toBe(CoValueLoadingState.UNAVAILABLE);
+  expect(lastError?.message).toBe(
+    "Jazz Unavailable Error: unable to load test",
+  );
 });
 
 test("load a missing optional value (co.optional)", async () => {
@@ -185,6 +202,9 @@ test("returns 'unavailable' if the value is unavailable after retries", async ()
   const john = await Person.load(map.$jazz.id, { loadAs: alice });
 
   expect(john.$jazz.loadingState).toBe(CoValueLoadingState.UNAVAILABLE);
+  expect(lastError?.message).toBe(
+    "Jazz Unavailable Error: unable to load " + map.$jazz.id,
+  );
 });
 
 test("load works even when the coValue access is granted after the creation", async () => {

package/src/tools/tests/request.test.ts

@@ -14,6 +14,7 @@ import {
   CoValueLoadingState,
   exportCoValue,
   importContentPieces,
+  Inaccessible,
 } from "../internal.js";
 import { createJazzTestAccount, linkAccounts } from "../testing.js";
 
@@ -663,7 +664,7 @@ describe("JazzRequestError handling", () => {
             createUnloadedCoValue(
               "some-covalue-id",
               CoValueLoadingState.UNAVAILABLE,
-            ),
+            ) as Inaccessible<Account>,
           );
 
           return userRequest.handle(request, worker, async () => {

package/src/tools/tests/subscribe.test.ts

@@ -1297,6 +1297,50 @@ describe("subscribeToCoValue", () => {
     expect(result.data[chunks]).toBe("new entry");
   });
 
+  it("should emit not emit when the content doesn't bring real changes", async () => {
+    const alice = await createJazzTestAccount();
+
+    const Person = co.map({
+      name: z.string(),
+    });
+    const PersonList = co.list(Person);
+
+    const group = Group.create(alice);
+
+    const person1 = Person.create({ name: "John" }, group);
+    const person2 = Person.create({ name: "Jane" }, group);
+
+    const personList = PersonList.create([person1, person2], group);
+
+    const spy = vi.fn();
+    // Test subscribing to the large coValue
+    const unsubscribe = subscribeToCoValue(
+      coValueClassFromCoValueClassOrSchema(PersonList),
+      personList.$jazz.id,
+      {
+        loadAs: alice,
+        resolve: {
+          $each: true,
+        },
+        syncResolution: true,
+      },
+      spy,
+    );
+
+    onTestFinished(unsubscribe);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    // Test that updates to the large coValue are properly subscribed
+    spy.mockClear();
+
+    group.addMember("everyone", "reader");
+
+    await new Promise((resolve) => setTimeout(resolve, 5));
+
+    expect(spy).not.toHaveBeenCalled();
+  });
+
   it.fails(
     "should return the latest loaded state when a deeply loaded child becomes not accessible",
     async () => {

package/tsup.config.ts

@@ -43,8 +43,16 @@ export default defineConfig([
       index: "src/expo/index.ts",
       testing: "src/expo/testing.ts",
       crypto: "src/expo/crypto.ts",
+      polyfills: "src/react-native-core/polyfills/index.js",
     },
     outDir: "dist/expo",
+    external: [
+      "jazz-tools",
+      "readable-stream",
+      "@azure/core-asynciterator-polyfill",
+      "react-native-get-random-values",
+      "react-native-fast-encoder",
+    ],
   },
   {
     ...cfg,
@@ -107,8 +115,16 @@ export default defineConfig([
       index: "src/react-native/index.ts",
       testing: "src/react-native/testing.ts",
       crypto: "src/react-native/crypto.ts",
+      polyfills: "src/react-native-core/polyfills/index.js",
     },
     outDir: "dist/react-native",
+    external: [
+      "jazz-tools",
+      "readable-stream",
+      "@azure/core-asynciterator-polyfill",
+      "react-native-get-random-values",
+      "react-native-fast-encoder",
+    ],
   },
   {
     ...cfg,
@@ -116,6 +132,7 @@ export default defineConfig([
       index: "src/react-native-core/index.ts",
       testing: "src/react-native-core/testing.tsx",
       crypto: "src/react-native-core/crypto/index.ts",
+      "crypto/RNCrypto": "src/react-native-core/crypto/RNCrypto.ts",
     },
     outDir: "dist/react-native-core",
   },