@ember-data/store 4.8.0-alpha.2 → 4.8.0-alpha.3

package/addon/-private/{core-store.ts → store-service.ts}

@@ -3,7 +3,7 @@
  */
 import { getOwner, setOwner } from '@ember/application';
 import { assert, deprecate } from '@ember/debug';
-import { _backburner as emberBackburner } from '@ember/runloop';
+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';
@@ -17,7 +17,6 @@ import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-
 import {
   DEPRECATE_HAS_RECORD,
   DEPRECATE_JSON_API_FALLBACK,
-  DEPRECATE_RECORD_WAS_INVALID,
   DEPRECATE_STORE_FIND,
 } from '@ember-data/private-build-infra/deprecations';
 import type { RecordData as RecordDataClass } from '@ember-data/record-data/-private';
@@ -33,38 +32,41 @@ import type { StableExistingRecordIdentifier, StableRecordIdentifier } from '@em
 import type { MinimumAdapterInterface } from '@ember-data/types/q/minimum-adapter-interface';
 import type { MinimumSerializerInterface } from '@ember-data/types/q/minimum-serializer-interface';
 import type { RecordData } from '@ember-data/types/q/record-data';
-import type { RecordDataRecordWrapper } from '@ember-data/types/q/record-data-record-wrapper';
+import { JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
+import type { RecordDataWrapper } from '@ember-data/types/q/record-data-record-wrapper';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import type { SchemaDefinitionService } from '@ember-data/types/q/schema-definition-service';
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
 import edBackburner from './backburner';
-import coerceId, { ensureStringId } from './coerce-id';
-import FetchManager, { SaveOp } from './fetch-manager';
-import { _findAll, _query, _queryRecord } from './finders';
-import { IdentifierCache } from './identifier-cache';
-import { InstanceCache, storeFor, StoreMap } from './instance-cache';
+import { IdentifierCache } from './caches/identifier-cache';
 import {
-  internalModelFactoryFor,
+  InstanceCache,
   peekRecordIdentifier,
+  recordDataIsFullyDeleted,
   recordIdentifierFor,
   setRecordIdentifier,
-} from './internal-model-factory';
-import RecordReference from './model/record-reference';
-import type ShimModelClass from './model/shim-model-class';
-import { getShimClass } from './model/shim-model-class';
-import normalizeModelName from './normalize-model-name';
-import { PromiseArray, promiseArray, PromiseObject, promiseObject } from './promise-proxies';
-import RecordArrayManager from './record-array-manager';
+  storeFor,
+  StoreMap,
+} from './caches/instance-cache';
+import { setRecordDataFor } from './caches/record-data-for';
+import RecordReference from './legacy-model-support/record-reference';
+import { DSModelSchemaDefinitionService, getModelFactory } from './legacy-model-support/schema-definition-service';
+import type ShimModelClass from './legacy-model-support/shim-model-class';
+import { getShimClass } from './legacy-model-support/shim-model-class';
+import RecordArrayManager from './managers/record-array-manager';
+import RecordDataStoreWrapper from './managers/record-data-store-wrapper';
+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 { 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 { setRecordDataFor } from './record-data-for';
-import RecordDataStoreWrapper from './record-data-store-wrapper';
-import NotificationManager from './record-notification-manager';
-import type RequestCache from './request-cache';
-import { DSModelSchemaDefinitionService, getModelFactory } from './schema-definition-service';
+import coerceId, { ensureStringId } from './utils/coerce-id';
 import constructResource from './utils/construct-resource';
+import normalizeModelName from './utils/normalize-model-name';
 import promiseRecord from './utils/promise-record';
 
 export { storeFor };
@@ -191,6 +193,7 @@ class Store extends Service {
   declare _trackAsyncRequestStart: (str: string) => void;
   declare _trackAsyncRequestEnd: (token: AsyncTrackingToken) => void;
   declare __asyncWaiter: () => boolean;
+  declare DISABLE_WAITER?: boolean;
 
   /**
     @method init
@@ -268,7 +271,7 @@ class Store extends Service {
 
       this.__asyncWaiter = () => {
         let tracked = this._trackedAsyncRequests;
-        return tracked.length === 0;
+        return this.DISABLE_WAITER || tracked.length === 0;
       };
 
       registerWaiter(this.__asyncWaiter);
@@ -282,23 +285,22 @@ class Store extends Service {
   instantiateRecord(
     identifier: StableRecordIdentifier,
     createRecordArgs: { [key: string]: unknown },
-    recordDataFor: (identifier: StableRecordIdentifier) => RecordDataRecordWrapper,
+    recordDataFor: (identifier: StableRecordIdentifier) => RecordDataWrapper,
     notificationManager: NotificationManager
   ): DSModel | RecordInstance {
     if (HAS_MODEL_PACKAGE) {
       let modelName = identifier.type;
       let store = this;
 
-      let internalModel = this._instanceCache._internalModelForResource(identifier);
+      let recordData = this._instanceCache.getRecordData(identifier);
       let createOptions: any = {
-        _internalModel: internalModel,
         // 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, internalModel._recordData);
+          setRecordDataFor(record, recordData);
         },
         container: null, // necessary hack for setOwner?
       };
@@ -306,7 +308,6 @@ class Store extends Service {
       // ensure that `getOwner(this)` works inside a model instance
       setOwner(createOptions, getOwner(this));
       delete createOptions.container;
-      // TODO this needs to not use the private property here to get modelFactoryCache so as to not break interop
       return getModelFactory(this, this._modelFactoryCache, modelName).create(createOptions);
     }
     assert(`You must implement the store's instantiateRecord hook for your custom model class.`);
@@ -326,6 +327,8 @@ class Store extends Service {
 
   getSchemaDefinitionService(): SchemaDefinitionService {
     if (HAS_MODEL_PACKAGE && !this._schemaDefinitionService) {
+      // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
+      // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
       this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
     }
     assert(
@@ -367,10 +370,6 @@ class Store extends Service {
     );
     if (HAS_MODEL_PACKAGE) {
       let normalizedModelName = normalizeModelName(modelName);
-      // TODO this is safe only because
-      // apps would be horribly broken if the schema service were using DS_MODEL but not using DS_MODEL's schema service.
-      // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
-      // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
       let maybeFactory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);
 
       // for factorFor factory/class split
@@ -461,12 +460,20 @@ class Store extends Service {
 
         // Coerce ID to a string
         properties.id = coerceId(properties.id);
+        const resource = { type: normalizedModelName, id: properties.id };
 
-        const factory = internalModelFactoryFor(this);
-        const internalModel = factory.build({ type: normalizedModelName, id: properties.id });
-        const { identifier } = internalModel;
+        if (resource.id) {
+          const identifier = this.identifierCache.peekRecordIdentifier(resource as ResourceIdentifierObject);
 
-        this._instanceCache.getRecordData(identifier).clientDidCreate();
+          assert(
+            `The id ${properties.id} has already been used with another '${normalizedModelName}' record.`,
+            !identifier
+          );
+        }
+
+        const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
+        const recordData = this._instanceCache.getRecordData(identifier);
+        recordData.clientDidCreate();
         this.recordArrayManager.recordDidChange(identifier);
 
         return this._instanceCache.getRecord(identifier, properties);
@@ -495,13 +502,27 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'deleteRecord');
     }
+    // TODO eliminate this interleaving
+    // it is unlikely we need both an outer join and the inner run
+    // of our own queue
     this._backburner.join(() => {
-      let identifier = peekRecordIdentifier(record);
+      const identifier = peekRecordIdentifier(record);
       if (identifier) {
-        let internalModel = internalModelFactoryFor(this).peek(identifier);
-        if (internalModel) {
-          internalModel.deleteRecord();
-        }
+        run(() => {
+          const backburner = this._backburner;
+          backburner.run(() => {
+            const recordData = this._instanceCache.peek({ identifier, bucket: 'recordData' });
+
+            if (recordData) {
+              if (recordData?.setIsDeleted) {
+                recordData.setIsDeleted(true);
+              }
+              if (recordData.isNew?.()) {
+                this._instanceCache.unloadRecord(identifier);
+              }
+            }
+          });
+        });
       }
     });
   }
@@ -528,10 +549,7 @@ class Store extends Service {
     }
     let identifier = peekRecordIdentifier(record);
     if (identifier) {
-      let internalModel = internalModelFactoryFor(this).peek(identifier);
-      if (internalModel) {
-        internalModel.unloadRecord();
-      }
+      this._instanceCache.unloadRecord(identifier);
     }
   }
 
@@ -745,7 +763,7 @@ class Store extends Service {
     //   }
     // ]
     store.findRecord('post', 1, { reload: true }).then(function(post) {
-      post.get('revision'); // 2
+      post.revision; // 2
     });
     ```
 
@@ -783,7 +801,7 @@ class Store extends Service {
     });
 
     let blogPost = store.findRecord('post', 1).then(function(post) {
-      post.get('revision'); // 1
+      post.revision; // 1
     });
 
     // later, once adapter#findRecord resolved with
@@ -795,7 +813,7 @@ class Store extends Service {
     //   }
     // ]
 
-    blogPost.get('revision'); // 2
+    blogPost.revision; // 2
     ```
 
     If you would like to force or prevent background reloading, you can set a
@@ -983,13 +1001,12 @@ class Store extends Service {
       resource = constructResource(type, normalizedId);
     }
 
-    const internalModel = internalModelFactoryFor(this).lookup(resource);
-    const { identifier } = internalModel;
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     let promise;
     options = options || {};
 
     // if not loaded start loading
-    if (!internalModel.isLoaded) {
+    if (!this._instanceCache.recordIsLoaded(identifier)) {
       promise = this._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
 
       // Refetch if the reload option is passed
@@ -1144,10 +1161,10 @@ class Store extends Service {
   peekRecord(identifier: ResourceIdentifierObject | string, id?: string | number): RecordInstance | null {
     if (arguments.length === 1 && isMaybeIdentifier(identifier)) {
       const stableIdentifier = this.identifierCache.peekRecordIdentifier(identifier);
-      const internalModel = stableIdentifier && internalModelFactoryFor(this).peek(stableIdentifier);
+      const isLoaded = stableIdentifier && this._instanceCache.recordIsLoaded(stableIdentifier);
       // TODO come up with a better mechanism for determining if we have data and could peek.
       // this is basically an "are we not empty" query.
-      return internalModel && internalModel.isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
+      return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
     }
 
     if (DEBUG) {
@@ -1164,9 +1181,9 @@ class Store extends Service {
     const normalizedId = ensureStringId(id);
     const resource = { type, id: normalizedId };
     const stableIdentifier = this.identifierCache.peekRecordIdentifier(resource);
-    const internalModel = stableIdentifier && internalModelFactoryFor(this).peek(stableIdentifier);
+    const isLoaded = stableIdentifier && this._instanceCache.recordIsLoaded(stableIdentifier);
 
-    return internalModel && internalModel.isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
+    return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
   }
 
   /**
@@ -1211,9 +1228,7 @@ class Store extends Service {
       const resource = { type, id: trueId };
 
       const identifier = this.identifierCache.peekRecordIdentifier(resource);
-      const internalModel = identifier && internalModelFactoryFor(this).peek(identifier);
-
-      return !!internalModel && internalModel.isLoaded;
+      return Boolean(identifier && this._instanceCache.recordIsLoaded(identifier));
     }
     assert(`store.hasRecordForId has been removed`);
   }
@@ -1336,8 +1351,8 @@ class Store extends Service {
 
     ```javascript
     store.queryRecord('user', {}).then(function(user) {
-      let username = user.get('username');
-      console.log(`Currently logged in as ${username}`);
+      let username = user.username;
+      // do thing
     });
     ```
 
@@ -1374,9 +1389,9 @@ class Store extends Service {
 
     ```javascript
     store.query('user', { username: 'unique' }).then(function(users) {
-      return users.get('firstObject');
+      return users.firstObject;
     }).then(function(user) {
-      let id = user.get('id');
+      let id = user.id;
     });
     ```
 
@@ -1394,7 +1409,7 @@ class Store extends Service {
 
     ```javascript
     store.queryRecord('user', { username: 'unique' }).then(function(user) {
-      console.log(user); // null
+       // user is null
     });
     ```
 
@@ -1752,50 +1767,14 @@ class Store extends Service {
       !modelName || typeof modelName === 'string'
     );
 
-    const factory = internalModelFactoryFor(this);
-
     if (modelName === undefined) {
-      factory.clear();
+      this._instanceCache.clear();
     } else {
       let normalizedModelName = normalizeModelName(modelName);
-      factory.clear(normalizedModelName);
+      this._instanceCache.clear(normalizedModelName);
     }
   }
 
-  /**
-    This method is called once the promise returned by an
-    adapter's `createRecord`, `updateRecord` or `deleteRecord`
-    is rejected with a `InvalidError`.
-
-    @method recordWasInvalid
-    @private
-    @deprecated
-    @param {InternalModel} internalModel
-    @param {Object} errors
-  */
-  recordWasInvalid(internalModel, parsedErrors, error) {
-    if (DEPRECATE_RECORD_WAS_INVALID) {
-      deprecate(
-        `The private API recordWasInvalid will be removed in an upcoming release. Use record.errors add/remove instead if the intent was to move the record into an invalid state manually.`,
-        false,
-        {
-          id: 'ember-data:deprecate-record-was-invalid',
-          for: 'ember-data',
-          until: '5.0',
-          since: { enabled: '4.5', available: '4.5' },
-        }
-      );
-      if (DEBUG) {
-        assertDestroyingStore(this, 'recordWasInvalid');
-      }
-      error = error || new Error(`unknown invalid error`);
-      error = typeof error === 'string' ? new Error(error) : error;
-      error._parsedErrors = parsedErrors;
-      internalModel.adapterDidInvalidate(error);
-    }
-    assert(`store.recordWasInvalid has been removed`);
-  }
-
   /**
     Push some data for a given type into the store.
 
@@ -1975,7 +1954,7 @@ class Store extends Service {
     @method _push
     @private
     @param {Object} jsonApiDoc
-    @return {InternalModel|Array<InternalModel>} pushed InternalModel(s)
+    @return {StableRecordIdentifier|Array<StableRecordIdentifier>} identifiers for the primary records that had data loaded
   */
   _push(jsonApiDoc): StableExistingRecordIdentifier | StableExistingRecordIdentifier[] | null {
     if (DEBUG) {
@@ -1987,7 +1966,7 @@ class Store extends Service {
 
       if (included) {
         for (i = 0, length = included.length; i < length; i++) {
-          this._instanceCache._load(included[i]);
+          this._instanceCache.loadData(included[i]);
         }
       }
 
@@ -1996,7 +1975,7 @@ class Store extends Service {
         let identifiers = new Array(length);
 
         for (i = 0; i < length; i++) {
-          identifiers[i] = this._instanceCache._load(jsonApiDoc.data[i]);
+          identifiers[i] = this._instanceCache.loadData(jsonApiDoc.data[i]);
         }
         return identifiers;
       }
@@ -2012,7 +1991,7 @@ class Store extends Service {
         typeof jsonApiDoc.data === 'object'
       );
 
-      return this._instanceCache._load(jsonApiDoc.data);
+      return this._instanceCache.loadData(jsonApiDoc.data);
     });
 
     // this typecast is necessary because `backburner.join` is mistyped to return void
@@ -2115,37 +2094,35 @@ class Store extends Service {
   saveRecord(record: RecordInstance, options: Dict<unknown> = {}): Promise<RecordInstance> {
     assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
     let identifier = recordIdentifierFor(record);
-    let internalModel = identifier && internalModelFactoryFor(this).peek(identifier)!;
+    let recordData = identifier && this._instanceCache.peek({ identifier, bucket: 'recordData' });
 
-    if (!internalModel) {
+    if (!recordData) {
       // this commonly means we're disconnected
       // but just in case we reject here to prevent bad things.
       return reject(`Record Is Disconnected`);
     }
     // TODO we used to check if the record was destroyed here
-    // Casting can be removed once REQUEST_SERVICE ff is turned on
-    // because a `Record` is provided there will always be a matching internalModel
-
     assert(
       `Cannot initiate a save request for an unloaded record: ${identifier}`,
-      !internalModel.isEmpty && !internalModel.isDestroyed
+      recordData && this._instanceCache.recordIsLoaded(identifier)
     );
-    if (internalModel._isRecordFullyDeleted()) {
+    if (recordDataIsFullyDeleted(this._instanceCache, identifier)) {
       return resolve(record);
     }
 
-    internalModel.adapterWillCommit();
+    recordData.willCommit();
+    if (isDSModel(record)) {
+      record.errors.clear();
+    }
 
     if (!options) {
       options = {};
     }
-    let recordData = this._instanceCache.getRecordData(identifier);
     let operation: 'createRecord' | 'deleteRecord' | 'updateRecord' = 'updateRecord';
 
-    // TODO handle missing isNew
-    if (recordData.isNew && recordData.isNew()) {
+    if (recordData.isNew?.()) {
       operation = 'createRecord';
-    } else if (recordData.isDeleted && recordData.isDeleted()) {
+    } else if (recordData.isDeleted?.()) {
       operation = 'deleteRecord';
     }
 
@@ -2173,20 +2150,21 @@ class Store extends Service {
           let data = payload && payload.data;
           if (!data) {
             assert(
-              `Your ${internalModel.modelName} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`,
-              internalModel.id
+              `Your ${identifier.type} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`,
+              identifier.id
             );
           }
 
           const cache = this.identifierCache;
+          let actualIdentifier = identifier;
           if (operation !== 'deleteRecord' && data) {
-            cache.updateRecordIdentifier(identifier, data);
+            actualIdentifier = cache.updateRecordIdentifier(identifier, data);
           }
 
           //We first make sure the primary data has been updated
-          //TODO try to move notification to the user to the end of the runloop
-          internalModel._recordData.didCommit(data);
-          this.recordArrayManager.recordDidChange(internalModel.identifier);
+          const recordData = this._instanceCache.getRecordData(actualIdentifier);
+          recordData.didCommit(data);
+          this.recordArrayManager.recordDidChange(actualIdentifier);
 
           if (payload && payload.included) {
             this._push({ data: null, included: payload.included });
@@ -2201,7 +2179,7 @@ class Store extends Service {
         } else if (typeof e === 'string') {
           err = new Error(e);
         }
-        internalModel.adapterDidInvalidate(err);
+        adapterDidInvalidate(this, identifier, err);
         throw err;
       }
     );
@@ -2215,13 +2193,13 @@ class Store extends Service {
    * @public
    * @param modelName
    * @param id
-   * @param clientId
+   * @param lid
    * @param storeWrapper
    */
   createRecordDataFor(
     modelName: string,
     id: string | null,
-    clientId: string,
+    lid: string,
     storeWrapper: RecordDataStoreWrapper
   ): RecordData {
     if (HAS_RECORD_DATA_PACKAGE) {
@@ -2233,13 +2211,13 @@ class Store extends Service {
       if (_RecordData === undefined) {
         _RecordData = (
           importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-        ).RecordData as RecordDataConstruct;
+        ).RecordData;
       }
 
       let identifier = this.identifierCache.getOrCreateRecordIdentifier({
         type: modelName,
         id,
-        lid: clientId,
+        lid,
       });
       return new _RecordData(identifier, storeWrapper);
     }
@@ -2515,3 +2493,84 @@ export function assertIdentifierHasId(
 ): asserts identifier is StableExistingRecordIdentifier {
   assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
 }
+
+function isDSModel(record: RecordInstance | null): record is DSModel {
+  return (
+    HAS_MODEL_PACKAGE &&
+    !!record &&
+    'constructor' in record &&
+    'isModel' in record.constructor &&
+    record.constructor.isModel === true
+  );
+}
+
+type AdapterErrors = Error & { errors?: unknown[]; isAdapterError?: true; code?: string };
+type SerializerWithParseErrors = MinimumSerializerInterface & {
+  extractErrors?(store: Store, modelClass: ShimModelClass, error: AdapterErrors, recordId: string | null): any;
+};
+
+function adapterDidInvalidate(
+  store: Store,
+  identifier: StableRecordIdentifier,
+  error: Error & { errors?: JsonApiValidationError[]; isAdapterError?: true; code?: string }
+) {
+  if (error && error.isAdapterError === true && error.code === 'InvalidError') {
+    let serializer = store.serializerFor(identifier.type) as SerializerWithParseErrors;
+
+    // TODO @deprecate extractErrors being called
+    // TODO remove extractErrors from the default serializers.
+    if (serializer && typeof serializer.extractErrors === 'function') {
+      let errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
+      error.errors = errorsHashToArray(errorsHash);
+    }
+  }
+  const recordData = store._instanceCache.getRecordData(identifier);
+
+  if (error.errors) {
+    assert(
+      `Expected the RecordData implementation for ${identifier} to have a getErrors(identifier) method for retreiving errors.`,
+      typeof recordData.getErrors === 'function'
+    );
+
+    let jsonApiErrors: JsonApiValidationError[] = error.errors;
+    if (jsonApiErrors.length === 0) {
+      jsonApiErrors = [{ title: 'Invalid Error', detail: '', source: { pointer: '/data' } }];
+    }
+    recordData.commitWasRejected(identifier, jsonApiErrors);
+  } else {
+    recordData.commitWasRejected(identifier);
+  }
+}
+
+function makeArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+const PRIMARY_ATTRIBUTE_KEY = 'base';
+
+function errorsHashToArray(errors): JsonApiValidationError[] {
+  const out: JsonApiValidationError[] = [];
+
+  if (errors) {
+    Object.keys(errors).forEach((key) => {
+      let messages = makeArray(errors[key]);
+      for (let i = 0; i < messages.length; i++) {
+        let title = 'Invalid Attribute';
+        let pointer = `/data/attributes/${key}`;
+        if (key === PRIMARY_ATTRIBUTE_KEY) {
+          title = 'Invalid Document';
+          pointer = `/data`;
+        }
+        out.push({
+          title: title,
+          detail: messages[i],
+          source: {
+            pointer: pointer,
+          },
+        });
+      }
+    });
+  }
+
+  return out;
+}

package/addon/-private/{coerce-id.ts → utils/coerce-id.ts}

@@ -35,7 +35,7 @@ export function ensureStringId(id: Coercable): string {
     throw new Error(`Expected id to be a string or number, received ${String(id)}`);
   }
 
-  return normalized!;
+  return normalized;
 }
 
 export default coerceId;

package/addon/-private/{common.js → utils/common.js}

@@ -1,5 +1,4 @@
 import { deprecate } from '@ember/debug';
-import { get } from '@ember/object';
 import { DEBUG } from '@glimmer/env';
 
 import { resolve } from 'rsvp';
@@ -27,7 +26,7 @@ export function _guard(promise, test) {
 }
 
 export function _objectIsAlive(object) {
-  return !(get(object, 'isDestroyed') || get(object, 'isDestroying'));
+  return !(object.isDestroyed || object.isDestroying);
 }
 
 export function guardDestroyedStore(promise, store, label) {

package/addon/-private/utils/construct-resource.ts

@@ -5,8 +5,8 @@ import type {
   ResourceIdentifierObject,
 } from '@ember-data/types/q/ember-data-json-api';
 
-import coerceId from '../coerce-id';
-import { isStableIdentifier } from '../identifier-cache';
+import { isStableIdentifier } from '../caches/identifier-cache';
+import coerceId from './coerce-id';
 import isNonEmptyString from './is-non-empty-string';
 
 function constructResource(type: ResourceIdentifierObject): ResourceIdentifierObject;

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

@@ -1,9 +1,9 @@
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 
-import type Store from '../core-store';
-import type { PromiseObject } from '../promise-proxies';
-import { promiseObject } from '../promise-proxies';
+import type { PromiseObject } from '../proxies/promise-proxies';
+import { promiseObject } from '../proxies/promise-proxies';
+import type Store from '../store-service';
 
 export default function promiseRecord(
   store: Store,