@ember-data/store 4.6.1 → 4.7.0

package/addon/-private/{request-cache.ts → network/request-cache.ts}

@@ -5,7 +5,7 @@ import type {
   RequestState,
   SaveRecordMutation,
 } from '@ember-data/types/q/fetch-manager';
-import type { RecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordIdentifier, StableRecordIdentifier } from '@ember-data/types/q/identifier';
 
 const Touching: unique symbol = Symbol('touching');
 export const RequestPromise: unique symbol = Symbol('promise');
@@ -23,7 +23,7 @@ function hasRecordIdentifier(op: Operation): op is RecordOperation {
 
 export default class RequestCache {
   _pending: { [lid: string]: InternalRequest[] } = Object.create(null);
-  _done: { [lid: string]: InternalRequest[] } = Object.create(null);
+  _done: Map<StableRecordIdentifier, InternalRequest[]> = new Map();
   _subscriptions: { [lid: string]: Function[] } = Object.create(null);
 
   enqueue(promise: Promise<any>, queryRequest: Request) {
@@ -62,7 +62,7 @@ export default class RequestCache {
             state: 'rejected',
             request: queryRequest,
             type,
-            response: { data: error && error.error },
+            response: { data: error },
           } as InternalRequest;
           finalizedRequest[Touching] = request[Touching];
           this._addDone(finalizedRequest);
@@ -86,22 +86,25 @@ export default class RequestCache {
 
   _addDone(request: InternalRequest) {
     request[Touching].forEach((identifier) => {
-      if (!this._done[identifier.lid]) {
-        this._done[identifier.lid] = [];
-      }
       // TODO add support for multiple
       let requestDataOp = request.request.data[0].op;
-      this._done[identifier.lid] = this._done[identifier.lid].filter((req) => {
-        // TODO add support for multiple
-        let data;
-        if (req.request.data instanceof Array) {
-          data = req.request.data[0];
-        } else {
-          data = req.request.data;
-        }
-        return data.op !== requestDataOp;
-      });
-      this._done[identifier.lid].push(request);
+      let requests = this._done.get(identifier);
+
+      if (requests) {
+        requests = requests.filter((req) => {
+          // TODO add support for multiple
+          let data;
+          if (req.request.data instanceof Array) {
+            data = req.request.data[0];
+          } else {
+            data = req.request.data;
+          }
+          return data.op !== requestDataOp;
+        });
+      }
+      requests = requests || [];
+      requests.push(request);
+      this._done.set(identifier, requests);
     });
   }
 
@@ -120,7 +123,7 @@ export default class RequestCache {
   }
 
   getLastRequestForRecord(identifier: RecordIdentifier): RequestState | null {
-    let requests = this._done[identifier.lid];
+    let requests = this._done.get(identifier);
     if (requests) {
       return requests[requests.length - 1];
     }

package/addon/-private/{snapshot-record-array.ts → network/snapshot-record-array.ts}

@@ -6,10 +6,13 @@ import { deprecate } from '@ember/debug';
 
 import { DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS } from '@ember-data/private-build-infra/deprecations';
 import type { ModelSchema } from '@ember-data/types/q/ds-model';
+import { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import type RecordArray from './record-arrays/record-array';
+import type IdentifierArray from '../record-arrays/identifier-array';
+import { SOURCE } from '../record-arrays/identifier-array';
+import Store from '../store-service';
 import type Snapshot from './snapshot';
 /**
   SnapshotRecordArray is not directly instantiable.
@@ -21,11 +24,11 @@ import type Snapshot from './snapshot';
 */
 export default class SnapshotRecordArray {
   declare _snapshots: Snapshot[] | null;
-  declare _recordArray: RecordArray;
+  declare _recordArray: IdentifierArray;
   declare _type: ModelSchema | null;
+  declare __store: Store;
 
   declare length: number;
-  declare meta: Dict<unknown> | null;
   declare adapterOptions?: Dict<unknown>;
   declare include?: string;
 
@@ -38,10 +41,10 @@ export default class SnapshotRecordArray {
     @private
     @constructor
     @param {RecordArray} recordArray
-    @param {Object} meta
     @param options
    */
-  constructor(recordArray: RecordArray, meta: Dict<unknown> | null, options: FindOptions = {}) {
+  constructor(store: Store, recordArray: IdentifierArray, options: FindOptions = {}) {
+    this.__store = store;
     /**
       An array of snapshots
       @private
@@ -77,30 +80,7 @@ export default class SnapshotRecordArray {
       @public
       @type {Number}
     */
-    this.length = recordArray.get('length');
-
-    /**
-      Meta objects for the record array.
-
-      Example
-
-      ```app/adapters/post.js
-      import JSONAPIAdapter from '@ember-data/adapter/json-api';
-
-      export default class PostAdapter extends JSONAPIAdapter {
-        shouldReloadAll(store, snapshotRecordArray) {
-          let lastRequestTime = snapshotRecordArray.meta.lastRequestTime;
-          let twentyMinutes = 20 * 60 * 1000;
-          return Date.now() > lastRequestTime + twentyMinutes;
-        }
-      });
-      ```
-
-      @property meta
-      @public
-      @type {Object}
-    */
-    this.meta = meta;
+    this.length = recordArray.length as unknown as number; // deal with computedProperty shennanigans
 
     /**
       A hash of adapter options passed into the store method for this request.
@@ -201,7 +181,10 @@ export default class SnapshotRecordArray {
       return this._snapshots;
     }
 
-    this._snapshots = this._recordArray._takeSnapshot();
+    const { _instanceCache } = this.__store;
+    this._snapshots = this._recordArray[SOURCE].map((identifier: StableRecordIdentifier) =>
+      _instanceCache.createSnapshot(identifier)
+    );
 
     return this._snapshots;
   }
@@ -220,7 +203,7 @@ if (DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS) {
           since: { available: '4.5.0', enabled: '4.5.0' },
         }
       );
-      return this._recordArray.get('type');
+      return this._recordArray.type;
     },
   });
 }

package/addon/-private/{snapshot.ts → network/snapshot.ts}

@@ -2,7 +2,6 @@
   @module @ember-data/store
 */
 import { assert, deprecate } from '@ember/debug';
-import { get } from '@ember/object';
 
 import { importSync } from '@embroider/macros';
 
@@ -10,11 +9,6 @@ import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import { DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS } from '@ember-data/private-build-infra/deprecations';
 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 { DSModel, DSModelSchema, ModelSchema } from '@ember-data/types/q/ds-model';
-import type {
-  ExistingResourceIdentifierObject,
-  NewResourceIdentifierObject,
-} from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { OptionsHash } from '@ember-data/types/q/minimum-serializer-interface';
 import type { ChangedAttributesHash } from '@ember-data/types/q/record-data';
@@ -23,15 +17,10 @@ import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import type Store from './core-store';
-import type InternalModel from './model/internal-model';
+import type Store from '../store-service';
 
 type RecordId = string | null;
 
-function schemaIsDSModel(schema: ModelSchema | DSModelSchema): schema is DSModelSchema {
-  return (schema as DSModelSchema).isModel === true;
-}
-
 /**
   Snapshot is not directly instantiable.
   Instances are provided to a consuming application's
@@ -41,12 +30,11 @@ function schemaIsDSModel(schema: ModelSchema | DSModelSchema): schema is DSModel
   @public
 */
 export default class Snapshot implements Snapshot {
-  private __attributes: Dict<unknown> | null = null;
-  private _belongsToRelationships: Dict<Snapshot> = Object.create(null);
-  private _belongsToIds: Dict<RecordId> = Object.create(null);
-  private _hasManyRelationships: Dict<Snapshot[]> = Object.create(null);
-  private _hasManyIds: Dict<RecordId[]> = Object.create(null);
-  declare _internalModel: InternalModel;
+  declare __attributes: Dict<unknown> | null;
+  declare _belongsToRelationships: Dict<Snapshot>;
+  declare _belongsToIds: Dict<RecordId>;
+  declare _hasManyRelationships: Dict<Snapshot[]>;
+  declare _hasManyIds: Dict<RecordId[]>;
   declare _changedAttributes: ChangedAttributesHash;
 
   declare identifier: StableRecordIdentifier;
@@ -54,6 +42,7 @@ export default class Snapshot implements Snapshot {
   declare id: string | null;
   declare include?: unknown;
   declare adapterOptions?: Dict<unknown>;
+  declare _store: Store;
 
   /**
    * @method constructor
@@ -63,8 +52,16 @@ export default class Snapshot implements Snapshot {
    * @param identifier
    * @param _store
    */
-  constructor(options: FindOptions, identifier: StableRecordIdentifier, private _store: Store) {
-    let internalModel = (this._internalModel = _store._instanceCache._internalModelForResource(identifier));
+  constructor(options: FindOptions, identifier: StableRecordIdentifier, store: Store) {
+    this._store = store;
+
+    this.__attributes = null;
+    this._belongsToRelationships = Object.create(null);
+    this._belongsToIds = Object.create(null);
+    this._hasManyRelationships = Object.create(null);
+    this._hasManyIds = Object.create(null);
+
+    const hasRecord = !!store._instanceCache.peek({ identifier, bucket: 'record' });
     this.modelName = identifier.type;
 
     /**
@@ -83,7 +80,7 @@ export default class Snapshot implements Snapshot {
       in time" in which a snapshot is created, we greedily grab
       the values.
      */
-    if (internalModel.hasRecord) {
+    if (hasRecord) {
       this._attributes;
     }
 
@@ -129,8 +126,8 @@ export default class Snapshot implements Snapshot {
      @public
      */
     this.modelName = identifier.type;
-    if (internalModel.hasRecord) {
-      this._changedAttributes = this._store._instanceCache.getRecordData(identifier).changedAttributes();
+    if (hasRecord) {
+      this._changedAttributes = this._store._instanceCache.getRecordData(identifier).changedAttrs(identifier);
     }
   }
 
@@ -156,17 +153,13 @@ export default class Snapshot implements Snapshot {
     if (this.__attributes !== null) {
       return this.__attributes;
     }
-    let record = this.record;
     let attributes = (this.__attributes = Object.create(null));
-    let attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(this.identifier));
-    let recordData = this._store._instanceCache.getRecordData(this.identifier);
+    const { identifier } = this;
+    let attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
+    let recordData = this._store._instanceCache.getRecordData(identifier);
+
     attrs.forEach((keyName) => {
-      if (schemaIsDSModel(this._internalModel.modelClass)) {
-        // if the schema is for a DSModel then the instance is too
-        attributes[keyName] = get(record as DSModel, keyName);
-      } else {
-        attributes[keyName] = recordData.getAttr(keyName);
-      }
+      attributes[keyName] = recordData.getAttr(identifier, keyName);
     });
 
     return attributes;
@@ -182,7 +175,8 @@ export default class Snapshot implements Snapshot {
    */
 
   get isNew(): boolean {
-    return this._internalModel.isNew();
+    const recordData = this._store._instanceCache.peek({ identifier: this.identifier, bucket: 'recordData' });
+    return recordData?.isNew(this.identifier) || false;
   }
 
   /**
@@ -297,9 +291,8 @@ export default class Snapshot implements Snapshot {
    */
   belongsTo(keyName: string, options?: { id?: boolean }): Snapshot | RecordId | undefined {
     let returnModeIsId = !!(options && options.id);
-    let inverseInternalModel: InternalModel | null;
     let result: Snapshot | RecordId | undefined;
-    let store = this._internalModel.store;
+    let store = this._store;
 
     if (returnModeIsId === true && keyName in this._belongsToIds) {
       return this._belongsToIds[keyName];
@@ -319,7 +312,7 @@ export default class Snapshot implements Snapshot {
 
     // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
     // this check is not a regression in behavior because relationships don't currently
-    // function without access to intimate API contracts between RecordData and InternalModel.
+    // function without access to intimate API contracts between RecordData and Model.
     // This is a requirement we should fix as soon as the relationship layer does not require
     // this intimate API usage.
     if (!HAS_RECORD_DATA_PACKAGE) {
@@ -344,14 +337,14 @@ export default class Snapshot implements Snapshot {
     let value = relationship.getData();
     let data = value && value.data;
 
-    inverseInternalModel = data ? store._instanceCache._internalModelForResource(data) : null;
+    let inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
 
     if (value && value.data !== undefined) {
-      if (inverseInternalModel && !inverseInternalModel.isDeleted()) {
+      if (inverseIdentifier && !store._instanceCache.getRecordData(inverseIdentifier).isDeleted(inverseIdentifier)) {
         if (returnModeIsId) {
-          result = inverseInternalModel.id;
+          result = inverseIdentifier.id;
         } else {
-          result = store._instanceCache.createSnapshot(inverseInternalModel.identifier);
+          result = store._instanceCache.createSnapshot(inverseIdentifier);
         }
       } else {
         result = null;
@@ -411,7 +404,7 @@ export default class Snapshot implements Snapshot {
       return cachedSnapshots;
     }
 
-    let store = this._internalModel.store;
+    let store = this._store;
     let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({ type: this.modelName })[
       keyName
     ];
@@ -422,7 +415,7 @@ export default class Snapshot implements Snapshot {
 
     // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
     // this check is not a regression in behavior because relationships don't currently
-    // function without access to intimate API contracts between RecordData and InternalModel.
+    // function without access to intimate API contracts between RecordData and Model.
     // This is a requirement we should fix as soon as the relationship layer does not require
     // this intimate API usage.
     if (!HAS_RECORD_DATA_PACKAGE) {
@@ -448,14 +441,12 @@ export default class Snapshot implements Snapshot {
     if (value.data) {
       results = [];
       value.data.forEach((member) => {
-        let internalModel = store._instanceCache._internalModelForResource(member);
-        if (!internalModel.isDeleted()) {
+        let inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
+        if (!store._instanceCache.getRecordData(inverseIdentifier).isDeleted(inverseIdentifier)) {
           if (returnModeIsIds) {
-            (results as RecordId[]).push(
-              (member as ExistingResourceIdentifierObject | NewResourceIdentifierObject).id || null
-            );
+            (results as RecordId[]).push(inverseIdentifier.id);
           } else {
-            (results as Snapshot[]).push(store._instanceCache.createSnapshot(internalModel.identifier));
+            (results as Snapshot[]).push(store._instanceCache.createSnapshot(inverseIdentifier));
           }
         }
       });
@@ -566,7 +557,7 @@ if (DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS) {
           since: { available: '4.5.0', enabled: '4.5.0' },
         }
       );
-      return this._internalModel.modelClass;
+      return this._store.modelFor(this.identifier.type);
     },
   });
 }

package/addon/-private/{promise-proxies.ts → proxies/promise-proxies.ts}

@@ -31,10 +31,10 @@ import { PromiseArrayProxy, PromiseObjectProxy } from './promise-proxy-base';
     promise: $.getJSON('/some/remote/data.json')
   });
 
-  promiseArray.get('length'); // 0
+  promiseArray.length; // 0
 
   promiseArray.then(function() {
-    promiseArray.get('length'); // 100
+    promiseArray.length; // 100
   });
   ```
 
@@ -77,10 +77,10 @@ export class PromiseArray<I, T extends EmberArrayLike<I>> extends PromiseArrayPr
     promise: $.getJSON('/some/remote/data.json')
   });
 
-  promiseObject.get('name'); // null
+  promiseObject.name; // null
 
   promiseObject.then(function() {
-    promiseObject.get('name'); // 'Tomster'
+    promiseObject.name; // 'Tomster'
   });
   ```
 
@@ -91,13 +91,13 @@ export class PromiseArray<I, T extends EmberArrayLike<I>> extends PromiseArrayPr
 */
 export { PromiseObjectProxy as PromiseObject };
 
-export function promiseObject<T>(promise: Promise<T>, label?: string): PromiseObjectProxy<T> {
+function _promiseObject<T>(promise: Promise<T>, label?: string): PromiseObjectProxy<T> {
   return PromiseObjectProxy.create({
     promise: resolve(promise, label),
   }) as PromiseObjectProxy<T>;
 }
 
-export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>, label?: string): PromiseArray<I, T> {
+function _promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>, label?: string): PromiseArray<I, T> {
   return PromiseArray.create({
     promise: resolve(promise, label),
   }) as unknown as PromiseArray<I, T>;
@@ -105,35 +105,96 @@ export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>
 
 // constructor is accessed in some internals but not including it in the copyright for the deprecation
 const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
+const PROXIED_ARRAY_PROPS = [
+  'length',
+  '[]',
+  'firstObject',
+  'lastObject',
+  'meta',
+  'content',
+  'isPending',
+  'isSettled',
+  'isRejected',
+  'isFulfilled',
+  'promise',
+  'reason',
+];
+const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
+
+export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>): PromiseArray<I, T> {
+  const promiseObjectProxy: PromiseArray<I, T> = _promiseArray(promise);
+  const handler = {
+    get(target: object, prop: string, receiver?: object): unknown {
+      if (typeof prop === 'symbol') {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (!ALLOWABLE_METHODS.includes(prop)) {
+        deprecate(
+          `Accessing ${prop} on this PromiseArray is deprecated. The return type is being changed from PromiseArray to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
+          false,
+          {
+            id: 'ember-data:deprecate-promise-proxies',
+            until: '5.0',
+            for: '@ember-data/store',
+            since: {
+              available: '4.8',
+              enabled: '4.8',
+            },
+          }
+        );
+      }
 
-export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObjectProxy<T> {
-  const promiseObjectProxy: PromiseObjectProxy<T> = promiseObject(promise);
+      const value: unknown = target[prop];
+      if (value && typeof value === 'function' && typeof value.bind === 'function') {
+        return value.bind(target);
+      }
+
+      if (PROXIED_ARRAY_PROPS.includes(prop)) {
+        return value;
+      }
+
+      return undefined;
+    },
+  };
+
+  return new Proxy(promiseObjectProxy, handler);
+}
+
+export function promiseObject<T>(promise: Promise<T>): PromiseObjectProxy<T> {
+  const promiseObjectProxy: PromiseObjectProxy<T> = _promiseObject(promise);
   const handler = {
     get(target: object, prop: string, receiver?: object): unknown {
+      if (typeof prop === 'symbol') {
+        return Reflect.get(target, prop, receiver);
+      }
       if (!ALLOWABLE_METHODS.includes(prop)) {
         deprecate(
-          `Accessing ${prop} is deprecated. The return type is being changed fomr PromiseObjectProxy to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
+          `Accessing ${prop} on this PromiseObject is deprecated. The return type is being changed from PromiseObject to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
           false,
           {
-            id: 'ember-data:model-save-promise',
+            id: 'ember-data:deprecate-promise-proxies',
             until: '5.0',
             for: '@ember-data/store',
             since: {
-              available: '4.4',
-              enabled: '4.4',
+              available: '4.8',
+              enabled: '4.8',
             },
           }
         );
       }
 
-      const value: unknown = Reflect.get(target, prop, receiver);
+      const value: unknown = target[prop];
       if (value && typeof value === 'function' && typeof value.bind === 'function') {
         return value.bind(target);
       }
 
-      return value;
+      if (PROXIED_OBJECT_PROPS.includes(prop)) {
+        return value;
+      }
+
+      return undefined;
     },
   };
 
-  return new Proxy(promiseObjectProxy, handler) as PromiseObjectProxy<T>;
+  return new Proxy(promiseObjectProxy, handler);
 }