jazz-tools 0.13.31 → 0.14.0

package/src/coValues/coFeed.ts

@@ -12,10 +12,12 @@ import type {
 import { MAX_RECOMMENDED_TX_SIZE, cojsonInternals } from "cojson";
 import type {
   AnonymousJazzAgent,
+  AnyAccountSchema,
   CoValue,
   CoValueClass,
+  Group,
   ID,
-  IfCo,
+  InstanceOfSchema,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -23,15 +25,17 @@ import type {
   SchemaFor,
   SubscribeListenerOptions,
   SubscribeRestArgs,
-  UnCo,
 } from "../internal.js";
 import {
+  Account,
   CoValueBase,
   ItemsSym,
   Ref,
+  RegisteredSchemas,
   SchemaInit,
   accessChildById,
-  co,
+  anySchemaToCoSchema,
+  coField,
   ensureCoValueLoaded,
   inspect,
   isRefEncoded,
@@ -41,10 +45,6 @@ import {
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
-import { RegisteredAccount } from "../types.js";
-import { type Account } from "./account.js";
-import { type Group } from "./group.js";
-import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /** @deprecated Use CoFeedEntry instead */
 export type CoStreamEntry<Item> = CoFeedEntry<Item>;
@@ -59,7 +59,7 @@ export type SingleCoStreamEntry<Item> = SingleCoFeedEntry<Item>;
 export type SingleCoFeedEntry<Item> = {
   value: NonNullable<Item> extends CoValue ? NonNullable<Item> | null : Item;
   ref: NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never;
-  by?: RegisteredAccount | null;
+  by: Account | null;
   madeAt: Date;
   tx: CojsonInternalTypes.TransactionID;
 };
@@ -83,22 +83,27 @@ export { CoFeed as CoStream };
  *
  * @category CoValues
  */
-export class CoFeed<Item = any> extends CoValueBase implements CoValue {
+export class CoFeed<out Item = any> extends CoValueBase implements CoValue {
   /**
-   * Declare a `CoFeed` by subclassing `CoFeed.Of(...)` and passing the item schema using a `co` primitive or a `co.ref`.
+   * Declare a `CoFeed` by subclassing `CoFeed.Of(...)` and passing the item schema using a `co` primitive or a `coField.ref`.
    *
    * @example
    * ```ts
-   * class ColorFeed extends CoFeed.Of(co.string) {}
-   * class AnimalFeed extends CoFeed.Of(co.ref(Animal)) {}
+   * class ColorFeed extends CoFeed.Of(coField.string) {}
+   * class AnimalFeed extends CoFeed.Of(coField.ref(Animal)) {}
    * ```
    *
    * @category Declaration
    */
-  static Of<Item>(item: IfCo<Item, Item>): typeof CoFeed<Item> {
-    return class CoFeedOf extends CoFeed<Item> {
-      [co.items] = item;
+  static Of<Item>(item: Item): typeof CoFeed<Item> {
+    const cls = class CoFeedOf extends CoFeed<Item> {
+      [coField.items] = item;
     };
+
+    cls._schema ||= {};
+    cls._schema[ItemsSym] = (item as any)[SchemaInit];
+
+    return cls;
   }
 
   /**
@@ -120,10 +125,21 @@ export class CoFeed<Item = any> extends CoValueBase implements CoValue {
   static _schema: any;
   /** @internal */
   get _schema(): {
-    [ItemsSym]: SchemaFor<Item>;
+    [ItemsSym]: SchemaFor<Item> | any;
   } {
     return (this.constructor as typeof CoFeed)._schema;
   }
+  /**
+   * The current account's view of this `CoFeed`
+   * @category Content
+   */
+  get byMe(): CoFeedEntry<Item> | undefined {
+    if (this._loadedAs._type === "Account") {
+      return this.perAccount[this._loadedAs.id];
+    } else {
+      return undefined;
+    }
+  }
 
   /**
    * The per-account view of this `CoFeed`
@@ -147,27 +163,24 @@ export class CoFeed<Item = any> extends CoValueBase implements CoValue {
    *
    * @category Content
    */
-  [key: ID<Account>]: CoFeedEntry<Item>;
-
-  /**
-   * The current account's view of this `CoFeed`
-   * @category Content
-   */
-  get byMe(): CoFeedEntry<Item> | undefined {
-    if (this._loadedAs._type === "Account") {
-      return this[this._loadedAs.id];
-    } else {
-      return undefined;
-    }
+  get perAccount(): {
+    [key: ID<Account>]: CoFeedEntry<Item>;
+  } {
+    return new Proxy({}, CoStreamPerAccountProxyHandler(this)) as any;
   }
 
   /**
    * The per-session view of this `CoFeed`
    * @category Content
    */
-  perSession!: {
+  get perSession(): {
     [key: SessionID]: CoFeedEntry<Item>;
-  };
+  } {
+    return new Proxy(
+      {},
+      CoStreamPerSessionProxyHandler(this, this) as any,
+    ) as any;
+  }
 
   /**
    * The current session's view of this `CoFeed`
@@ -201,7 +214,7 @@ export class CoFeed<Item = any> extends CoValueBase implements CoValue {
       });
     }
 
-    return new Proxy(this, CoStreamProxyHandler as ProxyHandler<this>);
+    return this;
   }
 
   /**
@@ -210,7 +223,7 @@ export class CoFeed<Item = any> extends CoValueBase implements CoValue {
    */
   static create<S extends CoFeed>(
     this: CoValueClass<S>,
-    init: S extends CoFeed<infer Item> ? UnCo<Item>[] : never,
+    init: S extends CoFeed<infer Item> ? Item[] : never,
     options?: { owner: Account | Group } | Account | Group,
   ) {
     const { owner } = parseCoValueCreateOptions(options);
@@ -471,7 +484,7 @@ function entryFromRawEntry<Item>(
       return (
         accountID &&
         accessChildById(accessFrom, accountID, {
-          ref: RegisteredSchemas["Account"],
+          ref: Account,
           optional: false,
         })
       );
@@ -485,23 +498,25 @@ function entryFromRawEntry<Item>(
  * The proxy handler for `CoFeed` instances
  * @internal
  */
-export const CoStreamProxyHandler: ProxyHandler<CoFeed> = {
-  get(target, key, receiver) {
+export const CoStreamPerAccountProxyHandler = (
+  innerTarget: CoFeed,
+): ProxyHandler<{}> => ({
+  get(_target, key, receiver) {
     if (typeof key === "string" && key.startsWith("co_")) {
-      const rawEntry = target._raw.lastItemBy(key as RawAccountID);
+      const rawEntry = innerTarget._raw.lastItemBy(key as RawAccountID);
 
       if (!rawEntry) return;
       const entry = entryFromRawEntry(
         receiver,
         rawEntry,
-        target._loadedAs,
+        innerTarget._loadedAs,
         key as unknown as ID<Account>,
-        target._schema[ItemsSym],
+        innerTarget._schema[ItemsSym],
       );
 
       Object.defineProperty(entry, "all", {
         get: () => {
-          const allRawEntries = target._raw.itemsBy(key as RawAccountID);
+          const allRawEntries = innerTarget._raw.itemsBy(key as RawAccountID);
           return (function* () {
             while (true) {
               const rawEntry = allRawEntries.next();
@@ -509,9 +524,9 @@ export const CoStreamProxyHandler: ProxyHandler<CoFeed> = {
               yield entryFromRawEntry(
                 receiver,
                 rawEntry.value,
-                target._loadedAs,
+                innerTarget._loadedAs,
                 key as unknown as ID<Account>,
-                target._schema[ItemsSym],
+                innerTarget._schema[ItemsSym],
               );
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -520,47 +535,14 @@ export const CoStreamProxyHandler: ProxyHandler<CoFeed> = {
       });
 
       return entry;
-    } else if (key === "perSession") {
-      return new Proxy({}, CoStreamPerSessionProxyHandler(target, receiver));
-    } else {
-      return Reflect.get(target, key, receiver);
-    }
-  },
-  set(target, key, value, receiver) {
-    if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
-      (target.constructor as typeof CoFeed)._schema ||= {};
-      (target.constructor as typeof CoFeed)._schema[ItemsSym] =
-        value[SchemaInit];
-      return true;
     } else {
-      return Reflect.set(target, key, value, receiver);
+      return Reflect.get(innerTarget, key, receiver);
     }
   },
-  defineProperty(target, key, descriptor) {
-    if (
-      descriptor.value &&
-      key === ItemsSym &&
-      typeof descriptor.value === "object" &&
-      SchemaInit in descriptor.value
-    ) {
-      (target.constructor as typeof CoFeed)._schema ||= {};
-      (target.constructor as typeof CoFeed)._schema[ItemsSym] =
-        descriptor.value[SchemaInit];
-      return true;
-    } else {
-      return Reflect.defineProperty(target, key, descriptor);
-    }
+  ownKeys(_target) {
+    return Array.from(innerTarget._raw.accounts());
   },
-  ownKeys(target) {
-    const keys = Reflect.ownKeys(target);
-
-    for (const accountID of target._raw.accounts()) {
-      keys.push(accountID);
-    }
-
-    return keys;
-  },
-  getOwnPropertyDescriptor(target, key) {
+  getOwnPropertyDescriptor(_target, key) {
     if (typeof key === "string" && key.startsWith("co_")) {
       return {
         configurable: true,
@@ -568,10 +550,10 @@ export const CoStreamProxyHandler: ProxyHandler<CoFeed> = {
         writable: false,
       };
     } else {
-      return Reflect.getOwnPropertyDescriptor(target, key);
+      return Reflect.getOwnPropertyDescriptor(innerTarget, key);
     }
   },
-};
+});
 
 /**
  * The proxy handler for the per-session view of a `CoFeed`
@@ -652,10 +634,10 @@ export { FileStream as BinaryCoStream };
  * `FileStream` can be referenced in schemas.
  *
  * ```ts
- * import { co, FileStream } from "jazz-tools";
+ * import { coField, FileStream } from "jazz-tools";
  *
  * class MyCoMap extends CoMap {
- *   file = co.ref(FileStream);
+ *   file = coField.ref(FileStream);
  * }
  * ```
  *
@@ -817,7 +799,7 @@ export class FileStream extends CoValueBase implements CoValue {
    *
    * @example
    * ```ts
-   * import { co, FileStream } from "jazz-tools";
+   * import { coField, FileStream } from "jazz-tools";
    *
    * const fileStream = await FileStream.createFromBlob(file, {owner: group})
    * ```

package/src/coValues/coList.ts

@@ -2,10 +2,14 @@ import type { JsonValue, RawCoList } from "cojson";
 import { ControlledAccount, RawAccount } from "cojson";
 import { calcPatch } from "fast-myers-diff";
 import type {
+  Account,
+  AnyAccountSchema,
   CoValue,
   CoValueClass,
   CoValueFromRaw,
+  Group,
   ID,
+  InstanceOfSchema,
   RefEncoded,
   RefsToResolve,
   RefsToResolveStrict,
@@ -14,15 +18,17 @@ import type {
   SchemaFor,
   SubscribeListenerOptions,
   SubscribeRestArgs,
-  UnCo,
 } from "../internal.js";
 import {
   AnonymousJazzAgent,
   ItemsSym,
   Ref,
+  RegisteredSchemas,
   SchemaInit,
   accessChildByKey,
-  co,
+  anySchemaToCoSchema,
+  coField,
+  coValuesCache,
   ensureCoValueLoaded,
   inspect,
   isRefEncoded,
@@ -33,11 +39,6 @@ import {
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
-import { coValuesCache } from "../lib/cache.js";
-import { RegisteredAccount } from "../types.js";
-import { type Account } from "./account.js";
-import { type Group } from "./group.js";
-import { RegisteredSchemas } from "./registeredSchemas.js";
 
 /**
  * CoLists are collaborative versions of plain arrays.
@@ -57,17 +58,17 @@ import { RegisteredSchemas } from "./registeredSchemas.js";
  * @category CoValues
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class CoList<Item = any> extends Array<Item> implements CoValue {
+export class CoList<out Item = any> extends Array<Item> implements CoValue {
   /**
    * Declare a `CoList` by subclassing `CoList.Of(...)` and passing the item schema using `co`.
    *
    * @example
    * ```ts
    * class ColorList extends CoList.Of(
-   *   co.string
+   *   coField.string
    * ) {}
    * class AnimalList extends CoList.Of(
-   *   co.ref(Animal)
+   *   coField.ref(Animal)
    * ) {}
    * ```
    *
@@ -76,7 +77,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
   static Of<Item>(item: Item): typeof CoList<Item> {
     // TODO: cache superclass for item class
     return class CoListOf extends CoList<Item> {
-      [co.items] = item;
+      [coField.items] = item;
     };
   }
 
@@ -108,7 +109,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
   static _schema: any;
   /** @internal */
   get _schema(): {
-    [ItemsSym]: SchemaFor<Item>;
+    [ItemsSym]: SchemaFor<Item> | any;
   } {
     return (this.constructor as typeof CoList)._schema;
   }
@@ -116,12 +117,14 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
   /** @category Collaboration */
   get _owner(): Account | Group {
     return this._raw.group instanceof RawAccount
-      ? RegisteredSchemas["Account"].fromRaw(this._raw.group)
+      ? anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
+          this._raw.group,
+        )
       : RegisteredSchemas["Group"].fromRaw(this._raw.group);
   }
 
   /**
-   * If a `CoList`'s items are a `co.ref(...)`, you can use `coList._refs[i]` to access
+   * If a `CoList`'s items are a `coField.ref(...)`, you can use `coList._refs[i]` to access
    * the `Ref` instead of the potentially loaded/null value.
    *
    * This allows you to always get the ID or load the value manually.
@@ -138,7 +141,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
    **/
   get _refs(): {
     [idx: number]: Exclude<Item, null> extends CoValue
-      ? Ref<UnCo<Exclude<Item, null>>>
+      ? Ref<Exclude<Item, null>>
       : never;
   } & {
     length: number;
@@ -160,7 +163,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
     [idx: number]: {
       value?: Item;
       ref?: Item extends CoValue ? Ref<Item> : never;
-      by?: RegisteredAccount;
+      by: Account | null;
       madeAt: Date;
     };
   } {
@@ -172,7 +175,9 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
 
     if (agent instanceof ControlledAccount) {
       return coValuesCache.get(agent.account, () =>
-        RegisteredSchemas["Account"].fromRaw(agent.account),
+        anySchemaToCoSchema(RegisteredSchemas["Account"]).fromRaw(
+          agent.account,
+        ),
       );
     }
 
@@ -231,7 +236,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
    **/
   static create<L extends CoList>(
     this: CoValueClass<L>,
-    items: UnCo<L[number]>[],
+    items: L[number][],
     options?: { owner: Account | Group } | Account | Group,
   ) {
     const { owner } = parseCoValueCreateOptions(options);
@@ -580,7 +585,7 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
           ? undefined
           : itemDescriptor.encoded.decode(rawValue);
       } else if (isRefEncoded(itemDescriptor)) {
-        return rawValue === undefined
+        return rawValue === undefined || rawValue === null
           ? undefined
           : accessChildByKey(target, rawValue as string, key);
       }
@@ -605,11 +610,13 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
       } else if ("encoded" in itemDescriptor) {
         rawValue = itemDescriptor.encoded.encode(value);
       } else if (isRefEncoded(itemDescriptor)) {
-        if (value === null) {
+        if (value === undefined) {
           if (itemDescriptor.optional) {
             rawValue = null;
           } else {
-            throw new Error(`Cannot set required reference ${key} to null`);
+            throw new Error(
+              `Cannot set required reference ${key} to undefined`,
+            );
           }
         } else if (value?.id) {
           rawValue = value.id;

package/src/coValues/coMap.ts

@@ -4,16 +4,18 @@ import {
   CojsonInternalTypes,
   type JsonValue,
   RawAccountID,
+  RawCoID,
   type RawCoMap,
   cojsonInternals,
 } from "cojson";
-import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import type {
   AnonymousJazzAgent,
+  AnyAccountSchema,
   CoValue,
   CoValueClass,
+  Group,
   ID,
-  IfCo,
+  InstanceOfSchema,
   RefEncoded,
   RefIfCoValue,
   RefsToResolve,
@@ -22,15 +24,18 @@ import type {
   Schema,
   SubscribeListenerOptions,
   SubscribeRestArgs,
-  co,
 } from "../internal.js";
 import {
+  Account,
   CoValueBase,
   ItemsSym,
   Ref,
+  RegisteredSchemas,
   SchemaInit,
   accessChildById,
   accessChildByKey,
+  activeAccountContext,
+  anySchemaToCoSchema,
   ensureCoValueLoaded,
   inspect,
   isRefEncoded,
@@ -41,15 +46,11 @@ import {
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
-import { RegisteredAccount } from "../types.js";
-import { type Account } from "./account.js";
-import { type Group } from "./group.js";
-import { RegisteredSchemas } from "./registeredSchemas.js";
 
 type CoMapEdit<V> = {
   value?: V;
   ref?: RefIfCoValue<V>;
-  by?: RegisteredAccount;
+  by: Account | null;
   madeAt: Date;
   key?: string;
 };
@@ -68,16 +69,16 @@ export type Simplify<A> = {
  * @categoryDescription Declaration
  * Declare your own CoMap schemas by subclassing `CoMap` and assigning field schemas with `co`.
  *
- * Optional `co.ref(...)` fields must be marked with `{ optional: true }`.
+ * Optional `coField.ref(...)` fields must be marked with `{ optional: true }`.
  *
  * ```ts
- * import { co, CoMap } from "jazz-tools";
+ * import { coField, CoMap } from "jazz-tools";
  *
  * class Person extends CoMap {
- *   name = co.string;
- *   age = co.number;
- *   pet = co.ref(Animal);
- *   car = co.ref(Car, { optional: true });
+ *   name = coField.string;
+ *   age = coField.number;
+ *   pet = coField.ref(Animal);
+ *   car = coField.ref(Car, { optional: true });
  * }
  * ```
  *
@@ -119,7 +120,7 @@ export class CoMap extends CoValueBase implements CoValue {
   }
 
   /**
-   * If property `prop` is a `co.ref(...)`, you can use `coMaps._refs.prop` to access
+   * If property `prop` is a `coField.ref(...)`, you can use `coMaps._refs.prop` to access
    * the `Ref` instead of the potentially loaded/null value.
    *
    * This allows you to always get the ID or load the value manually.
@@ -134,9 +135,19 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @category Content
    **/
-  get _refs(): {
-    [Key in CoKeys<this>]: IfCo<this[Key], RefIfCoValue<this[Key]>>;
-  } {
+  get _refs(): Simplify<
+    {
+      [Key in CoKeys<this> as NonNullable<this[Key]> extends CoValue
+        ? Key
+        : never]?: RefIfCoValue<this[Key]>;
+    } & {
+      [Key in CoKeys<this> as this[Key] extends undefined
+        ? never
+        : this[Key] extends CoValue
+          ? Key
+          : never]: RefIfCoValue<this[Key]>;
+    }
+  > {
     return makeRefs<CoKeys<this>>(
       this,
       (key) => this._raw.get(key as string) as unknown as ID<CoValue>,
@@ -186,12 +197,15 @@ export class CoMap extends CoValueBase implements CoValue {
               target,
             )
           : undefined,
-      by:
-        rawEdit.by &&
-        accessChildById(target, rawEdit.by, {
-          ref: RegisteredSchemas["Account"],
-          optional: false,
-        }),
+      get by() {
+        return (
+          rawEdit.by &&
+          accessChildById(target, rawEdit.by, {
+            ref: Account,
+            optional: false,
+          })
+        );
+      },
       madeAt: rawEdit.at,
       key,
     };
@@ -233,7 +247,7 @@ export class CoMap extends CoValueBase implements CoValue {
         },
       },
     ) as {
-      [Key in CoKeys<this>]: IfCo<this[Key], LastAndAllCoMapEdits<this[Key]>>;
+      [Key in CoKeys<this>]?: LastAndAllCoMapEdits<this[Key]>;
     };
   }
 
@@ -413,10 +427,10 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @example
    * ```ts
-   * import { co, CoMap } from "jazz-tools";
+   * import { coField, CoMap } from "jazz-tools";
    *
    * class ColorToFruitMap extends CoMap.Record(
-   *  co.ref(Fruit)
+   *  coField.ref(Fruit)
    * ) {}
    *
    * // assume we have map: ColorToFruitMap
@@ -426,7 +440,7 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @category Declaration
    */
-  static Record<Value>(value: IfCo<Value, Value>) {
+  static Record<Value>(value: Value) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
     class RecordLikeCoMap extends CoMap {
       [ItemsSym] = value;
@@ -527,7 +541,7 @@ export class CoMap extends CoValueBase implements CoValue {
       type: "comap" as const,
       ruleset: {
         type: "ownedByGroup" as const,
-        group: ownerID,
+        group: ownerID as RawCoID,
       },
       meta: null,
       uniqueness: unique,
@@ -625,8 +639,8 @@ export type CoKeys<Map extends object> = Exclude<
  * Force required ref fields to be non nullable
  *
  * Considering that:
- * - Optional refs are typed as co<InstanceType<CoValueClass> | null | undefined>
- * - Required refs are typed as co<InstanceType<CoValueClass> | null>
+ * - Optional refs are typed as coField<InstanceType<CoValueClass> | null | undefined>
+ * - Required refs are typed as coField<InstanceType<CoValueClass> | null>
  *
  * This type works in two steps:
  * - Remove the null from both types
@@ -646,18 +660,18 @@ export type CoKeys<Map extends object> = Exclude<
  *
  * map.requiredRef // this value is still nullable
  */
-type ForceRequiredRef<V> = V extends co<InstanceType<CoValueClass> | null>
+type ForceRequiredRef<V> = V extends InstanceType<CoValueClass> | null
   ? NonNullable<V>
-  : V extends co<InstanceType<CoValueClass> | undefined>
+  : V extends InstanceType<CoValueClass> | undefined
     ? V | null
     : V;
 
 export type CoMapInit<Map extends object> = {
   [Key in CoKeys<Map> as undefined extends Map[Key]
     ? never
-    : IfCo<Map[Key], Key>]: ForceRequiredRef<Map[Key]>;
+    : Key]: ForceRequiredRef<Map[Key]>;
 } & {
-  [Key in CoKeys<Map> as IfCo<Map[Key], Key>]?: ForceRequiredRef<Map[Key]>;
+  [Key in CoKeys<Map>]?: ForceRequiredRef<Map[Key]>;
 };
 
 // TODO: cache handlers per descriptor for performance?
@@ -685,7 +699,7 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
       } else if ("encoded" in descriptor) {
         return raw === undefined ? undefined : descriptor.encoded.decode(raw);
       } else if (isRefEncoded(descriptor)) {
-        return raw === undefined
+        return raw === undefined || raw === null
           ? undefined
           : accessChildByKey(target, raw as string, key);
       }
@@ -713,11 +727,13 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
       } else if ("encoded" in descriptor) {
         target._raw.set(key, descriptor.encoded.encode(value));
       } else if (isRefEncoded(descriptor)) {
-        if (value === null) {
+        if (value === undefined) {
           if (descriptor.optional) {
             target._raw.set(key, null);
           } else {
-            throw new Error(`Cannot set required reference ${key} to null`);
+            throw new Error(
+              `Cannot set required reference ${key} to undefined`,
+            );
           }
         } else if (value?.id) {
           target._raw.set(key, value.id);