jazz-tools 0.15.10 → 0.15.12

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

@@ -1,13 +1,19 @@
+import {
+  ZodArray,
+  ZodTuple,
+  ZodUnion,
+  core,
+  array as zodArray,
+  tuple as zodTuple,
+  union as zodUnion,
+} from "zod/v4";
 export {
   string,
   number,
   boolean,
-  union,
   object,
-  array,
   templateLiteral,
   json,
-  tuple,
   date,
   emoji,
   base64,
@@ -29,8 +35,8 @@ export {
   int32,
   strictObject,
   discriminatedUnion,
-  //   intersection,
-  //   record,
+  // record,
+  // intersection,
   int,
   optional,
   type ZodOptional,
@@ -42,3 +48,26 @@ export {
   type ZodDiscriminatedUnion,
   z,
 } from "zod/v4";
+
+type NonCoZodType = core.$ZodType & { collaborative?: false };
+
+export function union<const T extends readonly NonCoZodType[]>(
+  options: T,
+  params?: string | core.$ZodUnionParams,
+): ZodUnion<T> {
+  return zodUnion(options, params);
+}
+
+export function array<T extends NonCoZodType>(
+  element: T,
+  params?: string | core.$ZodArrayParams,
+): ZodArray<T> {
+  return zodArray(element, params);
+}
+
+export function tuple<T extends readonly [NonCoZodType, ...NonCoZodType[]]>(
+  options: T,
+  params?: string | core.$ZodTupleParams,
+): ZodTuple<T> {
+  return zodTuple(options, params);
+}

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

@@ -2,23 +2,47 @@ import { LocalNode, RawAccount } from "cojson";
 import {
   Account,
   AccountClass,
-  CoValue,
   CoValueClass,
   CoValueFromRaw,
+  InstanceOfSchema,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
   Simplify,
 } from "../../internal.js";
-import { AnyAccountSchema } from "./schemaTypes/AccountSchema.js";
-import { AnyCoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
-import { AnyCoListSchema } from "./schemaTypes/CoListSchema.js";
-import { AnyCoMapSchema, CoMapInitZod } from "./schemaTypes/CoMapSchema.js";
-import { AnyCoRecordSchema } from "./schemaTypes/CoRecordSchema.js";
-import { FileStreamSchema } from "./schemaTypes/FileStreamSchema.js";
-import { PlainTextSchema } from "./schemaTypes/PlainTextSchema.js";
-import { RichTextSchema } from "./schemaTypes/RichTextSchema.js";
-import { InstanceOfSchema } from "./typeConverters/InstanceOfSchema.js";
+import {
+  AccountSchema,
+  AnyAccountSchema,
+  BaseAccountShape,
+} from "./schemaTypes/AccountSchema.js";
+import {
+  AnyDiscriminableCoSchema,
+  CoDiscriminatedUnionSchema,
+} from "./schemaTypes/CoDiscriminatedUnionSchema.js";
+import { AnyCoFeedSchema, CoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
+import { AnyCoListSchema, CoListSchema } from "./schemaTypes/CoListSchema.js";
+import {
+  AnyCoMapSchema,
+  CoMapInitZod,
+  CoMapSchema,
+} from "./schemaTypes/CoMapSchema.js";
+import { AnyCoOptionalSchema } from "./schemaTypes/CoOptionalSchema.js";
+import {
+  AnyCoRecordSchema,
+  CoRecordSchema,
+} from "./schemaTypes/CoRecordSchema.js";
+import {
+  AnyFileStreamSchema,
+  FileStreamSchema,
+} from "./schemaTypes/FileStreamSchema.js";
+import {
+  AnyPlainTextSchema,
+  PlainTextSchema,
+} from "./schemaTypes/PlainTextSchema.js";
+import {
+  AnyRichTextSchema,
+  RichTextSchema,
+} from "./schemaTypes/RichTextSchema.js";
 import { InstanceOfSchemaCoValuesNullable } from "./typeConverters/InstanceOfSchemaCoValuesNullable.js";
 import { z } from "./zodReExport.js";
 
@@ -47,7 +71,7 @@ export type AnyCoUnionSchema = z.core.$ZodDiscriminatedUnion<
 // this is a series of hacks to work around z4 removing _zod at runtime from z.core.$ZodType
 export function isZodObject(
   schema: z.core.$ZodType,
-): schema is z.core.$ZodObject<any, any> {
+): schema is z.ZodObject<any, any> {
   return (schema as any).def?.type === "object";
 }
 
@@ -67,19 +91,53 @@ export function getDef<S extends z.core.$ZodType>(schema: S): S["_zod"]["def"] {
   return (schema as any).def;
 }
 
+// TODO rename. This represents a CoValue class or a CoValue schema
 export type CoValueOrZodSchema = CoValueClass | AnyCoSchema;
 
-export type CoValueClassFromZodSchema<S extends z.core.$ZodType> = CoValueClass<
-  InstanceOfSchema<S>
-> &
-  CoValueFromRaw<InstanceOfSchema<S>> &
-  (S extends AnyAccountSchema ? AccountClassEssentials : {});
+// TODO rename to CoValueSchemaFromCoProtoSchema
+export type CoValueSchemaFromZodSchema<S extends z.core.$ZodType> =
+  S extends z.core.$ZodType
+    ? S extends AnyAccountSchema<infer Shape extends BaseAccountShape>
+      ? AccountSchema<Shape>
+      : S extends AnyCoRecordSchema<infer K, infer V>
+        ? CoRecordSchema<K, V>
+        : S extends AnyCoMapSchema<infer Shape, infer Config>
+          ? CoMapSchema<Shape, Config>
+          : S extends AnyCoListSchema<infer T>
+            ? CoListSchema<T>
+            : S extends AnyCoFeedSchema<infer T>
+              ? CoFeedSchema<T>
+              : S extends AnyPlainTextSchema
+                ? PlainTextSchema
+                : S extends AnyRichTextSchema
+                  ? RichTextSchema
+                  : S extends AnyFileStreamSchema
+                    ? FileStreamSchema
+                    : S extends z.core.$ZodOptional<infer Inner>
+                      ? CoValueSchemaFromZodSchema<Inner>
+                      : S extends z.core.$ZodUnion<
+                            infer Members extends readonly [
+                              AnyDiscriminableCoSchema,
+                              ...AnyDiscriminableCoSchema[],
+                            ]
+                          >
+                        ? CoDiscriminatedUnionSchema<Members>
+                        : never
+    : never;
+
+export type CoValueClassFromAnySchema<S extends CoValueOrZodSchema> =
+  S extends CoValueClass<any>
+    ? S
+    : CoValueClass<InstanceOfSchema<S>> &
+        CoValueFromRaw<InstanceOfSchema<S>> &
+        (S extends AnyAccountSchema ? AccountClassEssentials : {});
 
 type AccountClassEssentials = {
   fromRaw: <A extends Account>(this: AccountClass<A>, raw: RawAccount) => A;
   fromNode: <A extends Account>(this: AccountClass<A>, node: LocalNode) => A;
 };
 
+// TODO rename to ProtoCoSchema?
 export type AnyCoSchema =
   | AnyCoMapSchema
   | AnyAccountSchema
@@ -87,9 +145,10 @@ export type AnyCoSchema =
   | AnyCoListSchema
   | AnyCoFeedSchema
   | AnyCoUnionSchema
-  | PlainTextSchema
-  | RichTextSchema
-  | FileStreamSchema;
+  | AnyCoOptionalSchema
+  | AnyPlainTextSchema
+  | AnyRichTextSchema
+  | AnyFileStreamSchema;
 
 export type Loaded<
   T extends CoValueClass | AnyCoSchema,

package/src/tools/internal.ts

@@ -33,6 +33,7 @@ export * from "./implementation/zodSchema/zodSchema.js";
 export * from "./implementation/zodSchema/zodCo.js";
 export * as co from "./implementation/zodSchema/coExport.js";
 export * from "./implementation/zodSchema/schemaTypes/CoMapSchema.js";
+export * from "./implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoRecordSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoListSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoFeedSchema.js";

package/src/tools/subscribe/CoValueCoreSubscription.ts

@@ -28,6 +28,10 @@ export class CoValueCoreSubscription {
             this.subscribeToState();
             this.listener("unavailable");
           }
+        })
+        .catch((error) => {
+          console.error("Unexpected error loading CoValue: ", error);
+          this.listener("unavailable");
         });
     }
   }

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

