@warp-drive/schema-record 0.0.0-alpha.101

package/dist/record.js

@@ -0,0 +1,1159 @@
+import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
+import { 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 { 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";
+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']);
+function isArrayGetter(prop) {
+  return ARRAY_GETTER_METHODS.has(prop);
+}
+const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
+function isArraySetter(prop) {
+  return ARRAY_SETTER_METHODS.has(prop);
+}
+
+// function isSelfProp<T extends object>(self: T, prop: KeyType): prop is keyof T {
+//   return prop in self;
+// }
+
+function convertToInt(prop) {
+  if (typeof prop === 'symbol') return null;
+  const num = Number(prop);
+  if (isNaN(num)) return null;
+  return num % 1 === 0 ? num : null;
+}
+function safeForEach(instance, arr, store, callback, target) {
+  if (target === undefined) {
+    target = null;
+  }
+  // clone to prevent mutation
+  arr = arr.slice();
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('`forEach` expects a function as first argument.');
+    }
+  })(typeof callback === 'function') : {};
+
+  // because we retrieveLatest above we need not worry if array is mutated during iteration
+  // by unloadRecord/rollbackAttributes
+  // push/add/removeObject may still be problematic
+  // but this is a more traditionally expected forEach bug.
+  const length = arr.length; // we need to access length to ensure we are consumed
+
+  for (let index = 0; index < length; index++) {
+    callback.call(target, arr[index], index, instance);
+  }
+  return instance;
+}
+class ManagedArray {
+  [SOURCE];
+  constructor(store, schema, cache, field, data, identifier, path, owner, isSchemaArray, editable, legacy) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    this[SOURCE] = data?.slice();
+    this[ARRAY_SIGNAL] = createSignal(this, 'length');
+    const IS_EDITABLE = this[Editable] = editable ?? false;
+    this[Legacy] = legacy;
+    const _SIGNAL = this[ARRAY_SIGNAL];
+    const boundFns = new Map();
+    this.identifier = identifier;
+    this.path = path;
+    this.owner = owner;
+    let transaction = false;
+    const mode = field.options?.key ?? '@identity';
+    const RefStorage = mode === '@identity' ? WeakMap :
+    // CAUTION CAUTION CAUTION
+    // this is a pile of lies
+    // the Map is Map<string, WeakRef<SchemaRecord>>
+    // but TS does not understand how to juggle modes like this
+    // internal to a method like ours without us duplicating the code
+    // into two separate methods.
+    Map;
+    const ManagedRecordRefs = isSchemaArray ? new RefStorage() : null;
+    const proxy = new Proxy(this[SOURCE], {
+      get(target, prop, receiver) {
+        if (prop === ARRAY_SIGNAL) {
+          return _SIGNAL;
+        }
+        if (prop === 'identifier') {
+          return self.identifier;
+        }
+        if (prop === 'owner') {
+          return self.owner;
+        }
+        const index = convertToInt(prop);
+        if (_SIGNAL.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
+          _SIGNAL.t = false;
+          _SIGNAL.shouldReset = false;
+          const newData = cache.getAttr(identifier, path);
+          if (newData && newData !== self[SOURCE]) {
+            self[SOURCE].length = 0;
+            self[SOURCE].push(...newData);
+          }
+        }
+        if (index !== null) {
+          let val;
+          if (mode === '@hash') {
+            val = target[index];
+            const hashField = schema.resource({
+              type: field.type
+            }).identity;
+            const hashFn = schema.hashFn(hashField);
+            val = hashFn(val, null, null);
+          } else {
+            // if mode is not @identity or @index, then access the key path.
+            // we should assert that `mode` is a string
+            // it should read directly from the cache value for that field (e.g. no derivation, no transformation)
+            // and, we likely should lookup the associated field and throw an error IF
+            // the given field does not exist OR
+            // the field is anything other than a GenericField or LegacyAttributeField.
+            if (mode !== '@identity' && mode !== '@index') {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error('mode must be a string');
+                }
+              })(typeof mode === 'string') : {};
+              const modeField = schema.resource({
+                type: field.type
+              }).fields.find(f => f.name === mode);
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error('field must exist in schema');
+                }
+              })(modeField) : {};
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error('field must be a GenericField or LegacyAttributeField');
+                }
+              })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
+            }
+            val = mode === '@identity' ? target[index] : mode === '@index' ? '@index' : target[index][mode];
+          }
+          if (isSchemaArray) {
+            if (!transaction) {
+              subscribe(_SIGNAL);
+            }
+            if (val) {
+              const recordRef = ManagedRecordRefs.get(val);
+              let record = recordRef?.deref();
+              if (!record) {
+                const recordPath = path.slice();
+                // this is a dirty lie since path is string[] but really we
+                // should change the types for paths to `Array<string | number>`
+                // TODO we should allow the schema for the field to define a "key"
+                // for stability. Default should be `@identity` which means that
+                // same object reference from cache should result in same SchemaRecord
+                // embedded object.
+                recordPath.push(index);
+                const recordIdentifier = self.owner[Identifier] || self.owner[Parent];
+                record = new SchemaRecord(store, recordIdentifier, {
+                  [Editable]: self.owner[Editable],
+                  [Legacy]: self.owner[Legacy]
+                }, true, field.type, recordPath);
+                // if mode is not @identity or @index, then access the key path now
+                // to determine the key value.
+                // chris says we can implement this as a special kind `@hash` which
+                // would be a function that only has access to the cache value and not
+                // the record itself, so derivation is possible but intentionally limited
+                // and non-reactive?
+                ManagedRecordRefs.set(val, new WeakRef(record));
+              }
+              return record;
+            }
+            return val;
+          }
+          if (!transaction) {
+            subscribe(_SIGNAL);
+          }
+          if (field.type) {
+            const transform = schema.transformation(field);
+            return transform.hydrate(val, field.options ?? null, self.owner);
+          }
+          return val;
+        }
+        if (isArrayGetter(prop)) {
+          let fn = boundFns.get(prop);
+          if (fn === undefined) {
+            if (prop === 'forEach') {
+              fn = function () {
+                subscribe(_SIGNAL);
+                transaction = true;
+                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
+                transaction = false;
+                return result;
+              };
+            } else {
+              fn = function () {
+                subscribe(_SIGNAL);
+                // array functions must run through Reflect to work properly
+                // binding via other means will not work.
+                transaction = true;
+                const result = Reflect.apply(target[prop], receiver, arguments);
+                transaction = false;
+                return result;
+              };
+            }
+            boundFns.set(prop, fn);
+          }
+          return fn;
+        }
+        if (isArraySetter(prop)) {
+          let fn = boundFns.get(prop);
+          if (fn === undefined) {
+            fn = function () {
+              if (!IS_EDITABLE) {
+                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
+              }
+              subscribe(_SIGNAL);
+              transaction = true;
+              const result = Reflect.apply(target[prop], receiver, arguments);
+              transaction = false;
+              return result;
+            };
+            boundFns.set(prop, fn);
+          }
+          return fn;
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        if (!IS_EDITABLE) {
+          let errorPath = identifier.type;
+          if (path) {
+            errorPath = path[path.length - 1];
+          }
+          throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
+        }
+        if (prop === 'identifier') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          self.identifier = value;
+          return true;
+        }
+        if (prop === 'owner') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          self.owner = value;
+          return true;
+        }
+        const reflect = Reflect.set(target, prop, value, receiver);
+        if (reflect) {
+          if (!field.type) {
+            cache.setAttr(identifier, path, self[SOURCE]);
+            _SIGNAL.shouldReset = true;
+            return true;
+          }
+          let rawValue = self[SOURCE];
+          if (!isSchemaArray) {
+            const transform = schema.transformation(field);
+            if (!transform) {
+              throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
+            }
+            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
+          }
+          cache.setAttr(identifier, path, rawValue);
+          _SIGNAL.shouldReset = true;
+        }
+        return reflect;
+      }
+    });
+    return proxy;
+  }
+}
+const ObjectSymbols = new Set([OBJECT_SIGNAL, Parent, SOURCE, Editable, EmbeddedPath]);
+
+// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
+
+class ManagedObject {
+  constructor(schema, cache, field, data, identifier, path, owner, editable, legacy) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    this[SOURCE] = {
+      ...data
+    };
+    this[OBJECT_SIGNAL] = createSignal(this, 'length');
+    this[Editable] = editable;
+    this[Legacy] = legacy;
+    this[Parent] = identifier;
+    this[EmbeddedPath] = path;
+    const _SIGNAL = this[OBJECT_SIGNAL];
+    const proxy = new Proxy(this[SOURCE], {
+      ownKeys() {
+        return Object.keys(self[SOURCE]);
+      },
+      has(target, prop) {
+        return prop in self[SOURCE];
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return {
+          writable: editable,
+          enumerable: true,
+          configurable: true
+        };
+      },
+      get(target, prop, receiver) {
+        if (ObjectSymbols.has(prop)) {
+          return self[prop];
+        }
+        if (prop === Symbol.toPrimitive) {
+          return null;
+        }
+        if (prop === Symbol.toStringTag) {
+          return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
+        }
+        if (prop === 'constructor') {
+          return Object;
+        }
+        if (prop === 'toString') {
+          return function () {
+            return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
+          };
+        }
+        if (prop === 'toHTML') {
+          return function () {
+            return '<div>ManagedObject</div>';
+          };
+        }
+        if (_SIGNAL.shouldReset) {
+          _SIGNAL.t = false;
+          _SIGNAL.shouldReset = false;
+          let newData = cache.getAttr(identifier, path);
+          if (newData && newData !== self[SOURCE]) {
+            if (field.type) {
+              const transform = schema.transformation(field);
+              newData = transform.hydrate(newData, field.options ?? null, owner);
+            }
+            self[SOURCE] = {
+              ...newData
+            }; // Add type assertion for newData
+          }
+        }
+        if (prop in self[SOURCE]) {
+          subscribe(_SIGNAL);
+          return self[SOURCE][prop];
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
+          }
+        })(editable) : {};
+        const reflect = Reflect.set(target, prop, value, receiver);
+        if (!reflect) {
+          return false;
+        }
+        if (!field.type) {
+          cache.setAttr(identifier, path, self[SOURCE]);
+        } else {
+          const transform = schema.transformation(field);
+          const val = transform.serialize(self[SOURCE], field.options ?? null, owner);
+          cache.setAttr(identifier, path, val);
+        }
+        _SIGNAL.shouldReset = true;
+        return true;
+      }
+    });
+    return proxy;
+  }
+}
+const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
+const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
+function computeLocal(record, field, prop) {
+  let signal = peekSignal(record, prop);
+  if (!signal) {
+    signal = getSignal(record, prop, false);
+    signal.lastValue = field.options?.defaultValue ?? null;
+  }
+  return signal.lastValue;
+}
+function peekManagedArray(record, field) {
+  const managedArrayMapForRecord = ManagedArrayMap.get(record);
+  if (managedArrayMapForRecord) {
+    return managedArrayMapForRecord.get(field);
+  }
+}
+function peekManagedObject(record, field) {
+  const managedObjectMapForRecord = ManagedObjectMap.get(record);
+  if (managedObjectMapForRecord) {
+    return managedObjectMapForRecord.get(field);
+  }
+}
+function computeField(schema, cache, record, identifier, field, prop) {
+  const rawValue = cache.getAttr(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) {
+  // 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);
+  }
+  if (managedArray) {
+    return managedArray;
+  } else {
+    const rawValue = cache.getAttr(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]]));
+    } else {
+      managedArrayMapForRecord.set(field, managedArray);
+    }
+  }
+  return managedArray;
+}
+function computeObject(schema, cache, record, identifier, field, path, editable, legacy) {
+  const managedObjectMapForRecord = ManagedObjectMap.get(record);
+  let managedObject;
+  if (managedObjectMapForRecord) {
+    managedObject = managedObjectMapForRecord.get(field);
+  }
+  if (managedObject) {
+    return managedObject;
+  } else {
+    let rawValue = cache.getAttr(identifier, path);
+    if (!rawValue) {
+      return null;
+    }
+    if (field.type) {
+      const transform = schema.transformation(field);
+      rawValue = transform.hydrate(rawValue, field.options ?? null, record);
+    }
+    managedObject = new ManagedObject(schema, cache, field, rawValue, identifier, path, record, editable, legacy);
+    if (!managedObjectMapForRecord) {
+      ManagedObjectMap.set(record, new Map([[field, managedObject]]));
+    } else {
+      managedObjectMapForRecord.set(field, managedObject);
+    }
+  }
+  return managedObject;
+}
+function computeSchemaObject(store, cache, record, identifier, field, path, legacy, editable) {
+  const schemaObjectMapForRecord = ManagedObjectMap.get(record);
+  let schemaObject;
+  if (schemaObjectMapForRecord) {
+    schemaObject = schemaObjectMapForRecord.get(field);
+  }
+  if (schemaObject) {
+    return schemaObject;
+  } else {
+    const rawValue = cache.getAttr(identifier, path);
+    if (!rawValue) {
+      return null;
+    }
+    const embeddedPath = path.slice();
+    schemaObject = new SchemaRecord(store, identifier, {
+      [Editable]: editable,
+      [Legacy]: legacy
+    }, true, field.type, embeddedPath);
+  }
+  if (!schemaObjectMapForRecord) {
+    ManagedObjectMap.set(record, new Map([[field, schemaObject]]));
+  } else {
+    schemaObjectMapForRecord.set(field, schemaObject);
+  }
+  return schemaObject;
+}
+function computeAttribute(cache, identifier, prop) {
+  return cache.getAttr(identifier, prop);
+}
+function computeDerivation(schema, record, identifier, field, prop) {
+  return schema.derivation(field)(record, field.options ?? null, 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);
+
+    // TODO setup true lids for relationship documents
+    // @ts-expect-error we need to give relationship documents a lid
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    this.lid = rawValue.lid ?? rawValue.links?.self ?? `relationship:${identifier.lid}.${name}`;
+    this.data = rawValue.data ? store.peekRecord(rawValue.data) : null;
+    this.name = name;
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      this.links = Object.freeze(Object.assign({}, rawValue.links));
+      this.meta = Object.freeze(Object.assign({}, rawValue.meta));
+    } else {
+      this.links = rawValue.links ?? {};
+      this.meta = rawValue.meta ?? {};
+    }
+    this[RecordStore] = store;
+    this[Parent] = parent;
+  }
+  fetch(options) {
+    const url = options?.url ?? getHref(this.links.related) ?? getHref(this.links.self) ?? null;
+    if (!url) {
+      throw new Error(`Cannot ${options?.method ?? 'fetch'} ${this[Parent][Identifier].type}.${String(this.name)} because it has no related link`);
+    }
+    const request = Object.assign({
+      url,
+      method: 'GET'
+    }, options);
+    return this[RecordStore].request(request);
+  }
+}
+defineSignal(ResourceRelationship.prototype, 'data');
+defineSignal(ResourceRelationship.prototype, 'links');
+defineSignal(ResourceRelationship.prototype, 'meta');
+function getHref(link) {
+  if (!link) {
+    return null;
+  }
+  if (typeof link === 'string') {
+    return link;
+  }
+  return link.href;
+}
+function computeResource(store, cache, parent, identifier, field, prop) {
+  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);
+}
+const HAS_MODEL_PACKAGE = dependencySatisfies('@ember-data/model', '*');
+const getLegacySupport = macroCondition(dependencySatisfies('@ember-data/model', '*')) ? importSync('@ember-data/model/-private').lookupLegacySupport : null;
+const IgnoredGlobalFields = new Set(['length', 'nodeType', 'then', 'setInterval', 'document', STRUCTURED]);
+const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, Signals, EmbeddedPath, EmbeddedType];
+const RecordSymbols = new Set(symbolList);
+function isPathMatch(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+const Editables = new WeakMap();
+class SchemaRecord {
+  constructor(store, identifier, Mode, isEmbedded = false, embeddedType = null, embeddedPath = null) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    this[RecordStore] = store;
+    if (isEmbedded) {
+      this[Parent] = identifier;
+    } else {
+      this[Identifier] = identifier;
+    }
+    const IS_EDITABLE = this[Editable] = Mode[Editable] ?? false;
+    this[Legacy] = Mode[Legacy] ?? false;
+    const schema = store.schema;
+    const cache = store.cache;
+    const identityField = schema.resource(identifier).identity;
+    this[EmbeddedType] = embeddedType;
+    this[EmbeddedPath] = embeddedPath;
+    let fields;
+    if (isEmbedded) {
+      fields = schema.fields({
+        type: embeddedType
+      });
+    } else {
+      fields = schema.fields(identifier);
+    }
+    const signals = new Map();
+    this[Signals] = signals;
+    const proxy = new Proxy(this, {
+      ownKeys() {
+        return Array.from(fields.keys());
+      },
+      has(target, prop) {
+        return fields.has(prop);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (!fields.has(prop)) {
+          throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
+        }
+        const schemaForField = fields.get(prop);
+        switch (schemaForField.kind) {
+          case 'derived':
+            return {
+              writable: false,
+              enumerable: true,
+              configurable: true
+            };
+          case '@local':
+          case 'field':
+          case 'attribute':
+          case 'resource':
+          case 'alias':
+          case 'belongsTo':
+          case 'hasMany':
+          case 'collection':
+          case 'schema-array':
+          case 'array':
+          case 'schema-object':
+          case 'object':
+            return {
+              writable: IS_EDITABLE,
+              enumerable: true,
+              configurable: true
+            };
+        }
+      },
+      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') {
+          return target.___notifications;
+        }
+
+        // SchemaRecord reserves use of keys that begin with these characters
+        // for its own usage.
+        // _, @, $, *
+
+        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
+        if (!maybeField) {
+          if (IgnoredGlobalFields.has(prop)) {
+            return undefined;
+          }
+          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}`);
+        }
+        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
+          }
+        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
+        const propArray = isEmbedded ? embeddedPath.slice() : [];
+        // we use the field.name instead of prop here because we want to use the cache-path not
+        // the record path.
+        propArray.push(field.name);
+        // propArray.push(prop as string);
+
+        switch (field.kind) {
+          case '@id':
+            entangleSignal(signals, receiver, '@identity');
+            return identifier.id;
+          case '@hash':
+            // TODO pass actual cache value not {}
+            return schema.hashFn(field)({}, field.options ?? null, field.name ?? null);
+          case '@local':
+            {
+              const lastValue = computeLocal(receiver, field, prop);
+              entangleSignal(signals, receiver, prop);
+              return lastValue;
+            }
+          case 'field':
+            macroCondition(getGlobalConfig().WarpDrive.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);
+          case 'attribute':
+            entangleSignal(signals, receiver, field.name);
+            return computeAttribute(cache, identifier, prop);
+          case 'resource':
+            macroCondition(getGlobalConfig().WarpDrive.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);
+          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) {
+                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]);
+          case 'object':
+            macroCondition(getGlobalConfig().WarpDrive.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().WarpDrive.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 (!HAS_MODEL_PACKAGE) {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                {
+                  throw new Error(`Cannot use belongsTo fields in your schema unless @ember-data/model is installed to provide legacy model support. ${field.name} should likely be migrated to be a resource field.`);
+                }
+              })() : {};
+            }
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Expected to have a getLegacySupport function`);
+              }
+            })(getLegacySupport) : {};
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
+              }
+            })(Mode[Legacy]) : {};
+            entangleSignal(signals, receiver, field.name);
+            return getLegacySupport(receiver).getBelongsTo(field.name);
+          case 'hasMany':
+            if (!HAS_MODEL_PACKAGE) {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                {
+                  throw new Error(`Cannot use hasMany fields in your schema unless @ember-data/model is installed to provide legacy model support.  ${field.name} should likely be migrated to be a collection field.`);
+                }
+              })() : {};
+            }
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Expected to have a getLegacySupport function`);
+              }
+            })(getLegacySupport) : {};
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+              }
+            })(Mode[Legacy]) : {};
+            entangleSignal(signals, receiver, field.name);
+            return getLegacySupport(receiver).getHasMany(field.name);
+          default:
+            throw new Error(`Field '${String(prop)}' on '${identifier.type}' has the unknown kind '${field.kind}'`);
+        }
+      },
+      set(target, prop, value, receiver) {
+        if (!IS_EDITABLE) {
+          const type = isEmbedded ? embeddedType : identifier.type;
+          throw new Error(`Cannot set ${String(prop)} on ${type} because the record is not editable`);
+        }
+        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
+        if (!maybeField) {
+          const type = isEmbedded ? embeddedType : identifier.type;
+          throw new Error(`There is no field named ${String(prop)} on ${type}`);
+        }
+        const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
+          }
+        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
+        const propArray = isEmbedded ? embeddedPath.slice() : [];
+        // we use the field.name instead of prop here because we want to use the cache-path not
+        // the record path.
+        propArray.push(field.name);
+        // propArray.push(prop as string);
+
+        switch (field.kind) {
+          case '@id':
+            {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected to receive a string id`);
+                }
+              })(typeof value === 'string' && value.length) : {};
+              const normalizedId = String(value);
+              const didChange = normalizedId !== identifier.id;
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Cannot set ${identifier.type} record's id to ${normalizedId}, because id is already ${identifier.id}`);
+                }
+              })(!didChange || identifier.id === null) : {};
+              if (normalizedId !== null && didChange) {
+                store._instanceCache.setRecordId(identifier, normalizedId);
+                store.notifications.notify(identifier, 'identity');
+              }
+              return true;
+            }
+          case '@local':
+            {
+              const signal = getSignal(receiver, prop, true);
+              if (signal.lastValue !== value) {
+                signal.lastValue = value;
+                addToTransaction(signal);
+              }
+              return true;
+            }
+          case 'field':
+            {
+              if (!field.type) {
+                cache.setAttr(identifier, propArray, value);
+                return true;
+              }
+              const transform = schema.transformation(field);
+              const rawValue = transform.serialize(value, field.options ?? null, target);
+              cache.setAttr(identifier, propArray, rawValue);
+              return true;
+            }
+          case 'attribute':
+            {
+              cache.setAttr(identifier, propArray, value);
+              return true;
+            }
+          case 'array':
+            {
+              if (!field.type) {
+                cache.setAttr(identifier, propArray, value?.slice());
+                const peeked = peekManagedArray(self, field);
+                if (peeked) {
+                  const arrSignal = peeked[ARRAY_SIGNAL];
+                  arrSignal.shouldReset = true;
+                }
+                if (!Array.isArray(value)) {
+                  ManagedArrayMap.delete(target);
+                }
+                return true;
+              }
+              const transform = schema.transformation(field);
+              const rawValue = value.map(item => transform.serialize(item, field.options ?? null, target));
+              cache.setAttr(identifier, propArray, rawValue);
+              const peeked = peekManagedArray(self, field);
+              if (peeked) {
+                const arrSignal = peeked[ARRAY_SIGNAL];
+                arrSignal.shouldReset = true;
+              }
+              return true;
+            }
+          case 'schema-array':
+            {
+              const arrayValue = value?.slice();
+              if (!Array.isArray(arrayValue)) {
+                ManagedArrayMap.delete(target);
+              }
+              cache.setAttr(identifier, propArray, arrayValue);
+              const peeked = peekManagedArray(self, field);
+              if (peeked) {
+                const arrSignal = peeked[ARRAY_SIGNAL];
+                arrSignal.shouldReset = true;
+              }
+              if (!Array.isArray(value)) {
+                ManagedArrayMap.delete(target);
+              }
+              return true;
+            }
+          case 'object':
+            {
+              if (!field.type) {
+                let newValue = value;
+                if (value !== null) {
+                  newValue = {
+                    ...value
+                  };
+                } else {
+                  ManagedObjectMap.delete(target);
+                }
+                cache.setAttr(identifier, propArray, newValue);
+                const peeked = peekManagedObject(self, field);
+                if (peeked) {
+                  const objSignal = peeked[OBJECT_SIGNAL];
+                  objSignal.shouldReset = true;
+                }
+                return true;
+              }
+              const transform = schema.transformation(field);
+              const rawValue = transform.serialize({
+                ...value
+              }, field.options ?? null, target);
+              cache.setAttr(identifier, propArray, rawValue);
+              const peeked = peekManagedObject(self, field);
+              if (peeked) {
+                const objSignal = peeked[OBJECT_SIGNAL];
+                objSignal.shouldReset = true;
+              }
+              return true;
+            }
+          case 'schema-object':
+            {
+              let newValue = value;
+              if (value !== null) {
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Expected value to be an object`);
+                  }
+                })(typeof value === 'object') : {};
+                newValue = {
+                  ...value
+                };
+                const schemaFields = schema.fields({
+                  type: field.type
+                });
+                for (const key of Object.keys(newValue)) {
+                  if (!schemaFields.has(key)) {
+                    throw new Error(`Field ${key} does not exist on schema object ${field.type}`);
+                  }
+                }
+              } else {
+                ManagedObjectMap.delete(target);
+              }
+              cache.setAttr(identifier, propArray, newValue);
+              // const peeked = peekManagedObject(self, field);
+              // if (peeked) {
+              //   const objSignal = peeked[OBJECT_SIGNAL];
+              //   objSignal.shouldReset = true;
+              // }
+              return true;
+            }
+          case 'derived':
+            {
+              throw new Error(`Cannot set ${String(prop)} on ${identifier.type} because it is derived`);
+            }
+          case 'belongsTo':
+            if (!HAS_MODEL_PACKAGE) {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                {
+                  throw new Error(`Cannot use belongsTo fields in your schema unless @ember-data/model is installed to provide legacy model support. ${field.name} should likely be migrated to be a resource field.`);
+                }
+              })() : {};
+            }
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Expected to have a getLegacySupport function`);
+              }
+            })(getLegacySupport) : {};
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
+              }
+            })(Mode[Legacy]) : {};
+            store._join(() => {
+              getLegacySupport(receiver).setDirtyBelongsTo(field.name, value);
+            });
+            return true;
+          case 'hasMany':
+            if (!HAS_MODEL_PACKAGE) {
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                {
+                  throw new Error(`Cannot use hasMany fields in your schema unless @ember-data/model is installed to provide legacy model support.  ${field.name} should likely be migrated to be a collection field.`);
+                }
+              })() : {};
+            }
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Expected to have a getLegacySupport function`);
+              }
+            })(getLegacySupport) : {};
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+              }
+            })(Mode[Legacy]) : {};
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`You must pass an array of records to set a hasMany relationship`);
+              }
+            })(Array.isArray(value)) : {};
+            store._join(() => {
+              const support = getLegacySupport(receiver);
+              const manyArray = support.getManyArray(field.name);
+              manyArray.splice(0, manyArray.length, ...value);
+            });
+            return true;
+          default:
+            throw new Error(`Unknown field kind ${field.kind}`);
+        }
+      }
+    });
+
+    // what signal do we need for embedded record?
+    this.___notifications = store.notifications.subscribe(identifier, (_, type, key) => {
+      switch (type) {
+        case 'identity':
+          {
+            if (isEmbedded || !identityField) return; // base paths never apply to embedded records
+
+            if (identityField.name && identityField.kind === '@id') {
+              const signal = signals.get('@identity');
+              if (signal) {
+                addToTransaction(signal);
+              }
+            }
+            break;
+          }
+        case 'attributes':
+          if (key) {
+            if (Array.isArray(key)) {
+              if (!isEmbedded) return; // deep paths will be handled by embedded records
+              // TODO we should have the notification manager
+              // ensure it is safe for each callback to mutate this array
+              if (isPathMatch(embeddedPath, key)) {
+                // handle the notification
+                // TODO we should likely handle this notification here
+                // also we should add a LOGGING flag
+                // eslint-disable-next-line no-console
+                console.warn(`Notification unhandled for ${key.join(',')} on ${identifier.type}`, self);
+                return;
+              }
+
+              // TODO we should add a LOGGING flag
+              // console.log(`Deep notification skipped for ${key.join('.')} on ${identifier.type}`, self);
+              // deep notify the key path
+            } else {
+              if (isEmbedded) return; // base paths never apply to embedded records
+
+              // TODO determine what LOGGING flag to wrap this in if any
+              // console.log(`Notification for ${key} on ${identifier.type}`, self);
+              const signal = signals.get(key);
+              if (signal) {
+                addToTransaction(signal);
+              }
+              const field = fields.get(key);
+              if (field?.kind === 'array' || field?.kind === 'schema-array') {
+                const peeked = peekManagedArray(self, field);
+                if (peeked) {
+                  const arrSignal = peeked[ARRAY_SIGNAL];
+                  arrSignal.shouldReset = true;
+                  addToTransaction(arrSignal);
+                }
+              }
+              if (field?.kind === 'object') {
+                const peeked = peekManagedObject(self, field);
+                if (peeked) {
+                  const objSignal = peeked[OBJECT_SIGNAL];
+                  objSignal.shouldReset = true;
+                  addToTransaction(objSignal);
+                }
+              }
+            }
+          }
+          break;
+        case 'relationships':
+          if (key) {
+            if (Array.isArray(key)) ;else {
+              if (isEmbedded) return; // base paths never apply to embedded records
+
+              const field = fields.get(key);
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected relationshp ${key} to be the name of a field`);
+                }
+              })(field) : {};
+              if (field.kind === 'belongsTo') {
+                // TODO determine what LOGGING flag to wrap this in if any
+                // console.log(`Notification for ${key} on ${identifier.type}`, self);
+                const signal = signals.get(key);
+                if (signal) {
+                  addToTransaction(signal);
+                }
+                // FIXME
+              } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Expected to have a getLegacySupport function`);
+                  }
+                })(getLegacySupport) : {};
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+                  }
+                })(Mode[Legacy]) : {};
+                const support = getLegacySupport(proxy);
+                const manyArray = support && support._manyArrayCache[key];
+                const hasPromise = support && support._relationshipPromisesCache[key];
+                if (manyArray && hasPromise) {
+                  // do nothing, we will notify the ManyArray directly
+                  // once the fetch has completed.
+                  return;
+                }
+                if (manyArray) {
+                  manyArray.notify();
+                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected options to exist on relationship meta`);
+                    }
+                  })(field.options) : {};
+                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected async to exist on relationship meta options`);
+                    }
+                  })('async' in field.options) : {};
+                  if (field.options.async) {
+                    const signal = signals.get(key);
+                    if (signal) {
+                      addToTransaction(signal);
+                    }
+                  }
+                }
+              } else if (field.kind === 'collection') ;
+            }
+          }
+          break;
+      }
+    });
+    return proxy;
+  }
+  [Destroy]() {
+    if (this[Legacy]) {
+      // @ts-expect-error
+      this.isDestroying = true;
+      // @ts-expect-error
+      this.isDestroyed = true;
+    }
+    this[RecordStore].notifications.unsubscribe(this.___notifications);
+  }
+  [Checkout]() {
+    const editable = Editables.get(this);
+    if (editable) {
+      return Promise.resolve(editable);
+    }
+    const embeddedType = this[EmbeddedType];
+    const embeddedPath = this[EmbeddedPath];
+    const isEmbedded = embeddedType !== null && embeddedPath !== null;
+    if (isEmbedded) {
+      throw new Error(`Cannot checkout an embedded record (yet)`);
+    }
+    const editableRecord = new SchemaRecord(this[RecordStore], this[Identifier], {
+      [Editable]: true,
+      [Legacy]: this[Legacy]
+    }, isEmbedded, embeddedType, embeddedPath);
+    setRecordIdentifier(editableRecord, recordIdentifierFor(this));
+    return Promise.resolve(editableRecord);
+  }
+}
+export { Checkout, Editable, Legacy, SchemaRecord };