@warp-drive/schema-record 0.0.0-alpha.56 → 0.0.0-alpha.58

package/dist/hooks.js

@@ -1,5 +1,5 @@
 import { SchemaRecord } from "./record";
-import { E as Editable, L as Legacy, D as Destroy } from "./symbols-CAUfvZjq";
+import { E as Editable, L as Legacy, D as Destroy } from "./symbols-DqoS4ybV";
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
   const isLegacy = schema.resource(identifier)?.legacy ?? false;

package/dist/record.js

@@ -2,7 +2,7 @@ import { createSignal, subscribe, defineSignal, Signals, addToTransaction, entan
 import { getOrSetGlobal } from '@warp-drive/core-types/-private';
 import { STRUCTURED } from '@warp-drive/core-types/request';
 import { RecordStore } from '@warp-drive/core-types/symbols';
-import { S as SOURCE, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, D as Destroy, I as Identifier, E as Editable, P as Parent, C as Checkout, L as Legacy } from "./symbols-CAUfvZjq";
+import { S as SOURCE, A as ARRAY_SIGNAL, I as Identifier, E as Editable, L as Legacy, O as OBJECT_SIGNAL, D as Destroy, P as Parent, C as Checkout, a as EmbeddedPath, b as EmbeddedType } from "./symbols-DqoS4ybV";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 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']);
@@ -48,7 +48,7 @@ function safeForEach(instance, arr, store, callback, target) {
 }
 class ManagedArray {
   [SOURCE];
-  constructor(store, schema, cache, field, data, address, key, owner) {
+  constructor(store, schema, cache, field, data, address, path, owner, isSchemaArray) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     this[SOURCE] = data?.slice();
@@ -56,9 +56,19 @@ class ManagedArray {
     const _SIGNAL = this[ARRAY_SIGNAL];
     const boundFns = new Map();
     this.address = address;
-    this.key = key;
+    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) {
@@ -67,9 +77,6 @@ class ManagedArray {
         if (prop === 'address') {
           return self.address;
         }
-        if (prop === 'key') {
-          return self.key;
-        }
         if (prop === 'owner') {
           return self.owner;
         }
@@ -77,24 +84,87 @@ class ManagedArray {
         if (_SIGNAL.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
           _SIGNAL.t = false;
           _SIGNAL.shouldReset = false;
-          const newData = cache.getAttr(self.address, self.key);
+          const newData = cache.getAttr(address, path);
           if (newData && newData !== self[SOURCE]) {
             self[SOURCE].length = 0;
             self[SOURCE].push(...newData);
           }
         }
         if (index !== null) {
-          const val = target[index];
+          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);
+                record = new SchemaRecord(store, self.owner[Identifier], {
+                  [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.type);
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`No '${field.type}' transform defined for use by ${address.type}.${String(prop)}`);
-              }
-            })(transform) : {};
+            const transform = schema.transformation(field);
             return transform.hydrate(val, field.options ?? null, self.owner);
           }
           return val;
@@ -133,11 +203,6 @@ class ManagedArray {
           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;
@@ -146,18 +211,19 @@ class ManagedArray {
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
           if (!field.type) {
-            cache.setAttr(self.address, self.key, self[SOURCE]);
+            cache.setAttr(address, path, self[SOURCE]);
             _SIGNAL.shouldReset = true;
             return true;
           }
-          const transform = schema.transformation(field.type);
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            if (!test) {
+          let rawValue = self[SOURCE];
+          if (!isSchemaArray) {
+            const transform = schema.transformation(field);
+            if (!transform) {
               throw new Error(`No '${field.type}' transform defined for use by ${address.type}.${String(prop)}`);
             }
-          })(transform) : {};
-          const rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
-          cache.setAttr(self.address, self.key, rawValue);
+            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
+          }
+          cache.setAttr(address, path, rawValue);
           _SIGNAL.shouldReset = true;
         }
         return reflect;
@@ -200,12 +266,7 @@ class ManagedObject {
           let newData = cache.getAttr(self.address, self.key);
           if (newData && newData !== self[SOURCE]) {
             if (field.type) {
-              const transform = schema.transformation(field.type);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`No '${field.type}' transform defined for use by ${address.type}.${String(prop)}`);
-                }
-              })(transform) : {};
+              const transform = schema.transformation(field);
               newData = transform.hydrate(newData, field.options ?? null, self.owner);
             }
             self[SOURCE] = {
@@ -244,12 +305,7 @@ class ManagedObject {
             _SIGNAL.shouldReset = true;
             return true;
           }
-          const transform = schema.transformation(field.type);
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            if (!test) {
-              throw new Error(`No '${field.type}' transform defined for use by ${address.type}.${String(prop)}`);
-            }
-          })(transform) : {};
+          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;
@@ -260,8 +316,8 @@ class ManagedObject {
     return proxy;
   }
 }
