@warp-drive/schema-record 5.4.0-alpha.138 → 5.4.0-alpha.140

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

@@ -1,10 +1,13 @@
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { setRecordIdentifier, recordIdentifierFor } from '@ember-data/store/-private';
+import { SOURCE as SOURCE$1, fastPush, RelatedCollection, setRecordIdentifier, recordIdentifierFor } from '@ember-data/store/-private';
 import { createSignal, subscribe, defineSignal, peekSignal, getSignal, Signals, entangleSignal, addToTransaction } from '@ember-data/tracking/-private';
-import { STRUCTURED } from '@warp-drive/core-types/request';
-import { RecordStore } from '@warp-drive/core-types/symbols';
+import { EnableHydration, STRUCTURED } from '@warp-drive/core-types/request';
+import { RecordStore, Type } from '@warp-drive/core-types/symbols';
 import { getOrSetGlobal } from '@warp-drive/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/store';
+import { createCache, getValue } from '@ember-data/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 +260,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;
@@ -360,6 +369,75 @@ 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];
+    currentState.length = 0;
+    fastPush(currentState, rawValue.data);
+  }
+  reloadHasMany(key, options) {
+    const field = this.store.schema.fields(this.identifier).get(key);
+    macroCondition(getGlobalConfig().WarpDrive.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().WarpDrive.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 +451,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 +479,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 +501,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 +516,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 +527,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 +543,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 +559,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 +602,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/model', '*');
 const getLegacySupport = macroCondition(dependencySatisfies('@ember-data/model', '*')) ? importSync('@ember-data/model/-private').lookupLegacySupport : null;
@@ -570,6 +694,9 @@ class SchemaRecord {
         return Array.from(fields.keys());
       },
       has(target, prop) {
+        if (prop === Destroy || prop === Checkout) {
+          return true;
+        }
         return fields.has(prop);
       },
       getOwnPropertyDescriptor(target, prop) {
@@ -683,10 +810,10 @@ class SchemaRecord {
               }
             })(!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().WarpDrive.env.DEBUG) ? (test => {
               if (!test) {
@@ -694,12 +821,10 @@ class SchemaRecord {
               }
             })(!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().WarpDrive.env.DEBUG) ? (test => {
               if (!test) {
@@ -707,7 +832,7 @@ class SchemaRecord {
               }
             })(!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().WarpDrive.env.DEBUG) ? (test => {
               if (!test) {
@@ -728,7 +853,7 @@ class SchemaRecord {
           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 +878,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().WarpDrive.env.DEBUG) ? (test => {
                 {
@@ -850,6 +979,11 @@ class SchemaRecord {
                 cache.setAttr(identifier, propArray, value?.slice());
                 const peeked = peekManagedArray(self, field);
                 if (peeked) {
+                  macroCondition(getGlobalConfig().WarpDrive.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 +997,11 @@ class SchemaRecord {
               cache.setAttr(identifier, propArray, rawValue);
               const peeked = peekManagedArray(self, field);
               if (peeked) {
+                macroCondition(getGlobalConfig().WarpDrive.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 +1016,11 @@ class SchemaRecord {
               cache.setAttr(identifier, propArray, arrayValue);
               const peeked = peekManagedArray(self, field);
               if (peeked) {
+                macroCondition(getGlobalConfig().WarpDrive.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 +1198,11 @@ class SchemaRecord {
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
                 const peeked = peekManagedArray(self, field);
                 if (peeked) {
+                  macroCondition(getGlobalConfig().WarpDrive.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 +1239,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().WarpDrive.env.DEBUG) ? (test => {
                   if (!test) {
                     throw new Error(`Expected to have a getLegacySupport function`);
@@ -1145,6 +1304,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 +1326,297 @@ class SchemaRecord {
     return Promise.resolve(editableRecord);
   }
 }
-export { Checkout, Editable, Legacy, SchemaRecord };
+function instantiateRecord(store, identifier, createArgs) {
+  const schema = store.schema;
+  const isLegacy = schema.resource(identifier)?.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().WarpDrive.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]();
+}
+const Support = getOrSetGlobal('Support', new WeakMap());
+const SchemaRecordFields = [{
+  type: '@constructor',
+  name: 'constructor',
+  kind: 'derived'
+}, {
+  type: '@identity',
+  name: '$type',
+  kind: 'derived',
+  options: {
+    key: 'type'
+  }
+}];
+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() {
+      throw new Error('Cannot access record.constructor.modelName on non-Legacy Schema Records.');
+    }
+  };
+}
+_constructor[Type] = '@constructor';
+function withDefaults(schema) {
+  schema.identity = schema.identity || {
+    name: 'id',
+    kind: '@id'
+  };
+  schema.fields.push(...SchemaRecordFields);
+  return schema;
+}
+function fromIdentity(record, options, key) {
+  const identifier = record[Identifier];
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Cannot compute @identity for a record without an identifier`);
+    }
+  })(identifier) : {};
+  macroCondition(getGlobalConfig().WarpDrive.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';
+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.
+ *
+ * @param record
+ * @param options
+ * @param prop
+ */
+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;
+}
+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();
+  }
+  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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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().WarpDrive.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(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().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+  SchemaService.prototype.attributesDefinitionFor = function ({
+    type
+  }) {
+    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.attributesDefinitionFor({ type })\``, false, {
+      id: 'ember-data:schema-service-updates',
+      until: '6.0',
+      for: 'ember-data',
+      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:schema-service-updates',
+      until: '6.0',
+      for: 'ember-data',
+      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:schema-service-updates',
+      until: '6.0',
+      for: 'ember-data',
+      since: {
+        available: '4.13',
+        enabled: '5.4'
+      }
+    });
+    return this._schemas.has(type);
+  };
+}
+export { Checkout, SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };