jazz-tools 0.19.6 → 0.19.8

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,