jazz-tools 0.13.31 → 0.14.1

package/src/tests/groupsAndAccounts.test.ts

@@ -1,7 +1,7 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test } from "vitest";
-import { Account, CoMap, Group, Profile, co } from "../exports.js";
-import { Ref } from "../internal.js";
+import { Account, CoMap, Group, Profile, coField, z } from "../exports.js";
+import { Loaded, Ref, co, zodSchemaToCoSchema } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes, waitFor } from "./utils.js";
 
@@ -17,31 +17,37 @@ beforeEach(async () => {
 
 describe("Custom accounts and groups", async () => {
   test("Custom account and group", async () => {
-    class CustomProfile extends Profile {
-      name = co.string;
-      color = co.string;
-    }
-
-    class CustomAccount extends Account {
-      profile = co.ref(CustomProfile);
-      root = co.ref(CoMap);
-
-      migrate(this: CustomAccount, creationProps?: { name: string }) {
-        if (creationProps) {
-          const profileGroup = Group.create({ owner: this });
-          profileGroup.addMember("everyone", "reader");
-          this.profile = CustomProfile.create(
-            { name: creationProps.name, color: "blue" },
-            profileGroup,
-          );
-        }
-      }
-    }
+    const CustomProfile = co.profile({
+      name: z.string(),
+      color: z.string(),
+    });
+
+    const CustomAccount = co
+      .account({
+        profile: CustomProfile,
+        root: co.map({}),
+      })
+      .withMigration(
+        (
+          account: Loaded<typeof CustomAccount>,
+          creationProps?: { name: string },
+        ) => {
+          if (creationProps) {
+            console.log("In migration!");
+            const profileGroup = Group.create({ owner: account });
+            profileGroup.addMember("everyone", "reader");
+            account.profile = CustomProfile.create(
+              { name: creationProps.name, color: "blue" },
+              profileGroup,
+            );
+          }
+        },
+      );
 
     const me = await createJazzTestAccount({
       creationProps: { name: "Hermes Puggington" },
       isCurrentActiveAccount: true,
-      AccountSchema: CustomAccount,
+      AccountSchema: zodSchemaToCoSchema(CustomAccount),
     });
 
     expect(me.profile).toBeDefined();
@@ -54,41 +60,44 @@ describe("Custom accounts and groups", async () => {
     expect(group.members).toMatchObject([{ id: me.id, role: "admin" }]);
 
     const meAsMember = group.members.find((member) => member.id === me.id);
-    expect((meAsMember?.account as CustomAccount).profile?.name).toBe(
-      "Hermes Puggington",
-    );
-    expect((meAsMember?.account as CustomAccount).profile?.color).toBe("blue");
+    assert(meAsMember?.account);
+    expect((meAsMember?.account).profile?.name).toBe("Hermes Puggington");
   });
 
   test("Should throw when creating a profile with an account as owner", async () => {
-    class CustomAccount extends Account {
-      migrate(this: CustomAccount, creationProps?: { name: string }) {
-        if (creationProps) {
-          this.profile = Profile.create(
-            { name: creationProps.name },
-            // @ts-expect-error - only groups can own profiles, but we want to also perform a runtime check
-            this,
-          );
-        }
-      }
-    }
+    const CustomAccount = co
+      .account()
+      .withMigration(
+        (
+          account: Loaded<typeof CustomAccount>,
+          creationProps?: { name: string },
+        ) => {
+          if (creationProps) {
+            account.profile = co.profile().create(
+              { name: creationProps.name },
+              // @ts-expect-error - only groups can own profiles, but we want to also perform a runtime check
+              account,
+            );
+          }
+        },
+      );
 
     await expect(() =>
       CustomAccount.create({
         creationProps: { name: "Hermes Puggington" },
         crypto: Crypto,
       }),
-    ).rejects.toThrowError("Profiles should be owned by a group");
+    ).rejects.toThrowError("Profile must be owned by a Group");
   });
 });
 
 describe("Group inheritance", () => {
-  class TestMap extends CoMap {
-    title = co.string;
-  }
+  const TestMap = co.map({
+    title: z.string(),
+  });
 
   test("Group inheritance", async () => {
-    const me = await Account.create({
+    const me = await co.account().create({
       creationProps: { name: "Hermes Puggington" },
       crypto: Crypto,
     });
@@ -98,7 +107,7 @@ describe("Group inheritance", () => {
 
     group.extend(parentGroup);
 
-    const reader = await Account.createAs(me, {
+    const reader = await co.account().createAs(me, {
       creationProps: { name: "Reader" },
     });
 
@@ -122,7 +131,7 @@ describe("Group inheritance", () => {
   });
 
   test("Group inheritance with grand-children", async () => {
-    const me = await Account.create({
+    const me = await co.account().create({
       creationProps: { name: "Hermes Puggington" },
       crypto: Crypto,
     });
@@ -134,7 +143,7 @@ describe("Group inheritance", () => {
     group.extend(parentGroup);
     parentGroup.extend(grandParentGroup);
 
-    const reader = await Account.createAs(me, {
+    const reader = await co.account().createAs(me, {
       creationProps: { name: "Reader" },
     });
 
@@ -163,7 +172,7 @@ describe("Group inheritance", () => {
   });
 
   test("Group.getParentGroups should return the parent groups", async () => {
-    const me = await Account.create({
+    const me = await co.account().create({
       creationProps: { name: "Test Owner" },
       crypto: Crypto,
     });
@@ -188,7 +197,7 @@ describe("Group inheritance", () => {
   });
 
   test("Account.getParentGroups should return an empty array", async () => {
-    const account = await Account.create({
+    const account = await co.account().create({
       creationProps: { name: "Test Account" },
       crypto: Crypto,
     });
@@ -313,7 +322,7 @@ describe("Group.getRoleOf with 'me' parameter", () => {
     await account.waitForAllCoValuesSync();
     const group = Group.create({ owner: account });
 
-    group.addMember(Account.getMe(), "writer");
+    group.addMember(co.account().getMe(), "writer");
 
     expect(group.getRoleOf("me")).toBe("writer");
   });
@@ -323,7 +332,7 @@ describe("Group.getRoleOf with 'me' parameter", () => {
     await account.waitForAllCoValuesSync();
     const group = Group.create({ owner: account });
 
-    group.addMember(Account.getMe(), "reader");
+    group.addMember(co.account().getMe(), "reader");
 
     expect(group.getRoleOf("me")).toBe("reader");
   });
@@ -343,7 +352,7 @@ describe("Account permissions", () => {
   });
 
   test("getRoleOf returns admin only for self and me", async () => {
-    const account = await Account.create({
+    const account = await co.account().create({
       creationProps: { name: "Test Account" },
       crypto: Crypto,
     });
@@ -353,10 +362,10 @@ describe("Account permissions", () => {
 
     // The GlobalMe is not this account
     expect(account.getRoleOf("me")).toBe(undefined);
-    expect(Account.getMe().getRoleOf("me")).toBe("admin");
+    expect(co.account().getMe().getRoleOf("me")).toBe("admin");
 
     // Other accounts should have no role
-    const otherAccount = await Account.create({
+    const otherAccount = await co.account().create({
       creationProps: { name: "Other Account" },
       crypto: Crypto,
     });
@@ -367,7 +376,7 @@ describe("Account permissions", () => {
   });
 
   test("members array only contains self as admin", async () => {
-    const account = await Account.create({
+    const account = await co.account().create({
       creationProps: { name: "Test Account" },
       crypto: Crypto,
     });
@@ -381,7 +390,7 @@ describe("Account permissions", () => {
 describe("Account permissions", () => {
   test("canRead permissions for different roles", async () => {
     // Create test accounts
-    const admin = await Account.create({
+    const admin = await co.account().create({
       creationProps: { name: "Admin" },
       crypto: Crypto,
     });
@@ -389,13 +398,13 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const writer = await Account.createAs(admin, {
+    const writer = await co.account().createAs(admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await Account.createAs(admin, {
+    const reader = await co.account().createAs(admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await Account.createAs(admin, {
+    const writeOnly = await co.account().createAs(admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -413,7 +422,7 @@ describe("Account permissions", () => {
 
   test("canWrite permissions for different roles", async () => {
     // Create test accounts
-    const admin = await Account.create({
+    const admin = await co.account().create({
       creationProps: { name: "Admin" },
       crypto: Crypto,
     });
@@ -421,13 +430,13 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const writer = await Account.createAs(admin, {
+    const writer = await co.account().createAs(admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await Account.createAs(admin, {
+    const reader = await co.account().createAs(admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await Account.createAs(admin, {
+    const writeOnly = await co.account().createAs(admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -445,7 +454,7 @@ describe("Account permissions", () => {
 
   test("canAdmin permissions for different roles", async () => {
     // Create test accounts
-    const admin = await Account.create({
+    const admin = await co.account().create({
       creationProps: { name: "Admin" },
       crypto: Crypto,
     });
@@ -453,13 +462,13 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const writer = await Account.createAs(admin, {
+    const writer = await co.account().createAs(admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await Account.createAs(admin, {
+    const reader = await co.account().createAs(admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await Account.createAs(admin, {
+    const writeOnly = await co.account().createAs(admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -476,7 +485,7 @@ describe("Account permissions", () => {
   });
 
   test("permissions for non-members", async () => {
-    const admin = await Account.create({
+    const admin = await co.account().create({
       creationProps: { name: "Admin" },
       crypto: Crypto,
     });
@@ -484,7 +493,7 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const nonMember = await Account.createAs(admin, {
+    const nonMember = await co.account().createAs(admin, {
       creationProps: { name: "NonMember" },
     });
 
@@ -508,7 +517,7 @@ describe("Group.members", () => {
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: Account.getMe().id,
+          id: co.account().getMe().id,
         }),
         role: "admin",
       }),
@@ -536,7 +545,7 @@ describe("Group.members", () => {
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: Account.getMe().id,
+          id: co.account().getMe().id,
         }),
         role: "admin",
       }),
@@ -558,7 +567,7 @@ describe("Group.members", () => {
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: Account.getMe().id,
+          id: co.account().getMe().id,
         }),
         role: "admin",
       }),
@@ -579,7 +588,7 @@ describe("Group.members", () => {
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: Account.getMe().id,
+          id: co.account().getMe().id,
         }),
         role: "admin",
       }),

package/src/tests/imageDef.test.ts

@@ -1,6 +1,6 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, test } from "vitest";
-import { Account, FileStream, ImageDefinition, co } from "../exports.js";
+import { Account, FileStream, ImageDefinition } from "../exports.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -31,7 +31,7 @@ describe("ImageDefinition", async () => {
       { owner: me },
     );
 
-    const result = imageDef.highestResAvailable();
+    const result = ImageDefinition.highestResAvailable(imageDef);
     expect(result).toBeUndefined();
   });
 
@@ -50,7 +50,7 @@ describe("ImageDefinition", async () => {
 
     imageDef["1920x1080"] = stream;
 
-    const result = imageDef.highestResAvailable();
+    const result = ImageDefinition.highestResAvailable(imageDef);
     expect(result).toBeDefined();
     expect(result?.res).toBe("1920x1080");
     expect(result?.stream).toStrictEqual(stream);
@@ -77,7 +77,7 @@ describe("ImageDefinition", async () => {
     imageDef["1920x1080"] = stream1;
     imageDef["1280x720"] = stream2;
 
-    const result = imageDef.highestResAvailable();
+    const result = ImageDefinition.highestResAvailable(imageDef);
     expect(result).toBeDefined();
     expect(result?.res).toBe("1920x1080");
     expect(result?.stream).toStrictEqual(stream1);
@@ -104,7 +104,9 @@ describe("ImageDefinition", async () => {
     imageDef["1920x1080"] = stream1;
     imageDef["1280x720"] = stream2;
 
-    const result = imageDef.highestResAvailable({ maxWidth: 1500 });
+    const result = ImageDefinition.highestResAvailable(imageDef, {
+      maxWidth: 1500,
+    });
     expect(result).toBeDefined();
     expect(result?.res).toBe("1280x720");
     expect(result?.stream).toStrictEqual(stream2);
@@ -130,7 +132,7 @@ describe("ImageDefinition", async () => {
     imageDef["1920x1080"] = stream1;
     imageDef["1280x720"] = stream2;
 
-    const result = imageDef.highestResAvailable();
+    const result = ImageDefinition.highestResAvailable(imageDef);
     expect(result).toBeDefined();
     expect(result?.res).toBe("1920x1080");
     expect(result?.stream).toStrictEqual(stream1);
@@ -162,7 +164,7 @@ describe("ImageDefinition", async () => {
     imageDef["1280x720"] = stream2;
     imageDef["1024x576"] = stream3;
 
-    const result = imageDef.highestResAvailable();
+    const result = ImageDefinition.highestResAvailable(imageDef);
     expect(result).toBeDefined();
     expect(result?.res).toBe("1920x1080");
     expect(result?.stream).toStrictEqual(stream1);
@@ -181,10 +183,9 @@ describe("ImageDefinition", async () => {
     stream.push(new Uint8Array([1, 2, 3]));
     stream.end();
 
-    // @ts-expect-error - Testing invalid key
     imageDef["invalid-key"] = stream;
 
-    const result = imageDef.highestResAvailable();
+    const result = ImageDefinition.highestResAvailable(imageDef);
     expect(result).toBeUndefined();
   });
 
@@ -216,19 +217,25 @@ describe("ImageDefinition", async () => {
     imageDef["800x450"] = stream3;
 
     // Should return 1280x720 as it's the smallest resolution >= 1000px
-    const result1 = imageDef.highestResAvailable({ targetWidth: 1000 });
+    const result1 = ImageDefinition.highestResAvailable(imageDef, {
+      targetWidth: 1000,
+    });
     expect(result1).toBeDefined();
     expect(result1?.res).toBe("1280x720");
     expect(result1?.stream).toStrictEqual(stream2);
 
     // Should return 800x450 as it's the smallest resolution >= 700px
-    const result2 = imageDef.highestResAvailable({ targetWidth: 700 });
+    const result2 = ImageDefinition.highestResAvailable(imageDef, {
+      targetWidth: 700,
+    });
     expect(result2).toBeDefined();
     expect(result2?.res).toBe("800x450");
     expect(result2?.stream).toStrictEqual(stream3);
 
     // Should return 1920x1080 as it's the smallest resolution >= 1500px
-    const result3 = imageDef.highestResAvailable({ targetWidth: 1500 });
+    const result3 = ImageDefinition.highestResAvailable(imageDef, {
+      targetWidth: 1500,
+    });
     expect(result3).toBeDefined();
     expect(result3?.res).toBe("1920x1080");
     expect(result3?.stream).toStrictEqual(stream1);
@@ -261,7 +268,9 @@ describe("ImageDefinition", async () => {
     imageDef["800x450"] = stream3;
 
     // Should skip 1280x720 as it's incomplete and return 1920x1080
-    const result = imageDef.highestResAvailable({ targetWidth: 1000 });
+    const result = ImageDefinition.highestResAvailable(imageDef, {
+      targetWidth: 1000,
+    });
     expect(result).toBeDefined();
     expect(result?.res).toBe("800x450");
     expect(result?.stream).toStrictEqual(stream1);

package/src/tests/inbox.test.ts

@@ -1,31 +1,32 @@
 import { describe, expect, it, vi } from "vitest";
-import { Account } from "../coValues/account";
-import { CoMap } from "../coValues/coMap";
-import { Group } from "../coValues/group";
-import { Inbox, InboxSender } from "../coValues/inbox";
-import { Profile } from "../exports";
-import { co } from "../internal";
+import {
+  Account,
+  CoMap,
+  Group,
+  Inbox,
+  InboxSender,
+  Profile,
+  z,
+} from "../exports";
+import { Loaded, co, coField, zodSchemaToCoSchema } from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
 
-class Message extends CoMap {
-  text = co.string;
-}
+const Message = co.map({
+  text: z.string(),
+});
 
 describe("Inbox", () => {
   describe("Private profile", () => {
     it("Should throw if the inbox owner profile is private", async () => {
-      class WorkerAccount extends Account {
-        migrate() {
-          this.profile = Profile.create(
-            { name: "Worker" },
-            Group.create({ owner: this }),
-          );
-        }
-      }
+      const WorkerAccount = co.account().withMigration((account) => {
+        account.profile = co
+          .profile()
+          .create({ name: "Worker" }, Group.create({ owner: account }));
+      });
 
       const { clientAccount: sender, serverAccount: receiver } =
         await setupTwoNodes({
-          ServerAccountSchema: WorkerAccount,
+          ServerAccountSchema: zodSchemaToCoSchema(WorkerAccount),
         });
 
       await expect(() => InboxSender.load(receiver.id, sender)).rejects.toThrow(
@@ -53,7 +54,7 @@ describe("Inbox", () => {
     inboxSender.sendMessage(message);
 
     // Track received messages
-    const receivedMessages: Message[] = [];
+    const receivedMessages: Loaded<typeof Message>[] = [];
     let senderAccountID: unknown = undefined;
 
     // Subscribe to inbox messages
@@ -79,7 +80,7 @@ describe("Inbox", () => {
     const { clientAccount: sender, serverAccount: receiver } =
       await setupTwoNodes();
 
-    class EmptyMessage extends CoMap {}
+    const EmptyMessage = co.map({});
 
     const receiverInbox = await Inbox.load(receiver);
 
@@ -96,7 +97,7 @@ describe("Inbox", () => {
     inboxSender.sendMessage(message);
 
     // Track received messages
-    const receivedMessages: EmptyMessage[] = [];
+    const receivedMessages: Loaded<typeof EmptyMessage>[] = [];
     let senderAccountID: unknown = undefined;
 
     // Subscribe to inbox messages
@@ -140,10 +141,10 @@ describe("Inbox", () => {
     });
 
     // Setup inbox sender
-    const inboxSender = await InboxSender.load<Message, Message>(
-      receiver.id,
-      sender,
-    );
+    const inboxSender = await InboxSender.load<
+      Loaded<typeof Message>,
+      Loaded<typeof Message>
+    >(receiver.id, sender);
     const resultId = await inboxSender.sendMessage(message);
 
     const result = await Message.load(resultId, { loadAs: receiver });
@@ -169,7 +170,10 @@ describe("Inbox", () => {
     const unsubscribe = receiverInbox.subscribe(Message, async (message) => {});
 
     // Setup inbox sender
-    const inboxSender = await InboxSender.load<Message>(receiver.id, sender);
+    const inboxSender = await InboxSender.load<Loaded<typeof Message>>(
+      receiver.id,
+      sender,
+    );
     const result = await inboxSender.sendMessage(message);
 
     expect(result).toBeUndefined();
@@ -198,7 +202,10 @@ describe("Inbox", () => {
     });
 
     // Setup inbox sender
-    const inboxSender = await InboxSender.load<Message>(receiver.id, sender);
+    const inboxSender = await InboxSender.load<Loaded<typeof Message>>(
+      receiver.id,
+      sender,
+    );
 
     await expect(inboxSender.sendMessage(message)).rejects.toThrow(
       "Error: Failed",
@@ -233,7 +240,7 @@ describe("Inbox", () => {
     inboxSender.sendMessage(message);
 
     // Track received messages
-    const receivedMessages: Message[] = [];
+    const receivedMessages: Loaded<typeof Message>[] = [];
 
     // Subscribe to inbox messages
     const unsubscribe = receiverInbox.subscribe(Message, async (message) => {
@@ -273,7 +280,7 @@ describe("Inbox", () => {
     inboxSender.sendMessage(message);
 
     // Track received messages
-    const receivedMessages: Message[] = [];
+    const receivedMessages: Loaded<typeof Message>[] = [];
 
     // Subscribe to inbox messages
     const unsubscribe = receiverInbox.subscribe(Message, async (message) => {

package/src/tests/load.test.ts

@@ -1,6 +1,6 @@
 import { cojsonInternals } from "cojson";
 import { beforeEach, expect, test } from "vitest";
-import { Account, CoMap, Group, co } from "../exports.js";
+import { Account, Group, co, z } from "../exports.js";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
@@ -15,9 +15,9 @@ beforeEach(async () => {
 });
 
 test("load a value", async () => {
-  class Person extends CoMap {
-    name = co.string;
-  }
+  const Person = co.map({
+    name: z.string(),
+  });
 
   const group = Group.create();
   const map = Person.create({ name: "John" }, group);
@@ -31,9 +31,9 @@ test("load a value", async () => {
 });
 
 test("retry an unavailable a value", async () => {
-  class Person extends CoMap {
-    name = co.string;
-  }
+  const Person = co.map({
+    name: z.string(),
+  });
 
   const currentAccount = Account.getMe();
 
@@ -74,9 +74,9 @@ test("retry an unavailable a value", async () => {
 });
 
 test("returns null if the value is unavailable after retries", async () => {
-  class Person extends CoMap {
-    name = co.string;
-  }
+  const Person = co.map({
+    name: z.string(),
+  });
 
   const currentAccount = Account.getMe();