@ember-data/model 4.12.8 → 4.13.0-alpha.3

package/unstable-preview-types/-private/references/has-many.d.ts

@@ -0,0 +1,515 @@
+declare module '@ember-data/model/-private/references/has-many' {
+  import type { CollectionEdge, Graph } from '@ember-data/graph/-private';
+  import type Store from '@ember-data/store';
+  import type { BaseFinderOptions } from '@ember-data/store/types';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { TypeFromInstanceOrString } from '@warp-drive/core-types/record';
+  import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from '@warp-drive/core-types/spec/json-api-raw';
+  import type { IsUnknown } from '@ember-data/model/-private/belongs-to';
+  import type { RelatedCollection as ManyArray } from '@ember-data/model/-private/many-array';
+  import type { MaybeHasManyFields } from '@ember-data/model/-private/type-utils';
+  /**
+    @module @ember-data/model
+  */
+  interface ResourceIdentifier {
+      links?: {
+          related?: string | LinkObject;
+      };
+      meta?: Meta;
+  }
+  type ArrayItemType<T> = T extends (infer U)[] ? U : never;
+  /**
+   A `HasManyReference` is a low-level API that allows access
+   and manipulation of a hasMany relationship.
+  
+   It is especially useful when you're dealing with `async` relationships
+   from `@ember-data/model` as it allows synchronous access to
+   the relationship data if loaded, as well as APIs for loading, reloading
+   the data or accessing available information without triggering a load.
+  
+   It may also be useful when using `sync` relationships with `@ember-data/model`
+   that need to be loaded/reloaded with more precise timing than marking the
+   relationship as `async` and relying on autofetch would have allowed.
+  
+   However,keep in mind that marking a relationship as `async: false` will introduce
+   bugs into your application if the data is not always guaranteed to be available
+   by the time the relationship is accessed. Ergo, it is recommended when using this
+   approach to utilize `links` for unloaded relationship state instead of identifiers.
+  
+   Reference APIs are entangled with the relationship's underlying state,
+   thus any getters or cached properties that utilize these will properly
+   invalidate if the relationship state changes.
+  
+   References are "stable", meaning that multiple calls to retrieve the reference
+    for a given relationship will always return the same HasManyReference.
+  
+   @class HasManyReference
+   @public
+   */
+  export default class HasManyReference<T = unknown, K extends string = IsUnknown<T> extends true ? string : MaybeHasManyFields<T>, Related = K extends keyof T ? ArrayItemType<Awaited<T[K]>> : unknown> {
+      graph: Graph;
+      store: Store;
+      hasManyRelationship: CollectionEdge;
+      /**
+       * The field name on the parent record for this has-many relationship.
+       *
+       * @property {String} key
+       * @public
+       */
+      key: K;
+      /**
+       * The type of resource this relationship will contain.
+       *
+       * @property {String} type
+       * @public
+       */
+      type: TypeFromInstanceOrString<Related>;
+      ___token: object;
+      ___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
+      ___relatedTokenMap: Map<StableRecordIdentifier, object>;
+      _ref: number;
+      constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
+      /**
+       * This method should never be called by user code.
+       *
+       * @internal
+       */
+      destroy(): void;
+      /**
+       * An array of identifiers for the records that this reference refers to.
+       *
+       * @property {StableRecordIdentifier[]} identifiers
+       * @public
+       */
+      get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
+      _resource(): CollectionResourceRelationship;
+      /**
+       This returns a string that represents how the reference will be
+       looked up when it is loaded. If the relationship has a link it will
+       use the "link" otherwise it defaults to "id".
+    
+       Example
+    
+       ```app/models/post.js
+       import Model, { hasMany } from '@ember-data/model';
+    
+       export default class PostModel extends Model {
+         @hasMany('comment', { async: true, inverse: null }) comments;
+       }
+       ```
+    
+       ```javascript
+       let post = store.push({
+         data: {
+           type: 'post',
+           id: 1,
+           relationships: {
+             comments: {
+               data: [{ type: 'comment', id: 1 }]
+             }
+           }
+         }
+       });
+    
+       let commentsRef = post.hasMany('comments');
+    
+       // get the identifier of the reference
+       if (commentsRef.remoteType() === "ids") {
+         let ids = commentsRef.ids();
+       } else if (commentsRef.remoteType() === "link") {
+         let link = commentsRef.link();
+       }
+       ```
+    
+       @method remoteType
+       @public
+       @return {String} The name of the remote type. This should either be `link` or `ids`
+       */
+      remoteType(): 'link' | 'ids';
+      /**
+       `ids()` returns an array of the record IDs in this relationship.
+    
+       Example
+    
+       ```app/models/post.js
+       import Model, { hasMany } from '@ember-data/model';
+    
+       export default class PostModel extends Model {
+         @hasMany('comment', { async: true, inverse: null }) comments;
+       }
+       ```
+    
+       ```javascript
+       let post = store.push({
+         data: {
+           type: 'post',
+           id: 1,
+           relationships: {
+             comments: {
+               data: [{ type: 'comment', id: 1 }]
+             }
+           }
+         }
+       });
+    
+       let commentsRef = post.hasMany('comments');
+    
+       commentsRef.ids(); // ['1']
+       ```
+    
+       @method ids
+        @public
+       @return {Array} The ids in this has-many relationship
+       */
+      ids(): Array<string | null>;
+      /**
+       The link Ember Data will use to fetch or reload this belongs-to
+       relationship. By default it uses only the "related" resource linkage.
+    
+       Example
+    
+       ```javascript
+       // models/blog.js
+       import Model, { belongsTo } from '@ember-data/model';
+       export default Model.extend({
+          user: belongsTo('user', { async: true, inverse: null })
+        });
+    
+       let blog = store.push({
+          data: {
+            type: 'blog',
+            id: 1,
+            relationships: {
+              user: {
+                links: {
+                  related: '/articles/1/author'
+                }
+              }
+            }
+          }
+        });
+       let userRef = blog.belongsTo('user');
+    
+       // get the identifier of the reference
+       if (userRef.remoteType() === "link") {
+          let link = userRef.link();
+        }
+       ```
+    
+       @method link
+       @public
+       @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
+       */
+      link(): string | null;
+      /**
+       * any links that have been received for this relationship
+       *
+       * @method links
+       * @public
+       * @return
+       */
+      links(): PaginationLinks | null;
+      /**
+       The meta data for the has-many relationship.
+    
+       Example
+    
+       ```javascript
+       // models/blog.js
+       import Model, { hasMany } from '@ember-data/model';
+       export default Model.extend({
+          users: hasMany('user', { async: true, inverse: null })
+        });
+    
+       let blog = store.push({
+          data: {
+            type: 'blog',
+            id: 1,
+            relationships: {
+              users: {
+                links: {
+                  related: {
+                    href: '/articles/1/authors'
+                  },
+                },
+                meta: {
+                  lastUpdated: 1458014400000
+                }
+              }
+            }
+          }
+        });
+    
+       let usersRef = blog.hasMany('user');
+    
+       usersRef.meta() // { lastUpdated: 1458014400000 }
+       ```
+    
+      @method meta
+      @public
+      @return {Object|null} The meta information for the belongs-to relationship.
+      */
+      meta(): Meta | null;
+      /**
+       `push` can be used to update the data in the relationship and EmberData
+       will treat the new data as the canonical value of this relationship on
+       the backend. An empty array will signify the canonical value should be
+       empty.
+    
+       Example model
+    
+       ```app/models/post.js
+       import Model, { hasMany } from '@ember-data/model';
+    
+       export default class PostModel extends Model {
+         @hasMany('comment', { async: true, inverse: null }) comments;
+       }
+       ```
+    
+       Setup some initial state, note we haven't loaded the comments yet:
+    
+       ```js
+       const post = store.push({
+         data: {
+           type: 'post',
+           id: '1',
+           relationships: {
+             comments: {
+               data: [{ type: 'comment', id: '1' }]
+             }
+           }
+         }
+       });
+    
+       const commentsRef = post.hasMany('comments');
+       commentsRef.ids(); // ['1']
+       ```
+    
+       Update the state using `push`, note we can do this even without
+       having loaded these comments yet by providing resource identifiers.
+    
+       Both full resources and resource identifiers are supported.
+    
+       ```js
+       await commentsRef.push({
+        data: [
+         { type: 'comment', id: '2' },
+         { type: 'comment', id: '3' },
+        ]
+       });
+    
+       commentsRef.ids(); // ['2', '3']
+       ```
+    
+       For convenience, you can also pass in an array of resources or resource identifiers
+       without wrapping them in the `data` property:
+    
+       ```js
+       await commentsRef.push([
+         { type: 'comment', id: '4' },
+         { type: 'comment', id: '5' },
+       ]);
+    
+       commentsRef.ids(); // ['4', '5']
+       ```
+    
+       When using the `data` property, you may also include other resource data via included,
+       as well as provide new links and meta to the relationship.
+    
+       ```js
+       await commentsRef.push({
+         links: {
+           related: '/posts/1/comments'
+         },
+         meta: {
+           total: 2
+         },
+         data: [
+           { type: 'comment', id: '4' },
+           { type: 'comment', id: '5' },
+         ],
+         included: [
+           { type: 'other-thing', id: '1', attributes: { foo: 'bar' },
+         ]
+       });
+       ```
+    
+       By default, the store will attempt to fetch any unloaded records before resolving
+       the returned promise with the ManyArray.
+    
+       Alternatively, pass `true` as the second argument to avoid fetching unloaded records
+       and instead the promise will resolve with void without attempting to fetch. This is
+       particularly useful if you want to update the state of the relationship without
+       forcing the load of all of the associated records.
+    
+       @method push
+       @public
+       @param {Array|Object} doc a JSONAPI document object describing the new value of this relationship.
+       @param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
+       @return {Promise<ManyArray | void>}
+      */
+      push(maybeDoc: ExistingResourceObject[] | CollectionResourceDocument, skipFetch?: boolean): Promise<ManyArray<Related> | void>;
+      _isLoaded(): boolean | undefined;
+      /**
+       `value()` synchronously returns the current value of the has-many
+       relationship. Unlike `record.relationshipName`, calling
+       `value()` on a reference does not trigger a fetch if the async
+       relationship is not yet loaded. If the relationship is not loaded
+       it will always return `null`.
+    
+       Example
+    
+       ```app/models/post.js
+       import Model, { hasMany } from '@ember-data/model';
+    
+       export default class PostModel extends Model {
+         @hasMany('comment', { async: true, inverse: null }) comments;
+       }
+       ```
+    
+       ```javascript
+       let post = store.push({
+         data: {
+           type: 'post',
+           id: 1,
+           relationships: {
+             comments: {
+               data: [{ type: 'comment', id: 1 }]
+             }
+           }
+         }
+       });
+    
+       let commentsRef = post.hasMany('comments');
+    
+       post.comments.then(function(comments) {
+         commentsRef.value() === comments
+       })
+       ```
+    
+       @method value
+        @public
+       @return {ManyArray}
+       */
+      value(): ManyArray<Related> | null;
+      /**
+       Loads the relationship if it is not already loaded.  If the
+       relationship is already loaded this method does not trigger a new
+       load. This causes a request to the specified
+       relationship link or reloads all items currently in the relationship.
+    
+       Example
+    
+       ```app/models/post.js
+       import Model, { hasMany } from '@ember-data/model';
+    
+       export default class PostModel extends Model {
+         @hasMany('comment', { async: true, inverse: null }) comments;
+       }
+       ```
+    
+       ```javascript
+       let post = store.push({
+         data: {
+           type: 'post',
+           id: 1,
+           relationships: {
+             comments: {
+               data: [{ type: 'comment', id: 1 }]
+             }
+           }
+         }
+       });
+    
+       let commentsRef = post.hasMany('comments');
+    
+       commentsRef.load().then(function(comments) {
+         //...
+       });
+       ```
+    
+       You may also pass in an options object whose properties will be
+       fed forward. This enables you to pass `adapterOptions` into the
+       request given to the adapter via the reference.
+    
+       Example
+    
+       ```javascript
+       commentsRef.load({ adapterOptions: { isPrivate: true } })
+         .then(function(comments) {
+           //...
+         });
+       ```
+    
+       ```app/adapters/comment.js
+       export default ApplicationAdapter.extend({
+         findMany(store, type, id, snapshots) {
+           // In the adapter you will have access to adapterOptions.
+           let adapterOptions = snapshots[0].adapterOptions;
+         }
+       });
+       ```
+    
+       @method load
+       @public
+       @param {Object} options the options to pass in.
+       @return {Promise} a promise that resolves with the ManyArray in
+       this has-many relationship.
+       */
+      load(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
+      /**
+       Reloads this has-many relationship. This causes a request to the specified
+       relationship link or reloads all items currently in the relationship.
+    
+       Example
+    
+       ```app/models/post.js
+       import Model, { hasMany } from '@ember-data/model';
+    
+       export default class PostModel extends Model {
+         @hasMany('comment', { async: true, inverse: null }) comments;
+       }
+       ```
+    
+       ```javascript
+       let post = store.push({
+         data: {
+           type: 'post',
+           id: 1,
+           relationships: {
+             comments: {
+               data: [{ type: 'comment', id: 1 }]
+             }
+           }
+         }
+       });
+    
+       let commentsRef = post.hasMany('comments');
+    
+       commentsRef.reload().then(function(comments) {
+         //...
+       });
+       ```
+    
+       You may also pass in an options object whose properties will be
+       fed forward. This enables you to pass `adapterOptions` into the
+       request given to the adapter via the reference. A full example
+       can be found in the `load` method.
+    
+       Example
+    
+       ```javascript
+       commentsRef.reload({ adapterOptions: { isPrivate: true } })
+       ```
+    
+       @method reload
+        @public
+       @param {Object} options the options to pass in.
+       @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
+       */
+      reload(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
+  }
+  export function isMaybeResource(object: ExistingResourceObject | ResourceIdentifier): object is ExistingResourceObject;
+  export {};
+}
+//# sourceMappingURL=has-many.d.ts.map

package/unstable-preview-types/-private/references/has-many.d.ts.map

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

package/unstable-preview-types/-private/relationship-meta.d.ts

@@ -0,0 +1,35 @@
+declare module '@ember-data/model/-private/relationship-meta' {
+  import type Store from '@ember-data/store';
+  import type { LegacyRelationshipSchema } from '@warp-drive/core-types/schema/fields';
+  import type { Model } from '@ember-data/model/-private/model';
+  class RelationshipDefinition {
+      _type: string;
+      __inverseKey: string | null;
+      __hasCalculatedInverse: boolean;
+      parentModelName: string;
+      inverseIsAsync: string | null;
+      meta: LegacyRelationshipSchema;
+      constructor(meta: LegacyRelationshipSchema, parentModelName: string);
+      get kind(): 'belongsTo' | 'hasMany';
+      get type(): string;
+      get options(): {
+          async: boolean;
+          inverse: string | null;
+          as?: string;
+          polymorphic?: boolean;
+          resetOnRemoteUpdate?: false;
+      } | {
+          async: boolean;
+          inverse: string | null;
+          as?: string;
+          polymorphic?: boolean;
+          resetOnRemoteUpdate?: false;
+      };
+      get name(): string;
+      _inverseKey(store: Store, modelClass: typeof Model): string | null;
+      _calculateInverse(store: Store, modelClass: typeof Model): void;
+  }
+  export type { RelationshipDefinition };
+  export function relationshipFromMeta(meta: LegacyRelationshipSchema, parentModelName: string): LegacyRelationshipSchema;
+}
+//# sourceMappingURL=relationship-meta.d.ts.map

package/unstable-preview-types/-private/relationship-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship-meta.d.ts","sourceRoot":"","sources":["../../src/-private/relationship-meta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAE3C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAErF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAiBrC,cAAM,sBAAsB;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,sBAAsB,EAAE,OAAO,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,IAAI,EAAE,wBAAwB,CAAC;gBAE3B,IAAI,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM;IAQnE,IAAI,IAAI,IAAI,WAAW,GAAG,SAAS,CAElC;IACD,IAAI,IAAI,IAAI,MAAM,CAMjB;IACD,IAAI,OAAO;;;;;;;;;;;;MAEV;IACD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,KAAK,GAAG,MAAM,GAAG,IAAI;IAOlE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,KAAK,GAAG,IAAI;CAsBhE;AACD,YAAY,EAAE,sBAAsB,EAAE,CAAC;AAEvC,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,wBAAwB,EAC9B,eAAe,EAAE,MAAM,GACtB,wBAAwB,CAE1B"}

package/unstable-preview-types/-private/schema-provider.d.ts

@@ -0,0 +1,64 @@
+declare module '@ember-data/model/-private/schema-provider' {
+  import type Store from '@ember-data/store';
+  import type { SchemaService } from '@ember-data/store/types';
+  import type { RecordIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { ObjectValue } from '@warp-drive/core-types/json/raw';
+  import type { Derivation, HashFn, Transformation } from '@warp-drive/core-types/schema/concepts';
+  import type { ArrayField, DerivedField, GenericField, HashField, LegacyAttributeField, LegacyFieldSchema, LegacyRelationshipSchema, ObjectField, ResourceSchema } from '@warp-drive/core-types/schema/fields';
+  import type { ModelFactory, ModelStore } from '@ember-data/model/-private/model';
+  type AttributesSchema = ReturnType<Exclude<SchemaService['attributesDefinitionFor'], undefined>>;
+  type RelationshipsSchema = ReturnType<Exclude<SchemaService['relationshipsDefinitionFor'], undefined>>;
+  type InternalSchema = {
+      schema: ResourceSchema;
+      fields: Map<string, LegacyAttributeField | LegacyRelationshipSchema>;
+      attributes: Record<string, LegacyAttributeField>;
+      relationships: Record<string, LegacyRelationshipSchema>;
+  };
+  export interface ModelSchemaProvider {
+      attributesDefinitionFor(resource: RecordIdentifier | {
+          type: string;
+      }): AttributesSchema;
+      relationshipsDefinitionFor(resource: RecordIdentifier | {
+          type: string;
+      }): RelationshipsSchema;
+      doesTypeExist(type: string): boolean;
+  }
+  export class ModelSchemaProvider implements SchemaService {
+      store: ModelStore;
+      _schemas: Map<string, InternalSchema>;
+      _typeMisses: Set<string>;
+      constructor(store: ModelStore);
+      hasTrait(type: string): boolean;
+      resourceHasTrait(resource: StableRecordIdentifier | {
+          type: string;
+      }, trait: string): boolean;
+      transformation(field: GenericField | ObjectField | ArrayField | {
+          type: string;
+      }): Transformation;
+      derivation(field: DerivedField | {
+          type: string;
+      }): Derivation;
+      hashFn(field: HashField | {
+          type: string;
+      }): HashFn;
+      resource(resource: StableRecordIdentifier | {
+          type: string;
+      }): ResourceSchema;
+      registerResources(schemas: ResourceSchema[]): void;
+      registerResource(schema: ResourceSchema): void;
+      registerTransformation(transform: Transformation): void;
+      registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
+      registerHashFn(hashFn: HashFn): void;
+      _loadModelSchema(type: string): InternalSchema;
+      fields(resource: RecordIdentifier | {
+          type: string;
+      }): Map<string, LegacyFieldSchema>;
+      hasResource(resource: {
+          type: string;
+      }): boolean;
+  }
+  export function buildSchema(store: Store): SchemaService;
+  export function getModelFactory(store: ModelStore, type: string): ModelFactory | null;
+  export {};
+}
+//# sourceMappingURL=schema-provider.d.ts.map

package/unstable-preview-types/-private/schema-provider.d.ts.map

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