ember-data-model-fragments 7.0.2 → 8.0.0

package/addon/schema-service.js

@@ -0,0 +1,190 @@
+function getType(resource) {
+  return typeof resource === 'string' ? resource : resource.type;
+}
+
+function isFragmentAttribute(meta) {
+  return (
+    typeof meta === 'object' &&
+    meta !== null &&
+    'kind' in meta &&
+    meta.isFragment === true &&
+    (meta.kind === 'fragment' ||
+      meta.kind === 'fragment-array' ||
+      meta.kind === 'array')
+  );
+}
+
+function transformFragmentMeta(name, meta) {
+  return {
+    name,
+    key: name,
+    kind: 'attribute',
+    type: meta.type,
+    options: {
+      ...meta.options,
+      isFragment: true,
+      fragmentKind: meta.kind,
+      modelName: meta.modelName,
+    },
+    isAttribute: true,
+    isFragment: true,
+    modelName: meta.modelName,
+  };
+}
+
+function mergedCacheFields(fields) {
+  const cacheFields = new Map();
+
+  fields.forEach((field, key) => {
+    if (field.kind === '@id' || field.kind === '@hash') {
+      return;
+    }
+
+    cacheFields.set(field.sourceKey || field.name || key, field);
+  });
+
+  return cacheFields;
+}
+
+export default class FragmentSchemaService {
+  constructor(store, schema) {
+    this.store = store;
+    this._schema = schema;
+  }
+
+  _fragmentDefinitionsFor(resource) {
+    const type = getType(resource);
+    const modelClass = this.store.modelFor(type);
+    const definitions = Object.create(null);
+
+    modelClass.eachComputedProperty((name, meta) => {
+      if (isFragmentAttribute(meta)) {
+        definitions[name] = transformFragmentMeta(name, meta);
+      }
+    });
+
+    return definitions;
+  }
+
+  _mergedFields(resource) {
+    const fields = new Map(this._schema.fields(resource));
+    const fragments = this._fragmentDefinitionsFor(resource);
+
+    Object.keys(fragments).forEach((name) => {
+      fields.set(name, fragments[name]);
+    });
+
+    return fields;
+  }
+
+  resourceTypes() {
+    return this._schema.resourceTypes();
+  }
+
+  hasResource(resource) {
+    return this._schema.hasResource(resource);
+  }
+
+  hasTrait(type) {
+    return this._schema.hasTrait(type);
+  }
+
+  resourceHasTrait(resource, trait) {
+    return this._schema.resourceHasTrait(resource, trait);
+  }
+
+  fields(resource) {
+    return this._mergedFields(resource);
+  }
+
+  cacheFields(resource) {
+    return mergedCacheFields(this._mergedFields(resource));
+  }
+
+  transformation(field) {
+    return this._schema.transformation(field);
+  }
+
+  hashFn(field) {
+    return this._schema.hashFn(field);
+  }
+
+  derivation(field) {
+    return this._schema.derivation(field);
+  }
+
+  resource(resource) {
+    const schema = this._schema.resource(resource);
+    const fields = this._mergedFields(resource);
+
+    return {
+      ...schema,
+      fields: Array.from(fields.values()),
+      cacheFields: mergedCacheFields(fields),
+    };
+  }
+
+  registerResources(schemas) {
+    this._schema.registerResources(schemas);
+  }
+
+  registerResource(schema) {
+    this._schema.registerResource(schema);
+  }
+
+  registerTransformation(transform) {
+    this._schema.registerTransformation(transform);
+  }
+
+  registerDerivation(derivation) {
+    this._schema.registerDerivation(derivation);
+  }
+
+  registerHashFn(hashFn) {
+    this._schema.registerHashFn(hashFn);
+  }
+
+  registerTrait(trait) {
+    this._schema.registerTrait?.(trait);
+  }
+
+  attributesDefinitionFor(resource) {
+    const attributes = this._schema.attributesDefinitionFor
+      ? { ...this._schema.attributesDefinitionFor(resource) }
+      : Object.create(null);
+    const fragments = this._fragmentDefinitionsFor(resource);
+
+    return Object.assign(attributes, fragments);
+  }
+
+  relationshipsDefinitionFor(resource) {
+    return this._schema.relationshipsDefinitionFor?.(resource);
+  }
+
+  doesTypeExist(type) {
+    return this._schema.doesTypeExist?.(type) ?? this.hasResource({ type });
+  }
+
+  CAUTION_MEGA_DANGER_ZONE_registerExtension(extension) {
+    this._schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(extension);
+  }
+
+  CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource) {
+    return this._schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions?.(resource);
+  }
+
+  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, resolvedType) {
+    return this._schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions?.(
+      field,
+      resolvedType,
+    );
+  }
+
+  CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) {
+    return this._schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions?.(field);
+  }
+
+  CAUTION_MEGA_DANGER_ZONE_hasExtension(extension) {
+    return this._schema.CAUTION_MEGA_DANGER_ZONE_hasExtension?.(extension);
+  }
+}

