ember-data-model-fragments 7.0.2 → 8.0.0

package/addon/ext.js

@@ -1,151 +1,11 @@
-import { assert } from '@ember/debug';
-import Store from '@ember-data/store';
 import Model from '@ember-data/model';
-// eslint-disable-next-line ember/use-ember-data-rfc-395-imports
-import { Snapshot } from 'ember-data/-private';
-import { dasherize } from '@ember/string';
-import JSONSerializer from '@ember-data/serializer/json';
-import FragmentCache from './cache/fragment-cache';
-import { default as Fragment } from './fragment';
-import { isPresent } from '@ember/utils';
-import { getOwner } from '@ember/application';
-
-function serializerForFragment(owner, normalizedModelName) {
-  let serializer = owner.lookup(`serializer:${normalizedModelName}`);
-
-  if (serializer !== undefined) {
-    return serializer;
-  }
-
-  // no serializer found for the specific model, fallback and check for application serializer
-  serializer = owner.lookup('serializer:-fragment');
-  if (serializer !== undefined) {
-    return serializer;
-  }
-
-  // final fallback, no model specific serializer, no application serializer, no
-  // `serializer` property on store: use json-api serializer
-  serializer = owner.lookup('serializer:-default');
-
-  return serializer;
-}
+import { dependencySatisfies, macroCondition } from '@embroider/macros';
+import { Snapshot } from '@ember-data/legacy-compat/-private';
+import fragmentCacheFor from './util/fragment-cache';
 /**
   @module ember-data-model-fragments
 */
 
