jazz-tools 0.19.22 → 0.20.1

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

@@ -1225,3 +1225,265 @@ describe("lastUpdatedAt", () => {
     expect(list.$jazz.lastUpdatedAt).not.toEqual(updatedAt);
   });
 });
+
+describe("CoList proxy traps", () => {
+  test(".values() returns the same values as Object.values()", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create([]);
+    list.$jazz.push("bread");
+    list.$jazz.push("butter");
+    list.$jazz.push("onion");
+
+    const valuesFromMethod = [...list.values()];
+    const valuesFromObject = Object.values(list);
+    expect(valuesFromMethod).toEqual(valuesFromObject);
+    expect(valuesFromMethod).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test(".values().map() returns the same values as .map()", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create([]);
+    list.$jazz.push("bread");
+    list.$jazz.push("butter");
+    list.$jazz.push("onion");
+
+    const valuesFromMethod = [...list.values().map((v) => v.toUpperCase())];
+    const valuesFromObject = list.map((v) => v.toUpperCase());
+
+    expect(valuesFromMethod).toEqual(valuesFromObject);
+    expect(valuesFromMethod).toEqual(["BREAD", "BUTTER", "ONION"]);
+  });
+
+  test(".keys() returns numeric indices", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const keys = [...list.keys()];
+
+    expect(keys).toEqual([0, 1, 2]);
+  });
+
+  test(".entries() returns index-value pairs", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const entries = [...list.entries()];
+
+    expect(entries).toEqual([
+      [0, "bread"],
+      [1, "butter"],
+      [2, "onion"],
+    ]);
+  });
+
+  test("for...of iteration works correctly", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const items: string[] = [];
+    for (const item of list) {
+      items.push(item);
+    }
+
+    expect(items).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test("spread operator works correctly", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const items = [...list];
+
+    expect(items).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test("Array.from works correctly", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const items = Array.from(list);
+
+    expect(items).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test(".values() works with CoValue references", () => {
+    const Dog = co.map({
+      name: z.string(),
+    });
+    const DogList = co.list(Dog);
+
+    const list = DogList.create([
+      { name: "Rex" },
+      { name: "Fido" },
+      { name: "Buddy" },
+    ]);
+
+    const valuesFromMethod = [...list.values()];
+    const valuesFromObject = Object.values(list);
+
+    expect(valuesFromMethod.length).toBe(3);
+    expect(valuesFromMethod.map((d) => d?.name)).toEqual([
+      "Rex",
+      "Fido",
+      "Buddy",
+    ]);
+    expect(valuesFromMethod).toEqual(valuesFromObject);
+  });
+
+  test(".values() works after ensureLoaded", async () => {
+    const Task = co.map({
+      title: z.string(),
+    });
+    const TaskList = co.list(Task);
+
+    const list = TaskList.create([
+      { title: "Task 1" },
+      { title: "Task 2" },
+      { title: "Task 3" },
+    ]);
+
+    const loadedList = await list.$jazz.ensureLoaded({
+      resolve: { $each: true },
+    });
+
+    const valuesFromMethod = [...loadedList.values()];
+    const valuesFromObject = Object.values(loadedList);
+
+    expect(valuesFromMethod.length).toBe(3);
+    expect(valuesFromMethod.map((t) => t.title)).toEqual([
+      "Task 1",
+      "Task 2",
+      "Task 3",
+    ]);
+    expect(valuesFromMethod.map((t) => t.$jazz.id)).toEqual(
+      valuesFromObject.map((t) => t.$jazz.id),
+    );
+  });
+
+  test(".values() works on remotely loaded list", async () => {
+    const Task = co.map({
+      title: z.string(),
+    });
+    const TaskList = co.list(Task);
+
+    const group = Group.create();
+    group.addMember("everyone", "writer");
+
+    const list = TaskList.create(
+      [{ title: "Task 1" }, { title: "Task 2" }, { title: "Task 3" }],
+      group,
+    );
+
+    const userB = await createJazzTestAccount();
+
+    const loadedList = await TaskList.load(list.$jazz.id, {
+      resolve: { $each: true },
+      loadAs: userB,
+    });
+
+    assertLoaded(loadedList);
+
+    const valuesFromMethod = [...loadedList.values()];
+    const valuesFromObject = Object.values(loadedList);
+
+    expect(valuesFromMethod.length).toBe(3);
+    expect(valuesFromMethod.map((t) => t.title)).toEqual([
+      "Task 1",
+      "Task 2",
+      "Task 3",
+    ]);
+    expect(valuesFromMethod.map((t) => t.$jazz.id)).toEqual(
+      valuesFromObject.map((t) => t.$jazz.id),
+    );
+  });
+
+  test("iterator methods work on empty list", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create([]);
+
+    expect([...list.values()]).toEqual([]);
+    expect([...list.keys()]).toEqual([]);
+    expect([...list.entries()]).toEqual([]);
+    expect([...list]).toEqual([]);
+  });
+
+  test("Object.getOwnPropertyDescriptors returns correct descriptors", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["a", "b", "c"]);
+
+    const descriptors = Object.getOwnPropertyDescriptors(list);
+
+    // Check numeric index descriptors
+    expect(descriptors["0"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: "a",
+    });
+    expect(descriptors["1"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: "b",
+    });
+    expect(descriptors["2"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: "c",
+    });
+
+    // Check length descriptor
+    expect(descriptors["length"]).toEqual({
+      enumerable: false,
+      configurable: false,
+      writable: true,
+      value: 3,
+    });
+
+    // Verify only expected enumerable keys
+    const enumerableKeys = Object.keys(descriptors).filter(
+      (key) => descriptors[key]?.enumerable,
+    );
+    expect(enumerableKeys.sort()).toEqual(["0", "1", "2"]);
+  });
+
+  test("Object.getOwnPropertyDescriptors returns the resolved references", () => {
+    const TestList = co.list(co.map({ name: z.string() }));
+    const list = TestList.create([{ name: "a" }, { name: "b" }, { name: "c" }]);
+
+    const descriptors = Object.getOwnPropertyDescriptors(list);
+
+    // Check numeric index descriptors
+    expect(descriptors["0"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: list[0],
+    });
+    expect(descriptors["1"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: list[1],
+    });
+    expect(descriptors["2"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: list[2],
+    });
+  });
+
+  test("setting the lenght to 0 has no effect", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["a", "b", "c"]);
+
+    list.length = 0;
+
+    expect(list.length).toBe(3);
+    expect(list[0]).toBe("a");
+    expect(list[1]).toBe("b");
+    expect(list[2]).toBe("c");
+  });
+});

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

