jazz-tools 0.15.16 → 0.16.0

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

@@ -12,7 +12,7 @@ import {
 } from "vitest";
 import { Group, co, subscribeToCoValue, z } from "../exports.js";
 import { Account } from "../index.js";
-import { Loaded, anySchemaToCoSchema } from "../internal.js";
+import { Loaded, coValueClassFromCoValueClassOrSchema } from "../internal.js";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
@@ -144,7 +144,7 @@ describe("CoMap", async () => {
         name: z.string(),
         age: z.number(),
         // TODO: would be nice if this didn't need a type annotation
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend(): co.Optional<typeof Person> {
           return co.optional(Person);
         },
       });
@@ -181,7 +181,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend(): co.Optional<typeof Person> {
           return co.optional(Person);
         },
       });
@@ -210,7 +210,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend(): co.Optional<typeof Person> {
           return co.optional(Person);
         },
       });
@@ -801,7 +801,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     subscribeToCoValue(
-      anySchemaToCoSchema(Person), // TODO: we should get rid of the conversion in the future
+      coValueClassFromCoValueClassOrSchema(Person), // TODO: we should get rid of the conversion in the future
       person.id,
       {
         syncResolution: true,
@@ -2104,6 +2104,20 @@ describe("CoMap migration", () => {
   });
 });
 
+describe("co.map schema", () => {
+  test("can access the inner schemas of a co.map", () => {
+    const Person = co.map({
+      name: co.plainText(),
+    });
+
+    const person = Person.create({
+      name: Person.shape["name"].create("John"),
+    });
+
+    expect(person.name.toString()).toEqual("John");
+  });
+});
+
 describe("Updating a nested reference", () => {
   test("should assign a resolved optional reference and expect value is not null", async () => {
     // Define the schema similar to the server-worker-http example

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

@@ -1,4 +1,4 @@
-import { beforeEach, describe, test } from "vitest";
+import { beforeEach, describe, expect, test } from "vitest";
 import { CoPlainText, co, z } from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 
@@ -36,4 +36,66 @@ describe("co.optional", () => {
       preferredName: co.optional(z.string()),
     });
   });
+
+  test("can use schem.optional() on all CoValue schemas but co.optional()", () => {
+    const Option1 = co.map({ type: z.literal("1") });
+    const Option2 = co.map({ type: z.literal("2") });
+    const Schema = co.map({
+      plainText: co.plainText().optional(),
+      richText: co.richText().optional(),
+      fileStream: co.fileStream().optional(),
+      image: co.image().optional(),
+      record: co.record(z.string(), z.string()).optional(),
+      map: co.map({ field: z.string() }).optional(),
+      list: co.list(z.string()).optional(),
+      feed: co.feed(z.string()).optional(),
+      union: co.discriminatedUnion("type", [Option1, Option2]).optional(),
+    });
+
+    const schema = Schema.create({});
+
+    expect(schema.plainText).toBeUndefined();
+    expect(schema.richText).toBeUndefined();
+    expect(schema.fileStream).toBeUndefined();
+    expect(schema.image).toBeUndefined();
+    expect(schema.record).toBeUndefined();
+    expect(schema.map).toBeUndefined();
+    expect(schema.list).toBeUndefined();
+    expect(schema.feed).toBeUndefined();
+    expect(schema.union).toBeUndefined();
+
+    schema.plainText = Schema.shape.plainText.innerType.create("Hello");
+    schema.richText = Schema.shape.richText.innerType.create("Hello");
+    schema.fileStream = Schema.shape.fileStream.innerType.create();
+    schema.image = Schema.shape.image.innerType.create({
+      originalSize: [1920, 1080],
+    });
+    schema.record = Schema.shape.record.innerType.create({ field: "hello" });
+    schema.map = Schema.shape.map.innerType.create({ field: "hello" });
+    schema.list = Schema.shape.list.innerType.create([]);
+    schema.feed = Schema.shape.feed.innerType.create([]);
+    schema.union = Option1.create({ type: "1" });
+
+    expect(schema.plainText?.toString()).toEqual("Hello");
+    expect(schema.richText?.toString()).toEqual("Hello");
+    expect(schema.fileStream).not.toBeUndefined();
+    expect(schema.image?.originalSize).toEqual([1920, 1080]);
+    expect(schema.record?.field).toEqual("hello");
+    expect(schema.map?.field).toEqual("hello");
+    expect(schema.list).toEqual([]);
+    expect(schema.feed).not.toBeUndefined();
+    expect(schema.union?.type).toEqual("1");
+  });
+
+  test("can access the inner schema of a co.optional", () => {
+    const Person = co.map({
+      preferredName: co.optional(co.plainText()),
+    });
+
+    const person = Person.create({
+      preferredName: Person.shape["preferredName"].innerType.create("John"),
+    });
+
+    expect(person?.preferredName?.toString()).toEqual("John");
+  });
 });

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

