@ember-data/store 4.6.1 → 4.7.0

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

@@ -1,20 +1,15 @@
 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' : ''
-);
+const RecordDataForIdentifierCache = new Map<StableRecordIdentifier | RecordInstance, RecordData>();
 
 export function setRecordDataFor(identifier: StableRecordIdentifier | RecordInstance, recordData: RecordData): void {
   assert(
@@ -24,7 +19,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,58 @@
   @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';
+  isStableIdentifier,
+} 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';
 
-// `ember-data-model-fragments` relies on `InternalModel`
-export { default as InternalModel } from './model/internal-model';
-
-export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './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 RecordArray,
+  default as IdentifierArray,
+  Collection as AdapterPopulatedRecordArray,
+  SOURCE,
+  MUTATE,
+  IDENTIFIER_ARRAY_TAG,
+} from './record-arrays/identifier-array';
+export { default as RecordArrayManager, fastPush } 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';

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

@@ -1,18 +1,21 @@
-import { DEBUG } from '@glimmer/env';
-
 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';
+
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap<Store, Dict<ShimModelClass>>();
 
-const AvailableShims = new WeakCache<Store, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
-AvailableShims._generator = () => {
-  return Object.create(null) as Dict<ShimModelClass>;
-};
 export function getShimClass(store: Store, modelName: string): ShimModelClass {
-  let shims = AvailableShims.lookup(store);
+  let shims = AvailableShims.get(store);
+
+  if (!shims) {
+    shims = Object.create(null) as Dict<ShimModelClass>;
+    AvailableShims.set(store, shims);
+  }
+
   let shim = shims[modelName];
   if (shim === undefined) {
     shim = shims[modelName] = new ShimModelClass(store, modelName);
@@ -33,8 +36,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/managers/record-array-manager.ts

@@ -0,0 +1,377 @@
+/**
+  @module @ember-data/store
+*/
+import type { CollectionResourceDocument } 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 IdentifierArray, {
+  Collection,
+  CollectionCreateOptions,
+  IDENTIFIER_ARRAY_TAG,
+  SOURCE,
+} from '../record-arrays/identifier-array';
+import type Store from '../store-service';
+
+const RecordArraysCache = new Map<StableRecordIdentifier, Set<Collection>>();
+const FAKE_ARR = {};
+
+const SLICE_BATCH_SIZE = 1200;
+/**
+ * This is a clever optimization.
+ *
+ * clever optimizations rarely stand the test of time, so if you're
+ * ever curious or think something better is possible please benchmark
+ * and discuss. The benchmark for this at the time of writing is in
+ * `scripts/benchmark-push.js`
+ *
+ * This approach turns out to be 150x faster in Chrome and node than
+ * simply using push or concat. It's highly susceptible to the specifics
+ * of the batch size, and may require tuning.
+ *
+ * Clever optimizations should always come with a `why`. This optimization
+ * exists for two reasons.
+ *
+ * 1) array.push(...objects) and Array.prototype.push.apply(arr, objects)
+ *   are susceptible to stack overflows. The size of objects at which this
+ *   occurs varies by environment, browser, and current stack depth and memory
+ *   pressure; however, it occurs in all browsers in fairly pristine conditions
+ *   somewhere around 125k to 200k elements. Since EmberData regularly encounters
+ *   arrays larger than this in size, we cannot use push.
+ *
+ * 2) `array.concat` or simply setting the array to a new reference is often an
+ *   easier approach; however, native Proxy to an array cannot swap it's target array
+ *   and attempts at juggling multiple array sources have proven to be victim to a number
+ *   of browser implementation bugs. Should these bugs be addressed then we could
+ *   simplify to using `concat`, however, do note this is currently 150x faster
+ *   than concat, and due to the overloaded signature of concat will likely always
+ *   be faster.
+ *
+ * Sincerely,
+ *   - runspired (Chris Thoburn) 08/21/2022
+ *
+ * @function fastPush
+ * @internal
+ * @param target the array to push into
+ * @param source the items to push into target
+ */
+export function fastPush<T>(target: T[], source: T[]) {
+  let startLength = 0;
+  let newLength = source.length;
+  while (newLength - startLength > SLICE_BATCH_SIZE) {
+    // eslint-disable-next-line prefer-spread
+    target.push.apply(target, source.slice(startLength, SLICE_BATCH_SIZE));
+    startLength += SLICE_BATCH_SIZE;
+  }
+  // eslint-disable-next-line prefer-spread
+  target.push.apply(target, source.slice(startLength));
+}
+
+type ChangeSet = Map<StableRecordIdentifier, 'add' | 'del'>;
+
+/**
+  @class RecordArrayManager
+  @internal
+*/
+class RecordArrayManager {
+  declare store: Store;
+  declare isDestroying: boolean;
+  declare isDestroyed: boolean;
+  declare _live: Map<string, IdentifierArray>;
+  declare _managed: Set<IdentifierArray>;
+  declare _pending: Map<IdentifierArray, ChangeSet>;
+  declare _identifiers: Map<StableRecordIdentifier, Set<Collection>>;
+  declare _staged: Map<string, ChangeSet>;
+
+  constructor(options: { store: Store }) {
+    this.store = options.store;
+    this.isDestroying = false;
+    this.isDestroyed = false;
+    this._live = new Map();
+    this._managed = new Set();
+    this._pending = new Map();
+    this._staged = new Map();
+    this._identifiers = RecordArraysCache;
+  }
+
+  _syncArray(array: IdentifierArray) {
+    const pending = this._pending.get(array);
+
+    if (!pending || this.isDestroying || this.isDestroyed) {
+      return;
+    }
+
+    sync(array, pending);
+    this._pending.delete(array);
+  }
+
+  /**
+    Get the `RecordArray` for a modelName, which contains all loaded records of
+    given modelName.
+
+    @method liveArrayFor
+    @internal
+    @param {String} modelName
+    @return {RecordArray}
+  */
+  liveArrayFor(type: string): IdentifierArray {
+    let array = this._live.get(type);
+    let identifiers: StableRecordIdentifier[] = [];
+    let staged = this._staged.get(type);
+    if (staged) {
+      staged.forEach((value, key) => {
+        if (value === 'add') {
+          identifiers.push(key);
+        }
+      });
+      this._staged.delete(type);
+    }
+
+    if (!array) {
+      array = new IdentifierArray({
+        type,
+        identifiers,
+        store: this.store,
+        allowMutation: false,
+        manager: this,
+      });
+      this._live.set(type, array);
+    }
+
+    return array;
+  }
+
+  createArray(config: {
+    type: string;
+    query?: Dict<unknown>;
+    identifiers?: StableRecordIdentifier[];
+    doc?: CollectionResourceDocument;
+  }): Collection {
+    let options: CollectionCreateOptions = {
+      type: config.type,
+      links: config.doc?.links || null,
+      meta: config.doc?.meta || null,
+      query: config.query || null,
+      identifiers: config.identifiers || [],
+      isLoaded: !!config.identifiers?.length,
+      allowMutation: false,
+      store: this.store,
+      manager: this,
+    };
+    let array = new Collection(options);
+    this._managed.add(array);
+    if (config.identifiers) {
+      associate(array, config.identifiers);
+    }
+
+    return array;
+  }
+
+  dirtyArray(array: IdentifierArray): void {
+    if (array === FAKE_ARR) {
+      return;
+    }
+    let tag = array[IDENTIFIER_ARRAY_TAG];
+    if (!tag.shouldReset) {
+      tag.shouldReset = true;
+      tag.ref = null;
+    }
+  }
+
+  _getPendingFor(
+    identifier: StableRecordIdentifier,
+    includeManaged: boolean,
+    isRemove?: boolean
+  ): Map<IdentifierArray, ChangeSet> | void {
+    if (this.isDestroying || this.isDestroyed) {
+      return;
+    }
+
+    let liveArray = this._live.get(identifier.type);
+    const allPending = this._pending;
+    let pending: Map<IdentifierArray, ChangeSet> = new Map();
+
+    if (includeManaged) {
+      let managed = RecordArraysCache.get(identifier);
+      if (managed) {
+        managed.forEach((arr) => {
+          let changes = allPending.get(arr);
+          if (!changes) {
+            changes = new Map();
+            allPending.set(arr, changes);
+          }
+          pending.set(arr, changes);
+        });
+      }
+    }
+
+    // during unloadAll we can ignore removes since we've already
+    // cleared the array.
+    if (liveArray && liveArray[SOURCE].length === 0 && isRemove) {
+      return pending;
+    }
+
+    if (!liveArray) {
+      // start building a changeset for when we eventually
+      // do have a live array
+      let changes = this._staged.get(identifier.type);
+      if (!changes) {
+        changes = new Map();
+        this._staged.set(identifier.type, changes);
+      }
+      pending.set(FAKE_ARR as IdentifierArray, changes);
+    } else {
+      let changes = allPending.get(liveArray);
+      if (!changes) {
+        changes = new Map();
+        allPending.set(liveArray, changes);
+      }
+      pending.set(liveArray, changes);
+    }
+
+    return pending;
+  }
+
+  populateManagedArray(array: Collection, identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument) {
+    this._pending.delete(array);
+    const source = array[SOURCE];
+    const old = source.slice();
+    source.length = 0;
+    fastPush(source, identifiers);
+    array[IDENTIFIER_ARRAY_TAG].ref = null;
+    array.meta = payload.meta || null;
+    array.links = payload.links || null;
+    array.isLoaded = true;
+
+    disassociate(array, old);
+    associate(array, identifiers);
+  }
+
+  identifierAdded(identifier: StableRecordIdentifier): void {
+    let changeSets = this._getPendingFor(identifier, false);
+    if (changeSets) {
+      changeSets.forEach((changes, array) => {
+        let existing = changes.get(identifier);
+        if (existing === 'del') {
+          changes.delete(identifier);
+        } else {
+          changes.set(identifier, 'add');
+
+          if (changes.size === 1) {
+            this.dirtyArray(array);
+          }
+        }
+      });
+    }
+  }
+
+  identifierRemoved(identifier: StableRecordIdentifier): void {
+    let changeSets = this._getPendingFor(identifier, true, true);
+    if (changeSets) {
+      changeSets.forEach((changes, array) => {
+        let existing = changes.get(identifier);
+        if (existing === 'add') {
+          changes.delete(identifier);
+        } else {
+          changes.set(identifier, 'del');
+
+          if (changes.size === 1) {
+            this.dirtyArray(array);
+          }
+        }
+      });
+    }
+  }
+
+  identifierChanged(identifier: StableRecordIdentifier): void {
+    let newState = this.store._instanceCache.recordIsLoaded(identifier, true);
+
+    if (newState) {
+      this.identifierAdded(identifier);
+    } else {
+      this.identifierRemoved(identifier);
+    }
+  }
+
+  clear() {
+    this._live.forEach((array) => array.destroy());
+    this._managed.forEach((array) => array.destroy());
+    this._managed.clear();
+    RecordArraysCache.clear();
+  }
+
+  destroy() {
+    this.isDestroying = true;
+    this.clear();
+    this._live.clear();
+    this.isDestroyed = true;
+  }
+}
+
+function associate(array: Collection, identifiers: StableRecordIdentifier[]) {
+  for (let i = 0; i < identifiers.length; i++) {
+    let identifier = identifiers[i];
+    let cache = RecordArraysCache.get(identifier);
+    if (!cache) {
+      cache = new Set();
+      RecordArraysCache.set(identifier, cache);
+    }
+    cache.add(array);
+  }
+}
+
+function disassociate(array: Collection, identifiers: StableRecordIdentifier[]) {
+  for (let i = 0; i < identifiers.length; i++) {
+    disassociateIdentifier(array, identifiers[i]);
+  }
+}
+
+export function disassociateIdentifier(array: Collection, identifier: StableRecordIdentifier) {
+  let cache = RecordArraysCache.get(identifier);
+  if (cache) {
+    cache.delete(array);
+  }
+}
+
+function sync(array: IdentifierArray, changes: Map<StableRecordIdentifier, 'add' | 'del'>) {
+  let state = array[SOURCE];
+  const adds: StableRecordIdentifier[] = [];
+  const removes: StableRecordIdentifier[] = [];
+  changes.forEach((value, key) => {
+    if (value === 'add') {
+      // likely we want to keep a Set along-side
+      if (state.includes(key)) {
+        return;
+      }
+      adds.push(key);
+    } else {
+      removes.push(key);
+    }
+  });
+  if (removes.length) {
+    if (removes.length === state.length) {
+      state.length = 0;
+      // changing the reference breaks the Proxy
+      // state = array[SOURCE] = [];
+    } else {
+      removes.forEach((i) => {
+        state.splice(state.indexOf(i), 1);
+      });
+    }
+  }
+
+  if (adds.length) {
+    fastPush(state, adds);
+    // changing the reference breaks the Proxy
+    // else we could do this
+    /*
+    if (state.length === 0) {
+      array[SOURCE] = adds;
+    } else {
+      array[SOURCE] = state.concat(adds);
+    }
+    */
+  }
+}
+
+export default RecordArrayManager;