@warp-drive-mirror/schema-record 0.0.1 → 0.0.3

package/dist/{record.js → index.js}

@@ -1,10 +1,14 @@
+import { isResourceSchema } from '@warp-drive-mirror/core-types/schema/fields';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { setRecordIdentifier, recordIdentifierFor } from '@ember-data-mirror/store/-private';
-import { createSignal, subscribe, defineSignal, peekSignal, getSignal, Signals, entangleSignal, addToTransaction } from '@ember-data-mirror/tracking/-private';
-import { STRUCTURED } from '@warp-drive-mirror/core-types/request';
-import { RecordStore } from '@warp-drive-mirror/core-types/symbols';
+import { SOURCE as SOURCE$1, fastPush, RelatedCollection, setRecordIdentifier, recordIdentifierFor } from '@ember-data-mirror/store/-private';
+import { createSignal, subscribe, defineSignal, peekSignal, getSignal, Signals, addToTransaction, entangleSignal } from '@ember-data-mirror/tracking/-private';
+import { EnableHydration, STRUCTURED } from '@warp-drive-mirror/core-types/request';
+import { RecordStore, Type } from '@warp-drive-mirror/core-types/symbols';
 import { getOrSetGlobal } from '@warp-drive-mirror/core-types/-private';
 import { S as SOURCE, A as ARRAY_SIGNAL, E as Editable, L as Legacy, I as Identifier, P as Parent, O as OBJECT_SIGNAL, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedType } from "./symbols-DqoS4ybV.js";
+import { deprecate } from '@ember/debug';
+import { recordIdentifierFor as recordIdentifierFor$1 } from '@ember-data-mirror/store';
+import { createCache, getValue } from '@ember-data-mirror/tracking';
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 // const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
 const SYNC_PROPS = new Set(['[]', 'length']);
@@ -257,6 +261,12 @@ class ManagedArray {
           _SIGNAL.shouldReset = true;
         }
         return reflect;
+      },
+      has(target, prop) {
+        if (prop === 'identifier' || prop === 'owner' || prop === ARRAY_SIGNAL) {
+          return true;
+        }
+        return Reflect.has(target, prop);
       }
     });
     return proxy;
