@warp-drive/legacy 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/unpkg/{dev-deprecated/json-Cu1LNgmQ.js → prod-deprecated/json-Qewu-UN9.js}

@@ -13,6 +13,58 @@ function coerceId(id) {
   }
 }
 
+/**
+  Given the name of a relationship on a resource `type`, determines the
+  inverse relationship field (if any) using only the schema service.
+
+  Unlike `Model.inverseFor`, this does not require `type` to be backed by
+  a `Model` class, so it works for both `Model`-based and schema-only
+  (e.g. `withDefaults` migration-support) resources.
+
+  @private
+*/
+function inverseForRelationship(store, type, name) {
+  const relationship = store.schema.fields({
+    type
+  }).get(name);
+  const {
+    options
+  } = relationship;
+  if (options.inverse === null) {
+    return null;
+  }
+  const schemaExists = store.schema.hasResource(relationship);
+  if (!schemaExists) {
+    return null;
+  }
+  const inverseField = store.schema.fields(relationship).get(options.inverse);
+  return inverseField ?? null;
+}
+
+/**
+  Given a relationship field on a resource `type`, determines the
+  cardinality of the relationship using only the schema service.
+
+  Unlike `Model.determineRelationshipType`, this does not require `type`
+  to be backed by a `Model` class, so it works for both `Model`-based and
+  schema-only (e.g. `withDefaults` migration-support) resources.
+
+  @private
+*/
+function determineRelationshipType(store, type, knownSide) {
+  const knownKind = knownSide.kind;
+  const inverse = inverseForRelationship(store, type, knownSide.name);
+  if (!inverse) {
+    return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';
+  }
+  const otherKind = inverse.kind;
+  if (otherKind === 'belongsTo') {
+    return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';
+  } else {
+    return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';
+  }
+}
+
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
@@ -381,11 +433,6 @@ const JSONSerializer = Serializer.extend({
     };
     const meta = this.extractMeta(store, primaryModelClass, payload);
     if (meta) {
-      (test => {
-        if (!test) {
-          throw new Error('The `meta` returned from `extractMeta` has to be an object, not "' + typeof meta + '".');
-        }
-      })(typeof meta === 'object');
       // @ts-expect-error untyped
       documentHash.meta = meta;
     }
@@ -691,9 +738,6 @@ const JSONSerializer = Serializer.extend({
      @private
   */
   _getMappedKey(key, modelClass) {
-    console.warn('There is no attribute or relationship with the name `' + key + '` on `' + modelClass.modelName + '`. Check your serializers attrs hash.', modelClass.attributes.has(key) || modelClass.relationshipsByName.has(key), {
-      id: 'ds.serializer.no-mapped-attrs-key'
-    }); // @ts-expect-error attrs is dynamically injected
     const attrs = this.attrs;
     let mappedKey;
     if (attrs && attrs[key]) {
@@ -741,9 +785,7 @@ const JSONSerializer = Serializer.extend({
   */
   shouldSerializeHasMany(snapshot, key, relationship) {
     // @ts-expect-error store is dynamically injected
-    const schema = this.store.modelFor(snapshot.modelName);
-    // @ts-expect-error store is dynamically injected
-    const relationshipType = schema.determineRelationshipType(relationship, this.store);
+    const relationshipType = determineRelationshipType(this.store, snapshot.modelName, relationship);
     if (this._mustSerialize(key)) {
       return true;
     }
@@ -782,8 +824,15 @@ const JSONSerializer = Serializer.extend({
      `serialize` takes an options hash with a single option:
     `includeId`. If this option is `true`, `serialize` will,
     by default include the ID in the JSON object it builds.
-     The adapter passes in `includeId: true` when serializing
-    a record for `createRecord`, but not for `updateRecord`.
+     Whether `includeId` is `true` or `false` depends on the
+    adapter and the operation being performed, since it is the
+    adapter that invokes `serialize` and decides which options
+    to pass. For instance, `RESTAdapter` passes `includeId: true`
+    when serializing a record for `createRecord`, but not for
+    `updateRecord`, while `JSONAPIAdapter` passes `includeId: true`
+    for both `createRecord` and `updateRecord`. Refer to the
+    documentation for the adapter and serializer pairing you are
+    using for specifics.
      ## Customization
      Your server may expect a different JSON format than the
     built-in serialization format.
@@ -1245,12 +1294,7 @@ const JSONSerializer = Serializer.extend({
   */
   transformFor(attributeType, skipAssertion) {
     const transform = getOwner(this).lookup(`transform:${attributeType}`);
-    (test => {
-      if (!test) {
-        throw new Error(`Unable to find the transform for \`attr('${attributeType}')\``);
-      }
-    })(skipAssertion || !!transform);
     return transform;
   }
 });
-export { JSONSerializer as J, coerceId as c };
+export { JSONSerializer as J, coerceId as c, inverseForRelationship as i };

package/dist/unpkg/prod-deprecated/model/-private.js

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

package/dist/unpkg/prod-deprecated/model/migration-support.js

@@ -4,8 +4,8 @@ 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-CdDaK81x.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-CjX55uSY.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-Dl2J9d1D.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-Dh6tRqVI.js";
 
 /**
  * This module provides support for migrating away from @warp-drive/legacy/model
@@ -27,6 +27,12 @@ import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as s
  * @module
  */
 
+/**
+ * Adds the `Model`-style `belongsTo`/`hasMany` reference methods to a
+ * {@link TypedRecordInstance}, for use when migrating a resource from
+ * `Model` to a schema-based record while preserving these APIs.
+ */
+
 // 'isDestroying', 'isDestroyed'
 const LegacyFields = ['_createSnapshot', 'adapterError', 'belongsTo', 'changedAttributes', 'constructor', 'currentState', 'deleteRecord', 'destroyRecord', 'dirtyType', 'errors', 'hasDirtyAttributes', 'hasMany', 'isDeleted', 'isEmpty', 'isError', 'isLoaded', 'isLoading', 'isNew', 'isSaving', 'isValid', 'reload', 'rollbackAttributes', 'save', 'serialize', 'unloadRecord'];
 
@@ -416,6 +422,9 @@ function registerDerivations(schema) {
  * @public
  */
 
+/**
+ * See the {@link DelegatingSchemaService | class documentation above} for usage.
+ */
 class DelegatingSchemaService {
   /** @internal */
   _preferred;
@@ -425,6 +434,11 @@ class DelegatingSchemaService {
     this._preferred = schema;
     this._secondary = buildSchema(store);
   }
+
+  /**
+   * Whether the given resource's schema is being served by the fallback
+   * (legacy Model-derived) schema service rather than the primary one.
+   */
   isDelegated(resource) {
     return !this._preferred.hasResource(resource) && this._secondary.hasResource(resource);
   }

package/dist/{model-for-CqXsIKws.js → unpkg/prod-deprecated/model-for-CXkJw59V.js}

@@ -1,6 +1,11 @@
 import { tracked, cached } from '@glimmer/tracking';
 import { Context } from '@warp-drive/core/reactive/-private';
 import { a as decorateFieldV2, i as initializeDeferredDecorator, d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
+
+/**
+ * The features added to an object resource by {@link FragmentExtension}, providing
+ * a subset of the legacy `ModelFragments` fragment API for migrated resources.
+ */
 class Fragment {
   static {
     decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
@@ -8,12 +13,21 @@ class Fragment {
     });
   }
   #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  /**
+   * Whether this fragment is in the process of being destroyed.
+   */
   static {
     decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
       return false;
     });
   }
   #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  /**
+   * Whether this fragment has been destroyed.
+   */
+  /**
+   * Whether this fragment (or the attribute it is rooted at) has uncommitted changes.
+   */
   get hasDirtyAttributes() {
     const {
       path,
@@ -27,18 +41,30 @@ class Fragment {
     }
     return false;
   }
+
+  /**
+   * Always `true`. Used to distinguish fragments from other resources.
+   */
   static {
     decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
   }
   get isFragment() {
     return true;
   }
+
+  /**
+   * The resource type of this fragment, if known.
+   */
   get $type() {
     const {
       field
     } = this[Context];
     return field?.type;
   }
+
+  /**
+   * Reverts this fragment's attribute back to its last known remote value.
+   */
   rollbackAttributes() {
     const {
       path,
@@ -51,11 +77,21 @@ class Fragment {
     }
   }
 }
+
+/**
+ * A schema extension that adds the {@link Fragment} API to migrated
+ * `ModelFragments` object resources.
+ */
 const FragmentExtension = {
   kind: 'object',
   name: 'fragment',
   features: Fragment
 };
+
+/**
+ * The features added to an array resource by {@link FragmentArrayExtension}, providing
+ * a subset of the legacy `ModelFragments` fragment-array API for migrated resources.
+ */
 class FragmentArray {
   static {
     decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
@@ -63,18 +99,29 @@ class FragmentArray {
     });
   }
   #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  /**
+   * Whether this fragment array is in the process of being destroyed.
+   */
   static {
     decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
       return false;
     });
   }
   #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  /**
+   * Whether this fragment array has been destroyed.
+   */
+  /**
+   * Whether this fragment array (or any of its members) has uncommitted changes.
+   */
   get hasDirtyAttributes() {
+    const array = this;
+    const context = array[Context];
     const {
       path,
       resourceKey,
       store
-    } = this[Context];
+    } = context;
     const record = store.peekRecord(resourceKey);
     if (record.hasDirtyAttributes && path) {
       const root = path.at(0);
@@ -82,6 +129,10 @@ class FragmentArray {
     }
     return false;
   }
+
+  /**
+   * Adds an existing fragment to this array, if one was given.
+   */
   static {
     decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
   }
@@ -91,12 +142,20 @@ class FragmentArray {
     }
     return this.addObject(fragment);
   }
+
+  /**
+   * Appends a new fragment to the end of this array, if one was given.
+   */
   createFragment(fragment) {
     if (!fragment) {
       return;
     }
     return this.pushObject(fragment);
   }
+
+  /**
+   * Removes the given fragment from this array, if present.
+   */
   removeFragment(fragment) {
     if (!fragment) {
       return;
@@ -106,6 +165,10 @@ class FragmentArray {
       this.splice(index, 1);
     }
   }
+
+  /**
+   * Reverts each member fragment's attribute back to its last known remote value.
+   */
   rollbackAttributes() {
     for (const fragment of this) {
       // @ts-expect-error TODO: fix these types
@@ -113,6 +176,11 @@ class FragmentArray {
     }
   }
 }
+
+/**
+ * A schema extension that adds the {@link FragmentArray} API to migrated
+ * `ModelFragments` array resources.
+ */
 const FragmentArrayExtension = {
   kind: 'array',
   name: 'fragment-array',
@@ -217,5 +285,13 @@ class ShimModelClass {
 function fragmentsModelFor(modelName) {
   return getShimClass(this, modelName);
 }
+
+/**
+ * The `modelFor` fallback used to construct a `ShimModelClass` schema for a
+ * type when ModelFragments support is enabled and no real `Model` subclass
+ * is registered for that type.
+ *
+ * @public
+ */
 const modelFor = fragmentsModelFor;
 export { FragmentExtension as F, FragmentArrayExtension as a, FragmentArray as b, Fragment as c, fragmentsModelFor as f, modelFor as m };

package/dist/unpkg/prod-deprecated/model-fragments.js

@@ -1,7 +1,7 @@
 import { pluralize, singularize } from '@warp-drive/utilities/string';
 import { withDefaults } from './model/migration-support.js';
-import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-CqXsIKws.js";
-export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-CqXsIKws.js";
+import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-CXkJw59V.js";
+export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-CXkJw59V.js";
 
 /**
  * Used as a helper to setup the relevant parts of an array
@@ -62,6 +62,15 @@ function withFragmentArrayDefaults(fragmentArrayType, fragmentArrayName) {
     }
   };
 }
+
+/**
+ * Used as a helper to setup the relevant parts of a legacy resource schema
+ * migrated from `Model`, applying the `ember-object` and `fragment` object
+ * extensions and a default `@id` identity field.
+ *
+ * @param schema the partial legacy resource schema to complete
+ * @returns the completed resource schema
+ */
 function withLegacy(schema) {
   return withDefaults({
     ...schema,
@@ -72,6 +81,13 @@ function withLegacy(schema) {
     objectExtensions: ['ember-object', 'fragment']
   });
 }
+
+/**
+ * Registers the {@link FragmentExtension}/{@link FragmentArrayExtension} schema
+ * extensions on the given `SchemaService`, enabling ModelFragments migration support.
+ *
+ * @public
+ */
 function registerFragmentExtensions(schema) {
   schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
   schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);

package/dist/unpkg/prod-deprecated/model.js

@@ -3,10 +3,10 @@ import { recordIdentifierFor } from '@warp-drive/core';
 import { RecordStore } from '@warp-drive/core/types/symbols';
 import { i as isElementDescriptor, n as normalizeModelName } from "./util-B6cn-i93.js";
 import { assertPrivateStore } from '@warp-drive/core/store/-private';
-import { l as lookupLegacySupport } from "./errors-CdDaK81x.js";
+import { l as lookupLegacySupport } from "./errors-Dl2J9d1D.js";
 import { singularize, dasherize } from '@warp-drive/utilities/string';
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-CjX55uSY.js";
-export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-yId87yyG.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-Dh6tRqVI.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-Cm60wWTf.js";
 
 /**
  * Options provided to the attr decorator are
@@ -44,6 +44,7 @@ function _attr(type, options) {
     kind: 'attribute',
     isAttribute: true,
     options: options,
+    sourceKey: options.sourceKey,
     key: null
   };
   return computed({
@@ -52,14 +53,15 @@ function _attr(type, options) {
         return;
       }
       const cache = this[RecordStore].cache;
-      return cache.getAttr(recordIdentifierFor(this), key);
+      return cache.getAttr(recordIdentifierFor(this), meta.sourceKey ?? key);
     },
     set(key, value) {
       const identifier = recordIdentifierFor(this);
       const cache = this[RecordStore].cache;
-      const currentValue = cache.getAttr(identifier, key);
+      const cacheKey = meta.sourceKey ?? key;
+      const currentValue = cache.getAttr(identifier, cacheKey);
       if (currentValue !== value) {
-        cache.setAttr(identifier, key, value);
+        cache.setAttr(identifier, cacheKey, value);
         if (!this.isValid) {
           const {
             errors
@@ -201,7 +203,8 @@ function _belongsTo(type, options) {
     type: normalizeModelName(type),
     options: options,
     kind: 'belongsTo',
-    name: '<Unknown BelongsTo>'
+    name: '<Unknown BelongsTo>',
+    sourceKey: options.sourceKey
   };
   return computed({
     get(key) {
@@ -407,7 +410,8 @@ function _hasMany(type, options) {
     type: normalizeType(type),
     options,
     kind: 'hasMany',
-    name: '<Unknown BelongsTo>'
+    name: '<Unknown BelongsTo>',
+    sourceKey: options.sourceKey
   };
   return computed({
     get(key) {

package/dist/unpkg/prod-deprecated/{schema-provider-CjX55uSY.js → schema-provider-Dh6tRqVI.js}

@@ -4,7 +4,7 @@ import { recordIdentifierFor, storeFor } from '@warp-drive/core';
 import { notifyInternalSignal, peekInternalSignal, withSignalStore, gate, memoized, defineSignal, entangleSignal, defineGate } from '@warp-drive/core/signals/-leaked';
 import { assertPrivateStore, recordIdentifierFor as recordIdentifierFor$1, coerceId } from '@warp-drive/core/store/-private';
 import { RecordStore } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-CdDaK81x.js";
+import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-Dl2J9d1D.js";
 import { u as upgradeStore, F as FetchManager } from "./-private-BdyZaGEh.js";
 import { cacheFor } from '@ember/object/internals';
 import { Context } from '@warp-drive/core/reactive/-private';
@@ -866,6 +866,9 @@ class Model extends EmberObject {
   get isError() {
     return this.currentState.isError;
   }
+  /**
+   * `isError` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "isError", [memoized]);
   }
@@ -903,6 +906,10 @@ class Model extends EmberObject {
 
     return recordIdentifierFor(this).id;
   }
+  /**
+   * Assigns the resource's primary key. Typically only used internally
+   * when a client-created record is assigned an id upon being saved.
+   */
   static {
     decorateMethodV2(this.prototype, "id", [gate]);
   }
@@ -937,6 +944,9 @@ class Model extends EmberObject {
     }
     return this.___recordState;
   }
+  /**
+   * `currentState` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "currentState", [gate]);
   }
@@ -1010,6 +1020,9 @@ class Model extends EmberObject {
   get adapterError() {
     return this.currentState.adapterError;
   }
+  /**
+   * `adapterError` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "adapterError", [memoized]);
   }
@@ -1077,12 +1090,29 @@ class Model extends EmberObject {
   eachRelationship(callback, binding) {
     this.constructor.eachRelationship(callback, binding);
   }
+
+  /**
+   * Returns the relationship schema for the given relationship name, if any.
+   */
   relationshipFor(name) {
     return this.constructor.relationshipsByName.get(name);
   }
+
+  /**
+   * Returns the inverse relationship schema for the given relationship
+   * name, if one exists. See {@link Model.inverseFor | the static inverseFor}.
+   */
   inverseFor(name) {
     return this.constructor.inverseFor(name, storeFor(this, false));
   }
+
+  /**
+   * Iterates over the attributes defined on this record's class, calling
+   * `callback` for each one. See {@link Model.eachAttribute | the static eachAttribute}.
+   *
+   * @param callback the callback to invoke
+   * @param binding the value to which the callback's `this` should be bound
+   */
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
@@ -1149,6 +1179,11 @@ class Model extends EmberObject {
     const relationship = this.relationshipsByName.get(name);
     return relationship && store.modelFor(relationship.type);
   }
+
+  /**
+   * A cache of resolved inverse relationships by name, populated lazily by
+   * {@link Model.inverseFor | inverseFor}.
+   */
   static get inverseMap() {
     return Object.create(null);
   }
@@ -1191,6 +1226,9 @@ class Model extends EmberObject {
     }
   }
 
+  /**
+   * @private
+   */
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(name, store) {
     const relationship = this.relationshipsByName.get(name);
@@ -1376,6 +1414,12 @@ class Model extends EmberObject {
     }
     return map;
   }
+
+  /**
+   * A hash of the model's relationship schemas keyed by relationship name.
+   * See also {@link Model.relationshipsByName | relationshipsByName}, which
+   * provides the same information as a `Map`.
+   */
   static {
     decorateMethodV2(this, "relationshipsByName", [computeOnce]);
   }
@@ -1686,6 +1730,13 @@ defineGate(Model.prototype, 'isReloading', {
   // @ts-expect-error specially handled prop
   isLocal: true
 });
+
+/**
+ * Restores the pre-`RequestManager` implementations of `save`,
+ * `destroyRecord`, and `reload` onto the given `Model` subclass, for
+ * apps that have not yet migrated off of the deprecated
+ * `ENABLE_LEGACY_REQUEST_METHODS` behaviors.
+ */
 function restoreDeprecatedModelRequestBehaviors(ModelKlass) {
   // @ts-expect-error TS doesn't know how to do `this` function overloads
   ModelKlass.prototype.save = _save;
@@ -1783,7 +1834,11 @@ class ModelSchemaProvider {
   registerHashFn(hashFn) {}
   /** @internal */
   _loadModelSchema(type) {
-    const modelClass = this.store.modelFor(type);
+    const factory = getModelFactory(this.store, type);
+    if (!factory) {
+      throw new Error(`No model was found for '${type}'`);
+    }
+    const modelClass = factory.class;
     const attributeMap = modelClass.attributes;
     const attributes = Object.create(null);
     attributeMap.forEach((meta, name) => attributes[name] = meta);
@@ -1804,11 +1859,17 @@ class ModelSchemaProvider {
       type,
       fields: Array.from(fields.values())
     };
+    const cacheFields = new Map();
+    for (const field of fields.values()) {
+      const cacheKey = field.sourceKey ?? field.name;
+      cacheFields.set(cacheKey, field);
+    }
     const internalSchema = {
       schema,
       attributes,
       relationships,
-      fields
+      fields,
+      cacheFields
     };
     this._schemas.set(type, internalSchema);
     return internalSchema;
@@ -1820,6 +1881,13 @@ class ModelSchemaProvider {
     }
     return this._schemas.get(type).fields;
   }
+  cacheFields(resource) {
+    const type = normalizeModelName(resource.type);
+    if (!this._schemas.has(type)) {
+      this._loadModelSchema(type);
+    }
+    return this._schemas.get(type).cacheFields;
+  }
   hasResource(resource) {
     const type = normalizeModelName(resource.type);
     if (this._schemas.has(type)) {
@@ -1868,6 +1936,14 @@ class ModelSchemaProvider {
     return this._schemas.get(type).relationships;
   };
 }
+
+/**
+ * The `createSchemaService` implementation for use with `Model`. Pass
+ * the result of this to your store's `createSchemaService` method when
+ * configuring the store to use `Model` for schema information.
+ *
+ * @public
+ */
 function buildSchema(store) {
   return new ModelSchemaProvider(store);
 }

package/dist/unpkg/prod-deprecated/serializer/json-api.js

@@ -1,5 +1,5 @@
 import { dasherize, pluralize, singularize } from '@warp-drive/utilities/string';
-import { J as JSONSerializer } from "../json-BWrZ5546.js";
+import { J as JSONSerializer } from "../json-Qewu-UN9.js";
 
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
@@ -102,7 +102,7 @@ import { J as JSONSerializer } from "../json-BWrZ5546.js";
   `extractRelationship`.
 
   ```js [app/serializers/application.js]
-  import JSONAPISerializer from '@warp-drive/legacy/serializer/json-api';
+  import { JSONAPISerializer } from '@warp-drive/legacy/serializer/json-api';
 
   export default class ApplicationSerializer extends JSONAPISerializer {
     normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {
@@ -136,10 +136,15 @@ const JSONAPISerializer = JSONSerializer.extend({
   */
   _normalizeDocumentHelper(documentHash) {
     if (Array.isArray(documentHash.data)) {
-      const ret = new Array(documentHash.data.length);
+      const ret = [];
       for (let i = 0; i < documentHash.data.length; i++) {
         const data = documentHash.data[i];
-        ret[i] = this._normalizeResourceHelper(data);
+        const normalized = this._normalizeResourceHelper(data);
+        if (normalized !== null) {
+          // @ts-expect-error untyped
+          // can be null when unknown type is encountered
+          ret.push(normalized);
+        }
       }
       documentHash.data = ret;
     } else if (documentHash.data && typeof documentHash.data === 'object') {

package/dist/unpkg/prod-deprecated/serializer/json.js

@@ -1,4 +1,4 @@
 import '@ember/application';
 import '@warp-drive/utilities/string';
 import '../serializer.js';
-export { J as JSONSerializer } from "../json-BWrZ5546.js";
+export { J as JSONSerializer } from "../json-Qewu-UN9.js";