@@ -0,0 +1,231 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import {
+  Account,
+  CoValueLoadingState,
+  Group,
+  co,
+  deleteCoValues,
+  z,
+} from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { assertLoaded, waitFor } from "./utils.js";
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
+describe("deleteCoValues", () => {
+  test("deletes a resolved graph (tombstones) and loads as DELETED", async () => {
+    const Meta = co.map({
+      tag: z.string(),
+    });
+
+    const Note = co.map({
+      text: co.plainText(),
+      meta: Meta,
+    });
+
+    const owner = Account.getMe();
+    const group = Group.create(owner).makePublic("reader");
+
+    const note = Note.create(
+      {
+        text: "hello",
+        meta: { tag: "t1" },
+      },
+      group,
+    );
+
+    const text = note.text;
+    const meta = note.meta;
+
+    await note.$jazz.raw.core.waitForSync();
+
+    await deleteCoValues(Note, note.$jazz.id, {
+      loadAs: owner,
+      resolve: { text: true, meta: true },
+    });
+
+    expect(note.$jazz.raw.core.isDeleted).toBe(true);
+    expect(text.$jazz.raw.core.isDeleted).toBe(true);
+    expect(meta.$jazz.raw.core.isDeleted).toBe(true);
+
+    const viewer = await createJazzTestAccount();
+    const loaded = await Note.load(note.$jazz.id, {
+      loadAs: viewer,
+      skipRetry: true,
+    });
+
+    expect(loaded.$isLoaded).toBe(false);
+    expect(loaded.$jazz.loadingState).toBe(CoValueLoadingState.DELETED);
+  });
+
+  test("rejects deletion for non-admin on a group-owned value", async () => {
+    const Meta = co.map({
+      tag: z.string(),
+    });
+
+    const Note = co.map({
+      meta: Meta,
+    });
+
+    const owner = Account.getMe();
+    const writer = await createJazzTestAccount();
+
+    const group = Group.create(owner);
+    group.addMember(writer, "writer");
+
+    const note = Note.create({ meta: { tag: "t1" } }, group);
+    await note.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Note, note.$jazz.id, {
+        loadAs: writer,
+        resolve: { meta: true },
+      }),
+    ).rejects.toThrow(/admin permissions/i);
+
+    expect(note.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("rejects deletion when a resolved child is not deletable (error includes path)", async () => {
+    const Child = co.map({
+      value: z.string(),
+    });
+
+    const Root = co.map({
+      child: Child,
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+
+    const groupA = Group.create(owner).makePublic("reader");
+    const groupB = Group.create({ owner: otherOwner }).makePublic("reader");
+
+    const child = Child.create({ value: "child" }, groupB);
+    await child.$jazz.raw.core.waitForSync();
+
+    const root = Root.create({ child }, groupA);
+    await root.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Root, root.$jazz.id, {
+        loadAs: owner,
+        resolve: { child: true },
+      }),
+    ).rejects.toThrow(
+      new RegExp(
+        `Subscription starts from ${root.$jazz.id}.*path ${child.$jazz.id}`,
+      ),
+    );
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(false);
+    expect(child.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("rejects deletion when the value cannot be loaded", async () => {
+    const Root = co.map({
+      value: z.string(),
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+    const root = Root.create(
+      { value: "root" },
+      Group.create({ owner: otherOwner }),
+    );
+    await root.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Root, root.$jazz.id, {
+        loadAs: owner,
+      }),
+    ).rejects.toThrow(new RegExp(`Jazz Authorization Error`));
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("rejects deletion when a child could not be loaded", async () => {
+    const Child = co.map({
+      value: z.string(),
+    });
+
+    const Root = co.map({
+      child: Child,
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+
+    const groupA = Group.create(owner).makePublic("reader");
+    const groupB = Group.create({ owner: otherOwner });
+
+    const child = Child.create({ value: "child" }, groupB);
+    await child.$jazz.raw.core.waitForSync();
+
+    const root = Root.create({ child }, groupA);
+    await root.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Root, root.$jazz.id, {
+        loadAs: owner,
+        resolve: { child: true },
+      }),
+    ).rejects.toThrow(new RegExp(`Jazz Authorization Error`));
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(false);
+    expect(child.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("delete the CoValue when the child cannot be loaded but is marked with $onError", async () => {
+    const Child = co.map({
+      value: z.string(),
+    });
+
+    const Root = co.map({
+      child: Child,
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+
+    const groupA = Group.create(owner).makePublic("reader");
+    const groupB = Group.create({ owner: otherOwner });
+
+    const child = Child.create({ value: "child" }, groupB);
+    await child.$jazz.raw.core.waitForSync();
+
+    const root = Root.create({ child }, groupA);
+    await root.$jazz.raw.core.waitForSync();
+
+    await deleteCoValues(Root, root.$jazz.id, {
+      loadAs: owner,
+      resolve: { child: { $onError: "catch" } },
+    });
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(true);
+    expect(child.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("skips Account and Group CoValues", async () => {
+    const me = Account.getMe();
+
+    await deleteCoValues(Account, me.$jazz.id, {
+      loadAs: me,
+    });
+
+    expect(me.$jazz.raw.core.isDeleted).toBe(false);
+
+    const group = Group.create(me).makePublic("reader");
+
+    await deleteCoValues(Group, group.$jazz.id, {
+      loadAs: me,
+    });
+
+    expect(group.$jazz.raw.core.isDeleted).toBe(false);
+  });
+});

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

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, onTestFinished, vi } from "vitest";
+import { cojsonInternals } from "cojson";
+
+import { Account, Group, z } from "../index.js";
+import {
+  CoValueLoadingState,
+  co,
+  coValueClassFromCoValueClassOrSchema,
+  subscribeToCoValue,
+} from "../internal.js";
+import { loadCoValue } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { setupAccount, waitFor } from "./utils.js";
+
+cojsonInternals.setCoValueLoadingRetryDelay(50);
+
+describe("deleted loading state", () => {
+  beforeEach(() => {
+    // Keep these tests snappy and deterministic.
+    cojsonInternals.CO_VALUE_LOADING_CONFIG.MAX_RETRIES = 1;
+    cojsonInternals.CO_VALUE_LOADING_CONFIG.TIMEOUT = 50;
+  });
+
+  it("subscribeToCoValue calls onError and stops emitting loaded updates", async () => {
+    const TestMap = co.map({
+      value: z.string(),
+    });
+
+    const { me, meOnSecondPeer } = await setupAccount();
+
+    const map = TestMap.create({ value: "hello" }, me);
+
+    const onLoaded = vi.fn();
+    const onError = vi.fn();
+    const onUnavailable = vi.fn();
+    const onUnauthorized = vi.fn();
+
+    const unsubscribe = subscribeToCoValue(
+      coValueClassFromCoValueClassOrSchema(TestMap),
+      map.$jazz.id,
+      {
+        loadAs: meOnSecondPeer,
+        onError,
+        onUnavailable,
+        onUnauthorized,
+      },
+      onLoaded,
+    );
+
+    onTestFinished(unsubscribe);
+
+    await waitFor(() => {
+      expect(onLoaded).toHaveBeenCalled();
+    });
+
+    const loadedCallCountBeforeDelete = onLoaded.mock.calls.length;
+
+    map.$jazz.raw.core.deleteCoValue();
+    await map.$jazz.raw.core.waitForSync();
+
+    await waitFor(() => {
+      expect(onError).toHaveBeenCalled();
+    });
+
+    const deletedValue = onError.mock.calls[0]?.[0];
+    expect(deletedValue?.$isLoaded).toBe(false);
+    expect(deletedValue?.$jazz.loadingState).toBe(CoValueLoadingState.DELETED);
+
+    // Give the system a moment; we should not emit additional loaded updates after deletion.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(onLoaded).toHaveBeenCalledTimes(loadedCallCountBeforeDelete);
+    expect(onUnavailable).not.toHaveBeenCalled();
+    expect(onUnauthorized).not.toHaveBeenCalled();
+  });
+
+  it("loadCoValue resolves a NotLoaded(DELETED) value for deleted coValues", async () => {
+    await setupJazzTestSync();
+
+    const TestMap = co.map({
+      value: z.string(),
+    });
+
+    const owner = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const group = Group.create(owner).makePublic("reader");
+    const map = TestMap.create({ value: "hello" }, group);
+
+    // Ensure the value exists on storage/peers before deleting.
+    await map.$jazz.raw.core.waitForSync();
+
+    map.$jazz.raw.core.deleteCoValue();
+    await map.$jazz.raw.core.waitForSync();
+
+    const viewer = await createJazzTestAccount();
+
+    const loaded = await loadCoValue(
+      coValueClassFromCoValueClassOrSchema(TestMap),
+      map.$jazz.id,
+      {
+        loadAs: viewer,
+        skipRetry: true,
+      },
+    );
+
+    expect(loaded.$isLoaded).toBe(false);
+    expect(loaded.$jazz.loadingState).toBe(CoValueLoadingState.DELETED);
+  });
+});

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

@@ -20,7 +20,18 @@ import { createJazzTestAccount, linkAccounts } from "../testing.js";
 
 const server = setupServer();
 
-beforeAll(() => server.listen());
+const ignoreWasmRequests = (request: Request, print: any) => {
+  if (request.url.includes("application/wasm")) {
+    return;
+  }
+  print.warning();
+};
+
+beforeAll(() =>
+  server.listen({
+    onUnhandledRequest: ignoreWasmRequests,
+  }),
+);
 afterEach(() => server.resetHandlers());
 afterEach(() => vi.restoreAllMocks());
 afterAll(() => server.close());
@@ -877,7 +888,9 @@ describe("JazzRequestError handling", () => {
         ),
       ).rejects.toThrow("fetch failed");
 
-      server.listen();
+      server.listen({
+        onUnhandledRequest: ignoreWasmRequests,
+      });
     });
   });
 

package/src/tools/tests/schema.withPermissions.test.ts

@@ -843,7 +843,7 @@ describe("setDefaultSchemaPermissions", () => {
     expect(childOwner.getRoleOf(anotherAccount.$jazz.id)).toEqual("reader");
   });
 
-  test("does not modify permissions for existing schemas", () => {
+  test("modifies default permissions for existing schemas", () => {
     const ExistingMap = co.map({
       name: co.plainText(),
     });
@@ -852,8 +852,31 @@ describe("setDefaultSchemaPermissions", () => {
     });
 
     const map = ExistingMap.create({ name: "Hello" });
-    expect(
-      map.name.$jazz.owner.getParentGroups().map((group) => group.$jazz.id),
-    ).toContain(map.$jazz.owner.$jazz.id);
+    expect(map.name.$jazz.owner.$jazz.id).toContain(map.$jazz.owner.$jazz.id);
+  });
+
+  test("modifies default permissions for copied schemas", async () => {
+    const anotherAccount = await createJazzTestAccount();
+
+    const ExistingMap = co.map({
+      name: co.plainText(),
+    });
+    setDefaultSchemaPermissions({
+      onCreate() {
+        // Do nothing
+      },
+    });
+    const CopiedMap = ExistingMap.resolved({ name: true });
+    setDefaultSchemaPermissions({
+      onCreate(newGroup) {
+        newGroup.addMember(anotherAccount, "reader");
+      },
+    });
+
+    const map = CopiedMap.create({ name: "Hello" });
+    await map.$jazz.waitForSync();
+
+    const mapOwner = map.$jazz.owner;
+    expect(mapOwner.getRoleOf(anotherAccount.$jazz.id)).toEqual("reader");
   });
 });

package/src/worker/edge-wasm.ts

@@ -1,5 +1,6 @@
 // InitWasm allow to load the wasm code in edge runtimes (ex. cloudflare worker and vercel edge functions)
-import { init as InitWasm } from "cojson/crypto/WasmCrypto/edge";
+import { init as InitWasm, initSync } from "cojson/crypto/WasmCrypto/edge";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 WasmCrypto.setInit(InitWasm);
+WasmCrypto.setInitSync(initSync);

package/src/worker/wasm.ts

@@ -0,0 +1 @@
+export { initWasmCrypto as initWasm } from "cojson/crypto/WasmCrypto";