@ember-data/model 5.3.2 → 5.3.4

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

@@ -0,0 +1,174 @@
+declare module '@ember-data/model/-private/attr' {
+  import type { ArrayValue, ObjectValue, PrimitiveValue } from '@warp-drive/core-types/json/raw';
+  import type { TransformName } from '@warp-drive/core-types/symbols';
+  import type { DecoratorPropertyDescriptor } from '@ember-data/model/-private/util';
+  /**
+   * Options provided to the attr decorator are
+   * supplied to the associated transform. Any
+   * key-value pair is valid; however, it is highly
+   * recommended to only use statically defined values
+   * that could be serialized to JSON.
+   *
+   * If no transform is provided, the only valid
+   * option is `defaultValue`.
+   *
+   * Examples:
+   *
+   * ```ts
+   * class User extends Model {
+   *  @attr('string', { defaultValue: 'Anonymous' }) name;
+   *  @attr('date', { defaultValue: () => new Date() }) createdAt;
+   *  @attr({ defaultValue: () => ({}) }) preferences;
+   *  @attr('boolean') hasVerifiedEmail;
+   *  @attr address;
+   * }
+   *
+   * @class NOTATHING
+   * @typedoc
+   */
+  export type AttrOptions<DV = PrimitiveValue | object | unknown[]> = {
+      /**
+       * The default value for this attribute.
+       *
+       * Default values can be provided as a value or a function that will be
+       * executed to generate the default value.
+       *
+       * Default values *should not* be stateful (object, arrays, etc.) as
+       * they will be shared across all instances of the record.
+       *
+       * @typedoc
+       */
+      defaultValue?: DV extends PrimitiveValue ? DV : () => DV;
+  };
+  type LooseTransformInstance<V, Raw, Name extends string> = {
+      /**
+       * value type must match the return type of the deserialize method
+       *
+       * @typedoc
+       */
+      serialize: (value: V, options: any) => Raw;
+      /**
+       * defaultValue type must match the return type of the deserialize method
+       *
+       * @typedoc
+       */
+      deserialize: (value: Raw, options: any) => V;
+      [TransformName]: Name;
+  };
+  export type TransformHasType = {
+      [TransformName]: string;
+  };
+  export type TypedTransformInstance<V, T extends string> = LooseTransformInstance<V, string, T> | LooseTransformInstance<V, number, T> | LooseTransformInstance<V, boolean, T> | LooseTransformInstance<V, null, T> | LooseTransformInstance<V, ObjectValue, T> | LooseTransformInstance<V, ArrayValue, T>;
+  export type GetMaybeDeserializeValue<T> = T extends {
+      deserialize: (...args: any[]) => unknown;
+  } ? ReturnType<T['deserialize']> : never;
+  export type TypeFromInstance<T> = T extends TransformHasType ? T[typeof TransformName] : never;
+  export type OptionsFromInstance<T> = TypeFromInstance<T> extends never ? never : GetMaybeDeserializeValue<T> extends never ? never : T extends TypedTransformInstance<GetMaybeDeserializeValue<T>, TypeFromInstance<T>> ? Parameters<T['deserialize']>[1] & Parameters<T['serialize']>[1] & AttrOptions<ReturnType<T['deserialize']>> : never;
+  /**
+   * The return type of `void` is a lie to appease TypeScript. The actual return type
+   * is a descriptor, but typescript incorrectly insists that decorator functions return
+   * `void` or `any`.
+   *
+   * @typedoc
+   */
+  export type DataDecorator = (target: object, key: string, desc?: DecoratorPropertyDescriptor) => void;
+  /**
+    `attr` defines an attribute on a [Model](/ember-data/release/classes/Model).
+    By default, attributes are passed through as-is, however you can specify an
+    optional type to have the value automatically transformed.
+    EmberData ships with four basic transform types: `string`, `number`,
+    `boolean` and `date`. You can define your own transforms by subclassing
+    [Transform](/ember-data/release/classes/Transform).
+  
+    Note that you cannot use `attr` to define an attribute of `id`.
+  
+    `attr` takes an optional hash as a second parameter, currently
+    supported options are:
+  
+    - `defaultValue`: Pass a string or a function to be called to set the attribute
+    to a default value if and only if the key is absent from the payload response.
+  
+    Example
+  
+    ```app/models/user.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @attr('string') username;
+      @attr('string') email;
+      @attr('boolean', { defaultValue: false }) verified;
+    }
+    ```
+  
+    Default value can also be a function. This is useful it you want to return
+    a new object for each attribute.
+  
+    ```app/models/user.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @attr('string') username;
+      @attr('string') email;
+  
+      @attr({
+        defaultValue() {
+          return {};
+        }
+      })
+      settings;
+    }
+    ```
+  
+    The `options` hash is passed as second argument to a transforms'
+    `serialize` and `deserialize` method. This allows to configure a
+    transformation and adapt the corresponding value, based on the config:
+  
+    ```app/models/post.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class PostModel extends Model {
+      @attr('text', {
+        uppercase: true
+      })
+      text;
+    }
+    ```
+  
+    ```app/transforms/text.js
+    export default class TextTransform {
+      serialize(value, options) {
+        if (options.uppercase) {
+          return value.toUpperCase();
+        }
+  
+        return value;
+      }
+  
+      deserialize(value) {
+        return value;
+      }
+  
+      static create() {
+        return new this();
+      }
+    }
+    ```
+  
+    @method attr
+    @public
+    @static
+    @for @ember-data/model
+    @param {String|Object} type the attribute type
+    @param {Object} options a hash of options
+    @return {Attribute}
+  */
+  export function attr(): DataDecorator;
+  export function attr<T>(type: TypeFromInstance<T>): DataDecorator;
+  export function attr(type: string): DataDecorator;
+  export function attr(options: AttrOptions): DataDecorator;
+  export function attr<T>(type: TypeFromInstance<T>, options?: OptionsFromInstance<T>): DataDecorator;
+  export function attr(type: string, options?: AttrOptions & object): DataDecorator;
+  export function attr(target: object, key: string | symbol, desc?: PropertyDescriptor): void;
+  export {};
+}
+//# sourceMappingURL=attr.d.ts.map

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

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