package/addon/serializer.js

@@ -0,0 +1,21 @@
+/**
+ * Re-exports for ember-data-model-fragments serializers.
+ *
+ * Usage:
+ *
+ * ```js
+ * // For JSONSerializer (default)
+ * import FragmentSerializer from 'ember-data-model-fragments/serializer';
+ *
+ * // For RESTSerializer
+ * import { FragmentRESTSerializer } from 'ember-data-model-fragments/serializer';
+ *
+ * // For JSONAPISerializer
+ * import { FragmentJSONAPISerializer } from 'ember-data-model-fragments/serializer';
+ * ```
+ */
+
+export { default } from './serializers/fragment';
+export { default as FragmentSerializer } from './serializers/fragment';
+export { default as FragmentRESTSerializer } from './serializers/rest';
+export { default as FragmentJSONAPISerializer } from './serializers/json-api';

package/addon/serializers/fragment.js

@@ -0,0 +1,85 @@
+import JSONSerializer from '@ember-data/serializer/json';
+import {
+  fragmentTransformFor,
+  fragmentApplyTransforms,
+  fragmentExtractAttributes,
+  fragmentSerialize,
+} from './utils';
+
+/**
+  FragmentSerializer is the base serializer class for ember-data-model-fragments.
+  Extends JSONSerializer.
+  
+  To use fragment serialization properly, your serializers should extend FragmentSerializer:
+  
+  ```js
+  // app/serializers/application.js
+  import FragmentSerializer from 'ember-data-model-fragments/serializer';
+  
+  export default class ApplicationSerializer extends FragmentSerializer {}
+  ```
+
+  @class FragmentSerializer
+  @extends JSONSerializer
+  @public
+*/
+export default class FragmentSerializer extends JSONSerializer {
+  serialize(snapshot, options) {
+    return fragmentSerialize(
+      this,
+      snapshot,
+      super.serialize(snapshot, options),
+    );
+  }
+
+  /**
+    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
+    @param {String} attributeType - The attribute type to get the transform for
+    @return {Transform}
+    @public
+  */
+  transformFor(attributeType) {
+    return fragmentTransformFor(
+      this,
+      attributeType,
+      JSONSerializer.prototype.transformFor,
+    );
+  }
+
+  /**
+    Override applyTransforms to handle polymorphic fragments with a typeKey function
+    
+    @method applyTransforms
+    @param {Class} typeClass - The model class
+    @param {Object} data - The data to apply transforms to
+    @return {Object} The transformed data
+    @public
+  */
+  applyTransforms(typeClass, data) {
+    return fragmentApplyTransforms(this, typeClass, data);
+  }
+
+  /**
+    Override extractAttributes to include fragment attributes.
+    The default implementation only iterates modelClass.eachAttribute which
+    doesn't include fragment attributes (they're computed properties with
+    isFragment: true metadata).
+
+    @method extractAttributes
+    @param {Class} modelClass - The model class
+    @param {Object} resourceHash - The raw resource data from the server
+    @return {Object} The extracted attributes
+    @public
+  */
+  extractAttributes(modelClass, resourceHash) {
+    return fragmentExtractAttributes(
+      this,
+      modelClass,
+      resourceHash,
+      JSONSerializer.prototype.extractAttributes,
+    );
+  }
+}

package/addon/serializers/json-api.js