-const IgnoredGlobalFields = new Set(['then', STRUCTURED]);
-const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, Signals];
+const IgnoredGlobalFields = new Set(['length', 'nodeType', 'then', 'setInterval', STRUCTURED]);
+const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, Signals, EmbeddedPath, EmbeddedType];
 const RecordSymbols = new Set(symbolList);
 const ManagedArrayMap = getOrSetGlobal('ManagedArrayMap', new Map());
 const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
@@ -290,15 +346,10 @@ function computeField(schema, cache, record, identifier, field, prop) {
   if (!field.type) {
     return rawValue;
   }
-  const transform = schema.transformation(field.type);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-    }
-  })(transform) : {};
+  const transform = schema.transformation(field);
   return transform.hydrate(rawValue, field.options ?? null, record);
 }
-function computeArray(store, schema, cache, record, identifier, field, prop) {
+function computeArray(store, schema, cache, record, identifier, field, path, isSchemaArray = false) {
   // 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
@@ -313,11 +364,11 @@ function computeArray(store, schema, cache, record, identifier, field, prop) {
   if (managedArray) {
     return managedArray;
   } else {
-    const rawValue = cache.getAttr(identifier, prop);
+    const rawValue = cache.getAttr(identifier, path);
     if (!rawValue) {
       return null;
     }
-    managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, prop, record);
+    managedArray = new ManagedArray(store, schema, cache, field, rawValue, identifier, path, record, isSchemaArray);
     if (!managedArrayMapForRecord) {
       ManagedArrayMap.set(record, new Map([[field, managedArray]]));
     } else {
@@ -341,12 +392,7 @@ function computeObject(store, schema, cache, record, identifier, field, prop) {
     }
     if (field.kind === 'object') {
       if (field.type) {
-        const transform = schema.transformation(field.type);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-          }
-        })(transform) : {};
+        const transform = schema.transformation(field);
         rawValue = transform.hydrate(rawValue, field.options ?? null, record);
       }
     }
@@ -363,16 +409,7 @@ function computeAttribute(cache, identifier, prop) {
   return cache.getAttr(identifier, prop);
 }
 function computeDerivation(schema, record, identifier, field, prop) {
-  if (!field.type) {
-    throw new Error(`The schema for ${identifier.type}.${String(prop)} is missing the type of the derivation`);
-  }
-  const derivation = schema.derivation(field.type);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`No '${field.type}' derivation defined for use by ${identifier.type}.${String(prop)}`);
-    }
-  })(derivation) : {};
-  return derivation(record, field.options ?? null, prop);
+  return schema.derivation(field)(record, field.options ?? null, prop);
 }
 
 // TODO probably this should just be a Document
