jazz-tools 0.15.15 → 0.16.0

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

@@ -1,7 +1,7 @@
 import { assert, describe, expectTypeOf, test } from "vitest";
 import { Group, co, z } from "../exports.js";
 import { Account } from "../index.js";
-import { CoListSchema, Loaded } from "../internal.js";
+import { Loaded } from "../internal.js";
 
 describe("CoMap", async () => {
   describe("init", () => {
@@ -117,9 +117,10 @@ describe("CoMap", async () => {
     });
 
     test("CoMap 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>;
 
@@ -131,7 +132,7 @@ describe("CoMap", async () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
@@ -158,8 +159,8 @@ describe("CoMap", async () => {
 
     test("Comap with recursive optional reference", () => {
       const Recursive = co.map({
-        get child(): z.ZodOptional<typeof Recursive> {
-          return co.optional(Recursive);
+        get child() {
+          return Recursive.optional();
         },
       });
 
@@ -183,8 +184,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         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() {
           return co.optional(Person);
         },
       });
@@ -243,7 +243,7 @@ describe("CoMap", async () => {
     test("update a reference on a loaded value", () => {
       const Dog = co.map({
         name: z.string(),
-        get siblings(): CoListSchema<typeof Dog> {
+        get siblings() {
           return co.list(Dog);
         },
       });

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(
       [