@ember-data/store 4.10.0-alpha.2 → 4.10.0-alpha.4

package/addon/-private/caches/instance-cache.ts

@@ -423,16 +423,21 @@ export class InstanceCache {
         }
       }
 
+      let removeFromRecordArray = true;
       if (recordData) {
+        removeFromRecordArray = !recordData.isDeletionCommitted(identifier);
         recordData.unloadRecord(identifier);
         this.__instances.recordData.delete(identifier);
         removeRecordDataFor(identifier);
       } else {
+        removeFromRecordArray = false;
         this.disconnect(identifier);
       }
 
       this.store._fetchManager.clearEntries(identifier);
-      this.store.recordArrayManager.identifierRemoved(identifier);
+      if (removeFromRecordArray) {
+        this.store.recordArrayManager.identifierRemoved(identifier);
+      }
       if (LOG_INSTANCE_CACHE) {
         // eslint-disable-next-line no-console
         console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
@@ -471,12 +476,6 @@ export class InstanceCache {
     const isEmpty = _isEmpty(this, identifier);
     const isLoading = _isLoading(this, identifier);
 
-    if (options.preload) {
-      this.store._join(() => {
-        preloadData(this.store, identifier, options.preload!);
-      });
-    }
-
     let promise: Promise<StableRecordIdentifier>;
     if (isEmpty) {
       assertIdentifierHasId(identifier);
@@ -612,7 +611,7 @@ export function recordDataIsFullyDeleted(cache: InstanceCache, identifier: Stabl
     models.
   */
 type PreloadRelationshipValue = RecordInstance | string;
-function preloadData(store: Store, identifier: StableRecordIdentifier, preload: Dict<unknown>) {
+export function preloadData(store: Store, identifier: StableRecordIdentifier, preload: Dict<unknown>) {
   let jsonPayload: JsonApiResource = {};
   //TODO(Igor) consider the polymorphic case
   const schemas = store.getSchemaDefinitionService();

package/addon/-private/legacy-model-support/shim-model-class.ts

@@ -81,16 +81,11 @@ export default class ShimModelClass implements ModelSchema {
     });
   }
 
-  eachTransformedAttribute<T>(
-    callback: (this: T | undefined, key: string, relationship: RelationshipSchema) => void,
-    binding?: T
-  ) {
-    let relationshipDefs = this.__store
-      .getSchemaDefinitionService()
-      .relationshipsDefinitionFor({ type: this.modelName });
-    Object.keys(relationshipDefs).forEach((key) => {
-      if (relationshipDefs[key]!.type) {
-        callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);
+  eachTransformedAttribute<T>(callback: (this: T | undefined, key: string, type: string) => void, binding?: T) {
+    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
+    Object.keys(attrDefs).forEach((key) => {
+      if (attrDefs[key]!.type) {
+        callback.call(binding, key, attrDefs[key]!.type);
       }
     });
   }

package/addon/-private/managers/record-array-manager.ts

@@ -357,7 +357,10 @@ function sync(array: IdentifierArray, changes: Map<StableRecordIdentifier, 'add'
       // state = array[SOURCE] = [];
     } else {
       removes.forEach((i) => {
-        state.splice(state.indexOf(i), 1);
+        const index = state.indexOf(i);
+        if (index !== -1) {
+          state.splice(index, 1);
+        }
       });
     }
   }

package/addon/-private/managers/record-data-manager.ts

@@ -119,7 +119,7 @@ export class NonSingletonRecordDataManager implements RecordData {
     // called by something V1
     if (!isStableIdentifier(identifier)) {
       data = identifier as JsonApiResource;
-      hasRecord = data as boolean;
+      hasRecord = data as unknown as boolean;
       identifier = this.#identifier;
     }
     if (this.#isDeprecated(recordData)) {

package/addon/-private/record-arrays/identifier-array.ts

@@ -114,6 +114,33 @@ interface PrivateState {
   links: Links | PaginationLinks | null;
   meta: Dict<unknown> | null;
 }
+type ForEachCB = (record: RecordInstance, index: number, context: IdentifierArray) => void;
+function safeForEach(
+  instance: IdentifierArray,
+  arr: StableRecordIdentifier[],
+  store: Store,
+  callback: ForEachCB,
+  target: unknown
+) {
+  if (target === undefined) {
+    target = null;
+  }
+  // clone to prevent mutation
+  arr = arr.slice();
+  assert('`forEach` expects a function as first argument.', typeof callback === 'function');
+
+  // because we retrieveLatest above we need not worry if array is mutated during iteration
+  // by unloadRecord/rollbackAttributes
+  // push/add/removeObject may still be problematic
+  // but this is a more traditionally expected forEach bug.
+  const length = arr.length; // we need to access length to ensure we are consumed
+
+  for (let index = 0; index < length; index++) {
+    callback.call(target, store._instanceCache.getRecord(arr[index]), index, instance);
+  }
+
+  return instance;
+}
 
 /**
   A record array is an array that contains records of a certain type (or modelName).
@@ -241,15 +268,25 @@ class IdentifierArray {
           let fn = boundFns.get(prop);
 
           if (fn === undefined) {
-            fn = function () {
-              subscribe(_TAG);
-              // array functions must run through Reflect to work properly
-              // binding via other means will not work.
-              transaction = true;
-              let result = Reflect.apply(target[prop] as ProxiedMethod, receiver, arguments) as unknown;
-              transaction = false;
-              return result;
-            };
+            if (prop === 'forEach') {
+              fn = function () {
+                subscribe(_TAG);
+                transaction = true;
+                let result = safeForEach(receiver, target, store, arguments[0] as ForEachCB, arguments[1]);
+                transaction = false;
+                return result;
+              };
+            } else {
+              fn = function () {
+                subscribe(_TAG);
+                // array functions must run through Reflect to work properly
+                // binding via other means will not work.
+                transaction = true;
+                let result = Reflect.apply(target[prop] as ProxiedMethod, receiver, arguments) as unknown;
+                transaction = false;
+                return result;
+              };
+            }
 
             boundFns.set(prop, fn);
           }
@@ -271,7 +308,7 @@ class IdentifierArray {
               const args: unknown[] = Array.prototype.slice.call(arguments);
               assert(`Cannot start a new array transaction while a previous transaction is underway`, !transaction);
               transaction = true;
-              let result = Reflect.apply(target[prop] as ProxiedMethod, receiver, args) as unknown;
+              let result: unknown = Reflect.apply(target[prop] as ProxiedMethod, receiver, args);
               self[MUTATE]!(prop as string, args, result);
               addToTransaction(_TAG);
               // TODO handle cache updates
@@ -658,13 +695,21 @@ if (DEPRECATE_ARRAY_LIKE) {
 
   IdentifierArray.prototype.removeObject = function (obj: RecordInstance) {
     deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeObject', 'splice');
-    this.splice(this.indexOf(obj), 1);
+    const index = this.indexOf(obj);
+    if (index !== -1) {
+      this.splice(index, 1);
+    }
     return this;
   };
 
   IdentifierArray.prototype.removeObjects = function (objs: RecordInstance[]) {
     deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeObjects', 'splice');
-    objs.forEach((obj) => this.splice(this.indexOf(obj), 1));
+    objs.forEach((obj) => {
+      const index = this.indexOf(obj);
+      if (index !== -1) {
+        this.splice(index, 1);
+      }
+    });
     return this;
   };
 

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

@@ -45,6 +45,7 @@ import { IdentifierCache } from './caches/identifier-cache';
 import {
   InstanceCache,
   peekRecordIdentifier,
+  preloadData,
   recordDataIsFullyDeleted,
   recordIdentifierFor,
   setRecordIdentifier,
@@ -482,6 +483,7 @@ class Store extends Service {
     @return {subclass of Model | ShimModelClass}
     */
   // TODO @deprecate in favor of schema APIs, requires adapter/serializer overhaul or replacement
+  declare _forceShim: boolean;
   modelFor(modelName: string): ShimModelClass | DSModelClass {
     if (DEBUG) {
       assertDestroyedStoreOnly(this, 'modelFor');
@@ -497,7 +499,7 @@ class Store extends Service {
 
       // for factorFor factory/class split
       let klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;
-      if (!klass || !klass.isModel) {
+      if (!klass || !klass.isModel || this._forceShim) {
         assert(
           `No model was found for '${modelName}' and no schema handles the type`,
           this.getSchemaDefinitionService().doesTypeExist(modelName)
@@ -1127,6 +1129,12 @@ class Store extends Service {
     let promise;
     options = options || {};
 
+    if (options.preload) {
+      this._join(() => {
+        preloadData(this, identifier, options!.preload!);
+      });
+    }
+
     // if not loaded start loading
     if (!this._instanceCache.recordIsLoaded(identifier)) {
       promise = this._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
@@ -1134,6 +1142,7 @@ class Store extends Service {
       // Refetch if the reload option is passed
     } else if (options.reload) {
       assertIdentifierHasId(identifier);
+
       promise = this._fetchManager.scheduleFetch(identifier, options);
     } else {
       let snapshot: Snapshot | null = null;
@@ -2310,8 +2319,8 @@ class Store extends Service {
 
     const saveOptions = Object.assign({ [SaveOp]: operation }, options);
     let fetchManagerPromise = this._fetchManager.scheduleSave(identifier, saveOptions);
-    return fetchManagerPromise.then(
-      (payload) => {
+    return fetchManagerPromise
+      .then((payload) => {
         if (LOG_PAYLOADS) {
           try {
             let data = payload ? JSON.parse(JSON.stringify(payload)) : payload;
@@ -2366,8 +2375,8 @@ class Store extends Service {
           }
         });
         return record;
-      },
-      (e) => {
+      })
+      .catch((e) => {
         let err = e;
         if (!e) {
           err = new Error(`Unknown Error Occurred During Request`);
@@ -2376,8 +2385,7 @@ class Store extends Service {
         }
         adapterDidInvalidate(this, identifier, err);
         throw err;
-      }
-    );
+      });
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "4.10.0-alpha.2",
+  "version": "4.10.0-alpha.4",
   "description": "The core of EmberData. Provides the Store service which coordinates the cache with the network and presentation layers.",
   "keywords": [
     "ember-addon"
@@ -14,9 +14,9 @@
   "author": "",
   "directories": {},
   "peerDependencies": {
-    "@ember-data/model": "4.10.0-alpha.2",
-    "@ember-data/record-data": "4.10.0-alpha.2",
-    "@ember-data/tracking": "4.10.0-alpha.2",
+    "@ember-data/model": "4.10.0-alpha.4",
+    "@ember-data/record-data": "4.10.0-alpha.4",
+    "@ember-data/tracking": "4.10.0-alpha.4",
     "@ember/string": "^3.0.0",
     "@glimmer/tracking": "^1.1.2"
   },
@@ -37,8 +37,8 @@
     }
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.10.0-alpha.2",
-    "@ember-data/private-build-infra": "4.10.0-alpha.2",
+    "@ember-data/canary-features": "4.10.0-alpha.4",
+    "@ember-data/private-build-infra": "4.10.0-alpha.4",
     "@embroider/macros": "^1.10.0",
     "ember-auto-import": "^2.5.0",
     "ember-cached-decorator-polyfill": "^1.0.1",
@@ -57,5 +57,5 @@
   "volta": {
     "extends": "../../package.json"
   },
-  "packageManager": "pnpm@7.15.0"
+  "packageManager": "pnpm@7.18.0"
 }