jazz-tools 0.13.31 → 0.14.1

package/src/exports.ts

@@ -8,53 +8,56 @@ export type {
   SyncMessage,
 } from "cojson";
 
+export { z } from "zod/v4";
+
 export type { CoValue, ID } from "./internal.js";
 
-export { Encoders, co } from "./internal.js";
+export { Encoders, coField } from "./internal.js";
 
-export { Inbox, InboxSender } from "./coValues/inbox.js";
+export { Inbox, InboxSender } from "./internal.js";
 
-export {
-  Account,
-  isControlledAccount,
-  type AccountClass,
-  type AccountCreationProps,
-} from "./coValues/account.js";
-export {
-  BinaryCoStream,
-  CoFeed,
-  CoStream,
-  type CoFeedEntry,
-  FileStream,
-} from "./coValues/coFeed.js";
-export { CoList } from "./coValues/coList.js";
-export { CoMap, type CoMapInit } from "./coValues/coMap.js";
-export { CoPlainText, type TextPos } from "./coValues/coPlainText.js";
-export { CoRichText } from "./coValues/coRichText.js";
-export { ImageDefinition } from "./coValues/extensions/imageDef.js";
-export { Group } from "./coValues/group.js";
-export { CoValueBase } from "./coValues/interfaces.js";
-export { Profile } from "./coValues/profile.js";
-export { SchemaUnion } from "./coValues/schemaUnion.js";
+export { Group } from "./internal.js";
+export { CoValueBase } from "./internal.js";
+export { Profile } from "./internal.js";
+export { SchemaUnion } from "./internal.js";
+
+export { co } from "./internal.js";
 
 export type {
   CoValueClass,
+  CoValueFromRaw,
   DeeplyLoaded,
   Resolved,
   RefsToResolve,
   RefsToResolveStrict,
+  CoMapInit,
+  CoFeedEntry,
+  TextPos,
+  AccountClass,
+  AccountCreationProps,
 } from "./internal.js";
 
 export {
+  CoMap,
+  CoList,
+  BinaryCoStream,
+  CoFeed,
+  CoStream,
+  FileStream,
+  CoPlainText,
+  CoRichText,
+  Account,
+  isControlledAccount,
   createCoValueObservable,
   loadCoValue,
   subscribeToCoValue,
+  ImageDefinition,
 } from "./internal.js";
 
 export {
   JazzContextManager,
   type JazzContextManagerAuthProps,
-} from "./implementation/ContextManager.js";
+} from "./internal.js";
 
 export { AuthSecretStorage } from "./auth/AuthSecretStorage.js";
 export { KvStoreContext, type KvStore } from "./auth/KvStoreContext.js";
@@ -81,3 +84,22 @@ export {
 } from "./internal.js";
 
 export type * from "./types.js";
+
+export {
+  zodSchemaToCoSchema,
+  anySchemaToCoSchema,
+  type InstanceOfSchema,
+  type InstanceOfSchemaCoValuesNullable,
+  type CoValueOrZodSchema,
+  type Loaded,
+  type AccountSchema,
+  type AnyAccountSchema,
+  type CoListSchema,
+  type CoMapSchema,
+  type CoFeedSchema,
+  type PlainTextSchema,
+  type FileStreamSchema,
+  type ResolveQuery,
+  type ResolveQueryStrict,
+  type InitFor,
+} from "./internal.js";

package/src/implementation/activeAccountContext.ts

