@ember-data/store 4.4.0 → 4.5.0-alpha.2

package/addon/-private/system/record-arrays/adapter-populated-record-array.ts

@@ -0,0 +1,129 @@
+import type NativeArray from '@ember/array/-private/native-array';
+import { assert } from '@ember/debug';
+
+import type { PromiseArray, RecordArrayManager } from 'ember-data/-private';
+
+import type { CollectionResourceDocument, Links, Meta, PaginationLinks } from '../../ts-interfaces/ember-data-json-api';
+import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
+import type { RecordInstance } from '../../ts-interfaces/record-instance';
+import type { FindOptions } from '../../ts-interfaces/store';
+import type { Dict } from '../../ts-interfaces/utils';
+import type CoreStore from '../core-store';
+import { promiseArray } from '../promise-proxies';
+import SnapshotRecordArray from '../snapshot-record-array';
+import RecordArray from './record-array';
+
+export interface AdapterPopulatedRecordArrayCreateArgs {
+  modelName: string;
+  store: CoreStore;
+  manager: RecordArrayManager;
+  content: NativeArray<StableRecordIdentifier>;
+  isLoaded: boolean;
+  query?: Dict<unknown>;
+  meta?: Meta;
+  links?: Links | PaginationLinks | null;
+}
+
+/**
+  @module @ember-data/store
+*/
+
+/**
+  Represents an ordered list of records whose order and membership is
+  determined by the adapter. For example, a query sent to the adapter
+  may trigger a search on the server, whose results would be loaded
+  into an instance of the `AdapterPopulatedRecordArray`.
+
+  This class should not be imported and instantiated by consuming applications.
+
+  ---
+
+  If you want to update the array and get the latest records from the
+  adapter, you can invoke [`update()`](AdapterPopulatedRecordArray/methods/update?anchor=update):
+
+  Example
+
+  ```javascript
+  // GET /users?isAdmin=true
+  store.query('user', { isAdmin: true }).then(function(admins) {
+
+    admins.then(function() {
+      console.log(admins.get("length")); // 42
+    });
+
+    // somewhere later in the app code, when new admins have been created
+    // in the meantime
+    //
+    // GET /users?isAdmin=true
+    admins.update().then(function() {
+      admins.get('isUpdating'); // false
+      console.log(admins.get("length")); // 123
+    });
+
+    admins.get('isUpdating'); // true
+  }
+  ```
+
+  @class AdapterPopulatedRecordArray
+  @public
+  @extends RecordArray
+*/
+export default class AdapterPopulatedRecordArray extends RecordArray {
+  declare links: Links | PaginationLinks | null;
+  declare meta: Dict<unknown> | null;
+  declare query: Dict<unknown> | null;
+
+  init(props?: AdapterPopulatedRecordArrayCreateArgs) {
+    assert(`Cannot initialize AdapterPopulatedRecordArray with isUpdating`, !props || !('isUpdating' in props));
+    super.init();
+    this.query = this.query || null;
+    this.links = this.links || null;
+    this.meta = this.meta || null;
+  }
+
+  replace() {
+    throw new Error(`The result of a server query (on ${this.modelName}) is immutable.`);
+  }
+
+  _update(): PromiseArray<RecordInstance, AdapterPopulatedRecordArray> {
+    const { store, query } = this;
+
+    // TODO save options from initial request?
+    return promiseArray(store._query(this.modelName, query, this, {}));
+  }
+
+  _setObjects(identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument) {
+    // TODO: initial load should not cause change events at all, only
+    // subsequent. This requires changing the public api of adapter.query, but
+    // hopefully we can do that soon.
+    this.content.setObjects(identifiers);
+
+    this.setProperties({
+      isLoaded: true,
+      isUpdating: false,
+      // TODO this assign kills the root reference but a deep-copy would be required
+      // for both meta and links to actually not be by-ref. We whould likely change
+      // this to a dev-only deep-freeze.
+      meta: Object.assign({}, payload.meta),
+      links: Object.assign({}, payload.links),
+    });
+
+    this.manager._associateWithRecordArray(identifiers, this);
+  }
+
+  _createSnapshot(options: FindOptions) {
+    // this is private for users, but public for ember-data internals
+    // meta will only be present for an AdapterPopulatedRecordArray
+    return new SnapshotRecordArray(this, this.meta, options);
+  }
+
+  /**
+    @method _setIdentifiers
+    @param {StableRecordIdentifier[]} identifiers
+    @param {Object} payload normalized payload
+    @private
+  */
+  _setIdentifiers(identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument): void {
+    this._setObjects(identifiers, payload);
+  }
+}