@@ -0,0 +1,85 @@
+import JSONAPISerializer from '@ember-data/serializer/json-api';
+import {
+  fragmentTransformFor,
+  fragmentApplyTransforms,
+  fragmentExtractAttributesJSONAPI,
+  fragmentSerialize,
+} from './utils';
+
+/**
+  FragmentJSONAPISerializer is the base serializer class for ember-data-model-fragments
+  when using JSONAPISerializer.
+  
+  ```js
+  // app/serializers/application.js
+  import { FragmentJSONAPISerializer } from 'ember-data-model-fragments/serializer';
+  
+  export default class ApplicationSerializer extends FragmentJSONAPISerializer {}
+  ```
+
+  @class FragmentJSONAPISerializer
+  @extends JSONAPISerializer
+  @public
+*/
+export default class FragmentJSONAPISerializer extends JSONAPISerializer {
+  serialize(snapshot, options) {
+    return fragmentSerialize(
+      this,
+      snapshot,
+      super.serialize(snapshot, options),
+    );
+  }
+
+  /**
+    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
+    @param {String} attributeType - The attribute type to get the transform for
+    @return {Transform}
+    @public
+  */
+  transformFor(attributeType) {
+    return fragmentTransformFor(
+      this,
+      attributeType,
+      JSONAPISerializer.prototype.transformFor,
+    );
+  }
+
+  /**
+    Override applyTransforms to handle polymorphic fragments with a typeKey function
+    
+    @method applyTransforms
+    @param {Class} typeClass - The model class
+    @param {Object} data - The data to apply transforms to
+    @return {Object} The transformed data
+    @public
+  */
+  applyTransforms(typeClass, data) {
+    return fragmentApplyTransforms(this, typeClass, data);
+  }
+
+  /**
+    Override extractAttributes to include fragment attributes.
+    The default implementation only iterates modelClass.eachAttribute which
+    doesn't include fragment attributes (they're computed properties with
+    isFragment: true metadata).
+
+    For JSON:API, attributes are nested under resourceHash.attributes.
+
+    @method extractAttributes
+    @param {Class} modelClass - The model class
+    @param {Object} resourceHash - The raw resource data from the server
+    @return {Object} The extracted attributes
+    @public
+  */
+  extractAttributes(modelClass, resourceHash) {
+    return fragmentExtractAttributesJSONAPI(
+      this,
+      modelClass,
+      resourceHash,
+      JSONAPISerializer.prototype.extractAttributes,
+    );
+  }
+}

package/addon/serializers/rest.js

@@ -0,0 +1,83 @@
+import RESTSerializer from '@ember-data/serializer/rest';
+import {
+  fragmentTransformFor,
+  fragmentApplyTransforms,
+  fragmentExtractAttributes,
+  fragmentSerialize,
+} from './utils';
+
+/**
+  FragmentRESTSerializer is the base serializer class for ember-data-model-fragments
+  when using RESTSerializer.
+  
+  ```js
+  // app/serializers/application.js
+  import { FragmentRESTSerializer } from 'ember-data-model-fragments/serializer';
+  
+  export default class ApplicationSerializer extends FragmentRESTSerializer {}
+  ```
+
+  @class FragmentRESTSerializer
+  @extends RESTSerializer
+  @public
+*/
+export default class FragmentRESTSerializer extends RESTSerializer {
+  serialize(snapshot, options) {
+    return fragmentSerialize(
+      this,
+      snapshot,
+      super.serialize(snapshot, options),
+    );
+  }
+
+  /**
+    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
+    @param {String} attributeType - The attribute type to get the transform for
+    @return {Transform}
+    @public
+  */
+  transformFor(attributeType) {
+    return fragmentTransformFor(
+      this,
+      attributeType,
+      RESTSerializer.prototype.transformFor,
+    );
+  }
+
+  /**
+    Override applyTransforms to handle polymorphic fragments with a typeKey function
+    
+    @method applyTransforms
+    @param {Class} typeClass - The model class
+    @param {Object} data - The data to apply transforms to
+    @return {Object} The transformed data
+    @public
+  */
+  applyTransforms(typeClass, data) {
+    return fragmentApplyTransforms(this, typeClass, data);
+  }
+
+  /**
+    Override extractAttributes to include fragment attributes.
+    The default implementation only iterates modelClass.eachAttribute which
+    doesn't include fragment attributes (they're computed properties with
+    isFragment: true metadata).
+
+    @method extractAttributes
+    @param {Class} modelClass - The model class
+    @param {Object} resourceHash - The raw resource data from the server
+    @return {Object} The extracted attributes
+    @public
+  */
+  extractAttributes(modelClass, resourceHash) {
+    return fragmentExtractAttributes(
+      this,
+      modelClass,
+      resourceHash,
+      RESTSerializer.prototype.extractAttributes,
+    );
+  }
+}