@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.17

package/declarations/serializer/rest.d.ts

@@ -1,554 +1,54 @@
-export { EmbeddedRecordsMixin } from "./-private/embedded-records-mixin";
 /**
- * <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.
-
-  ```js [app/serializers/application.js]
-  import { RESTSerializer } from '@warp-drive/legacy/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
-  @public
+* <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.
+
+```js [app/serializers/application.js]
+import { RESTSerializer } from '@warp-drive/legacy/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
+@public
 */
-export const RESTSerializer: Readonly<Readonly<typeof import("../serializer.ts").Serializer> & (new (owner?: import("@ember/-internals/owner").default) => import("../serializer.ts").Serializer) & {
-    primaryKey: string;
-    mergedProperties: any;
-    applyTransforms(typeClass: Model, data: any): any;
-    normalizeResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
-    normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string): any;
-    normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string): any;
-    _normalizeResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, isSingle: boolean): any;
-    normalize(modelClass: any, resourceHash: any): any;
-    extractId(modelClass: any, resourceHash: any): string;
-    extractAttributes(modelClass: any, resourceHash: any): any;
-    extractRelationship(relationshipModelName: any, relationshipHash: any): any;
-    extractPolymorphicRelationship(relationshipModelName: any, relationshipHash: any, relationshipOptions: any): any;
-    extractRelationships(modelClass: any, resourceHash: any): any;
-    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: any): any;
-    serializeIntoHash(hash: any, typeClass: Model, snapshot: Snapshot, options: any): void;
-    serializeAttribute(snapshot: Snapshot, json: any, key: string, attribute: any): void;
-    serializeBelongsTo(snapshot: Snapshot, json: any, relationship: any): void;
-    serializeHasMany(snapshot: Snapshot, json: any, relationship: any): void;
-    serializePolymorphicType(): void;
-    extractMeta(store: Store, modelClass: Model, payload: any): any;
-    extractErrors(store: Store, typeClass: Model, payload: any, id: (string | number)): any;
-    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) => import("../serializer.ts").Serializer) & {
-    /**
-     `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
-  
-      ```js [app/serializers/post.js]
-      import { RESTSerializer } from '@warp-drive/legacy/serializer/rest';
-  
-      export default class ApplicationSerializer extends RESTSerializer {
-        keyForPolymorphicType(key, relationship) {
-          let relationshipKey = this.keyForRelationship(key);
-  
-          return 'type-' + relationshipKey;
-        }
-      }
-      ```
-  
-      @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:
-  
-      ```js [app/serializers/post.js]
-      import { RESTSerializer } from '@warp-drive/legacy/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`.
-  
-      @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 }`.
-  
-      @param {Store} store
-      @param {String} modelName
-      @param {Object} arrayHash
-      @param {String} prop
-      @return {Object}
-      @private
-    */
-    _normalizeArray(store: Store, modelName: string, arrayHash: any, prop: string): any;
-    _normalizePolymorphicRecord(store: any, hash: any, prop: any, primaryModelClass: any, primarySerializer: any): any;
-    /**
-      @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: any, id: string | number, requestType: string, isSingle: boolean): any;
-    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.
-  
-      @public
-      @param {Store} store
-      @param {Object} payload
-    */
-    pushPayload(store: Store, payload: any): 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:
-  
-      ```js [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:
-  
-      ```js [app/serializers/application.js]
-      import { RESTSerializer } from '@warp-drive/legacy/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.
-  
-      @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:
-  
-      ```js [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.
-  
-      ```js [app/serializers/post.js]
-      import { RESTSerializer } from '@warp-drive/legacy/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.
-  
-      ```js [app/serializers/application.js]
-      import { RESTSerializer } from '@warp-drive/legacy/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.
-  
-      ```js [app/serializers/post.js]
-      import { RESTSerializer } from '@warp-drive/legacy/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;
-        }
-      }
-      ```
-  
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} options
-      @return {Object} json
-    */
-    serialize(snapshot: Snapshot, options: any, ...args: any[]): any;
-    /**
-      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.
-  
-      ```js [app/serializers/application.js]
-      import { RESTSerializer } from '@warp-drive/legacy/serializer/rest';
-      import { underscore } from '<app-name>/utils/string-utils';
-  
-      export default class ApplicationSerializer extends RESTSerializer {
-        serializeIntoHash(data, type, record, options) {
-          let root = underscore(type.modelName);
-          data[root] = this.serialize(record, options);
-        }
-      }
-      ```
-  
-      @public
-      @param {Object} hash
-      @param {Model} typeClass
-      @param {Snapshot} snapshot
-      @param {Object} options
-    */
-    serializeIntoHash(hash: any, typeClass: Model, snapshot: Snapshot, options: any): 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:
-  
-      ```js [app/serializers/application.js]
-      import { RESTSerializer } from '@warp-drive/legacy/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"
-        }
-      }
-      ```
-  
-      @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.
-  
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} json
-      @param {Object} relationship
-    */
-    serializePolymorphicType(snapshot: Snapshot, json: any, relationship: any): void;
-    /**
-      You can use this method to customize how a polymorphic relationship should
-      be extracted.
-  
-      @public
-      @param {Object} relationshipType
-      @param {Object} relationshipHash
-      @param {Object} relationshipOptions
-      @return {Object}
-     */
-    extractPolymorphicRelationship(relationshipType: any, relationshipHash: any, relationshipOptions: any, ...args: any[]): any;
-};
-//# sourceMappingURL=rest.d.ts.map
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare const RESTSerializer: any;
+export { EmbeddedRecordsMixin } from "./-private/embedded-records-mixin.js";
+export { RESTSerializer };

package/declarations/serializer/transform.d.ts

@@ -1,6 +1,5 @@
-export { Transform } from './-private/transforms/transform.ts';
-export { BooleanTransform } from './-private/transforms/boolean.ts';
-export { DateTransform } from './-private/transforms/date.ts';
-export { NumberTransform } from './-private/transforms/number.ts';
-export { StringTransform } from './-private/transforms/string.ts';
-//# sourceMappingURL=transform.d.ts.map
+export { Transform } from "./-private/transforms/transform.js";
+export { BooleanTransform } from "./-private/transforms/boolean.js";
+export { DateTransform } from "./-private/transforms/date.js";
+export { NumberTransform } from "./-private/transforms/number.js";
+export { StringTransform } from "./-private/transforms/string.js";