@warp-drive/schema-record 0.0.0-beta.9 → 0.0.0

package/dist/hooks.js

@@ -3,7 +3,7 @@ import { E as Editable, L as Legacy, D as Destroy } from "./symbols-DqoS4ybV.js"
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
   const isLegacy = schema.resource(identifier)?.legacy ?? false;
-  const isEditable = isLegacy || Boolean(createArgs);
+  const isEditable = isLegacy || store.cache.isNew(identifier);
   const record = new SchemaRecord(store, identifier, {
     [Editable]: isEditable,
     [Legacy]: isLegacy

package/dist/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","sources":["../src/hooks.ts"],"sourcesContent":["import type Store from '@ember-data/store';\nimport type { StableRecordIdentifier } from '@warp-drive/core-types';\n\nimport { SchemaRecord } from './record';\nimport type { SchemaService } from './schema';\nimport { Destroy, Editable, Legacy } from './symbols';\n\nexport function instantiateRecord(\n  store: Store,\n  identifier: StableRecordIdentifier,\n  createArgs?: Record<string, unknown>\n): SchemaRecord {\n  const schema = store.schema as unknown as SchemaService;\n  const isLegacy = schema.resource(identifier)?.legacy ?? false;\n  const isEditable = isLegacy || Boolean(createArgs);\n  const record = new SchemaRecord(store, identifier, {\n    [Editable]: isEditable,\n    [Legacy]: isLegacy,\n  });\n\n  if (createArgs) {\n    Object.assign(record, createArgs);\n  }\n\n  return record;\n}\n\nexport function teardownRecord(record: SchemaRecord): void {\n  record[Destroy]();\n}\n"],"names":["instantiateRecord","store","identifier","createArgs","schema","isLegacy","resource","legacy","isEditable","Boolean","record","SchemaRecord","Editable","Legacy","Object","assign","teardownRecord","Destroy"],"mappings":";;;AAOO,SAASA,iBAAiBA,CAC/BC,KAAY,EACZC,UAAkC,EAClCC,UAAoC,EACtB;AACd,EAAA,MAAMC,MAAM,GAAGH,KAAK,CAACG,MAAkC,CAAA;EACvD,MAAMC,QAAQ,GAAGD,MAAM,CAACE,QAAQ,CAACJ,UAAU,CAAC,EAAEK,MAAM,IAAI,KAAK,CAAA;AAC7D,EAAA,MAAMC,UAAU,GAAGH,QAAQ,IAAII,OAAO,CAACN,UAAU,CAAC,CAAA;EAClD,MAAMO,MAAM,GAAG,IAAIC,YAAY,CAACV,KAAK,EAAEC,UAAU,EAAE;IACjD,CAACU,QAAQ,GAAGJ,UAAU;AACtB,IAAA,CAACK,MAAM,GAAGR,QAAAA;AACZ,GAAC,CAAC,CAAA;AAEF,EAAA,IAAIF,UAAU,EAAE;AACdW,IAAAA,MAAM,CAACC,MAAM,CAACL,MAAM,EAAEP,UAAU,CAAC,CAAA;AACnC,GAAA;AAEA,EAAA,OAAOO,MAAM,CAAA;AACf,CAAA;AAEO,SAASM,cAAcA,CAACN,MAAoB,EAAQ;AACzDA,EAAAA,MAAM,CAACO,OAAO,CAAC,EAAE,CAAA;AACnB;;;;"}
+{"version":3,"file":"hooks.js","sources":["../src/hooks.ts"],"sourcesContent":["import type Store from '@ember-data/store';\nimport type { StableRecordIdentifier } from '@warp-drive/core-types';\n\nimport { SchemaRecord } from './record';\nimport type { SchemaService } from './schema';\nimport { Destroy, Editable, Legacy } from './symbols';\n\nexport function instantiateRecord(\n  store: Store,\n  identifier: StableRecordIdentifier,\n  createArgs?: Record<string, unknown>\n): SchemaRecord {\n  const schema = store.schema as unknown as SchemaService;\n  const isLegacy = schema.resource(identifier)?.legacy ?? false;\n  const isEditable = isLegacy || store.cache.isNew(identifier);\n  const record = new SchemaRecord(store, identifier, {\n    [Editable]: isEditable,\n    [Legacy]: isLegacy,\n  });\n\n  if (createArgs) {\n    Object.assign(record, createArgs);\n  }\n\n  return record;\n}\n\nexport function teardownRecord(record: SchemaRecord): void {\n  record[Destroy]();\n}\n"],"names":["instantiateRecord","store","identifier","createArgs","schema","isLegacy","resource","legacy","isEditable","cache","isNew","record","SchemaRecord","Editable","Legacy","Object","assign","teardownRecord","Destroy"],"mappings":";;;AAOO,SAASA,iBAAiBA,CAC/BC,KAAY,EACZC,UAAkC,EAClCC,UAAoC,EACtB;AACd,EAAA,MAAMC,MAAM,GAAGH,KAAK,CAACG,MAAkC,CAAA;EACvD,MAAMC,QAAQ,GAAGD,MAAM,CAACE,QAAQ,CAACJ,UAAU,CAAC,EAAEK,MAAM,IAAI,KAAK,CAAA;EAC7D,MAAMC,UAAU,GAAGH,QAAQ,IAAIJ,KAAK,CAACQ,KAAK,CAACC,KAAK,CAACR,UAAU,CAAC,CAAA;EAC5D,MAAMS,MAAM,GAAG,IAAIC,YAAY,CAACX,KAAK,EAAEC,UAAU,EAAE;IACjD,CAACW,QAAQ,GAAGL,UAAU;AACtB,IAAA,CAACM,MAAM,GAAGT,QAAAA;AACZ,GAAC,CAAC,CAAA;AAEF,EAAA,IAAIF,UAAU,EAAE;AACdY,IAAAA,MAAM,CAACC,MAAM,CAACL,MAAM,EAAER,UAAU,CAAC,CAAA;AACnC,GAAA;AAEA,EAAA,OAAOQ,MAAM,CAAA;AACf,CAAA;AAEO,SAASM,cAAcA,CAACN,MAAoB,EAAQ;AACzDA,EAAAA,MAAM,CAACO,OAAO,CAAC,EAAE,CAAA;AACnB;;;;"}

package/dist/record.js

@@ -1,18 +1,21 @@
 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, I as Identifier, E as Editable, L as Legacy, O as OBJECT_SIGNAL, P as Parent, D as Destroy, C as Checkout, a as EmbeddedPath, b as EmbeddedType } from "./symbols-DqoS4ybV.js";
+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);
 }
