@ember-data/store 4.5.0-beta.0 → 4.5.0

package/addon/-private/{system/references/record.ts → model/record-reference.ts}

@@ -1,15 +1,19 @@
-import { dependentKeyCompat } from '@ember/object/compat';
-import { cached, tracked } from '@glimmer/tracking';
+import { assert } from '@ember/debug';
+import { tracked } from '@glimmer/tracking';
 
+/**
+  @module @ember-data/store
+*/
 import RSVP, { resolve } from 'rsvp';
 
-import type { SingleResourceDocument } from '../../ts-interfaces/ember-data-json-api';
-import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
-import type { RecordInstance } from '../../ts-interfaces/record-instance';
-import type CoreStore from '../core-store';
-import { NotificationType, unsubscribe } from '../record-notification-manager';
-import { internalModelFactoryFor } from '../store/internal-model-factory';
-import Reference from './reference';
+import type { SingleResourceDocument } from '@ember-data/types/q/ember-data-json-api';
+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 { NotificationType } from '../record-notification-manager';
+import { unsubscribe } from '../record-notification-manager';
+
 /**
   @module @ember-data/store
 */
@@ -22,15 +26,14 @@ import Reference from './reference';
    @public
    @extends Reference
 */
-export default class RecordReference extends Reference {
+export default class RecordReference {
   // unsubscribe token given to us by the notification manager
   #token!: Object;
-  #identifier;
+  #identifier: StableRecordIdentifier;
 
   @tracked _ref = 0;
 
-  constructor(public store: CoreStore, identifier: StableRecordIdentifier) {
-    super(store, identifier);
+  constructor(public store: Store, identifier: StableRecordIdentifier) {
     this.#identifier = identifier;
     this.#token = store._notificationManager.subscribe(
       identifier,
@@ -46,22 +49,10 @@ export default class RecordReference extends Reference {
     unsubscribe(this.#token);
   }
 
-  public get type(): string {
+  get type(): string {
     return this.identifier().type;
   }
 
-  @cached
-  @dependentKeyCompat
-  private get _id(): string | null {
-    this._ref; // consume the tracked prop
-    let identifier = this.identifier();
-    if (identifier) {
-      return identifier.id;
-    }
-
-    return null;
-  }
-
   /**
      The `id` of the record that this reference refers to.
 
@@ -81,7 +72,8 @@ export default class RecordReference extends Reference {
      @return {String} The id of the record.
   */
   id() {
-    return this._id;
+    this._ref; // consume the tracked prop
+    return this.#identifier.id;
   }
 
   /**
@@ -167,6 +159,7 @@ export default class RecordReference extends Reference {
     @return a promise for the value (record or relationship)
   */
   push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): RSVP.Promise<RecordInstance> {
+    // TODO @deprecate pushing unresolved payloads
     return resolve(objectOrPromise).then((data) => {
       return this.store.push(data);
     });
@@ -190,13 +183,7 @@ export default class RecordReference extends Reference {
      @return {Model} the record for this RecordReference
   */
   value(): RecordInstance | null {
-    if (this.id() !== null) {
-      let internalModel = internalModelFactoryFor(this.store).peek(this.#identifier);
-      if (internalModel && internalModel.currentState.isLoaded) {
-        return internalModel.getRecord();
-      }
-    }
-    return null;
+    return this.store.peekRecord(this.#identifier);
   }
 
   /**
@@ -221,7 +208,7 @@ export default class RecordReference extends Reference {
     if (id !== null) {
       return this.store.findRecord(this.type, id);
     }
-    throw new Error(`Unable to fetch record of type ${this.type} without an id`);
+    assert(`Unable to fetch record of type ${this.type} without an id`);
   }
 
   /**
@@ -246,6 +233,6 @@ export default class RecordReference extends Reference {
     if (id !== null) {
       return this.store.findRecord(this.type, id, { reload: true });
     }
-    throw new Error(`Unable to fetch record of type ${this.type} without an id`);
+    assert(`Unable to fetch record of type ${this.type} without an id`);
   }
 }

package/addon/-private/{system/model → model}/shim-model-class.ts

@@ -1,16 +1,17 @@
 import { DEBUG } from '@glimmer/env';
 
-import { ModelSchema } from '../../ts-interfaces/ds-model';
-import type { AttributeSchema, RelationshipSchema } from '../../ts-interfaces/record-data-schemas';
-import type { Dict } from '../../ts-interfaces/utils';
-import type CoreStore from '../core-store';
+import type { ModelSchema } from '@ember-data/types/q/ds-model';
+import type { AttributeSchema, RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
+import type { Dict } from '@ember-data/types/q/utils';
+
+import type Store from '../core-store';
 import WeakCache from '../weak-cache';
 
-const AvailableShims = new WeakCache<CoreStore, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
+const AvailableShims = new WeakCache<Store, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
 AvailableShims._generator = () => {
   return Object.create(null) as Dict<ShimModelClass>;
 };
-export function getShimClass(store: CoreStore, modelName: string): ShimModelClass {
+export function getShimClass(store: Store, modelName: string): ShimModelClass {
   let shims = AvailableShims.lookup(store);
   let shim = shims[modelName];
   if (shim === undefined) {
@@ -33,11 +34,11 @@ function mapFromHash<T>(hash: Dict<T>): Map<string, T> {
 // Mimics the static apis of DSModel
 export default class ShimModelClass implements ModelSchema {
   // TODO Maybe expose the class here?
-  constructor(private __store: CoreStore, public modelName: string) {}
+  constructor(private __store: Store, public modelName: string) {}
 
   get fields(): Map<string, 'attribute' | 'belongsTo' | 'hasMany'> {
-    let attrs = this.__store._attributesDefinitionFor({ type: this.modelName });
-    let relationships = this.__store._relationshipsDefinitionFor({ type: this.modelName });
+    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
+    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({ type: this.modelName });
     let fields = new Map<string, 'attribute' | 'belongsTo' | 'hasMany'>();
     Object.keys(attrs).forEach((key) => fields.set(key, 'attribute'));
     Object.keys(relationships).forEach((key) => fields.set(key, relationships[key]!.kind));
@@ -45,17 +46,17 @@ export default class ShimModelClass implements ModelSchema {
   }
 
   get attributes(): Map<string, AttributeSchema> {
-    let attrs = this.__store._attributesDefinitionFor({ type: this.modelName });
+    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
     return mapFromHash(attrs);
   }
 
   get relationshipsByName(): Map<string, RelationshipSchema> {
-    let relationships = this.__store._relationshipsDefinitionFor({ type: this.modelName });
+    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({ type: this.modelName });
     return mapFromHash(relationships);
   }
 
   eachAttribute<T>(callback: (this: T | undefined, key: string, attribute: AttributeSchema) => void, binding?: T) {
-    let attrDefs = this.__store._attributesDefinitionFor({ type: this.modelName });
+    let attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
     Object.keys(attrDefs).forEach((key) => {
       callback.call(binding, key, attrDefs[key] as AttributeSchema);
     });
@@ -65,7 +66,9 @@ export default class ShimModelClass implements ModelSchema {
     callback: (this: T | undefined, key: string, relationship: RelationshipSchema) => void,
     binding?: T
   ) {
-    let relationshipDefs = this.__store._relationshipsDefinitionFor({ type: this.modelName });
+    let relationshipDefs = this.__store
+      .getSchemaDefinitionService()
+      .relationshipsDefinitionFor({ type: this.modelName });
     Object.keys(relationshipDefs).forEach((key) => {
       callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);
     });
@@ -75,7 +78,9 @@ export default class ShimModelClass implements ModelSchema {
     callback: (this: T | undefined, key: string, relationship: RelationshipSchema) => void,
     binding?: T
   ) {
-    let relationshipDefs = this.__store._relationshipsDefinitionFor({ type: this.modelName });
+    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);

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

@@ -4,7 +4,8 @@ import { reads } from '@ember/object/computed';
 
 import { resolve } from 'rsvp';
 
-import type { Dict } from '../ts-interfaces/utils';
+import type { Dict } from '@ember-data/types/q/utils';
+
 import { PromiseArrayProxy, PromiseObjectProxy } from './promise-proxy-base';
 
 /**
@@ -105,12 +106,13 @@ 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'];
 
-export function deprecatedPromiseObject<T>(promise: PromiseObjectProxy<T>): PromiseObjectProxy<T> {
+export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObjectProxy<T> {
+  const promiseObjectProxy: PromiseObjectProxy<T> = promiseObject(promise);
   const handler = {
     get(target: object, prop: string, receiver?: object): unknown {
       if (!ALLOWABLE_METHODS.includes(prop)) {
         deprecate(
-          `Accessing ${prop} is deprecated.  Only available methods to access on a promise returned from model.save() are .then, .catch and .finally`,
+          `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`,
           false,
           {
             id: 'ember-data:model-save-promise',
@@ -124,9 +126,14 @@ export function deprecatedPromiseObject<T>(promise: PromiseObjectProxy<T>): Prom
         );
       }
 
-      return (Reflect.get(target, prop, receiver) as Function).bind(target);
+      const value: unknown = Reflect.get(target, prop, receiver);
+      if (value && typeof value === 'function' && typeof value.bind === 'function') {
+        return value.bind(target);
+      }
+
+      return value;
     },
   };
 
-  return new Proxy(promise, handler) as PromiseObjectProxy<T>;
+  return new Proxy(promiseObjectProxy, handler) as PromiseObjectProxy<T>;
 }

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

@@ -9,12 +9,14 @@ import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
 // import isStableIdentifier from '../identifiers/is-stable-identifier';
-import type { CollectionResourceDocument, Meta } from '../ts-interfaces/ember-data-json-api';
-import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
-import type { Dict } from '../ts-interfaces/utils';
-import type CoreStore from './core-store';
-import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
-import { internalModelFactoryFor } from './store/internal-model-factory';
+import type { CollectionResourceDocument, Meta } from '@ember-data/types/q/ember-data-json-api';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { Dict } from '@ember-data/types/q/utils';
+
+import type Store from './core-store';
+import { internalModelFactoryFor } from './internal-model-factory';
+import AdapterPopulatedRecordArray from './record-arrays/adapter-populated-record-array';
+import RecordArray from './record-arrays/record-array';
 import WeakCache from './weak-cache';
 
 const RecordArraysCache = new WeakCache<StableRecordIdentifier, Set<RecordArray>>(DEBUG ? 'record-arrays' : '');
@@ -36,7 +38,7 @@ function getIdentifier(identifier: StableRecordIdentifier): StableRecordIdentifi
   return identifier;
 }
 
-function shouldIncludeInRecordArrays(store: CoreStore, identifier: StableRecordIdentifier): boolean {
+function shouldIncludeInRecordArrays(store: Store, identifier: StableRecordIdentifier): boolean {
   const cache = internalModelFactoryFor(store);
   const internalModel = cache.peek(identifier);
 
@@ -51,14 +53,14 @@ function shouldIncludeInRecordArrays(store: CoreStore, identifier: StableRecordI
   @internal
 */
 class RecordArrayManager {
-  declare store: CoreStore;
+  declare store: Store;
   declare isDestroying: boolean;
   declare isDestroyed: boolean;
   declare _liveRecordArrays: Dict<RecordArray>;
   declare _pendingIdentifiers: Dict<StableRecordIdentifier[]>;
   declare _adapterPopulatedRecordArrays: RecordArray[];
 
-  constructor(options: { store: CoreStore }) {
+  constructor(options: { store: Store }) {
     this.store = options.store;
     this.isDestroying = false;
     this.isDestroyed = false;
@@ -164,6 +166,9 @@ class RecordArrayManager {
     let recordArray = this._liveRecordArrays[modelName];
     if (recordArray) {
       set(recordArray, 'isUpdating', false);
+      // TODO potentially we should sync here, currently
+      // this occurs as a side-effect of individual records updating
+      // this._syncLiveRecordArray(recordArray, modelName);
     }
   }
 
@@ -275,8 +280,8 @@ class RecordArrayManager {
         // TODO this assign kills the root reference but a deep-copy would be required
         // for both meta and links to actually not be by-ref. We whould likely change
         // this to a dev-only deep-freeze.
-        meta: Object.assign({} as Meta, payload!.meta),
-        links: Object.assign({}, payload!.links),
+        meta: Object.assign({} as Meta, payload?.meta),
+        links: Object.assign({}, payload?.links),
       });
 
       this._associateWithRecordArray(identifiers, array);
@@ -389,11 +394,7 @@ function removeFromArray(array: RecordArray[], item: RecordArray): boolean {
   return false;
 }
 
-function updateLiveRecordArray(
-  store: CoreStore,
-  recordArray: RecordArray,
-  identifiers: StableRecordIdentifier[]
-): void {
+function updateLiveRecordArray(store: Store, recordArray: RecordArray, identifiers: StableRecordIdentifier[]): void {
   let identifiersToAdd: StableRecordIdentifier[] = [];
   let identifiersToRemove: StableRecordIdentifier[] = [];
 
@@ -423,13 +424,13 @@ function updateLiveRecordArray(
   }
 }
 
-function removeFromAdapterPopulatedRecordArrays(store: CoreStore, identifiers: StableRecordIdentifier[]): void {
+function removeFromAdapterPopulatedRecordArrays(store: Store, identifiers: StableRecordIdentifier[]): void {
   for (let i = 0; i < identifiers.length; i++) {
     removeFromAll(store, identifiers[i]);
   }
 }
 
-function removeFromAll(store: CoreStore, identifier: StableRecordIdentifier): void {
+function removeFromAll(store: Store, identifier: StableRecordIdentifier): void {
   identifier = getIdentifier(identifier);
   const recordArrays = recordArraysForIdentifier(identifier);
 

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

@@ -1,21 +1,22 @@
 import type NativeArray from '@ember/array/-private/native-array';
 import { assert } from '@ember/debug';
 
-import type { PromiseArray, RecordArrayManager } from 'ember-data/-private';
-
-import type { CollectionResourceDocument, Links, Meta, PaginationLinks } from '../../ts-interfaces/ember-data-json-api';
-import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
-import type { RecordInstance } from '../../ts-interfaces/record-instance';
-import type { FindOptions } from '../../ts-interfaces/store';
-import type { Dict } from '../../ts-interfaces/utils';
-import type CoreStore from '../core-store';
+import type { CollectionResourceDocument, Links, Meta, PaginationLinks } from '@ember-data/types/q/ember-data-json-api';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+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 { PromiseArray } from '../promise-proxies';
 import { promiseArray } from '../promise-proxies';
+import type RecordArrayManager from '../record-array-manager';
 import SnapshotRecordArray from '../snapshot-record-array';
 import RecordArray from './record-array';
 
 export interface AdapterPopulatedRecordArrayCreateArgs {
   modelName: string;
-  store: CoreStore;
+  store: Store;
   manager: RecordArrayManager;
   content: NativeArray<StableRecordIdentifier>;
   isLoaded: boolean;
@@ -89,7 +90,7 @@ export default class AdapterPopulatedRecordArray extends RecordArray {
     const { store, query } = this;
 
     // TODO save options from initial request?
-    return promiseArray(store._query(this.modelName, query, this, {}));
+    return promiseArray(store.query(this.modelName, query, { _recordArray: this }));
   }
 
   _setObjects(identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument) {

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

@@ -3,30 +3,31 @@
 */
 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 { assert, deprecate } from '@ember/debug';
+import { 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 { DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS } from '@ember-data/private-build-infra/deprecations';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordInstance } from '@ember-data/types/q/record-instance';
+import type { FindOptions } from '@ember-data/types/q/store';
+
+import type Store from '../core-store';
 import type { 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 {
-  return internalModelFactoryFor(store).lookup(identifier).getRecord();
+function recordForIdentifier(store: Store, identifier: StableRecordIdentifier): RecordInstance {
+  return store._instanceCache.getRecord(identifier);
 }
 
 export interface RecordArrayCreateArgs {
   modelName: string;
-  store: CoreStore;
+  store: Store;
   manager: RecordArrayManager;
   content: NativeArray<StableRecordIdentifier>;
   isLoaded: boolean;
@@ -81,7 +82,7 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @private
     @type Store
     */
-  declare store: CoreStore;
+  declare store: Store;
   declare _updatingPromise: PromiseArray<RecordInstance, RecordArray> | null;
   declare manager: RecordArrayManager;
 
@@ -121,15 +122,9 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
 
    @property type
     @public
+    @deprecated
    @type {subclass of Model}
    */
-  @computed('modelName')
-  get type() {
-    if (!this.modelName) {
-      return null;
-    }
-    return this.store.modelFor(this.modelName);
-  }
 
   /**
     Retrieves an object from the content by index.
@@ -295,6 +290,29 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @internal
   */
   _takeSnapshot(): Snapshot[] {
-    return this.content.map((identifier) => internalModelFactoryFor(this.store).lookup(identifier).createSnapshot());
+    return this.content.map((identifier) => this.store._instanceCache.createSnapshot(identifier));
   }
 }
+
+if (DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS) {
+  Object.defineProperty(RecordArray.prototype, 'type', {
+    get() {
+      deprecate(
+        `Using RecordArray.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`,
+        false,
+        {
+          id: 'ember-data:deprecate-snapshot-model-class-access',
+          until: '5.0',
+          for: 'ember-data',
+          since: { available: '4.5.0', enabled: '4.5.0' },
+        }
+      );
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (!this.modelName) {
+        return null;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      return this.store.modelFor(this.modelName);
+    },
+  });
+}

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

@@ -0,0 +1,39 @@
+import { assert } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
+
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordData } from '@ember-data/types/q/record-data';
+import type { RecordInstance } from '@ember-data/types/q/record-instance';
+
+import WeakCache from './weak-cache';
+
+/*
+ * Returns the RecordData instance associated with a given
+ * Model or Identifier
+ */
+
+const RecordDataForIdentifierCache = new WeakCache<StableRecordIdentifier | RecordInstance, RecordData>(
+  DEBUG ? 'recordData' : ''
+);
+
+export function setRecordDataFor(identifier: StableRecordIdentifier | RecordInstance, recordData: RecordData): void {
+  assert(
+    `Illegal set of identifier`,
+    !RecordDataForIdentifierCache.has(identifier) || RecordDataForIdentifierCache.get(identifier) === recordData
+  );
+  RecordDataForIdentifierCache.set(identifier, recordData);
+}
+
+export function removeRecordDataFor(identifier: StableRecordIdentifier): void {
+  RecordDataForIdentifierCache.delete(identifier);
+}
+
+export default function recordDataFor(instance: StableRecordIdentifier): RecordData | null;
+export default function recordDataFor(instance: RecordInstance): RecordData;
+export default function recordDataFor(instance: StableRecordIdentifier | RecordInstance): RecordData | null {
+  if (RecordDataForIdentifierCache.has(instance as StableRecordIdentifier)) {
+    return RecordDataForIdentifierCache.get(instance as StableRecordIdentifier) as RecordData;
+  }
+
+  return null;
+}

package/addon/-private/{system/store/record-data-store-wrapper.ts → record-data-store-wrapper.ts}

@@ -1,21 +1,20 @@
 import { importSync } from '@embroider/macros';
 
-import type { RelationshipDefinition } from '@ember-data/model/-private/system/relationships/relationship-meta';
+import type { RelationshipDefinition } from '@ember-data/model/-private/relationship-meta';
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
-
-import type { IdentifierCache } from '../../identifiers/cache';
-import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
-import type { RecordData } from '../../ts-interfaces/record-data';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordData } from '@ember-data/types/q/record-data';
 import type {
   AttributesSchema,
   RelationshipSchema,
   RelationshipsSchema,
-} from '../../ts-interfaces/record-data-schemas';
-import type { RecordDataStoreWrapper as StoreWrapper } from '../../ts-interfaces/record-data-store-wrapper';
-import { RecordInstance } from '../../ts-interfaces/record-instance';
-import constructResource from '../../utils/construct-resource';
-import type CoreStore from '../core-store';
+} from '@ember-data/types/q/record-data-schemas';
+import type { RecordDataStoreWrapper as StoreWrapper } from '@ember-data/types/q/record-data-store-wrapper';
+
+import type Store from './core-store';
+import type { IdentifierCache } from './identifier-cache';
 import { internalModelFactoryFor } from './internal-model-factory';
+import constructResource from './utils/construct-resource';
 
 /**
   @module @ember-data/store
@@ -39,9 +38,9 @@ if (HAS_RECORD_DATA_PACKAGE) {
 export default class RecordDataStoreWrapper implements StoreWrapper {
   declare _willNotify: boolean;
   declare _pendingNotifies: Map<StableRecordIdentifier, Map<string, string>>;
-  declare _store: CoreStore;
+  declare _store: Store;
 
-  constructor(_store: CoreStore) {
+  constructor(_store: Store) {
     this._store = _store;
     this._willNotify = false;
     this._pendingNotifies = new Map();
@@ -108,11 +107,11 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   }
 
   attributesDefinitionFor(type: string): AttributesSchema {
-    return this._store._attributesDefinitionFor({ type });
+    return this._store.getSchemaDefinitionService().attributesDefinitionFor({ type });
   }
 
   relationshipsDefinitionFor(type: string): RelationshipsSchema {
-    return this._store._relationshipsDefinitionFor({ type });
+    return this._store.getSchemaDefinitionService().relationshipsDefinitionFor({ type });
   }
 
   inverseForRelationship(type: string, key: string): string | null {
@@ -152,15 +151,15 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     }
   }
 
-  notifyPropertyChange(type: string, id: string | null, lid: string, key: string): void;
-  notifyPropertyChange(type: string, id: string, lid: string | null | undefined, key: string): void;
-  notifyPropertyChange(type: string, id: string | null, lid: string | null | undefined, key: string): void {
+  notifyPropertyChange(type: string, id: string | null, lid: string, key?: string): void;
+  notifyPropertyChange(type: string, id: string, lid: string | null | undefined, key?: string): void;
+  notifyPropertyChange(type: string, id: string | null, lid: string | null | undefined, key?: string): void {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     let internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
     if (internalModel) {
-      internalModel.notifyPropertyChange(key);
+      internalModel.notifyAttributes(key ? [key] : []);
     }
   }
 
@@ -207,11 +206,11 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
       identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     }
 
-    return this._store.recordDataFor(identifier, isCreate);
+    return this._store._instanceCache.recordDataFor(identifier, isCreate);
   }
 
   setRecordId(type: string, id: string, lid: string) {
-    this._store.setRecordId(type, id, lid);
+    this._store._instanceCache.setRecordId(type, id, lid);
   }
 
   isRecordInUse(type: string, id: string | null, lid: string): boolean;
@@ -219,14 +218,10 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   isRecordInUse(type: string, id: string | null, lid?: string | null): boolean {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    const internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
-    if (!internalModel) {
-      return false;
-    }
+    const record = this._store._instanceCache.peek({ identifier, bucket: 'record' });
 
-    const record = internalModel._record as RecordInstance;
-    return record && !(record.isDestroyed || record.isDestroying);
+    return record ? !(record.isDestroyed || record.isDestroying) : false;
   }
 
   disconnectRecord(type: string, id: string | null, lid: string): void;