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

package/dist/unpkg/{dev/json-Cu1LNgmQ.js → prod/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/model/-private.js

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

package/dist/unpkg/prod/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-BGVFCBmi.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-DJtD_8jZ.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-B-PWeYlW.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-BgRqk8i9.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/unpkg/prod/model-for-CXkJw59V.js

@@ -0,0 +1,297 @@
+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 () {
+      return false;
+    });
+  }
+  #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,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    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,
+      resourceKey,
+      store
+    } = this[Context];
+    if (path) {
+      const oldValue = store.cache.getRemoteAttr(resourceKey, path);
+      store.cache.setAttr(resourceKey, path, oldValue);
+    }
+  }
+}
+
+/**
+ * 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 () {
+      return false;
+    });
+  }
+  #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
+    } = context;
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+
+  /**
+   * Adds an existing fragment to this array, if one was given.
+   */
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  addFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    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;
+    }
+    const index = this.indexOf(fragment);
+    if (index !== -1) {
+      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
+      fragment?.rollbackAttributes?.();
+    }
+  }
+}
+
+/**
+ * A schema extension that adds the {@link FragmentArray} API to migrated
+ * `ModelFragments` array resources.
+ */
+const FragmentArrayExtension = {
+  kind: 'array',
+  name: 'fragment-array',
+  features: FragmentArray
+};
+
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap();
+function getShimClass(store, modelName) {
+  let shims = AvailableShims.get(store);
+  if (!shims) {
+    shims = Object.create(null);
+    AvailableShims.set(store, shims);
+  }
+  let shim = shims[modelName];
+  if (shim === undefined) {
+    shim = shims[modelName] = new ShimModelClass(store, modelName);
+  }
+  return shim;
+}
+const AttributeKinds = ['field', 'attribute', 'object', 'array', 'schema-object', 'schema-array'];
+
+// Mimics the static apis of @warp-drive/legacy/model
+class ShimModelClass {
+  constructor(store, modelName) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
+  get fields() {
+    const fields = new Map();
+    const fieldSchemas = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fieldSchemas.forEach((schema, key) => {
+      // @ts-expect-error checking if a string is a valid string
+      if (AttributeKinds.includes(schema.kind)) {
+        fields.set(key, 'attribute');
+      } else if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        fields.set(key, schema.kind);
+      }
+    });
+    return fields;
+  }
+  get attributes() {
+    const attrs = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        attrs.set(key, schema);
+        // @ts-expect-error checking if a string is a valid string
+      } else if (AttributeKinds.includes(schema.kind)) {
+        attrs.set(key, {
+          kind: 'attribute',
+          name: key,
+          type: null,
+          options: schema.options ?? {}
+        });
+      }
+    });
+    return attrs;
+  }
+  get relationshipsByName() {
+    const rels = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        rels.set(key, schema);
+      }
+    });
+    return rels;
+  }
+  eachAttribute(callback, binding) {
+    this.attributes.forEach((schema, key) => {
+      callback.call(binding, key, schema);
+    });
+  }
+  eachRelationship(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        callback.call(binding, key, schema);
+      }
+    });
+  }
+  eachTransformedAttribute(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        const type = schema.type;
+        if (type) callback.call(binding, key, type);
+      }
+    });
+  }
+}
+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/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/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-DvanW33H.js";
 import { assertPrivateStore } from '@warp-drive/core/store/-private';
-import { l as lookupLegacySupport } from "./errors-BGVFCBmi.js";
+import { l as lookupLegacySupport } from "./errors-B-PWeYlW.js";
 import '@warp-drive/utilities/string';
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DJtD_8jZ.js";
-export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-BztVA_x0.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-BgRqk8i9.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-Bx-zBziU.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) {
@@ -404,7 +407,8 @@ function _hasMany(type, options) {
     type: normalizeType(type),
     options,
     kind: 'hasMany',
-    name: '<Unknown BelongsTo>'
+    name: '<Unknown BelongsTo>',
+    sourceKey: options.sourceKey
   };
   return computed({
     get(key) {