jazz-tools 0.14.5 → 0.14.7

package/src/implementation/zodSchema/schemaTypes/CoFeedSchema.ts

@@ -13,6 +13,12 @@ import { InstanceOfSchema } from "../typeConverters/InstanceOfSchema.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 
+type CoFeedInit<T extends z.core.$ZodType> = Array<
+  T extends z.core.$ZodOptional<any>
+    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
+    : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>
+>;
+
 export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
   CoFeed<InstanceOfSchema<T>>,
   unknown
@@ -22,7 +28,7 @@ export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
   element: T;
 
   create(
-    init: InstanceOrPrimitiveOfSchema<T>[],
+    init: CoFeedInit<T>,
     options?: { owner: Account | Group } | Account | Group,
   ): CoFeedInstance<T>;
 

package/src/implementation/zodSchema/schemaTypes/CoListSchema.ts

@@ -13,11 +13,17 @@ import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimiti
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { WithHelpers } from "../zodSchema.js";
 
+type CoListInit<T extends z.core.$ZodType> = Array<
+  T extends z.core.$ZodOptional<any>
+    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
+    : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>
+>;
+
 export type CoListSchema<T extends z.core.$ZodType> = z.core.$ZodArray<T> & {
   collaborative: true;
 
   create: (
-    items: InstanceOrPrimitiveOfSchema<T>[],
+    items: CoListInit<T>,
     options?: { owner: Account | Group } | Account | Group,
   ) => CoList<InstanceOrPrimitiveOfSchema<T>>;
 

package/src/implementation/zodSchema/schemaTypes/CoRecordSchema.ts

@@ -16,6 +16,15 @@ import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimiti
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { WithHelpers } from "../zodSchema.js";
 
+type CoRecordInit<
+  K extends z.core.$ZodString<string>,
+  V extends z.core.$ZodType,
+> = {
+  [key in z.output<K>]: V extends z.core.$ZodOptional<any>
+    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<V>
+    : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<V>>;
+};
+
 export type CoRecordSchema<
   K extends z.core.$ZodString<string>,
   V extends z.core.$ZodType,
@@ -23,9 +32,7 @@ export type CoRecordSchema<
   collaborative: true;
 
   create: (
-    init: Simplify<{
-      [key in z.output<K>]?: InstanceOrPrimitiveOfSchema<V>;
-    }>,
+    init: Simplify<CoRecordInit<K, V>>,
     options?:
       | {
           owner: Account | Group;

package/src/implementation/zodSchema/schemaTypes/FileStreamSchema.ts

@@ -1,9 +1,43 @@
 import z from "zod/v4";
-import { FileStream } from "../../../internal.js";
+import {
+  Account,
+  AnonymousJazzAgent,
+  FileStream,
+  Group,
+} from "../../../internal.js";
 
 export type FileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
   collaborative: true;
   builtin: "FileStream";
-  create: (typeof FileStream)["create"];
-  createFromBlob: (typeof FileStream)["createFromBlob"];
+  create(options?: { owner?: Account | Group } | Account | Group): FileStream;
+  createFromBlob(
+    blob: Blob | File,
+    options?:
+      | {
+          owner?: Group | Account;
+          onProgress?: (progress: number) => void;
+        }
+      | Account
+      | Group,
+  ): Promise<FileStream>;
+  loadAsBlob(
+    id: string,
+    options?: {
+      allowUnfinished?: boolean;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
+  ): Promise<Blob | undefined>;
+  load(
+    id: string,
+    options: { loadAs: Account | AnonymousJazzAgent },
+  ): Promise<FileStream>;
+  subscribe(
+    id: string,
+    options: { loadAs: Account | AnonymousJazzAgent },
+    listener: (value: FileStream, unsubscribe: () => void) => void,
+  ): () => void;
+  subscribe(
+    id: string,
+    listener: (value: FileStream, unsubscribe: () => void) => void,
+  ): () => void;
 };

package/src/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchema.ts

@@ -1,3 +1,4 @@
+import { JsonValue } from "cojson";
 import z from "zod/v4";
 import {
   Account,
@@ -57,36 +58,48 @@ export type InstanceOrPrimitiveOfSchema<
                   ? FileStream
                   : S extends z.core.$ZodOptional<infer Inner>
                     ? InstanceOrPrimitiveOfSchema<Inner> | undefined
-                    : S extends z.core.$ZodUnion<infer Members>
-                      ? InstanceOrPrimitiveOfSchema<Members[number]>
-                      : // primitives below here - we manually traverse to ensure we only allow what we can handle
-                        S extends z.core.$ZodObject<infer Shape>
-                        ? {
-                            -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                              Shape[key]
-                            >;
-                          }
-                        : S extends z.core.$ZodArray<infer Item>
-                          ? InstanceOrPrimitiveOfSchema<Item>[]
-                          : S extends z.core.$ZodTuple<infer Items>
-                            ? {
-                                [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                                  Items[key]
-                                >;
-                              }
-                            : S extends z.core.$ZodString
-                              ? string
-                              : S extends z.core.$ZodNumber
-                                ? number
-                                : S extends z.core.$ZodBoolean
-                                  ? boolean
-                                  : S extends z.core.$ZodLiteral<infer Literal>
-                                    ? Literal
-                                    : S extends z.core.$ZodDate
-                                      ? Date
-                                      : S extends z.core.$ZodEnum<infer Enum>
-                                        ? Enum[keyof Enum]
-                                        : never
+                    : S extends z.ZodJSONSchema
+                      ? JsonValue
+                      : S extends z.core.$ZodUnion<infer Members>
+                        ? InstanceOrPrimitiveOfSchema<Members[number]>
+                        : // primitives below here - we manually traverse to ensure we only allow what we can handle
+                          S extends z.core.$ZodObject<infer Shape>
+                          ? {
+                              -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                                Shape[key]
+                              >;
+                            }
+                          : S extends z.core.$ZodArray<infer Item>
+                            ? InstanceOrPrimitiveOfSchema<Item>[]
+                            : S extends z.core.$ZodTuple<infer Items>
+                              ? {
+                                  [key in keyof Items]: InstanceOrPrimitiveOfSchema<
+                                    Items[key]
+                                  >;
+                                }
+                              : S extends z.core.$ZodString
+                                ? string
+                                : S extends z.core.$ZodNumber
+                                  ? number
+                                  : S extends z.core.$ZodBoolean
+                                    ? boolean
+                                    : S extends z.core.$ZodLiteral<
+                                          infer Literal
+                                        >
+                                      ? Literal
+                                      : S extends z.core.$ZodDate
+                                        ? Date
+                                        : S extends z.core.$ZodEnum<infer Enum>
+                                          ? Enum[keyof Enum]
+                                          : S extends z.core.$ZodTemplateLiteral<
+                                                infer pattern
+                                              >
+                                            ? pattern
+                                            : S extends z.core.$ZodReadonly<
+                                                  infer Inner
+                                                >
+                                              ? InstanceOrPrimitiveOfSchema<Inner>
+                                              : never
   : S extends CoValueClass
     ? InstanceType<S>
     : never;

package/src/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.ts

@@ -1,3 +1,4 @@
+import { JsonValue } from "cojson";
 import z from "zod/v4";
 import {
   Account,
@@ -68,38 +69,50 @@ export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
                     ?
                         | InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner>
                         | undefined
-                    : S extends z.core.$ZodUnion<infer Members>
-                      ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
-                          Members[number]
-                        >
-                      : // primitives below here - we manually traverse to ensure we only allow what we can handle
-                        S extends z.core.$ZodObject<infer Shape>
-                        ? {
-                            -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                              Shape[key]
-                            >;
-                          }
-                        : S extends z.core.$ZodArray<infer Item>
-                          ? InstanceOrPrimitiveOfSchema<Item>[]
-                          : S extends z.core.$ZodTuple<infer Items>
-                            ? {
-                                [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                                  Items[key]
-                                >;
-                              }
-                            : S extends z.core.$ZodString
-                              ? string
-                              : S extends z.core.$ZodNumber
-                                ? number
-                                : S extends z.core.$ZodBoolean
-                                  ? boolean
-                                  : S extends z.core.$ZodLiteral<infer Literal>
-                                    ? Literal
-                                    : S extends z.core.$ZodDate
-                                      ? Date
-                                      : S extends z.core.$ZodEnum<infer Enum>
-                                        ? Enum[keyof Enum]
-                                        : never
+                    : S extends z.ZodJSONSchema
+                      ? JsonValue
+                      : S extends z.core.$ZodUnion<infer Members>
+                        ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
+                            Members[number]
+                          >
+                        : // primitives below here - we manually traverse to ensure we only allow what we can handle
+                          S extends z.core.$ZodObject<infer Shape>
+                          ? {
+                              -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                                Shape[key]
+                              >;
+                            }
+                          : S extends z.core.$ZodArray<infer Item>
+                            ? InstanceOrPrimitiveOfSchema<Item>[]
+                            : S extends z.core.$ZodTuple<infer Items>
+                              ? {
+                                  [key in keyof Items]: InstanceOrPrimitiveOfSchema<
+                                    Items[key]
+                                  >;
+                                }
+                              : S extends z.core.$ZodString
+                                ? string
+                                : S extends z.core.$ZodNumber
+                                  ? number
+                                  : S extends z.core.$ZodBoolean
+                                    ? boolean
+                                    : S extends z.core.$ZodLiteral<
+                                          infer Literal
+                                        >
+                                      ? Literal
+                                      : S extends z.core.$ZodDate
+                                        ? Date
+                                        : S extends z.core.$ZodEnum<infer Enum>
+                                          ? Enum[keyof Enum]
+                                          : S extends z.core.$ZodTemplateLiteral<
+                                                infer pattern
+                                              >
+                                            ? pattern
+                                            : S extends z.core.$ZodReadonly<
+                                                  infer Inner
+                                                >
+                                              ? InstanceOrPrimitiveOfSchema<Inner>
+                                              : never
   : S extends CoValueClass
     ? InstanceType<S> | null
     : never;

package/src/implementation/zodSchema/zodCo.ts

@@ -306,8 +306,11 @@ export const coFileStreamDefiner = (): FileStreamSchema => {
   > & {
     collaborative: true;
     builtin: "FileStream";
-    create: (typeof FileStream)["create"];
-    createFromBlob: (typeof FileStream)["createFromBlob"];
+    create: FileStreamSchema["create"];
+    createFromBlob: FileStreamSchema["createFromBlob"];
+    load: FileStreamSchema["load"];
+    loadAsBlob: FileStreamSchema["loadAsBlob"];
+    subscribe: FileStreamSchema["subscribe"];
   };
 
   fileStreamSchema.collaborative = true;
@@ -315,11 +318,27 @@ export const coFileStreamDefiner = (): FileStreamSchema => {
 
   fileStreamSchema.create = function (options: any) {
     return FileStream.create(options);
-  } as (typeof FileStream)["create"];
+  } as FileStreamSchema["create"];
 
   fileStreamSchema.createFromBlob = function (blob: Blob, options: any) {
     return FileStream.createFromBlob(blob, options);
-  } as (typeof FileStream)["createFromBlob"];
+  } as FileStreamSchema["createFromBlob"];
+
+  fileStreamSchema.load = function (id: string, options: any) {
+    return FileStream.load(id, options);
+  } as FileStreamSchema["load"];
+
+  fileStreamSchema.loadAsBlob = function (id: string, options: any) {
+    return FileStream.loadAsBlob(id, options);
+  } as FileStreamSchema["loadAsBlob"];
+
+  fileStreamSchema.subscribe = function (
+    id: string,
+    options: any,
+    listener: any,
+  ) {
+    return FileStream.subscribe(id, options, listener);
+  } as FileStreamSchema["subscribe"];
 
   return fileStreamSchema;
 };

package/src/implementation/zodSchema/zodReExport.ts

@@ -0,0 +1,37 @@
+export {
+  string,
+  number,
+  boolean,
+  union,
+  object,
+  array,
+  templateLiteral,
+  json,
+  tuple,
+  date,
+  emoji,
+  base64,
+  base64url,
+  nanoid,
+  cuid,
+  cuid2,
+  ulid,
+  ipv4,
+  ipv6,
+  email,
+  url,
+  uuid,
+  literal,
+  enum,
+  cidrv4,
+  cidrv6,
+  iso,
+  int32,
+  strictObject,
+  discriminatedUnion,
+  //   intersection,
+  //   record,
+  int,
+  optional,
+  type ZodOptional,
+} from "zod/v4";

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

@@ -0,0 +1,256 @@
+import { assert, describe, expectTypeOf, test } from "vitest";
+import { Group, co, z } from "../exports.js";
+import { Account } from "../index.js";
+import { CoFeed, FileStream, Loaded } from "../internal.js";
+
+describe("CoFeed", () => {
+  describe("init", () => {
+    test("create a CoFeed with basic property access", () => {
+      const StringFeed = co.feed(z.string());
+
+      const feed = StringFeed.create(["milk"]);
+
+      type ExpectedType = string;
+
+      function matches(value: ExpectedType | undefined) {
+        return value;
+      }
+
+      matches(feed.perAccount[Account.getMe().id]!.value);
+    });
+
+    test("has the _owner property", () => {
+      const StringFeed = co.feed(z.string());
+
+      const feed = StringFeed.create(["milk"], Account.getMe());
+
+      expectTypeOf(feed._owner).toEqualTypeOf<Account | Group>();
+    });
+
+    test("CoFeed with reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogFeed = co.feed(Dog);
+
+      const feed = DogFeed.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+      ]);
+
+      type ExpectedType = Loaded<typeof Dog> | undefined | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(feed.perAccount[Account.getMe().id]!.value);
+    });
+
+    test("CoFeed with optional reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogFeed = co.feed(Dog.optional());
+
+      const feed = DogFeed.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+      ]);
+
+      type ExpectedType = Loaded<typeof Dog> | undefined | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(feed.perAccount[Account.getMe().id]?.value);
+    });
+
+    test("CoFeed create with partially loaded, reference and optional", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+      });
+      type Dog = co.loaded<typeof Dog>;
+
+      const DogFeed = co.feed(Dog.optional());
+
+      const dog = Dog.create({
+        name: "Rex",
+        breed: Dog.def.shape.breed.create({
+          type: "labrador",
+          value: "Labrador",
+        }),
+      }) as Dog;
+
+      const feed = DogFeed.create([dog, undefined]);
+
+      type ExpectedType = Loaded<typeof Dog> | undefined | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(feed.perAccount[Account.getMe().id]!.value);
+    });
+
+    test("CoFeed with nested feeds", () => {
+      const NestedFeed = co.feed(co.feed(z.string()));
+
+      const feed = NestedFeed.create([co.feed(z.string()).create(["milk"])]);
+
+      type ExpectedType = CoFeed<string> | undefined | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(feed.perAccount[Account.getMe().id]?.value);
+    });
+
+    test("CoFeed with enum type", () => {
+      const EnumFeed = co.feed(z.enum(["a", "b", "c"]));
+
+      const feed = EnumFeed.create(["a"]);
+
+      type ExpectedType = "a" | "b" | "c" | undefined | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(feed.perAccount[Account.getMe().id]?.value);
+    });
+  });
+
+  describe("CoFeed resolution", () => {
+    test("loading a feed with deep resolve", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogFeed = co.feed(Dog);
+
+      const feed = DogFeed.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+      ]);
+
+      const loadedFeed = await DogFeed.load(feed.id, {
+        resolve: true,
+      });
+
+      type ExpectedType = Loaded<typeof Dog> | null | undefined;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(loadedFeed?.perAccount[Account.getMe().id]?.value);
+
+      assert(loadedFeed);
+      const dog = loadedFeed.perAccount[Account.getMe().id]?.value;
+      assert(dog);
+      expectTypeOf(dog.name).toEqualTypeOf<string>();
+    });
+
+    test("loading a feed with $onError", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogFeed = co.feed(Dog);
+
+      const feed = DogFeed.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+      ]);
+
+      const loadedFeed = await DogFeed.load(feed.id, {
+        resolve: { $each: { $onError: null } },
+      });
+
+      type ExpectedType = Loaded<typeof Dog> | null | undefined;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(loadedFeed?.perAccount[Account.getMe().id]?.value);
+    });
+
+    test("loading a nested feed with deep resolve", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogFeed = co.feed(Dog);
+      const NestedFeed = co.feed(DogFeed);
+
+      const feed = NestedFeed.create([
+        DogFeed.create([Dog.create({ name: "Rex", breed: "Labrador" })]),
+      ]);
+
+      const loadedFeed = await NestedFeed.load(feed.id, {
+        resolve: {
+          $each: true,
+        },
+      });
+
+      type ExpectedType = Loaded<typeof Dog> | null | undefined;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      const nestedFeed = loadedFeed?.perAccount[Account.getMe().id]?.value;
+      assert(nestedFeed);
+      matches(nestedFeed.perAccount[Account.getMe().id]?.value);
+
+      assert(loadedFeed);
+      const dog = nestedFeed.perAccount[Account.getMe().id]?.value;
+      assert(dog);
+      expectTypeOf(dog.name).toEqualTypeOf<string>();
+    });
+  });
+});
+
+describe("co.fileStream", () => {
+  test("create function type", () => {
+    const FileStreamFeed = co.fileStream();
+
+    const feed = FileStreamFeed.create({ owner: Account.getMe() });
+
+    type ExpectedType = FileStream;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(feed);
+  });
+
+  test("createFromBlob function type", async () => {
+    const FileStreamFeed = co.fileStream();
+    const blob = new Blob(["test"], { type: "text/plain" });
+
+    const feed = await FileStreamFeed.createFromBlob(blob, {
+      owner: Account.getMe(),
+      onProgress: (progress: number) => {
+        console.log(`Progress: ${progress}`);
+      },
+    });
+
+    type ExpectedType = FileStream;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(feed);
+  });
+});