@ember-data/serializer 5.4.0-alpha.30 → 5.4.0-alpha.31

package/unstable-preview-types/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.js"],"names":[],"mappings":"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"}

package/unstable-preview-types/rest.d.ts

@@ -0,0 +1,600 @@
+/// <reference types="ember-source/types" />
+export { EmbeddedRecordsMixin } from "./-private";
+export default RESTSerializer;
+/**
+ * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
+  <p>
+    ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+    If starting a new app or thinking of implementing a new adapter, consider writing a
+    <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
+  </p>
+  </blockquote>
+
+  Normally, applications will use the `RESTSerializer` by implementing
+  the `normalize` method.
+
+  This allows you to do whatever kind of munging you need and is
+  especially useful if your server is inconsistent and you need to
+  do munging differently for many different kinds of responses.
+
+  See the `normalize` documentation for more information.
+
+  ## Across the Board Normalization
+
+  There are also a number of hooks that you might find useful to define
+  across-the-board rules for your payload. These rules will be useful
+  if your server is consistent, or if you're building an adapter for
+  an infrastructure service, like Firebase, and want to encode service
+  conventions.
+
+  For example, if all of your keys are underscored and all-caps, but
+  otherwise consistent with the names you use in your models, you
+  can implement across-the-board rules for how to convert an attribute
+  name in your model to a key in your JSON.
+
+  ```app/serializers/application.js
+  import RESTSerializer from '@ember-data/serializer/rest';
+  import { underscore } from '<app-name>/utils/string-utils';
+
+  export default class ApplicationSerializer extends RESTSerializer {
+    keyForAttribute(attr, method) {
+      return underscore(attr).toUpperCase();
+    }
+  }
+  ```
+
+  You can also implement `keyForRelationship`, which takes the name
+  of the relationship as the first parameter, the kind of
+  relationship (`hasMany` or `belongsTo`) as the second parameter, and
+  the method (`serialize` or `deserialize`) as the third parameter.
+
+  @class RESTSerializer
+  @main @ember-data/serializer/rest
+  @public
+  @extends JSONSerializer
+*/
+declare const RESTSerializer: Readonly<Readonly<typeof import(".").default> & (new (owner?: import("@ember/-internals/owner").default | undefined) => import(".").default) & {
+    primaryKey: string;
+    mergedProperties: Object;
+    applyTransforms(typeClass: Model, data: Object): Object;
+    normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object; /**
+      This method allows you to push a payload containing top-level
+      collections of records organized per type.
+  
+      ```js
+      {
+        "posts": [{
+          "id": "1",
+          "title": "Rails is omakase",
+          "author", "1",
+          "comments": [ "1" ]
+        }],
+        "comments": [{
+          "id": "1",
+          "body": "FIRST"
+        }],
+        "users": [{
+          "id": "1",
+          "name": "@d2h"
+        }]
+      }
+      ```
+  
+      It will first normalize the payload, so you can use this to push
+      in data streaming in from your server structured the same way
+      that fetches and saves are structured.
+  
+      @method pushPayload
+      @public
+      @param {Store} store
+      @param {Object} payload
+    */
+    normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+    normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
+    normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
+    _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
+    normalize(modelClass: any, resourceHash: any): Object;
+    extractId(modelClass: Object, resourceHash: Object): string;
+    extractAttributes(modelClass: Object, resourceHash: Object): Object;
+    extractRelationship(relationshipModelName: Object, relationshipHash: Object): Object;
+    extractPolymorphicRelationship(relationshipModelName: Object, relationshipHash: Object, relationshipOptions: Object): Object;
+    extractRelationships(modelClass: Object, resourceHash: Object): Object;
+    modelNameFromPayloadKey(key: string): string;
+    normalizeRelationships(typeClass: any, hash: any): void;
+    normalizeUsingDeclaredMapping(modelClass: any, hash: any): void;
+    _getMappedKey(key: string, modelClass: any): string;
+    _canSerialize(key: string): boolean;
+    _mustSerialize(key: string): boolean;
+    shouldSerializeHasMany(snapshot: Snapshot, key: string, relationship: RelationshipSchema): boolean;
+    serialize(snapshot: Snapshot, options: Object): Object;
+    serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
+    serializeAttribute(snapshot: Snapshot, json: Object, key: string, attribute: Object): void;
+    serializeBelongsTo(snapshot: Snapshot, json: Object, relationship: Object): void;
+    serializeHasMany(snapshot: Snapshot, json: Object, relationship: Object): void;
+    serializePolymorphicType(): void;
+    extractMeta(store: Store, modelClass: Model, payload: Object): any;
+    extractErrors(store: Store, typeClass: Model, payload: Object, id: string | number): Object;
+    keyForAttribute(key: string, method: string): string;
+    keyForRelationship(key: string, typeClass: string, method: string): string;
+    keyForLink(key: string, kind: string): string;
+    transformFor(attributeType: string, skipAssertion: boolean): Transform;
+}> & (new (owner?: import("@ember/-internals/owner").default | undefined) => import(".").default) & {
+    /**
+     `keyForPolymorphicType` can be used to define a custom key when
+     serializing and deserializing a polymorphic type. By default, the
+     returned key is `${key}Type`.
+  
+     Example
+  
+      ```app/serializers/post.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        keyForPolymorphicType(key, relationship) {
+          let relationshipKey = this.keyForRelationship(key);
+  
+          return 'type-' + relationshipKey;
+        }
+      }
+      ```
+  
+     @method keyForPolymorphicType
+      @public
+     @param {String} key
+     @param {String} typeClass
+     @param {String} method
+     @return {String} normalized key
+    */
+    keyForPolymorphicType(key: string, typeClass: string, method: string): string;
+    /**
+      Normalizes a part of the JSON payload returned by
+      the server. You should override this method, munge the hash
+      and call super if you have generic normalization to do.
+  
+      It takes the type of the record that is being normalized
+      (as a Model class), the property where the hash was
+      originally found, and the hash to normalize.
+  
+      For example, if you have a payload that looks like this:
+  
+      ```js
+      {
+        "post": {
+          "id": 1,
+          "title": "Rails is omakase",
+          "comments": [ 1, 2 ]
+        },
+        "comments": [{
+          "id": 1,
+          "body": "FIRST"
+        }, {
+          "id": 2,
+          "body": "Rails is unagi"
+        }]
+      }
+      ```
+  
+      The `normalize` method will be called three times:
+  
+      * With `App.Post`, `"posts"` and `{ id: 1, title: "Rails is omakase", ... }`
+      * With `App.Comment`, `"comments"` and `{ id: 1, body: "FIRST" }`
+      * With `App.Comment`, `"comments"` and `{ id: 2, body: "Rails is unagi" }`
+  
+      You can use this method, for example, to normalize underscored keys to camelized
+      or other general-purpose normalizations. You will only need to implement
+      `normalize` and manipulate the payload as desired.
+  
+      For example, if the `IDs` under `"comments"` are provided as `_id` instead of
+      `id`, you can specify how to normalize just the comments:
+  
+      ```app/serializers/post.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        normalize(model, hash, prop) {
+          if (prop === 'comments') {
+            hash.id = hash._id;
+            delete hash._id;
+          }
+  
+          return super.normalize(...arguments);
+        }
+      }
+      ```
+  
+      On each call to the `normalize` method, the third parameter (`prop`) is always
+      one of the keys that were in the original payload or in the result of another
+      normalization as `normalizeResponse`.
+  
+      @method normalize
+      @public
+      @param {Model} modelClass
+      @param {Object} resourceHash
+      @param {String} prop
+      @return {Object}
+    */
+    /**
+      Normalizes an array of resource payloads and returns a JSON-API Document
+      with primary data and, if any, included data as `{ data, included }`.
+  
+      @method _normalizeArray
+      @param {Store} store
+      @param {String} modelName
+      @param {Object} arrayHash
+      @param {String} prop
+      @return {Object}
+      @private
+    */
+    _normalizeArray(store: Store, modelName: string, arrayHash: Object, prop: string): Object;
+    _normalizePolymorphicRecord(store: any, hash: any, prop: any, primaryModelClass: any, primarySerializer: any): any;
+    /**
+      @method _normalizeResponse
+      @param {Store} store
+      @param {Model} primaryModelClass
+      @param {Object} payload
+      @param {String|Number} id
+      @param {String} requestType
+      @param {Boolean} isSingle
+      @return {Object} JSON-API Document
+      @private
+    */
+    _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
+    isPrimaryType(store: any, modelName: any, primaryModelClass: any): boolean;
+    /**
+      This method allows you to push a payload containing top-level
+      collections of records organized per type.
+  
+      ```js
+      {
+        "posts": [{
+          "id": "1",
+          "title": "Rails is omakase",
+          "author", "1",
+          "comments": [ "1" ]
+        }],
+        "comments": [{
+          "id": "1",
+          "body": "FIRST"
+        }],
+        "users": [{
+          "id": "1",
+          "name": "@d2h"
+        }]
+      }
+      ```
+  
+      It will first normalize the payload, so you can use this to push
+      in data streaming in from your server structured the same way
+      that fetches and saves are structured.
+  
+      @method pushPayload
+      @public
+      @param {Store} store
+      @param {Object} payload
+    */
+    pushPayload(store: Store, payload: Object): void;
+    /**
+      This method is used to convert each JSON root key in the payload
+      into a modelName that it can use to look up the appropriate model for
+      that part of the payload.
+  
+      For example, your server may send a model name that does not correspond with
+      the name of the model in your app. Let's take a look at an example model,
+      and an example payload:
+  
+      ```app/models/post.js
+      import Model from '@ember-data/model';
+  
+      export default class Post extends Model {}
+      ```
+  
+      ```javascript
+        {
+          "blog/post": {
+            "id": "1
+          }
+        }
+      ```
+  
+      Ember Data is going to normalize the payload's root key for the modelName. As a result,
+      it will try to look up the "blog/post" model. Since we don't have a model called "blog/post"
+      (or a file called app/models/blog/post.js in ember-cli), Ember Data will throw an error
+      because it cannot find the "blog/post" model.
+  
+      Since we want to remove this namespace, we can define a serializer for the application that will
+      remove "blog/" from the payload key whenver it's encountered by Ember Data:
+  
+      ```app/serializers/application.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        modelNameFromPayloadKey(payloadKey) {
+          if (payloadKey === 'blog/post') {
+            return super.modelNameFromPayloadKey(payloadKey.replace('blog/', ''));
+          } else {
+           return super.modelNameFromPayloadKey(payloadKey);
+          }
+        }
+      }
+      ```
+  
+      After refreshing, Ember Data will appropriately look up the "post" model.
+  
+      By default the modelName for a model is its
+      name in dasherized form. This means that a payload key like "blogPost" would be
+      normalized to "blog-post" when Ember Data looks up the model. Usually, Ember Data
+      can use the correct inflection to do this for you. Most of the time, you won't
+      need to override `modelNameFromPayloadKey` for this purpose.
+  
+      @method modelNameFromPayloadKey
+      @public
+      @param {String} key
+      @return {String} the model's modelName
+    */
+    modelNameFromPayloadKey(key: string): string;
+    /**
+      Called when a record is saved in order to convert the
+      record into JSON.
+  
+      By default, it creates a JSON object with a key for
+      each attribute and belongsTo relationship.
+  
+      For example, consider this model:
+  
+      ```app/models/comment.js
+      import Model, { attr, belongsTo } from '@ember-data/model';
+  
+      export default class Comment extends Model {
+        @attr title
+        @attr body
+  
+        @belongsTo('user') author
+      }
+      ```
+  
+      The default serialization would create a JSON object like:
+  
+      ```js
+      {
+        "title": "Rails is unagi",
+        "body": "Rails? Omakase? O_O",
+        "author": 12
+      }
+      ```
+  
+      By default, attributes are passed through as-is, unless
+      you specified an attribute type (`attr('date')`). If
+      you specify a transform, the JavaScript value will be
+      serialized when inserted into the JSON hash.
+  
+      By default, belongs-to relationships are converted into
+      IDs when inserted into the JSON hash.
+  
+      ## IDs
+  
+      `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`.
+  
+      ## Customization
+  
+      Your server may expect a different JSON format than the
+      built-in serialization format.
+  
+      In that case, you can implement `serialize` yourself and
+      return a JSON hash of your choosing.
+  
+      ```app/serializers/post.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        serialize(snapshot, options) {
+          let json = {
+            POST_TTL: snapshot.attr('title'),
+            POST_BDY: snapshot.attr('body'),
+            POST_CMS: snapshot.hasMany('comments', { ids: true })
+          };
+  
+          if (options.includeId) {
+            json.POST_ID_ = snapshot.id;
+          }
+  
+          return json;
+        }
+      }
+      ```
+  
+      ## Customizing an App-Wide Serializer
+  
+      If you want to define a serializer for your entire
+      application, you'll probably want to use `eachAttribute`
+      and `eachRelationship` on the record.
+  
+      ```app/serializers/application.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+      import { pluralize } from '<app-name>/utils/string-utils';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        serialize(snapshot, options) {
+          let json = {};
+  
+          snapshot.eachAttribute(function(name) {
+            json[serverAttributeName(name)] = snapshot.attr(name);
+          });
+  
+          snapshot.eachRelationship(function(name, relationship) {
+            if (relationship.kind === 'hasMany') {
+              json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+            }
+          });
+  
+          if (options.includeId) {
+            json.ID_ = snapshot.id;
+          }
+  
+          return json;
+        }
+      }
+  
+      function serverAttributeName(attribute) {
+        return attribute.underscore().toUpperCase();
+      }
+  
+      function serverHasManyName(name) {
+        return serverAttributeName(singularize(name)) + "_IDS";
+      }
+      ```
+  
+      This serializer will generate JSON that looks like this:
+  
+      ```js
+      {
+        "TITLE": "Rails is omakase",
+        "BODY": "Yep. Omakase.",
+        "COMMENT_IDS": [ 1, 2, 3 ]
+      }
+      ```
+  
+      ## Tweaking the Default JSON
+  
+      If you just want to do some small tweaks on the default JSON,
+      you can call super first and make the tweaks on the returned
+      JSON.
+  
+      ```app/serializers/post.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        serialize(snapshot, options) {
+          let json = super.serialize(snapshot, options);
+  
+          json.subject = json.title;
+          delete json.title;
+  
+          return json;
+        }
+      }
+      ```
+  
+      @method serialize
+      @public
+      @param {Snapshot} snapshot
+      @param {Object} options
+      @return {Object} json
+    */
+    serialize(snapshot: Snapshot, options: Object, ...args: any[]): Object;
+    /**
+      You can use this method to customize the root keys serialized into the JSON.
+      The hash property should be modified by reference (possibly using something like _.extend)
+      By default the REST Serializer sends the modelName of a model, which is a camelized
+      version of the name.
+  
+      For example, your server may expect underscored root objects.
+  
+      ```app/serializers/application.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+      import { decamelize } from '<app-name>/utils/string-utils';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        serializeIntoHash(data, type, record, options) {
+          let root = decamelize(type.modelName);
+          data[root] = this.serialize(record, options);
+        }
+      }
+      ```
+  
+      @method serializeIntoHash
+      @public
+      @param {Object} hash
+      @param {Model} typeClass
+      @param {Snapshot} snapshot
+      @param {Object} options
+    */
+    serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
+    /**
+      You can use `payloadKeyFromModelName` to override the root key for an outgoing
+      request. By default, the RESTSerializer returns a camelized version of the
+      model's name.
+  
+      For a model called TacoParty, its `modelName` would be the string `taco-party`. The RESTSerializer
+      will send it to the server with `tacoParty` as the root key in the JSON payload:
+  
+      ```js
+      {
+        "tacoParty": {
+          "id": "1",
+          "location": "Matthew Beale's House"
+        }
+      }
+      ```
+  
+      For example, your server may expect dasherized root objects:
+  
+      ```app/serializers/application.js
+      import RESTSerializer from '@ember-data/serializer/rest';
+      import { dasherize } from '<app-name>/utils/string-utils';
+  
+      export default class ApplicationSerializer extends RESTSerializer {
+        payloadKeyFromModelName(modelName) {
+          return dasherize(modelName);
+        }
+      }
+      ```
+  
+      Given a `TacoParty` model, calling `save` on it would produce an outgoing
+      request like:
+  
+      ```js
+      {
+        "taco-party": {
+          "id": "1",
+          "location": "Matthew Beale's House"
+        }
+      }
+      ```
+  
+      @method payloadKeyFromModelName
+      @public
+      @param {String} modelName
+      @return {String}
+    */
+    payloadKeyFromModelName(modelName: string): string;
+    /**
+      You can use this method to customize how polymorphic objects are serialized.
+      By default the REST Serializer creates the key by appending `Type` to
+      the attribute and value from the model's camelcased model name.
+  
+      @method serializePolymorphicType
+      @public
+      @param {Snapshot} snapshot
+      @param {Object} json
+      @param {Object} relationship
+    */
+    serializePolymorphicType(snapshot: Snapshot, json: Object, relationship: Object): void;
+    /**
+      You can use this method to customize how a polymorphic relationship should
+      be extracted.
+  
+      @method extractPolymorphicRelationship
+      @public
+      @param {Object} relationshipType
+      @param {Object} relationshipHash
+      @param {Object} relationshipOptions
+      @return {Object}
+     */
+    extractPolymorphicRelationship(relationshipType: Object, relationshipHash: Object, relationshipOptions: Object, ...args: any[]): Object;
+};
+//# sourceMappingURL=rest.d.ts.map

