@ember-data/store 4.8.0-alpha.1 → 4.8.0-alpha.4

package/addon/-private/{record-data-for.ts → caches/record-data-for.ts}

@@ -5,7 +5,7 @@ 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';
+import WeakCache from '../utils/weak-cache';
 
 /*
  * Returns the RecordData instance associated with a given
@@ -24,7 +24,7 @@ export function setRecordDataFor(identifier: StableRecordIdentifier | RecordInst
   RecordDataForIdentifierCache.set(identifier, recordData);
 }
 
-export function removeRecordDataFor(identifier: StableRecordIdentifier): void {
+export function removeRecordDataFor(identifier: StableRecordIdentifier | RecordInstance): void {
   RecordDataForIdentifierCache.delete(identifier);
 }
 

package/addon/-private/index.ts

@@ -2,38 +2,55 @@
   @module @ember-data/store
 */
 
-export { default as Store, storeFor } from './core-store';
+import { assert, deprecate } from '@ember/debug';
 
-export { recordIdentifierFor } from './internal-model-factory';
+import { DEPRECATE_HELPERS } from '@ember-data/private-build-infra/deprecations';
 
-export { default as Snapshot } from './snapshot';
+import _normalize from './utils/normalize-model-name';
+
+export { default as Store, storeFor } from './store-service';
+
+export { recordIdentifierFor } from './caches/instance-cache';
+
+export { default as Snapshot } from './network/snapshot';
 export {
   setIdentifierGenerationMethod,
   setIdentifierUpdateMethod,
   setIdentifierForgetMethod,
   setIdentifierResetMethod,
-} from './identifier-cache';
-
-export { default as normalizeModelName } from './normalize-model-name';
-export { default as coerceId } from './coerce-id';
-
-export { errorsHashToArray, errorsArrayToHash } from './errors-utils';
-
-// `ember-data-model-fragments` relies on `InternalModel`
-export { default as InternalModel } from './model/internal-model';
-
-export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './promise-proxies';
+} from './caches/identifier-cache';
+
+export function normalizeModelName(modelName: string) {
+  if (DEPRECATE_HELPERS) {
+    deprecate(
+      `the helper function normalizeModelName is deprecated. You should use model names that are already normalized, or use string helpers of your own. This function is primarily an alias for dasherize from @ember/string.`,
+      false,
+      {
+        id: 'ember-data:deprecate-normalize-modelname-helper',
+        for: 'ember-data',
+        until: '5.0',
+        since: { available: '4.8', enabled: '4.8' },
+      }
+    );
+    return _normalize(modelName);
+  }
+  assert(`normalizeModelName support has been removed`);
+}
+
+// TODO this should be a deprecated helper but we have so much usage of it
+// to also eliminate
+export { default as coerceId } from './utils/coerce-id';
+
+export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './proxies/promise-proxies';
 
 export { default as RecordArray } from './record-arrays/record-array';
 export { default as AdapterPopulatedRecordArray } from './record-arrays/adapter-populated-record-array';
 
-export { default as RecordArrayManager } from './record-array-manager';
+export { default as RecordArrayManager } from './managers/record-array-manager';
 
 // // Used by tests
-export { default as SnapshotRecordArray } from './snapshot-record-array';
-
-// New
-export { default as recordDataFor, removeRecordDataFor } from './record-data-for';
-export { default as RecordDataStoreWrapper } from './record-data-store-wrapper';
+export { default as SnapshotRecordArray } from './network/snapshot-record-array';
 
-export { default as WeakCache } from './weak-cache';
+// leaked for private use / test use, should investigate removing
+export { default as recordDataFor, removeRecordDataFor } from './caches/record-data-for';
+export { default as WeakCache } from './utils/weak-cache';

package/addon/-private/{model → legacy-model-support}/record-reference.ts

@@ -10,9 +10,9 @@ import type { SingleResourceDocument } from '@ember-data/types/q/ember-data-json
 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';
