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

package/declarations/model/-private/attr.d.ts

@@ -1,158 +1,178 @@
-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 './util.ts';
+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 "./util.js";
 /**
- * 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
- */
+* 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
+*/
 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.
-     *
-     */
-    defaultValue?: DV extends PrimitiveValue ? DV : () => DV;
+	/**
+	* 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.
+	*
+	*/
+	defaultValue?: DV extends PrimitiveValue ? DV : () => DV;
 };
-type LooseTransformInstance<V, Raw, Name extends string> = {
-    /**
-     * value type must match the return type of the deserialize method
-     *
-     */
-    serialize: (value: V, options: any) => Raw;
-    /**
-     * defaultValue type must match the return type of the deserialize method
-     *
-     */
-    deserialize: (value: Raw, options: any) => V;
-    [TransformName]: Name;
+// NOTE: Usage of Explicit ANY
+// -------------------------------------------------------------------
+// any is required here because we are the maximal not the minimal
+// subset of options allowed. If we used unknown, object, or
+// Record<string, unknown> we would get type errors when we try to
+// assert against a more specific implementation with precise options.
+// -------------------------------------------------------------------
+type LooseTransformInstance<
+	V,
+	Raw,
+	Name extends string
+> = {
+	/**
+	* value type must match the return type of the deserialize method
+	*
+	*/
+	// see note on Explicit ANY above
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	serialize: (value: V, options: any) => Raw;
+	/**
+	* defaultValue type must match the return type of the deserialize method
+	*
+	*/
+	// see note on Explicit ANY above
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	deserialize: (value: Raw, options: any) => V;
+	[TransformName]: Name;
 };
 export type TransformHasType = {
-    [TransformName]: string;
+	[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> | LooseTransformInstance<V, string | null, T> | LooseTransformInstance<V, number | null, T> | LooseTransformInstance<V, boolean | null, T> | LooseTransformInstance<V, ObjectValue | null, T> | LooseTransformInstance<V, ArrayValue | null, T>;
+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> | LooseTransformInstance<V, string | null, T> | LooseTransformInstance<V, number | null, T> | LooseTransformInstance<V, boolean | null, T> | LooseTransformInstance<V, ObjectValue | null, T> | LooseTransformInstance<V, ArrayValue | null, T>;
+// see note on Explicit ANY above
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type GetMaybeDeserializeValue<T> = T extends {
-    deserialize: (...args: any[]) => unknown;
-} ? ReturnType<T['deserialize']> : never;
+	deserialize: (...args: any[]) => unknown;
+} ? ReturnType<T["deserialize"]> : never;
 export type TypeFromInstance<T> = T extends TransformHasType ? T[typeof TransformName] : never;
-export type ExtractOptions<T extends TypedTransformInstance<GetMaybeDeserializeValue<T>, TypeFromInstance<T>>> = Parameters<T['deserialize']>[1] & Parameters<T['serialize']>[1] & AttrOptions<ReturnType<T['deserialize']>>;
-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;
+export type ExtractOptions<T extends TypedTransformInstance<GetMaybeDeserializeValue<T>, TypeFromInstance<T>>> = Parameters<T["deserialize"]>[1] & Parameters<T["serialize"]>[1] & AttrOptions<ReturnType<T["deserialize"]>>;
+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`.
- *
- */
+* 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`.
+*
+*/
 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
-
-  ```js [app/models/user.js]
-  import { Model, attr } from '@warp-drive/legacy/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.
-
-  ```js [app/models/user.js]
-  import { Model, attr } from '@warp-drive/legacy/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:
-
-  ```js [app/models/post.js]
-  import { Model, attr } from '@warp-drive/legacy/model';
-
-  export default class PostModel extends Model {
-    @attr('text', {
-      uppercase: true
-    })
-    text;
-  }
-  ```
-
-  ```js [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();
-    }
-  }
-  ```
-
-  @public
-  @param {String|Object} type the attribute type
-  @param {Object} options a hash of options
-  @return {Attribute}
+`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
+
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/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.
+
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/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:
+
+```js [app/models/post.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class PostModel extends Model {
+@attr('text', {
+uppercase: true
+})
+text;
+}
+```
+
+```js [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();
+}
+}
+```
+
+@public
+@param {String|Object} type the attribute type
+@param {Object} options a hash of options
+@return {Attribute}
 */
 export declare function attr(): DataDecorator;
 export declare function attr<T>(type: TypeFromInstance<T>): DataDecorator;
@@ -162,4 +182,3 @@ export declare function attr<T>(type: TypeFromInstance<T>, options?: OptionsFrom
 export declare function attr(type: string, options?: AttrOptions & object): DataDecorator;
 export declare function attr(target: object, key: string | symbol, desc?: PropertyDescriptor): void;
 export {};
-//# sourceMappingURL=attr.d.ts.map

package/declarations/model/-private/belongs-to.d.ts

@@ -1,173 +1,186 @@
-import type { TypeFromInstance } from '@warp-drive/core/types/record';
+import type { TypeFromInstance } from "@warp-drive/core/types/record";
 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;
-    linksMode?: true;
-    resetOnRemoteUpdate?: boolean;
+export type RelationshipOptions<
+	T,
+	Async extends boolean
+> = {
+	async: Async;
+	inverse: null | (IsUnknown<T> extends true ? string : keyof NoNull<T> & string);
+	polymorphic?: boolean;
+	as?: string;
+	linksMode?: true;
+	resetOnRemoteUpdate?: boolean;
 };
 export type NoNull<T> = Exclude<T, null>;
+// type BelongsToDecoratorObject<getT> = {
+//   get: () => getT;
+//   // set: (value: Awaited<getT>) => void;
+//   set: (value: getT) => void;
+//   // init: () => getT;
+// };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 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` 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:
+`belongsTo` takes a configuration hash as a second parameter, currently
+supported options are:
 
-  - `async`: (*required*) A boolean value used to declare 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 declare the abstract type "this" record satisfies for polymorphism.
+- `async`: (*required*) A boolean value used to declare 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 declare the abstract type "this" record satisfies for polymorphism.
 
-  ### Examples
+### Examples
 
-  To declare a **one-to-many** (or many-to-many) relationship, use
-  `belongsTo` in combination with `hasMany`:
+To declare a **one-to-many** (or many-to-many) relationship, use
+`belongsTo` in combination with `hasMany`:
 
-  ```js
-  // app/models/comment.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Comment extends Model {
-    @belongsTo('post', { async: false, inverse: 'comments' }) post;
-  }
+export default class Comment extends Model {
+@belongsTo('post', { async: false, inverse: 'comments' }) post;
+}
 
-  // app/models/post.js
-  import { Model, hasMany } from '@warp-drive/legacy/model';
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('comment', { async: false, inverse: 'post' }) comments;
-  }
-  ```
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'post' }) comments;
+}
+```
 
-  To declare a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:
+To declare a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:
 
-  ```js
-  // app/models/author.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+```js
+// app/models/author.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Author extends Model {
-    @belongsTo('address', { async: true, inverse: 'owner' }) address;
-  }
+export default class Author extends Model {
+@belongsTo('address', { async: true, inverse: 'owner' }) address;
+}
 
-  // app/models/address.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+// app/models/address.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Address extends Model {
-    @belongsTo('author', { async: true, inverse: 'address' }) owner;
-  }
-  ```
+export default class Address extends Model {
+@belongsTo('author', { async: true, inverse: 'address' }) owner;
+}
+```
 
-  To declare a **one-to-one** relationship without managed inverses, use `belongsTo` for both sides
-  with `null` as the inverse:
+To declare 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 '@warp-drive/legacy/model';
+```js
+// app/models/author.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Author extends Model {
-    @belongsTo('address', { async: true, inverse: null }) address;
-  }
+export default class Author extends Model {
+@belongsTo('address', { async: true, inverse: null }) address;
+}
 
-  // app/models/address.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+// app/models/address.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Address extends Model {
-    @belongsTo('author', { async: true, inverse: null }) owner;
-  }
-  ```
+export default class Address extends Model {
+@belongsTo('author', { async: true, inverse: null }) owner;
+}
+```
 
-  To declare a one-to-none relationship between two models, use
-  `belongsTo` with inverse set to `null` on just one side::
+To declare 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 '@warp-drive/legacy/model';
+```js
+// app/models/person.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Person extends Model {
-    @belongsTo('person', { async: false, inverse: null }) bestFriend;
-  }
-  ```
+export default class Person extends Model {
+@belongsTo('person', { async: false, inverse: null }) bestFriend;
+}
+```
 
-  #### Sync vs Async Relationships
+#### Sync vs Async Relationships
 
-  EmberData fulfills relationships using resource data available in
-  the cache.
+EmberData fulfills relationships using resource data available in
+the cache.
 
-  Sync relationships point directly to the known related resources.
+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.
+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.
+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.
+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:
+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();
-  ```
+```js
+person.belongsTo('bestFriend').reload();
+```
 
-  #### Polymorphic Relationships
+#### Polymorphic Relationships
 
-  To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
-  option set to `true`:
+To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+option set to `true`:
 
-  ```js
-  // app/models/comment.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Comment extends Model {
-    @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
-  }
-  ```
+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.
+`'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.
+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 declare the that 'post' record satisfies the abstract type 'commentable'
-  for this relationship.
+Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
+for this relationship.
 
-  ```js
-  // app/models/post.js
-  import { Model, hasMany } from '@warp-drive/legacy/model';
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
-  }
-  ```
+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
-  declare itself exactly the same. This is because polymorphism is based on structural
-  traits.
+Note: every Model that declares an inverse to a polymorphic relationship must
+declare 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 declare the abstract
-  type each record satisfies on both sides.
+Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+must be declared as polymorphic, and the `as` option must be used to declare the abstract
+type each record satisfies on both sides.
 
-  @public
-  @param {String} type (optional) the name of the related resource
-  @param {Object} options (optional) a hash of options
-  @return {PropertyDescriptor} relationship
+@public
+@param {String} type (optional) the name of the related resource
+@param {Object} options (optional) a hash of options
+@return {PropertyDescriptor} relationship
 */
 export declare function belongsTo(): never;
 export declare function belongsTo(type: string): never;
 export declare function belongsTo<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
+// export function belongsTo<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(
+//   type: TypeFromInstance<NoNull<T>>,
+//   options: RelationshipOptions<T, true>
+// ): RelationshipDecorator<K>;
 export declare function belongsTo(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;
-//# sourceMappingURL=belongs-to.d.ts.map