@warp-drive/legacy 5.8.0-beta.0 → 5.8.0-beta.2

package/dist/hooks-D6diaM34.js

@@ -0,0 +1,74 @@
+import { setOwner, getOwner } from '@ember/application';
+import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
+import { g as getModelFactory } from "./schema-provider-DJCV_6AF.js";
+import { n as normalizeModelName } from "./util-Dul6TZts.js";
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+function instantiateRecord(identifier, createRecordArgs) {
+  const type = identifier.type;
+
+  // TODO deprecate allowing unknown args setting
+  const createOptions = {
+    _createProps: createRecordArgs ?? {},
+    // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
+    _secretInit: {
+      identifier,
+      store: this,
+      cb: secretInit
+    }
+  };
+
+  // ensure that `getOwner(this)` works inside a model instance
+  setOwner(createOptions, getOwner(this));
+  const factory = getModelFactory(this, type);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No model was found for '${type}'`);
+    }
+  })(factory) : {};
+  return factory.class.create(createOptions);
+}
+function teardownRecord(record) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`expected to receive an instance of Model from @ember-data/model. If using a custom model make sure you implement teardownRecord`);
+    }
+  })('destroy' in record) : {};
+  record.destroy();
+}
+function modelFor(modelName) {
+  assertPrivateStore(this);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Attempted to call store.modelFor(), but the store instance has already been destroyed.`);
+    }
+  })(!this.isDestroyed && !this.isDestroying) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the store's modelFor method`);
+    }
+  })(modelName) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Please pass a proper model name to the store's modelFor method`);
+    }
+  })(typeof modelName === 'string' && modelName.length) : {};
+  const type = normalizeModelName(modelName);
+  const maybeFactory = getModelFactory(this, type);
+  const klass = maybeFactory && maybeFactory.class ? maybeFactory.class : null;
+  const ignoreType = !klass || !klass.isModel || this._forceShim;
+  if (!ignoreType) {
+    return klass;
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No model was found for '${type}' and no schema handles the type`);
+    }
+  })(this.schema.hasResource({
+    type
+  })) : {};
+}
+function secretInit(record, identifier, store) {
+  setRecordIdentifier(record, identifier);
+  StoreMap.set(record, store);
+}
+export { instantiateRecord as i, modelFor as m, teardownRecord as t };

package/dist/index.js

@@ -0,0 +1,195 @@
+import { Store, RequestManager, Fetch, CacheHandler, recordIdentifierFor } from '@warp-drive/core';
+import { SchemaService, registerDerivations, instantiateRecord as instantiateRecord$1, teardownRecord as teardownRecord$1 } from '@warp-drive/core/reactive';
+import { DefaultCachePolicy } from '@warp-drive/core/store';
+import { LegacyNetworkHandler, adapterFor, serializerFor, pushPayload, normalize, serializeRecord, cleanup } from './compat.js';
+import { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension } from './compat/extensions.js';
+import '@ember/object';
+import '@warp-drive/core/types/symbols';
+import '@ember/debug';
+import '@warp-drive/utilities/string';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+import '@warp-drive/core/store/-private';
+import "./errors-Cz5KrzBk.js";
+import "./schema-provider-DJCV_6AF.js";
+import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-D6diaM34.js";
+import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
+import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-CqXsIKws.js";
+import { restoreDeprecatedStoreBehaviors } from './store.js';
+
+/**
+ * @module
+ * @mergeModuleWith <project>
+ */
+
+/**
+ * Use the legacy store with the given options.
+ */
+function useLegacyStore(options, StoreKlass = Store) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`If legacyRequests is true, linksMode must be false`);
+    }
+  })(!(options.linksMode && options.legacyRequests)) : {};
+  // we extend the store to ensure we don't leak our prototype overrides to other stores below.
+  class BaseKlass extends StoreKlass {}
+  class LegacyConfiguredStore extends BaseKlass {
+    requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...(options.handlers ?? []), Fetch].filter(Boolean)).useCache(CacheHandler);
+    lifetimes = options.policy ?? new DefaultCachePolicy({
+      apiCacheHardExpires: 15 * 60 * 1000,
+      // 15 minutes
+      apiCacheSoftExpires: 1 * 30 * 1000,
+      // 30 seconds
+      constraints: {
+        headers: {
+          'X-WarpDrive-Expires': true,
+          'Cache-Control': true,
+          Expires: true
+        }
+      }
+    });
+    createSchemaService() {
+      // prepare for PolarisMode
+      const schema = new SchemaService();
+      registerDerivations(schema);
+      if (options.schemas) schema.registerResources(options.schemas);
+      if (options.traits) {
+        for (const trait of options.traits) {
+          schema.registerTrait(trait);
+        }
+      }
+      if (options.derivations) {
+        for (const derivation of options.derivations) {
+          schema.registerDerivation(derivation);
+        }
+      }
+      if (options.transformations) {
+        for (const transformation of options.transformations) {
+          schema.registerTransformation(transformation);
+        }
+      }
+      if (options.hashFns) {
+        for (const hashFn of options.hashFns) {
+          schema.registerHashFn(hashFn);
+        }
+      }
+      if (options.CAUTION_MEGA_DANGER_ZONE_extensions) {
+        for (const extension of options.CAUTION_MEGA_DANGER_ZONE_extensions) {
+          schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
+        }
+      }
+
+      // Add support for LegacyMode ReactiveResource with Maximal coverage
+      // for upgrading from 4.x
+      registerDerivations$1(schema);
+      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberArrayLikeExtension);
+      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectArrayExtension);
+      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectExtension);
+
+      // add support for fragments
+      if (options.modelFragments) {
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+      }
+
+      // Add fallback for Models
+      return new DelegatingSchemaService(this, schema);
+    }
+    createCache(capabilities) {
+      // eslint-disable-next-line new-cap
+      return new options.cache(capabilities);
+    }
+    instantiateRecord(key, createArgs) {
+      if (this.schema.isDelegated(key)) {
+        return instantiateRecord.call(this, key, createArgs);
+      }
+      return instantiateRecord$1(this, key, createArgs);
+    }
+    teardownRecord(record) {
+      const key = recordIdentifierFor(record);
+      if (this.schema.isDelegated(key)) {
+        return teardownRecord.call(this, record);
+      }
+      return teardownRecord$1(record);
+    }
+    modelFor(type) {
+      assertType(this.schema, type);
+      // TODO I'm not sure this is right
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`modelFor should only be used to lookup legacy models when in linksMode: false`);
+        }
+      })(!options.linksMode || !this.schema.isDelegated({
+        type
+      })) : {};
+      const klass =
+      // prefer real models if present
+      modelFor.call(this, type) || (
+      // fallback to ShimModelClass specific to fragments if fragments support in use
+      options.modelFragments ? fragmentsModelFor.call(this, type) : false) ||
+      // fallback to ShimModelClass
+      super.modelFor(type);
+      return klass;
+    }
+    adapterFor(modelName, _allowMissing) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+        }
+      })(!options.linksMode) : {};
+      // @ts-expect-error
+      return adapterFor.call(this, modelName, _allowMissing);
+    }
+    serializerFor(...args) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+        }
+      })(!options.linksMode) : {};
+      return serializerFor.call(this, ...args);
+    }
+    pushPayload(...args) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+        }
+      })(!options.linksMode) : {};
+      return pushPayload.call(this, ...args);
+    }
+    normalize(...args) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+        }
+      })(!options.linksMode) : {};
+      return normalize.call(this, ...args);
+    }
+    serializeRecord(...args) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+        }
+      })(!options.linksMode) : {};
+      return serializeRecord.call(this, ...args);
+    }
+    destroy() {
+      if (!options.linksMode) {
+        cleanup.call(this);
+      }
+      super.destroy();
+    }
+  }
+  if (options.legacyRequests) {
+    restoreDeprecatedStoreBehaviors(BaseKlass);
+  }
+  return LegacyConfiguredStore;
+}
+function assertType(schema, type) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected type ${type} to be a valid ResourceType`);
+    }
+  })(schema.hasResource({
+    type
+  })) : {};
+}
+export { useLegacyStore };

