@ember-data/store 4.4.0-alpha.9 → 4.4.1

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

@@ -0,0 +1,95 @@
+import { A } from '@ember/array';
+import { get } from '@ember/object';
+
+import RecordArray from './record-array';
+
+/**
+  @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 RecordArray.extend({
+  init() {
+    this.set('content', this.get('content') || A());
+
+    this._super(...arguments);
+    this.query = this.query || null;
+    this.links = this.links || null;
+  },
+
+  replace() {
+    throw new Error(`The result of a server query (on ${this.modelName}) is immutable.`);
+  },
+
+  _update() {
+    let store = get(this, 'store');
+    let query = get(this, 'query');
+
+    return store._query(this.modelName, query, this);
+  },
+
+  _setObjects(identifiersOrInternalModels, payload) {
+    // 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.get('content').setObjects(identifiersOrInternalModels);
+
+    this.setProperties({
+      isLoaded: true,
+      isUpdating: false,
+      meta: { ...payload.meta },
+      links: { ...payload.links },
+    });
+
+    this.manager._associateWithRecordArray(identifiersOrInternalModels, this);
+  },
+
+  /**
+    @method _setIdentifiers
+    @param {StableRecordIdentifier[]} identifiers
+    @param {Object} payload normalized payload
+    @private
+  */
+  _setIdentifiers(identifiers, payload) {
+    this._setObjects(identifiers, payload);
+  },
+});

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

@@ -1,37 +1,19 @@
 /**
   @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 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 { PromiseArray } from '../promise-proxies';
 import SnapshotRecordArray from '../snapshot-record-array';
 import { internalModelFactoryFor } from '../store/internal-model-factory';
 
-function recordForIdentifier(store: CoreStore, identifier: StableRecordIdentifier): RecordInstance {
+function recordForIdentifier(store, identifier) {
   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
@@ -45,21 +27,24 @@ export interface RecordArrayCreateArgs {
   @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.
 
-    @property content
-    @private
-    @type Ember.Array
-  */
-  declare content: NativeArray<StableRecordIdentifier>;
-  declare _getDeprecatedEventedInfo: () => string;
-  declare modelName: string;
-  /**
+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);
+
+    /**
     The flag to signal a `RecordArray` is finished loading data.
 
     Example
@@ -72,49 +57,42 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @property isLoaded
     @public
     @type Boolean
-  */
-  declare isLoaded: boolean;
-  /**
-    The store that created this record array.
-
-    @property store
-    @private
-    @type Store
     */
-  declare store: CoreStore;
-  declare _updatingPromise: PromiseArray<RecordInstance, RecordArray> | null;
-  declare manager: RecordArrayManager;
-
-  /**
+    this.isLoaded = this.isLoaded || false;
+    /**
     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
-  */
-  @tracked isUpdating: boolean = false;
+    */
+    this.isUpdating = false;
 
-  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();
+    /**
+    The store that created this record array.
 
-    // TODO can we get rid of this?
-    this.set('content', this.content || null);
+    @property store
+    @private
+    @type Store
+    */
+    this.store = this.store || 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.
@@ -123,13 +101,12 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @public
    @type {subclass of Model}
    */
-  @computed('modelName')
-  get type() {
+  type: computed('modelName', function () {
     if (!this.modelName) {
       return null;
     }
     return this.store.modelFor(this.modelName);
-  }
+  }).readOnly(),
 
   /**
     Retrieves an object from the content by index.
@@ -139,10 +116,10 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @param {Number} index
     @return {Model} record
   */