package/unstable-preview-types/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../src/rest.js"],"names":[],"mappings":";;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDE;AACF;;;;;;;;+JAsSE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IApUF;;;;;;;;;;;;;;;;;;;;;;;;;MAyBE;;IAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkEE;IAEF;;;;;;;;;;;MAWE;gEAJQ,MAAM,iBAEL,MAAM;;IA0CjB;;;;;;;;;;MAUE;wEANQ,MAAM,MACN,eAAa,2CAGZ,MAAM;;IAsIjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;uCADQ,MAAM;IA+BhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyDE;;IAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwJE;2CAFQ,MAAM,mBACL,MAAM;IAMjB;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;4BAJQ,MAAM,iDAGN,MAAM;IAOhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8CE;;IAKF;;;;;;;;;;MAUE;uDAFQ,MAAM,gBACN,MAAM;IAchB;;;;;;;;;;OAUG;qDAJO,MAAM,oBACN,MAAM,uBACN,MAAM,mBACL,MAAM;EAmChB"}

package/unstable-preview-types/transform.d.ts

@@ -0,0 +1,5 @@
+/**
+  @module @ember-data/serializer
+*/
+export { Transform as default, BooleanTransform, DateTransform, NumberTransform, StringTransform } from './-private';
+//# sourceMappingURL=transform.d.ts.map

package/unstable-preview-types/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA;;EAEE;AACF,OAAO,EAAE,SAAS,IAAI,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}