feat: ensure objects behave amazeballs

Author: runspired

packages/schema-record/src/-private/fields/managed-object.ts

@@ -83,7 +83,7 @@ export class ManagedObject {
         }
 
         if (prop === Symbol.toPrimitive) {
-          return null;
+          return () => null;
         }
         if (prop === Symbol.toStringTag) {
           return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
@@ -98,7 +98,12 @@ export class ManagedObject {
         }
         if (prop === 'toHTML') {
           return function () {
-            return '<div>ManagedObject</div>';
+            return '<span>ManagedObject</span>';
+          };
+        }
+        if (prop === 'toJSON') {
+          return function () {
+            return structuredClone(self[SOURCE]);
           };
         }
 

packages/schema-record/src/-private/record.ts

@@ -66,6 +66,7 @@ const symbolList = [
 const RecordSymbols = new Set(symbolList);
 
 type RecordSymbol = (typeof symbolList)[number];
+type ProxiedMethod = (...args: unknown[]) => unknown;
 
 function isPathMatch(a: string[], b: string[]) {
   return a.length === b.length && a.every((v, i) => v === b[i]);
@@ -106,6 +107,7 @@ export class SchemaRecord {
     const schema = store.schema as unknown as SchemaService;
     const cache = store.cache;
     const identityField = schema.resource(identifier).identity;
+    const BoundFns = new Map<string | symbol, ProxiedMethod>();
 
     this[EmbeddedType] = embeddedType;
     this[EmbeddedPath] = embeddedPath;
@@ -136,14 +138,20 @@ export class SchemaRecord {
         if (!fields.has(prop as string)) {
           throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
         }
-        const schemaForField = fields.get(prop as string)!;
+        const schemaForField = prop === identityField?.name ? identityField : fields.get(prop as string)!;
         switch (schemaForField.kind) {
           case 'derived':
             return {
               writable: false,
               enumerable: true,
               configurable: true,
             };
+          case '@id':
+            return {
+              writable: identifier.id === null,
+              enumerable: true,
+              configurable: true,
+            };
           case '@local':
           case 'field':
           case 'attribute':
@@ -161,6 +169,12 @@ export class SchemaRecord {
               enumerable: true,
               configurable: true,
             };
+          default:
+            return {
+              writable: false,
+              enumerable: false,
+              configurable: false,
+            };
         }
       },
 
@@ -169,26 +183,6 @@ export class SchemaRecord {
           return target[prop as keyof SchemaRecord];
         }
 
-        if (prop === Symbol.toStringTag) {
-          return `SchemaRecord<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-        }
-
-        if (prop === 'toString') {
-          return function () {
-            return `SchemaRecord<${identifier.type}:${identifier.id} (${identifier.lid})>`;
-          };
-        }
-
-        if (prop === 'toHTML') {
-          return function () {
-            return `<div>SchemaRecord<${identifier.type}:${identifier.id} (${identifier.lid})></div>`;
-          };
-        }
-
-        if (prop === Symbol.toPrimitive) {
-          return null;
-        }
-
         // TODO make this a symbol
         if (prop === '___notifications') {
           return target.___notifications;
@@ -203,19 +197,65 @@ export class SchemaRecord {
           if (IgnoredGlobalFields.has(prop as string)) {
             return undefined;
           }
+
+          /////////////////////////////////////////////////////////////
+          //// Note these bound function behaviors are essentially ////
+          //// built-in but overrideable derivations.              ////
+          ////                                                     ////
+          //// The bar for this has to be "basic expectations of   ////
+          ///  an object" – very, very high                        ////
+          /////////////////////////////////////////////////////////////
+
+          if (prop === Symbol.toStringTag || prop === 'toString') {
+            let fn = BoundFns.get('toString');
+            if (!fn) {
+              fn = function () {
+                entangleSignal(signals, receiver, '@identity');
+                return `Record<${identifier.type}:${identifier.id} (${identifier.lid})>`;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+
+          if (prop === 'toHTML') {
+            let fn = BoundFns.get('toHTML');
+            if (!fn) {
+              fn = function () {
+                entangleSignal(signals, receiver, '@identity');
+                return `<span>Record<${identifier.type}:${identifier.id} (${identifier.lid})></span>`;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+
+          if (prop === 'toJSON') {
+            let fn = BoundFns.get('toJSON');
+            if (!fn) {
+              fn = function () {
+                const json: Record<string, unknown> = {};
+                for (const key in receiver) {
+                  json[key] = receiver[key as keyof typeof receiver];
+                }
+
+                return json;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+
+          if (prop === Symbol.toPrimitive) return () => null;
+
           if (prop === 'constructor') {
             return SchemaRecord;
           }
           // too many things check for random symbols
-          if (typeof prop === 'symbol') {
-            return undefined;
-          }
-          let type = identifier.type;
-          if (isEmbedded) {
-            type = embeddedType!;
-          }
+          if (typeof prop === 'symbol') return undefined;
 
-          throw new Error(`No field named ${String(prop)} on ${type}`);
+          assert(`No field named ${String(prop)} on ${isEmbedded ? embeddedType! : identifier.type}`);
+          return undefined;
         }
 
         const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;

packages/schema-record/src/-private/schema.ts

@@ -17,6 +17,7 @@ import {
   type FieldSchema,
   type GenericField,
   type HashField,
+  type IdentityField,
   isResourceSchema,
   type LegacyAttributeField,
   type LegacyRelationshipSchema,
@@ -32,19 +33,18 @@ import { Identifier } from './symbols';
 
 const Support = getOrSetGlobal('Support', new WeakMap<WeakKey, Record<string, unknown>>());
 
-export const SchemaRecordFields: FieldSchema[] = [
-  {
-    type: '@constructor',
-    name: 'constructor',
-    kind: 'derived',
-  },
-  {
-    type: '@identity',
-    name: '$type',
-    kind: 'derived',
-    options: { key: 'type' },
-  },
-];
+const ConstructorField = {
+  type: '@constructor',
+  name: 'constructor',
+  kind: 'derived',
+} satisfies DerivedField;
+const TypeField = {
+  type: '@identity',
+  name: '$type',
+  kind: 'derived',
+  options: { key: 'type' },
+} satisfies DerivedField;
+const DefaultIdentityField = { name: 'id', kind: '@id' } satisfies IdentityField;
 
 function _constructor(record: SchemaRecord) {
   let state = Support.get(record as WeakKey);
@@ -55,16 +55,17 @@ function _constructor(record: SchemaRecord) {
 
   return (state._constructor = state._constructor || {
     name: `SchemaRecord<${recordIdentifierFor(record).type}>`,
-    get modelName() {
-      throw new Error('Cannot access record.constructor.modelName on non-Legacy Schema Records.');
-    },
   });
 }
 _constructor[Type] = '@constructor';
 
+/**
+ * Utility for constructing a ResourceSchema with the recommended fields
+ * for the Polaris experience.
+ */
 export function withDefaults(schema: WithPartial<ResourceSchema, 'identity'>): ResourceSchema {
-  schema.identity = schema.identity || { name: 'id', kind: '@id' };
-  schema.fields.push(...SchemaRecordFields);
+  schema.identity = schema.identity || DefaultIdentityField;
+  schema.fields.push(TypeField, ConstructorField);
   return schema as ResourceSchema;
 }