package/unstable-preview-types/-private/attr.type-test.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember-data/model/-private/attr.type-test' {
+  export {};
+}
+//# sourceMappingURL=attr.type-test.d.ts.map

package/unstable-preview-types/-private/attr.type-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attr.type-test.d.ts","sourceRoot":"","sources":["../../src/-private/attr.type-test.ts"],"names":[],"mappings":""}

package/unstable-preview-types/-private/belongs-to.d.ts

@@ -0,0 +1,180 @@
+declare module '@ember-data/model/-private/belongs-to' {
+  import type { TypeFromInstance } from '@warp-drive/core-types/record';
+  /**
+    @module @ember-data/model
+  */
+  export type IsUnknown<T> = unknown extends T ? true : false;
+  export type RelationshipOptions<T, Async extends boolean> = {
+      async: Async;
+      inverse: null | (IsUnknown<T> extends true ? string : keyof NoNull<T> & string);
+      polymorphic?: boolean;
+      as?: string;
+      resetOnRemoteUpdate?: boolean;
+  };
+  export type NoNull<T> = Exclude<T, null>;
+  export type RelationshipDecorator<T> = <This>(target: This, key: string, desc?: PropertyDescriptor) => void;
+  /**
+    `belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
+    relationships on a [Model](/ember-data/release/classes/Model).
+  
+    `belongsTo` takes a configuration hash as a second parameter, currently
+    supported options are:
+  
+    - `async`: (*required*) A boolean value used to whether this is a sync (false) or async (true) relationship.
+    - `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+    - `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+    - `as`: (*optional*) A string used to the abstract type "this" record satisfies for polymorphism.
+  
+    ### Examples
+  
+    To a **one-to-many** (or many-to-many) relationship, use
+    `belongsTo` in combination with `hasMany`:
+  
+    ```js
+    // app/models/comment.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Comment extends Model {
+      @belongsTo('post', { async: false, inverse: 'comments' }) post;
+    }
+  
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('comment', { async: false, inverse: 'post' }) comments;
+    }
+    ```
+  
+    To a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:
+  
+    ```js
+    // app/models/author.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Author extends Model {
+      @belongsTo('address', { async: true, inverse: 'owner' }) address;
+    }
+  
+    // app/models/address.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Address extends Model {
+      @belongsTo('author', { async: true, inverse: 'address' }) owner;
+    }
+    ```
+  
+    To a **one-to-one** relationship without managed inverses, use `belongsTo` for both sides
+    with `null` as the inverse:
+  
+    ```js
+    // app/models/author.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Author extends Model {
+      @belongsTo('address', { async: true, inverse: null }) address;
+    }
+  
+    // app/models/address.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Address extends Model {
+      @belongsTo('author', { async: true, inverse: null }) owner;
+    }
+    ```
+  
+    To a one-to-none relationship between two models, use
+    `belongsTo` with inverse set to `null` on just one side::
+  
+    ```js
+    // app/models/person.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Person extends Model {
+      @belongsTo('person', { async: false, inverse: null }) bestFriend;
+    }
+    ```
+  
+    #### Sync vs Async Relationships
+  
+    EmberData fulfills relationships using resource data available in
+    the cache.
+  
+    Sync relationships point directly to the known related resources.
+  
+    When a relationship is declared as async, if any of the known related
+    resources have not been loaded, they will be fetched. The property
+    on the record when accessed provides a promise that resolves once
+    all resources are loaded.
+  
+    Async relationships may take advantage of links. On access, if the related
+    link has not been loaded, or if any known resources are not available in
+    the cache, the fresh state will be fetched using the link.
+  
+    In contrast to async relationship, accessing a sync relationship
+    will error on access when any of the known related resources have
+    not been loaded.
+  
+    If you are using `links` with sync relationships, you have to use
+    the BelongsTo reference API to fetch or refresh related resources
+    that aren't loaded. For instance, for a `bestFriend` relationship:
+  
+    ```js
+    person.belongsTo('bestFriend').reload();
+    ```
+  
+    #### Polymorphic Relationships
+  
+    To a polymorphic relationship, use `hasMany` with the `polymorphic`
+    option set to `true`:
+  
+    ```js
+    // app/models/comment.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Comment extends Model {
+      @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+    }
+    ```
+  
+    `'commentable'` here is referred to as the "abstract type" for the polymorphic
+    relationship.
+  
+    Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+    Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+    inverse relationships declaring itself as satisfying the abstract type.
+  
+    Below, 'as' is used to the that 'post' record satisfies the abstract type 'commentable'
+    for this relationship.
+  
+    ```js
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+    }
+    ```
+  
+    Note: every Model that declares an inverse to a polymorphic relationship must
+    itself exactly the same. This is because polymorphism is based on structural
+    traits.
+  
+    Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+    must be declared as polymorphic, and the `as` option must be used to the abstract
+    type each record satisfies on both sides.
+  
+    @method belongsTo
+    @public
+    @static
+    @for @ember-data/model
+    @param {string} type (optional) the name of the related resource
+    @param {object} options (optional) a hash of options
+    @return {PropertyDescriptor} relationship
+  */
+  export function belongsTo(): never;
+  export function belongsTo(type: string): never;
+  export function belongsTo<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
+  export function belongsTo(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;
+}
+//# sourceMappingURL=belongs-to.d.ts.map

package/unstable-preview-types/-private/belongs-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongs-to.d.ts","sourceRoot":"","sources":["../../src/-private/belongs-to.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAMtE;;EAEE;AAEF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,OAAO,SAAS,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAE5D,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,KAAK,SAAS,OAAO,IAAI;IAC1D,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;IAChF,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAQzC,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,kBAAkB,KAAK,IAAI,CAAC;AA+E5G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8JE;AAEF,wBAAgB,SAAS,IAAI,KAAK,CAAC;AACnC,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;AAC/C,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EACjC,OAAO,EAAE,mBAAmB,CAAC,CAAC,EAAE,OAAO,CAAC,GACvC,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAK5B,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC"}

package/unstable-preview-types/-private/belongs-to.type-test.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember-data/model/-private/belongs-to.type-test' {
+  export {};
+}
+//# sourceMappingURL=belongs-to.type-test.d.ts.map

package/unstable-preview-types/-private/belongs-to.type-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongs-to.type-test.d.ts","sourceRoot":"","sources":["../../src/-private/belongs-to.type-test.ts"],"names":[],"mappings":""}

package/unstable-preview-types/-private/debug/assert-polymorphic-type.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember-data/model/-private/debug/assert-polymorphic-type' {
+  import type { UpgradedMeta } from '@ember-data/graph/-private';
+  import type Store from '@ember-data/store';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: Store) => void;
+  export { assertPolymorphicType };
+}
+//# sourceMappingURL=assert-polymorphic-type.d.ts.map

package/unstable-preview-types/-private/debug/assert-polymorphic-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-polymorphic-type.d.ts","sourceRoot":"","sources":["../../../src/-private/debug/assert-polymorphic-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAG3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAcrE,QAAA,IAAI,qBAAqB,EAAE,CACzB,gBAAgB,EAAE,sBAAsB,EACxC,gBAAgB,EAAE,YAAY,EAC9B,eAAe,EAAE,sBAAsB,EACvC,KAAK,EAAE,KAAK,KACT,IAAI,CAAC;AA2BV,OAAO,EAAE,qBAAqB,EAAE,CAAC"}