-  objectAtContent(index: number): RecordInstance | undefined {
+  objectAtContent(index) {
     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
@@ -164,34 +141,33 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @method update
     @public
   */
-  update(): PromiseArray<RecordInstance, RecordArray> {
-    if (this.isUpdating) {
-      return this._updatingPromise!;
+  update() {
+    if (get(this, 'isUpdating')) {
+      return this._updatingPromise;
     }
 
-    this.isUpdating = true;
+    this.set('isUpdating', true);
 
-    let updatingPromise = this._update();
-    updatingPromise.finally(() => {
+    let updatingPromise = this._update().finally(() => {
       this._updatingPromise = null;
-      if (this.isDestroying || this.isDestroyed) {
+      if (this.get('isDestroying') || this.get('isDestroyed')) {
         return;
       }
-      this.isUpdating = false;
+      this.set('isUpdating', false);
     });
 
     this._updatingPromise = updatingPromise;
 
     return updatingPromise;
-  }
+  },
 
   /*
     Update this RecordArray and return a promise which resolves once the update
     is finished.
    */
-  _update(): PromiseArray<RecordInstance, RecordArray> {
+  _update() {
     return this.store.findAll(this.modelName, { reload: true });
-  }
+  },
 
   /**
     Saves all of the records in the `RecordArray`.
@@ -210,7 +186,7 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @public
     @return {PromiseArray} promise
   */
-  save(): PromiseArray<RecordInstance, RecordArray> {
+  save() {
     let promiseLabel = `DS: RecordArray#save ${this.modelName}`;
     let promise = Promise.all(this.invoke('save'), promiseLabel).then(
       () => this,
@@ -218,8 +194,8 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
       'DS: RecordArray#save return RecordArray'
     );
 
-    return promiseArray<RecordInstance, RecordArray>(promise);
-  }
+    return PromiseArray.create({ promise });
+  },
 
   /**
     @method _unregisterFromManager
@@ -227,7 +203,7 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
   */
   _unregisterFromManager() {
     this.manager.unregisterRecordArray(this);
-  }
+  },
 
   willDestroy() {
     this._unregisterFromManager();
@@ -239,34 +215,33 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     //   * 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 as unknown as NativeArray<StableRecordIdentifier>);
+    set(this, 'content', null);
     set(this, 'length', 0);
-    super.willDestroy();
-  }
+    this._super(...arguments);
+  },
 
   /**
     @method _createSnapshot
     @private
   */
-  _createSnapshot(options: FindOptions) {
+  _createSnapshot(options) {
     // this is private for users, but public for ember-data internals
-    // meta will only be present for an AdapterPopulatedRecordArray
-    return new SnapshotRecordArray(this, null, options);
-  }
+    return new SnapshotRecordArray(this, this.get('meta'), options);
+  },
 
   /**
     @method _dissociateFromOwnRecords
     @internal
   */
   _dissociateFromOwnRecords() {
-    this.content.forEach((identifier) => {
+    this.get('content').forEach((identifier) => {
       let recordArrays = this.manager.getRecordArraysForIdentifier(identifier);
 
       if (recordArrays) {
         recordArrays.delete(this);
       }
     });
-  }
+  },
 
   /**
     Adds identifiers to the `RecordArray` without duplicates
@@ -275,9 +250,9 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @internal
     @param {StableRecordIdentifier[]} identifiers
   */
-  _pushIdentifiers(identifiers: StableRecordIdentifier[]): void {
-    this.content.pushObjects(identifiers);
-  }
+  _pushIdentifiers(identifiers) {
+    get(this, 'content').pushObjects(identifiers);
+  },
 
   /**
     Removes identifiers from the `RecordArray`.
@@ -286,15 +261,19 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @internal
     @param {StableRecordIdentifier[]} identifiers
   */
-  _removeIdentifiers(identifiers: StableRecordIdentifier[]): void {
-    this.content.removeObjects(identifiers);
-  }
+  _removeIdentifiers(identifiers) {
+    get(this, 'content').removeObjects(identifiers);
+  },
 
   /**
     @method _takeSnapshot
     @internal
   */
-  _takeSnapshot(): Snapshot[] {
-    return this.content.map((identifier) => internalModelFactoryFor(this.store).lookup(identifier).createSnapshot());
-  }
-}
+  _takeSnapshot() {
+    return get(this, 'content').map((identifier) =>
+      internalModelFactoryFor(this.store).lookup(identifier).createSnapshot()
+    );
+  },
+});
+
+export default RecordArray;

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

@@ -3,7 +3,6 @@ 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';
 
 /*
@@ -41,7 +40,6 @@ 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,7 +8,6 @@ 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';
@@ -194,7 +193,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<RecordInstance> {
+  async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<Object> {
     const jsonApiDoc = await resolve(data);
     let record = this.store.push(jsonApiDoc);
 
@@ -268,7 +267,7 @@ export default class BelongsToReference extends Reference {
     @public
    @return {Model} the record in this relationship
    */
-  value(): RecordInstance | null {
+  value(): Object | 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,8 +4,6 @@ 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';
 
@@ -252,7 +250,7 @@ export default class HasManyReference extends Reference {
    */
   async push(
     objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
-  ): Promise<ManyArray> {
+  ): Promise<any> {
     const payload = await resolve(objectOrPromise);
     let array: Array<ExistingResourceObject | SingleResourceDocument>;
 
@@ -293,7 +291,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) as Promise<ManyArray> | ManyArray; // this cast is necessary because typescript does not work properly with custom thenables
+    return internalModel.getHasMany(this.key);
   }
 
   _isLoaded() {

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

@@ -1,7 +1,7 @@
 import { getOwner } from '@ember/application';
 import { get } from '@ember/object';
 
-import { importSync } from '@embroider/macros';
+import require from 'require';
 
 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 = (importSync('@ember-data/model/-private') as typeof import('@ember-data/model/-private'))._modelForMixin;
+      _found = require('@ember-data/model/-private')._modelForMixin;
     }
     return _found(...arguments);
   };

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

@@ -3,41 +3,40 @@
 */
 
 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 {
-  declare _snapshots: Snapshot[] | null;
-  declare _recordArray: RecordArray;
-  declare _type: ModelSchema | null;
+  private _snapshots: Snapshot[] | null;
+  private _recordArray: RecordArray | null;
+  private _type: ModelSchema | null;
 
-  declare length: number;
-  declare meta: Dict<unknown> | null;
-  declare adapterOptions?: Dict<unknown>;
-  declare include?: string;
+  public length: number;
+  public meta?: Dict<any>;
+  public adapterOptions: Dict<any>;
+  public 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<unknown> | null, options: FindOptions = {}) {
+  constructor(recordArray: RecordArray, meta?: Dict<any>, options: Dict<any> = {}) {
     /**
       An array of snapshots
       @private

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

@@ -4,19 +4,10 @@
 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';
@@ -331,11 +322,9 @@ export default class Snapshot implements Snapshot {
       assert(`snapshot.belongsTo only supported when using the package @ember-data/record-data`);
     }
 
-    const graphFor = (
-      importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-    ).graphFor;
+    const graphFor = require('@ember-data/record-data/-private').graphFor;
     const { identifier } = this;
-    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName) as BelongsToRelationship;
+    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);
 
     assert(
       `You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`,
@@ -432,11 +421,9 @@ export default class Snapshot implements Snapshot {
       assert(`snapshot.hasMany only supported when using the package @ember-data/record-data`);
     }
 
-    const graphFor = (
-      importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-    ).graphFor;
+    const graphFor = require('@ember-data/record-data/-private').graphFor;
     const { identifier } = this;
-    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName) as ManyRelationship;
+    const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);
     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
@@ -454,9 +441,7 @@ export default class Snapshot implements Snapshot {
         let internalModel = store._internalModelForResource(member);
         if (!internalModel.isDeleted()) {
           if (returnModeIsIds) {
-            (results as RecordId[]).push(
-              (member as ExistingResourceIdentifierObject | NewResourceIdentifierObject).id || null
-            );
+            (results as RecordId[]).push(member.id || null);
           } else {
             (results as Snapshot[]).push(internalModel.createSnapshot());
           }
@@ -549,9 +534,7 @@ export default class Snapshot implements Snapshot {
     @return {Object} an object whose values are primitive JSON values only
     @public
    */
-  serialize(options?: OptionsHash): unknown {
-    const serializer = this._store.serializerFor(this.modelName);
-    assert(`Cannot serialize record, no serializer found`, serializer);
-    return serializer.serialize(this, options);
+  serialize(options: unknown): unknown {
+    return this._store.serializerFor(this.modelName).serialize(this, options);
   }
 }

package/addon/-private/system/store/common.js

@@ -1,11 +1,8 @@
-import { deprecate } from '@ember/debug';
 import { get } from '@ember/object';
 import { DEBUG } from '@glimmer/env';
 
 import { resolve } from 'rsvp';
 
-import { DEPRECATE_RSVP_PROMISE } from '@ember-data/private-build-infra/deprecations';
-
 /**
   @module @ember-data/store
 */
@@ -35,27 +32,7 @@ export function guardDestroyedStore(promise, store, label) {
   if (DEBUG) {
     token = store._trackAsyncRequestStart(label);
   }
-  let wrapperPromise = resolve(promise, label).then((_v) => {
-    if (!_objectIsAlive(store)) {
-      if (DEPRECATE_RSVP_PROMISE) {
-        deprecate(
-          `A Promise did not resolve by the time the store was destroyed. This will error in a future release.`,
-          false,
-          {
-            id: 'ember-data:rsvp-unresolved-async',
-            until: '5.0',
-            for: '@ember-data/store',
-            since: {
-              available: '4.5',
-              enabled: '4.5',
-            },
-          }
-        );
-      }
-    }
-
-    return promise;
-  });
+  let wrapperPromise = resolve(promise, label).then((v) => promise);
 
   return _guard(wrapperPromise, () => {
     if (DEBUG) {