@ember-data/serializer 5.4.0-beta.3 → 5.4.0-beta.5

package/unstable-preview-types/-private/transforms/number.d.ts

@@ -0,0 +1,34 @@
+declare module '@ember-data/serializer/-private/transforms/number' {
+  /**
+    @module @ember-data/serializer
+  */
+  import { TransformName } from '@warp-drive/core-types/symbols';
+  /**
+    The `NumberTransform` class is used to serialize and deserialize
+    numeric attributes on Ember Data record objects. This transform is
+    used when `number` is passed as the type parameter to the
+    [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+  
+    Usage
+  
+    ```app/models/score.js
+    import Model, { attr, belongsTo } from '@ember-data/model';
+  
+    export default class ScoreModel extends Model {
+      @attr('number') value;
+      @belongsTo('player') player;
+      @attr('date') date;
+    }
+    ```
+  
+    @class NumberTransform
+    @public
+   */
+  export class NumberTransform {
+      deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+      serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+      [TransformName]: "number";
+      static create(): NumberTransform;
+  }
+}
+//# sourceMappingURL=number.d.ts.map

package/unstable-preview-types/-private/transforms/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/number.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAC1B,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAU9G,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAU9G,CAAC,aAAa,CAAC,WAAqB;IAEpC,MAAM,CAAC,MAAM;CAGd"}

package/unstable-preview-types/-private/transforms/string.d.ts

@@ -0,0 +1,34 @@
+declare module '@ember-data/serializer/-private/transforms/string' {
+  /**
+    @module @ember-data/serializer
+  */
+  import { TransformName } from '@warp-drive/core-types/symbols';
+  /**
+    The `StringTransform` class is used to serialize and deserialize
+    string attributes on Ember Data record objects. This transform is
+    used when `string` is passed as the type parameter to the
+    [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+  
+    Usage
+  
+    ```app/models/user.js
+    import Model, { attr, belongsTo } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @attr('boolean') isAdmin;
+      @attr('string') name;
+      @attr('string') email;
+    }
+    ```
+  
+    @class StringTransform
+    @public
+   */
+  export class StringTransform {
+      deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
+      serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
+      [TransformName]: "string";
+      static create(): StringTransform;
+  }
+}
+//# sourceMappingURL=string.d.ts.map

package/unstable-preview-types/-private/transforms/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/string.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAC1B,WAAW,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAGnF,SAAS,CAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAInF,CAAC,aAAa,CAAC,WAAqB;IAEpC,MAAM,CAAC,MAAM;CAGd"}

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

@@ -0,0 +1,127 @@
+declare module '@ember-data/serializer/-private/transforms/transform' {
+  /// <reference types="ember-source/types" />
+  /**
+    @module @ember-data/serializer
+  */
+  import EmberObject from '@ember/object';
+  import type { LegacyAttributeField } from '@warp-drive/core-types/schema/fields';
+  /**
+    The `Transform` class is used to serialize and deserialize model
+    attributes when they are saved or loaded from an
+    adapter. Subclassing `Transform` is useful for creating custom
+    attributes. All subclasses of `Transform` must implement a
+    `serialize` and a `deserialize` method.
+  
+    Example
+  
+    ```app/transforms/temperature.js
+  
+    // Converts centigrade in the JSON to fahrenheit in the app
+    export default class TemperatureTransform {
+      deserialize(serialized, options) {
+        return (serialized *  1.8) + 32;
+      }
+  
+      serialize(deserialized, options) {
+        return (deserialized - 32) / 1.8;
+      }
+  
+      static create() {
+        return new this();
+      }
+    }
+    ```
+  
+    Usage
+  
+    ```app/models/requirement.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class RequirementModel extends Model {
+      @attr('string') name;
+      @attr('temperature') temperature;
+    }
+    ```
+  
+    The options passed into the `attr` function when the attribute is
+    declared on the model is also available in the transform.
+  
+    ```app/models/post.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class PostModel extends Model {
+      @attr('string') title;
+      @attr('markdown', {
+        markdown: {
+          gfm: false,
+          sanitize: true
+        }
+      })
+      markdown;
+    }
+    ```
+  
+    ```app/transforms/markdown.js
+    export default class MarkdownTransform {
+      serialize(deserialized, options) {
+        return deserialized.raw;
+      }
+  
+      deserialize(serialized, options) {
+        let markdownOptions = options.markdown || {};
+  
+        return marked(serialized, markdownOptions);
+      }
+  
+      static create() {
+        return new this();
+      }
+    }
+    ```
+  
+    @class Transform
+    @public
+   */
+  /**
+    When given a deserialized value from a record attribute this
+    method must return the serialized value.
+  
+    Example
+  
+    ```javascript
+    serialize(deserialized, options) {
+      return deserialized ? null : Number(deserialized);
+    }
+    ```
+  
+    @method serialize
+    @public
+    @param deserialized The deserialized value
+    @param options hash of options passed to `attr`
+    @return The serialized value
+  */
+  /**
+    When given a serialized value from a JSON object this method must
+    return the deserialized value for the record attribute.
+  
+    Example
+  
+    ```javascript
+    deserialize(serialized, options) {
+      return empty(serialized) ? null : Number(serialized);
+    }
+    ```
+  
+    @method deserialize
+    @public
+    @param serialized The serialized value
+    @param options hash of options passed to `attr`
+    @return The deserialized value
+  */
+  export interface Transform {
+      serialize(value: unknown, options: LegacyAttributeField['options']): unknown;
+      deserialize(value: unknown, options: LegacyAttributeField['options']): unknown;
+  }
+  export const Transform: typeof EmberObject;
+}
+//# sourceMappingURL=transform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/transform.ts"],"names":[],"mappings":";AAAA;;EAEE;AACF,OAAO,WAAW,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH;;;;;;;;;;;;;;;;;EAiBE;AACF;;;;;;;;;;;;;;;;;EAiBE;AACF,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;IAC7E,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;CAChF;AACD,eAAO,MAAM,SAAS,oBAAc,CAAC"}

