@ember-data/store 4.8.0-alpha.4 → 4.8.0-beta.0

package/addon/-private/store-service.ts

@@ -4,7 +4,6 @@
 import { getOwner, setOwner } from '@ember/application';
 import { assert, deprecate } from '@ember/debug';
 import { _backburner as emberBackburner, run } from '@ember/runloop';
-import type { Backburner } from '@ember/runloop/-private/backburner';
 import Service from '@ember/service';
 import { registerWaiter, unregisterWaiter } from '@ember/test';
 import { DEBUG } from '@glimmer/env';
@@ -12,12 +11,12 @@ import { DEBUG } from '@glimmer/env';
 import { importSync } from '@embroider/macros';
 import { reject, resolve } from 'rsvp';
 
-import { V2CACHE_SINGLETON_RECORD_DATA } from '@ember-data/canary-features';
 import type DSModelClass from '@ember-data/model';
 import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import {
   DEPRECATE_HAS_RECORD,
   DEPRECATE_JSON_API_FALLBACK,
+  DEPRECATE_PROMISE_PROXIES,
   DEPRECATE_STORE_FIND,
   DEPRECATE_V1CACHE_STORE_APIS,
 } from '@ember-data/private-build-infra/deprecations';
@@ -41,7 +40,6 @@ import type { SchemaDefinitionService } from '@ember-data/types/q/schema-definit
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import edBackburner from './backburner';
 import { IdentifierCache } from './caches/identifier-cache';
 import {
   InstanceCache,
@@ -63,9 +61,10 @@ import NotificationManager from './managers/record-notification-manager';
 import FetchManager, { SaveOp } from './network/fetch-manager';
 import { _findAll, _query, _queryRecord } from './network/finders';
 import type RequestCache from './network/request-cache';
+import type Snapshot from './network/snapshot';
+import SnapshotRecordArray from './network/snapshot-record-array';
 import { PromiseArray, promiseArray, PromiseObject, promiseObject } from './proxies/promise-proxies';
-import AdapterPopulatedRecordArray from './record-arrays/adapter-populated-record-array';
-import RecordArray from './record-arrays/record-array';
+import IdentifierArray, { Collection } from './record-arrays/identifier-array';
 import coerceId, { ensureStringId } from './utils/coerce-id';
 import constructResource from './utils/construct-resource';
 import normalizeModelName from './utils/normalize-model-name';
@@ -167,18 +166,7 @@ export interface CreateRecordProperties {
 
 class Store extends Service {
   __private_singleton_recordData!: RecordData;
-  /**
-   * Ember Data uses several specialized micro-queues for organizing
-    and coalescing similar async work.
 
-    These queues are currently controlled by a flush scheduled into
-    ember-data's custom backburner instance.
-   *
-   * EmberData specific backburner instance
-   * @property _backburner
-   * @private
-   */
-  declare _backburner: Backburner;
   declare recordArrayManager: RecordArrayManager;
 
   declare _notificationManager: NotificationManager;
@@ -230,10 +218,6 @@ class Store extends Service {
     this._serializerCache = Object.create(null);
     this._modelFactoryCache = Object.create(null);
 
-    // private
-    // TODO we should find a path to something simpler than backburner
-    this._backburner = edBackburner;
-
     if (DEBUG) {
       if (this.generateStackTracesForTrackedRequests === undefined) {
         this.generateStackTracesForTrackedRequests = false;
@@ -281,6 +265,37 @@ class Store extends Service {
     }
   }
 
+  declare _cbs: { coalesce?: () => void; sync?: () => void; notify?: () => void } | null;
+  _run(cb: () => void) {
+    assert(`EmberData should never encounter a nested run`, !this._cbs);
+    const _cbs: { coalesce?: () => void; sync?: () => void; notify?: () => void } = (this._cbs = {});
+    cb();
+    if (_cbs.coalesce) {
+      _cbs.coalesce();
+    }
+    if (_cbs.sync) {
+      _cbs.sync();
+    }
+    if (_cbs.notify) {
+      _cbs.notify();
+    }
+    this._cbs = null;
+  }
+  _join(cb: () => void): void {
+    if (this._cbs) {
+      cb();
+    } else {
+      this._run(cb);
+    }
+  }
+
+  _schedule(name: 'coalesce' | 'sync' | 'notify', cb: () => void): void {
+    assert(`EmberData expects to schedule only when there is an active run`, !!this._cbs);
+    assert(`EmberData expects only one flush per queue name, cannot schedule ${name}`, !this._cbs[name]);
+
+    this._cbs[name] = cb;
+  }
+
   /**
    * Retrieve the RequestStateService instance
    * associated with this Store.
@@ -321,25 +336,23 @@ class Store extends Service {
   ): DSModel | RecordInstance {
     if (HAS_MODEL_PACKAGE) {
       let modelName = identifier.type;
-      let store = this;
 
       let recordData = this._instanceCache.getRecordData(identifier);
+      // TODO deprecate allowing unknown args setting
       let createOptions: any = {
-        // TODO deprecate allowing unknown args setting
         _createProps: createRecordArgs,
         // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
-        _secretInit: (record: RecordInstance): void => {
-          setRecordIdentifier(record, identifier);
-          StoreMap.set(record, store);
-          setRecordDataFor(record, recordData);
+        _secretInit: {
+          identifier,
+          recordData,
+          store: this,
+          cb: secretInit,
         },
-        container: null, // necessary hack for setOwner?
       };
 
       // ensure that `getOwner(this)` works inside a model instance
       setOwner(createOptions, getOwner(this));
-      delete createOptions.container;
-      return getModelFactory(this, this._modelFactoryCache, modelName).create(createOptions);
+      return getModelFactory(this, this._modelFactoryCache, modelName).class.create(createOptions);
     }
     assert(`You must implement the store's instantiateRecord hook for your custom model class.`);
   }
@@ -394,15 +407,53 @@ class Store extends Service {
    * for use when information about a resource's schema needs
    * to be queried.
    *
-   * This method can only be called once and needs to be called before
-   * `getSchemaDefinitionService` is called when using `@ember-data/model`.
+   * This method can only be called more than once, but only one schema
+   * definition service may exist. Therefore if you wish to chain services
+   * you must lookup the existing service and close over it with the new
+   * service by calling `getSchemaDefinitionService` prior to registration.
+   *
+   * For Example:
+   *
+   * ```ts
+   * import Store from '@ember-data/store';
+   *
+   * class SchemaDelegator {
+   *   constructor(schema) {
+   *     this._schema = schema;
+   *   }
+   *
+   *   doesTypeExist(type: string): boolean {
+   *     if (AbstractSchemas.has(type)) {
+   *       return true;
+   *     }
+   *     return this._schema.doesTypeExist(type);
+   *   }
+   *
+   *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+   *     return this._schema.attributesDefinitionFor(identifier);
+   *   }
+   *
+   *   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+   *     const schema = AbstractSchemas.get(identifier.type);
+   *     return schema || this._schema.relationshipsDefinitionFor(identifier);
+   *   }
+   * }
+   *
+   * export default class extends Store {
+   *   constructor(...args) {
+   *     super(...args);
+   *
+   *     const schema = this.getSchemaDefinitionService();
+   *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
+   *   }
+   * }
+   * ```
    *
    * @method registerSchemaDefinitionService
    * @param {SchemaDefinitionService} schema
    * @public
    */
   registerSchemaDefinitionService(schema: SchemaDefinitionService) {
-    assert(`Cannot register a schema definition service when one already exists`, !this._schemaDefinitionService);
     this._schemaDefinitionService = schema;
   }
 
@@ -508,8 +559,9 @@ class Store extends Service {
     //   of record-arrays via ember's run loop, not our own.
     //
     //   to remove this, we would need to move to a new `async` API.
-    return emberBackburner.join(() => {
-      return this._backburner.join(() => {
+    let record!: RecordInstance;
+    emberBackburner.join(() => {
+      this._join(() => {
         let normalizedModelName = normalizeModelName(modelName);
         let properties = { ...inputProperties };
 
@@ -551,11 +603,12 @@ class Store extends Service {
           (recordData as NonSingletonRecordDataManager).managedVersion === '1'
         );
         const resultProps = recordData.clientDidCreate(identifier, createOptions);
-        this.recordArrayManager.recordDidChange(identifier);
+        this.recordArrayManager.identifierAdded(identifier);
 
-        return this._instanceCache.getRecord(identifier, resultProps);
+        record = this._instanceCache.getRecord(identifier, resultProps);
       });
     });
+    return record;
   }
 
   /**
@@ -583,13 +636,15 @@ class Store extends Service {
     const identifier = peekRecordIdentifier(record);
     const recordData = identifier && this._instanceCache.peek({ identifier, bucket: 'recordData' });
     assert(`expected a recordData instance to exist for the record`, recordData);
-    recordData.setIsDeleted(identifier, true);
+    this._join(() => {
+      recordData.setIsDeleted(identifier, true);
 
-    if (recordData.isNew(identifier)) {
-      run(() => {
-        this._instanceCache.unloadRecord(identifier);
-      });
-    }
+      if (recordData.isNew(identifier)) {
+        run(() => {
+          this._instanceCache.unloadRecord(identifier);
+        });
+      }
+    });
   }
 
   /**
@@ -612,7 +667,7 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'unloadRecord');
     }
-    let identifier = peekRecordIdentifier(record);
+    const identifier = peekRecordIdentifier(record);
     if (identifier) {
       this._instanceCache.unloadRecord(identifier);
     }
@@ -1079,14 +1134,14 @@ class Store extends Service {
       assertIdentifierHasId(identifier);
       promise = this._fetchManager.scheduleFetch(identifier, options);
     } else {
-      let snapshot = this._instanceCache.createSnapshot(identifier, options);
+      let snapshot: Snapshot | null = null;
       let adapter = this.adapterFor(identifier.type);
 
       // Refetch the record if the adapter thinks the record is stale
       if (
         typeof options.reload === 'undefined' &&
         adapter.shouldReloadRecord &&
-        adapter.shouldReloadRecord(this, snapshot)
+        adapter.shouldReloadRecord(this, (snapshot = this._instanceCache.createSnapshot(identifier, options)))
       ) {
         assertIdentifierHasId(identifier);
         promise = this._fetchManager.scheduleFetch(identifier, options);
@@ -1096,7 +1151,10 @@ class Store extends Service {
           options.backgroundReload !== false &&
           (options.backgroundReload ||
             !adapter.shouldBackgroundReloadRecord ||
-            adapter.shouldBackgroundReloadRecord(this, snapshot))
+            adapter.shouldBackgroundReloadRecord(
+              this,
+              (snapshot = snapshot || this._instanceCache.createSnapshot(identifier, options))
+            ))
         ) {
           assertIdentifierHasId(identifier);
           this._fetchManager.scheduleFetch(identifier, options);
@@ -1107,7 +1165,11 @@ class Store extends Service {
       }
     }
 
-    return promiseRecord(this, promise, `DS: Store#findRecord ${identifier}`);
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseRecord(this, promise);
+    }
+
+    return promise.then((identifier: StableRecordIdentifier) => this.peekRecord(identifier));
   }
 
   /**
@@ -1338,8 +1400,8 @@ class Store extends Service {
     decoded: "/api/v1/person?ids[]=1&ids[]=2&ids[]=3"
     ```
 
-    This method returns a promise, which is resolved with an
-    [`AdapterPopulatedRecordArray`](/ember-data/release/classes/AdapterPopulatedRecordArray)
+    This method returns a promise, which is resolved with a
+    [`Collection`](/ember-data/release/classes/Collection)
     once the server returns.
 
     @since 1.13.0
@@ -1350,7 +1412,7 @@ class Store extends Service {
     @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query
     @return {Promise} promise
   */
-  query(modelName: string, query, options): PromiseArray<RecordInstance, AdapterPopulatedRecordArray> {
+  query(modelName: string, query, options): PromiseArray<RecordInstance, Collection> | Promise<Collection> {
     if (DEBUG) {
       assertDestroyingStore(this, 'query');
     }
@@ -1384,9 +1446,12 @@ class Store extends Service {
       query,
       recordArray,
       adapterOptionsWrapper
-    ) as unknown as Promise<AdapterPopulatedRecordArray>;
+    ) as unknown as Promise<Collection>;
 
-    return promiseArray(queryPromise);
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseArray(queryPromise);
+    }
+    return queryPromise;
   }
 
   /**
@@ -1487,7 +1552,11 @@ class Store extends Service {
     @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
     @return {Promise} promise which resolves with the found record or `null`
   */
-  queryRecord(modelName: string, query, options?): PromiseObject<RecordInstance | null> {
+  queryRecord(
+    modelName: string,
+    query,
+    options?
+  ): PromiseObject<RecordInstance | null> | Promise<RecordInstance | null> {
     if (DEBUG) {
       assertDestroyingStore(this, 'queryRecord');
     }
@@ -1520,7 +1589,10 @@ class Store extends Service {
       adapterOptionsWrapper
     ) as Promise<StableRecordIdentifier | null>;
 
-    return promiseObject(promise.then((identifier) => identifier && this.peekRecord(identifier)));
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseObject(promise.then((identifier) => identifier && this.peekRecord(identifier)));
+    }
+    return promise.then((identifier) => identifier && this.peekRecord(identifier));
   }
 
   /**
@@ -1714,7 +1786,7 @@ class Store extends Service {
   findAll(
     modelName: string,
     options: { reload?: boolean; backgroundReload?: boolean } = {}
-  ): PromiseArray<RecordInstance, RecordArray> {
+  ): PromiseArray<RecordInstance, IdentifierArray> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findAll');
     }
@@ -1740,7 +1812,7 @@ class Store extends Service {
       array.isUpdating = true;
       fetch = _findAll(adapter, this, normalizedModelName, options);
     } else {
-      let snapshotArray = array._createSnapshot(options);
+      let snapshotArray = new SnapshotRecordArray(this, array, options);
 
       if (options.reload !== false) {
         if (
@@ -1748,7 +1820,7 @@ class Store extends Service {
           (!adapter.shouldReloadAll && snapshotArray.length === 0)
         ) {
           array.isUpdating = true;
-          fetch = _findAll(adapter, this, modelName, options);
+          fetch = _findAll(adapter, this, modelName, options, snapshotArray);
         }
       }
 
@@ -1761,14 +1833,17 @@ class Store extends Service {
           adapter.shouldBackgroundReloadAll(this, snapshotArray)
         ) {
           array.isUpdating = true;
-          _findAll(adapter, this, modelName, options);
+          _findAll(adapter, this, modelName, options, snapshotArray);
         }
 
         fetch = resolve(array);
       }
     }
 
-    return promiseArray(fetch);
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseArray(fetch);
+    }
+    return fetch;
   }
 
   /**
@@ -1796,7 +1871,7 @@ class Store extends Service {
     @param {String} modelName
     @return {RecordArray}
   */
-  peekAll(modelName) {
+  peekAll(modelName: string): IdentifierArray {
     if (DEBUG) {
       assertDestroyingStore(this, 'peekAll');
     }
@@ -1805,8 +1880,9 @@ class Store extends Service {
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
     );
-    let normalizedModelName = normalizeModelName(modelName);
-    return this.recordArrayManager.liveRecordArrayFor(normalizedModelName);
+
+    let type = normalizeModelName(modelName);
+    return this.recordArrayManager.liveArrayFor(type);
   }
 
   /**
@@ -1833,24 +1909,29 @@ class Store extends Service {
       !modelName || typeof modelName === 'string'
     );
 
-    if (modelName === undefined) {
-      // destroy the graph before unloadAll
-      // since then we avoid churning relationships
-      // during unload
-      if (HAS_RECORD_DATA_PACKAGE) {
-        const peekGraph = (
-          importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-        ).peekGraph;
-        let graph = peekGraph(this);
-        if (graph) {
-          graph.identifiers.clear();
+    this._join(() => {
+      if (modelName === undefined) {
+        // destroy the graph before unloadAll
+        // since then we avoid churning relationships
+        // during unload
+        if (HAS_RECORD_DATA_PACKAGE) {
+          const peekGraph = (
+            importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+          ).peekGraph;
+          let graph = peekGraph(this);
+          if (graph) {
+            graph.identifiers.clear();
+          }
         }
+        this._notificationManager.destroy();
+
+        this.recordArrayManager.clear();
+        this._instanceCache.clear();
+      } else {
+        let normalizedModelName = normalizeModelName(modelName);
+        this._instanceCache.clear(normalizedModelName);
       }
-      this._instanceCache.clear();
-    } else {
-      let normalizedModelName = normalizeModelName(modelName);
-      this._instanceCache.clear(normalizedModelName);
-    }
+    });
   }
 
   /**
@@ -2038,7 +2119,8 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, '_push');
     }
-    let identifiers = this._backburner.join(() => {
+    let ret;
+    this._join(() => {
       let included = jsonApiDoc.included;
       let i, length;
 
@@ -2055,11 +2137,13 @@ class Store extends Service {
         for (i = 0; i < length; i++) {
           identifiers[i] = this._instanceCache.loadData(jsonApiDoc.data[i]);
         }
-        return identifiers;
+        ret = identifiers;
+        return;
       }
 
       if (jsonApiDoc.data === null) {
-        return null;
+        ret = null;
+        return;
       }
 
       assert(
@@ -2069,11 +2153,11 @@ class Store extends Service {
         typeof jsonApiDoc.data === 'object'
       );
 
-      return this._instanceCache.loadData(jsonApiDoc.data);
+      ret = this._instanceCache.loadData(jsonApiDoc.data);
+      return;
     });
 
-    // this typecast is necessary because `backburner.join` is mistyped to return void
-    return identifiers;
+    return ret;
   }
 
   /**
@@ -2228,7 +2312,7 @@ class Store extends Service {
         have an outer run loop available still from the first
         call to `store._push`;
        */
-        this._backburner.join(() => {
+        this._join(() => {
           if (DEBUG) {
             assertDestroyingStore(this, 'saveRecord');
           }
@@ -2250,7 +2334,10 @@ class Store extends Service {
           //We first make sure the primary data has been updated
           const recordData = this._instanceCache.getRecordData(actualIdentifier);
           recordData.didCommit(identifier, data);
-          this.recordArrayManager.recordDidChange(actualIdentifier);
+
+          if (operation === 'deleteRecord') {
+            this.recordArrayManager.identifierRemoved(actualIdentifier);
+          }
 
           if (payload && payload.included) {
             this._push({ data: null, included: payload.included });
@@ -2315,17 +2402,11 @@ class Store extends Service {
         storeWrapper = arguments[3];
       }
 
-      if (V2CACHE_SINGLETON_RECORD_DATA) {
-        // @ts-expect-error
-        this.__private_singleton_recordData = this.__private_singleton_recordData || new _RecordData(storeWrapper);
-        (
-          this.__private_singleton_recordData as RecordData & { createCache(identifier: StableRecordIdentifier): void }
-        ).createCache(identifier);
-        return this.__private_singleton_recordData;
-      }
-
-      // @ts-expect-error
-      return new _RecordData(identifier, storeWrapper);
+      this.__private_singleton_recordData = this.__private_singleton_recordData || new _RecordData(storeWrapper);
+      (
+        this.__private_singleton_recordData as RecordData & { createCache(identifier: StableRecordIdentifier): void }
+      ).createCache(identifier);
+      return this.__private_singleton_recordData;
     }
 
     assert(`Expected store.createRecordDataFor to be implemented but it wasn't`);
@@ -2532,16 +2613,6 @@ class Store extends Service {
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
 
-    if (HAS_RECORD_DATA_PACKAGE) {
-      const peekGraph = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).peekGraph;
-      let graph = peekGraph(this);
-      if (graph) {
-        graph.willDestroy();
-      }
-    }
-
     this.unloadAll();
 
     if (DEBUG) {
@@ -2758,12 +2829,25 @@ function extractIdentifierFromRecord(
   }
   const extract = isForV1 ? recordDataFor : recordIdentifierFor;
 
-  if (isPromiseRecord(recordOrPromiseRecord)) {
+  if (DEPRECATE_PROMISE_PROXIES && isPromiseRecord(recordOrPromiseRecord)) {
     let content = recordOrPromiseRecord.content;
     assert(
       'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.',
       content !== undefined
     );
+    deprecate(
+      `You passed in a PromiseProxy to a Relationship API that now expects a resolved value. await the value before setting it.`,
+      false,
+      {
+        id: 'ember-data:deprecate-promise-proxies',
+        until: '5.0',
+        since: {
+          enabled: '4.8',
+          available: '4.8',
+        },
+        for: 'ember-data',
+      }
+    );
     return content ? extract(content) : null;
   }
 
@@ -2773,3 +2857,14 @@ function extractIdentifierFromRecord(
 function isPromiseRecord(record: PromiseProxyRecord | RecordInstance): record is PromiseProxyRecord {
   return !!record.then;
 }
+
+function secretInit(
+  record: RecordInstance,
+  recordData: RecordData,
+  identifier: StableRecordIdentifier,
+  store: Store
+): void {
+  setRecordIdentifier(record, identifier);
+  StoreMap.set(record, store);
+  setRecordDataFor(record, recordData);
+}

package/addon/-private/utils/is-non-empty-string.ts

@@ -1,3 +1,3 @@
 export default function isNonEmptyString(str: any): str is string {
-  return typeof str === 'string' && str.length > 0;
+  return str && typeof str === 'string';
 }

package/addon/-private/utils/promise-record.ts

@@ -7,10 +7,9 @@ import type Store from '../store-service';
 
 export default function promiseRecord(
   store: Store,
-  promise: Promise<StableRecordIdentifier>,
-  label?: string
+  promise: Promise<StableRecordIdentifier>
 ): PromiseObject<RecordInstance> {
   let toReturn = promise.then((identifier: StableRecordIdentifier) => store.peekRecord(identifier)!);
 
-  return promiseObject(toReturn, label);
+  return promiseObject(toReturn);
 }