jazz-tools 0.14.4 → 0.14.6

package/src/implementation/zodSchema/zodCo.ts

@@ -89,7 +89,7 @@ export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
   return coMapSchema as unknown as CoMapSchema<Shape>;
 };
 
-const coAccountDefiner = <
+export const coAccountDefiner = <
   Shape extends {
     profile: AnyCoMapSchema<{
       name: z.core.$ZodString<string>;
@@ -100,12 +100,12 @@ const coAccountDefiner = <
   },
 >(
   shape: Shape = {
-    profile: co.map({
+    profile: coMapDefiner({
       name: z.string(),
       inbox: z.optional(z.string()),
       inboxInvite: z.optional(z.string()),
     }),
-    root: co.map({}),
+    root: coMapDefiner({}),
   } as unknown as Shape,
 ): AccountSchema<Shape> => {
   const objectSchema = z.object(shape).meta({
@@ -183,7 +183,7 @@ const coAccountDefiner = <
   return accountSchema as unknown as AccountSchema<Shape>;
 };
 
-const coRecordDefiner = <
+export const coRecordDefiner = <
   K extends z.core.$ZodString<string>,
   V extends z.core.$ZodType,
 >(
@@ -196,7 +196,7 @@ const coRecordDefiner = <
   >;
 };
 
-const coListDefiner = <T extends z.core.$ZodType>(
+export const coListDefiner = <T extends z.core.$ZodType>(
   element: T,
 ): CoListSchema<T> => {
   const arraySchema = z.array(element).meta({
@@ -237,7 +237,7 @@ const coListDefiner = <T extends z.core.$ZodType>(
   return coListSchema;
 };
 
-const coProfileDefiner = <
+export const coProfileDefiner = <
   Shape extends z.core.$ZodLooseShape = Simplify<DefaultProfileShape>,
 >(
   shape: Shape & {
@@ -261,7 +261,7 @@ const coProfileDefiner = <
   } as CoProfileSchema<Shape>;
 };
 
-const coFeedDefiner = <T extends z.core.$ZodType>(
+export const coFeedDefiner = <T extends z.core.$ZodType>(
   element: T,
 ): CoFeedSchema<T> => {
   const placeholderSchema = z.instanceof(CoFeed);
@@ -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;
 };
@@ -393,17 +412,6 @@ export const coRichTextDefiner = (): RichTextSchema => {
   return richTextSchema;
 };
 
-export const co = {
-  map: coMapDefiner,
-  record: coRecordDefiner,
-  list: coListDefiner,
-  feed: coFeedDefiner,
-  plainText: coPlainTextDefiner,
-  richText: coRichTextDefiner,
-  fileStream: coFileStreamDefiner,
-  image: (): typeof ImageDefinition => {
-    return ImageDefinition;
-  },
-  account: coAccountDefiner,
-  profile: coProfileDefiner,
+export const coImageDefiner = (): typeof ImageDefinition => {
+  return ImageDefinition;
 };

package/src/implementation/zodSchema/zodSchema.ts

@@ -31,11 +31,6 @@ export type WithHelpers<
   Helpers extends object,
 > = Base & Helpers;
 
-export type FullyOrPartiallyLoaded<S extends z.core.$ZodType | CoValueClass> =
-  InstanceOrPrimitiveOfSchema<S> extends CoValue
-    ? NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<S>>
-    : InstanceOrPrimitiveOfSchema<S>;
-
 export type ZodPrimitiveSchema =
   | z.core.$ZodString
   | z.core.$ZodNumber

package/src/internal.ts

@@ -31,6 +31,7 @@ export * from "./implementation/createContext.js";
 export * from "./types.js";
 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/CoRecordSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoListSchema.js";

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);
+  });
+});

package/src/tests/coFeed.test.ts

@@ -2,18 +2,14 @@ import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, expectTypeOf, test } from "vitest";
 import {
   Account,
-  CoFeed,
   FileStream,
   Group,
-  ID,
   co,
-  coField,
   cojsonInternals,
   isControlledAccount,
   z,
 } from "../index.js";
 import {
-  AnyCoFeedSchema,
   Loaded,
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
@@ -350,23 +346,50 @@ describe("Simple FileStream operations", async () => {
 
   const stream = FileStream.create({ owner: me });
 
-  test("Construction", () => {
-    expect(stream.getChunks()).toBe(undefined);
+  describe("FileStream", () => {
+    test("Construction", () => {
+      expect(stream.getChunks()).toBe(undefined);
+    });
+
+    test("Mutation", () => {
+      stream.start({ mimeType: "text/plain" });
+      stream.push(new Uint8Array([1, 2, 3]));
+      stream.push(new Uint8Array([4, 5, 6]));
+      stream.end();
+
+      const chunks = stream.getChunks();
+      expect(chunks?.mimeType).toBe("text/plain");
+      expect(chunks?.chunks).toEqual([
+        new Uint8Array([1, 2, 3]),
+        new Uint8Array([4, 5, 6]),
+      ]);
+      expect(chunks?.finished).toBe(true);
+    });
   });
 
-  test("Mutation", () => {
-    stream.start({ mimeType: "text/plain" });
-    stream.push(new Uint8Array([1, 2, 3]));
-    stream.push(new Uint8Array([4, 5, 6]));
-    stream.end();
+  describe("co.fileStream", () => {
+    const fs = co.fileStream().create({ owner: me });
 
-    const chunks = stream.getChunks();
-    expect(chunks?.mimeType).toBe("text/plain");
-    expect(chunks?.chunks).toEqual([
-      new Uint8Array([1, 2, 3]),
-      new Uint8Array([4, 5, 6]),
-    ]);
-    expect(chunks?.finished).toBe(true);
+    test("Construction", () => {
+      expect(fs.getChunks()).toBe(undefined);
+    });
+
+    test("Type compatibility", () => {
+      // Check base functionality works
+      expectTypeOf(co.fileStream()).toHaveProperty("create");
+
+      // We can acknowledge the type error exists
+      // This is a runtime test that verifies that despite the TypeScript error,
+      // the functionality still works as expected
+      expect(typeof fs.getChunks).toBe("function");
+    });
+
+    test("Mutation", () => {
+      fs.start({ mimeType: "text/plain" });
+      fs.push(new Uint8Array([1, 2, 3]));
+      fs.push(new Uint8Array([4, 5, 6]));
+      fs.end();
+    });
   });
 });