jazz-tools 0.13.30 → 0.14.0

package/src/coValues/coPlainText.ts

@@ -14,6 +14,7 @@ import {
   Resolved,
   SubscribeListenerOptions,
   SubscribeRestArgs,
+  anySchemaToCoSchema,
   parseCoValueCreateOptions,
 } from "../internal.js";
 import {
@@ -46,7 +47,9 @@ export class CoPlainText extends String implements CoValue {
 
     if (agent instanceof ControlledAccount) {
       return coValuesCache.get(agent.account, () =>
-        RegisteredSchemas["Account"].fromRaw(agent.account),
+        anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
+          agent.account,
+        ),
       );
     }
 

package/src/coValues/deepLoading.ts

@@ -1,12 +1,11 @@
 import { SessionID } from "cojson";
-import { ItemsSym, UnCo } from "../internal.js";
+import { ItemsSym } from "../internal.js";
 import { type Account } from "./account.js";
 import { CoFeedEntry } from "./coFeed.js";
-import { type CoKeys } from "./coMap.js";
+import { type CoKeys, type CoMap } from "./coMap.js";
 import { type CoValue, type ID } from "./interfaces.js";
 
-type UnCoNotNull<T> = UnCo<Exclude<T, null>>;
-export type Clean<T> = UnCo<NonNullable<T>>;
+type NotNull<T> = Exclude<T, null>;
 
 export type RefsToResolve<
   V,
@@ -22,31 +21,33 @@ export type RefsToResolve<
         ?
             | {
                 $each: RefsToResolve<
-                  UnCoNotNull<Item>,
+                  NotNull<Item>,
                   DepthLimit,
                   [0, ...CurrentDepth]
                 >;
+                $onError?: null;
               }
             | boolean
         : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
           V extends { _type: "CoMap" | "Group" | "Account" }
           ?
-              | {
-                  [Key in CoKeys<V> as Clean<V[Key]> extends CoValue
+              | ({
+                  [Key in CoKeys<V> as NonNullable<V[Key]> extends CoValue
                     ? Key
                     : never]?: RefsToResolve<
-                    Clean<V[Key]>,
+                    NonNullable<V[Key]>,
                     DepthLimit,
                     [0, ...CurrentDepth]
                   >;
-                }
+                } & { $onError?: null })
               | (ItemsSym extends keyof V
                   ? {
                       $each: RefsToResolve<
-                        Clean<V[ItemsSym]>,
+                        NonNullable<V[ItemsSym]>,
                         DepthLimit,
                         [0, ...CurrentDepth]
                       >;
+                      $onError?: null;
                     }
                   : never)
               | boolean
@@ -57,10 +58,11 @@ export type RefsToResolve<
             ?
                 | {
                     $each: RefsToResolve<
-                      UnCoNotNull<Item>,
+                      NotNull<Item>,
                       DepthLimit,
                       [0, ...CurrentDepth]
                     >;
+                    $onError?: null;
                   }
                 | boolean
             : boolean);
@@ -69,12 +71,14 @@ export type RefsToResolveStrict<T, V> = V extends RefsToResolve<T>
   ? RefsToResolve<T>
   : V;
 
-export type Resolved<T, R extends RefsToResolve<T> | undefined> = DeeplyLoaded<
+export type Resolved<
   T,
-  R,
-  10,
-  []
->;
+  R extends RefsToResolve<T> | undefined = true,
+> = DeeplyLoaded<T, R, 10, []>;
+
+type onErrorNullEnabled<Depth> = Depth extends { $onError: null }
+  ? null
+  : never;
 
 export type DeeplyLoaded<
   V,
@@ -87,16 +91,19 @@ export type DeeplyLoaded<
     ? V
     : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
       [V] extends [Array<infer Item>]
-      ? UnCoNotNull<Item> extends CoValue
+      ? NotNull<Item> extends CoValue
         ? Depth extends { $each: infer ItemDepth }
           ? // Deeply loaded CoList
-            (UnCoNotNull<Item> &
-              DeeplyLoaded<
-                UnCoNotNull<Item>,
-                ItemDepth,
-                DepthLimit,
-                [0, ...CurrentDepth]
-              >)[] &
+            (
+              | (NotNull<Item> &
+                  DeeplyLoaded<
+                    NotNull<Item>,
+                    ItemDepth,
+                    DepthLimit,
+                    [0, ...CurrentDepth]
+                  >)
+              | onErrorNullEnabled<Depth["$each"]>
+            )[] &
               V // the CoList base type needs to be intersected after so that built-in methods return the correct narrowed array type
           : never
         : V
@@ -106,12 +113,14 @@ export type DeeplyLoaded<
           ? Depth extends { $each: infer ItemDepth }
             ? // Deeply loaded Record-like CoMap
               {
-                [key: string]: DeeplyLoaded<
-                  Clean<V[ItemsSym]>,
-                  ItemDepth,
-                  DepthLimit,
-                  [0, ...CurrentDepth]
-                >;
+                [key: string]:
+                  | DeeplyLoaded<
+                      NonNullable<V[ItemsSym]>,
+                      ItemDepth,
+                      DepthLimit,
+                      [0, ...CurrentDepth]
+                    >
+                  | onErrorNullEnabled<Depth["$each"]>;
               } & V // same reason as in CoList
             : never
           : keyof Depth extends never // Depth = {}
@@ -119,15 +128,16 @@ export type DeeplyLoaded<
             : // Deeply loaded CoMap
               {
                 -readonly [Key in keyof Depth]-?: Key extends CoKeys<V>
-                  ? Clean<V[Key]> extends CoValue
+                  ? NonNullable<V[Key]> extends CoValue
                     ?
                         | DeeplyLoaded<
-                            Clean<V[Key]>,
+                            NonNullable<V[Key]>,
                             Depth[Key],
                             DepthLimit,
                             [0, ...CurrentDepth]
                           >
                         | (undefined extends V[Key] ? undefined : never)
+                        | onErrorNullEnabled<Depth[Key]>
                     : never
                   : never;
               } & V // same reason as in CoList
@@ -139,12 +149,12 @@ export type DeeplyLoaded<
             ]
           ? // Deeply loaded CoStream
             {
-              byMe?: { value: UnCoNotNull<Item> };
-              inCurrentSession?: { value: UnCoNotNull<Item> };
+              byMe?: { value: NotNull<Item> };
+              inCurrentSession?: { value: NotNull<Item> };
               perSession: {
-                [key: SessionID]: { value: UnCoNotNull<Item> };
+                [key: SessionID]: { value: NotNull<Item> };
               };
-            } & { [key: ID<Account>]: { value: UnCoNotNull<Item> } } & V // same reason as in CoList
+            } & { [key: ID<Account>]: { value: NotNull<Item> } } & V // same reason as in CoList
           : [V] extends [
                 {
                   _type: "BinaryCoStream";

package/src/coValues/extensions/imageDef.ts

@@ -1,20 +1,22 @@
-import { co } from "../../internal.js";
-import { FileStream } from "../coFeed.js";
-import { CoMap } from "../coMap.js";
+import z from "zod/v4";
+import { Loaded, coFileStreamDefiner, coMapDefiner } from "../../internal.js";
+
+// avoiding circularity by using the standalone definers instead of `co`
+const ImageDefinitionBase = coMapDefiner({
+  originalSize: z.tuple([z.number(), z.number()]),
+  placeholderDataURL: z.string().optional(),
+}).catchall(coFileStreamDefiner());
 
 /** @category Media */
-export class ImageDefinition extends CoMap {
-  originalSize = co.json<[number, number]>();
-  placeholderDataURL? = co.string;
-
-  [co.items] = co.ref(FileStream);
-  [res: `${number}x${number}`]: co<FileStream | null>;
-
-  highestResAvailable(options?: {
-    maxWidth?: number;
-    targetWidth?: number;
-  }): { res: `${number}x${number}`; stream: FileStream } | undefined {
-    const resolutions = Object.keys(this).filter((key) =>
+export const ImageDefinition = ImageDefinitionBase.withHelpers((Self) => ({
+  highestResAvailable(
+    imageDef: Loaded<typeof Self>,
+    options?: {
+      maxWidth?: number;
+      targetWidth?: number;
+    },
+  ) {
+    const resolutions = Object.keys(imageDef).filter((key) =>
       key.match(/^\d+x\d+$/),
     ) as `${number}x${number}`[];
 
@@ -41,7 +43,7 @@ export class ImageDefinition extends CoMap {
     let highestAvailableResolution: `${number}x${number}` | undefined;
 
     for (const resolution of validResolutions) {
-      if (this[resolution] && this[resolution]?.getChunks()) {
+      if (imageDef[resolution] && imageDef[resolution]?.getChunks()) {
         highestAvailableResolution = resolution;
       }
     }
@@ -50,8 +52,8 @@ export class ImageDefinition extends CoMap {
     return (
       highestAvailableResolution && {
         res: highestAvailableResolution,
-        stream: this[highestAvailableResolution]!,
+        stream: imageDef[highestAvailableResolution]!,
       }
     );
-  }
-}
+  },
+}));

package/src/coValues/group.ts

@@ -6,11 +6,13 @@ import type {
   RawGroup,
   Role,
 } from "cojson";
-import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import type {
+  AnyAccountSchema,
+  CoMap,
   CoValue,
   CoValueClass,
   ID,
+  InstanceOfSchema,
   RefEncoded,
   RefsToResolve,
   RefsToResolveStrict,
@@ -20,23 +22,23 @@ import type {
   SubscribeRestArgs,
 } from "../internal.js";
 import {
+  Account,
+  AccountAndGroupProxyHandler,
   CoValueBase,
+  Profile,
   Ref,
+  RegisteredSchemas,
   accessChildById,
-  co,
+  activeAccountContext,
+  anySchemaToCoSchema,
   ensureCoValueLoaded,
+  isControlledAccount,
   loadCoValueWithoutMe,
   parseGroupCreateOptions,
   parseSubscribeRestArgs,
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
-import { RegisteredAccount } from "../types.js";
-import { AccountAndGroupProxyHandler, isControlledAccount } from "./account.js";
-import { type Account } from "./account.js";
-import { type CoMap } from "./coMap.js";
-import { type Profile } from "./profile.js";
-import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /** @category Identity & Permissions */
 export class Group extends CoValueBase implements CoValue {
@@ -80,26 +82,26 @@ export class Group extends CoValueBase implements CoValue {
       | ID<NonNullable<this["root"]>>
       | undefined;
     return {
-      profile:
-        profileID &&
-        (new Ref(
-          profileID,
-          this._loadedAs,
-          this._schema.profile as RefEncoded<NonNullable<this["profile"]>>,
-          this,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ) as any as this["profile"] extends Profile
-          ? Ref<this["profile"]>
-          : never),
-      root:
-        rootID &&
-        (new Ref(
-          rootID,
-          this._loadedAs,
-          this._schema.root as RefEncoded<NonNullable<this["root"]>>,
-          this,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ) as any as this["root"] extends CoMap ? Ref<this["root"]> : never),
+      profile: profileID
+        ? (new Ref(
+            profileID,
+            this._loadedAs,
+            this._schema.profile as RefEncoded<NonNullable<this["profile"]>>,
+            this,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ) as any as this["profile"] extends Profile
+            ? Ref<this["profile"]>
+            : never)
+        : undefined,
+      root: rootID
+        ? (new Ref(
+            rootID,
+            this._loadedAs,
+            this._schema.root as RefEncoded<NonNullable<this["root"]>>,
+            this,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ) as any as this["root"] extends CoMap ? Ref<this["root"]> : never)
+        : undefined,
     };
   }
 
@@ -154,20 +156,17 @@ export class Group extends CoValueBase implements CoValue {
   }
 
   get members(): Array<{
-    id: ID<RegisteredAccount>;
+    id: string;
     role: AccountRole;
-    ref: Ref<RegisteredAccount>;
-    account: RegisteredAccount;
+    ref: Ref<Account>;
+    account: Account;
   }> {
     const members = [];
 
-    const BaseAccountSchema =
-      (activeAccountContext.maybeGet()?.constructor as typeof Account) ||
-      RegisteredSchemas["Account"];
     const refEncodedAccountSchema = {
-      ref: () => BaseAccountSchema,
+      ref: () => Account,
       optional: false,
-    } satisfies RefEncoded<RegisteredAccount>;
+    } satisfies RefEncoded<Account>;
 
     for (const accountID of this._raw.getAllMemberKeysSet()) {
       if (!isAccountID(accountID)) continue;
@@ -180,8 +179,8 @@ export class Group extends CoValueBase implements CoValue {
         role === "reader" ||
         role === "writeOnly"
       ) {
-        const ref = new Ref<RegisteredAccount>(
-          accountID as unknown as ID<RegisteredAccount>,
+        const ref = new Ref<Account>(
+          accountID,
           this._loadedAs,
           refEncodedAccountSchema,
           this,

package/src/coValues/inbox.ts

@@ -1,8 +1,17 @@
 import { CoID, InviteSecret, RawAccount, RawCoMap, SessionID } from "cojson";
 import { CoStreamItem, RawCoStream } from "cojson";
-import { activeAccountContext } from "../implementation/activeAccountContext.js";
-import { type Account } from "./account.js";
-import { CoValue, CoValueClass, ID, loadCoValue } from "./interfaces.js";
+import {
+  type Account,
+  CoValue,
+  CoValueClass,
+  CoValueOrZodSchema,
+  ID,
+  InstanceOfSchema,
+  activeAccountContext,
+  anySchemaToCoSchema,
+  loadCoValue,
+  zodSchemaToCoSchema,
+} from "../internal.js";
 
 export type InboxInvite = `${CoID<MessagesStream>}/${InviteSecret}`;
 type TxKey = `${SessionID}/${number}`;
@@ -101,10 +110,10 @@ export class Inbox {
     this.failed = failed;
   }
 
-  subscribe<I extends CoValue, O extends CoValue | undefined>(
-    Schema: CoValueClass<I>,
+  subscribe<M extends CoValueOrZodSchema, O extends CoValue | undefined>(
+    Schema: M,
     callback: (
-      message: I,
+      message: InstanceOfSchema<M>,
       senderAccountID: ID<Account>,
     ) => Promise<O | undefined | void>,
     options: { retries?: number } = {},
@@ -137,7 +146,7 @@ export class Inbox {
 
       for (const [sessionID, items] of Object.entries(stream.items) as [
         SessionID,
-        CoStreamItem<CoID<InboxMessage<I, O>>>[],
+        CoStreamItem<CoID<InboxMessage<InstanceOfSchema<M>, O>>>[],
       ][]) {
         const accountID = getAccountIDfromSessionID(sessionID);
 
@@ -163,9 +172,13 @@ export class Inbox {
                   );
                 }
 
-                return loadCoValue(Schema, message.get("payload") as ID<I>, {
-                  loadAs: account,
-                });
+                return loadCoValue(
+                  anySchemaToCoSchema(Schema),
+                  message.get("payload")!,
+                  {
+                    loadAs: account,
+                  },
+                );
               })
               .then((value) => {
                 if (!value) {
@@ -174,7 +187,7 @@ export class Inbox {
                   );
                 }
 
-                return callback(value, accountID);
+                return callback(value as InstanceOfSchema<M>, accountID);
               })
               .then((result) => {
                 const inboxMessage = node

package/src/coValues/interfaces.ts

@@ -1,19 +1,22 @@
-import type {
-  CoValueUniqueness,
-  CojsonInternalTypes,
-  RawCoValue,
-} from "cojson";
-import { ControlledAccount, RawAccount } from "cojson";
-import { activeAccountContext } from "../implementation/activeAccountContext.js";
-import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
-import { inspect } from "../internal.js";
-import { coValuesCache } from "../lib/cache.js";
-import { SubscriptionScope } from "../subscribe/SubscriptionScope.js";
-import { SubscriptionValue } from "../subscribe/types.js";
-import { type Account } from "./account.js";
-import { RefsToResolve, RefsToResolveStrict, Resolved } from "./deepLoading.js";
-import { type Group } from "./group.js";
-import { RegisteredSchemas } from "./registeredSchemas.js";
+import type { CoValueUniqueness, RawCoValue } from "cojson";
+import {
+  type Account,
+  AnonymousJazzAgent,
+  CoValueOrZodSchema,
+  type Group,
+  Loaded,
+  RefsToResolve,
+  RefsToResolveStrict,
+  RegisteredSchemas,
+  ResolveQuery,
+  ResolveQueryStrict,
+  Resolved,
+  SubscriptionScope,
+  type SubscriptionValue,
+  activeAccountContext,
+  anySchemaToCoSchema,
+  inspect,
+} from "../internal.js";
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -76,74 +79,7 @@ export function isCoValueClass<V extends CoValue>(
  *
  * @category CoValues
  */
-export type ID<T> = CojsonInternalTypes.RawCoID & IDMarker<T>;
-
-type IDMarker<out T> = { __type(_: never): T };
-
-/** @internal */
-export class CoValueBase implements CoValue {
-  declare id: ID<this>;
-  declare _type: string;
-  declare _raw: RawCoValue;
-  /** @category Internals */
-  declare _instanceID: string;
-
-  get _owner(): Account | Group {
-    const owner = coValuesCache.get(this._raw.group, () =>
-      this._raw.group instanceof RawAccount
-        ? RegisteredSchemas["Account"].fromRaw(this._raw.group)
-        : RegisteredSchemas["Group"].fromRaw(this._raw.group),
-    );
-
-    return owner;
-  }
-
-  /** @private */
-  get _loadedAs() {
-    const agent = this._raw.core.node.getCurrentAgent();
-
-    if (agent instanceof ControlledAccount) {
-      return coValuesCache.get(agent.account, () =>
-        RegisteredSchemas["Account"].fromRaw(agent.account),
-      );
-    }
-
-    return new AnonymousJazzAgent(this._raw.core.node);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(..._args: any) {
-    Object.defineProperty(this, "_instanceID", {
-      value: `instance-${Math.random().toString(36).slice(2)}`,
-      enumerable: false,
-    });
-  }
-
-  /** @category Internals */
-  static fromRaw<V extends CoValue>(this: CoValueClass<V>, raw: RawCoValue): V {
-    return new this({ fromRaw: raw });
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  toJSON(): object | any[] | string {
-    return {
-      id: this.id,
-      type: this._type,
-      error: "unknown CoValue class",
-    };
-  }
-
-  [inspect]() {
-    return this.toJSON();
-  }
-
-  /** @category Type Helpers */
-  castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
-    cl: Cl,
-  ): InstanceType<Cl> {
-    return cl.fromRaw(this._raw) as InstanceType<Cl>;
-  }
-}
+export type ID<T> = string;
 
 export function loadCoValueWithoutMe<
   V extends CoValue,
@@ -359,18 +295,18 @@ export function subscribeToCoValue<
 }
 
 export function createCoValueObservable<
-  V extends CoValue,
-  const R extends RefsToResolve<V>,
+  S extends CoValueOrZodSchema,
+  const R extends ResolveQuery<S>,
 >(initialValue: undefined | null = undefined) {
-  let currentValue: Resolved<V, R> | undefined | null = initialValue;
+  let currentValue: Loaded<S, R> | undefined | null = initialValue;
   let subscriberCount = 0;
 
   function subscribe(
-    cls: CoValueClass<V>,
-    id: ID<CoValue>,
+    cls: S,
+    id: string,
     options: {
       loadAs: Account | AnonymousJazzAgent;
-      resolve?: RefsToResolveStrict<V, R>;
+      resolve?: ResolveQueryStrict<S, R>;
       onUnavailable?: () => void;
       onUnauthorized?: () => void;
       syncResolution?: boolean;
@@ -380,11 +316,11 @@ export function createCoValueObservable<
     subscriberCount++;
 
     const unsubscribe = subscribeToCoValue(
-      cls,
+      anySchemaToCoSchema(cls),
       id,
       {
         loadAs: options.loadAs,
-        resolve: options.resolve,
+        resolve: options.resolve as any,
         onUnavailable: () => {
           currentValue = null;
           options.onUnavailable?.();
@@ -396,7 +332,7 @@ export function createCoValueObservable<
         syncResolution: options.syncResolution,
       },
       (value) => {
-        currentValue = value;
+        currentValue = value as Loaded<S, R>;
         listener();
       },
     );

package/src/coValues/profile.ts

@@ -1,19 +1,18 @@
-import { CoID } from "cojson";
-import { CoValueClass, co } from "../internal.js";
-import { Account } from "./account.js";
-import { CoMap, CoMapInit, Simplify } from "./coMap.js";
-import { Group } from "./group.js";
-import { InboxInvite, InboxRoot } from "./inbox.js";
+import {
+  Account,
+  CoMap,
+  CoMapInit,
+  CoValueClass,
+  Group,
+  Simplify,
+  coField,
+} from "../internal.js";
 
 /** @category Identity & Permissions */
 export class Profile extends CoMap {
-  name = co.string;
-  inbox = co.optional.json<CoID<InboxRoot>>();
-  inboxInvite = co.optional.json<InboxInvite>();
-
-  override get _owner(): Group {
-    return super._owner as Group;
-  }
+  name = coField.string;
+  inbox? = coField.optional.string;
+  inboxInvite? = coField.optional.string;
 
   /**
    * Creates a new profile with the given initial values and owner.

package/src/coValues/registeredSchemas.ts

@@ -1,6 +1,4 @@
-import type { Account } from "./account.js";
-import type { CoMap } from "./coMap.js";
-import type { Group } from "./group.js";
+import type { Account, CoMap, Group } from "../internal.js";
 
 /**
  * Regisering schemas into this Record to avoid circular dependencies.

package/src/coValues/schemaUnion.ts

@@ -15,18 +15,18 @@ import {
  * import { SchemaUnion, CoMap } from "jazz-tools";
  *
  * class BaseWidget extends CoMap {
- *   type = co.string;
+ *   type = coField.string;
  * }
  *
  * class ButtonWidget extends BaseWidget {
- *   type = co.literal("button");
- *   label = co.string;
+ *   type = coField.literal("button");
+ *   label = coField.string;
  * }
  *
  * class SliderWidget extends BaseWidget {
- *   type = co.literal("slider");
- *   min = co.number;
- *   max = co.number;
+ *   type = coField.literal("slider");
+ *   min = coField.number;
+ *   max = coField.number;
  * }
  *
  * const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {