@ember-data/store 4.5.0-beta.0 → 4.5.0

package/addon/-private/system/references/has-many.ts

@@ -1,487 +0,0 @@
-import { dependentKeyCompat } from '@ember/object/compat';
-import { DEBUG } from '@glimmer/env';
-import { cached, tracked } from '@glimmer/tracking';
-
-import { resolve } from 'rsvp';
-
-import { ManyArray } from 'ember-data/-private';
-
-import type { ManyRelationship } from '@ember-data/record-data/-private';
-import { assertPolymorphicType } from '@ember-data/store/-debug';
-
-import {
-  CollectionResourceDocument,
-  ExistingResourceObject,
-  SingleResourceDocument,
-} from '../../ts-interfaces/ember-data-json-api';
-import { StableRecordIdentifier } from '../../ts-interfaces/identifier';
-import CoreStore from '../core-store';
-import { NotificationType, unsubscribe } from '../record-notification-manager';
-import { internalModelFactoryFor, recordIdentifierFor } from '../store/internal-model-factory';
-import RecordReference from './record';
-import Reference from './reference';
-/**
-  @module @ember-data/store
-*/
-
-/**
- A `HasManyReference` is a low-level API that allows users and addon
- authors to perform meta-operations on a has-many relationship.
-
- @class HasManyReference
- @public
- @extends Reference
- */
-export default class HasManyReference extends Reference {
-  declare key: string;
-  declare hasManyRelationship: ManyRelationship;
-  declare type: string;
-  declare parent: RecordReference;
-
-  // unsubscribe tokens given to us by the notification manager
-  #token!: Object;
-  #identifier: StableRecordIdentifier;
-  #relatedTokenMap!: Map<StableRecordIdentifier, Object>;
-
-  @tracked _ref = 0;
-
-  constructor(
-    store: CoreStore,
-    parentIdentifier: StableRecordIdentifier,
-    hasManyRelationship: ManyRelationship,
-    key: string
-  ) {
-    super(store, parentIdentifier);
-    this.key = key;
-    this.hasManyRelationship = hasManyRelationship;
-    this.type = hasManyRelationship.definition.type;
-
-    this.parent = internalModelFactoryFor(store).peek(parentIdentifier)!.recordReference;
-    this.#identifier = parentIdentifier;
-    this.#token = store._notificationManager.subscribe(
-      parentIdentifier,
-      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
-          this._ref++;
-        }
-      }
-    );
-    this.#relatedTokenMap = new Map();
-    // TODO inverse
-  }
-
-  destroy() {
-    unsubscribe(this.#token);
-    this.#relatedTokenMap.forEach((token) => {
-      unsubscribe(token);
-    });
-    this.#relatedTokenMap.clear();
-  }
-
-  @cached
-  @dependentKeyCompat
-  get _relatedIdentifiers(): StableRecordIdentifier[] {
-    this._ref; // consume the tracked prop
-
-    let resource = this._resource();
-
-    this.#relatedTokenMap.forEach((token) => {
-      unsubscribe(token);
-    });
-    this.#relatedTokenMap.clear();
-
-    if (resource && resource.data) {
-      return resource.data.map((resourceIdentifier) => {
-        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
-        const token = this.store._notificationManager.subscribe(
-          identifier,
-          (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-            if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
-              this._ref++;
-            }
-          }
-        );
-
-        this.#relatedTokenMap.set(identifier, token);
-
-        return identifier;
-      });
-    }
-
-    return [];
-  }
-
-  _resource() {
-    return this.recordData.getHasMany(this.key);
-  }
-
-  /**
-   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({ async: true }) 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' {
-    let value = this._resource();
-    if (value && value.links && value.links.related) {
-      return 'link';
-    }
-
-    return '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({ async: true }) 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> {
-    return this._relatedIdentifiers.map((identifier) => identifier.id);
-  }
-
-  /**
-   `push` can be used to update the data in the relationship and Ember
-   Data will treat the new data as the canonical value of this
-   relationship on the backend.
-
-   Example
-
-   ```app/models/post.js
-   import Model, { hasMany } from '@ember-data/model';
-
-   export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
-   }
-   ```
-
-   ```
-   let post = store.push({
-     data: {
-       type: 'post',
-       id: 1,
-       relationships: {
-         comments: {
-           data: [{ type: 'comment', id: 1 }]
-         }
-       }
-     }
-   });
-
-   let commentsRef = post.hasMany('comments');
-
-   commentsRef.ids(); // ['1']
-
-   commentsRef.push([
-   [{ type: 'comment', id: 2 }],
-   [{ type: 'comment', id: 3 }],
-   ])
-
-   commentsRef.ids(); // ['2', '3']
-   ```
-
-   @method push
-    @public
-   @param {Array|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
-   @return {ManyArray}
-   */
-  async push(
-    objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
-  ): Promise<ManyArray> {
-    const payload = await resolve(objectOrPromise);
-    let array: Array<ExistingResourceObject | SingleResourceDocument>;
-
-    if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {
-      array = payload.data;
-    } else {
-      array = payload as ExistingResourceObject[];
-    }
-
-    const internalModel = internalModelFactoryFor(this.store).peek(this.#identifier)!;
-    const { store } = this;
-
-    let identifiers = array.map((obj) => {
-      let record;
-      if ('data' in obj) {
-        // TODO deprecate pushing non-valid JSON:API here
-        record = store.push(obj);
-      } else {
-        record = store.push({ data: obj });
-      }
-
-      if (DEBUG) {
-        let relationshipMeta = this.hasManyRelationship.definition;
-        let identifier = this.hasManyRelationship.identifier;
-        assertPolymorphicType(identifier, relationshipMeta, recordIdentifierFor(record), store);
-      }
-      return recordIdentifierFor(record);
-    });
-
-    const { graph, identifier } = this.hasManyRelationship;
-    store._backburner.join(() => {
-      graph.push({
-        op: 'replaceRelatedRecords',
-        record: identifier,
-        field: this.key,
-        value: identifiers,
-      });
-    });
-
-    // TODO IGOR it seems wrong that we were returning the many array here
-    return internalModel.getHasMany(this.key) as Promise<ManyArray> | ManyArray; // this cast is necessary because typescript does not work properly with custom thenables
-  }
-
-  _isLoaded() {
-    let hasRelationshipDataProperty = this.hasManyRelationship.state.hasReceivedData;
-    if (!hasRelationshipDataProperty) {
-      return false;
-    }
-
-    let members = this.hasManyRelationship.currentState;
-
-    //TODO Igor cleanup
-    return members.every((identifier) => {
-      let internalModel = this.store._internalModelForResource(identifier);
-      return internalModel.currentState.isLoaded === true;
-    });
-  }
-
-  /**
-   `value()` synchronously returns the current value of the has-many
-   relationship. Unlike `record.get('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({ async: true }) comments;
-   }
-   ```
-
-   ```javascript
-   let post = store.push({
-     data: {
-       type: 'post',
-       id: 1,
-       relationships: {
-         comments: {
-           data: [{ type: 'comment', id: 1 }]
-         }
-       }
-     }
-   });
-
-   let commentsRef = post.hasMany('comments');
-
-   post.get('comments').then(function(comments) {
-     commentsRef.value() === comments
-   })
-   ```
-
-   @method value
-    @public
-   @return {ManyArray}
-   */
-  value() {
-    const internalModel = internalModelFactoryFor(this.store).peek(this.#identifier)!;
-    if (this._isLoaded()) {
-      return internalModel.getManyArray(this.key);
-    }
-
-    return 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({ async: true }) 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) {
-    const internalModel = internalModelFactoryFor(this.store).peek(this.#identifier)!;
-    return internalModel.getHasMany(this.key, options);
-  }
-
-  /**
-   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({ async: true }) 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) {
-    const internalModel = internalModelFactoryFor(this.store).peek(this.#identifier)!;
-    return internalModel.reloadHasMany(this.key, options);
-  }
-}

package/addon/-private/system/references/reference.ts

@@ -1,205 +0,0 @@
-import type { Object as JSONObject, Value as JSONValue } from 'json-typescript';
-
-import type { LinkObject, PaginationLinks } from '../../ts-interfaces/ember-data-json-api';
-import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
-import type { JsonApiRelationship } from '../../ts-interfaces/record-data-json-api';
-import type { Dict } from '../../ts-interfaces/utils';
-import type CoreStore from '../core-store';
-/**
-  @module @ember-data/store
-*/
-
-interface ResourceIdentifier {
-  links?: {
-    related?: string;
-  };
-  meta?: JSONObject;
-}
-
-function isResourceIdentiferWithRelatedLinks(
-  value: any
-): value is ResourceIdentifier & { links: { related: string | LinkObject | null } } {
-  return value && value.links && value.links.related;
-}
-
-/**
-  This is the baseClass for the different References
-  like RecordReference/HasManyReference/BelongsToReference
-
- @class Reference
- @public
- */
-interface Reference {
-  links(): PaginationLinks | null;
-}
-abstract class Reference {
-  #identifier: StableRecordIdentifier;
-
-  constructor(public store: CoreStore, identifier: StableRecordIdentifier) {
-    this.#identifier = identifier;
-  }
-
-  get recordData() {
-    return this.store.recordDataFor(this.#identifier, false);
-  }
-
-  public _resource(): ResourceIdentifier | JsonApiRelationship | void {}
-
-  /**
-   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 Model.extend({
-     comments: hasMany({ async: true })
-   });
-   ```
-
-   ```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' | 'id' | 'ids' | 'identity' {
-    let value = this._resource();
-    if (isResourceIdentiferWithRelatedLinks(value)) {
-      return 'link';
-    }
-    return 'id';
-  }
-
-  /**
-   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({ async: true })
-    });
-
-   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 {
-    let link;
-    let resource = this._resource();
-
-    if (isResourceIdentiferWithRelatedLinks(resource)) {
-      if (resource.links) {
-        link = resource.links.related;
-        link = !link || typeof link === 'string' ? link : link.href;
-      }
-    }
-    return link || null;
-  }
-
-  links(): PaginationLinks | null {
-    let resource = this._resource();
-
-    return resource && resource.links ? resource.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({ async: true })
-    });
-
-   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 }
-   ```
-
-   @method meta
-    @public
-   @return {Object} The meta information for the belongs-to relationship.
-   */
-  meta() {
-    let meta: Dict<JSONValue> | null = null;
-    let resource = this._resource();
-    if (resource && resource.meta && typeof resource.meta === 'object') {
-      meta = resource.meta;
-    }
-    return meta;
-  }
-}
-
-export default Reference;

package/addon/-private/system/references.js

@@ -1,9 +0,0 @@
-/**
-  @module @ember-data/store
-*/
-
-import BelongsToReference from './references/belongs-to';
-import HasManyReference from './references/has-many';
-import RecordReference from './references/record';
-
-export { RecordReference, BelongsToReference, HasManyReference };