+import type { NotificationType } from '../managers/record-notification-manager';
+import { unsubscribe } from '../managers/record-notification-manager';
+import type Store from '../store-service';
 
 /**
   @module @ember-data/store
@@ -27,18 +27,20 @@ import { unsubscribe } from '../record-notification-manager';
    @extends Reference
 */
 export default class RecordReference {
+  declare store: Store;
   // unsubscribe token given to us by the notification manager
-  #token!: Object;
-  #identifier: StableRecordIdentifier;
+  ___token!: Object;
+  ___identifier: StableRecordIdentifier;
 
   @tracked _ref = 0;
 
-  constructor(public store: Store, identifier: StableRecordIdentifier) {
-    this.#identifier = identifier;
-    this.#token = store._notificationManager.subscribe(
+  constructor(store: Store, identifier: StableRecordIdentifier) {
+    this.store = store;
+    this.___identifier = identifier;
+    this.___token = store._notificationManager.subscribe(
       identifier,
       (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+        if (bucket === 'identity' || (bucket === 'attributes' && notifiedKey === 'id')) {
           this._ref++;
         }
       }
@@ -46,7 +48,7 @@ export default class RecordReference {
   }
 
   destroy() {
-    unsubscribe(this.#token);
+    unsubscribe(this.___token);
   }
 
   get type(): string {
@@ -73,7 +75,7 @@ export default class RecordReference {
   */
   id() {
     this._ref; // consume the tracked prop
-    return this.#identifier.id;
+    return this.___identifier.id;
   }
 
   /**
@@ -95,7 +97,7 @@ export default class RecordReference {
      @return {String} The identifier of the record.
   */
   identifier(): StableRecordIdentifier {
-    return this.#identifier;
+    return this.___identifier;
   }
 
   /**
@@ -183,7 +185,7 @@ export default class RecordReference {
      @return {Model} the record for this RecordReference
   */
   value(): RecordInstance | null {
-    return this.store.peekRecord(this.#identifier);
+    return this.store.peekRecord(this.___identifier);
   }
 
   /**

package/addon/-private/{schema-definition-service.ts → legacy-model-support/schema-definition-service.ts}

@@ -1,6 +1,5 @@
 import { getOwner } from '@ember/application';
 import { deprecate } from '@ember/debug';
-import { get } from '@ember/object';
 
 import { importSync } from '@embroider/macros';
 
@@ -10,8 +9,8 @@ import { DEPRECATE_STRING_ARG_SCHEMAS } from '@ember-data/private-build-infra/de
 import type { RecordIdentifier } from '@ember-data/types/q/identifier';
 import type { AttributesSchema, RelationshipsSchema } from '@ember-data/types/q/record-data-schemas';
 
-import type Store from './core-store';
-import normalizeModelName from './normalize-model-name';
+import type Store from '../store-service';
+import normalizeModelName from '../utils/normalize-model-name';
 
 type ModelForMixin = (store: Store, normalizedModelName: string) => Model | null;
 
@@ -27,10 +26,15 @@ if (HAS_MODEL_PACKAGE) {
 }
 
 export class DSModelSchemaDefinitionService {
-  private _relationshipsDefCache = Object.create(null);
-  private _attributesDefCache = Object.create(null);
-
-  constructor(public store: Store) {}
+  declare store: Store;
+  declare _relationshipsDefCache;
+  declare _attributesDefCache;
+
+  constructor(store: Store) {
+    this.store = store;
+    this._relationshipsDefCache = Object.create(null);
+    this._attributesDefCache = Object.create(null);
+  }
 
   // Following the existing RD implementation
   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
@@ -55,7 +59,7 @@ export class DSModelSchemaDefinitionService {
 
     if (attributes === undefined) {
       let modelClass = this.store.modelFor(modelName);
-      let attributeMap = get(modelClass, 'attributes');
+      let attributeMap = modelClass.attributes;
 
       attributes = Object.create(null);
       attributeMap.forEach((meta, name) => (attributes[name] = meta));
@@ -88,7 +92,7 @@ export class DSModelSchemaDefinitionService {
 
     if (relationships === undefined) {
       let modelClass = this.store.modelFor(modelName);
-      relationships = get(modelClass, 'relationshipsObject') || null;
+      relationships = modelClass.relationshipsObject || null;
       this._relationshipsDefCache[modelName] = relationships;
     }
 

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

@@ -4,8 +4,8 @@ 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';
+import type Store from '../store-service';
+import WeakCache from '../utils/weak-cache';
 
 const AvailableShims = new WeakCache<Store, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
 AvailableShims._generator = () => {
@@ -33,8 +33,12 @@ 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: Store, public modelName: string) {}
+  declare __store: Store;
+  declare modelName: string;
+  constructor(store: Store, modelName: string) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
 
   get fields(): Map<string, 'attribute' | 'belongsTo' | 'hasMany'> {
     let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });

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

@@ -4,20 +4,17 @@
 
 import { A } from '@ember/array';
 import { assert } from '@ember/debug';
-import { set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-// import isStableIdentifier from '../identifiers/is-stable-identifier';
 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';
+import AdapterPopulatedRecordArray from '../record-arrays/adapter-populated-record-array';
+import RecordArray from '../record-arrays/record-array';
+import type Store from '../store-service';
+import WeakCache from '../utils/weak-cache';
 
 const RecordArraysCache = new WeakCache<StableRecordIdentifier, Set<RecordArray>>(DEBUG ? 'record-arrays' : '');
 RecordArraysCache._generator = () => new Set();
@@ -27,27 +24,6 @@ export function recordArraysForIdentifier(identifier: StableRecordIdentifier): S
 
 const pendingForIdentifier: Set<StableRecordIdentifier> = new Set([]);
 
-function getIdentifier(identifier: StableRecordIdentifier): StableRecordIdentifier {
-  // during dematerialization we will get an identifier that
-  // has already been removed from the identifiers cache
-  // so it will not behave as if stable. This is a bug we should fix.
-  // if (!isStableIdentifier(identifierOrInternalModel)) {
-  //   console.log({ unstable: i });
-  // }
-
-  return identifier;
-}
-
-function shouldIncludeInRecordArrays(store: Store, identifier: StableRecordIdentifier): boolean {
-  const cache = internalModelFactoryFor(store);
-  const internalModel = cache.peek(identifier);
-
-  if (internalModel === null) {
-    return false;
-  }
-  return !internalModel.isHiddenFromRecordArrays();
-}
-
 /**
   @class RecordArrayManager
   @internal
@@ -84,6 +60,7 @@ class RecordArrayManager {
       return;
     }
     let identifiersToRemove: StableRecordIdentifier[] = [];
+    let cache = this.store._instanceCache;
 
     for (let j = 0; j < identifiers.length; j++) {
       let i = identifiers[j];
@@ -91,8 +68,7 @@ class RecordArrayManager {
       // recordArrayManager
       pendingForIdentifier.delete(i);
       // build up a set of models to ensure we have purged correctly;
-      let isIncluded = shouldIncludeInRecordArrays(this.store, i);
-      if (!isIncluded) {
+      if (!cache.recordIsLoaded(i, true)) {
         identifiersToRemove.push(i);
       }
     }
@@ -130,8 +106,8 @@ class RecordArrayManager {
       return;
     }
     let hasNoPotentialDeletions = pending.length === 0;
-    let map = internalModelFactoryFor(this.store).modelMapFor(modelName);
-    let hasNoInsertionsOrRemovals = map.length === array.length;
+    let listSize = this.store._instanceCache.peekList[modelName]?.size;
+    let hasNoInsertionsOrRemovals = listSize === array.length;
 
     /*
       Ideally the recordArrayManager has knowledge of the changes to be applied to
@@ -144,6 +120,11 @@ class RecordArrayManager {
     }
 
     this._flushPendingIdentifiersForModelName(modelName, pending);
+    // TODO make this a map
+    // TODO we probably do way too much work here, probably can just take
+    // current all-known state and filter visible.
+    // We can then provide this directly to the RecordArray instance.
+    // If we deprecate RecordArray being an ArrayProxy this will be stellar.
     delete this._pendingIdentifiers[modelName];
 
     let identifiers = this._visibleIdentifiersByType(modelName);
@@ -165,7 +146,7 @@ class RecordArrayManager {
   _didUpdateAll(modelName: string): void {
     let recordArray = this._liveRecordArrays[modelName];
     if (recordArray) {
-      set(recordArray, 'isUpdating', false);
+      recordArray.isUpdating = false;
       // TODO potentially we should sync here, currently
       // this occurs as a side-effect of individual records updating
       // this._syncLiveRecordArray(recordArray, modelName);
@@ -204,13 +185,14 @@ class RecordArrayManager {
   }
 
   _visibleIdentifiersByType(modelName: string) {
-    let all = internalModelFactoryFor(this.store).modelMapFor(modelName).recordIdentifiers;
+    const cache = this.store._instanceCache;
+    const list = cache.peekList[modelName];
+    let all = list ? [...list.values()] : [];
     let visible: StableRecordIdentifier[] = [];
     for (let i = 0; i < all.length; i++) {
       let identifier = all[i];
-      let shouldInclude = shouldIncludeInRecordArrays(this.store, identifier);
 
-      if (shouldInclude) {
+      if (cache.recordIsLoaded(identifier, true)) {
         visible.push(identifier);
       }
     }
@@ -335,7 +317,6 @@ class RecordArrayManager {
   _associateWithRecordArray(identifiers: StableRecordIdentifier[], array: RecordArray): void {
     for (let i = 0, l = identifiers.length; i < l; i++) {
       let identifier = identifiers[i];
-      identifier = getIdentifier(identifier);
       let recordArrays = this.getRecordArraysForIdentifier(identifier);
       recordArrays.add(array);
     }
@@ -350,7 +331,6 @@ class RecordArrayManager {
       return;
     }
     let modelName = identifier.type;
-    identifier = getIdentifier(identifier);
 
     if (pendingForIdentifier.has(identifier)) {
       return;
@@ -397,20 +377,18 @@ function removeFromArray(array: RecordArray[], item: RecordArray): boolean {
 function updateLiveRecordArray(store: Store, recordArray: RecordArray, identifiers: StableRecordIdentifier[]): void {
   let identifiersToAdd: StableRecordIdentifier[] = [];
   let identifiersToRemove: StableRecordIdentifier[] = [];
+  const cache = store._instanceCache;
 
   for (let i = 0; i < identifiers.length; i++) {
     let identifier = identifiers[i];
-    let shouldInclude = shouldIncludeInRecordArrays(store, identifier);
     let recordArrays = recordArraysForIdentifier(identifier);
 
-    if (shouldInclude) {
+    if (cache.recordIsLoaded(identifier, true)) {
       if (!recordArrays.has(recordArray)) {
         identifiersToAdd.push(identifier);
         recordArrays.add(recordArray);
       }
-    }
-
-    if (!shouldInclude) {
+    } else {
       identifiersToRemove.push(identifier);
       recordArrays.delete(recordArray);
     }
@@ -431,7 +409,6 @@ function removeFromAdapterPopulatedRecordArrays(store: Store, identifiers: Stabl
 }
 
 function removeFromAll(store: Store, identifier: StableRecordIdentifier): void {
-  identifier = getIdentifier(identifier);
   const recordArrays = recordArraysForIdentifier(identifier);
 
   recordArrays.forEach(function (recordArray) {