package/dist/{json-Et4mt_LM.js → json-ChdEfB0X.js}

@@ -25,20 +25,18 @@ const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
 const PRIMARY_ATTRIBUTE_KEY = 'base';
 
 /**
- * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-  <p>
-    ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+ * :::danger
+    ⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
     If starting a new app or thinking of implementing a new adapter, consider writing a
-    <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-  </p>
-  </blockquote>
+    {@link Handler} instead to be used with the {@link RequestManager}
+  :::
 
-  In EmberData a Serializer is used to serialize and deserialize
+  In WarpDrive a Serializer is used to serialize and deserialize
   records when they are transferred in and out of an external source.
   This process involves normalizing property names, transforming
   attribute values and serializing relationships.
 
-  By default, EmberData uses and recommends the `JSONAPISerializer`.
+  By default, WarpDrive uses and recommends the `JSONAPISerializer`.
 
   `JSONSerializer` is useful for simpler or legacy backends that may
   not support the http://jsonapi.org/ spec.
@@ -46,7 +44,7 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
   For example, given the following `User` model and JSON payload:
 
   ```js [app/models/user.js]
-  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+  import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
 
   export default class UserModel extends Model {
     @hasMany('user') friends;
@@ -67,8 +65,8 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
   }
   ```
 
-  `JSONSerializer` will normalize the JSON payload to the JSON API format that the
-  Ember Data store expects.
+  `JSONSerializer` will normalize the JSON payload to the {json:api} format that the
+  JSONAPICache uses to cache data in the Store.
 
   You can customize how JSONSerializer processes its payload by passing options in
   the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:
@@ -103,7 +101,7 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
 const JSONSerializer = Serializer.extend({
   /**
     The `primaryKey` is used when serializing and deserializing
-    data. Ember Data always uses the `id` property to store the id of
+    data. WarpDrive always uses the `id` property to store the id of
     the record. The external source may not always follow this
     convention. In these cases it is useful to override the
     `primaryKey` property to match the `primaryKey` of your external
@@ -115,9 +113,7 @@ const JSONSerializer = Serializer.extend({
       primaryKey = '_id'
     }
     ```
-     @property primaryKey
-    @type {String}
-    @public
+     @public
     @default 'id'
   */
   primaryKey: 'id',