@@ -1,4 +1,4 @@
-import type { Account } from "../coValues/account.js";
+import type { Account } from "../internal.js";
 
 class ActiveAccountContext {
   private activeAccount: Account | null = null;

package/src/implementation/createContext.ts

@@ -12,7 +12,14 @@ import {
 import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
 import { type Account, type AccountClass } from "../coValues/account.js";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
-import type { ID } from "../internal.js";
+import {
+  type AccountSchema,
+  type AnyAccountSchema,
+  CoValueFromRaw,
+  type ID,
+  type InstanceOfSchema,
+  anySchemaToCoSchema,
+} from "../internal.js";
 import { AuthCredentials, NewAccountProps } from "../types.js";
 import { activeAccountContext } from "./activeAccountContext.js";
 import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
@@ -79,7 +86,9 @@ export type JazzContext<Acc extends Account> =
   | JazzContextWithAgent;
 
 export async function createJazzContextFromExistingCredentials<
-  Acc extends Account,
+  S extends
+    | (AccountClass<Account> & CoValueFromRaw<Account>)
+    | AnyAccountSchema,
 >({
   credentials,
   peersToLoadFrom,
@@ -91,18 +100,19 @@ export async function createJazzContextFromExistingCredentials<
   credentials: Credentials;
   peersToLoadFrom: Peer[];
   crypto: CryptoProvider;
-  AccountSchema?: AccountClass<Acc>;
+  AccountSchema?: S;
   sessionProvider: SessionProvider;
   onLogOut?: () => void;
-}): Promise<JazzContextWithAccount<Acc>> {
+}): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
   const { sessionID, sessionDone } = await sessionProvider(
     credentials.accountID,
     crypto,
   );
 
   const CurrentAccountSchema =
-    PropsAccountSchema ??
-    (RegisteredSchemas["Account"] as unknown as AccountClass<Acc>);
+    PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
+
+  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
 
   const node = await LocalNode.withLoadedAccount({
     accountID: credentials.accountID as unknown as CoID<RawAccount>,
@@ -111,21 +121,19 @@ export async function createJazzContextFromExistingCredentials<
     peersToLoadFrom: peersToLoadFrom,
     crypto: crypto,
     migration: async (rawAccount, _node, creationProps) => {
-      const account = new CurrentAccountSchema({
-        fromRaw: rawAccount,
-      }) as Acc;
+      const account = AccountClass.fromRaw(rawAccount) as InstanceOfSchema<S>;
       activeAccountContext.set(account);
 
       await account.applyMigration(creationProps);
     },
   });
 
-  const account = CurrentAccountSchema.fromNode(node);
+  const account = AccountClass.fromNode(node);
   activeAccountContext.set(account);
 
   return {
     node,
-    account,
+    account: account as InstanceOfSchema<S>,
     done: () => {
       node.gracefulShutdown();
       sessionDone();
@@ -138,7 +146,11 @@ export async function createJazzContextFromExistingCredentials<
   };
 }
 
-export async function createJazzContextForNewAccount<Acc extends Account>({
+export async function createJazzContextForNewAccount<
+  S extends
+    | (AccountClass<Account> & CoValueFromRaw<Account>)
+    | AnyAccountSchema,
+>({
   creationProps,
   initialAgentSecret,
   peersToLoadFrom,
@@ -150,12 +162,13 @@ export async function createJazzContextForNewAccount<Acc extends Account>({
   initialAgentSecret?: AgentSecret;
   peersToLoadFrom: Peer[];
   crypto: CryptoProvider;
-  AccountSchema?: AccountClass<Acc>;
+  AccountSchema?: S;
   onLogOut?: () => Promise<void>;
-}): Promise<JazzContextWithAccount<Acc>> {
+}): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
   const CurrentAccountSchema =
-    PropsAccountSchema ??
-    (RegisteredSchemas["Account"] as unknown as AccountClass<Acc>);
+    PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
+
+  const AccountClass = anySchemaToCoSchema(CurrentAccountSchema);
 
   const { node } = await LocalNode.withNewlyCreatedAccount({
     creationProps,
@@ -163,21 +176,19 @@ export async function createJazzContextForNewAccount<Acc extends Account>({
     crypto,
     initialAgentSecret,
     migration: async (rawAccount, _node, creationProps) => {
-      const account = new CurrentAccountSchema({
-        fromRaw: rawAccount,
-      }) as Acc;
+      const account = AccountClass.fromRaw(rawAccount) as InstanceOfSchema<S>;
       activeAccountContext.set(account);
 
       await account.applyMigration(creationProps);
     },
   });
 
-  const account = CurrentAccountSchema.fromNode(node);
+  const account = AccountClass.fromNode(node);
   activeAccountContext.set(account);
 
   return {
     node,
-    account,
+    account: account as InstanceOfSchema<S>,
     done: () => {
       node.gracefulShutdown();
     },
@@ -188,19 +199,23 @@ export async function createJazzContextForNewAccount<Acc extends Account>({
   };
 }
 
-export async function createJazzContext<Acc extends Account>(options: {
+export async function createJazzContext<
+  S extends
+    | (AccountClass<Account> & CoValueFromRaw<Account>)
+    | AnyAccountSchema,
+>(options: {
   credentials?: AuthCredentials;
   newAccountProps?: NewAccountProps;
   peersToLoadFrom: Peer[];
   crypto: CryptoProvider;
   defaultProfileName?: string;
-  AccountSchema?: AccountClass<Acc>;
+  AccountSchema?: S;
   sessionProvider: SessionProvider;
   authSecretStorage: AuthSecretStorage;
 }) {
   const crypto = options.crypto;
 
-  let context: JazzContextWithAccount<Acc>;
+  let context: JazzContextWithAccount<InstanceOfSchema<S>>;
 
   const authSecretStorage = options.authSecretStorage;
 

package/src/implementation/invites.ts

@@ -1,6 +1,11 @@
 import { type InviteSecret, cojsonInternals } from "cojson";
 import { Account } from "../coValues/account.js";
-import type { CoValue, CoValueClass, ID } from "../internal.js";
+import type {
+  CoValue,
+  CoValueClass,
+  CoValueOrZodSchema,
+  ID,
+} from "../internal.js";
 
 /** @category Invite Links */
 export function createInviteLink<C extends CoValue>(
@@ -31,11 +36,9 @@ export function createInviteLink<C extends CoValue>(
 }
 
 /** @category Invite Links */
-export function parseInviteLink<C extends CoValue>(
-  inviteURL: string,
-):
+export function parseInviteLink(inviteURL: string):
   | {
-      valueID: ID<C>;
+      valueID: string;
       valueHint?: string;
       inviteSecret: InviteSecret;
     }
@@ -44,16 +47,16 @@ export function parseInviteLink<C extends CoValue>(
   const parts = url.hash.split("/");
 
   let valueHint: string | undefined;
-  let valueID: ID<C> | undefined;
+  let valueID: string | undefined;
   let inviteSecret: InviteSecret | undefined;
 
   if (parts[0] === "#" && parts[1] === "invite") {
     if (parts.length === 5) {
       valueHint = parts[2];
-      valueID = parts[3] as ID<C>;
+      valueID = parts[3];
       inviteSecret = parts[4] as InviteSecret;
     } else if (parts.length === 4) {
-      valueID = parts[2] as ID<C>;
+      valueID = parts[2];
       inviteSecret = parts[3] as InviteSecret;
     }
 
@@ -65,7 +68,7 @@ export function parseInviteLink<C extends CoValue>(
 }
 
 /** @category Invite Links */
-export function consumeInviteLink<V extends CoValue>({
+export function consumeInviteLink<S extends CoValueOrZodSchema>({
   inviteURL,
   as = Account.getMe(),
   forValueHint,
@@ -74,17 +77,17 @@ export function consumeInviteLink<V extends CoValue>({
   inviteURL: string;
   as?: Account;
   forValueHint?: string;
-  invitedObjectSchema: CoValueClass<V>;
+  invitedObjectSchema: S;
 }): Promise<
   | {
-      valueID: ID<V>;
+      valueID: string;
       valueHint?: string;
       inviteSecret: InviteSecret;
     }
   | undefined
 > {
   return new Promise((resolve, reject) => {
-    const result = parseInviteLink<V>(inviteURL);
+    const result = parseInviteLink(inviteURL);
 
     if (result && result.valueHint === forValueHint) {
       as.acceptInvite(result.valueID, result.inviteSecret, invitedObjectSchema)

package/src/implementation/refs.ts

@@ -4,10 +4,12 @@ import type {
   CoValue,
   ID,
   RefEncoded,
-  UnCo,
 } from "../internal.js";
-import { isRefEncoded } from "../internal.js";
-import { accessChildById, getSubscriptionScope } from "../subscribe/index.js";
+import {
+  accessChildById,
+  getSubscriptionScope,
+  isRefEncoded,
+} from "../internal.js";
 
 export class Ref<out V extends CoValue> {
   constructor(
@@ -119,5 +121,5 @@ export function makeRefs<Keys extends string | number>(
 }
 
 export type RefIfCoValue<V> = NonNullable<V> extends CoValue
-  ? Ref<UnCo<NonNullable<V>>>
+  ? Ref<NonNullable<V>>
   : never;

package/src/implementation/schema.ts

@@ -23,77 +23,65 @@ export const Encoders = {
   },
 };
 
-export type CoMarker = { readonly __co: unique symbol };
-/** @category Schema definition */
-export type co<T> = T | (T & CoMarker);
-export type IfCo<C, R> = C extends infer _A | infer B
-  ? B extends CoMarker
-    ? R extends JazzToolsSymbol // Exclude symbol properties like co.items from the refs/init types
-      ? never
-      : R
-    : never
-  : never;
-export type UnCo<T> = T extends co<infer A> ? A : T;
-
 const optional = {
   ref: optionalRef,
-  json<T extends CojsonInternalTypes.CoJsonValue<T>>(): co<T | undefined> {
+  json<T extends CojsonInternalTypes.CoJsonValue<T>>(): T | undefined {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return { [SchemaInit]: "json" satisfies Schema } as any;
   },
-  encoded<T>(arg: OptionalEncoder<T>): co<T | undefined> {
+  encoded<T>(arg: OptionalEncoder<T>): T | undefined {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
   },
   string: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<string | undefined>,
+  } as unknown as string | undefined,
   number: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<number | undefined>,
+  } as unknown as number | undefined,
   boolean: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<boolean | undefined>,
+  } as unknown as boolean | undefined,
   null: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<null | undefined>,
+  } as unknown as null | undefined,
   Date: {
     [SchemaInit]: { encoded: Encoders.OptionalDate } satisfies Schema,
-  } as unknown as co<Date | undefined>,
+  } as unknown as Date | undefined,
   literal<T extends (string | number | boolean)[]>(
     ..._lit: T
-  ): co<T[number] | undefined> {
+  ): T[number] | undefined {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return { [SchemaInit]: "json" satisfies Schema } as any;
   },
 };
 
 /** @category Schema definition */
-export const co = {
+export const coField = {
   string: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<string>,
+  } as unknown as string,
   number: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<number>,
+  } as unknown as number,
   boolean: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<boolean>,
+  } as unknown as boolean,
   null: {
     [SchemaInit]: "json" satisfies Schema,
-  } as unknown as co<null>,
+  } as unknown as null,
   Date: {
     [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
-  } as unknown as co<Date>,
-  literal<T extends (string | number | boolean)[]>(..._lit: T): co<T[number]> {
+  } as unknown as Date,
+  literal<T extends (string | number | boolean)[]>(..._lit: T): T[number] {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return { [SchemaInit]: "json" satisfies Schema } as any;
   },
-  json<T extends CojsonInternalTypes.CoJsonValue<T>>(): co<T> {
+  json<T extends CojsonInternalTypes.CoJsonValue<T>>(): T {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return { [SchemaInit]: "json" satisfies Schema } as any;
   },
-  encoded<T>(arg: Encoder<T>): co<T> {
+  encoded<T>(arg: Encoder<T>): T {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
   },
@@ -104,18 +92,18 @@ export const co = {
 
 function optionalRef<C extends CoValueClass>(
   arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
-): co<InstanceType<C> | null | undefined> {
+): InstanceType<C> | null | undefined {
   return ref(arg, { optional: true });
 }
 
 function ref<C extends CoValueClass>(
   arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
   options?: never,
-): co<InstanceType<C> | null>;
+): InstanceType<C> | null;
 function ref<C extends CoValueClass>(
   arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
   options: { optional: true },
-): co<InstanceType<C> | null | undefined>;
+): InstanceType<C> | null | undefined;
 function ref<
   C extends CoValueClass,
   Options extends { optional?: boolean } | undefined,
@@ -123,8 +111,8 @@ function ref<
   arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
   options?: Options,
 ): Options extends { optional: true }
-  ? co<InstanceType<C> | null | undefined>
-  : co<InstanceType<C> | null> {
+  ? InstanceType<C> | null | undefined
+  : InstanceType<C> | null {
   return {
     [SchemaInit]: {
       ref: arg,

package/src/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts

@@ -0,0 +1,101 @@
+import z from "zod/v4";
+import { CoMap, CoValueClass, isCoValueClass } from "../../../internal.js";
+import { coField } from "../../schema.js";
+import {
+  isUnionOfCoMapsDeeply,
+  isUnionOfPrimitivesDeeply,
+  schemaUnionDiscriminatorFor,
+} from "../unionUtils.js";
+import { ZodPrimitiveSchema } from "../zodSchema.js";
+import { zodSchemaToCoSchemaOrKeepPrimitive } from "./zodSchemaToCoSchema.js";
+
+type FieldSchema =
+  | CoValueClass
+  | ZodPrimitiveSchema
+  | z.core.$ZodOptional<z.core.$ZodType>
+  | z.core.$ZodUnion<z.core.$ZodType[]>
+  | z.core.$ZodObject<z.core.$ZodLooseShape>
+  | z.core.$ZodArray<z.core.$ZodType>
+  | z.core.$ZodTuple<z.core.$ZodType[]>
+  | (z.core.$ZodCustom<any, any> & { builtin: any });
+
+export function zodFieldToCoFieldDef(schema: FieldSchema) {
+  if (isCoValueClass(schema)) {
+    return coField.ref(schema);
+  } else {
+    if ("_zod" in schema) {
+      if (schema._zod.def.type === "optional") {
+        const inner = zodSchemaToCoSchemaOrKeepPrimitive(
+          schema._zod.def.innerType,
+        );
+        if (isCoValueClass(inner)) {
+          return coField.ref(inner, { optional: true });
+        } else {
+          return zodFieldToCoFieldDef(inner);
+        }
+      } else if (schema._zod.def.type === "string") {
+        return coField.string;
+      } else if (schema._zod.def.type === "number") {
+        return coField.number;
+      } else if (schema._zod.def.type === "boolean") {
+        return coField.boolean;
+      } else if (schema._zod.def.type === "null") {
+        return coField.null;
+      } else if (schema._zod.def.type === "date") {
+        return coField.Date;
+      } else if (schema._zod.def.type === "literal") {
+        if (
+          schema._zod.def.values.some(
+            (literal) => typeof literal === "undefined",
+          )
+        ) {
+          throw new Error("z.literal() with undefined is not supported");
+        }
+        if (schema._zod.def.values.some((literal) => literal === null)) {
+          throw new Error("z.literal() with null is not supported");
+        }
+        if (
+          schema._zod.def.values.some((literal) => typeof literal === "bigint")
+        ) {
+          throw new Error("z.literal() with bigint is not supported");
+        }
+        return coField.literal(
+          ...(schema._zod.def.values as Exclude<
+            (typeof schema._zod.def.values)[number],
+            undefined | null | bigint
+          >[]),
+        );
+      } else if (
+        schema._zod.def.type === "object" ||
+        schema._zod.def.type === "array" ||
+        schema._zod.def.type === "tuple"
+      ) {
+        return coField.json();
+      } else if (schema._zod.def.type === "custom") {
+        if ("builtin" in schema) {
+          return zodFieldToCoFieldDef(schema.builtin);
+        } else {
+          throw new Error(`Unsupported custom zod type`);
+        }
+      } else if (schema._zod.def.type === "union") {
+        if (isUnionOfPrimitivesDeeply(schema)) {
+          return coField.json();
+        } else if (isUnionOfCoMapsDeeply(schema)) {
+          return coField.ref<CoValueClass<CoMap>>(
+            schemaUnionDiscriminatorFor(schema),
+          );
+        } else {
+          throw new Error(
+            "z.union()/z.discriminatedUnion() of mixed collaborative and non-collaborative types is not supported",
+          );
+        }
+      } else {
+        throw new Error(
+          `Unsupported zod type: ${(schema._zod?.def as any)?.type || JSON.stringify(schema)}`,
+        );
+      }
+    } else {
+      throw new Error(`Unsupported zod type: ${schema}`);
+    }
+  }
+}