jazz-tools 0.15.10 → 0.15.12

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 { ID, Loaded, zodSchemaToCoSchema } from "../internal.js";
+import { Loaded, anySchemaToCoSchema } from "../internal.js";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
@@ -145,7 +145,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);
         },
       });
 
@@ -182,7 +182,7 @@ describe("CoMap", async () => {
         name: z.string(),
         age: z.number(),
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -211,7 +211,7 @@ describe("CoMap", async () => {
         name: z.string(),
         age: z.number(),
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -400,7 +400,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({
@@ -801,7 +801,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     subscribeToCoValue(
-      zodSchemaToCoSchema(Person), // TODO: we should get rid of the conversion in the future
+      anySchemaToCoSchema(Person), // TODO: we should get rid of the conversion in the future
       person.id,
       {
         syncResolution: true,
@@ -1003,7 +1003,7 @@ describe("CoMap applyDiff", async () => {
     birthday: z.date(),
     nested: NestedMap,
     optionalField: z.string().optional(),
-    optionalNested: z.optional(NestedMap),
+    optionalNested: co.optional(NestedMap),
   });
 
   test("Basic applyDiff", () => {
@@ -1698,7 +1698,7 @@ describe("Creating and finding unique CoMaps", async () => {
       dateValue: z.date(),
     });
 
-    const AttributeValue = z.discriminatedUnion("type", [
+    const AttributeValue = co.discriminatedUnion("type", [
       StringAttributeValue,
       NumberAttributeValue,
       DateAttributeValue,
@@ -1714,7 +1714,7 @@ describe("Creating and finding unique CoMaps", async () => {
       attributeValue: AttributeValue,
     });
 
-    const Tag = z.discriminatedUnion("type", [
+    const Tag = co.discriminatedUnion("type", [
       AttributeTag,
       StringTag,
       DateTag,
@@ -1764,7 +1764,7 @@ describe("Creating and finding unique CoMaps", async () => {
       error: HttpError,
     });
 
-    const ErrorResponse = z.discriminatedUnion("type", [
+    const ErrorResponse = co.discriminatedUnion("type", [
       ClientError,
       ServerError,
       NetworkError,

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

@@ -0,0 +1,39 @@
+import { beforeEach, describe, test } from "vitest";
+import { CoPlainText, co, z } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+
+describe("co.optional", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  test("can use co.optional with CoValue schemas as values", () => {
+    const Person = co.map({
+      preferredName: co.optional(co.plainText()),
+    });
+
+    const person = Person.create({});
+
+    type ExpectedType = {
+      preferredName?: CoPlainText;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(person);
+  });
+
+  test("cannot use co.optional with zod schemas as values", () => {
+    const Person = co.map({
+      // @ts-expect-error: cannot use co.optional with a Zod schema
+      preferredName: co.optional(z.string()),
+    });
+  });
+});

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

@@ -1,4 +1,4 @@
-import { AgentSecret, RawCoMap } from "cojson";
+import { AgentSecret } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import {
@@ -9,6 +9,7 @@ import {
   ID,
   InMemoryKVStore,
   KvStoreContext,
+  anySchemaToCoSchema,
   co,
   createAnonymousJazzContext,
   createJazzContext,
@@ -90,7 +91,7 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeInstanceOf(
-        zodSchemaToCoSchema(CustomAccount),
+        anySchemaToCoSchema(CustomAccount),
       );
     });
 
@@ -199,7 +200,7 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeInstanceOf(
-        zodSchemaToCoSchema(CustomAccount),
+        anySchemaToCoSchema(CustomAccount),
       );
     });
 
@@ -350,7 +351,7 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeInstanceOf(
-        zodSchemaToCoSchema(CustomAccount),
+        anySchemaToCoSchema(CustomAccount),
       );
     });
   });

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

@@ -36,7 +36,7 @@ const TestList = co.list(InnerMap);
 
 const TestMap = co.map({
   list: TestList,
-  optionalRef: z.optional(InnermostMap),
+  optionalRef: co.optional(InnermostMap),
 });
 
 describe("Deep loading with depth arg", async () => {
@@ -599,7 +599,7 @@ describe("Deep loading with unauthorized account", async () => {
     });
 
     const Lv2 = co.map({
-      lv3: z.optional(Lv3),
+      lv3: co.optional(Lv3),
     });
 
     const Lv1 = co.map({
@@ -737,7 +737,7 @@ describe("Deep loading with unauthorized account", async () => {
     const Person = co.map({
       name: z.string(),
       get friends(): z.ZodOptional<typeof Friends> {
-        return z.optional(Friends);
+        return co.optional(Friends);
       },
     });
     const Friends: CoListSchema<typeof Person> = co.list(Person); // TODO: annoying that we have to annotate

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

@@ -1,14 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
-import {
-  Account,
-  CoMap,
-  Group,
-  Inbox,
-  InboxSender,
-  Profile,
-  z,
-} from "../exports";
-import { Loaded, co, coField, zodSchemaToCoSchema } from "../internal";
+import { Group, Inbox, InboxSender, z } from "../exports";
+import { Loaded, anySchemaToCoSchema, co } from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
 
 const Message = co.map({
@@ -26,7 +18,7 @@ describe("Inbox", () => {
 
       const { clientAccount: sender, serverAccount: receiver } =
         await setupTwoNodes({
-          ServerAccountSchema: zodSchemaToCoSchema(WorkerAccount),
+          ServerAccountSchema: anySchemaToCoSchema(WorkerAccount),
         });
 
       await expect(() => InboxSender.load(receiver.id, sender)).rejects.toThrow(

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

@@ -33,6 +33,15 @@ test("load a value", async () => {
   expect(john?.name).toBe("John");
 });
 
+test("return null if id is invalid", async () => {
+  const Person = co.map({
+    name: z.string(),
+  });
+
+  const john = await Person.load("test");
+  expect(john).toBeNull();
+});
+
 test("retry an unavailable value", async () => {
   const Person = co.map({
     name: z.string(),

package/src/tools/tests/patterns/requestToJoin.test.ts

@@ -1,5 +1,5 @@
 import { assert, describe, expect, test } from "vitest";
-import { Account, CoList, CoMap, Group, ID, co, z } from "../../exports";
+import { Account, Group, co, z } from "../../exports";
 import { createJazzTestAccount, linkAccounts } from "../../testing";
 
 const RequestToJoin = co.map({

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

@@ -6,7 +6,6 @@ import {
   Loaded,
   anySchemaToCoSchema,
   co,
-  loadCoValue,
   subscribeToCoValue,
   z,
 } from "../exports.js";
@@ -24,7 +23,7 @@ const BlueButtonWidget = co.map({
   blueness: z.number(),
 });
 
-const ButtonWidget = z.discriminatedUnion("type", [
+const ButtonWidget = co.discriminatedUnion("type", [
   RedButtonWidget,
   BlueButtonWidget,
 ]);
@@ -40,7 +39,7 @@ const CheckboxWidget = co.map({
   checked: z.boolean(),
 });
 
-const WidgetUnion = z.discriminatedUnion("type", [
+const WidgetUnion = co.discriminatedUnion("type", [
   ButtonWidget,
   SliderWidget,
   CheckboxWidget,
@@ -72,25 +71,15 @@ describe("SchemaUnion", () => {
       { owner: me },
     );
 
-    const loadedButtonWidget = await loadCoValue(
-      anySchemaToCoSchema(WidgetUnion),
-      buttonWidget.id,
-      {
-        loadAs: me,
-      },
-    );
-    const loadedSliderWidget = await loadCoValue(
-      anySchemaToCoSchema(WidgetUnion),
-      sliderWidget.id,
-      {
-        loadAs: me,
-      },
-    );
-    const loadedCheckboxWidget = await loadCoValue(
-      anySchemaToCoSchema(WidgetUnion),
-      checkboxWidget.id,
-      { loadAs: me },
-    );
+    const loadedButtonWidget = await WidgetUnion.load(buttonWidget.id, {
+      loadAs: me,
+    });
+    const loadedSliderWidget = await WidgetUnion.load(sliderWidget.id, {
+      loadAs: me,
+    });
+    const loadedCheckboxWidget = await WidgetUnion.load(checkboxWidget.id, {
+      loadAs: me,
+    });
 
     expect(loadedButtonWidget?.type).toBe("button");
     expect(loadedSliderWidget?.type).toBe("slider");

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

@@ -7,27 +7,13 @@ import {
   onTestFinished,
   vi,
 } from "vitest";
+import { Account, Group, cojsonInternals, z } from "../index.js";
 import {
-  Account,
-  CoFeed,
-  CoList,
-  CoMap,
-  FileStream,
-  Group,
-  coField,
-  cojsonInternals,
-  z,
-} from "../index.js";
-import {
-  CoMapInstance,
-  ID,
-  InstanceOrPrimitiveOfSchema,
   Loaded,
-  Resolved,
+  anySchemaToCoSchema,
   co,
   createCoValueObservable,
   subscribeToCoValue,
-  zodSchemaToCoSchema,
 } from "../internal.js";
 import {
   createJazzTestAccount,
@@ -43,7 +29,7 @@ const ReactionsFeed = co.feed(z.string());
 const Message = co.map({
   text: z.string(),
   reactions: ReactionsFeed,
-  attachment: z.optional(co.fileStream()),
+  attachment: co.optional(co.fileStream()),
 });
 
 const ChatRoom = co.map({
@@ -84,7 +70,7 @@ describe("subscribeToCoValue", () => {
     let result = null as Loaded<typeof ChatRoom, true> | null;
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(ChatRoom),
+      anySchemaToCoSchema(ChatRoom),
       chatRoom.id,
       { loadAs: meOnSecondPeer },
       (value) => {
@@ -131,7 +117,7 @@ describe("subscribeToCoValue", () => {
     let result = null as Loaded<typeof ChatRoom, {}> | null;
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(ChatRoom),
+      anySchemaToCoSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -172,7 +158,7 @@ describe("subscribeToCoValue", () => {
     messages.push(createMessage(me, "Hello"));
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(ChatRoom),
+      anySchemaToCoSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -215,7 +201,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(ChatRoom),
+      anySchemaToCoSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -275,7 +261,7 @@ describe("subscribeToCoValue", () => {
     >[];
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(ChatRoom),
+      anySchemaToCoSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -346,7 +332,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(ChatRoom),
+      anySchemaToCoSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -410,7 +396,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: account,
@@ -471,7 +457,7 @@ describe("subscribeToCoValue", () => {
     const onUnauthorized = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -542,7 +528,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -617,7 +603,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -654,7 +640,7 @@ describe("subscribeToCoValue", () => {
       value: z.string(),
     });
 
-    const TestList = co.list(z.optional(TestMap));
+    const TestList = co.list(co.optional(TestMap));
 
     const reader = await createJazzTestAccount({
       isCurrentActiveAccount: true,
@@ -687,7 +673,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -718,7 +704,7 @@ describe("subscribeToCoValue", () => {
       value: z.string(),
     });
 
-    const TestList = co.list(z.optional(TestMap));
+    const TestList = co.list(co.optional(TestMap));
 
     const creator = await createJazzTestAccount({
       isCurrentActiveAccount: true,
@@ -739,7 +725,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: creator,
@@ -806,7 +792,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: creator,
@@ -895,7 +881,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(Person),
+      anySchemaToCoSchema(Person),
       person.id,
       {
         loadAs: reader,
@@ -982,7 +968,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -1069,7 +1055,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(PersonList),
+      anySchemaToCoSchema(PersonList),
       list.id,
       {
         loadAs: reader,
@@ -1165,7 +1151,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(PersonList),
+      anySchemaToCoSchema(PersonList),
       list.id,
       {
         loadAs: reader,
@@ -1248,7 +1234,7 @@ describe("subscribeToCoValue", () => {
 
     // Test subscribing to the large coValue
     const unsubscribe = subscribeToCoValue(
-      zodSchemaToCoSchema(LargeDataset),
+      anySchemaToCoSchema(LargeDataset),
       largeMap.id,
       {
         loadAs: alice,
@@ -1314,7 +1300,7 @@ describe("createCoValueObservable", () => {
     const mockListener = vi.fn();
 
     const unsubscribe = observable.subscribe(
-      zodSchemaToCoSchema(TestMap),
+      anySchemaToCoSchema(TestMap),
       testMap.id,
       {
         loadAs: meOnSecondPeer,
@@ -1343,7 +1329,7 @@ describe("createCoValueObservable", () => {
     const mockListener = vi.fn();
 
     const unsubscribe = observable.subscribe(
-      zodSchemaToCoSchema(TestMap),
+      anySchemaToCoSchema(TestMap),
       testMap.id,
       {
         loadAs: meOnSecondPeer,

package/src/tools/tests/testStorage.ts

@@ -0,0 +1,70 @@
+import { randomUUID } from "node:crypto";
+import { unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SQLiteDatabaseDriverAsync, getSqliteStorageAsync } from "cojson";
+import Database, { type Database as DatabaseT } from "libsql";
+import { onTestFinished } from "vitest";
+
+class LibSQLSqliteAsyncDriver implements SQLiteDatabaseDriverAsync {
+  private readonly db: DatabaseT;
+
+  constructor(filename: string) {
+    this.db = new Database(filename, {});
+  }
+
+  async initialize() {
+    await this.db.pragma("journal_mode = WAL");
+  }
+
+  async run(sql: string, params: unknown[]) {
+    this.db.prepare(sql).run(params);
+  }
+
+  async query<T>(sql: string, params: unknown[]): Promise<T[]> {
+    return this.db.prepare(sql).all(params) as T[];
+  }
+
+  async get<T>(sql: string, params: unknown[]): Promise<T | undefined> {
+    return this.db.prepare(sql).get(params) as T | undefined;
+  }
+
+  async transaction(callback: () => unknown) {
+    await this.run("BEGIN TRANSACTION", []);
+
+    try {
+      await callback();
+      await this.run("COMMIT", []);
+    } catch (error) {
+      await this.run("ROLLBACK", []);
+    }
+  }
+
+  async closeDb() {
+    this.db.close();
+  }
+}
+
+export async function createAsyncStorage({ filename }: { filename?: string }) {
+  const storage = await getSqliteStorageAsync(
+    new LibSQLSqliteAsyncDriver(getDbPath(filename)),
+  );
+
+  onTestFinished(() => {
+    storage.close();
+  });
+
+  return storage;
+}
+
+export function getDbPath(defaultDbPath?: string) {
+  const dbPath = defaultDbPath ?? join(tmpdir(), `test-${randomUUID()}.db`);
+
+  if (!defaultDbPath) {
+    onTestFinished(() => {
+      unlinkSync(dbPath);
+    });
+  }
+
+  return dbPath;
+}

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

@@ -0,0 +1,70 @@
+import { describe, test } from "vitest";
+import { z } from "../exports";
+import { co } from "../internal";
+
+describe("CoValue and Zod schema compatibility", () => {
+  test("cannot use z.record with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+
+    const Person = co.map({
+      // @ts-expect-error: cannot use z.record with a CoValue schema
+      // (z.record is not exported by jazz-tools)
+      pets: z.record(z.string(), Dog),
+    });
+  });
+
+  test("cannot use z.union 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({
+      // @ts-expect-error: cannot use z.union with a CoValue schema
+      pets: z.union([Dog, Cat]),
+    });
+  });
+
+  test("cannot use z.intersection 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({
+      // @ts-expect-error: cannot use z.intersection with a CoValue schema
+      // (z.intersection is not exported by jazz-tools)
+      pets: z.intersection(Dog, Cat),
+    });
+  });
+
+  test("cannot use z.array with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+
+    const Person = co.map({
+      // @ts-expect-error: cannot use z.array with a CoValue schema
+      pets: z.array(Dog),
+    });
+  });
+
+  test("cannot use z.tuple with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+
+    const Person = co.map({
+      // @ts-expect-error: cannot use z.tuple with a CoValue schema
+      pets: z.tuple([Dog]),
+    });
+  });
+});