-// function isArraySetter<T>(prop: KeyType): prop is keyof Array<T> {
-//   return ARRAY_SETTER_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;
 // }
@@ -48,14 +51,16 @@ function safeForEach(instance, arr, store, callback, target) {
 }
 class ManagedArray {
   [SOURCE];
-  constructor(store, schema, cache, field, data, address, path, owner, isSchemaArray) {
+  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.address = address;
+    this.identifier = identifier;
     this.path = path;
     this.owner = owner;
     let transaction = false;
@@ -74,8 +79,8 @@ class ManagedArray {
         if (prop === ARRAY_SIGNAL) {
           return _SIGNAL;
         }
-        if (prop === 'address') {
-          return self.address;
+        if (prop === 'identifier') {
+          return self.identifier;
         }
         if (prop === 'owner') {
           return self.owner;
@@ -84,7 +89,7 @@ class ManagedArray {
         if (_SIGNAL.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
           _SIGNAL.t = false;
           _SIGNAL.shouldReset = false;
-          const newData = cache.getAttr(address, path);
+          const newData = cache.getAttr(identifier, path);
           if (newData && newData !== self[SOURCE]) {
             self[SOURCE].length = 0;
             self[SOURCE].push(...newData);
@@ -144,7 +149,8 @@ class ManagedArray {
                 // same object reference from cache should result in same SchemaRecord
                 // embedded object.
                 recordPath.push(index);
-                record = new SchemaRecord(store, self.owner[Identifier], {
+                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);
@@ -195,12 +201,36 @@ class ManagedArray {
           }
           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 (prop === 'address') {
+        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.address = value;
+          self.identifier = value;
           return true;
         }
         if (prop === 'owner') {
@@ -211,7 +241,7 @@ class ManagedArray {
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
           if (!field.type) {
-            cache.setAttr(address, path, self[SOURCE]);
+            cache.setAttr(identifier, path, self[SOURCE]);
             _SIGNAL.shouldReset = true;
             return true;
           }
@@ -219,11 +249,11 @@ class ManagedArray {
           if (!isSchemaArray) {
             const transform = schema.transformation(field);
             if (!transform) {
-              throw new Error(`No '${field.type}' transform defined for use by ${address.type}.${String(prop)}`);
+              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(address, path, rawValue);
+          cache.setAttr(identifier, path, rawValue);
           _SIGNAL.shouldReset = true;
         }
         return reflect;
@@ -232,41 +262,53 @@ class ManagedArray {
     return proxy;
   }
 }
-const ignoredGlobalFields = new Set(['constructor', 'setInterval', 'nodeType', 'length']);
+const ObjectSymbols = new Set([OBJECT_SIGNAL, Parent, SOURCE, Editable, EmbeddedPath]);
+
+// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
+
 class ManagedObject {
-  [SOURCE];
-  constructor(store, schema, cache, field, data, address, key, owner, isSchemaObject) {
+  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 boundFns = new Map<KeyType, ProxiedMethod>();
-    this.address = address;
-    this.key = key;
-    this.owner = owner;
     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 (prop === OBJECT_SIGNAL) {
-          return _SIGNAL;
+        if (ObjectSymbols.has(prop)) {
+          return self[prop];
         }
-        if (prop === 'address') {
-          return self.address;
-        }
-        if (prop === 'key') {
-          return self.key;
-        }
-        if (prop === 'owner') {
-          return self.owner;
+        if (prop === Symbol.toPrimitive) {
+          return null;
         }
         if (prop === Symbol.toStringTag) {
-          return `ManagedObject<${address.type}:${address.id} (${address.lid})>`;
+          return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
+        }
+        if (prop === 'constructor') {
+          return Object;
         }
         if (prop === 'toString') {
           return function () {
-            return `ManagedObject<${address.type}:${address.id} (${address.lid})>`;
+            return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
           };
         }
         if (prop === 'toHTML') {
@@ -277,71 +319,42 @@ class ManagedObject {
         if (_SIGNAL.shouldReset) {
           _SIGNAL.t = false;
           _SIGNAL.shouldReset = false;
-          let newData = cache.getAttr(self.address, self.key);
+          let newData = cache.getAttr(identifier, path);
           if (newData && newData !== self[SOURCE]) {
-            if (!isSchemaObject && field.type) {
+            if (field.type) {
               const transform = schema.transformation(field);
-              newData = transform.hydrate(newData, field.options ?? null, self.owner);
+              newData = transform.hydrate(newData, field.options ?? null, owner);
             }
             self[SOURCE] = {
               ...newData
             }; // Add type assertion for newData
           }
         }
-        if (isSchemaObject) {
-          const fields = schema.fields({
-            type: field.type
-          });
-          // TODO: is there a better way to do this?
-          if (typeof prop === 'string' && !ignoredGlobalFields.has(prop) && !fields.has(prop)) {
-            throw new Error(`Field ${prop} does not exist on schema object ${field.type}`);
-          }
-        }
         if (prop in self[SOURCE]) {
-          {
-            subscribe(_SIGNAL);
-          }
+          subscribe(_SIGNAL);
           return self[SOURCE][prop];
         }
         return Reflect.get(target, prop, receiver);
       },
       set(target, prop, value, receiver) {
-        if (prop === 'address') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          self.address = value;
-          return true;
-        }
-        if (prop === 'key') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          self.key = value;
-          return true;
-        }
-        if (prop === 'owner') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          self.owner = value;
-          return true;
-        }
-        if (isSchemaObject) {
-          const fields = schema.fields({
-            type: field.type
-          });
-          if (typeof prop === 'string' && !ignoredGlobalFields.has(prop) && !fields.has(prop)) {
-            throw new Error(`Field ${prop} does not exist on schema object ${field.type}`);
+        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) {
-          if (isSchemaObject || !field.type) {
-            cache.setAttr(self.address, self.key, self[SOURCE]);
-            _SIGNAL.shouldReset = true;
-            return true;
-          }
+        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, self.owner);
-          cache.setAttr(self.address, self.key, val);
-          _SIGNAL.shouldReset = true;
+          const val = transform.serialize(self[SOURCE], field.options ?? null, owner);
+          cache.setAttr(identifier, path, val);
         }
-        return reflect;
+        _SIGNAL.shouldReset = true;
+        return true;
       }
     });
     return proxy;
@@ -377,7 +390,7 @@ function computeField(schema, cache, record, identifier, field, prop) {
   const transform = schema.transformation(field);
   return transform.hydrate(rawValue, field.options ?? null, record);
 }
-function computeArray(store, schema, cache, record, identifier, field, path, isSchemaArray = false) {
+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
@@ -396,7 +409,7 @@ function computeArray(store, schema, cache, record, identifier, field, path, isS
     if (!rawValue) {
       return null;
     }
-    managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, path, record, isSchemaArray);
+    managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, path, record, isSchemaArray, editable, legacy);
     if (!managedArrayMapForRecord) {
       ManagedArrayMap.set(record, new Map([[field, managedArray]]));
     } else {
@@ -405,7 +418,7 @@ function computeArray(store, schema, cache, record, identifier, field, path, isS
   }
   return managedArray;
 }
-function computeObject(store, schema, cache, record, identifier, field, prop, isSchemaObject = false) {
+function computeObject(schema, cache, record, identifier, field, path, editable, legacy) {
   const managedObjectMapForRecord = ManagedObjectMap.get(record);
   let managedObject;
   if (managedObjectMapForRecord) {
@@ -414,17 +427,15 @@ function computeObject(store, schema, cache, record, identifier, field, prop, is
   if (managedObject) {
     return managedObject;
   } else {
-    let rawValue = cache.getAttr(identifier, prop);
+    let rawValue = cache.getAttr(identifier, path);
     if (!rawValue) {
       return null;
     }
-    if (field.kind === 'object') {
-      if (field.type) {
-        const transform = schema.transformation(field);
-        rawValue = transform.hydrate(rawValue, field.options ?? null, record);
-      }
+    if (field.type) {
+      const transform = schema.transformation(field);
+      rawValue = transform.hydrate(rawValue, field.options ?? null, record);
     }
-    managedObject = new ManagedObject(store, schema, cache, field, rawValue, identifier, prop, record, isSchemaObject);
+    managedObject = new ManagedObject(schema, cache, field, rawValue, identifier, path, record, editable, legacy);
     if (!managedObjectMapForRecord) {
       ManagedObjectMap.set(record, new Map([[field, managedObject]]));
     } else {
@@ -433,6 +444,32 @@ function computeObject(store, schema, cache, record, identifier, field, prop, is
   }
   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);
 }
@@ -494,12 +531,13 @@ function computeResource(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', STRUCTURED]);
+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
@@ -550,6 +588,7 @@ class SchemaRecord {
           case 'field':
           case 'attribute':
           case 'resource':
+          case 'alias':
           case 'belongsTo':
           case 'hasMany':
           case 'collection':
@@ -576,6 +615,11 @@ class SchemaRecord {
             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;
         }
@@ -589,10 +633,8 @@ class SchemaRecord {
         // for its own usage.
         // _, @, $, *
 
-        const propArray = isEmbedded ? embeddedPath.slice() : [];
-        propArray.push(prop);
-        const field = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!field) {
+        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
+        if (!maybeField) {
           if (IgnoredGlobalFields.has(prop)) {
             return undefined;
           }
@@ -603,8 +645,24 @@ class SchemaRecord {
           if (typeof prop === 'symbol') {
             return undefined;
           }
-          throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
+          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');
@@ -641,7 +699,7 @@ class SchemaRecord {
             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);
+            return computeArray(store, schema, cache, target, identifier, field, propArray, true, Mode[Editable], Mode[Legacy]);
           case 'array':
             macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
               if (!test) {
@@ -649,13 +707,16 @@ class SchemaRecord {
               }
             })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
-            return computeArray(store, schema, cache, target, identifier, field, propArray);
-          case 'schema-object':
-            // validate any access off of schema, no transform to run
-            // use raw cache value as the object to manage
-            entangleSignal(signals, receiver, field.name);
-            return computeObject(store, schema, cache, target, identifier, field, prop, true);
+            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}'`);
@@ -663,7 +724,7 @@ class SchemaRecord {
             })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
             // run transform, then use that value as the object to manage
-            return computeObject(store, schema, cache, target, identifier, field, prop);
+            return computeSchemaObject(store, cache, target, identifier, field, propArray, Mode[Legacy], Mode[Editable]);
           case 'belongsTo':
             if (!HAS_MODEL_PACKAGE) {
               macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -710,14 +771,26 @@ class SchemaRecord {
       },
       set(target, prop, value, receiver) {
         if (!IS_EDITABLE) {
-          throw new Error(`Cannot set ${String(prop)} on ${identifier.type} because the record is not editable`);
+          const type = isEmbedded ? embeddedType : identifier.type;
+          throw new Error(`Cannot set ${String(prop)} on ${type} because the record is not editable`);
         }
-        const propArray = isEmbedded ? embeddedPath.slice() : [];
-        propArray.push(prop);
-        const field = prop === identityField?.name ? identityField : fields.get(prop);
-        if (!field) {
-          throw new Error(`There is no field named ${String(prop)} on ${identifier.type}`);
+        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':
             {
@@ -840,6 +913,11 @@ class SchemaRecord {
             {
               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
                 };
@@ -855,11 +933,11 @@ class SchemaRecord {
                 ManagedObjectMap.delete(target);
               }
               cache.setAttr(identifier, propArray, newValue);
-              const peeked = peekManagedObject(self, field);
-              if (peeked) {
-                const objSignal = peeked[OBJECT_SIGNAL];
-                objSignal.shouldReset = true;
-              }
+              // const peeked = peekManagedObject(self, field);
+              // if (peeked) {
+              //   const objSignal = peeked[OBJECT_SIGNAL];
+              //   objSignal.shouldReset = true;
+              // }
               return true;
             }
           case 'derived':
@@ -974,7 +1052,7 @@ class SchemaRecord {
                   addToTransaction(arrSignal);
                 }
               }
-              if (field?.kind === 'object' || field?.kind === 'schema-object') {
+              if (field?.kind === 'object') {
                 const peeked = peekManagedObject(self, field);
                 if (peeked) {
                   const objSignal = peeked[OBJECT_SIGNAL];
@@ -1060,7 +1138,22 @@ class SchemaRecord {
     this[RecordStore].notifications.unsubscribe(this.___notifications);
   }
   [Checkout]() {
-    return Promise.resolve(this);
+    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 { Editable, Legacy, SchemaRecord };
+export { Checkout, Editable, Legacy, SchemaRecord };