jazz-tools 0.17.4 → 0.17.6

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

@@ -863,6 +863,173 @@ describe("CoList subscription", async () => {
   });
 });
 
+describe("CoList unique methods", () => {
+  test("loadUnique returns existing list", async () => {
+    const ItemList = co.list(z.string());
+    const group = Group.create();
+
+    const originalList = ItemList.create(["item1", "item2", "item3"], {
+      owner: group,
+      unique: "test-list",
+    });
+
+    const foundList = await ItemList.loadUnique("test-list", group.id);
+    expect(foundList).toEqual(originalList);
+    expect(foundList?.length).toBe(3);
+    expect(foundList?.[0]).toBe("item1");
+  });
+
+  test("loadUnique returns null for non-existent list", async () => {
+    const ItemList = co.list(z.string());
+    const group = Group.create();
+
+    const foundList = await ItemList.loadUnique("non-existent", group.id);
+    expect(foundList).toBeNull();
+  });
+
+  test("upsertUnique creates new list when none exists", async () => {
+    const ItemList = co.list(z.string());
+    const group = Group.create();
+
+    const sourceData = ["item1", "item2", "item3"];
+
+    const result = await ItemList.upsertUnique({
+      value: sourceData,
+      unique: "new-list",
+      owner: group,
+    });
+
+    expect(result).not.toBeNull();
+    expect(result?.length).toBe(3);
+    expect(result?.[0]).toBe("item1");
+    expect(result?.[1]).toBe("item2");
+    expect(result?.[2]).toBe("item3");
+  });
+
+  test("upsertUnique updates existing list", async () => {
+    const ItemList = co.list(z.string());
+    const group = Group.create();
+
+    // Create initial list
+    const originalList = ItemList.create(["original1", "original2"], {
+      owner: group,
+      unique: "update-list",
+    });
+
+    // Upsert with new data
+    const updatedList = await ItemList.upsertUnique({
+      value: ["updated1", "updated2", "updated3"],
+      unique: "update-list",
+      owner: group,
+    });
+
+    expect(updatedList).toEqual(originalList); // Should be the same instance
+    expect(updatedList?.length).toBe(3);
+    expect(updatedList?.[0]).toBe("updated1");
+    expect(updatedList?.[1]).toBe("updated2");
+    expect(updatedList?.[2]).toBe("updated3");
+  });
+
+  test("upsertUnique with CoValue items", async () => {
+    const Item = co.map({
+      name: z.string(),
+      value: z.number(),
+    });
+    const ItemList = co.list(Item);
+    const group = Group.create();
+
+    const items = [
+      Item.create({ name: "First", value: 1 }, group),
+      Item.create({ name: "Second", value: 2 }, group),
+    ];
+
+    const result = await ItemList.upsertUnique({
+      value: items,
+      unique: "item-list",
+      owner: group,
+      resolve: { $each: true },
+    });
+
+    expect(result).not.toBeNull();
+    expect(result?.length).toBe(2);
+    expect(result?.[0]?.name).toBe("First");
+    expect(result?.[1]?.name).toBe("Second");
+  });
+
+  test("upsertUnique updates list with CoValue items", async () => {
+    const Item = co.map({
+      name: z.string(),
+      value: z.number(),
+    });
+    const ItemList = co.list(Item);
+    const group = Group.create();
+
+    // Create initial list
+    const initialItems = [Item.create({ name: "Initial", value: 0 }, group)];
+    const originalList = ItemList.create(initialItems, {
+      owner: group,
+      unique: "updateable-item-list",
+    });
+
+    // Upsert with new items
+    const newItems = [
+      Item.create({ name: "Updated", value: 1 }, group),
+      Item.create({ name: "Added", value: 2 }, group),
+    ];
+
+    const updatedList = await ItemList.upsertUnique({
+      value: newItems,
+      unique: "updateable-item-list",
+      owner: group,
+      resolve: { $each: true },
+    });
+
+    expect(updatedList).toEqual(originalList); // Should be the same instance
+    expect(updatedList?.length).toBe(2);
+    expect(updatedList?.[0]?.name).toBe("Updated");
+    expect(updatedList?.[1]?.name).toBe("Added");
+  });
+
+  test("findUnique returns correct ID", async () => {
+    const ItemList = co.list(z.string());
+    const group = Group.create();
+
+    const originalList = ItemList.create(["test"], {
+      owner: group,
+      unique: "find-test",
+    });
+
+    const foundId = ItemList.findUnique("find-test", group.id);
+    expect(foundId).toBe(originalList.id);
+  });
+
+  test("upsertUnique with resolve options", async () => {
+    const Category = co.map({ title: z.string() });
+    const Item = co.map({
+      name: z.string(),
+      category: Category,
+    });
+    const ItemList = co.list(Item);
+    const group = Group.create();
+
+    const category = Category.create({ title: "Category 1" }, group);
+
+    const items = [Item.create({ name: "Item 1", category }, group)];
+
+    const result = await ItemList.upsertUnique({
+      value: items,
+      unique: "resolved-list",
+      owner: group,
+      resolve: { $each: { category: true } },
+    });
+
+    expect(result).not.toBeNull();
+    expect(result?.length).toBe(1);
+    expect(result?.[0]?.name).toBe("Item 1");
+    expect(result?.[0]?.category?.title).toBe("Category 1");
+  });
+});
+
 describe("co.list schema", () => {
   test("can access the inner schema of a co.list", () => {
     const Keywords = co.list(co.plainText());

package/src/tools/tests/coMap.record.test.ts

@@ -460,3 +460,107 @@ describe("CoMap.Record", async () => {
     }
   });
 });
+
+describe("CoRecord unique methods", () => {
+  test("loadUnique returns existing record", async () => {
+    const ItemRecord = co.record(z.string(), z.number());
+    const group = Group.create();
+
+    const originalRecord = ItemRecord.create(
+      { item1: 1, item2: 2, item3: 3 },
+      { owner: group, unique: "test-record" },
+    );
+
+    const foundRecord = await ItemRecord.loadUnique("test-record", group.id);
+    expect(foundRecord).toEqual(originalRecord);
+    expect(foundRecord?.item1).toBe(1);
+    expect(foundRecord?.item2).toBe(2);
+  });
+
+  test("loadUnique returns null for non-existent record", async () => {
+    const ItemRecord = co.record(z.string(), z.number());
+    const group = Group.create();
+
+    const foundRecord = await ItemRecord.loadUnique("non-existent", group.id);
+    expect(foundRecord).toBeNull();
+  });
+
+  test("upsertUnique creates new record when none exists", async () => {
+    const ItemRecord = co.record(z.string(), z.number());
+    const group = Group.create();
+
+    const sourceData = { item1: 1, item2: 2, item3: 3 };
+
+    const result = await ItemRecord.upsertUnique({
+      value: sourceData,
+      unique: "new-record",
+      owner: group,
+    });
+
+    expect(result).not.toBeNull();
+    expect(result?.item1).toBe(1);
+    expect(result?.item2).toBe(2);
+    expect(result?.item3).toBe(3);
+  });
+
+  test("upsertUnique updates existing record", async () => {
+    const ItemRecord = co.record(z.string(), z.number());
+    const group = Group.create();
+
+    // Create initial record
+    const originalRecord = ItemRecord.create(
+      { original1: 1, original2: 2 },
+      { owner: group, unique: "update-record" },
+    );
+
+    // Upsert with new data
+    const updatedRecord = await ItemRecord.upsertUnique({
+      value: { updated1: 10, updated2: 20, updated3: 30 },
+      unique: "update-record",
+      owner: group,
+    });
+
+    expect(updatedRecord).toEqual(originalRecord); // Should be the same instance
+    expect(updatedRecord?.updated1).toBe(10);
+    expect(updatedRecord?.updated2).toBe(20);
+    expect(updatedRecord?.updated3).toBe(30);
+  });
+
+  test("upsertUnique with CoValue items", async () => {
+    const Item = co.map({
+      name: z.string(),
+      value: z.number(),
+    });
+    const ItemRecord = co.record(z.string(), Item);
+    const group = Group.create();
+
+    const items = {
+      first: Item.create({ name: "First", value: 1 }, group),
+      second: Item.create({ name: "Second", value: 2 }, group),
+    };
+
+    const result = await ItemRecord.upsertUnique({
+      value: items,
+      unique: "item-record",
+      owner: group,
+      resolve: { first: true, second: true },
+    });
+
+    expect(result).not.toBeNull();
+    expect(result?.first?.name).toBe("First");
+    expect(result?.second?.name).toBe("Second");
+  });
+
+  test("findUnique returns correct ID", async () => {
+    const ItemRecord = co.record(z.string(), z.string());
+    const group = Group.create();
+
+    const originalRecord = ItemRecord.create(
+      { test: "value" },
+      { owner: group, unique: "find-test" },
+    );
+
+    const foundId = ItemRecord.findUnique("find-test", group.id);
+    expect(foundId).toBe(originalRecord.id);
+  });
+});

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

@@ -12,10 +12,15 @@ import {
 } from "vitest";
 import { Group, co, subscribeToCoValue, z } from "../exports.js";
 import { Account } from "../index.js";
-import { Loaded, coValueClassFromCoValueClassOrSchema } from "../internal.js";
+import {
+  Loaded,
+  activeAccountContext,
+  coValueClassFromCoValueClassOrSchema,
+} from "../internal.js";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
+  runWithoutActiveAccount,
   setupJazzTestSync,
 } from "../testing.js";
 import { setupTwoNodes, waitFor } from "./utils.js";
@@ -214,6 +219,19 @@ describe("CoMap", async () => {
         const map = Schema.create({ text: "" });
         expect(map.text.toString()).toBe("");
       });
+
+      it("creates a group for the new CoValue when there is no active account", () => {
+        const Schema = co.map({ text: co.plainText() });
+
+        const parentGroup = Group.create();
+        runWithoutActiveAccount(() => {
+          const map = Schema.create({ text: "Hello" }, parentGroup);
+
+          expect(
+            map.text._owner.getParentGroups().map((group: Group) => group.id),
+          ).toContain(parentGroup.id);
+        });
+      });
     });
 
     test("CoMap with self reference", () => {