package/unstable-preview-types/-private/utils.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember-data/serializer/-private/utils' {
+  type Coercable = string | number | boolean | null | undefined | symbol;
+  export function coerceId(id: Coercable): string | null;
+  export {};
+}
+//# sourceMappingURL=utils.d.ts.map

package/unstable-preview-types/-private/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/-private/utils.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;AAEvE,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAUrD"}

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

@@ -0,0 +1,277 @@
+/// <reference path="./rest.d.ts" />
+/// <reference path="./json.d.ts" />
+/// <reference path="./transform.d.ts" />
+/// <reference path="./json-api.d.ts" />
+/// <reference path="./-private/utils.d.ts" />
+/// <reference path="./-private/embedded-records-mixin.d.ts" />
+/// <reference path="./-private/transforms/date.d.ts" />
+/// <reference path="./-private/transforms/boolean.d.ts" />
+/// <reference path="./-private/transforms/transform.d.ts" />
+/// <reference path="./-private/transforms/number.d.ts" />
+/// <reference path="./-private/transforms/string.d.ts" />
+declare module '@ember-data/serializer' {
+  /**
+    ## Overview
+  
+    <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 serializer, 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>
+  
+    In order to properly manage and present your data, EmberData
+    needs to understand the structure of data it receives.
+  
+    `Serializers` convert data between the server's API format and
+    the format EmberData understands.
+  
+    Data received from an API response is **normalized** into
+    [JSON:API](https://jsonapi.org/) (the format used internally
+    by EmberData), while data sent to an API is **serialized**
+    into the format the API expects.
+  
+    ### Implementing a Serializer
+  
+    There are only two required serializer methods, one for
+    normalizing data from the server API format into JSON:API, and
+    another for serializing records via `Snapshots` into the expected
+    server API format.
+  
+    To implement a serializer, export a class that conforms to the structure
+    described by [<Interface> Serializer](/ember-data/release/classes/%3CInterface%3E%20Serializer)
+    from the `app/serializers/` directory. An example is below.
+  
+    ```ts
+    import EmberObject from '@ember/object';
+  
+    export default class ApplicationSerializer extends EmberObject {
+      normalizeResponse(store, schema, rawPayload) {
+        return rawPayload;
+      }
+  
+      serialize(snapshot, options) {
+        const serializedResource = {
+          id: snapshot.id,
+          type: snapshot.modelName,
+          attributes: snapshot.attributes()
+        };
+  
+        return serializedResource;
+      }
+    }
+   ```
+  
+  
+    ### Serializer Resolution
+  
+    `store.serializerFor(name)` will lookup serializers defined in
+    `app/serializers/` and return an instance. If no serializer is found, an
+    error will be thrown.
+  
+    `serializerFor` first attempts to find a serializer with an exact match on `name`,
+    then falls back to checking for the presence of a serializer named `application`.
+  
+    ```ts
+    store.serializerFor('author');
+  
+    // lookup paths (in order) =>
+    //   app/serializers/author.js
+    //   app/serializers/application.js
+    ```
+  
+    Most requests in EmberData are made with respect to a particular `type` (or `modelName`)
+    (e.g., "get me the full collection of **books**" or "get me the **employee** whose id is 37"). We
+    refer to this as the **primary** resource `type`.
+  
+    Typically `serializerFor` will be used to find a serializer with a name matching that of the primary
+    resource `type` for the request, falling back to the `application` serializer for those types that
+    do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy
+    for defining serializers. However, because APIs rarely format payloads per-type but rather
+    per-API-version, this may not be a desired strategy.
+  
+    It is recommended that applications define only a single `application` adapter and serializer
+    where possible.
+  
+    If you have multiple API formats and the per-type strategy is not viable, one strategy is to
+    write an `application` adapter and serializer that make use of `options` to specify the desired
+    format when making a request.
+  
+    ### Using a Serializer
+  
+    Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.
+  
+    ### Default Serializers
+  
+    For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**
+    format the `@ember-data/serializer` package contains implementations these applications can
+    extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.
+  
+    Many applications will find writing their own serializer to be more performant and less
+    complex than extending these classes even when their API format is very close to that expected
+    by these serializers.
+  
+    It is recommended that apps write their own serializer to best suit the needs of their API and
+    application.
+  
+    @module @ember-data/serializer
+    @main @ember-data/serializer
+  */
+  /// <reference types="ember-source/types" />
+  import EmberObject from '@ember/object';
+  import type Store from '@ember-data/store';
+  import type { ModelSchema } from '@ember-data/store/types';
+  import type { EmptyResourceDocument, SingleResourceDocument } from '@warp-drive/core-types/spec/json-api-raw';
+  /**
+    > ⚠️ CAUTION you likely want the docs for [<Interface> Serializer](/ember-data/release/classes/%3CInterface%3E%20Serializer)
+    > as extending this abstract class is unnecessary.
+  
+    `Serializer` is an abstract base class that you may override in your
+    application to customize it for your backend. The minimum set of methods
+    that you should implement is:
+  
+      * `normalizeResponse()`
+      * `serialize()`
+  
+    And you can optionally override the following methods:
+  
+      * `normalize()`
+  
+    For an example implementation, see
+    [JSONSerializer](JSONSerializer), the included JSON serializer.
+  
+    @class Serializer
+    @public
+    @extends Ember.EmberObject
+  */
+  export default class extends EmberObject {
+      store: Store;
+      /**
+        The `store` property is the application's `store` that contains
+        all records. It can be used to look up serializers for other model
+        types that may be nested inside the payload response.
+    
+        Example:
+    
+        ```js
+        Serializer.extend({
+          extractRelationship(relationshipModelName, relationshipHash) {
+            let modelClass = this.store.modelFor(relationshipModelName);
+            let relationshipSerializer = this.store.serializerFor(relationshipModelName);
+            return relationshipSerializer.normalize(modelClass, relationshipHash);
+          }
+        });
+        ```
+    
+        @property store
+        @type {Store}
+        @public
+      */
+      /**
+        The `normalizeResponse` method is used to normalize a payload from the
+        server to a JSON-API Document.
+    
+        http://jsonapi.org/format/#document-structure
+    
+        Example:
+    
+        ```js
+        Serializer.extend({
+          normalizeResponse(store, primaryModelClass, payload, id, requestType) {
+            if (requestType === 'findRecord') {
+              return this.normalize(primaryModelClass, payload);
+            } else {
+              return payload.reduce(function(documentHash, item) {
+                let { data, included } = this.normalize(primaryModelClass, item);
+                documentHash.included.push(...included);
+                documentHash.data.push(data);
+                return documentHash;
+              }, { data: [], included: [] })
+            }
+          }
+        });
+        ```
+    
+        @since 1.13.0
+        @method normalizeResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      /**
+        The `serialize` method is used when a record is saved in order to convert
+        the record into the form that your external data source expects.
+    
+        `serialize` takes an optional `options` hash with a single option:
+    
+        - `includeId`: If this is `true`, `serialize` should include the ID
+          in the serialized object it builds.
+    
+        Example:
+    
+        ```js
+        Serializer.extend({
+          serialize(snapshot, options) {
+            let json = {
+              id: snapshot.id
+            };
+    
+            snapshot.eachAttribute((key, attribute) => {
+              json[key] = snapshot.attr(key);
+            });
+    
+            snapshot.eachRelationship((key, relationship) => {
+              if (relationship.kind === 'belongsTo') {
+                json[key] = snapshot.belongsTo(key, { id: true });
+              } else if (relationship.kind === 'hasMany') {
+                json[key] = snapshot.hasMany(key, { ids: true });
+              }
+            });
+    
+            return json;
+          },
+        });
+        ```
+    
+        @method serialize
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} [options]
+        @return {Object}
+      */
+      /**
+        The `normalize` method is used to convert a payload received from your
+        external data source into the normalized form `store.push()` expects. You
+        should override this method, munge the hash and return the normalized
+        payload.
+    
+        Example:
+    
+        ```js
+        Serializer.extend({
+          normalize(modelClass, resourceHash) {
+            let data = {
+              id:            resourceHash.id,
+              type:          modelClass.modelName,
+              attributes:    resourceHash
+            };
+            return { data: data };
+          }
+        })
+        ```
+    
+        @method normalize
+        @public
+        @param {Model} typeClass
+        @param {Object} hash
+        @return {Object}
+      */
+      normalize(_typeClass: ModelSchema, hash: Record<string, unknown>): SingleResourceDocument | EmptyResourceDocument;
+  }
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2GE;;AAEF,OAAO,WAAW,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAE9G;;;;;;;;;;;;;;;;;;;;;EAqBE;AAEF,MAAM,CAAC,OAAO,MAAO,SAAQ,WAAW;IACrB,KAAK,EAAE,KAAK,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;;MAoBE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkCE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwCE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;IACF,SAAS,CAAC,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,sBAAsB,GAAG,qBAAqB;CAGlH"}