jazz-tools 0.16.2 → 0.16.4

package/src/tools/implementation/zodSchema/zodSchema.ts

@@ -23,11 +23,7 @@ import {
 } from "./schemaTypes/CoDiscriminatedUnionSchema.js";
 import { CoFeedSchema, CoreCoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
 import { CoListSchema, CoreCoListSchema } from "./schemaTypes/CoListSchema.js";
-import {
-  CoMapSchema,
-  CoMapSchemaInit,
-  CoreCoMapSchema,
-} from "./schemaTypes/CoMapSchema.js";
+import { CoMapSchema, CoreCoMapSchema } from "./schemaTypes/CoMapSchema.js";
 import {
   CoOptionalSchema,
   CoreCoOptionalSchema,
@@ -84,8 +80,8 @@ export type CoValueSchemaFromCoreSchema<S extends CoreCoValueSchema> =
 export type CoValueClassFromAnySchema<S extends CoValueClassOrSchema> =
   S extends CoValueClass<any>
     ? S
-    : CoValueClass<InstanceOfSchema<S>> &
-        CoValueFromRaw<InstanceOfSchema<S>> &
+    : CoValueClass<NonNullable<InstanceOfSchema<S>>> &
+        CoValueFromRaw<NonNullable<InstanceOfSchema<S>>> &
         (S extends CoreAccountSchema ? AccountClassEssentials : {});
 
 type AccountClassEssentials = {
@@ -105,7 +101,7 @@ export type AnyCoreCoValueSchema =
   | CoreRichTextSchema
   | CoreFileStreamSchema;
 
-type AnyZodSchema = z.core.$ZodType;
+export type AnyZodSchema = z.core.$ZodType;
 
 export type AnyZodOrCoValueSchema = AnyZodSchema | CoreCoValueSchema;
 
@@ -122,9 +118,3 @@ export type ResolveQueryStrict<
   T extends CoValueClassOrSchema,
   R extends ResolveQuery<T>,
 > = RefsToResolveStrict<NonNullable<InstanceOfSchemaCoValuesNullable<T>>, R>;
-
-export type InitFor<T extends CoValueClassOrSchema> = T extends CoreCoMapSchema<
-  infer Shape
->
-  ? Simplify<CoMapSchemaInit<Shape>>
-  : never;

package/src/tools/internal.ts

@@ -45,6 +45,7 @@ export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSc
 export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOfSchema.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOfSchemaCoValuesNullable.js";
+export * from "./implementation/zodSchema/typeConverters/CoFieldInit.js";
 export * from "./implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.js";
 export * from "./implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.js";
 export * from "./coValues/extensions/imageDef.js";

package/src/tools/subscribe/SubscriptionScope.ts

@@ -7,7 +7,7 @@ import {
   type ID,
   type RefEncoded,
   type RefsToResolve,
-  instantiateRefEncoded,
+  instantiateRefEncodedFromRaw,
   isRefEncoded,
 } from "../internal.js";
 import { applyCoValueMigrations } from "../lib/migration.js";
@@ -75,7 +75,9 @@ export class SubscriptionScope<D extends CoValue> {
           }
 
           this.migrating = true;
-          applyCoValueMigrations(instantiateRefEncoded(this.schema, value));
+          applyCoValueMigrations(
+            instantiateRefEncodedFromRaw(this.schema, value),
+          );
           this.migrated = true;
           this.handleUpdate(lastUpdate);
           return;

package/src/tools/subscribe/utils.ts

@@ -4,7 +4,7 @@ import {
   CoValue,
   RefEncoded,
   coValueClassFromCoValueClassOrSchema,
-  instantiateRefEncoded,
+  instantiateRefEncodedFromRaw,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
@@ -26,7 +26,7 @@ export function createCoValue<D extends CoValue>(
   raw: RawCoValue,
   subscriptionScope: SubscriptionScope<D>,
 ) {
-  const freshValueInstance = instantiateRefEncoded(ref, raw);
+  const freshValueInstance = instantiateRefEncodedFromRaw(ref, raw);
 
   Object.defineProperty(freshValueInstance, "_subscriptionScope", {
     value: subscriptionScope,

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

@@ -52,6 +52,46 @@ describe("Simple CoFeed operations", async () => {
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
+  describe("Create CoFeed with a reference", () => {
+    let me: Account;
+
+    beforeEach(async () => {
+      await setupJazzTestSync();
+      me = await createJazzTestAccount({
+        isCurrentActiveAccount: true,
+        creationProps: { name: "Hermes Puggington" },
+      });
+    });
+
+    test("using a CoValue", () => {
+      const Text = co.plainText();
+      const TextStream = co.feed(Text);
+
+      const stream = TextStream.create([Text.create("milk")], { owner: me });
+
+      const coValue = stream.perAccount[me.id]?.value;
+      expect(coValue?.toString()).toEqual("milk");
+    });
+
+    describe("using JSON", () => {
+      test("automatically creates CoValues for nested objects", () => {
+        const Text = co.plainText();
+        const TextStream = co.feed(Text);
+
+        const stream = TextStream.create(["milk"], { owner: me });
+
+        const coValue = stream.perAccount[me.id]?.value;
+        expect(coValue?.toString()).toEqual("milk");
+      });
+
+      test("can create a coPlainText from an empty string", () => {
+        const Schema = co.feed(co.plainText());
+        const feed = Schema.create([""]);
+        expect(feed.perAccount[me.id]?.value?.toString()).toBe("");
+      });
+    });
+  });
+
   test("Construction with nullable values", () => {
     const NullableTestStream = co.feed(z.string().nullable());
     const stream = NullableTestStream.create(["milk", null], { owner: me });

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

@@ -52,6 +52,48 @@ describe("Simple CoList operations", async () => {
     expect(list[2]).toBe("c");
   });
 
+  test("create CoList with reference using CoValue", () => {
+    const Dog = co.map({
+      name: z.string(),
+    });
+    const Person = co.map({
+      pets: co.list(Dog),
+    });
+
+    const person = Person.create({
+      pets: [Dog.create({ name: "Rex" }), Dog.create({ name: "Fido" })],
+    });
+
+    expect(person.pets.length).toEqual(2);
+    expect(person.pets[0]?.name).toEqual("Rex");
+    expect(person.pets[1]?.name).toEqual("Fido");
+  });
+
+  describe("create CoList with reference using JSON", () => {
+    test("automatically creates CoValues for nested objects", () => {
+      const Dog = co.map({
+        name: z.string(),
+      });
+      const Person = co.map({
+        pets: co.list(Dog),
+      });
+
+      const person = Person.create({
+        pets: [{ name: "Rex" }, { name: "Fido" }],
+      });
+
+      expect(person.pets.length).toEqual(2);
+      expect(person.pets[0]?.name).toEqual("Rex");
+      expect(person.pets[1]?.name).toEqual("Fido");
+    });
+
+    test("can create a coPlainText from an empty string", () => {
+      const Schema = co.list(co.plainText());
+      const list = Schema.create([""]);
+      expect(list[0]?.toString()).toBe("");
+    });
+  });
+
   test("list with nullable content", () => {
     const List = co.list(z.string().nullable());
     const list = List.create(["a", "b", "c", null]);

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

@@ -1,4 +1,5 @@
 import { assert, describe, expectTypeOf, test } from "vitest";
+import { ZodNumber, ZodOptional, ZodString } from "zod/v4";
 import { Group, co, z } from "../exports.js";
 import { Account } from "../index.js";
 import { CoMap, Loaded } from "../internal.js";
@@ -54,7 +55,7 @@ describe("CoMap", async () => {
       expectTypeOf(john._owner).toEqualTypeOf<Account | Group>();
     });
 
-    test("CoMap with reference", () => {
+    test("create CoMap with reference using CoValue", () => {
       const Dog = co.map({
         name: z.string(),
         breed: z.string(),
@@ -85,6 +86,46 @@ describe("CoMap", async () => {
       matches(person);
     });
 
+    test("create CoMap with reference using JSON", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+      const Person = co.map({
+        dog1: Dog,
+        dog2: Dog,
+        get friend() {
+          return Person.optional();
+        },
+      });
+
+      const person = Person.create({
+        // @ts-expect-error - breed is missing
+        dog1: { name: "Rex", items },
+        // @ts-expect-error - Object literal may only specify known properties
+        dog2: { name: "Fido", breed: "Labrador", extra: "extra" },
+        friend: {
+          dog1: {
+            name: "Rex",
+            breed: "Labrador",
+          },
+          dog2: { name: "Fido", breed: "Labrador" },
+        },
+      });
+
+      type ExpectedType = {
+        dog1: Loaded<typeof Dog>;
+        dog2: Loaded<typeof Dog>;
+        friend: Loaded<typeof Person> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
+
     test("CoMap with optional reference", () => {
       const Dog = co.map({
         name: z.string(),
@@ -310,6 +351,148 @@ describe("CoMap", async () => {
       matchesNarrowed(mapWithEnum.child);
     }
   });
+
+  test("CoMap.pick()", () => {
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+      dog: co.map({
+        name: z.string(),
+        breed: z.string(),
+      }),
+    });
+
+    const PersonWithoutDog = Person.pick({
+      name: true,
+      age: true,
+    });
+
+    type ExpectedType = co.Map<{
+      name: ZodString;
+      age: ZodNumber;
+    }>;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(PersonWithoutDog);
+  });
+
+  test("CoMap.pick() with a recursive reference", () => {
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+      dog: co.map({
+        name: z.string(),
+        breed: z.string(),
+      }),
+      get friend() {
+        return Person.pick({
+          name: true,
+          age: true,
+        }).optional();
+      },
+    });
+
+    type ExpectedType = co.Map<{
+      name: ZodString;
+      age: ZodNumber;
+      dog: co.Map<{
+        name: ZodString;
+        breed: ZodString;
+      }>;
+      friend: co.Optional<
+        co.Map<{
+          name: ZodString;
+          age: ZodNumber;
+        }>
+      >;
+    }>;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(Person);
+  });
+
+  test("CoMap.partial()", () => {
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+      dog: co.map({
+        name: z.string(),
+        breed: z.string(),
+      }),
+    });
+
+    const PersonPartial = Person.partial();
+
+    type ExpectedType = co.Map<{
+      name: ZodOptional<ZodString>;
+      age: ZodOptional<ZodNumber>;
+      dog: co.Optional<
+        co.Map<{
+          name: ZodString;
+          breed: ZodString;
+        }>
+      >;
+    }>;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(PersonPartial);
+  });
+
+  test("CoMap.partial() with a recursive reference", () => {
+    const Person = co.map({
+      get draft() {
+        return Person.partial()
+          .pick({
+            name: true,
+            age: true,
+            dog: true,
+          })
+          .optional();
+      },
+      name: z.string(),
+      age: z.number(),
+      dog: co.map({
+        name: z.string(),
+        breed: z.string(),
+      }),
+    });
+
+    type ExpectedType = co.Map<{
+      draft: co.Optional<
+        co.Map<{
+          name: ZodOptional<ZodString>;
+          age: ZodOptional<ZodNumber>;
+          dog: co.Optional<
+            co.Map<{
+              name: ZodString;
+              breed: ZodString;
+            }>
+          >;
+        }>
+      >;
+      name: ZodString;
+      age: ZodNumber;
+      dog: co.Map<{
+        name: ZodString;
+        breed: ZodString;
+      }>;
+    }>;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(Person);
+  });
 });
 
 describe("CoMap resolution", async () => {

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

@@ -117,10 +117,9 @@ describe("CoMap", async () => {
       expect(emptyMap.color).toEqual(undefined);
     });
 
-    test("CoMap with reference", () => {
+    test("create CoMap with reference using CoValue", () => {
       const Dog = co.map({
         name: z.string(),
-        breed: z.string(),
       });
 
       const Person = co.map({
@@ -132,11 +131,89 @@ describe("CoMap", async () => {
       const person = Person.create({
         name: "John",
         age: 20,
-        dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+        dog: Dog.create({ name: "Rex" }),
       });
 
       expect(person.dog?.name).toEqual("Rex");
-      expect(person.dog?.breed).toEqual("Labrador");
+    });
+
+    describe("create CoMap with references using JSON", () => {
+      const Dog = co.map({
+        type: z.literal("dog"),
+        name: z.string(),
+      });
+      const Cat = co.map({
+        type: z.literal("cat"),
+        name: z.string(),
+      });
+
+      const Person = co.map({
+        name: co.plainText(),
+        bio: co.richText(),
+        dog: Dog,
+        get friends() {
+          return co.list(Person);
+        },
+        reactions: co.feed(co.plainText()),
+        pet: co.discriminatedUnion("type", [Dog, Cat]),
+      });
+
+      let person: ReturnType<typeof Person.create>;
+
+      beforeEach(() => {
+        person = Person.create({
+          name: "John",
+          bio: "I am a software engineer",
+          dog: { type: "dog", name: "Rex" },
+          friends: [
+            {
+              name: "Jane",
+              bio: "I am a mechanical engineer",
+              dog: { type: "dog", name: "Fido" },
+              friends: [],
+              reactions: [],
+              pet: { type: "dog", name: "Fido" },
+            },
+          ],
+          reactions: ["👎", "👍"],
+          pet: { type: "cat", name: "Whiskers" },
+        });
+      });
+
+      it("automatically creates CoValues for each CoValue reference", () => {
+        expect(person.name.toString()).toEqual("John");
+        expect(person.bio.toString()).toEqual("I am a software engineer");
+        expect(person.dog?.name).toEqual("Rex");
+        expect(person.friends.length).toEqual(1);
+        expect(person.friends[0]?.name.toString()).toEqual("Jane");
+        expect(person.friends[0]?.bio.toString()).toEqual(
+          "I am a mechanical engineer",
+        );
+        expect(person.friends[0]?.dog.name).toEqual("Fido");
+        expect(person.friends[0]?.friends.length).toEqual(0);
+        expect(person.reactions.byMe?.value?.toString()).toEqual("👍");
+        expect(person.pet.name).toEqual("Whiskers");
+      });
+
+      it("creates a group for each new CoValue that is a child of the referencing CoValue's owner", () => {
+        for (const value of Object.values(person)) {
+          expect(
+            value._owner.getParentGroups().map((group: Group) => group.id),
+          ).toContain(person._owner.id);
+        }
+        const friend = person.friends[0]!;
+        for (const value of Object.values(friend)) {
+          expect(
+            value._owner.getParentGroups().map((group: Group) => group.id),
+          ).toContain(friend._owner.id);
+        }
+      });
+
+      it("can create a coPlainText from an empty string", () => {
+        const Schema = co.map({ text: co.plainText() });
+        const map = Schema.create({ text: "" });
+        expect(map.text.toString()).toBe("");
+      });
     });
 
     test("CoMap with self reference", () => {
@@ -209,7 +286,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        get friend(): co.Optional<typeof Person> {
+        get friend() {
           return co.optional(Person);
         },
       });
@@ -2104,84 +2181,131 @@ describe("CoMap migration", () => {
     expect(loaded?.friend?.name).toEqual("Charlie");
     expect(loaded?.friend?.version).toEqual(2);
   });
-  describe("Time", () => {
-    test("empty map created time", () => {
-      const currentTimestampInSeconds = Math.floor(Date.now() / 1000);
-      const emptyMap = co.map({}).create({});
-      const createdAtInSeconds = Math.floor(emptyMap._createdAt / 1000);
+});
+
+describe("createdAt & lastUpdatedAt", () => {
+  test("empty map created time", () => {
+    const emptyMap = co.map({}).create({});
 
-      expect(createdAtInSeconds).toEqual(currentTimestampInSeconds);
-      expect(emptyMap._lastUpdatedAt).toEqual(emptyMap._createdAt);
+    expect(emptyMap._lastUpdatedAt).toEqual(emptyMap._createdAt);
+  });
+
+  test("created time and last updated time", async () => {
+    const Person = co.map({
+      name: z.string(),
     });
 
-    test("created time and last updated time", async () => {
-      const Person = co.map({
-        name: z.string(),
-      });
+    const person = Person.create({ name: "John" });
 
-      let currentTimestampInSeconds = Math.floor(Date.now() / 1000);
-      const person = Person.create({ name: "John" });
+    const createdAt = person._createdAt;
+    expect(person._lastUpdatedAt).toEqual(createdAt);
 
-      const createdAt = person._createdAt;
-      const createdAtInSeconds = Math.floor(createdAt / 1000);
-      expect(createdAtInSeconds).toEqual(currentTimestampInSeconds);
-      expect(person._lastUpdatedAt).toEqual(createdAt);
+    await new Promise((r) => setTimeout(r, 10));
+    person.name = "Jane";
 
-      await new Promise((r) => setTimeout(r, 1000));
-      currentTimestampInSeconds = Math.floor(Date.now() / 1000);
-      person.name = "Jane";
+    expect(person._createdAt).toEqual(createdAt);
+    expect(person._lastUpdatedAt).not.toEqual(createdAt);
+  });
+});
 
-      const lastUpdatedAtInSeconds = Math.floor(person._lastUpdatedAt / 1000);
-      expect(lastUpdatedAtInSeconds).toEqual(currentTimestampInSeconds);
-      expect(person._createdAt).toEqual(createdAt);
-      expect(person._lastUpdatedAt).not.toEqual(createdAt);
+describe("co.map schema", () => {
+  test("can access the inner schemas of a co.map", () => {
+    const Person = co.map({
+      name: co.plainText(),
     });
 
-    test("comap with custom uniqueness", () => {
+    const person = Person.create({
+      name: Person.shape["name"].create("John"),
+    });
+
+    expect(person.name.toString()).toEqual("John");
+  });
+
+  describe("pick()", () => {
+    test("creates a new CoMap schema by picking fields of another CoMap schema", () => {
       const Person = co.map({
         name: z.string(),
+        age: z.number(),
       });
 
-      let currentTimestampInSeconds = Math.floor(Date.now() / 1000);
-      const person = Person.create(
-        { name: "John" },
-        { unique: "name", owner: Account.getMe() },
-      );
+      const PersonWithName = Person.pick({
+        name: true,
+      });
+
+      const person = PersonWithName.create({
+        name: "John",
+      });
 
-      const createdAt = person._createdAt;
-      const createdAtInSeconds = Math.floor(createdAt / 1000);
-      expect(createdAtInSeconds).toEqual(currentTimestampInSeconds);
+      expect(person.name).toEqual("John");
     });
 
-    test("empty comap with custom uniqueness", () => {
-      const Person = co.map({
-        name: z.optional(z.string()),
+    test("the new schema does not include catchall properties", () => {
+      const Person = co
+        .map({
+          name: z.string(),
+          age: z.number(),
+        })
+        .catchall(z.string());
+
+      const PersonWithName = Person.pick({
+        name: true,
       });
 
-      let currentTimestampInSeconds = Math.floor(Date.now() / 1000);
-      const person = Person.create(
-        {},
-        { unique: "name", owner: Account.getMe() },
-      );
+      expect(PersonWithName.catchAll).toBeUndefined();
 
-      const createdAt = person._createdAt;
-      const createdAtInSeconds = Math.floor(createdAt / 1000);
-      expect(createdAtInSeconds).toEqual(currentTimestampInSeconds);
+      const person = PersonWithName.create({
+        name: "John",
+      });
+      // @ts-expect-error - property `extraField` does not exist in person
+      expect(person.extraField).toBeUndefined();
     });
   });
-});
 
-describe("co.map schema", () => {
-  test("can access the inner schemas of a co.map", () => {
-    const Person = co.map({
-      name: co.plainText(),
-    });
+  describe("partial()", () => {
+    test("creates a new CoMap schema by making all properties optional", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        pet: Dog,
+      });
 
-    const person = Person.create({
-      name: Person.shape["name"].create("John"),
+      const DraftPerson = Person.partial();
+
+      const draftPerson = DraftPerson.create({});
+
+      expect(draftPerson.name).toBeUndefined();
+      expect(draftPerson.age).toBeUndefined();
+      expect(draftPerson.pet).toBeUndefined();
+
+      draftPerson.name = "John";
+      draftPerson.age = 20;
+      const rex = Dog.create({ name: "Rex", breed: "Labrador" });
+      draftPerson.pet = rex;
+
+      expect(draftPerson.name).toEqual("John");
+      expect(draftPerson.age).toEqual(20);
+      expect(draftPerson.pet).toEqual(rex);
     });
 
-    expect(person.name.toString()).toEqual("John");
+    test("the new schema includes catchall properties", () => {
+      const Person = co
+        .map({
+          name: z.string(),
+          age: z.number(),
+        })
+        .catchall(z.string());
+
+      const DraftPerson = Person.partial();
+
+      const draftPerson = DraftPerson.create({});
+      draftPerson.extraField = "extra";
+
+      expect(draftPerson.extraField).toEqual("extra");
+    });
   });
 });