@warp-drive/schema-record 5.4.1-beta.1 → 5.4.1-beta.2

package/README.md

@@ -23,15 +23,9 @@
 - ⚛️ Universal
 - ☢️ Reactive
 
-SchemaRecord is a reactive object that transforms raw data from an [associated cache](https://github.com/emberjs/data/blob/main/packages/core-types/src/cache.ts) into reactive data backed by Signals.
+SchemaRecord is a reactive object that transforms raw data from an [associated cache](https://github.com/emberjs/data/blob/main/packages/core-types/src/cache.ts) into reactive data backed by Signals. The shape of the object and the transformation of raw cache data into its reactive form is controlled by a resource schema. Resource schemas are simple JSON, allowing them to be defined and delivered from anywhere.
 
-The shape of the object and the transformation of raw cache data into its
-reactive form is controlled by a resource schema.
-
-Resource schemas are simple JSON, allowing them to be defined and delivered from anywhere.
-
-The capabilities that SchemaRecord brings to [*Warp***Drive**](https://github.com/emberjs/data/)
-will simplify even the most complex parts of your app's state management.
+The capabilities that SchemaRecord brings to [*Warp***Drive**](https://github.com/emberjs/data/) will simplify even the most complex parts of your app's state management.
 
 ## Installation
 
@@ -266,7 +260,9 @@ store.schema.registerResources([
         options: {
           async: false,
           inverse: 'owner',
-          polymorphic: true
+          polymorphic: true,
+          linksMode: true,
+          resetOnRemoteUpdate: false
         }
       }
     ]
@@ -283,6 +279,8 @@ store.schema.registerResources([
           async: false,
           inverse: 'pets',
           as: 'pet',
+          linksMode: true,
+          resetOnRemoteUpdate: false
         }
       }
     ]

package/dist/-private.js

@@ -1 +1 @@
-export { E as Editable, L as Legacy } from "./symbols-DqoS4ybV.js";
+export { E as Editable, L as Legacy } from "./symbols-B_60yPO2.js";

package/dist/index.js

@@ -1,14 +1,12 @@
 import { isResourceSchema } from '@warp-drive/core-types/schema/fields';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { SOURCE as SOURCE$1, fastPush, RelatedCollection, setRecordIdentifier, recordIdentifierFor } from '@ember-data/store/-private';
-import { createSignal, subscribe, defineSignal, peekSignal, getSignal, Signals, addToTransaction, entangleSignal } from '@ember-data/tracking/-private';
+import { withSignalStore, entangleSignal, ARRAY_SIGNAL, consumeInternalSignal, OBJECT_SIGNAL, SOURCE as SOURCE$1, fastPush, defineSignal, RelatedCollection, getOrCreateInternalSignal, notifyInternalSignal, Signals, setRecordIdentifier, recordIdentifierFor, createMemo } from '@ember-data/store/-private';
 import { EnableHydration, STRUCTURED } from '@warp-drive/core-types/request';
 import { RecordStore, Type } from '@warp-drive/core-types/symbols';
 import { getOrSetGlobal } from '@warp-drive/core-types/-private';
-import { S as SOURCE, A as ARRAY_SIGNAL, E as Editable, L as Legacy, I as Identifier, P as Parent, O as OBJECT_SIGNAL, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedType } from "./symbols-DqoS4ybV.js";
+import { S as SOURCE, E as Editable, L as Legacy, I as Identifier, P as Parent, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedType } from "./symbols-B_60yPO2.js";
 import { deprecate } from '@ember/debug';
 import { recordIdentifierFor as recordIdentifierFor$1 } from '@ember-data/store';
-import { createCache, getValue } from '@ember-data/tracking';
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 // const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
 const SYNC_PROPS = new Set(['[]', 'length']);
@@ -59,10 +57,13 @@ class ManagedArray {
     // 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];
+
+    // FIXME probably can get rid of the manual ARRAY_SIGNAL storage
+    // FIXME probably the storage should be on the proxy/receiver not this class
+    const signals = withSignalStore(this);
+    const _SIGNAL = this[ARRAY_SIGNAL] = entangleSignal(signals, this, ARRAY_SIGNAL, undefined);
     const boundFns = new Map();
     this.identifier = identifier;
     this.path = path;
@@ -90,9 +91,8 @@ class ManagedArray {
           return self.owner;
         }
         const index = convertToInt(prop);
-        if (_SIGNAL.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
-          _SIGNAL.t = false;
-          _SIGNAL.shouldReset = false;
+        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
+          _SIGNAL.isStale = false;
           const newData = cache.getAttr(identifier, path);
           if (newData && newData !== self[SOURCE]) {
             self[SOURCE].length = 0;
@@ -139,7 +139,7 @@ class ManagedArray {
           }
           if (isSchemaArray) {
             if (!transaction) {
-              subscribe(_SIGNAL);
+              consumeInternalSignal(_SIGNAL);
             }
             if (val) {
               const recordRef = ManagedRecordRefs.get(val);
@@ -171,7 +171,7 @@ class ManagedArray {
             return val;
           }
           if (!transaction) {
-            subscribe(_SIGNAL);
+            consumeInternalSignal(_SIGNAL);
           }
           if (field.type) {
             const transform = schema.transformation(field);
@@ -184,7 +184,7 @@ class ManagedArray {
           if (fn === undefined) {
             if (prop === 'forEach') {
               fn = function () {
-                subscribe(_SIGNAL);
+                consumeInternalSignal(_SIGNAL);
                 transaction = true;
                 const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
                 transaction = false;
@@ -192,7 +192,7 @@ class ManagedArray {
               };
             } else {
               fn = function () {
-                subscribe(_SIGNAL);
+                consumeInternalSignal(_SIGNAL);
                 // array functions must run through Reflect to work properly
                 // binding via other means will not work.
                 transaction = true;
@@ -212,7 +212,7 @@ class ManagedArray {
               if (!IS_EDITABLE) {
                 throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
               }
-              subscribe(_SIGNAL);
+              consumeInternalSignal(_SIGNAL);
               transaction = true;
               const result = Reflect.apply(target[prop], receiver, arguments);
               transaction = false;
@@ -246,7 +246,7 @@ class ManagedArray {
         if (reflect) {
           if (!field.type) {
             cache.setAttr(identifier, path, self[SOURCE]);
-            _SIGNAL.shouldReset = true;
+            _SIGNAL.isStale = true;
             return true;
           }
           let rawValue = self[SOURCE];
@@ -258,7 +258,7 @@ class ManagedArray {
             rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
           }
           cache.setAttr(identifier, path, rawValue);
-          _SIGNAL.shouldReset = true;
+          _SIGNAL.isStale = true;
         }
         return reflect;
       },
@@ -283,12 +283,12 @@ class ManagedObject {
     this[SOURCE] = {
       ...data
     };
-    this[OBJECT_SIGNAL] = createSignal(this, 'length');
+    const signals = withSignalStore(this);
+    const _SIGNAL = this[OBJECT_SIGNAL] = entangleSignal(signals, this, OBJECT_SIGNAL, undefined);
     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]);
@@ -331,9 +331,8 @@ class ManagedObject {
             return structuredClone(self[SOURCE]);
           };
         }
-        if (_SIGNAL.shouldReset) {
-          _SIGNAL.t = false;
-          _SIGNAL.shouldReset = false;
+        if (_SIGNAL.isStale) {
+          _SIGNAL.isStale = false;
           let newData = cache.getAttr(identifier, path);
           if (newData && newData !== self[SOURCE]) {
             if (field.type) {
@@ -346,7 +345,7 @@ class ManagedObject {
           }
         }
         if (prop in self[SOURCE]) {
-          subscribe(_SIGNAL);
+          consumeInternalSignal(_SIGNAL);
           return self[SOURCE][prop];
         }
         return Reflect.get(target, prop, receiver);
@@ -368,7 +367,7 @@ class ManagedObject {
           const val = transform.serialize(self[SOURCE], field.options ?? null, owner);
           cache.setAttr(identifier, path, val);
         }
-        _SIGNAL.shouldReset = true;
+        _SIGNAL.isStale = true;
         return true;
       }
     });
@@ -376,13 +375,15 @@ class ManagedObject {
   }
 }
 class ManyArrayManager {
-  constructor(record) {
+  constructor(record, editable) {
     this.record = record;
     this.store = record[RecordStore];
     this.identifier = record[Identifier];
+    this.editable = editable;
   }
   _syncArray(array) {
-    const rawValue = this.store.cache.getRelationship(this.identifier, array.key);
+    const method = this.editable ? 'getRelationship' : 'getRemoteRelationship';
+    const rawValue = this.store.cache[method](this.identifier, array.key);
     if (rawValue.meta) {
       array.meta = rawValue.meta;
     }
@@ -428,7 +429,7 @@ class ManyArrayManager {
     return this.store.request(req);
   }
   mutate(mutation) {
-    this.cache.mutate(mutation);
+    this.store.cache.mutate(mutation);
   }
 }
 function getRelatedLink(resource) {
@@ -453,12 +454,10 @@ function extractCacheOptions(options) {
 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;
+  const signals = withSignalStore(record);
+  const signal = getOrCreateInternalSignal(signals, record, prop, field.options?.defaultValue ?? null);
+  consumeInternalSignal(signal);
+  return signal.value;
 }
 function peekManagedArray(record, field) {
   const managedArrayMapForRecord = ManagedArrayMap.get(record);
@@ -602,9 +601,9 @@ class ResourceRelationship {
     return this[RecordStore].request(request);
   }
 }
-defineSignal(ResourceRelationship.prototype, 'data');
-defineSignal(ResourceRelationship.prototype, 'links');
-defineSignal(ResourceRelationship.prototype, 'meta');
+defineSignal(ResourceRelationship.prototype, 'data', null);
+defineSignal(ResourceRelationship.prototype, 'links', null);
+defineSignal(ResourceRelationship.prototype, 'meta', null);
 function getHref(link) {
   if (!link) {
     return null;
@@ -644,7 +643,9 @@ function computeHasMany(store, schema, cache, record, identifier, field, path, e
       type: field.type,
       identifier,
       cache,
-      identifiers: rawValue.data,
+      // we divorce the reference here because ManyArray mutates the target directly
+      // before sending the mutation op to the cache. We may be able to avoid this in the future
+      identifiers: rawValue.data?.slice(),
       key: field.name,
       meta: rawValue.meta || null,
       links: rawValue.links || null,
@@ -653,7 +654,7 @@ function computeHasMany(store, schema, cache, record, identifier, field, path, e
       // TODO: Grab the proper value
       _inverseIsAsync: false,
       // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-      manager: new ManyArrayManager(record),
+      manager: new ManyArrayManager(record, editable),
       isLoaded: true,
       allowMutation: editable
     });
@@ -668,7 +669,7 @@ function computeHasMany(store, schema, cache, record, identifier, field, path, e
 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 symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, EmbeddedPath, EmbeddedType];
 const RecordSymbols = new Set(symbolList);
 function isPathMatch(a, b) {
   return a.length === b.length && a.every((v, i) => v === b[i]);
@@ -700,8 +701,7 @@ class SchemaRecord {
     const fields = isEmbedded ? schema.fields({
       type: embeddedType
     }) : schema.fields(identifier);
-    const signals = new Map();
-    this[Signals] = signals;
+    const signals = withSignalStore(this);
     const proxy = new Proxy(this, {
       ownKeys() {
         const identityKey = identityField?.name;
@@ -773,6 +773,9 @@ class SchemaRecord {
         if (RecordSymbols.has(prop)) {
           return target[prop];
         }
+        if (prop === Signals) {
+          return signals;
+        }
 
         // TODO make this a symbol
         if (prop === '___notifications') {
@@ -801,7 +804,7 @@ class SchemaRecord {
             let fn = BoundFns.get('toString');
             if (!fn) {
               fn = function () {
-                entangleSignal(signals, receiver, '@identity');
+                entangleSignal(signals, receiver, '@identity', null);
                 return `Record<${identifier.type}:${identifier.id} (${identifier.lid})>`;
               };
               BoundFns.set(prop, fn);
@@ -812,7 +815,7 @@ class SchemaRecord {
             let fn = BoundFns.get('toHTML');
             if (!fn) {
               fn = function () {
-                entangleSignal(signals, receiver, '@identity');
+                entangleSignal(signals, receiver, '@identity', null);
                 return `<span>Record<${identifier.type}:${identifier.id} (${identifier.lid})></span>`;
               };
               BoundFns.set(prop, fn);
@@ -872,42 +875,40 @@ class SchemaRecord {
 
         switch (field.kind) {
           case '@id':
-            entangleSignal(signals, receiver, '@identity');
+            entangleSignal(signals, receiver, '@identity', null);
             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;
+              return computeLocal(receiver, field, prop);
             }
           case 'field':
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return computeField(schema, cache, target, identifier, field, propArray, IS_EDITABLE);
           case 'attribute':
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return computeAttribute(cache, identifier, prop, IS_EDITABLE);
           case 'resource':
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return computeResource(store, cache, target, identifier, field, prop, IS_EDITABLE);
           case 'derived':
             return computeDerivation(schema, receiver, identifier, field, prop);
           case 'schema-array':
           case 'array':
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return computeArray(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
           case 'object':
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return computeObject(schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
           case 'schema-object':
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             // run transform, then use that value as the object to manage
             return computeSchemaObject(store, cache, target, identifier, field, propArray, Mode[Legacy], Mode[Editable]);
           case 'belongsTo':
             if (field.options.linksMode) {
-              entangleSignal(signals, receiver, field.name);
+              entangleSignal(signals, receiver, field.name, null);
               const rawValue = IS_EDITABLE ? cache.getRelationship(identifier, field.name) : cache.getRemoteRelationship(identifier, field.name);
 
               // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -930,11 +931,11 @@ class SchemaRecord {
                 throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
               }
             })(Mode[Legacy]) : {};
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return getLegacySupport(receiver).getBelongsTo(field.name);
           case 'hasMany':
             if (field.options.linksMode) {
-              entangleSignal(signals, receiver, field.name);
+              entangleSignal(signals, receiver, field.name, null);
               return computeHasMany(store, schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
             }
             if (!HAS_MODEL_PACKAGE) {
@@ -954,7 +955,7 @@ class SchemaRecord {
                 throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
               }
             })(Mode[Legacy]) : {};
-            entangleSignal(signals, receiver, field.name);
+            entangleSignal(signals, receiver, field.name, null);
             return getLegacySupport(receiver).getHasMany(field.name);
           default:
             throw new Error(`Field '${String(prop)}' on '${identifier.type}' has the unknown kind '${field.kind}'`);
@@ -1005,10 +1006,10 @@ class SchemaRecord {
             }
           case '@local':
             {
-              const signal = getSignal(receiver, prop, true);
-              if (signal.lastValue !== value) {
-                signal.lastValue = value;
-                addToTransaction(signal);
+              const signal = getOrCreateInternalSignal(signals, receiver, prop, field.options?.defaultValue ?? null);
+              if (signal.value !== value) {
+                signal.value = value;
+                notifyInternalSignal(signal);
               }
               return true;
             }
@@ -1040,7 +1041,7 @@ class SchemaRecord {
                     }
                   })(ARRAY_SIGNAL in peeked) : {};
                   const arrSignal = peeked[ARRAY_SIGNAL];
-                  arrSignal.shouldReset = true;
+                  arrSignal.isStale = true;
                 }
                 if (!Array.isArray(value)) {
                   ManagedArrayMap.delete(target);
@@ -1058,7 +1059,7 @@ class SchemaRecord {
                   }
                 })(ARRAY_SIGNAL in peeked) : {};
                 const arrSignal = peeked[ARRAY_SIGNAL];
-                arrSignal.shouldReset = true;
+                arrSignal.isStale = true;
               }
               return true;
             }
@@ -1077,7 +1078,7 @@ class SchemaRecord {
                   }
                 })(ARRAY_SIGNAL in peeked) : {};
                 const arrSignal = peeked[ARRAY_SIGNAL];
-                arrSignal.shouldReset = true;
+                arrSignal.isStale = true;
               }
               if (!Array.isArray(value)) {
                 ManagedArrayMap.delete(target);
@@ -1099,7 +1100,7 @@ class SchemaRecord {
                 const peeked = peekManagedObject(self, field);
                 if (peeked) {
                   const objSignal = peeked[OBJECT_SIGNAL];
-                  objSignal.shouldReset = true;
+                  objSignal.isStale = true;
                 }
                 return true;
               }
@@ -1111,7 +1112,7 @@ class SchemaRecord {
               const peeked = peekManagedObject(self, field);
               if (peeked) {
                 const objSignal = peeked[OBJECT_SIGNAL];
-                objSignal.shouldReset = true;
+                objSignal.isStale = true;
               }
               return true;
             }
@@ -1142,7 +1143,7 @@ class SchemaRecord {
               // const peeked = peekManagedObject(self, field);
               // if (peeked) {
               //   const objSignal = peeked[OBJECT_SIGNAL];
-              //   objSignal.shouldReset = true;
+              //   objSignal.isStale = true;
               // }
               return true;
             }
@@ -1217,7 +1218,7 @@ class SchemaRecord {
             if (identityField.name && identityField.kind === '@id') {
               const signal = signals.get('@identity');
               if (signal) {
-                addToTransaction(signal);
+                notifyInternalSignal(signal);
               }
             }
             break;
@@ -1247,7 +1248,7 @@ class SchemaRecord {
               // console.log(`Notification for ${key} on ${identifier.type}`, self);
               const signal = signals.get(key);
               if (signal) {
-                addToTransaction(signal);
+                notifyInternalSignal(signal);
               }
               const field = fields.get(key);
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
@@ -1259,16 +1260,14 @@ class SchemaRecord {
                     }
                   })(ARRAY_SIGNAL in peeked) : {};
                   const arrSignal = peeked[ARRAY_SIGNAL];
-                  arrSignal.shouldReset = true;
-                  addToTransaction(arrSignal);
+                  notifyInternalSignal(arrSignal);
                 }
               }
               if (field?.kind === 'object') {
                 const peeked = peekManagedObject(self, field);
                 if (peeked) {
                   const objSignal = peeked[OBJECT_SIGNAL];
-                  objSignal.shouldReset = true;
-                  addToTransaction(objSignal);
+                  notifyInternalSignal(objSignal);
                 }
               }
             }
@@ -1290,17 +1289,14 @@ class SchemaRecord {
                 // console.log(`Notification for ${key} on ${identifier.type}`, self);
                 const signal = signals.get(key);
                 if (signal) {
-                  addToTransaction(signal);
+                  notifyInternalSignal(signal);
                 }
                 // FIXME
               } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
                 if (field.options.linksMode) {
                   const peeked = peekManagedArray(self, field);
                   if (peeked) {
-                    // const arrSignal = peeked[ARRAY_SIGNAL];
-                    // arrSignal.shouldReset = true;
-                    // addToTransaction(arrSignal);
-                    peeked.notify();
+                    notifyInternalSignal(peeked[ARRAY_SIGNAL]);
                   }
                   return;
                 }
@@ -1323,7 +1319,7 @@ class SchemaRecord {
                   return;
                 }
                 if (manyArray) {
-                  manyArray.notify();
+                  notifyInternalSignal(manyArray[ARRAY_SIGNAL]);
                   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
                     if (!test) {
                       throw new Error(`Expected options to exist on relationship meta`);
@@ -1337,7 +1333,7 @@ class SchemaRecord {
                   if (field.options.async) {
                     const signal = signals.get(key);
                     if (signal) {
-                      addToTransaction(signal);
+                      notifyInternalSignal(signal);
                     }
                   }
                 }
@@ -1467,15 +1463,23 @@ function _constructor(record) {
 _constructor[Type] = '@constructor';
 
 /**
- * Utility for constructing a ResourceSchema with the recommended fields
- * for the Polaris experience.
+ * Utility for constructing a ResourceSchema with the recommended
+ * fields for the PolarisMode experience.
+ *
+ * Using this requires registering the PolarisMode derivations
+ *
+ * ```ts
+ * import { registerDerivations } from '@warp-drive/schema-record';
+ *
+ * registerDerivations(schema);
+ * ```
  *
  * @method withDefaults
  * @for @warp-drive/schema-record
  * @static
  * @public
  * @param schema
- * @return {ResourceSchema}
+ * @return {PolarisResourceSchema}
  */
 function withDefaults(schema) {
   schema.identity = schema.identity || DefaultIdentityField;
@@ -1530,7 +1534,12 @@ function fromIdentity(record, options, key) {
 fromIdentity[Type] = '@identity';
 
 /**
- * Registers the default derivations for the SchemaRecord
+ * Registers the default derivations for records that want
+ * to use the PolarisMode defaults provided by
+ *
+ * ```ts
+ * import { withDefaults } from '@warp-drive/schema-record';
+ * ```
  *
  * @method registerDerivations
  * @for @warp-drive/schema-record
@@ -1550,15 +1559,15 @@ function registerDerivations(schema) {
  */
 function makeCachedDerivation(derivation) {
   const memoizedDerivation = (record, options, prop) => {
-    const signals = record[Signals];
+    const signals = withSignalStore(record);
     let signal = signals.get(prop);
     if (!signal) {
-      signal = createCache(() => {
+      signal = createMemo(record, prop, () => {
         return derivation(record, options, prop);
       }); // a total lie, for convenience of reusing the storage
       signals.set(prop, signal);
     }
-    return getValue(signal);
+    return signal();
   };
   memoizedDerivation[Type] = derivation[Type];
   return memoizedDerivation;
@@ -1577,6 +1586,7 @@ class SchemaService {
     this._transforms = new Map();
     this._hashFns = new Map();
     this._derivations = new Map();
+    this._traits = new Set();
   }
   resourceTypes() {
     return Array.from(this._schemas.keys());