@@ -9,15 +9,13 @@ import {
   ID,
   InMemoryKVStore,
   KvStoreContext,
-  anySchemaToCoSchema,
   co,
+  coValueClassFromCoValueClassOrSchema,
   createAnonymousJazzContext,
   createJazzContext,
   createJazzContextForNewAccount,
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
-  z,
-  zodSchemaToCoSchema,
 } from "../exports";
 import { activeAccountContext } from "../implementation/activeAccountContext";
 import {
@@ -86,12 +84,12 @@ describe("createContext methods", () => {
         credentials,
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
         sessionProvider: randomSessionProvider,
       });
 
       expect(context.account).toBeInstanceOf(
-        anySchemaToCoSchema(CustomAccount),
+        coValueClassFromCoValueClassOrSchema(CustomAccount),
       );
     });
 
@@ -196,11 +194,11 @@ describe("createContext methods", () => {
         creationProps: { name: "New User" },
         peersToLoadFrom: [],
         crypto: Crypto,
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
       });
 
       expect(context.account).toBeInstanceOf(
-        anySchemaToCoSchema(CustomAccount),
+        coValueClassFromCoValueClassOrSchema(CustomAccount),
       );
     });
 
@@ -347,11 +345,11 @@ describe("createContext methods", () => {
         crypto: Crypto,
         authSecretStorage,
         sessionProvider: randomSessionProvider,
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
       });
 
       expect(context.account).toBeInstanceOf(
-        anySchemaToCoSchema(CustomAccount),
+        coValueClassFromCoValueClassOrSchema(CustomAccount),
       );
     });
   });

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