package/addon/-private/system/record-arrays/{record-array.js → record-array.ts}

@@ -1,19 +1,37 @@
 /**
   @module @ember-data/store
 */
+import type NativeArray from '@ember/array/-private/native-array';
 import ArrayProxy from '@ember/array/proxy';
+import { assert } from '@ember/debug';
 import { computed, get, set } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
 
 import { Promise } from 'rsvp';
 
-import { PromiseArray } from '../promise-proxies';
+import type { RecordArrayManager, Snapshot } from 'ember-data/-private';
+
+import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
+import type { RecordInstance } from '../../ts-interfaces/record-instance';
+import type { FindOptions } from '../../ts-interfaces/store';
+import type CoreStore from '../core-store';
+import type { PromiseArray } from '../promise-proxies';
+import { promiseArray } from '../promise-proxies';
 import SnapshotRecordArray from '../snapshot-record-array';
 import { internalModelFactoryFor } from '../store/internal-model-factory';
 
-function recordForIdentifier(store, identifier) {
+function recordForIdentifier(store: CoreStore, identifier: StableRecordIdentifier): RecordInstance {
   return internalModelFactoryFor(store).lookup(identifier).getRecord();
 }
 
+export interface RecordArrayCreateArgs {
+  modelName: string;
+  store: CoreStore;
+  manager: RecordArrayManager;
+  content: NativeArray<StableRecordIdentifier>;
+  isLoaded: boolean;
+}
+
 /**
   A record array is an array that contains records of a certain modelName. The record
   array materializes records as needed when they are retrieved for the first
@@ -27,24 +45,21 @@ function recordForIdentifier(store, identifier) {
   @public
   @extends Ember.ArrayProxy
 */
+export default class RecordArray extends ArrayProxy<StableRecordIdentifier, RecordInstance> {
+  /**
+    The array of client ids backing the record array. When a
+    record is requested from the record array, the record
+    for the client id at the same index is materialized, if
+    necessary, by the store.
 
-let RecordArray = ArrayProxy.extend({
-  init(args) {
-    this._super(args);
-
-    /**
-      The array of client ids backing the record array. When a
-      record is requested from the record array, the record
-      for the client id at the same index is materialized, if
-      necessary, by the store.
-
-      @property content
-      @private
-      @type Ember.Array
-      */
-    this.set('content', this.content || null);
-
-    /**
+    @property content
+    @private
+    @type Ember.Array
+  */
+  declare content: NativeArray<StableRecordIdentifier>;
+  declare _getDeprecatedEventedInfo: () => string;
+  declare modelName: string;
+  /**
     The flag to signal a `RecordArray` is finished loading data.
 
     Example
@@ -57,42 +72,49 @@ let RecordArray = ArrayProxy.extend({
     @property isLoaded
     @public
     @type Boolean
+  */
+  declare isLoaded: boolean;
+  /**
+    The store that created this record array.
+
+    @property store
+    @private
+    @type Store
     */
-    this.isLoaded = this.isLoaded || false;
-    /**
-    The flag to signal a `RecordArray` is currently loading data.
+  declare store: CoreStore;
+  declare _updatingPromise: PromiseArray<RecordInstance, RecordArray> | null;
+  declare manager: RecordArrayManager;
 
+  /**
+    The flag to signal a `RecordArray` is currently loading data.
     Example
-
     ```javascript
     let people = store.peekAll('person');
     people.get('isUpdating'); // false
     people.update();
     people.get('isUpdating'); // true
     ```
-
     @property isUpdating
     @public
     @type Boolean
-    */
-    this.isUpdating = false;
+  */
+  @tracked isUpdating: boolean = false;
 
-    /**
-    The store that created this record array.
+  init(props?: RecordArrayCreateArgs) {
+    assert(`Cannot initialize RecordArray with isUpdating`, !props || !('isUpdating' in props));
+    assert(`Cannot initialize RecordArray with isUpdating`, !props || !('_updatingPromise' in props));
+    super.init();
 
-    @property store
-    @private
-    @type Store
-    */
-    this.store = this.store || null;
+    // TODO can we get rid of this?
+    this.set('content', this.content || null);
     this._updatingPromise = null;
-  },
+  }
 
   replace() {
     throw new Error(
       `The result of a server query (for all ${this.modelName} types) is immutable. To modify contents, use toArray()`
     );
-  },
+  }
 
   /**
    The modelClass represented by this record array.
@@ -101,12 +123,13 @@ let RecordArray = ArrayProxy.extend({
     @public
    @type {subclass of Model}
    */