-/**
-  @class Store
-  @namespace DS
-*/
-Store.reopen({
-  /**
-   * Override createCache to return our FragmentCache
-   * This is the V2 Cache hook introduced in ember-data 4.7+
-   */
-  createCache(storeWrapper) {
-    return new FragmentCache(storeWrapper);
-  },
-
-  /**
-   * Override teardownRecord to handle fragments in a disconnected state.
-   * In ember-data 4.12+, fragments can end up disconnected during unload,
-   * and the default teardownRecord fails when trying to destroy them.
-   */
-  teardownRecord(record) {
-    // Check if record is a fragment (by checking if it has no id or by model type)
-    // We need to handle the case where the fragment's store is disconnected
-    if (record.isDestroyed || record.isDestroying) {
-      return;
-    }
-    try {
-      record.destroy();
-    } catch (e) {
-      // If the error is about disconnected state, just let it go
-      // The fragment will be cleaned up by ember's garbage collection
-      if (
-        e?.message?.includes?.('disconnected state') ||
-        e?.message?.includes?.('cannot utilize the store')
-      ) {
-        return;
-      }
-      throw e;
-    }
-  },
-
-  /**
-    Create a new fragment that does not yet have an owner record.
-    The properties passed to this method are set on the newly created
-    fragment.
-
-    To create a new instance of the `name` fragment:
-
-    ```js
-    store.createFragment('name', {
-      first: 'Alex',
-      last: 'Routé'
-    });
-    ```
-
-    @method createFragment
-    @param {String} type
-    @param {Object} properties a hash of properties to set on the
-      newly created fragment.
-    @return {MF.Fragment} fragment
-  */
-  createFragment(modelName, props) {
-    assert(
-      `The '${modelName}' model must be a subclass of MF.Fragment`,
-      this.isFragment(modelName),
-    );
-    // Create a new identifier for the fragment
-    const identifier = this.identifierCache.createIdentifierForNewRecord({
-      type: modelName,
-    });
-    // Signal to cache that this is a new record
-    this.cache.clientDidCreate(identifier, props || {});
-    // Get the record instance
-    return this._instanceCache.getRecord(identifier, props);
-  },
-
-  /**
-    Returns true if the modelName is a fragment, false if not
-
-    @method isFragment
-    @private
-    @param {String} the modelName to check if a fragment
-    @return {boolean}
-  */
-  isFragment(modelName) {
-    if (modelName === 'application' || modelName === '-default') {
-      return false;
-    }
-
-    const type = this.modelFor(modelName);
-    return Fragment.detect(type);
-  },
-
-  serializerFor(modelName) {
-    // this assertion is cargo-culted from ember-data TODO: update comment
-    assert(
-      "You need to pass a model name to the store's serializerFor method",
-      isPresent(modelName),
-    );
-    assert(
-      `Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`,
-      typeof modelName === 'string',
-    );
-
-    const owner = getOwner(this);
-    const normalizedModelName = dasherize(modelName);
-
-    if (this.isFragment(normalizedModelName)) {
-      return serializerForFragment(owner, normalizedModelName);
-    } else {
-      return this._super(...arguments);
-    }
-  },
-});
-
 /**
   Override `Snapshot._attributes` to snapshot fragment attributes before they are
   passed to the `DS.Model#serialize`.
@@ -157,89 +17,65 @@ const oldSnapshotAttributes = Object.getOwnPropertyDescriptor(
   '_attributes',
 );
 
+// Symbol to store our converted attributes cache
+const FRAGMENT_ATTRS = Symbol('fragmentAttrs');
+
+function convertSnapshotValue(value) {
+  if (value && typeof value._createSnapshot === 'function') {
+    return value._createSnapshot();
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => convertSnapshotValue(item));
+  }
+
+  return value;
+}
+
+function isFragmentDefinition(definition) {
+  return definition?.isFragment || definition?.options?.isFragment;
+}
+
 Object.defineProperty(Snapshot.prototype, '_attributes', {
   get() {
-    const attrs = oldSnapshotAttributes.get.call(this);
-    Object.keys(attrs).forEach((key) => {
-      const attr = attrs[key];
-      // If the attribute has a `_createSnapshot` method, invoke it before the
-      // snapshot gets passed to the serializer
-      if (attr && typeof attr._createSnapshot === 'function') {
-        attrs[key] = attr._createSnapshot();
-      }
-      // Handle arrays of fragments (fragment arrays)
-      else if (Array.isArray(attr)) {
-        attrs[key] = attr.map((item) => {
-          if (item && typeof item._createSnapshot === 'function') {
-            return item._createSnapshot();
-          }
-          return item;
-        });
-      }
+    // Return cached converted attrs if available
+    if (this[FRAGMENT_ATTRS]) {
+      return this[FRAGMENT_ATTRS];
+    }
+
+    const cachedAttrs = oldSnapshotAttributes.get.call(this);
+
+    // Create a new object to avoid modifying the cached __attributes in place
+    // This is needed because ember-data caches __attributes and reuses it
+    const attrs = Object.create(null);
+
+    Object.keys(cachedAttrs).forEach((key) => {
+      attrs[key] = convertSnapshotValue(cachedAttrs[key]);
     });
-    return attrs;
-  },
-});
 
-/**
-  @class JSONSerializer
-  @namespace DS
-*/
-JSONSerializer.reopen({
-  /**
-    Enables fragment properties to have custom transforms based on the fragment
-    type, so that deserialization does not have to happen on the fly
-
-    @method transformFor
-    @private
-  */
-  transformFor(attributeType) {
-    if (attributeType.indexOf('-mf-') !== 0) {
-      return this._super(...arguments);
-    }
+    if (macroCondition(dependencySatisfies('ember-data', '>=5.8.0'))) {
+      const schema = this._store.getSchemaDefinitionService?.();
 
-    const owner = getOwner(this);
-    const containerKey = `transform:${attributeType}`;
-
-    if (!owner.hasRegistration(containerKey)) {
-      const match = attributeType.match(
-        /^-mf-(fragment|fragment-array|array)(?:\$([^$]+))?(?:\$(.+))?$/,
-      );
-      assert(
-        `Failed parsing ember-data-model-fragments attribute type ${attributeType}`,
-        match != null,
-      );
-      const transformName = match[1];
-      const type = match[2];
-      const polymorphicTypeProp = match[3];
-      let transformClass = owner.factoryFor(`transform:${transformName}`);
-      transformClass = transformClass && transformClass.class;
-      transformClass = transformClass.extend({
-        type,
-        polymorphicTypeProp,
-        store: this.store,
-      });
-      owner.register(containerKey, transformClass);
-    }
-    return owner.lookup(containerKey);
-  },
+      if (schema) {
+        const definitions = schema.attributesDefinitionFor(this.identifier);
 
-  // We need to override this to handle polymorphic with a typeKey function
-  applyTransforms(typeClass, data) {
-    const attributes = typeClass.attributes;
+        Object.entries(definitions).forEach(([key, definition]) => {
+          if (key in attrs || !isFragmentDefinition(definition)) {
+            return;
+          }
 
-    typeClass.eachTransformedAttribute((key, typeClass) => {
-      if (data[key] === undefined) {
-        return;
+          attrs[key] = convertSnapshotValue(
+            fragmentCacheFor(this._store).getAttr(this.identifier, key),
+          );
+        });
       }
+    }
 
-      const transform = this.transformFor(typeClass);
-      const transformMeta = attributes.get(key);
-      data[key] = transform.deserialize(data[key], transformMeta.options, data);
-    });
+    // Cache the converted attrs
+    this[FRAGMENT_ATTRS] = attrs;
 
-    return data;
+    return attrs;
   },
 });
 
-export { Store, Model, JSONSerializer };
+export { Model };

package/addon/fragment.js

@@ -1,8 +1,10 @@
 import { get, computed } from '@ember/object';
-import Ember from 'ember';
+import { isDestroying, isDestroyed } from '@ember/destroyable';
+import { Comparable } from '@ember/-internals/runtime';
 // DS.Model gets munged to add fragment support, which must be included first
 import { Model } from './ext';
 import { copy } from './util/copy';
+import fragmentCacheFor from './util/fragment-cache';
 import { recordIdentifierFor } from '@ember-data/store';
 
 /**
@@ -15,7 +17,7 @@ import { recordIdentifierFor } from '@ember-data/store';
  */
 export function fragmentRecordDataFor(fragment) {
   const identifier = recordIdentifierFor(fragment);
-  return fragment.store.cache.createFragmentRecordData(identifier);
+  return fragmentCacheFor(fragment.store).createFragmentRecordData(identifier);
 }
 
 /**
@@ -30,14 +32,17 @@ export function fragmentRecordDataFor(fragment) {
   Example:
 
   ```javascript
-  App.Person = DS.Model.extend({
-    name: MF.fragment('name')
-  });
+  import Model from '@ember-data/model';
+  import MF from 'ember-data-model-fragments';
 
-  App.Name = MF.Fragment.extend({
-    first  : DS.attr('string'),
-    last   : DS.attr('string')
-  });
+  class Person extends Model {
+    @MF.fragment('name') name;
+  }
+
+  class Name extends MF.Fragment {
+    @attr('string') first;
+    @attr('string') last;
+  }
   ```
 
   With JSON response:
@@ -53,37 +58,39 @@ export function fragmentRecordDataFor(fragment) {
   ```
 
   ```javascript
-  let person = store.getbyid('person', '1');
-  let name = person.get('name');
+  let person = store.peekRecord('person', '1');
+  let name = person.name;
 
-  person.get('hasDirtyAttributes'); // false
-  name.get('hasDirtyAttributes'); // false
-  name.get('first'); // 'Robert'
+  person.hasDirtyAttributes; // false
+  name.hasDirtyAttributes; // false
+  name.first; // 'Robert'
 
-  name.set('first', 'The Animal');
-  name.get('hasDirtyAttributes'); // true
-  person.get('hasDirtyAttributes'); // true
+  name.first = 'The Animal';
+  name.hasDirtyAttributes; // true
+  person.hasDirtyAttributes; // true
 
   person.rollbackAttributes();
-  name.get('first'); // 'Robert'
-  person.get('hasDirtyAttributes'); // false
-  person.get('hasDirtyAttributes'); // false
+  name.first; // 'Robert'
+  person.hasDirtyAttributes; // false
   ```
 
   @class Fragment
   @namespace MF
-  @extends CoreModel
-  @uses Ember.Comparable
-  @uses Copyable
+  @extends Model
+  @uses Comparable
+  @public
 */
-const Fragment = Model.extend(Ember.Comparable, {
+// Note: We use Model.extend() with Comparable mixin for now
+// as mixins are being phased out but still work in ember-data 4.12+
+const Fragment = Model.extend(Comparable, {
   /**
     Compare two fragments by identity to allow `FragmentArray` to diff arrays.
 
     @method compare
-    @param a {MF.Fragment} the first fragment to compare
-    @param b {MF.Fragment} the second fragment to compare
-    @return {Integer} the result of the comparison
+    @param {Fragment} f1 - The first fragment to compare
+    @param {Fragment} f2 - The second fragment to compare
+    @return {Integer} The result of the comparison (0 if equal, 1 if not)
+    @public
   */
   compare(f1, f2) {
     return f1 === f2 ? 0 : 1;
@@ -95,53 +102,117 @@ const Fragment = Model.extend(Ember.Comparable, {
     to other records safely.
 
     @method copy
-    @return {MF.Fragment} the newly created fragment
+    @return {Fragment} The newly created fragment
+    @public
   */
   copy() {
     const type = this.constructor;
     const props = Object.create(null);
     const modelName = type.modelName || this._internalModel.modelName;
+    const identifier = recordIdentifierFor(this);
 
-    // Look up model via store to avoid schema access deprecation in ember-data 4.12+
-    const modelClass = this.store.modelFor(modelName);
+    // Use schema service to get all attributes including fragment attributes
+    // eachAttribute only iterates standard @attr() properties, not fragment properties
+    const schemaService = this.store
+      .getSchemaDefinitionService()
+      .attributesDefinitionFor(identifier);
 
     // Loop over each attribute and copy individually to ensure nested fragments
-    // are also copied
-    modelClass.eachAttribute((name) => {
-      props[name] = copy(get(this, name));
-    });
+    // are also copied. For fragment attributes, we need to serialize to raw data
+    // since createFragment expects raw data, not fragment instances.
+    for (const name of Object.keys(schemaService)) {
+      const value = get(this, name);
+      const definition = schemaService[name];
+      const isFragmentAttr =
+        definition?.isFragment || definition?.options?.isFragment;
+
+      if (isFragmentAttr) {
+        // For fragment attributes, serialize to get raw data that can be used to create new fragments
+        if (value === null || value === undefined) {
+          props[name] = value;
+        } else if (typeof value.serialize === 'function') {
+          // Single fragment - serialize it
+          props[name] = value.serialize();
+        } else if (
+          Array.isArray(value) ||
+          typeof value.toArray === 'function'
+        ) {
+          // Fragment array or array - serialize each element
+          const arr =
+            typeof value.toArray === 'function' ? value.toArray() : value;
+          props[name] = arr.map((item) =>
+            typeof item.serialize === 'function' ? item.serialize() : item,
+          );
+        } else {
+          // Fallback - use as-is
+          props[name] = value;
+        }
+      } else {
+        // Regular attribute - just copy the value
+        props[name] = copy(value);
+      }
+    }
 
     return this.store.createFragment(modelName, props);
   },
 
+  /**
+    @method toStringExtension
+    @return {String}
+    @public
+  */
   toStringExtension() {
+    if (isDestroying(this) || isDestroyed(this)) {
+      return '';
+    }
     const identifier = recordIdentifierFor(this);
-    const owner = this.store.cache.getFragmentOwner(identifier);
+    const owner = fragmentCacheFor(this.store).getFragmentOwner(identifier);
     return owner ? `owner(${owner.ownerIdentifier?.id})` : '';
   },
 
   /**
     Override toString to include the toStringExtension output.
     ember-data 4.12+ doesn't call toStringExtension in Model.toString().
+
+    @method toString
+    @return {String}
+    @public
   */
   toString() {
+    if (isDestroying(this) || isDestroyed(this)) {
+      return `<fragment(destroyed)>`;
+    }
     const identifier = recordIdentifierFor(this);
     const extension = this.toStringExtension();
     const extensionStr = extension ? `:${extension}` : '';
     return `<${identifier.type}:${identifier.id}${extensionStr}>`;
   },
-}).reopenClass({
-  fragmentOwnerProperties: computed(function () {
-    const props = [];
+});
 
-    this.eachComputedProperty((name, meta) => {
-      if (meta.isFragmentOwner) {
-        props.push(name);
-      }
-    });
+// Add static property using native class syntax approach
+// This replaces reopenClass which is deprecated
+Object.defineProperty(Fragment, 'fragmentOwnerProperties', {
+  get() {
+    return computed(function () {
+      const props = [];
 
-    return props;
-  }).readOnly(),
+      this.eachComputedProperty((name, meta) => {
+        if (meta.isFragmentOwner) {
+          props.push(name);
+        }
+      });
+
+      return props;
+    }).readOnly();
+  },
+  configurable: true,
+});
+
+Object.defineProperty(Fragment, 'toString', {
+  value() {
+    return `model:${this.modelName || 'fragment'}`;
+  },
+  configurable: true,
 });
 
 /**
@@ -171,7 +242,7 @@ export function setFragmentOwner(fragment, ownerRecordDataOrIdentifier, key) {
   const fragmentIdentifier = recordIdentifierFor(fragment);
   const ownerIdentifier =
     ownerRecordDataOrIdentifier.identifier || ownerRecordDataOrIdentifier;
-  fragment.store.cache.setFragmentOwner(
+  fragmentCacheFor(fragment.store).setFragmentOwner(
     fragmentIdentifier,
     ownerIdentifier,
     key,
@@ -180,7 +251,17 @@ export function setFragmentOwner(fragment, ownerRecordDataOrIdentifier, key) {
   // Notify any observers of `fragmentOwner` properties
   // Look up model via store to avoid schema access deprecation in ember-data 4.12+
   const modelClass = fragment.store.modelFor(fragment.constructor.modelName);
-  modelClass.fragmentOwnerProperties.forEach((name) => {
+
+  // Get the fragment owner properties array
+  // In 4.13+, we need to iterate computed properties directly since static property access may not work
+  const ownerProps = [];
+  modelClass.eachComputedProperty((name, meta) => {
+    if (meta.isFragmentOwner) {
+      ownerProps.push(name);
+    }
+  });
+
+  ownerProps.forEach((name) => {
     fragment.notifyPropertyChange(name);
   });
 
@@ -200,7 +281,7 @@ export function isFragment(obj) {
 Object.defineProperty(Fragment.prototype, 'hasDirtyAttributes', {
   get() {
     const identifier = recordIdentifierFor(this);
-    return this.store.cache.hasChangedAttrs(identifier);
+    return fragmentCacheFor(this.store).hasChangedAttrs(identifier);
   },
   configurable: true,
 });

package/addon/index.js

@@ -1,5 +1,5 @@
 import Namespace from '@ember/application/namespace';
-import Ember from 'ember';
+import { importSync } from '@embroider/macros';
 import VERSION from './version';
 import Fragment from './fragment';
 import FragmentArray from './array/fragment';
@@ -7,6 +7,11 @@ import FragmentTransform from './transforms/fragment';
 import FragmentArrayTransform from './transforms/fragment-array';
 import ArrayTransform from './transforms/array';
 import { fragment, fragmentArray, array, fragmentOwner } from './attributes';
+import FragmentStore from './store';
+import FragmentSerializer, {
+  FragmentRESTSerializer,
+  FragmentJSONAPISerializer,
+} from './serializer';
 
 /**
   Ember Data Model Fragments
@@ -21,14 +26,20 @@ const MF = Namespace.create({
   FragmentTransform: FragmentTransform,
   FragmentArrayTransform: FragmentArrayTransform,
   ArrayTransform: ArrayTransform,
+  FragmentStore: FragmentStore,
+  FragmentSerializer: FragmentSerializer,
+  FragmentRESTSerializer: FragmentRESTSerializer,
+  FragmentJSONAPISerializer: FragmentJSONAPISerializer,
   fragment: fragment,
   fragmentArray: fragmentArray,
   array: array,
   fragmentOwner: fragmentOwner,
 });
 
-if (Ember.libraries) {
-  Ember.libraries.register('Model Fragments', MF.VERSION);
-}
+Object.defineProperty(MF, 'FragmentSchemaService', {
+  get() {
+    return importSync('./schema-service').default;
+  },
+});
 
 export default MF;