@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.1

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

@@ -15,6 +15,78 @@ 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);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No relationship named '${name}' on '${type}' exists.`);
+    }
+  })(relationship) : {};
+  const {
+    options
+  } = relationship;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected the relationship ${name} on ${type} to define an inverse.`);
+    }
+  })(options.inverse === null || typeof options.inverse === 'string' && options.inverse.length > 0) : {};
+  if (options.inverse === null) {
+    return null;
+  }
+  const schemaExists = store.schema.hasResource(relationship);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No associated schema found for '${relationship.type}' while calculating the inverse of ${name} on ${type}`);
+    }
+  })(schemaExists) : {};
+  if (!schemaExists) {
+    return null;
+  }
+  const inverseField = store.schema.fields(relationship).get(options.inverse);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No inverse relationship found for '${name}' on '${type}'`);
+    }
+  })(inverseField && (inverseField.kind === 'belongsTo' || inverseField.kind === 'hasMany')) : {};
+  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 */
@@ -744,9 +816,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;
     }
@@ -785,8 +855,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.
@@ -1256,4 +1333,4 @@ const JSONSerializer = Serializer.extend({
     return transform;
   }
 });
-export { JSONSerializer as J, coerceId as c };
+export { JSONSerializer as J, coerceId as c, inverseForRelationship as i };

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-Cz5KrzBk.js";
+export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-DZKA206g.js";

package/dist/model/migration-support.js

@@ -5,8 +5,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-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 { l as lookupLegacySupport, E as Errors } from "../errors-DZKA206g.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-DtPOp0d7.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
@@ -28,6 +28,11 @@ import { macroCondition, getGlobalConfig } from '@embroider/macros';
  *
  * @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'];
 
@@ -434,6 +439,9 @@ function registerDerivations(schema) {
  * @public
  */
 
+/**
+ * See the {@link DelegatingSchemaService | class documentation above} for usage.
+ */
 class DelegatingSchemaService {
   /** @internal */
   _preferred;
@@ -443,6 +451,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/{unpkg/dev-deprecated/model-for-CqXsIKws.js → 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/model-fragments.js

@@ -1,20 +1,23 @@
-import { singularize, pluralize } from '@warp-drive/utilities/string';
+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
  * schema and add extensions etc.
  *
  * @param arrayName The name of the array
+ * @param primitiveType The primitive type of items in the array (optional)
  * @returns The schema for an array
  */
-function withArrayDefaults(arrayName) {
+
+function withArrayDefaults(arrayName, primitiveType) {
+  const type = primitiveType ? `array:${primitiveType}` : 'array';
   return {
     kind: 'array',
     name: arrayName,
-    type: `array:${singularize(arrayName)}`,
+    type,
     options: {
       arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array']
     }
@@ -59,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,
@@ -69,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/model.js

@@ -5,10 +5,10 @@ import { i as isElementDescriptor, n as normalizeModelName } from "./util-Dul6TZ
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
 import { assertPrivateStore } from '@warp-drive/core/store/-private';
-import { l as lookupLegacySupport } from "./errors-Cz5KrzBk.js";
+import { l as lookupLegacySupport } from "./errors-DZKA206g.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-DJCV_6AF.js";
-export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-D6diaM34.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DtPOp0d7.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-BvOqJBei.js";
 function _attr(type, options) {
   if (typeof type === 'object') {
     options = type;
@@ -21,6 +21,7 @@ function _attr(type, options) {
     kind: 'attribute',
     isAttribute: true,
     options: options,
+    sourceKey: options.sourceKey,
     key: null
   };
   return computed({
@@ -34,7 +35,7 @@ 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) {
       if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
@@ -49,9 +50,10 @@ function _attr(type, options) {
         }
       })(!this.currentState.isDeleted) : {};
       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
@@ -202,7 +204,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) {
@@ -456,7 +459,8 @@ function _hasMany(type, options) {
     type: normalizeType(type),
     options,
     kind: 'hasMany',
-    name: '<Unknown BelongsTo>'
+    name: '<Unknown BelongsTo>',
+    sourceKey: options.sourceKey
   };
   return computed({
     get(key) {