@@ -1,16 +1,15 @@
+import { StorageAPI } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import {
   Account,
   AccountClass,
   AuthSecretStorage,
-  CoMap,
   Group,
   InMemoryKVStore,
   JazzAuthContext,
   KvStoreContext,
   co,
-  coField,
   z,
 } from "../exports";
 import {
@@ -26,6 +25,7 @@ import {
   CoValueFromRaw,
   InstanceOfSchema,
   Loaded,
+  anySchemaToCoSchema,
   zodSchemaToCoSchema,
 } from "../internal";
 import {
@@ -33,6 +33,7 @@ import {
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing";
+import { createAsyncStorage, getDbPath } from "./testStorage";
 
 const Crypto = await WasmCrypto.create();
 
@@ -41,12 +42,14 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
   JazzContextManagerBaseProps<Acc> & {
     defaultProfileName?: string;
     AccountSchema?: AccountClass<Acc>;
+    storage?: string;
   }
 > {
   async getNewContext(
     props: JazzContextManagerBaseProps<Acc> & {
       defaultProfileName?: string;
       AccountSchema?: AccountClass<Acc> & CoValueFromRaw<Acc>;
+      storage?: string;
     },
     authProps?: JazzContextManagerAuthProps,
   ) {
@@ -59,6 +62,7 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
       sessionProvider: randomSessionProvider,
       authSecretStorage: this.getAuthSecretStorage(),
       AccountSchema: props.AccountSchema,
+      storage: await createAsyncStorage({ filename: props.storage }),
     });
 
     return {
@@ -77,12 +81,14 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
 describe("ContextManager", () => {
   let manager: TestJazzContextManager<Account>;
   let authSecretStorage: AuthSecretStorage;
+  let storage: StorageAPI;
 
   function getCurrentValue() {
     return manager.getCurrentValue() as JazzAuthContext<Account>;
   }
 
   beforeEach(async () => {
+    storage = await createAsyncStorage({});
     KvStoreContext.getInstance().initialize(new InMemoryKVStore());
     authSecretStorage = new AuthSecretStorage();
     await authSecretStorage.clear();
@@ -233,6 +239,78 @@ describe("ContextManager", () => {
     expect(onAnonymousAccountDiscarded).not.toHaveBeenCalled();
   });
 
+  test("onAnonymousAccountDiscarded should not block the authentication when storage is active", async () => {
+    const dbFilename = getDbPath();
+
+    const AccountRoot = co.map({
+      value: z.string(),
+      get transferredRoot(): z.ZodOptional<typeof AccountRoot> {
+        return co.optional(AccountRoot);
+      },
+    });
+
+    let lastRootId: string | undefined;
+
+    const CustomAccount = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration(async (account) => {
+        account.root = AccountRoot.create(
+          {
+            value: "Hello",
+          },
+          Group.create(this).makePublic(),
+        );
+      });
+
+    const customManager = new TestJazzContextManager<
+      InstanceOfSchema<typeof CustomAccount>
+    >();
+
+    await customManager.createContext({
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
+      storage: dbFilename,
+      onAnonymousAccountDiscarded: async (anonymousAccount) => {
+        const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
+          resolve: { root: true },
+        });
+
+        const me = await CustomAccount.getMe().ensureLoaded({
+          resolve: { root: true },
+        });
+
+        me.root.transferredRoot = anonymousAccountWithRoot.root;
+      },
+    });
+
+    const prevContextNode = customManager.getCurrentValue()!.node;
+
+    expect(prevContextNode.storage).toBeDefined();
+
+    const account = (
+      customManager.getCurrentValue() as JazzAuthContext<
+        InstanceOfSchema<typeof CustomAccount>
+      >
+    ).me;
+
+    await customManager.authenticate({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      provider: "test",
+    });
+
+    // The storage should be closed and set to undefined
+    expect(prevContextNode.storage).toBeUndefined();
+
+    const me = await CustomAccount.getMe().ensureLoaded({
+      resolve: { root: { transferredRoot: true } },
+    });
+
+    expect(me.root.transferredRoot?.value).toBe("Hello");
+  });
+
   test("the migration should be applied correctly on existing accounts", async () => {
     const AccountRoot = co.map({
       value: z.string(),
@@ -258,7 +336,7 @@ describe("ContextManager", () => {
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
     });
 
     const account = (
@@ -267,8 +345,6 @@ describe("ContextManager", () => {
       >
     ).me;
 
-    console.log("before", account._refs.root?.id);
-
     await customManager.authenticate({
       accountID: account.id,
       accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
@@ -279,8 +355,6 @@ describe("ContextManager", () => {
       resolve: { root: true },
     });
 
-    console.log("after", me._refs.root?.id);
-
     expect(me.root.id).toBe(lastRootId);
   });
 
@@ -313,7 +387,7 @@ describe("ContextManager", () => {
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
     });
 
     const account = (
@@ -339,7 +413,7 @@ describe("ContextManager", () => {
     const AccountRoot = co.map({
       value: z.string(),
       get transferredRoot(): z.ZodOptional<typeof AccountRoot> {
-        return z.optional(AccountRoot);
+        return co.optional(AccountRoot);
       },
     });
 
@@ -385,7 +459,7 @@ describe("ContextManager", () => {
     // Create initial anonymous context
     await customManager.createContext({
       onAnonymousAccountDiscarded,
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
     });
 
     const account = await createJazzTestAccount({

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

@@ -0,0 +1,57 @@
+import { beforeEach, describe, test } from "vitest";
+import { Loaded, co, z } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+
+describe("co.discriminatedUnion", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  test("can use co.discriminatedUnion with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Person = co.map({
+      pet: co.discriminatedUnion("type", [Dog, Cat]),
+    });
+
+    const person = Person.create({
+      pet: Dog.create({
+        type: "dog",
+      }),
+    });
+
+    person.pet = Cat.create({
+      type: "cat",
+    });
+
+    type ExpectedType = {
+      pet: Loaded<typeof Dog> | Loaded<typeof Cat>;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(person);
+  });
+
+  test("cannot use co.discriminatedUnion with zod schemas as values", () => {
+    const Person = co.map({
+      pet: co.discriminatedUnion("type", [
+        // @ts-expect-error: cannot use co.discriminatedUnion with a Zod schema
+        z.object({
+          type: z.string(),
+        }),
+      ]),
+    });
+  });
+});

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

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { Loaded, co, z } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { waitFor } from "./utils.js";
+
+describe("co.discriminatedUnion", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  test("use co.discriminatedUnion with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Person = co.map({
+      pet: co.discriminatedUnion("type", [Dog, Cat]),
+    });
+
+    const person = Person.create({
+      pet: Dog.create({
+        type: "dog",
+      }),
+    });
+
+    expect(person.pet.type).toEqual("dog");
+
+    person.pet = Cat.create({
+      type: "cat",
+    });
+
+    expect(person.pet.type).toEqual("cat");
+  });
+
+  test("load CoValue instances using the DiscriminatedUnion schema", async () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({ type: "dog" });
+    const loadedPet = await Pet.load(dog.id);
+    expect(loadedPet?.type).toEqual("dog");
+  });
+
+  test("subscribe to CoValue instances using the DiscriminatedUnion schema", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      name: z.string(),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      name: z.string(),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({
+      type: "dog",
+      name: "Rex",
+      owner: Person.create({ name: "John Doe" }),
+    });
+
+    const updates: Loaded<typeof Pet>[] = [];
+    const spy = vi.fn((pet) => updates.push(pet));
+
+    Pet.subscribe(dog.id, {}, (pet) => {
+      expect(pet.type).toEqual("dog");
+      spy(pet);
+    });
+
+    expect(spy).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(spy).toHaveBeenCalled());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    expect(updates[0]?.name).toEqual("Rex");
+  });
+});

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

@@ -1,15 +1,7 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import {
-  Account,
-  CoList,
-  CoMap,
-  Group,
-  coField,
-  subscribeToCoValue,
-  z,
-} from "../index.js";
-import { Loaded, co, zodSchemaToCoSchema } from "../internal.js";
+import { Account, Group, subscribeToCoValue, z } from "../index.js";
+import { Loaded, anySchemaToCoSchema, co } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -127,7 +119,7 @@ describe("Simple CoList operations", async () => {
         name: z.string(),
       });
 
-      const Recipe = co.list(z.optional(Ingredient));
+      const Recipe = co.list(co.optional(Ingredient));
 
       const recipe = Recipe.create(
         [
@@ -588,7 +580,7 @@ describe("CoList subscription", async () => {
     const spy = vi.fn((list) => updates.push(list));
 
     subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         syncResolution: true,

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

@@ -281,7 +281,7 @@ describe("CoMap.Record", async () => {
     });
 
     test("Is ok to omit optional fields", () => {
-      const TestRecord = co.record(z.string(), z.optional(NestedRecord));
+      const TestRecord = co.record(z.string(), co.optional(NestedRecord));
 
       expectTypeOf<typeof TestRecord.create>().toBeCallableWith(
         {
@@ -315,7 +315,7 @@ describe("CoMap.Record", async () => {
 
     const PersonRecord = co.record(
       z.string(),
-      z.discriminatedUnion("type", [Base, IssueRepro]),
+      co.discriminatedUnion("type", [Base, IssueRepro]),
     );
 
     const person = IssueRepro.create({
@@ -350,7 +350,7 @@ describe("CoMap.Record", async () => {
 
     const PersonRecord = co.record(
       z.string(),
-      z.discriminatedUnion("type", [Base, IssueRepro]),
+      co.discriminatedUnion("type", [Base, IssueRepro]),
     );
 
     const person = IssueRepro.create({
@@ -385,7 +385,7 @@ describe("CoMap.Record", async () => {
 
     const PersonRecord = co.record(
       z.string(),
-      z.discriminatedUnion("type", [Base, IssueRepro]),
+      co.discriminatedUnion("type", [Base, IssueRepro]),
     );
 
     const person = IssueRepro.create({

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

@@ -159,7 +159,7 @@ describe("CoMap", async () => {
     test("Comap with recursive optional reference", () => {
       const Recursive = co.map({
         get child(): z.ZodOptional<typeof Recursive> {
-          return z.optional(Recursive);
+          return co.optional(Recursive);
         },
       });
 
@@ -185,7 +185,7 @@ describe("CoMap", async () => {
         age: z.number(),
         // TODO: would be nice if this didn't need a type annotation
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -280,7 +280,7 @@ describe("CoMap", async () => {
 
     const MapWithEnumOfMaps = co.map({
       name: z.string(),
-      child: z.discriminatedUnion("type", [ChildA, ChildB]),
+      child: co.discriminatedUnion("type", [ChildA, ChildB]),
     });
 
     const mapWithEnum = MapWithEnumOfMaps.create({