@@ -412,6 +449,9 @@ class ResourceRelationship {
 defineSignal(ResourceRelationship.prototype, 'data');
 defineSignal(ResourceRelationship.prototype, 'links');
 defineSignal(ResourceRelationship.prototype, 'meta');
+function isPathMatch(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
 function getHref(link) {
   if (!link) {
     return null;
@@ -428,34 +468,70 @@ function computeResource(store, cache, parent, identifier, field, prop) {
   return new ResourceRelationship(store, cache, parent, identifier, field, prop);
 }
 class SchemaRecord {
-  constructor(store, identifier, Mode) {
+  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;
-    this[Identifier] = identifier;
+    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;
-    const fields = schema.fields(identifier);
+    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;
+    // what signal do we need for embedded record?
     this.___notifications = store.notifications.subscribe(identifier, (_, type, key) => {
       switch (type) {
         case 'attributes':
           if (key) {
-            const signal = signals.get(key);
-            if (signal) {
-              addToTransaction(signal);
-            }
-            const field = fields.get(key);
-            if (field?.kind === 'array') {
-              const peeked = peekManagedArray(self, field);
-              if (peeked) {
-                const arrSignal = peeked[ARRAY_SIGNAL];
-                arrSignal.shouldReset = true;
-                addToTransaction(arrSignal);
+            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);
+                }
               }
             }
           }
@@ -463,10 +539,54 @@ class SchemaRecord {
       }
     });
     return 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 '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 === Symbol.toPrimitive) {
+          return null;
+        }
         if (prop === '___notifications') {
           return target.___notifications;
         }
@@ -475,11 +595,16 @@ 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) {
           if (IgnoredGlobalFields.has(prop)) {
             return undefined;
           }
+          if (prop === 'constructor') {
+            return SchemaRecord;
+          }
           throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
         }
         switch (field.kind) {
@@ -488,7 +613,7 @@ class SchemaRecord {
             return identifier.id;
           case '@hash':
             // TODO pass actual cache value not {}
-            return schema.hashFn(field.type)({}, field.options ?? null, field.name ?? null);
+            return schema.hashFn(field)({}, field.options ?? null, field.name ?? null);
           case '@local':
             {
               const lastValue = computeLocal(receiver, field, prop);
@@ -502,7 +627,7 @@ class SchemaRecord {
               }
             })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
-            return computeField(schema, cache, target, identifier, field, prop);
+            return computeField(schema, cache, target, identifier, field, propArray);
           case 'attribute':
             entangleSignal(signals, receiver, field.name);
             return computeAttribute(cache, identifier, prop);
@@ -517,7 +642,8 @@ class SchemaRecord {
           case 'derived':
             return computeDerivation(schema, receiver, identifier, field, prop);
           case 'schema-array':
-            throw new Error(`Not Implemented`);
+            entangleSignal(signals, receiver, field.name);
+            return computeArray(store, schema, cache, target, identifier, field, propArray, true);
           case 'array':
             macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
               if (!test) {
@@ -525,7 +651,7 @@ class SchemaRecord {
               }
             })(!target[Legacy]) : {};
             entangleSignal(signals, receiver, field.name);
-            return computeArray(store, schema, cache, target, identifier, field, prop);
+            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
@@ -547,6 +673,8 @@ class SchemaRecord {
         if (!IS_EDITABLE) {
           throw new Error(`Cannot set ${String(prop)} on ${identifier.type} because the record is not editable`);
         }
+        const propArray = isEmbedded ? embeddedPath.slice() : [];
+        propArray.push(prop);
         const field = fields.get(prop);
         if (!field) {
           throw new Error(`There is no field named ${String(prop)} on ${identifier.type}`);
@@ -564,28 +692,23 @@ class SchemaRecord {
           case 'field':
             {
               if (!field.type) {
-                cache.setAttr(identifier, prop, value);
+                cache.setAttr(identifier, propArray, value);
                 return true;
               }
-              const transform = schema.transformation(field.type);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-                }
-              })(transform) : {};
+              const transform = schema.transformation(field);
               const rawValue = transform.serialize(value, field.options ?? null, target);
-              cache.setAttr(identifier, prop, rawValue);
+              cache.setAttr(identifier, propArray, rawValue);
               return true;
             }
           case 'attribute':
             {
-              cache.setAttr(identifier, prop, value);
+              cache.setAttr(identifier, propArray, value);
               return true;
             }
           case 'array':
             {
               if (!field.type) {
-                cache.setAttr(identifier, prop, value?.slice());
+                cache.setAttr(identifier, propArray, value?.slice());
                 const peeked = peekManagedArray(self, field);
                 if (peeked) {
                   const arrSignal = peeked[ARRAY_SIGNAL];
@@ -596,19 +719,31 @@ class SchemaRecord {
                 }
                 return true;
               }
-              const transform = schema.transformation(field.type);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-                }
-              })(transform) : {};
+              const transform = schema.transformation(field);
               const rawValue = value.map(item => transform.serialize(item, field.options ?? null, target));
-              cache.setAttr(identifier, prop, rawValue);
+              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':
@@ -622,7 +757,7 @@ class SchemaRecord {
                 } else {
                   ManagedObjectMap.delete(target);
                 }
-                cache.setAttr(identifier, prop, newValue);
+                cache.setAttr(identifier, propArray, newValue);
                 const peeked = peekManagedObject(self, field);
                 if (peeked) {
                   const objSignal = peeked[OBJECT_SIGNAL];
@@ -630,16 +765,11 @@ class SchemaRecord {
                 }
                 return true;
               }
-              const transform = schema.transformation(field.type);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`No '${field.type}' transform defined for use by ${identifier.type}.${String(prop)}`);
-                }
-              })(transform) : {};
+              const transform = schema.transformation(field);
               const rawValue = transform.serialize({
                 ...value
               }, field.options ?? null, target);
-              cache.setAttr(identifier, prop, rawValue);
+              cache.setAttr(identifier, propArray, rawValue);
               const peeked = peekManagedObject(self, field);
               if (peeked) {
                 const objSignal = peeked[OBJECT_SIGNAL];