@ember-data/model 5.6.0-alpha.5 → 5.6.0-beta.1

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

@@ -1,497 +0,0 @@
-declare module '@ember-data/model/-private/references/belongs-to' {
-  import type { Graph, ResourceEdge } from '@ember-data/graph/-private';
-  import type Store from '@ember-data/store';
-  import type { StableRecordIdentifier } from '@warp-drive/core-types';
-  import type { TypeFromInstance, TypeFromInstanceOrString } from '@warp-drive/core-types/record';
-  import type { Links, Meta, SingleResourceDocument, SingleResourceRelationship } from '@warp-drive/core-types/spec/json-api-raw';
-  import type { IsUnknown } from '@ember-data/model/-private/belongs-to';
-  import type { MaybeBelongsToFields } from '@ember-data/model/-private/type-utils';
-  /**
-   A `BelongsToReference` is a low-level API that allows access
-   and manipulation of a belongsTo 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 BelongsToReference
-   @public
-   */
-  export default class BelongsToReference<T = unknown, K extends string = IsUnknown<T> extends true ? string : MaybeBelongsToFields<T>, Related = K extends keyof T ? Exclude<Awaited<T[K]>, null> : unknown> {
-      graph: Graph;
-      store: Store;
-      belongsToRelationship: ResourceEdge;
-      /**
-       * The field name on the parent record for this has-many relationship.
-       *
-       * @property key
-       * @type {String}
-       * @public
-       */
-      key: K;
-      /**
-       * The type of resource this relationship will contain.
-       *
-       * @property type
-       * @type {String}
-       * @public
-       */
-      type: TypeFromInstanceOrString<Related>;
-      ___token: object;
-      ___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
-      ___relatedToken: object | null;
-      _ref: number;
-      constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
-      destroy(): void;
-      /**
-       * The identifier of the record that this reference refers to.
-       * `null` if no related record is known.
-       *
-       * @property identifier
-       * @type {StableRecordIdentifier | null}
-       * @public
-       */
-      get identifier(): StableRecordIdentifier<TypeFromInstanceOrString<Related>> | null;
-      /**
-       The `id` of the record that this reference refers to. Together, the
-       `type()` and `id()` methods form a composite key for the identity
-       map. This can be used to access the id of an async relationship
-       without triggering a fetch that would normally happen if you
-       attempted to use `record.relationship.id`.
-    
-       Example
-    
-       ```javascript
-       // models/blog.js
-       import Model, { belongsTo } from '@ember-data/model';
-    
-       export default class BlogModel extends Model {
-        @belongsTo('user', { async: true, inverse: null }) user;
-       }
-    
-       let blog = store.push({
-          data: {
-            type: 'blog',
-            id: 1,
-            relationships: {
-              user: {
-                data: { type: 'user', id: 1 }
-              }
-            }
-          }
-        });
-       let userRef = blog.belongsTo('user');
-    
-       // get the identifier of the reference
-       if (userRef.remoteType() === "id") {
-          let id = userRef.id();
-        }
-       ```
-    
-       @public
-       @return {String} The id of the record in this belongsTo relationship.
-       */
-      id(): 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();
-        }
-       ```
-    
-       @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
-       *
-       * @public
-       * @return
-       */
-      links(): Links | null;
-      /**
-       The meta data for the belongs-to relationship.
-    
-       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: {
-                    href: '/articles/1/author'
-                  },
-                },
-                meta: {
-                  lastUpdated: 1458014400000
-                }
-              }
-            }
-          }
-        });
-    
-       let userRef = blog.belongsTo('user');
-    
-       userRef.meta() // { lastUpdated: 1458014400000 }
-       ```
-    
-        @public
-       @return {Object} The meta information for the belongs-to relationship.
-       */
-      meta(): Meta | null;
-      _resource(): SingleResourceRelationship<StableRecordIdentifier<TypeFromInstance<Related>>>;
-      /**
-       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
-    
-       ```js [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();
-       }
-       ```
-    
-       @public
-       @return {String} The name of the remote type. This should either be `link` or `id`
-       */
-      remoteType(): 'link' | 'id';
-      /**
-       `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. A value of `null` (e.g. `{ data: null }`) can be passed to
-       clear the relationship.
-    
-       Example model
-    
-       ```js [app/models/blog.js]
-       import Model, { belongsTo } from '@ember-data/model';
-    
-       export default class BlogModel extends Model {
-          @belongsTo('user', { async: true, inverse: null }) user;
-        }
-       ```
-    
-       Setup some initial state, note we haven't loaded the user yet:
-    
-       ```js
-       const blog = store.push({
-          data: {
-            type: 'blog',
-            id: '1',
-            relationships: {
-              user: {
-                data: { type: 'user', id: '1' }
-              }
-            }
-          }
-       });
-    
-       const userRef = blog.belongsTo('user');
-       userRef.id(); // '1'
-       ```
-    
-       Update the state using `push`, note we can do this even without
-       having loaded the user yet by providing a resource-identifier.
-    
-       Both full a resource and a resource-identifier are supported.
-    
-       ```js
-       await userRef.push({
-          data: {
-            type: 'user',
-            id: '2',
-          }
-        });
-    
-        userRef.id(); // '2'
-       ```
-    
-       You may also pass in links and meta fore the relationship, and sideload
-       additional resources that might be required.
-    
-       ```js
-        await userRef.push({
-            data: {
-              type: 'user',
-              id: '2',
-            },
-            links: {
-              related: '/articles/1/author'
-            },
-            meta: {
-              lastUpdated: Date.now()
-            },
-            included: [
-              {
-                type: 'user-preview',
-                id: '2',
-                attributes: {
-                  username: '@runspired'
-                }
-              }
-            ]
-          });
-        ```
-    
-       By default, the store will attempt to fetch the record if it is not loaded or its
-       resource data is not included in the call to `push` before resolving the returned
-       promise with the new state..
-    
-       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 record.
-    
-       @public
-       @param {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<OpaqueRecordInstance | null | void>}
-      */
-      push(doc: SingleResourceDocument, skipFetch?: boolean): Promise<Related | null | void>;
-      /**
-       `value()` synchronously returns the current value of the belongs-to
-       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
-    
-       ```javascript
-       // models/blog.js
-       import Model, { belongsTo } from '@ember-data/model';
-    
-       export default class BlogModel extends Model {
-         @belongsTo('user', { async: true, inverse: null }) user;
-       }
-    
-       let blog = store.push({
-          data: {
-            type: 'blog',
-            id: 1,
-            relationships: {
-              user: {
-                data: { type: 'user', id: 1 }
-              }
-            }
-          }
-        });
-       let userRef = blog.belongsTo('user');
-    
-       userRef.value(); // null
-    
-       // provide data for reference
-       userRef.push({
-          data: {
-            type: 'user',
-            id: 1,
-            attributes: {
-              username: "@user"
-            }
-          }
-        }).then(function(user) {
-          userRef.value(); // user
-        });
-       ```
-    
-        @public
-       @return {Model} the record in this relationship
-       */
-      value(): Related | null;
-      /**
-       Loads a record in a belongs-to relationship if it is not already
-       loaded. If the relationship is already loaded this method does not
-       trigger a new load.
-    
-       Example
-    
-       ```javascript
-       // models/blog.js
-       import Model, { belongsTo } from '@ember-data/model';
-    
-       export default class BlogModel extends Model {
-         @belongsTo('user', { async: true, inverse: null }) user;
-       }
-    
-       let blog = store.push({
-          data: {
-            type: 'blog',
-            id: 1,
-            relationships: {
-              user: {
-                data: { type: 'user', id: 1 }
-              }
-            }
-          }
-        });
-       let userRef = blog.belongsTo('user');
-    
-       userRef.value(); // null
-    
-       userRef.load().then(function(user) {
-          userRef.value() === user
-        });
-       ```
-    
-       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
-       userRef.load({ adapterOptions: { isPrivate: true } }).then(function(user) {
-         userRef.value() === user;
-       });
-       ```
-       ```js [app/adapters/user.js]
-       import Adapter from '@ember-data/adapter';
-    
-       export default class UserAdapter extends Adapter {
-         findRecord(store, type, id, snapshot) {
-           // In the adapter you will have access to adapterOptions.
-           let adapterOptions = snapshot.adapterOptions;
-         }
-       });
-       ```
-    
-        @public
-       @param {Object} options the options to pass in.
-       @return {Promise} a promise that resolves with the record in this belongs-to relationship.
-       */
-      load(options?: Record<string, unknown>): Promise<Related | null>;
-      /**
-       Triggers a reload of the value in this relationship. If the
-       remoteType is `"link"` Ember Data will use the relationship link to
-       reload the relationship. Otherwise it will reload the record by its
-       id.
-    
-       Example
-    
-       ```javascript
-       // models/blog.js
-       import Model, { belongsTo } from '@ember-data/model';
-    
-       export default class BlogModel extends Model {
-         @belongsTo('user', { async: true, inverse: null }) user;
-       }
-    
-       let blog = store.push({
-          data: {
-            type: 'blog',
-            id: 1,
-            relationships: {
-              user: {
-                data: { type: 'user', id: 1 }
-              }
-            }
-          }
-        });
-       let userRef = blog.belongsTo('user');
-    
-       userRef.reload().then(function(user) {
-          userRef.value() === user
-        });
-       ```
-    
-       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
-       userRef.reload({ adapterOptions: { isPrivate: true } })
-       ```
-    
-        @public
-       @param {Object} options the options to pass in.
-       @return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.
-       */
-      reload(options?: Record<string, unknown>): Promise<Related | null>;
-  }
-}
-//# sourceMappingURL=belongs-to.d.ts.map

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

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