@@ -129,7 +125,7 @@ const JSONSerializer = Serializer.extend({
     the response payload.
      Example
      ```js [app/models/person.js]
-    import Model, { attr } from '@ember-data/model';
+    import Model, { attr } from '@warp-drive/legacy/model';
      export default class PersonModel extends Model {
       @attr('string') firstName;
       @attr('string') lastName;
@@ -159,7 +155,7 @@ const JSONSerializer = Serializer.extend({
     }
     ```
      When serialized:
-     ```javascript
+     ```js
     {
       "firstName": "Harry",
       "lastName": "Houdini",
@@ -170,9 +166,7 @@ const JSONSerializer = Serializer.extend({
      Setting `serialize` to `true` enforces serialization for hasMany
     relationships even if it's neither a many-to-many nor many-to-none
     relationship.
-     @property attrs
-    @public
-    @type {Object}
+     @public
   */
   mergedProperties: ['attrs'],
   /**
@@ -457,9 +451,6 @@ const JSONSerializer = Serializer.extend({
     }
     ```
      @public
-    @param {Model} typeClass
-    @param {Object} hash
-    @return {Object}
   */
   normalize(modelClass, resourceHash) {
     let data = null;
@@ -505,9 +496,6 @@ const JSONSerializer = Serializer.extend({
     Returns the resource's attributes formatted as a JSON-API "attributes object".
      http://jsonapi.org/format/#document-resource-object-attributes
      @public
-    @param {Object} modelClass
-    @param {Object} resourceHash
-    @return {Object}
   */
   extractAttributes(modelClass, resourceHash) {
     let attributeKey;
@@ -648,8 +636,7 @@ const JSONSerializer = Serializer.extend({
   /**
     Dasherizes the model name in the payload
      @public
-    @param {String} key
-    @return {String} the model's modelName
+    @return the model's modelName
   */
   modelNameFromPayloadKey(key) {
     return dasherize(singularize(key));
@@ -773,7 +760,7 @@ const JSONSerializer = Serializer.extend({
     each attribute and belongsTo relationship.
      For example, consider this model:
      ```js [app/models/comment.js]
-    import Model, { attr, belongsTo } from '@ember-data/model';
+    import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
      export default class CommentModel extends Model {
       @attr title;
       @attr body;
@@ -908,7 +895,7 @@ const JSONSerializer = Serializer.extend({
     The hash property should be modified by reference.
      For example, your server may expect underscored root objects.
      ```js [app/serializers/application.js]
-    import RESTSerializer from '@ember-data/serializer/rest';
+    import RESTSerializer from '@warp-drive/legacy/serializer/rest';
     import { underscoren} from '<app-name>/utils/string-utils';
      export default class ApplicationSerializer extends RESTSerializer {
       serializeIntoHash(data, type, snapshot, options) {
@@ -1162,11 +1149,7 @@ const JSONSerializer = Serializer.extend({
     }
     ```
      @public
-    @param {Store} store
-    @param {Model} typeClass
-    @param {Object} payload
-    @param {(String|Number)} id
-    @return {Object} json The deserialized errors
+    @return json The deserialized errors
   */
   extractErrors(store, typeClass, payload, id) {
     // @ts-expect-error

package/dist/model/-private.js

@@ -1 +1 @@
-export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-8kD2mSe_.js";
+export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-Cz5KrzBk.js";

package/dist/model/migration-support.js

@@ -1,23 +1,24 @@
 import { deprecate } from '@ember/debug';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { Context } from '@warp-drive/core/reactive/-private';
-import { notifyInternalSignal, assertPrivateStore } from '@warp-drive/core/store/-private';
+import { notifyInternalSignal } from '@warp-drive/core/signals/-leaked';
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { Type } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, E as Errors } from "../errors-8kD2mSe_.js";
-import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, g as deleteRecord, R as RecordState, i as changedAttributes, j as belongsTo, k as createSnapshot } from "../schema-provider-DQu4Rjco.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-Cz5KrzBk.js";
+import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, i as deleteRecord, R as RecordState, j as changedAttributes, k as belongsTo, l as createSnapshot } from "../schema-provider-DJCV_6AF.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
- * This module provides support for migrating away from @ember-data/model
- * to @warp-drive/schema-record.
+ * This module provides support for migrating away from @warp-drive/legacy/model
+ * to ReactiveResource from @warp-drive/core/reactive.
  *
  * It includes:
  *
  * - A `withDefaults` function to assist in creating a schema in LegacyMode
  * - A `registerDerivations` function to register the derivations necessary to support LegacyMode
  * - A `DelegatingSchemaService` that can be used to provide a schema service that works with both
- *   @ember-data/model and @warp-drive/schema-record simultaneously for migration purposes.
+ *   @warp-drive/legacy/model and @warp-drive/core/reactive simultaneously for migration purposes.
  * - A `WithLegacy` type util that can be used to create a type that includes the legacy
  *   properties and methods of a record.
  *
@@ -32,14 +33,14 @@ const LegacyFields = ['_createSnapshot', 'adapterError', 'belongsTo', 'changedAt
 
 /**
  * A Type utility that enables quickly adding type information for the fields
- * defined by `import { withDefaults } from '@ember-data/model/migration-support'`.
+ * defined by `import { withDefaults } from '@warp-drive/legacy/model/migration-support'`.
  *
  * Example:
  *
  * ```ts
- * import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
- * import { Type } from '@warp-drive/core-types/symbols';
- * import type { HasMany } from '@ember-data/model';
+ * import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+ * import { Type } from '@warp-drive/core/types/symbols';
+ * import type { HasMany } from '@@warp-drive/legacy/model';
  *
  * export const UserSchema = withDefaults({
  *   type: 'user',
@@ -156,14 +157,14 @@ legacySupport[Type] = '@legacy';
 /**
  * A function which adds the necessary fields to a schema and marks it as
  * being in LegacyMode. This is used to support the legacy features of
- * @ember-data/model while migrating to WarpDrive.
+ * @warp-drive/legacy/model while migrating to WarpDrive.
  *
  * Example:
  *
  * ```ts
- * import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
- * import { Type } from '@warp-drive/core-types/symbols';
- * import type { HasMany } from '@ember-data/model';
+ * import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+ * import { Type } from '@warp-drive/core/types/symbols';
+ * import type { HasMany } from '@warp-drive/legacy/model';
  *
  * export const UserSchema = withDefaults({
  *   type: 'user',
@@ -198,13 +199,13 @@ legacySupport[Type] = '@legacy';
  * it requires with the schema service.
  *
  * ```ts
- * import { registerDerivations } from '@ember-data/model/migration-support';
+ * import { registerDerivations } from '@warp-drive/legacy/model/migration-support';
  *
  * registerDerivations(schema);
  * ```
  *
- * @param {LegacyResourceSchema} schema The schema to add legacy support to.
- * @return {LegacyResourceSchema} The schema with legacy support added.
+ * @param schema The schema to add legacy support to.
+ * @return The schema with legacy support added.
  * @public
  */
 function withDefaults(schema) {
@@ -248,6 +249,26 @@ function withDefaults(schema) {
   schema.objectExtensions.push('deprecated-model-behaviors');
   return schema;
 }
+
+/**
+ * Adds the necessasary fields to the schema for supporting
+ * the deprecated request methods on LegacyMode schemas.
+ *
+ * Use this instead of `withDefaults` to add the fields
+ * and behaviors necessary to support Model-Like capabilities.
+ *
+ * ```ts
+ * import { withRestoredDeprecatedModelRequestBehaviors } from '@warp-drive/legacy/model/migration-support';
+ *
+ * export const UserSchema = withRestoredDeprecatedModelRequestBehaviors({
+ *   type: 'user',
+ *   fields: [
+ *     { name: 'firstName', kind: 'attribute' },
+ *     { name: 'lastName', kind: 'attribute' },
+ *   ]
+ * });
+ * ```
+ */
 function withRestoredDeprecatedModelRequestBehaviors(schema) {
   schema.legacy = true;
   schema.identity = {
@@ -293,13 +314,10 @@ function withRestoredDeprecatedModelRequestBehaviors(schema) {
 
 /**
  * A function which registers the necessary derivations to support
- * the LegacyMode features of @ember-data/model while migrating to WarpDrive.
- *
- * This must be called in order to use the fields added by:
+ * the LegacyMode features of @warp-drive/legacy/model while migrating to WarpDrive.
  *
- * ```ts
- * import { withDefaults } from '@ember-data/model/migration-support';
- * ```
+ * This must be called in order to use the fields added by {@link withDefaults} or
+ * {@link withRestoredDeprecatedModelRequestBehaviors}.
  *
  * @param schema The schema service to register the derivations with.
  * @public
@@ -398,8 +416,8 @@ function registerDerivations(schema) {
  * provide their own schema information to the application.
  *
  * ```ts
- * import { DelegatingSchemaService } from '@ember-data/model/migration-support';
- * import { SchemaService } from '@warp-drive/schema-record';
+ * import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
+ * import { SchemaService } from '@warp-drive/core/reactive';
  *
  * class AppStore extends Store {
  *   createSchemaService() {
@@ -417,7 +435,9 @@ function registerDerivations(schema) {
  */
 
 class DelegatingSchemaService {
+  /** @internal */
   _preferred;
+  /** @internal */
   _secondary;
   constructor(store, schema) {
     this._preferred = schema;
@@ -452,6 +472,15 @@ class DelegatingSchemaService {
     }
     return this._secondary.fields(resource);
   }
+  cacheFields(resource) {
+    if (this._preferred.hasResource?.(resource)) {
+      // @ts-expect-error
+      return this._preferred.cacheFields?.(resource);
+    }
+
+    // @ts-expect-error
+    return this._secondary.cacheFields?.(resource);
+  }
   transformation(field) {
     return this._preferred.transformation(field);
   }
@@ -482,6 +511,9 @@ class DelegatingSchemaService {
   registerHashFn(hashFn) {
     this._preferred.registerHashFn(hashFn);
   }
+  CAUTION_MEGA_DANGER_ZONE_hasExtension(ext) {
+    return this._preferred.CAUTION_MEGA_DANGER_ZONE_hasExtension(ext);
+  }
   CAUTION_MEGA_DANGER_ZONE_registerExtension(extension) {
     this._preferred.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
   }
@@ -502,7 +534,7 @@ class DelegatingSchemaService {
    * We do think a generalized `kind` registration system would be useful,
    * but we have not yet designed it.
    *
-   * See https://github.com/emberjs/data/issues/9534
+   * See https://github.com/warp-drive-data/warp-drive/issues/9534
    *
    * @internal
    */
@@ -519,7 +551,7 @@ class DelegatingSchemaService {
    * We do think a generalized `kind` registration system would be useful,
    * but we have not yet designed it.
    *
-   * See https://github.com/emberjs/data/issues/9534
+   * See https://github.com/warp-drive-data/warp-drive/issues/9534
    *
    * @internal
    */