@@ -1,4 +1,4 @@
-import { Profile, cojsonInternals } from "cojson";
+import { cojsonInternals } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, describe, expect, expectTypeOf, test, vi } from "vitest";
 import {
@@ -9,13 +9,7 @@ import {
   isControlledAccount,
   z,
 } from "../index.js";
-import {
-  Account,
-  CoListSchema,
-  Loaded,
-  co,
-  randomSessionProvider,
-} from "../internal.js";
+import { Account, Loaded, co, randomSessionProvider } from "../internal.js";
 import { createJazzTestAccount, linkAccounts } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -794,11 +788,11 @@ describe("Deep loading with unauthorized account", async () => {
   test("unaccessible list element with $onError and $each with depth", async () => {
     const Person = co.map({
       name: z.string(),
-      get friends(): z.ZodOptional<typeof Friends> {
+      get friends(): co.Optional<typeof Friends> {
         return co.optional(Friends);
       },
     });
-    const Friends: CoListSchema<typeof Person> = co.list(Person); // TODO: annoying that we have to annotate
+    const Friends: co.List<typeof Person> = co.list(Person); // TODO: annoying that we have to annotate
 
     const list = Friends.create(
       [

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

@@ -464,13 +464,13 @@ describe("importContentPieces", () => {
       {
         title: "My First Post",
         content: "Hello World",
-        comments: Post.def.shape.comments.create([comment1, comment2], group),
+        comments: Post.shape.comments.create([comment1, comment2], group),
       },
       group,
     );
 
     const blog = Blog.create(
-      { name: "My Blog", posts: Blog.def.shape.posts.create([post], group) },
+      { name: "My Blog", posts: Blog.shape.posts.create([post], group) },
       group,
     );
 

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

@@ -1,7 +1,7 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { CoMap, Group, z } from "../exports.js";
-import { Loaded, Ref, co, zodSchemaToCoSchema } from "../internal.js";
+import { Loaded, Ref, co } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes, waitFor } from "./utils.js";
 
@@ -22,15 +22,16 @@ describe("Custom accounts and groups", async () => {
       color: z.string(),
     });
 
+    const Root = co.map({});
     const CustomAccount = co
       .account({
         profile: CustomProfile,
-        root: co.map({}),
+        root: Root,
       })
       .withMigration((account, creationProps?: { name: string }) => {
         // making sure that the inferred type of account.root & account.profile considers the root/profile not being loaded
         type R = typeof account.root;
-        const _r: R = {} as Loaded<typeof CustomAccount.def.shape.root> | null;
+        const _r: R = {} as Loaded<typeof Root> | null;
         type P = typeof account.profile;
         const _p: P = {} as Loaded<typeof CustomProfile> | null;
         if (creationProps) {
@@ -47,7 +48,7 @@ describe("Custom accounts and groups", async () => {
     const me = await createJazzTestAccount({
       creationProps: { name: "Hermes Puggington" },
       isCurrentActiveAccount: true,
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
     });
 
     expect(me.profile).toBeDefined();

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

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import { Group, Inbox, InboxSender, z } from "../exports";
-import { Loaded, anySchemaToCoSchema, co } from "../internal";
+import { Loaded, co, coValueClassFromCoValueClassOrSchema } from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
 
 const Message = co.map({
@@ -18,7 +18,8 @@ describe("Inbox", () => {
 
       const { clientAccount: sender, serverAccount: receiver } =
         await setupTwoNodes({
-          ServerAccountSchema: anySchemaToCoSchema(WorkerAccount),
+          ServerAccountSchema:
+            coValueClassFromCoValueClassOrSchema(WorkerAccount),
         });
 
       await expect(() => InboxSender.load(receiver.id, sender)).rejects.toThrow(

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

@@ -69,33 +69,6 @@ test("load a missing optional value (co.optional)", async () => {
   expect(john.dog).toBeUndefined();
 });
 
-test("load a missing optional value (z.optional)", async () => {
-  const Dog = co.map({
-    name: z.string(),
-  });
-
-  const Person = co.map({
-    name: z.string(),
-    dog: z.optional(Dog),
-  });
-
-  const group = Group.create();
-  const map = Person.create({ name: "John" }, group);
-  group.addMember("everyone", "reader");
-
-  const alice = await createJazzTestAccount();
-
-  const john = await Person.load(map.id, {
-    loadAs: alice,
-    resolve: { dog: true },
-  });
-
-  assert(john);
-
-  expect(john.name).toBe("John");
-  expect(john.dog).toBeUndefined();
-});
-
 test("load a missing optional value (Schema.optional)", async () => {
   const Dog = co.map({
     name: z.string(),
@@ -214,13 +187,14 @@ test("returns null if the value is unavailable after retries", async () => {
 test("load a large coValue", async () => {
   const syncServer = await setupJazzTestSync({ asyncPeers: true });
 
+  const Data = co.list(z.string());
   const LargeDataset = co.map({
     metadata: z.object({
       name: z.string(),
       description: z.string(),
       createdAt: z.number(),
     }),
-    data: co.list(z.string()),
+    data: Data,
   });
 
   const group = Group.create(syncServer);
@@ -232,7 +206,7 @@ test("load a large coValue", async () => {
           "A dataset with many entries for testing large coValue loading",
         createdAt: Date.now(),
       },
-      data: LargeDataset.def.shape.data.create([], group),
+      data: Data.create([], group),
     },
     group,
   );

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

@@ -4,8 +4,8 @@ import {
   Account,
   CryptoProvider,
   Loaded,
-  anySchemaToCoSchema,
   co,
+  coValueClassFromCoValueClassOrSchema,
   subscribeToCoValue,
   z,
 } from "../exports.js";
@@ -93,7 +93,7 @@ describe("SchemaUnion", () => {
     );
     let currentValue = "Submit";
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(WidgetUnion),
+      coValueClassFromCoValueClassOrSchema(WidgetUnion),
       buttonWidget.id,
       { loadAs: me, syncResolution: true },
       (value: Loaded<typeof WidgetUnion>) => {

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

@@ -10,9 +10,8 @@ import {
 import { Account, Group, cojsonInternals, z } from "../index.js";
 import {
   Loaded,
-  anySchemaToCoSchema,
   co,
-  createCoValueObservable,
+  coValueClassFromCoValueClassOrSchema,
   subscribeToCoValue,
 } from "../internal.js";
 import {
@@ -70,7 +69,7 @@ describe("subscribeToCoValue", () => {
     let result = null as Loaded<typeof ChatRoom, true> | null;
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       { loadAs: meOnSecondPeer },
       (value) => {
@@ -117,7 +116,7 @@ describe("subscribeToCoValue", () => {
     let result = null as Loaded<typeof ChatRoom, {}> | null;
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -158,7 +157,7 @@ describe("subscribeToCoValue", () => {
     messages.push(createMessage(me, "Hello"));
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -201,7 +200,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -261,7 +260,7 @@ describe("subscribeToCoValue", () => {
     >[];
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -332,7 +331,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -396,7 +395,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: account,
@@ -457,7 +456,7 @@ describe("subscribeToCoValue", () => {
     const onUnauthorized = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -528,7 +527,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -603,7 +602,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -673,7 +672,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -725,7 +724,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: creator,
@@ -792,7 +791,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: creator,
@@ -881,7 +880,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(Person),
+      coValueClassFromCoValueClassOrSchema(Person),
       person.id,
       {
         loadAs: reader,
@@ -968,7 +967,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -1055,7 +1054,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(PersonList),
+      coValueClassFromCoValueClassOrSchema(PersonList),
       list.id,
       {
         loadAs: reader,
@@ -1151,7 +1150,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(PersonList),
+      coValueClassFromCoValueClassOrSchema(PersonList),
       list.id,
       {
         loadAs: reader,
@@ -1188,13 +1187,14 @@ describe("subscribeToCoValue", () => {
   it("should subscribe to a large coValue", async () => {
     const syncServer = await setupJazzTestSync({ asyncPeers: true });
 
+    const Data = co.list(z.string());
     const LargeDataset = co.map({
       metadata: z.object({
         name: z.string(),
         description: z.string(),
         createdAt: z.number(),
       }),
-      data: co.list(z.string()),
+      data: Data,
     });
 
     const group = Group.create(syncServer);
@@ -1206,7 +1206,7 @@ describe("subscribeToCoValue", () => {
             "A dataset with many entries for testing large coValue subscription",
           createdAt: Date.now(),
         },
-        data: LargeDataset.def.shape.data.create([], group),
+        data: Data.create([], group),
       },
       group,
     );
@@ -1234,7 +1234,7 @@ describe("subscribeToCoValue", () => {
 
     // Test subscribing to the large coValue
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(LargeDataset),
+      coValueClassFromCoValueClassOrSchema(LargeDataset),
       largeMap.id,
       {
         loadAs: alice,
@@ -1277,95 +1277,3 @@ describe("subscribeToCoValue", () => {
     expect(result.data[chunks]).toBe("new entry");
   });
 });
-
-describe("createCoValueObservable", () => {
-  const TestMap = co.map({
-    color: z.string(),
-  });
-
-  function createTestMap(me: Account | Group) {
-    return TestMap.create({ color: "red" }, { owner: me });
-  }
-
-  it("should return undefined when there are no subscribers", async () => {
-    const observable = createCoValueObservable();
-
-    expect(observable.getCurrentValue()).toBeUndefined();
-  });
-
-  it("should update currentValue when subscribed", async () => {
-    const { me, meOnSecondPeer } = await setupAccount();
-    const testMap = createTestMap(me);
-    const observable = createCoValueObservable();
-    const mockListener = vi.fn();
-
-    const unsubscribe = observable.subscribe(
-      anySchemaToCoSchema(TestMap),
-      testMap.id,
-      {
-        loadAs: meOnSecondPeer,
-      },
-      () => {
-        mockListener();
-      },
-    );
-
-    testMap.color = "blue";
-
-    await waitFor(() => mockListener.mock.calls.length > 0);
-
-    expect(observable.getCurrentValue()).toMatchObject({
-      id: testMap.id,
-      color: "blue",
-    });
-
-    unsubscribe();
-  });
-
-  it("should reset to undefined after unsubscribe", async () => {
-    const { me, meOnSecondPeer } = await setupAccount();
-    const testMap = createTestMap(me);
-    const observable = createCoValueObservable();
-    const mockListener = vi.fn();
-
-    const unsubscribe = observable.subscribe(
-      anySchemaToCoSchema(TestMap),
-      testMap.id,
-      {
-        loadAs: meOnSecondPeer,
-      },
-      () => {
-        mockListener();
-      },
-    );
-
-    await waitFor(() => mockListener.mock.calls.length > 0);
-    expect(observable.getCurrentValue()).toBeDefined();
-
-    unsubscribe();
-    expect(observable.getCurrentValue()).toBeUndefined();
-  });
-
-  it("should return null if the coValue is not found", async () => {
-    const { meOnSecondPeer } = await setupAccount();
-    const observable = createCoValueObservable<
-      typeof TestMap,
-      Loaded<typeof TestMap, {}>
-    >();
-
-    const unsubscribe = observable.subscribe(
-      TestMap,
-      "co_z123",
-      { loadAs: meOnSecondPeer },
-      () => {},
-    );
-
-    expect(observable.getCurrentValue()).toBeUndefined();
-
-    await waitFor(() => {
-      expect(observable.getCurrentValue()).toBeNull();
-    });
-
-    unsubscribe();
-  });
-});