jazz-tools 0.15.16 → 0.16.1

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

@@ -25,8 +25,7 @@ import {
   CoValueFromRaw,
   InstanceOfSchema,
   Loaded,
-  anySchemaToCoSchema,
-  zodSchemaToCoSchema,
+  coValueClassFromCoValueClassOrSchema,
 } from "../internal";
 import {
   createJazzTestAccount,
@@ -244,7 +243,7 @@ describe("ContextManager", () => {
 
     const AccountRoot = co.map({
       value: z.string(),
-      get transferredRoot(): z.ZodOptional<typeof AccountRoot> {
+      get transferredRoot(): co.Optional<typeof AccountRoot> {
         return co.optional(AccountRoot);
       },
     });
@@ -270,7 +269,7 @@ describe("ContextManager", () => {
     >();
 
     await customManager.createContext({
-      AccountSchema: anySchemaToCoSchema(CustomAccount),
+      AccountSchema: coValueClassFromCoValueClassOrSchema(CustomAccount),
       storage: dbFilename,
       onAnonymousAccountDiscarded: async (anonymousAccount) => {
         const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
@@ -336,7 +335,7 @@ describe("ContextManager", () => {
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: anySchemaToCoSchema(CustomAccount),
+      AccountSchema: coValueClassFromCoValueClassOrSchema(CustomAccount),
     });
 
     const account = (
@@ -387,7 +386,7 @@ describe("ContextManager", () => {
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: anySchemaToCoSchema(CustomAccount),
+      AccountSchema: coValueClassFromCoValueClassOrSchema(CustomAccount),
     });
 
     const account = (
@@ -412,7 +411,7 @@ describe("ContextManager", () => {
   test("onAnonymousAccountDiscarded should work on transfering data between accounts", async () => {
     const AccountRoot = co.map({
       value: z.string(),
-      get transferredRoot(): z.ZodOptional<typeof AccountRoot> {
+      get transferredRoot(): co.Optional<typeof AccountRoot> {
         return co.optional(AccountRoot);
       },
     });
@@ -459,12 +458,12 @@ describe("ContextManager", () => {
     // Create initial anonymous context
     await customManager.createContext({
       onAnonymousAccountDiscarded,
-      AccountSchema: anySchemaToCoSchema(CustomAccount),
+      AccountSchema: coValueClassFromCoValueClassOrSchema(CustomAccount),
     });
 
     const account = await createJazzTestAccount({
       isCurrentActiveAccount: true,
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
     });
 
     await customManager.authenticate({

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

@@ -1,5 +1,5 @@
 import { assert, beforeEach, expect, test } from "vitest";
-import { Account, CoListSchema, Group, co, z } from "../exports.js";
+import { Account, Group, co, z } from "../exports.js";
 import {
   createJazzTestAccount,
   linkAccounts,
@@ -147,10 +147,10 @@ test("should support recursive props on co.profile", async () => {
     username: z.optional(z.string()),
     display_name: z.optional(z.string()),
     anonymous: z.boolean(),
-    get following(): CoListSchema<typeof User> {
+    get following(): co.List<typeof User> {
       return co.list(User);
     },
-    get followers(): CoListSchema<typeof User> {
+    get followers(): co.List<typeof User> {
       return co.list(User);
     },
   });
@@ -194,3 +194,65 @@ test("should support recursive props on co.profile", async () => {
   expect(account.profile.following.length).toBe(0);
   expect(account.profile.followers.length).toBe(0);
 });
+
+test("root and profile should be trusting by default", async () => {
+  const AccountSchema = co
+    .account({
+      profile: co.profile(),
+      root: co.map({
+        name: z.string(),
+      }),
+    })
+    .withMigration((me, creationProps) => {
+      const group = Group.create({ owner: me }).makePublic();
+
+      if (me.profile === undefined) {
+        me.profile = co.profile().create(
+          {
+            name: creationProps?.name ?? "Anonymous",
+          },
+          group,
+        );
+      }
+
+      if (me.root === undefined) {
+        me.root = co
+          .map({
+            name: z.string(),
+          })
+          .create(
+            {
+              name: creationProps?.name ?? "Anonymous",
+            },
+            group,
+          );
+      }
+    });
+
+  const bob = await createJazzTestAccount({
+    AccountSchema,
+    creationProps: {
+      name: "Bob",
+    },
+  });
+
+  const alice = await createJazzTestAccount({
+    AccountSchema,
+    creationProps: {
+      name: "Alice",
+    },
+  });
+
+  const bobAccountLoadedFromAlice = await AccountSchema.load(bob.id, {
+    loadAs: alice,
+    resolve: {
+      profile: true,
+      root: true,
+    },
+  });
+
+  assert(bobAccountLoadedFromAlice);
+
+  expect(bobAccountLoadedFromAlice.profile.name).toBe("Bob");
+  expect(bobAccountLoadedFromAlice.root.name).toBe("Bob");
+});

package/src/tools/tests/coDiscriminatedUnion.test-d.ts

@@ -44,6 +44,44 @@ describe("co.discriminatedUnion", () => {
     matches(person);
   });
 
+  test("recursive co.discriminatedUnion", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+      get friend() {
+        return co.optional(Pet);
+      },
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      get friend() {
+        return co.optional(Pet);
+      },
+    });
+
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const pallino = Cat.create({
+      type: "cat",
+      friend: Dog.create({
+        type: "dog",
+      }),
+    });
+
+    pallino.friend = Cat.create({
+      type: "cat",
+    });
+
+    type ExpectedType = {
+      friend: Loaded<typeof Dog> | Loaded<typeof Cat> | undefined;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(pallino);
+  });
+
   test("cannot use co.discriminatedUnion with zod schemas as values", () => {
     const Person = co.map({
       pet: co.discriminatedUnion("type", [

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

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import { Loaded, co, z } from "../exports.js";
+import { CoPlainText, Loaded, co, z } from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -39,6 +39,224 @@ describe("co.discriminatedUnion", () => {
     expect(person.pet.type).toEqual("cat");
   });
 
+  test("use nested co.discriminatedUnions", () => {
+    const BaseError = { status: z.literal("failed"), message: z.string() };
+    const BadRequestError = co.map({ ...BaseError, code: z.literal(400) });
+    const UnauthorizedError = co.map({ ...BaseError, code: z.literal(401) });
+    const InternalServerError = co.map({ ...BaseError, code: z.literal(500) });
+    const Errors = co.discriminatedUnion("code", [
+      BadRequestError,
+      UnauthorizedError,
+      InternalServerError,
+    ]);
+
+    const Success = co.map({ status: z.literal("success"), data: z.string() });
+    const Response = co.map({
+      result: co.discriminatedUnion("status", [Success, Errors]),
+    });
+
+    const response = Response.create({
+      result: Success.create({
+        status: "success",
+        data: "Hello, world!",
+      }),
+    });
+
+    expect(response.result.status).toEqual("success");
+    if (response.result.status === "success") {
+      expect(response.result.data).toEqual("Hello, world!");
+    }
+
+    response.result = BadRequestError.create({
+      status: "failed",
+      message: "Bad request",
+      code: 400,
+    });
+
+    expect(response.result.status).toEqual("failed");
+    if (response.result.status === "failed") {
+      expect(response.result.code).toEqual(400);
+      if (response.result.code === 400) {
+        expect(response.result.message).toEqual("Bad request");
+      }
+    }
+  });
+
+  test("use deeply nested co.discriminatedUnions", () => {
+    const BaseError = { status: z.literal("failed"), message: z.string() };
+    const BadRequestError = co.map({ ...BaseError, code: z.literal(400) });
+    const UnauthorizedError = co.map({ ...BaseError, code: z.literal(401) });
+    const Errors = co.discriminatedUnion("code", [
+      BadRequestError,
+      co.discriminatedUnion("code", [
+        co.discriminatedUnion("code", [
+          co.discriminatedUnion("code", [UnauthorizedError]),
+        ]),
+      ]),
+    ]);
+
+    const Response = co.map({
+      error: Errors,
+    });
+
+    const response = Response.create({
+      error: BadRequestError.create({
+        status: "failed",
+        message: "Bad request",
+        code: 400,
+      }),
+    });
+
+    expect(response.error.status).toEqual("failed");
+    if (response.error.status === "failed") {
+      expect(response.error.code).toEqual(400);
+      if (response.error.code === 400) {
+        expect(response.error.message).toEqual("Bad request");
+      }
+    }
+
+    response.error = UnauthorizedError.create({
+      status: "failed",
+      message: "Unauthorized",
+      code: 401,
+    });
+
+    expect(response.error.status).toEqual("failed");
+    if (response.error.status === "failed") {
+      expect(response.error.code).toEqual(401);
+      if (response.error.code === 401) {
+        expect(response.error.message).toEqual("Unauthorized");
+      }
+    }
+  });
+
+  test("co.discriminatedUnion works when nested inside a co.list", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const Pets = co.list(Pet);
+
+    const Person = co.map({
+      pets: Pets,
+    });
+
+    const pets = Pets.create([
+      Dog.create({
+        type: "dog",
+      }),
+      Cat.create({
+        type: "cat",
+      }),
+    ]);
+    const person = Person.create({
+      pets,
+    });
+
+    expect(person.pets[0]?.type).toEqual("dog");
+    expect(person.pets[1]?.type).toEqual("cat");
+  });
+
+  test("co.discriminatedUnion works when used in a recursive reference", () => {
+    const NoteItem = co.map({
+      type: z.literal("note"),
+      internal: z.boolean(),
+      content: co.plainText(),
+    });
+
+    const AttachmentItem = co.map({
+      type: z.literal("attachment"),
+      internal: z.boolean(),
+      content: co.fileStream(),
+    });
+
+    const ReferenceItem = co.map({
+      type: z.literal("reference"),
+      internal: z.boolean(),
+      content: z.string(),
+
+      get child(): co.DiscriminatedUnion<
+        [typeof NoteItem, typeof AttachmentItem, typeof ReferenceItem]
+      > {
+        return ProjectContextItem;
+      },
+    });
+
+    const ProjectContextItem = co.discriminatedUnion("type", [
+      NoteItem,
+      AttachmentItem,
+      ReferenceItem,
+    ]);
+
+    const referenceItem = ReferenceItem.create({
+      type: "reference",
+      internal: false,
+      content: "Hello",
+      child: NoteItem.create({
+        type: "note",
+        internal: false,
+        content: CoPlainText.create("Hello"),
+      }),
+    });
+
+    expect(referenceItem.child.type).toEqual("note");
+  });
+
+  test("co.discriminatedUnion works when used inside another schema in a recursive reference", () => {
+    const NoteItem = co.map({
+      type: z.literal("note"),
+      internal: z.boolean(),
+      content: co.plainText(),
+    });
+
+    const AttachmentItem = co.map({
+      type: z.literal("attachment"),
+      internal: z.boolean(),
+      content: co.fileStream(),
+    });
+
+    const ReferenceItem = co.map({
+      type: z.literal("reference"),
+      internal: z.boolean(),
+      content: z.string(),
+
+      get children(): co.List<
+        co.DiscriminatedUnion<
+          [typeof NoteItem, typeof AttachmentItem, typeof ReferenceItem]
+        >
+      > {
+        return ProjectContextItems;
+      },
+    });
+
+    const ProjectContextItem = co.discriminatedUnion("type", [
+      NoteItem,
+      AttachmentItem,
+      ReferenceItem,
+    ]);
+
+    const ProjectContextItems = co.list(ProjectContextItem);
+
+    const referenceItem = ReferenceItem.create({
+      type: "reference",
+      internal: false,
+      content: "Hello",
+      children: ProjectContextItems.create([
+        NoteItem.create({
+          type: "note",
+          internal: false,
+          content: CoPlainText.create("Hello"),
+        }),
+      ]),
+    });
+
+    expect(referenceItem.children[0]?.type).toEqual("note");
+  });
+
   test("load CoValue instances using the DiscriminatedUnion schema", async () => {
     const Dog = co.map({
       type: z.literal("dog"),

package/src/tools/tests/coFeed.test-d.ts

@@ -70,9 +70,10 @@ describe("CoFeed", () => {
     });
 
     test("CoFeed create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -80,11 +81,11 @@ describe("CoFeed", () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
-      }) as Dog;
+      });
 
       const feed = DogFeed.create([dog, undefined]);
 

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

@@ -13,15 +13,9 @@ import {
   FileStream,
   Group,
   co,
-  cojsonInternals,
   isControlledAccount,
   z,
 } from "../index.js";
-import {
-  Loaded,
-  createJazzContextFromExistingCredentials,
-  randomSessionProvider,
-} from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
@@ -58,6 +52,14 @@ describe("Simple CoFeed operations", async () => {
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
+  test("Construction with nullable values", () => {
+    const NullableTestStream = co.feed(z.string().nullable());
+    const stream = NullableTestStream.create(["milk", null], { owner: me });
+
+    expect(stream.perAccount[me.id]?.value).toEqual(null);
+    expect(stream.perSession[me.sessionID]?.value).toEqual(null);
+  });
+
   test("Construction with an Account", () => {
     const stream = TestStream.create(["milk"], me);
 

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

@@ -74,9 +74,10 @@ describe("CoList", () => {
     });
 
     test("CoList create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -84,11 +85,11 @@ describe("CoList", () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
-      }) as Dog;
+      });
 
       const list = DogList.create([dog, undefined]);
 
@@ -101,6 +102,34 @@ describe("CoList", () => {
       matches(list);
     });
 
+    test("CoList with recursive reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+        get friends() {
+          return DogList.optional();
+        },
+      });
+
+      const DogList = co.list(Dog);
+
+      const rex = Dog.create({
+        name: "Rex",
+        breed: "Labrador",
+        friends: DogList.create([]),
+      });
+
+      const list = DogList.create([rex]);
+
+      type ExpectedType = Loaded<typeof Dog>[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
     test("CoList with nested lists", () => {
       const NestedList = co.list(co.list(z.string()));
 

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

@@ -1,7 +1,11 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { Account, Group, subscribeToCoValue, z } from "../index.js";
-import { Loaded, anySchemaToCoSchema, co } from "../internal.js";
+import {
+  Loaded,
+  co,
+  coValueClassFromCoValueClassOrSchema,
+} from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -48,6 +52,16 @@ describe("Simple CoList operations", async () => {
     expect(list[2]).toBe("c");
   });
 
+  test("list with nullable content", () => {
+    const List = co.list(z.string().nullable());
+    const list = List.create(["a", "b", "c", null]);
+    expect(list.length).toBe(4);
+    expect(list[0]).toBe("a");
+    expect(list[1]).toBe("b");
+    expect(list[2]).toBe("c");
+    expect(list[3]).toBeNull();
+  });
+
   test("Construction with an Account", () => {
     const list = TestList.create(["milk"], me);
 
@@ -580,7 +594,7 @@ describe("CoList subscription", async () => {
     const spy = vi.fn((list) => updates.push(list));
 
     subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         syncResolution: true,
@@ -806,3 +820,17 @@ describe("CoList subscription", async () => {
     expect(spy).toHaveBeenCalledTimes(2);
   });
 });
+
+describe("co.list schema", () => {
+  test("can access the inner schema of a co.list", () => {
+    const Keywords = co.list(co.plainText());
+
+    const keywords = Keywords.create([
+      Keywords.element.create("hello"),
+      Keywords.element.create("world"),
+    ]);
+
+    expect(keywords[0]?.toString()).toEqual("hello");
+    expect(keywords[1]?.toString()).toEqual("world");
+  });
+});

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

@@ -81,9 +81,10 @@ describe("CoMap.Record", () => {
     });
 
     test("Record create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -91,11 +92,11 @@ describe("CoMap.Record", () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
-      }) as Dog;
+      });
 
       const record = DogRecord.create({
         pet1: dog,
@@ -112,6 +113,33 @@ describe("CoMap.Record", () => {
 
       matches(record);
     });
+
+    test("Record with recursive reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        get owner() {
+          return Person.optional();
+        },
+      });
+
+      const Person = co.record(z.string(), Dog);
+
+      const person = Person.create({
+        pet1: Dog.create({ name: "Rex" }),
+      });
+
+      person.pet1!.owner = person;
+
+      type ExpectedType = {
+        [key: string]: Loaded<typeof Dog> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
   });
 
   describe("Record resolution", () => {