@@ -298,7 +308,7 @@ class ManagedObject {
           return self[prop];
         }
         if (prop === Symbol.toPrimitive) {
-          return null;
+          return () => null;
         }
         if (prop === Symbol.toStringTag) {
           return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
@@ -313,7 +323,12 @@ class ManagedObject {
         }
         if (prop === 'toHTML') {
           return function () {
-            return '<div>ManagedObject</div>';
+            return '<span>ManagedObject</span>';
+          };
+        }
+        if (prop === 'toJSON') {
+          return function () {
+            return structuredClone(self[SOURCE]);
           };
         }
         if (_SIGNAL.shouldReset) {
@@ -360,6 +375,81 @@ class ManagedObject {
     return proxy;
   }
 }
+class ManyArrayManager {
+  constructor(record) {
+    this.record = record;
+    this.store = record[RecordStore];
+    this.identifier = record[Identifier];
+  }
+  _syncArray(array) {
+    const rawValue = this.store.cache.getRelationship(this.identifier, array.key);
+    if (rawValue.meta) {
+      array.meta = rawValue.meta;
+    }
+    if (rawValue.links) {
+      array.links = rawValue.links;
+    }
+    const currentState = array[SOURCE$1];
+
+    // unlike in the normal RecordArray case, we don't need to divorce the reference
+    // because we don't need to worry about associate/disassociate since the graph
+    // takes care of that for us
+    if (currentState !== rawValue.data) {
+      currentState.length = 0;
+      fastPush(currentState, rawValue.data);
+    }
+  }
+  reloadHasMany(key, options) {
+    const field = this.store.schema.fields(this.identifier).get(key);
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a hasMany field for ${key}`);
+      }
+    })(field?.kind === 'hasMany') : {};
+    const cacheOptions = options ? extractCacheOptions(options) : {
+      reload: true
+    };
+    cacheOptions.types = [field.type];
+    const rawValue = this.store.cache.getRelationship(this.identifier, key);
+    const req = {
+      url: getRelatedLink(rawValue),
+      op: 'findHasMany',
+      method: 'GET',
+      records: rawValue.data,
+      cacheOptions,
+      options: {
+        field,
+        identifier: this.identifier,
+        links: rawValue.links,
+        meta: rawValue.meta
+      },
+      [EnableHydration]: false
+    };
+    return this.store.request(req);
+  }
+  mutate(mutation) {
+    this.cache.mutate(mutation);
+  }
+}
+function getRelatedLink(resource) {
+  const related = resource.links?.related;
+  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a related link`);
+    }
+  })(related) : {};
+  return typeof related === 'object' ? related.href : related;
+}
+function extractCacheOptions(options) {
+  const cacheOptions = {};
+  if ('reload' in options) {
+    cacheOptions.reload = options.reload;
+  }
+  if ('backgroundReload' in options) {
+    cacheOptions.backgroundReload = options.backgroundReload;
+  }
+  return cacheOptions;
+}
 const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
 const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
 function computeLocal(record, field, prop) {
@@ -373,24 +463,25 @@ function computeLocal(record, field, prop) {
 function peekManagedArray(record, field) {
   const managedArrayMapForRecord = ManagedArrayMap.get(record);
   if (managedArrayMapForRecord) {
-    return managedArrayMapForRecord.get(field);
+    return managedArrayMapForRecord.get(field.name);
   }
 }
 function peekManagedObject(record, field) {
   const managedObjectMapForRecord = ManagedObjectMap.get(record);
   if (managedObjectMapForRecord) {
-    return managedObjectMapForRecord.get(field);
+    return managedObjectMapForRecord.get(field.name);
   }
 }
-function computeField(schema, cache, record, identifier, field, prop) {
-  const rawValue = cache.getAttr(identifier, prop);
+function computeField(schema, cache, record, identifier, field, prop, editable) {
+  const rawValue = editable ? cache.getAttr(identifier, prop) : cache.getRemoteAttr(identifier, prop);
   if (!field.type) {
     return rawValue;
   }
   const transform = schema.transformation(field);
   return transform.hydrate(rawValue, field.options ?? null, record);
 }
-function computeArray(store, schema, cache, record, identifier, field, path, isSchemaArray, editable, legacy) {
+function computeArray(store, schema, cache, record, identifier, field, path, editable, legacy) {
+  const isSchemaArray = field.kind === 'schema-array';
   // the thing we hand out needs to know its owner and path in a private manner
   // its "address" is the parent identifier (identifier) + field name (field.name)
   //  in the nested object case field name here is the full dot path from root resource to this value
@@ -400,20 +491,20 @@ function computeArray(store, schema, cache, record, identifier, field, path, isS
   const managedArrayMapForRecord = ManagedArrayMap.get(record);
   let managedArray;
   if (managedArrayMapForRecord) {
-    managedArray = managedArrayMapForRecord.get(field);
+    managedArray = managedArrayMapForRecord.get(field.name);
   }
   if (managedArray) {
     return managedArray;
   } else {
-    const rawValue = cache.getAttr(identifier, path);
+    const rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
     if (!rawValue) {
       return null;
     }
     managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, path, record, isSchemaArray, editable, legacy);
     if (!managedArrayMapForRecord) {
-      ManagedArrayMap.set(record, new Map([[field, managedArray]]));
+      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
     } else {
-      managedArrayMapForRecord.set(field, managedArray);
+      managedArrayMapForRecord.set(field.name, managedArray);
     }
   }
   return managedArray;
@@ -422,12 +513,12 @@ function computeObject(schema, cache, record, identifier, field, path, editable,
   const managedObjectMapForRecord = ManagedObjectMap.get(record);
   let managedObject;
   if (managedObjectMapForRecord) {
-    managedObject = managedObjectMapForRecord.get(field);
+    managedObject = managedObjectMapForRecord.get(field.name);
   }
   if (managedObject) {
     return managedObject;
   } else {
-    let rawValue = cache.getAttr(identifier, path);
+    let rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
     if (!rawValue) {
       return null;
     }
@@ -437,9 +528,9 @@ function computeObject(schema, cache, record, identifier, field, path, editable,
     }
     managedObject = new ManagedObject(schema, cache, field, rawValue, identifier, path, record, editable, legacy);
     if (!managedObjectMapForRecord) {
-      ManagedObjectMap.set(record, new Map([[field, managedObject]]));
+      ManagedObjectMap.set(record, new Map([[field.name, managedObject]]));
     } else {
-      managedObjectMapForRecord.set(field, managedObject);
+      managedObjectMapForRecord.set(field.name, managedObject);
     }
   }
   return managedObject;
@@ -448,12 +539,12 @@ function computeSchemaObject(store, cache, record, identifier, field, path, lega
   const schemaObjectMapForRecord = ManagedObjectMap.get(record);
   let schemaObject;
   if (schemaObjectMapForRecord) {
-    schemaObject = schemaObjectMapForRecord.get(field);
+    schemaObject = schemaObjectMapForRecord.get(field.name);
   }
   if (schemaObject) {
     return schemaObject;
   } else {
-    const rawValue = cache.getAttr(identifier, path);
+    const rawValue = editable ? cache.getAttr(identifier, path) : cache.getRemoteAttr(identifier, path);
     if (!rawValue) {
       return null;
     }
@@ -464,14 +555,14 @@ function computeSchemaObject(store, cache, record, identifier, field, path, lega
     }, true, field.type, embeddedPath);
   }
   if (!schemaObjectMapForRecord) {
-    ManagedObjectMap.set(record, new Map([[field, schemaObject]]));
+    ManagedObjectMap.set(record, new Map([[field.name, schemaObject]]));
   } else {
-    schemaObjectMapForRecord.set(field, schemaObject);
+    schemaObjectMapForRecord.set(field.name, schemaObject);
   }
   return schemaObject;
 }
-function computeAttribute(cache, identifier, prop) {
-  return cache.getAttr(identifier, prop);
+function computeAttribute(cache, identifier, prop, editable) {
+  return editable ? cache.getAttr(identifier, prop) : cache.getRemoteAttr(identifier, prop);
 }
 function computeDerivation(schema, record, identifier, field, prop) {
   return schema.derivation(field)(record, field.options ?? null, prop);
@@ -480,8 +571,8 @@ function computeDerivation(schema, record, identifier, field, prop) {
 // TODO probably this should just be a Document
 // but its separate until we work out the lid situation
 class ResourceRelationship {
-  constructor(store, cache, parent, identifier, field, name) {
-    const rawValue = cache.getRelationship(identifier, name);
+  constructor(store, cache, parent, identifier, field, name, editable) {
+    const rawValue = editable ? cache.getRelationship(identifier, name) : cache.getRemoteRelationship(identifier, name);
 
     // TODO setup true lids for relationship documents
     // @ts-expect-error we need to give relationship documents a lid
@@ -523,11 +614,56 @@ function getHref(link) {
   }
   return link.href;
 }
-function computeResource(store, cache, parent, identifier, field, prop) {
+function computeResource(store, cache, parent, identifier, field, prop, editable) {
   if (field.kind !== 'resource') {
     throw new Error(`The schema for ${identifier.type}.${String(prop)} is not a resource relationship`);
   }
-  return new ResourceRelationship(store, cache, parent, identifier, field, prop);
+  return new ResourceRelationship(store, cache, parent, identifier, field, prop, editable);
+}
+function computeHasMany(store, schema, cache, record, identifier, field, path, editable, legacy) {
+  // the thing we hand out needs to know its owner and path in a private manner
+  // its "address" is the parent identifier (identifier) + field name (field.name)
+  //  in the nested object case field name here is the full dot path from root resource to this value
+  // its "key" is the field on the parent record
+  // its "owner" is the parent record
+
+  const managedArrayMapForRecord = ManagedArrayMap.get(record);
+  let managedArray;
+  if (managedArrayMapForRecord) {
+    managedArray = managedArrayMapForRecord.get(field.name);
+  }
+  if (managedArray) {
+    return managedArray;
+  } else {
+    const rawValue = cache.getRelationship(identifier, field.name);
+    if (!rawValue) {
+      return null;
+    }
+    managedArray = new RelatedCollection({
+      store,
+      type: field.type,
+      identifier,
+      cache,
+      identifiers: rawValue.data,
+      key: field.name,
+      meta: rawValue.meta || null,
+      links: rawValue.links || null,
+      isPolymorphic: field.options.polymorphic ?? false,
+      isAsync: field.options.async ?? false,
+      // TODO: Grab the proper value
+      _inverseIsAsync: false,
+      // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
+      manager: new ManyArrayManager(record),
+      isLoaded: true,
+      allowMutation: editable
+    });
+    if (!managedArrayMapForRecord) {
+      ManagedArrayMap.set(record, new Map([[field.name, managedArray]]));
+    } else {
+      managedArrayMapForRecord.set(field.name, managedArray);
+    }
+  }
+  return managedArray;
 }
 const HAS_MODEL_PACKAGE = dependencySatisfies('@ember-data-mirror/model', '*');
 const getLegacySupport = macroCondition(dependencySatisfies('@ember-data-mirror/model', '*')) ? importSync('@ember-data-mirror/model/-private').lookupLegacySupport : null;
@@ -537,6 +673,9 @@ const RecordSymbols = new Set(symbolList);
 function isPathMatch(a, b) {
   return a.length === b.length && a.every((v, i) => v === b[i]);
 }
+function isNonEnumerableProp(prop) {
+  return prop === 'constructor' || prop === 'prototype' || prop === '__proto__' || prop === 'toString' || prop === 'toJSON' || prop === 'toHTML' || typeof prop === 'symbol';
+}
 const Editables = new WeakMap();
 class SchemaRecord {
   constructor(store, identifier, Mode, isEmbedded = false, embeddedType = null, embeddedPath = null) {
@@ -552,31 +691,46 @@ class SchemaRecord {
     this[Legacy] = Mode[Legacy] ?? false;
     const schema = store.schema;
     const cache = store.cache;
-    const identityField = schema.resource(identifier).identity;
+    const identityField = schema.resource(isEmbedded ? {
+      type: embeddedType
+    } : identifier).identity;
+    const BoundFns = new Map();
     this[EmbeddedType] = embeddedType;
     this[EmbeddedPath] = embeddedPath;
-    let fields;
-    if (isEmbedded) {
-      fields = schema.fields({
-        type: embeddedType
-      });
-    } else {
-      fields = schema.fields(identifier);
-    }
+    const fields = isEmbedded ? schema.fields({
+      type: embeddedType
+    }) : schema.fields(identifier);
     const signals = new Map();
     this[Signals] = signals;
     const proxy = new Proxy(this, {
       ownKeys() {
-        return Array.from(fields.keys());
+        const identityKey = identityField?.name;
+        const keys = Array.from(fields.keys());
+        if (identityKey) {
+          keys.unshift(identityKey);
+        }
+        return keys;
       },
       has(target, prop) {
+        if (prop === Destroy || prop === Checkout) {
+          return true;
+        }
         return fields.has(prop);
       },
       getOwnPropertyDescriptor(target, prop) {
-        if (!fields.has(prop)) {
-          throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
+        const schemaForField = prop === identityField?.name ? identityField : fields.get(prop);
+        macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
+          }
+        })(schemaForField) : {};
+        if (isNonEnumerableProp(prop)) {
+          return {
+            writable: false,
+            enumerable: false,
+            configurable: true
+          };
         }
-        const schemaForField = fields.get(prop);
         switch (schemaForField.kind) {
           case 'derived':
             return {
@@ -584,6 +738,12 @@ class SchemaRecord {
               enumerable: true,
               configurable: true
             };
+          case '@id':
+            return {
+              writable: identifier.id === null,
+              enumerable: true,
+              configurable: true
+            };
           case '@local':
           case 'field':
           case 'attribute':
@@ -601,28 +761,18 @@ class SchemaRecord {
               enumerable: true,
               configurable: true
             };
+          default:
+            return {
+              writable: false,
+              enumerable: false,
+              configurable: false
+            };
         }
       },
       get(target, prop, receiver) {
         if (RecordSymbols.has(prop)) {
           return target[prop];
         }
-        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') {
@@ -638,18 +788,75 @@ class SchemaRecord {
           if (IgnoredGlobalFields.has(prop)) {
             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 = {};
+                for (const key in receiver) {
+                  json[key] = receiver[key];
+                }
+                return json;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+          if (prop === Symbol.toPrimitive) return () => null;
+          if (prop === Symbol.iterator) {
+            let fn = BoundFns.get(Symbol.iterator);
+            if (!fn) {
+              fn = function* () {
+                for (const key in receiver) {
+                  yield [key, receiver[key]];
+                }
+              };
+              BoundFns.set(Symbol.iterator, fn);
+            }
+            return fn;
+          }
           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;
-          }
-          throw new Error(`No field named ${String(prop)} on ${type}`);
+          if (typeof prop === 'symbol') return undefined;
+          macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+            {
+              throw new Error(`No field named ${String(prop)} on ${isEmbedded ? embeddedType : identifier.type}`);
+            }
+          })() : {};
+          return undefined;
         }
         const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
         macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
@@ -677,58 +884,31 @@ class SchemaRecord {
               return lastValue;
             }
           case 'field':
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`);
-              }
-            })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
-            return computeField(schema, cache, target, identifier, field, propArray);
+            return computeField(schema, cache, target, identifier, field, propArray, IS_EDITABLE);
           case 'attribute':
             entangleSignal(signals, receiver, field.name);
-            return computeAttribute(cache, identifier, prop);
+            return computeAttribute(cache, identifier, prop, IS_EDITABLE);
           case 'resource':
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`);
-              }
-            })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
-            return computeResource(store, cache, target, identifier, field, prop);
+            return computeResource(store, cache, target, identifier, field, prop, IS_EDITABLE);
           case 'derived':
             return computeDerivation(schema, receiver, identifier, field, prop);
           case 'schema-array':
-            entangleSignal(signals, receiver, field.name);
-            return computeArray(store, schema, cache, target, identifier, field, propArray, true, Mode[Editable], Mode[Legacy]);
           case 'array':
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`);
-              }
-            })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
-            return computeArray(store, schema, cache, target, identifier, field, propArray, false, Mode[Editable], Mode[Legacy]);
+            return computeArray(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
           case 'object':
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`);
-              }
-            })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
             return computeObject(schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
           case 'schema-object':
-            macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`);
-              }
-            })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
             // run transform, then use that value as the object to manage
             return computeSchemaObject(store, cache, target, identifier, field, propArray, Mode[Legacy], Mode[Editable]);
           case 'belongsTo':
             if (field.options.linksMode) {
               entangleSignal(signals, receiver, field.name);
-              const rawValue = cache.getRelationship(identifier, field.name);
+              const rawValue = IS_EDITABLE ? cache.getRelationship(identifier, field.name) : cache.getRemoteRelationship(identifier, field.name);
 
               // eslint-disable-next-line @typescript-eslint/no-unsafe-return
               return rawValue.data ? store.peekRecord(rawValue.data) : null;
@@ -753,6 +933,10 @@ class SchemaRecord {
             entangleSignal(signals, receiver, field.name);
             return getLegacySupport(receiver).getBelongsTo(field.name);
           case 'hasMany':
+            if (field.options.linksMode) {
+              entangleSignal(signals, receiver, field.name);
+              return computeHasMany(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
+            }
             if (!HAS_MODEL_PACKAGE) {
               macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
                 {
@@ -850,6 +1034,11 @@ class SchemaRecord {
                 cache.setAttr(identifier, propArray, value?.slice());
                 const peeked = peekManagedArray(self, field);
                 if (peeked) {
+                  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
+                    }
+                  })(ARRAY_SIGNAL in peeked) : {};
                   const arrSignal = peeked[ARRAY_SIGNAL];
                   arrSignal.shouldReset = true;
                 }
@@ -863,6 +1052,11 @@ class SchemaRecord {
               cache.setAttr(identifier, propArray, rawValue);
               const peeked = peekManagedArray(self, field);
               if (peeked) {
+                macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
+                  }
+                })(ARRAY_SIGNAL in peeked) : {};
                 const arrSignal = peeked[ARRAY_SIGNAL];
                 arrSignal.shouldReset = true;
               }
@@ -877,6 +1071,11 @@ class SchemaRecord {
               cache.setAttr(identifier, propArray, arrayValue);
               const peeked = peekManagedArray(self, field);
               if (peeked) {
+                macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
+                  }
+                })(ARRAY_SIGNAL in peeked) : {};
                 const arrSignal = peeked[ARRAY_SIGNAL];
                 arrSignal.shouldReset = true;
               }
@@ -1054,6 +1253,11 @@ class SchemaRecord {
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
                 const peeked = peekManagedArray(self, field);
                 if (peeked) {
+                  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
+                    }
+                  })(ARRAY_SIGNAL in peeked) : {};
                   const arrSignal = peeked[ARRAY_SIGNAL];
                   arrSignal.shouldReset = true;
                   addToTransaction(arrSignal);
@@ -1090,6 +1294,16 @@ class SchemaRecord {
                 }
                 // FIXME
               } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
+                if (field.options.linksMode) {
+                  const peeked = peekManagedArray(self, field);
+                  if (peeked) {
+                    // const arrSignal = peeked[ARRAY_SIGNAL];
+                    // arrSignal.shouldReset = true;
+                    // addToTransaction(arrSignal);
+                    peeked.notify();
+                  }
+                  return;
+                }
                 macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
                   if (!test) {
                     throw new Error(`Expected to have a getLegacySupport function`);
@@ -1133,6 +1347,19 @@ class SchemaRecord {
           break;
       }
     });
+    if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
+      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
+        enumerable: false,
+        configurable: true,
+        get() {
+          const data = {};
+          for (const key of fields.keys()) {
+            data[key] = proxy[key];
+          }
+          return data;
+        }
+      });
+    }
     return proxy;
   }
   [Destroy]() {
@@ -1145,6 +1372,10 @@ class SchemaRecord {
     this[RecordStore].notifications.unsubscribe(this.___notifications);
   }
   [Checkout]() {
+    // IF we are already the editable record, throw an error
+    if (this[Editable]) {
+      throw new Error(`Cannot checkout an already editable record`);
+    }
     const editable = Editables.get(this);
     if (editable) {
       return Promise.resolve(editable);
@@ -1163,4 +1394,374 @@ class SchemaRecord {
     return Promise.resolve(editableRecord);
   }
 }
-export { Checkout, Editable, Legacy, SchemaRecord };
+function instantiateRecord(store, identifier, createArgs) {
+  const schema = store.schema;
+  const resourceSchema = schema.resource(identifier);
+  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a resource schema`);
+    }
+  })(isResourceSchema(resourceSchema)) : {};
+  const isLegacy = resourceSchema?.legacy ?? false;
+  const isEditable = isLegacy || store.cache.isNew(identifier);
+  const record = new SchemaRecord(store, identifier, {
+    [Editable]: isEditable,
+    [Legacy]: isLegacy
+  });
+  if (createArgs) {
+    Object.assign(record, createArgs);
+  }
+  return record;
+}
+function assertSchemaRecord(record) {
+  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('Expected a SchemaRecord');
+    }
+  })(record && typeof record === 'object' && Destroy in record) : {};
+}
+function teardownRecord(record) {
+  assertSchemaRecord(record);
+  record[Destroy]();
+}
+
+/**
+ * @module @warp-drive-mirror/schema-record
+ */
+const Support = getOrSetGlobal('Support', new WeakMap());
+const ConstructorField = {
+  type: '@constructor',
+  name: 'constructor',
+  kind: 'derived'
+};
+const TypeField = {
+  type: '@identity',
+  name: '$type',
+  kind: 'derived',
+  options: {
+    key: 'type'
+  }
+};
+const DefaultIdentityField = {
+  name: 'id',
+  kind: '@id'
+};
+function _constructor(record) {
+  let state = Support.get(record);
+  if (!state) {
+    state = {};
+    Support.set(record, state);
+  }
+  return state._constructor = state._constructor || {
+    name: `SchemaRecord<${recordIdentifierFor$1(record).type}>`,
+    get modelName() {
+      macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+        {
+          throw new Error(`record.constructor.modelName is not available outside of legacy mode`);
+        }
+      })() : {};
+      return undefined;
+    }
+  };
+}
+_constructor[Type] = '@constructor';
+
+/**
+ * Utility for constructing a ResourceSchema with the recommended fields
+ * for the Polaris experience.
+ *
+ * @method withDefaults
+ * @for @warp-drive-mirror/schema-record
+ * @static
+ * @public
+ * @param schema
+ * @return {ResourceSchema}
+ */
+function withDefaults(schema) {
+  schema.identity = schema.identity || DefaultIdentityField;
+
+  // because fields gets iterated in definition order,
+  // we add TypeField to the beginning so that it will
+  // appear right next to the identity field
+  schema.fields.unshift(TypeField);
+  schema.fields.push(ConstructorField);
+  return schema;
+}
+
+/**
+ * A derivation that computes its value from the
+ * record's identity.
+ *
+ * It can be used via a derived field definition like:
+ *
+ * ```ts
+ * {
+ *   kind: 'derived',
+ *   name: 'id',
+ *   type: '@identity',
+ *   options: { key: 'id' }
+ * }
+ * ```
+ *
+ * Valid keys are `'id'`, `'lid'`, `'type'`, and `'^'`.
+ *
+ * `^` returns the entire identifier object.
+ *
+ * @method fromIdentity
+ * @for @warp-drive-mirror/schema-record
+ * @static
+ * @public
+ */
+
+function fromIdentity(record, options, key) {
+  const identifier = record[Identifier];
+  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Cannot compute @identity for a record without an identifier`);
+    }
+  })(identifier) : {};
+  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected to receive a key to compute @identity, but got ${String(options)}`);
+    }
+  })(options?.key && ['lid', 'id', 'type', '^'].includes(options.key)) : {};
+  return options.key === '^' ? identifier : identifier[options.key];
+}
+fromIdentity[Type] = '@identity';
+
+/**
+ * Registers the default derivations for the SchemaRecord
+ *
+ * @method registerDerivations
+ * @for @warp-drive-mirror/schema-record
+ * @static
+ * @public
+ * @param {SchemaService} schema
+ */
+function registerDerivations(schema) {
+  schema.registerDerivation(fromIdentity);
+  schema.registerDerivation(_constructor);
+}
+/**
+ * Wraps a derivation in a new function with Derivation signature but that looks
+ * up the value in the cache before recomputing.
+ *
+ * @internal
+ */
+function makeCachedDerivation(derivation) {
+  const memoizedDerivation = (record, options, prop) => {
+    const signals = record[Signals];
+    let signal = signals.get(prop);
+    if (!signal) {
+      signal = createCache(() => {
+        return derivation(record, options, prop);
+      }); // a total lie, for convenience of reusing the storage
+      signals.set(prop, signal);
+    }
+    return getValue(signal);
+  };
+  memoizedDerivation[Type] = derivation[Type];
+  return memoizedDerivation;
+}
+/**
+ * A SchemaService designed to work with dynamically registered schemas.
+ *
+ * @class SchemaService
+ * @public
+ */
+class SchemaService {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  constructor() {
+    this._schemas = new Map();
+    this._transforms = new Map();
+    this._hashFns = new Map();
+    this._derivations = new Map();
+  }
+  resourceTypes() {
+    return Array.from(this._schemas.keys());
+  }
+  hasTrait(type) {
+    return this._traits.has(type);
+  }
+  resourceHasTrait(resource, trait) {
+    return this._schemas.get(resource.type).traits.has(trait);
+  }
+  transformation(field) {
+    const kind = 'kind' in field ? field.kind : '<unknown kind>';
+    const name = 'name' in field ? field.name : '<unknown name>';
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`'${kind}' fields cannot be transformed. Only fields of kind 'field' 'object' or 'array' can specify a transformation. Attempted to find '${field.type ?? '<unknown type>'}' on field '${name}'.`);
+      }
+    })(!('kind' in field) || ['field', 'object', 'array'].includes(kind)) : {};
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the '${kind}' field '${name}' to specify a transformation via 'field.type', but none was present`);
+      }
+    })(field.type) : {};
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No transformation registered with name '${field.type}' for '${kind}' field '${name}'`);
+      }
+    })(this._transforms.has(field.type)) : {};
+    return this._transforms.get(field.type);
+  }
+  derivation(field) {
+    const kind = 'kind' in field ? field.kind : '<unknown kind>';
+    const name = 'name' in field ? field.name : '<unknown name>';
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The '${kind}' field '${name}' is not derived and so cannot be used to lookup a derivation`);
+      }
+    })(!('kind' in field) || kind === 'derived') : {};
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the '${kind}' field '${name}' to specify a derivation via 'field.type', but no value was present`);
+      }
+    })(field.type) : {};
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No '${field.type}' derivation registered for use by the '${kind}' field '${name}'`);
+      }
+    })(this._derivations.has(field.type)) : {};
+    return this._derivations.get(field.type);
+  }
+  hashFn(field) {
+    const kind = 'kind' in field ? field.kind : '<unknown kind>';
+    const name = 'name' in field ? field.name : '<unknown name>';
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The '${kind}' field '${name}' is not a HashField and so cannot be used to lookup a hash function`);
+      }
+    })(!('kind' in field) || kind === '@hash') : {};
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the '${kind}' field '${name}' to specify a hash function via 'field.type', but no value was present`);
+      }
+    })(field.type) : {};
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No '${field.type}' hash function is registered for use by the '${kind}' field '${name}'`);
+      }
+    })(this._hashFns.has(field.type)) : {};
+    return this._hashFns.get(field.type);
+  }
+  resource(resource) {
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No resource registered with name '${resource.type}'`);
+      }
+    })(this._schemas.has(resource.type)) : {};
+    return this._schemas.get(resource.type).original;
+  }
+  registerResources(schemas) {
+    schemas.forEach(schema => {
+      this.registerResource(schema);
+    });
+  }
+  registerResource(schema) {
+    const fields = new Map();
+    const relationships = {};
+    const attributes = {};
+    schema.fields.forEach(field => {
+      macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`${field.kind} is not valid inside a ResourceSchema's fields.`);
+        }
+      })(
+      // @ts-expect-error we are checking for mistakes at runtime
+      field.kind !== '@id' && field.kind !== '@hash') : {};
+      fields.set(field.name, field);
+      if (field.kind === 'attribute') {
+        attributes[field.name] = field;
+      } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
+        relationships[field.name] = field;
+      }
+    });
+    const traits = new Set(isResourceSchema(schema) ? schema.traits : []);
+    traits.forEach(trait => {
+      this._traits.add(trait);
+    });
+    const internalSchema = {
+      original: schema,
+      fields,
+      relationships,
+      attributes,
+      traits
+    };
+    this._schemas.set(schema.type, internalSchema);
+  }
+  registerTransformation(transformation) {
+    this._transforms.set(transformation[Type], transformation);
+  }
+  registerDerivation(derivation) {
+    this._derivations.set(derivation[Type], makeCachedDerivation(derivation));
+  }
+  registerHashFn(hashFn) {
+    this._hashFns.set(hashFn[Type], hashFn);
+  }
+  fields({
+    type
+  }) {
+    const schema = this._schemas.get(type);
+    if (!schema) {
+      throw new Error(`No schema defined for ${type}`);
+    }
+    return schema.fields;
+  }
+  hasResource(resource) {
+    return this._schemas.has(resource.type);
+  }
+}
+if (macroCondition(getGlobalConfig().WarpDriveMirror.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+  SchemaService.prototype.attributesDefinitionFor = function ({
+    type
+  }) {
+    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.attributesDefinitionFor({ type })\``, false, {
+      id: 'ember-data-mirror:schema-service-updates',
+      until: '6.0',
+      for: 'ember-data-mirror',
+      since: {
+        available: '4.13',
+        enabled: '5.4'
+      }
+    });
+    const schema = this._schemas.get(type);
+    if (!schema) {
+      throw new Error(`No schema defined for ${type}`);
+    }
+    return schema.attributes;
+  };
+  SchemaService.prototype.relationshipsDefinitionFor = function ({
+    type
+  }) {
+    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.relationshipsDefinitionFor({ type })\``, false, {
+      id: 'ember-data-mirror:schema-service-updates',
+      until: '6.0',
+      for: 'ember-data-mirror',
+      since: {
+        available: '4.13',
+        enabled: '5.4'
+      }
+    });
+    const schema = this._schemas.get(type);
+    if (!schema) {
+      throw new Error(`No schema defined for ${type}`);
+    }
+    return schema.relationships;
+  };
+  SchemaService.prototype.doesTypeExist = function (type) {
+    deprecate(`Use \`schema.hasResource({ type })\` instead of \`schema.doesTypeExist(type)\``, false, {
+      id: 'ember-data-mirror:schema-service-updates',
+      until: '6.0',
+      for: 'ember-data-mirror',
+      since: {
+        available: '4.13',
+        enabled: '5.4'
+      }
+    });
+    return this._schemas.has(type);
+  };
+}
+export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };