@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

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

@@ -1,191 +0,0 @@
-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
-*/
-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 name of the field as returned by the API and inserted into the
-	* cache if it differs from the name of the decorated property.
-	*
-	* For instance, if the API returns:
-	*
-	* ```ts
-	* {
-	*   attributes: {
-	*     'first-name': 'Chris'
-	*   }
-	* }
-	* ```
-	*
-	* But the app desires to use `record.firstName; // 'Chris'`, then the
-	* property should be named `firstName` and `sourceKey` should be set
-	* to `'first-name'`.
-	*
-	* This option is only needed when the value differs from the property name.
-	*/
-	sourceKey?: string;
-};
-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;
-};
-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> | 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 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 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`.
-*
-*/
-export type DataDecorator = (target: object, key: string, desc?: DecoratorPropertyDescriptor) => void;
-/**
-`attr` defines an attribute on a {@link Model}.
-By default, attributes are passed through as-is, however you can specify an
-optional type to have the value automatically transformed.
-WarpDrive ships with four basic transform types: `string`, `number`,
-`boolean` and `date`. You can define your own transforms by subclassing
-{@link 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 type the attribute type
-@param options a hash of options
-*/
-export declare function attr(): DataDecorator;
-export declare function attr<T>(type: TypeFromInstance<T>): DataDecorator;
-export declare function attr(type: string): DataDecorator;
-export declare function attr(options: AttrOptions): DataDecorator;
-export declare function attr<T>(type: TypeFromInstance<T>, options?: OptionsFromInstance<T>): DataDecorator;
-export declare function attr(type: string, options?: AttrOptions & object): DataDecorator;
-export declare function attr(target: object, key: string | symbol, desc?: PropertyDescriptor): void;
-export {};

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

@@ -1,195 +0,0 @@
-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;
-	/**
-	* The name of the field as returned by the API and inserted into the
-	* cache if it differs from the name of the decorated property.
-	*
-	* For instance, if the API returns:
-	*
-	* ```ts
-	* {
-	*   relationships: {
-	*     'best-friend': { data: { type: 'user', id: '1' } }
-	*   }
-	* }
-	* ```
-	*
-	* But the app desires to use `record.bestFriend`, then the property
-	* should be named `bestFriend` and `sourceKey` should be set to
-	* `'best-friend'`.
-	*
-	* This option is only needed when the value differs from the property name.
-	*/
-	sourceKey?: string;
-};
-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 {@link Model}.
-
-`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.
-
-### Examples
-
-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';
-
-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';
-
-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:
-
-```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;
-}
-
-// 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;
-}
-```
-
-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';
-
-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';
-
-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::
-
-```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;
-}
-```
-
-#### Sync vs Async Relationships
-
-WarpDrive 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 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';
-
-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 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';
-
-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.
-
-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 type the name of the related resource
-@param options a hash of options
-*/
-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 declare function belongsTo(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;

package/declarations/model/-private/debug/assert-polymorphic-type.d.ts

@@ -1,5 +0,0 @@
-import type { Store } from "@warp-drive/core";
-import type { UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { ResourceKey } from "@warp-drive/core/types/identifier";
-declare let assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: Store) => void;
-export { assertPolymorphicType };

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

@@ -1,289 +0,0 @@
-import { type NativeArray } from "@ember/array";
-import ArrayProxy from "@ember/array/proxy";
-import type RecordState from "./record-state.js";
-type ValidationError = {
-	attribute: string;
-	message: string;
-};
-interface ArrayProxyWithCustomOverrides<T> extends Omit<ArrayProxy<T>, "clear" | "content"> {
-	content: NativeArray<T>;
-	clear(): void;
-	_has(name: string): boolean;
-}
-declare const ArrayProxyWithCustomOverrides: new <T>() => ArrayProxyWithCustomOverrides<T>;
-/**
-Holds validation errors for a given record, organized by attribute names.
-
-This class is not directly instantiable.
-
-Every `Model` has an `errors` property that is an instance of
-`Errors`. This can be used to display validation error
-messages returned from the server when a `record.save()` rejects.
-
-For Example, if you had a `User` model that looked like this:
-
-```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;
-}
-```
-And you attempted to save a record that did not validate on the backend:
-
-```javascript
-let user = store.createRecord('user', {
-username: 'tomster',
-email: 'invalidEmail'
-});
-user.save();
-```
-
-Your backend would be expected to return an error response that described
-the problem, so that error messages can be generated on the app.
-
-API responses will be translated into instances of `Errors` differently,
-depending on the specific combination of adapter and serializer used. You
-may want to check the documentation or the source code of the libraries
-that you are using, to know how they expect errors to be communicated.
-
-Errors can be displayed to the user by accessing their property name
-to get an array of all the error objects for that property. Each
-error object is a JavaScript object with two keys:
-
-- `message` A string containing the error message from the backend
-- `attribute` The name of the property associated with this error message
-
-```handlebars
-<label>Username: <Input @value={{@model.username}} /> </label>
-{{#each @model.errors.username as |error|}}
-<div class="error">
-{{error.message}}
-</div>
-{{/each}}
-
-<label>Email: <Input @value={{@model.email}} /> </label>
-{{#each @model.errors.email as |error|}}
-<div class="error">
-{{error.message}}
-</div>
-{{/each}}
-```
-
-You can also access the special `messages` property on the error
-object to get an array of all the error strings.
-
-```handlebars
-{{#each @model.errors.messages as |message|}}
-<div class="error">
-{{message}}
-</div>
-{{/each}}
-```
-
-@class Errors
-@public
-*/
-export declare class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
-	__record: {
-		currentState: RecordState;
-	};
-	/**
-	@property errorsByAttributeName
-	@type {MapWithDefault}
-	@private
-	*/
-	get errorsByAttributeName(): Map<string, NativeArray<ValidationError>>;
-	/**
-	Returns errors for a given attribute
-	
-	```javascript
-	let user = store.createRecord('user', {
-	username: 'tomster',
-	email: 'invalidEmail'
-	});
-	user.save().catch(function(){
-	user.errors.errorsFor('email'); // returns:
-	// [{attribute: "email", message: "Doesn't look like a valid email."}]
-	});
-	```
-	
-	@public
-	@param {String} attribute
-	@return {Array}
-	*/
-	errorsFor(attribute: string): NativeArray<ValidationError>;
-	/**
-	An array containing all of the error messages for this
-	record. This is useful for displaying all errors to the user.
-	
-	```handlebars
-	{{#each @model.errors.messages as |message|}}
-	<div class="error">
-	{{message}}
-	</div>
-	{{/each}}
-	```
-	
-	@property messages
-	@public
-	@type {Array}
-	*/
-	messages: string[];
-	/**
-	@property content
-	@type {Array}
-	@private
-	*/
-	get content(): NativeArray<ValidationError>;
-	/**
-	@private
-	*/
-	unknownProperty(attribute: string): NativeArray<ValidationError> | undefined;
-	/**
-	Total number of errors.
-	
-	@property length
-	@type {Number}
-	@public
-	@readonly
-	*/
-	/**
-	`true` if we have no errors.
-	
-	@property isEmpty
-	@type {Boolean}
-	@public
-	@readonly
-	*/
-	isEmpty: boolean;
-	/**
-	Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
-	the record and transition the record into an `invalid` state.
-	
-	Example
-	```javascript
-	let errors = user.errors;
-	
-	// add multiple errors
-	errors.add('password', [
-	'Must be at least 12 characters',
-	'Must contain at least one symbol',
-	'Cannot contain your name'
-	]);
-	
-	errors.errorsFor('password');
-	// =>
-	// [
-	//   { attribute: 'password', message: 'Must be at least 12 characters' },
-	//   { attribute: 'password', message: 'Must contain at least one symbol' },
-	//   { attribute: 'password', message: 'Cannot contain your name' },
-	// ]
-	
-	// add a single error
-	errors.add('username', 'This field is required');
-	
-	errors.errorsFor('username');
-	// =>
-	// [
-	//   { attribute: 'username', message: 'This field is required' },
-	// ]
-	```
-	@public
-	@param {String} attribute - the property name of an attribute or relationship
-	@param {string[]|string} messages - an error message or array of error messages for the attribute
-	*/
-	add(attribute: string, messages: string[] | string): void;
-	/**
-	@private
-	*/
-	_findOrCreateMessages(attribute: string, messages: string | string[]): ValidationError[];
-	/**
-	Manually removes all errors for a given member from the record.
-	This will transition the record into a `valid` state, and
-	triggers the `becameValid` event and lifecycle method.
-	
-	Example:
-	
-	```javascript
-	let errors = user.errors;
-	errors.add('phone', ['error-1', 'error-2']);
-	
-	errors.errorsFor('phone');
-	// =>
-	// [
-	//   { attribute: 'phone', message: 'error-1' },
-	//   { attribute: 'phone', message: 'error-2' },
-	// ]
-	
-	errors.remove('phone');
-	
-	errors.errorsFor('phone');
-	// => undefined
-	```
-	@public
-	@param {String} member - the property name of an attribute or relationship
-	*/
-	remove(attribute: string): void;
-	/**
-	Manually clears all errors for the record.
-	This will transition the record into a `valid` state, and
-	will trigger the `becameValid` event and lifecycle method.
-	
-	Example:
-	
-	```javascript
-	let errors = user.errors;
-	errors.add('username', ['error-a']);
-	errors.add('phone', ['error-1', 'error-2']);
-	
-	errors.errorsFor('username');
-	// =>
-	// [
-	//   { attribute: 'username', message: 'error-a' },
-	// ]
-	
-	errors.errorsFor('phone');
-	// =>
-	// [
-	//   { attribute: 'phone', message: 'error-1' },
-	//   { attribute: 'phone', message: 'error-2' },
-	// ]
-	
-	errors.clear();
-	
-	errors.errorsFor('username');
-	// => undefined
-	
-	errors.errorsFor('phone');
-	// => undefined
-	
-	errors.messages
-	// => []
-	```
-	@public
-	*/
-	clear(): void;
-	/**
-	Checks if there are error messages for the given attribute.
-	
-	```js [app/controllers/user/edit.js]
-	export default class UserEditController extends Controller {
-	@action
-	save(user) {
-	if (user.errors.has('email')) {
-	return alert('Please update your email before attempting to save.');
-	}
-	user.save();
-	}
-	}
-	```
-	
-	@public
-	@param {String} attribute
-	@return {Boolean} true if there some errors on given attribute
-	*/
-	has(attribute: string): boolean;
-}
-export {};