@ember-data/serializer 5.4.0-beta.0 → 5.4.0-beta.10

package/unstable-preview-types/-private/embedded-records-mixin.d.ts

@@ -0,0 +1,103 @@
+declare module '@ember-data/serializer/-private/embedded-records-mixin' {
+  /// <reference types="ember-source/types" />
+  /**
+    @module @ember-data/serializer/rest
+  */
+  /**
+    ## Using Embedded Records
+  
+    `EmbeddedRecordsMixin` supports serializing embedded records.
+  
+    To set up embedded records, include the mixin when extending a serializer,
+    then define and configure embedded (model) relationships.
+  
+    Note that embedded records will serialize with the serializer for their model instead of the serializer in which they are defined.
+  
+    Note also that this mixin does not work with JSONAPISerializer because the JSON:API specification does not describe how to format embedded resources.
+  
+    Below is an example of a per-type serializer (`post` type).
+  
+    ```app/serializers/post.js
+    import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';
+  
+    export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {
+      attrs = {
+        author: { embedded: 'always' },
+        comments: { serialize: 'ids' }
+      }
+    }
+    ```
+    Note that this use of `{ embedded: 'always' }` is unrelated to
+    the `{ embedded: 'always' }` that is defined as an option on `attr` as part of
+    defining a model while working with the `ActiveModelSerializer`.  Nevertheless,
+    using `{ embedded: 'always' }` as an option to `attr` is not a valid way to set up
+    embedded records.
+  
+    The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
+  
+    ```js
+    {
+      serialize: 'records',
+      deserialize: 'records'
+    }
+    ```
+  
+    ### Configuring Attrs
+  
+    A resource's `attrs` option may be set to use `ids`, `records` or false for the
+    `serialize`  and `deserialize` settings.
+  
+    The `attrs` property can be set on the `ApplicationSerializer` or a per-type
+    serializer.
+  
+    In the case where embedded JSON is expected while extracting a payload (reading)
+    the setting is `deserialize: 'records'`, there is no need to use `ids` when
+    extracting as that is the default behaviour without this mixin if you are using
+    the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while
+    serializing `serialize: 'records'` is the setting to use. There is an option of
+    not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
+    do not want the relationship sent at all, you can use `serialize: false`.
+  
+  
+    ### EmbeddedRecordsMixin defaults
+    If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
+    will behave in the following way:
+  
+    BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
+    HasMany:   `{ serialize: false, deserialize: 'ids' }`
+  
+    ### Model Relationships
+  
+    Embedded records must have a model defined to be extracted and serialized. Note that
+    when defining any relationships on your model such as `belongsTo` and `hasMany`, you
+    should not both specify `async: true` and also indicate through the serializer's
+    `attrs` attribute that the related model should be embedded for deserialization.
+    If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),
+    then do not use `async: true`.
+  
+    To successfully extract and serialize embedded records the model relationships
+    must be set up correctly. See the
+    [defining relationships](https://guides.emberjs.com/current/models/relationships)
+    section of the **Defining Models** guide page.
+  
+    Records without an `id` property are not considered embedded records, model
+    instances must have an `id` property to be used with Ember Data.
+  
+    ### Example JSON payloads, Models and Serializers
+  
+    **When customizing a serializer it is important to grok what the customizations
+    are. Please read the docs for the methods this mixin provides, in case you need
+    to modify it to fit your specific needs.**
+  
+    For example, review the docs for each method of this mixin:
+    * [normalize](/ember-data/release/classes/EmbeddedRecordsMixin/methods/normalize?anchor=normalize)
+    * [serializeBelongsTo](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeBelongsTo?anchor=serializeBelongsTo)
+    * [serializeHasMany](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeHasMany?anchor=serializeHasMany)
+  
+    @class EmbeddedRecordsMixin
+    @public
+  */
+  export const EmbeddedRecordsMixin: Mixin;
+  import Mixin from '@ember/object/mixin';
+}
+//# sourceMappingURL=embedded-records-mixin.d.ts.map

package/unstable-preview-types/-private/embedded-records-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-records-mixin.d.ts","sourceRoot":"","sources":["../../src/-private/embedded-records-mixin.js"],"names":[],"mappings":";AAKA;;EAEE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6FE;AACF,yCAwhBG;kBA9nBe,qBAAqB"}

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

@@ -0,0 +1,52 @@
+declare module '@ember-data/serializer/-private/transforms/boolean' {
+  /**
+    @module @ember-data/serializer
+  */
+  import { TransformName } from '@warp-drive/core-types/symbols';
+  /**
+    The `BooleanTransform` class is used to serialize and deserialize
+    boolean attributes on Ember Data record objects. This transform is
+    used when `boolean` 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 } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @attr('boolean') isAdmin;
+      @attr('string') name;
+      @attr('string') email;
+    }
+    ```
+  
+    By default, the boolean transform only allows for values of `true` or
+    `false`. You can opt into allowing `null` values for
+    boolean attributes via `attr('boolean', { allowNull: true })`
+  
+    ```app/models/user.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @attr('string') email;
+      @attr('string') username;
+      @attr('boolean', { allowNull: true }) wantsWeeklyEmail;
+    }
+    ```
+  
+    @class BooleanTransform
+    @public
+   */
+  export class BooleanTransform {
+      deserialize(serialized: boolean | null | number | string, options?: {
+          allowNull?: boolean;
+      }): boolean | null;
+      serialize(deserialized: boolean | null, options?: {
+          allowNull?: boolean;
+      }): boolean | null;
+      [TransformName]: "boolean";
+      static create(): BooleanTransform;
+  }
+}
+//# sourceMappingURL=boolean.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/boolean.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,gBAAgB;IAC3B,WAAW,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,GAAG,IAAI;IAgB5G,SAAS,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,GAAG,IAAI;IAQ1F,CAAC,aAAa,CAAC,YAAsB;IAErC,MAAM,CAAC,MAAM;CAGd"}

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

@@ -0,0 +1,33 @@
+declare module '@ember-data/serializer/-private/transforms/date' {
+  /**
+    @module @ember-data/serializer
+  */
+  import { TransformName } from '@warp-drive/core-types/symbols';
+  /**
+   The `DateTransform` class is used to serialize and deserialize
+   date attributes on Ember Data record objects. This transform is used
+   when `date` is passed as the type parameter to the
+   [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
+   standard.
+  
+   ```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 DateTransform
+    @public
+   */
+  export class DateTransform {
+      deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
+      serialize(date: Date, _options?: Record<string, unknown>): string | null;
+      [TransformName]: "date";
+      static create(): DateTransform;
+  }
+}
+//# sourceMappingURL=date.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/date.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qBAAa,aAAa;IACxB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAoBlF,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IASxE,CAAC,aAAa,CAAC,SAAmB;IAElC,MAAM,CAAC,MAAM;CAGd"}

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"}