jazz-tools 0.15.15 → 0.16.0

package/src/tools/implementation/createContext.ts

@@ -1,7 +1,6 @@
 import {
   AgentSecret,
   CoID,
-  ControlledAgent,
   CryptoProvider,
   LocalNode,
   Peer,
@@ -14,12 +13,11 @@ import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
 import { type Account, type AccountClass } from "../coValues/account.js";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
 import {
-  type AccountSchema,
-  type AnyAccountSchema,
   CoValueFromRaw,
+  type CoreAccountSchema,
   type ID,
   type InstanceOfSchema,
-  anySchemaToCoSchema,
+  coValueClassFromCoValueClassOrSchema,
 } from "../internal.js";
 import { AuthCredentials, NewAccountProps } from "../types.js";
 import { activeAccountContext } from "./activeAccountContext.js";
@@ -89,7 +87,7 @@ export type JazzContext<Acc extends Account> =
 export async function createJazzContextFromExistingCredentials<
   S extends
     | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
+    | CoreAccountSchema,
 >({
   credentials,
   peersToLoadFrom,
@@ -115,7 +113,8 @@ export async function createJazzContextFromExistingCredentials<
   const CurrentAccountSchema =
     PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
 
-  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
+  const AccountClass =
+    coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
 
   const node = await LocalNode.withLoadedAccount({
     accountID: credentials.accountID as unknown as CoID<RawAccount>,
@@ -153,7 +152,7 @@ export async function createJazzContextFromExistingCredentials<
 export async function createJazzContextForNewAccount<
   S extends
     | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
+    | CoreAccountSchema,
 >({
   creationProps,
   initialAgentSecret,
@@ -174,7 +173,8 @@ export async function createJazzContextForNewAccount<
   const CurrentAccountSchema =
     PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
 
-  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
+  const AccountClass =
+    coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
 
   const { node } = await LocalNode.withNewlyCreatedAccount({
     creationProps,
@@ -209,7 +209,7 @@ export async function createJazzContextForNewAccount<
 export async function createJazzContext<
   S extends
     | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
+    | CoreAccountSchema,
 >(options: {
   credentials?: AuthCredentials;
   newAccountProps?: NewAccountProps;

package/src/tools/implementation/invites.ts

@@ -3,7 +3,7 @@ import { Account } from "../coValues/account.js";
 import type {
   CoValue,
   CoValueClass,
-  CoValueOrZodSchema,
+  CoValueClassOrSchema,
   ID,
 } from "../internal.js";
 
@@ -68,7 +68,7 @@ export function parseInviteLink(inviteURL: string):
 }
 
 /** @category Invite Links */
-export function consumeInviteLink<S extends CoValueOrZodSchema>({
+export function consumeInviteLink<S extends CoValueClassOrSchema>({
   inviteURL,
   as = Account.getMe(),
   forValueHint,

package/src/tools/implementation/schemaUtils.ts

@@ -0,0 +1,18 @@
+/**
+ * Remove getters from an object
+ *
+ * @param obj - The object to remove getters from.
+ * @returns A new object with the getters removed.
+ */
+export function removeGetters<T extends object>(obj: T): Partial<T> {
+  const result: any = {};
+
+  for (const key of Object.keys(obj)) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (!descriptor?.get) {
+      result[key] = (obj as any)[key];
+    }
+  }
+
+  return result;
+}

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

@@ -1,4 +1,17 @@
 export { Loaded as loaded } from "./zodSchema.js";
+export { CoMapSchema as Map } from "./schemaTypes/CoMapSchema.js";
+export { CoRecordSchema as Record } from "./schemaTypes/CoRecordSchema.js";
+export { CoListSchema as List } from "./schemaTypes/CoListSchema.js";
+export { CoFeedSchema as Feed } from "./schemaTypes/CoFeedSchema.js";
+export { PlainTextSchema as PlainText } from "./schemaTypes/PlainTextSchema.js";
+export { RichTextSchema as RichText } from "./schemaTypes/RichTextSchema.js";
+export { FileStreamSchema as FileStream } from "./schemaTypes/FileStreamSchema.js";
+export {
+  AccountSchema as Account,
+  CoProfileSchema as Profile,
+} from "./schemaTypes/AccountSchema.js";
+export { CoOptionalSchema as Optional } from "./schemaTypes/CoOptionalSchema.js";
+export { CoDiscriminatedUnionSchema as DiscriminatedUnion } from "./schemaTypes/CoDiscriminatedUnionSchema.js";
 export {
   coMapDefiner as map,
   coRecordDefiner as record,
@@ -12,4 +25,5 @@ export {
   coProfileDefiner as profile,
   coOptionalDefiner as optional,
   coDiscriminatedUnionDefiner as discriminatedUnion,
+  ImageDefinitionSchema as Image,
 } from "./zodCo.js";

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

@@ -0,0 +1,156 @@
+import { RawCoList, RawCoMap } from "cojson";
+import {
+  Account,
+  CoDiscriminatedUnionSchema,
+  CoFeed,
+  CoFeedSchema,
+  CoList,
+  CoListSchema,
+  CoMap,
+  CoPlainText,
+  CoRichText,
+  CoValueClass,
+  FileStream,
+  FileStreamSchema,
+  PlainTextSchema,
+  SchemaUnion,
+  enrichAccountSchema,
+  enrichCoMapSchema,
+  isCoValueClass,
+} from "../../../internal.js";
+import { coField } from "../../schema.js";
+
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { RichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { schemaUnionDiscriminatorFor } from "../unionUtils.js";
+import {
+  AnyCoreCoValueSchema,
+  AnyZodOrCoValueSchema,
+  CoValueClassFromAnySchema,
+  CoValueClassOrSchema,
+  CoValueSchemaFromCoreSchema,
+} from "../zodSchema.js";
+import {
+  SchemaField,
+  schemaFieldToCoFieldDef,
+} from "./schemaFieldToCoFieldDef.js";
+
+// Note: if you're editing this function, edit the `isAnyCoValueSchema`
+// function in `zodReExport.ts` as well
+export function isAnyCoValueSchema(
+  schema: AnyZodOrCoValueSchema | CoValueClass,
+): schema is AnyCoreCoValueSchema {
+  return "collaborative" in schema && schema.collaborative === true;
+}
+
+export function isCoValueSchema(
+  schema: AnyZodOrCoValueSchema | CoValueClass,
+): schema is CoValueSchemaFromCoreSchema<AnyCoreCoValueSchema> {
+  return isAnyCoValueSchema(schema) && "getCoValueClass" in schema;
+}
+
+/**
+ * Convert a "core" CoValue schema into a CoValue schema.
+ * See {@link CoreCoValueSchema} for more information.
+ *
+ * @returns The CoValue schema matching the provided CoreCoValueSchema
+ */
+export function hydrateCoreCoValueSchema<S extends AnyCoreCoValueSchema>(
+  schema: S,
+): CoValueSchemaFromCoreSchema<S> {
+  if (isCoValueSchema(schema)) {
+    // If the schema is already a CoValue schema, return it as is
+    return schema as any;
+  }
+
+  if (schema.builtin === "CoOptional") {
+    throw new Error(
+      `co.optional() of collaborative types is not supported as top-level schema: ${JSON.stringify(schema)}`,
+    );
+  } else if (schema.builtin === "CoMap" || schema.builtin === "Account") {
+    const def = schema.getDefinition();
+    const ClassToExtend = schema.builtin === "Account" ? Account : CoMap;
+
+    const coValueClass = class ZCoMap extends ClassToExtend {
+      constructor(options: { fromRaw: RawCoMap } | undefined) {
+        super(options);
+        for (const [fieldName, fieldType] of Object.entries(def.shape)) {
+          (this as any)[fieldName] = schemaFieldToCoFieldDef(
+            fieldType as SchemaField,
+          );
+        }
+        if (def.catchall) {
+          (this as any)[coField.items] = schemaFieldToCoFieldDef(
+            def.catchall as SchemaField,
+          );
+        }
+      }
+    };
+
+    const coValueSchema =
+      ClassToExtend === Account
+        ? enrichAccountSchema(schema as any, coValueClass as any)
+        : enrichCoMapSchema(schema as any, coValueClass as any);
+
+    return coValueSchema as unknown as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoList") {
+    const element = schema.element;
+    const coValueClass = class ZCoList extends CoList {
+      constructor(options: { fromRaw: RawCoList } | undefined) {
+        super(options);
+        (this as any)[coField.items] = schemaFieldToCoFieldDef(
+          element as SchemaField,
+        );
+      }
+    };
+
+    const coValueSchema = new CoListSchema(element, coValueClass as any);
+
+    return coValueSchema as unknown as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoFeed") {
+    const coValueClass = CoFeed.Of(
+      schemaFieldToCoFieldDef(schema.element as SchemaField),
+    );
+    const coValueSchema = new CoFeedSchema(schema.element, coValueClass);
+    return coValueSchema as unknown as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "FileStream") {
+    const coValueClass = FileStream;
+    return new FileStreamSchema(coValueClass) as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoPlainText") {
+    const coValueClass = CoPlainText;
+    return new PlainTextSchema(coValueClass) as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoRichText") {
+    const coValueClass = CoRichText;
+    return new RichTextSchema(coValueClass) as CoValueSchemaFromCoreSchema<S>;
+  } else if (schema.builtin === "CoDiscriminatedUnion") {
+    const coValueClass = SchemaUnion.Of(schemaUnionDiscriminatorFor(schema));
+    const coValueSchema = new CoDiscriminatedUnionSchema(schema, coValueClass);
+    return coValueSchema as CoValueSchemaFromCoreSchema<S>;
+  } else {
+    const notReachable: never = schema;
+    throw new Error(
+      `Unsupported zod CoValue type for top-level schema: ${JSON.stringify(notReachable, undefined, 2)}`,
+    );
+  }
+}
+
+/**
+ * Convert a CoValue class or a CoValue schema into a CoValue class.
+ *
+ * This function bridges the gap between CoValue classes created with the class syntax,
+ * and CoValue classes created with our `co.` definers.
+ *
+ * @param schema A CoValue class or a CoValue schema
+ * @returns The same CoValue class, or a CoValue class that matches the provided schema
+ */
+export function coValueClassFromCoValueClassOrSchema<
+  S extends CoValueClassOrSchema,
+>(schema: S): CoValueClassFromAnySchema<S> {
+  if (isCoValueClass(schema)) {
+    return schema as any;
+  } else if (isCoValueSchema(schema)) {
+    return schema.getCoValueClass() as any;
+  }
+
+  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
+}

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

@@ -0,0 +1,133 @@
+import { CoValueClass, isCoValueClass } from "../../../internal.js";
+import { coField } from "../../schema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { isUnionOfPrimitivesDeeply } from "../unionUtils.js";
+import {
+  ZodCatch,
+  ZodDefault,
+  ZodLazy,
+  ZodReadonly,
+  z,
+} from "../zodReExport.js";
+import { ZodPrimitiveSchema } from "../zodSchema.js";
+import { isCoValueSchema } from "./coValueSchemaTransformation.js";
+
+/**
+ * Types of objects that can be nested inside CoValue schema containers
+ */
+export type SchemaField =
+  // Schemas created with co.map(), co.record(), co.list(), etc.
+  | CoreCoValueSchema
+  // CoValue classes created with class syntax, or framework-provided classes like Group
+  | CoValueClass
+  | ZodPrimitiveSchema
+  | z.core.$ZodOptional<z.core.$ZodType>
+  | z.core.$ZodUnion<z.core.$ZodType[]>
+  | z.core.$ZodDiscriminatedUnion<z.core.$ZodType[]>
+  | z.core.$ZodObject<z.core.$ZodLooseShape>
+  | z.core.$ZodArray<z.core.$ZodType>
+  | z.core.$ZodTuple<z.core.$ZodType[]>
+  | z.core.$ZodReadonly<z.core.$ZodType>
+  | z.core.$ZodLazy<z.core.$ZodType>
+  | z.core.$ZodTemplateLiteral<any>
+  | z.core.$ZodLiteral<any>
+  | z.core.$ZodCatch<z.core.$ZodType>
+  | z.core.$ZodEnum<any>
+  | z.core.$ZodDefault<z.core.$ZodType>
+  | z.core.$ZodCatch<z.core.$ZodType>;
+
+export function schemaFieldToCoFieldDef(schema: SchemaField) {
+  if (isCoValueClass(schema)) {
+    return coField.ref(schema);
+  } else if (isCoValueSchema(schema)) {
+    if (schema.builtin === "CoOptional") {
+      return coField.ref(schema.getCoValueClass(), {
+        optional: true,
+      });
+    }
+    return coField.ref(schema.getCoValueClass());
+  } else {
+    if ("_zod" in schema) {
+      const zodSchemaDef = schema._zod.def;
+      if (zodSchemaDef.type === "optional") {
+        const inner = zodSchemaDef.innerType as ZodPrimitiveSchema;
+        return schemaFieldToCoFieldDef(inner);
+      } else if (zodSchemaDef.type === "string") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "number") {
+        return coField.number;
+      } else if (zodSchemaDef.type === "boolean") {
+        return coField.boolean;
+      } else if (zodSchemaDef.type === "null") {
+        return coField.null;
+      } else if (zodSchemaDef.type === "enum") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "readonly") {
+        return schemaFieldToCoFieldDef(
+          (schema as unknown as ZodReadonly).def.innerType as SchemaField,
+        );
+      } else if (zodSchemaDef.type === "date") {
+        return coField.optional.Date;
+      } else if (zodSchemaDef.type === "template_literal") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "lazy") {
+        // Mostly to support z.json()
+        return schemaFieldToCoFieldDef(
+          (schema as unknown as ZodLazy).unwrap() as SchemaField,
+        );
+      } else if (
+        zodSchemaDef.type === "default" ||
+        zodSchemaDef.type === "catch"
+      ) {
+        console.warn(
+          "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored.",
+        );
+
+        return schemaFieldToCoFieldDef(
+          (schema as unknown as ZodDefault | ZodCatch).def
+            .innerType as SchemaField,
+        );
+      } else if (zodSchemaDef.type === "literal") {
+        if (
+          zodSchemaDef.values.some((literal) => typeof literal === "undefined")
+        ) {
+          throw new Error("z.literal() with undefined is not supported");
+        }
+        if (zodSchemaDef.values.some((literal) => literal === null)) {
+          throw new Error("z.literal() with null is not supported");
+        }
+        if (
+          zodSchemaDef.values.some((literal) => typeof literal === "bigint")
+        ) {
+          throw new Error("z.literal() with bigint is not supported");
+        }
+        return coField.literal(
+          ...(zodSchemaDef.values as Exclude<
+            (typeof zodSchemaDef.values)[number],
+            undefined | null | bigint
+          >[]),
+        );
+      } else if (
+        zodSchemaDef.type === "object" ||
+        zodSchemaDef.type === "array" ||
+        zodSchemaDef.type === "tuple"
+      ) {
+        return coField.json();
+      } else if (zodSchemaDef.type === "union") {
+        if (isUnionOfPrimitivesDeeply(schema)) {
+          return coField.json();
+        } else {
+          throw new Error(
+            "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead.",
+          );
+        }
+      } else {
+        throw new Error(
+          `Unsupported zod type: ${(schema._zod?.def as any)?.type || JSON.stringify(schema)}`,
+        );
+      }
+    } else {
+      throw new Error(`Unsupported zod type: ${schema}`);
+    }
+  }
+}

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

@@ -9,8 +9,13 @@ import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { z } from "../zodReExport.js";
-import { Loaded, ResolveQuery } from "../zodSchema.js";
-import { AnyCoMapSchema, CoMapSchema } from "./CoMapSchema.js";
+import { AnyZodOrCoValueSchema, Loaded, ResolveQuery } from "../zodSchema.js";
+import {
+  CoMapSchema,
+  CoMapSchemaDefinition,
+  CoreCoMapSchema,
+  createCoreCoMapSchema,
+} from "./CoMapSchema.js";
 
 export type BaseProfileShape = {
   name: z.core.$ZodString<string>;
@@ -19,8 +24,8 @@ export type BaseProfileShape = {
 };
 
 export type BaseAccountShape = {
-  profile: AnyCoMapSchema<BaseProfileShape>;
-  root: AnyCoMapSchema;
+  profile: CoreCoMapSchema<BaseProfileShape>;
+  root: CoreCoMapSchema;
 };
 
 export type DefaultAccountShape = {
@@ -28,9 +33,18 @@ export type DefaultAccountShape = {
   root: CoMapSchema<{}>;
 };
 
-export type AccountSchema<
+export interface AccountSchema<
   Shape extends BaseAccountShape = DefaultAccountShape,
-> = Omit<CoMapSchema<Shape>, "create" | "load" | "withMigration"> & {
+> extends CoreAccountSchema<Shape>,
+    Omit<
+      CoMapSchema<Shape>,
+      | "builtin"
+      | "getDefinition"
+      | "create"
+      | "load"
+      | "withMigration"
+      | "getCoValueClass"
+    > {
   builtin: "Account";
 
   create: (options: {
@@ -63,10 +77,19 @@ export type AccountSchema<
   ): AccountSchema<Shape>;
 
   getCoValueClass: () => typeof Account;
-};
+}
+
+export function createCoreAccountSchema<Shape extends BaseAccountShape>(
+  shape: Shape,
+): CoreAccountSchema<Shape> {
+  return {
+    ...createCoreCoMapSchema(shape),
+    builtin: "Account" as const,
+  };
+}
 
 export function enrichAccountSchema<Shape extends BaseAccountShape>(
-  schema: AnyAccountSchema<Shape>,
+  schema: CoreAccountSchema<Shape>,
   coValueClass: typeof Account,
 ): AccountSchema<Shape> {
   const enrichedSchema = Object.assign(schema, {
@@ -90,9 +113,6 @@ export function enrichAccountSchema<Shape extends BaseAccountShape>(
       // @ts-expect-error
       return coValueClass.subscribe(...args);
     },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
     fromRaw: (...args: any[]) => {
       // @ts-expect-error
       return coValueClass.fromRaw(...args);
@@ -127,16 +147,15 @@ export type DefaultProfileShape = {
 
 export type CoProfileSchema<
   Shape extends z.core.$ZodLooseShape = DefaultProfileShape,
-  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
-> = CoMapSchema<Shape & DefaultProfileShape, Config, Group>;
+  CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
+> = CoMapSchema<Shape & DefaultProfileShape, CatchAll, Group>;
 
 // less precise version to avoid circularity issues and allow matching against
-export type AnyAccountSchema<
+export interface CoreAccountSchema<
   Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
-> = z.core.$ZodObject<Shape> & {
-  collaborative: true;
+> extends Omit<CoreCoMapSchema<Shape>, "builtin"> {
   builtin: "Account";
-};
+}
 
 export type AccountInstance<Shape extends z.core.$ZodLooseShape> = {
   -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;