-  type: computed('modelName', function () {
+  @computed('modelName')
+  get type() {
     if (!this.modelName) {
       return null;
     }
     return this.store.modelFor(this.modelName);
-  }).readOnly(),
+  }
 
   /**
     Retrieves an object from the content by index.
@@ -116,10 +139,10 @@ let RecordArray = ArrayProxy.extend({
     @param {Number} index
     @return {Model} record
   */
-  objectAtContent(index) {
+  objectAtContent(index: number): RecordInstance | undefined {
     let identifier = get(this, 'content').objectAt(index);
     return identifier ? recordForIdentifier(this.store, identifier) : undefined;
-  },
+  }
 
   /**
     Used to get the latest version of all of the records in this array
@@ -141,33 +164,34 @@ let RecordArray = ArrayProxy.extend({
     @method update
     @public
   */
-  update() {
-    if (get(this, 'isUpdating')) {
-      return this._updatingPromise;
+  update(): PromiseArray<RecordInstance, RecordArray> {
+    if (this.isUpdating) {
+      return this._updatingPromise!;
     }
 
-    this.set('isUpdating', true);
+    this.isUpdating = true;
 
-    let updatingPromise = this._update().finally(() => {
+    let updatingPromise = this._update();
+    updatingPromise.finally(() => {
       this._updatingPromise = null;
-      if (this.get('isDestroying') || this.get('isDestroyed')) {
+      if (this.isDestroying || this.isDestroyed) {
         return;
       }
-      this.set('isUpdating', false);
+      this.isUpdating = false;
     });
 
     this._updatingPromise = updatingPromise;
 
     return updatingPromise;
-  },
+  }
 
   /*
     Update this RecordArray and return a promise which resolves once the update
     is finished.
    */
-  _update() {
+  _update(): PromiseArray<RecordInstance, RecordArray> {
     return this.store.findAll(this.modelName, { reload: true });
-  },
+  }
 
   /**
     Saves all of the records in the `RecordArray`.
@@ -186,7 +210,7 @@ let RecordArray = ArrayProxy.extend({
     @public
     @return {PromiseArray} promise
   */
-  save() {
+  save(): PromiseArray<RecordInstance, RecordArray> {
     let promiseLabel = `DS: RecordArray#save ${this.modelName}`;
     let promise = Promise.all(this.invoke('save'), promiseLabel).then(
       () => this,
@@ -194,8 +218,8 @@ let RecordArray = ArrayProxy.extend({
       'DS: RecordArray#save return RecordArray'
     );
 
-    return PromiseArray.create({ promise });
-  },
+    return promiseArray<RecordInstance, RecordArray>(promise);
+  }
 
   /**
     @method _unregisterFromManager
@@ -203,7 +227,7 @@ let RecordArray = ArrayProxy.extend({
   */
   _unregisterFromManager() {
     this.manager.unregisterRecordArray(this);
-  },
+  }
 
   willDestroy() {
     this._unregisterFromManager();
@@ -215,33 +239,34 @@ let RecordArray = ArrayProxy.extend({
     //   * the exception being: if an dominator has a reference to this object,
     //     and must be informed to release e.g. e.g. removing itself from th
     //     recordArrayMananger
-    set(this, 'content', null);
+    set(this, 'content', null as unknown as NativeArray<StableRecordIdentifier>);
     set(this, 'length', 0);
-    this._super(...arguments);
-  },
+    super.willDestroy();
+  }
 
   /**
     @method _createSnapshot
     @private
   */
-  _createSnapshot(options) {
+  _createSnapshot(options: FindOptions) {
     // this is private for users, but public for ember-data internals
-    return new SnapshotRecordArray(this, this.get('meta'), options);
-  },
+    // meta will only be present for an AdapterPopulatedRecordArray
+    return new SnapshotRecordArray(this, null, options);
+  }
 
   /**
     @method _dissociateFromOwnRecords
     @internal
   */
   _dissociateFromOwnRecords() {
-    this.get('content').forEach((identifier) => {
+    this.content.forEach((identifier) => {
       let recordArrays = this.manager.getRecordArraysForIdentifier(identifier);
 
       if (recordArrays) {
         recordArrays.delete(this);
       }
     });
-  },
+  }
 
   /**
     Adds identifiers to the `RecordArray` without duplicates
@@ -250,9 +275,9 @@ let RecordArray = ArrayProxy.extend({
     @internal
     @param {StableRecordIdentifier[]} identifiers
   */
-  _pushIdentifiers(identifiers) {
-    get(this, 'content').pushObjects(identifiers);
-  },
+  _pushIdentifiers(identifiers: StableRecordIdentifier[]): void {
+    this.content.pushObjects(identifiers);
+  }
 
   /**
     Removes identifiers from the `RecordArray`.
@@ -261,19 +286,15 @@ let RecordArray = ArrayProxy.extend({
     @internal
     @param {StableRecordIdentifier[]} identifiers
   */
-  _removeIdentifiers(identifiers) {
-    get(this, 'content').removeObjects(identifiers);
-  },
+  _removeIdentifiers(identifiers: StableRecordIdentifier[]): void {
+    this.content.removeObjects(identifiers);
+  }
 
   /**
     @method _takeSnapshot
     @internal
   */
-  _takeSnapshot() {
-    return get(this, 'content').map((identifier) =>
-      internalModelFactoryFor(this.store).lookup(identifier).createSnapshot()
-    );
-  },
-});
-
-export default RecordArray;
+  _takeSnapshot(): Snapshot[] {
+    return this.content.map((identifier) => internalModelFactoryFor(this.store).lookup(identifier).createSnapshot());
+  }
+}

package/addon/-private/system/record-data-for.ts

@@ -3,6 +3,7 @@ import { DEBUG } from '@glimmer/env';
 
 import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
 import type { RecordData } from '../ts-interfaces/record-data';
+import type { RecordInstance } from '../ts-interfaces/record-instance';
 import WeakCache from './weak-cache';
 
 /*
@@ -40,6 +41,7 @@ export function removeRecordDataFor(identifier: StableRecordIdentifier): void {
 
 export default function recordDataFor(instance: StableRecordIdentifier): RecordData | null;
 export default function recordDataFor(instance: Instance): RecordData;
+export default function recordDataFor(instance: RecordInstance): RecordData;
 export default function recordDataFor(instance: object): null;
 export default function recordDataFor(instance: Instance | object): RecordData | null {
   if (RecordDataForIdentifierCache.has(instance as StableRecordIdentifier)) {

package/addon/-private/system/references/belongs-to.ts

@@ -8,6 +8,7 @@ import { assertPolymorphicType } from '@ember-data/store/-debug';
 
 import { SingleResourceDocument } from '../../ts-interfaces/ember-data-json-api';
 import { StableRecordIdentifier } from '../../ts-interfaces/identifier';
+import { RecordInstance } from '../../ts-interfaces/record-instance';
 import CoreStore from '../core-store';
 import { NotificationType, unsubscribe } from '../record-notification-manager';
 import { internalModelFactoryFor, recordIdentifierFor } from '../store/internal-model-factory';
@@ -193,7 +194,7 @@ export default class BelongsToReference extends Reference {
    @param {Object|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
-  async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<Object> {
+  async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<RecordInstance> {
     const jsonApiDoc = await resolve(data);
     let record = this.store.push(jsonApiDoc);
 
@@ -267,7 +268,7 @@ export default class BelongsToReference extends Reference {
     @public
    @return {Model} the record in this relationship
    */
-  value(): Object | null {
+  value(): RecordInstance | null {
     let resource = this._resource();
     if (resource && resource.data) {
       let inverseInternalModel = this.store._internalModelForResource(resource.data);

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

@@ -4,6 +4,8 @@ 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';
 
@@ -250,7 +252,7 @@ export default class HasManyReference extends Reference {
    */
   async push(
     objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
-  ): Promise<any> {
+  ): Promise<ManyArray> {
     const payload = await resolve(objectOrPromise);
     let array: Array<ExistingResourceObject | SingleResourceDocument>;
 
@@ -291,7 +293,7 @@ export default class HasManyReference extends Reference {
     });
 
     // TODO IGOR it seems wrong that we were returning the many array here
-    return internalModel.getHasMany(this.key);
+    return internalModel.getHasMany(this.key) as Promise<ManyArray> | ManyArray; // this cast is necessary because typescript does not work properly with custom thenables
   }
 
   _isLoaded() {

package/addon/-private/system/schema-definition-service.ts

@@ -1,7 +1,7 @@
 import { getOwner } from '@ember/application';
 import { get } from '@ember/object';
 
-import require from 'require';
+import { importSync } from '@embroider/macros';
 
 import type Model from '@ember-data/model';
 import { HAS_MODEL_PACKAGE } from '@ember-data/private-build-infra';
@@ -18,7 +18,7 @@ if (HAS_MODEL_PACKAGE) {
   let _found;
   _modelForMixin = function () {
     if (!_found) {
-      _found = require('@ember-data/model/-private')._modelForMixin;
+      _found = (importSync('@ember-data/model/-private') as typeof import('@ember-data/model/-private'))._modelForMixin;
     }
     return _found(...arguments);
   };

package/addon/-private/system/snapshot-record-array.ts

@@ -3,40 +3,41 @@
 */
 
 import type { ModelSchema } from '../ts-interfaces/ds-model';
+import { FindOptions } from '../ts-interfaces/store';
 import type { Dict } from '../ts-interfaces/utils';
 import type RecordArray from './record-arrays/record-array';
 import type Snapshot from './snapshot';
 /**
   SnapshotRecordArray is not directly instantiable.
   Instances are provided to consuming application's
-  adapters for certain requests.  
+  adapters for certain requests.
 
   @class SnapshotRecordArray
   @public
 */
 export default class SnapshotRecordArray {
-  private _snapshots: Snapshot[] | null;
-  private _recordArray: RecordArray | null;
-  private _type: ModelSchema | null;
+  declare _snapshots: Snapshot[] | null;
+  declare _recordArray: RecordArray;
+  declare _type: ModelSchema | null;
 
-  public length: number;
-  public meta?: Dict<any>;
-  public adapterOptions: Dict<any>;
-  public include?: string;
+  declare length: number;
+  declare meta: Dict<unknown> | null;
+  declare adapterOptions?: Dict<unknown>;
+  declare include?: string;
 
   /**
     SnapshotRecordArray is not directly instantiable.
     Instances are provided to consuming application's
-    adapters and serializers for certain requests.  
+    adapters and serializers for certain requests.
 
     @method constructor
     @private
     @constructor
     @param {RecordArray} recordArray
     @param {Object} meta
-    @param options 
+    @param options
    */
-  constructor(recordArray: RecordArray, meta?: Dict<any>, options: Dict<any> = {}) {
+  constructor(recordArray: RecordArray, meta: Dict<unknown> | null, options: FindOptions = {}) {
     /**
       An array of snapshots
       @private

package/addon/-private/system/snapshot.ts

@@ -4,10 +4,19 @@
 import { assert } from '@ember/debug';
 import { get } from '@ember/object';
 
+import { importSync } from '@embroider/macros';
+
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
+import type BelongsToRelationship from '@ember-data/record-data/addon/-private/relationships/state/belongs-to';
+import type ManyRelationship from '@ember-data/record-data/addon/-private/relationships/state/has-many';
+import type {
+  ExistingResourceIdentifierObject,
+  NewResourceIdentifierObject,
+} from '@ember-data/store/-private/ts-interfaces/ember-data-json-api';
 
 import type { DSModel, DSModelSchema, ModelSchema } from '../ts-interfaces/ds-model';
 import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
+import { OptionsHash } from '../ts-interfaces/minimum-serializer-interface';
 import type { ChangedAttributesHash } from '../ts-interfaces/record-data';
 import type { AttributeSchema, RelationshipSchema } from '../ts-interfaces/record-data-schemas';
 import type { RecordInstance } from '../ts-interfaces/record-instance';
@@ -322,9 +331,11 @@ export default class Snapshot implements Snapshot {
       assert(`snapshot.belongsTo only supported when using the package @ember-data/record-data`);
     }
 
-    const graphFor = require('@ember-data/record-data/-private').graphFor;
+    const graphFor = (
+      importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+    ).graphFor;
     const { identifier } = this;
-    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);
+    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName) as BelongsToRelationship;
 
     assert(
       `You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`,
@@ -421,9 +432,11 @@ export default class Snapshot implements Snapshot {
       assert(`snapshot.hasMany only supported when using the package @ember-data/record-data`);
     }
 
-    const graphFor = require('@ember-data/record-data/-private').graphFor;
+    const graphFor = (
+      importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+    ).graphFor;
     const { identifier } = this;
-    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);
+    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName) as ManyRelationship;
     assert(
       `You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`,
       relationship
@@ -441,7 +454,9 @@ export default class Snapshot implements Snapshot {
         let internalModel = store._internalModelForResource(member);
         if (!internalModel.isDeleted()) {
           if (returnModeIsIds) {
-            (results as RecordId[]).push(member.id || null);
+            (results as RecordId[]).push(
+              (member as ExistingResourceIdentifierObject | NewResourceIdentifierObject).id || null
+            );
           } else {
             (results as Snapshot[]).push(internalModel.createSnapshot());
           }
@@ -534,7 +549,9 @@ export default class Snapshot implements Snapshot {
     @return {Object} an object whose values are primitive JSON values only
     @public
    */
-  serialize(options: unknown): unknown {
-    return this._store.serializerFor(this.modelName).serialize(this, options);
+  serialize(options?: OptionsHash): unknown {
+    const serializer = this._store.serializerFor(this.modelName);
+    assert(`Cannot serialize record, no serializer found`, serializer);
+    return serializer.serialize(this, options);
   }
 }