@ember-data/store 4.6.1 → 4.7.0

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

@@ -0,0 +1,924 @@
+/**
+  @module @ember-data/store
+*/
+import { assert, deprecate } from '@ember/debug';
+import { get, set } from '@ember/object';
+import { dependentKeyCompat } from '@ember/object/compat';
+import { compare } from '@ember/utils';
+import { DEBUG } from '@glimmer/env';
+import { tracked } from '@glimmer/tracking';
+import Ember from 'ember';
+
+import {
+  DEPRECATE_A_USAGE,
+  DEPRECATE_ARRAY_LIKE,
+  DEPRECATE_PROMISE_PROXIES,
+  DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS,
+} from '@ember-data/private-build-infra/deprecations';
+import { Links, 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 { Dict } from '@ember-data/types/q/utils';
+
+import { recordIdentifierFor } from '../caches/instance-cache';
+import type RecordArrayManager from '../managers/record-array-manager';
+import { PromiseArray, promiseArray } from '../proxies/promise-proxies';
+import type Store from '../store-service';
+
+type KeyType = string | symbol | number;
+const ARRAY_GETTER_METHODS = new Set<KeyType>([
+  Symbol.iterator,
+  'concat',
+  'entries',
+  'every',
+  'fill',
+  'filter',
+  'find',
+  'findIndex',
+  'flat',
+  'flatMap',
+  'forEach',
+  'includes',
+  'indexOf',
+  'join',
+  'keys',
+  'lastIndexOf',
+  'map',
+  'reduce',
+  'reduceRight',
+  'slice',
+  'some',
+  'values',
+]);
+const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
+const SYNC_PROPS = new Set<KeyType>(['[]', 'length', 'links', 'meta']);
+function isArrayGetter(prop: KeyType): boolean {
+  return ARRAY_GETTER_METHODS.has(prop);
+}
+function isArraySetter(prop: KeyType): boolean {
+  return ARRAY_SETTER_METHODS.has(prop);
+}
+
+export const IDENTIFIER_ARRAY_TAG = Symbol('#tag');
+export const SOURCE = Symbol('#source');
+export const MUTATE = Symbol('#update');
+
+function convertToInt(prop: KeyType): number | null {
+  if (typeof prop === 'symbol') return null;
+
+  const num = Number(prop);
+
+  if (isNaN(num)) return null;
+
+  return num % 1 === 0 ? num : null;
+}
+
+class Tag {
+  @tracked ref = null;
+  shouldReset: boolean = false;
+}
+
+type ProxiedMethod = (...args: unknown[]) => unknown;
+declare global {
+  interface ProxyConstructor {
+    new <TSource extends object, TTarget extends object>(target: TSource, handler: ProxyHandler<TSource>): TTarget;
+  }
+}
+
+export type IdentifierArrayCreateOptions = {
+  identifiers: StableRecordIdentifier[];
+  type: string;
+  store: Store;
+  allowMutation: boolean;
+  manager: RecordArrayManager;
+  links?: Links | PaginationLinks | null;
+  meta?: Dict<unknown> | null;
+};
+
+function deprecateArrayLike(className: string, fnName: string, replName: string) {
+  deprecate(
+    `The \`${fnName}\` method on the class ${className} is deprecated. Use the native array method \`${replName}\` instead.`,
+    false,
+    {
+      id: 'ember-data:deprecate-array-like',
+      until: '5.0',
+      since: { enabled: '4.8', available: '4.8' },
+      for: 'ember-data',
+    }
+  );
+}
+
+interface PrivateState {
+  links: Links | PaginationLinks | null;
+  meta: Dict<unknown> | null;
+}
+
+/**
+  A record array is an array that contains records of a certain type (or modelName).
+  The record array materializes records as needed when they are retrieved for the first
+  time. You should not create record arrays yourself. Instead, an instance of
+  `RecordArray` or its subclasses will be returned by your application's store
+  in response to queries.
+
+  This class should not be imported and instantiated by consuming applications.
+
+  @class RecordArray
+  @public
+*/
+
+interface IdentifierArray {
+  [MUTATE]?(prop: string, args: unknown[], result?: unknown): void;
+}
+interface IdentifierArray extends Array<RecordInstance> {}
+class IdentifierArray {
+  declare DEPRECATED_CLASS_NAME: string;
+  /**
+    The flag to signal a `RecordArray` is currently loading data.
+    Example
+    ```javascript
+    let people = store.peekAll('person');
+    people.isUpdating; // false
+    people.update();
+    people.isUpdating; // true
+    ```
+    @property isUpdating
+    @public
+    @type Boolean
+  */
+  @tracked isUpdating: boolean = false;
+  isLoaded: boolean = true;
+  isDestroying: boolean = false;
+  isDestroyed: boolean = false;
+  _updatingPromise: PromiseArray<RecordInstance, IdentifierArray> | Promise<IdentifierArray> | null = null;
+
+  [IDENTIFIER_ARRAY_TAG] = new Tag();
+  [SOURCE]: StableRecordIdentifier[];
+
+  declare links: Links | PaginationLinks | null;
+  declare meta: Dict<unknown> | null;
+
+  /**
+   The modelClass represented by this record array.
+
+   @property type
+    @public
+    @deprecated
+   @type {subclass of Model}
+   */
+  declare modelName: string;
+  /**
+    The store that created this record array.
+
+    @property store
+    @private
+    @type Store
+    */
+  declare store: Store;
+  declare _manager: RecordArrayManager;
+
+  destroy() {
+    this.isDestroying = true;
+    // changing the reference breaks the Proxy
+    // this[SOURCE] = [];
+    this[SOURCE].length = 0;
+    this[IDENTIFIER_ARRAY_TAG].ref = null;
+    this.isDestroyed = true;
+  }
+
+  // length must be on self for proxied methods to work properly
+  @dependentKeyCompat
+  get length() {
+    return this[SOURCE].length;
+  }
+  set length(value) {
+    this[SOURCE].length = value;
+  }
+
+  constructor(options: IdentifierArrayCreateOptions) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let self = this;
+    this.modelName = options.type;
+    this.store = options.store;
+    this._manager = options.manager;
+    this[SOURCE] = options.identifiers;
+    const store = options.store;
+    const boundFns = new Map<KeyType, ProxiedMethod>();
+    const _TAG = this[IDENTIFIER_ARRAY_TAG];
+    const PrivateState: PrivateState = {
+      links: options.links || null,
+      meta: options.meta || null,
+    };
+    let transaction: boolean = false;
+
+    // when a mutation occurs
+    // we track all mutations within the call
+    // and forward them as one
+
+    const proxy = new Proxy<StableRecordIdentifier[], RecordInstance[]>(this[SOURCE], {
+      get(target: StableRecordIdentifier[], prop: KeyType, receiver: IdentifierArray): unknown {
+        let index = convertToInt(prop);
+        if (_TAG.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
+          options.manager._syncArray(receiver as unknown as IdentifierArray);
+          _TAG.shouldReset = false;
+        }
+
+        if (index !== null) {
+          const identifier = target[index];
+          if (!transaction) {
+            _TAG.ref;
+          }
+          return identifier && store._instanceCache.getRecord(identifier);
+        }
+
+        if (prop === 'meta') return _TAG.ref, PrivateState.meta;
+        if (prop === 'links') return _TAG.ref, PrivateState.links;
+        if (prop === '[]') return _TAG.ref, receiver;
+
+        if (isArrayGetter(prop)) {
+          let fn = boundFns.get(prop);
+
+          if (fn === undefined) {
+            fn = function () {
+              _TAG.ref;
+              // array functions must run through Reflect to work properly
+              // binding via other means will not work.
+              transaction = true;
+              let result = Reflect.apply(target[prop] as ProxiedMethod, receiver, arguments) as unknown;
+              transaction = false;
+              return result;
+            };
+
+            boundFns.set(prop, fn);
+          }
+
+          return fn;
+        }
+
+        if (isArraySetter(prop)) {
+          let fn = boundFns.get(prop);
+
+          if (fn === undefined) {
+            fn = function () {
+              // array functions must run through Reflect to work properly
+              // binding via other means will not work.
+              if (!options.allowMutation) {
+                assert(`Mutating this array of records via ${String(prop)} is not allowed.`, options.allowMutation);
+                return;
+              }
+              const args: unknown[] = Array.prototype.slice.call(arguments);
+              assert(`Cannot start a new array transaction while a previous transaction is underway`, !transaction);
+              transaction = true;
+              let result = Reflect.apply(target[prop] as ProxiedMethod, receiver, args) as unknown;
+              self[MUTATE]!(prop as string, args, result);
+              _TAG.ref = null;
+              // TODO handle cache updates
+              transaction = false;
+              return result;
+            };
+
+            boundFns.set(prop, fn);
+          }
+
+          return fn;
+        }
+
+        if (prop in self) {
+          if (DEPRECATE_ARRAY_LIKE) {
+            if (prop === 'firstObject') {
+              deprecateArrayLike(self.DEPRECATED_CLASS_NAME, prop, '[0]');
+              return receiver.at(0);
+            } else if (prop === 'lastObject') {
+              deprecateArrayLike(self.DEPRECATED_CLASS_NAME, prop, 'at(-1)');
+              return receiver.at(-1);
+            }
+          }
+
+          let fn = boundFns.get(prop);
+          if (fn) return fn;
+
+          let outcome: unknown = self[prop];
+
+          if (typeof outcome === 'function') {
+            fn = function () {
+              _TAG.ref;
+              // array functions must run through Reflect to work properly
+              // binding via other means will not work.
+              return Reflect.apply(outcome as ProxiedMethod, receiver, arguments) as unknown;
+            };
+
+            boundFns.set(prop, fn);
+            return fn;
+          }
+
+          return _TAG.ref, outcome;
+        }
+
+        return target[prop];
+      },
+
+      set(target: StableRecordIdentifier[], prop: KeyType, value: unknown /*, receiver */): boolean {
+        if (prop === 'length') {
+          if (!transaction && value === 0) {
+            transaction = true;
+            _TAG.ref = null;
+            Reflect.set(target, prop, value);
+            self[MUTATE]!('length 0', []);
+            transaction = false;
+            return true;
+          } else if (transaction) {
+            return Reflect.set(target, prop, value);
+          } else {
+            assert(`unexpected length set`);
+          }
+        }
+        if (prop === 'links') {
+          PrivateState.links = (value || null) as PaginationLinks | Links | null;
+          return true;
+        }
+        if (prop === 'meta') {
+          PrivateState.meta = (value || null) as Dict<unknown> | null;
+          return true;
+        }
+        let index = convertToInt(prop);
+
+        if (index === null || index > target.length) {
+          if (prop in self) {
+            self[prop] = value;
+            return true;
+          }
+          return false;
+        }
+
+        if (!options.allowMutation) {
+          assert(`Mutating ${String(prop)} on this RecordArray is not allowed.`, options.allowMutation);
+          return false;
+        }
+
+        let original: StableRecordIdentifier | undefined = target[index];
+        let newIdentifier = extractIdentifierFromRecord(value as RecordInstance);
+        (target as unknown as Record<KeyType, unknown>)[index] = newIdentifier;
+        if (!transaction) {
+          self[MUTATE]!('replace cell', [index, original, newIdentifier]);
+          _TAG.ref = null;
+        }
+
+        return true;
+      },
+
+      deleteProperty(target: StableRecordIdentifier[], prop: string | symbol): boolean {
+        assert(`Deleting keys on managed arrays is disallowed`, transaction);
+        if (!transaction) {
+          return false;
+        }
+        return Reflect.deleteProperty(target, prop);
+      },
+
+      getPrototypeOf() {
+        return IdentifierArray.prototype;
+      },
+    }) as IdentifierArray;
+
+    if (DEPRECATE_A_USAGE) {
+      const meta = Ember.meta(this);
+      meta.hasMixin = (mixin: Object) => {
+        deprecate(`Do not call A() on EmberData RecordArrays`, false, {
+          id: 'ember-data:no-a-with-array-like',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        });
+        // @ts-expect-error ArrayMixin is more than a type
+        if (mixin === NativeArray || mixin === ArrayMixin) {
+          return true;
+        }
+        return false;
+      };
+    } else if (DEBUG) {
+      const meta = Ember.meta(this);
+      meta.hasMixin = (mixin: Object) => {
+        assert(`Do not call A() on EmberData RecordArrays`);
+      };
+    }
+
+    return proxy;
+  }
+
+  /**
+    Used to get the latest version of all of the records in this array
+    from the adapter.
+
+    Example
+
+    ```javascript
+    let people = store.peekAll('person');
+    people.isUpdating; // false
+
+    people.update().then(function() {
+      people.isUpdating; // false
+    });
+
+    people.isUpdating; // true
+    ```
+
+    @method update
+    @public
+  */
+  update(): PromiseArray<RecordInstance, IdentifierArray> | Promise<IdentifierArray> {
+    if (this.isUpdating) {
+      return this._updatingPromise!;
+    }
+
+    this.isUpdating = true;
+
+    let updatingPromise = this._update();
+    updatingPromise.finally(() => {
+      this._updatingPromise = null;
+      if (this.isDestroying || this.isDestroyed) {
+        return;
+      }
+      this.isUpdating = false;
+    });
+
+    this._updatingPromise = updatingPromise;
+
+    return updatingPromise;
+  }
+
+  /*
+    Update this RecordArray and return a promise which resolves once the update
+    is finished.
+   */
+  _update(): PromiseArray<RecordInstance, IdentifierArray> | Promise<IdentifierArray> {
+    return this.store.findAll(this.modelName, { reload: true });
+  }
+
+  // TODO deprecate
+  /**
+    Saves all of the records in the `RecordArray`.
+
+    Example
+
+    ```javascript
+    let messages = store.peekAll('message');
+    messages.forEach(function(message) {
+      message.hasBeenSeen = true;
+    });
+    messages.save();
+    ```
+
+    @method save
+    @public
+    @return {PromiseArray} promise
+  */
+  save(): PromiseArray<RecordInstance, IdentifierArray> | Promise<IdentifierArray> {
+    let promise = Promise.all(this.map((record) => this.store.saveRecord(record))).then(() => this);
+
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseArray<RecordInstance, IdentifierArray>(promise);
+    }
+
+    return promise;
+  }
+}
+
+export default IdentifierArray;
+
+if (DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS) {
+  Object.defineProperty(IdentifierArray.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);
+    },
+  });
+}
+
+export type CollectionCreateOptions = IdentifierArrayCreateOptions & {
+  query: Dict<unknown> | null;
+  isLoaded: boolean;
+};
+export class Collection extends IdentifierArray {
+  query: Dict<unknown> | null = null;
+
+  constructor(options: CollectionCreateOptions) {
+    super(options as IdentifierArrayCreateOptions);
+    this.query = options.query || null;
+    this.isLoaded = options.isLoaded || false;
+  }
+
+  _update(): PromiseArray<RecordInstance, Collection> | Promise<Collection> {
+    const { store, query } = this;
+
+    // TODO save options from initial request?
+    const promise = store.query(this.modelName, query, { _recordArray: this });
+
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseArray(promise);
+    }
+    return promise;
+  }
+
+  destroy() {
+    super.destroy();
+    this._manager._managed.delete(this);
+    this._manager._pending.delete(this);
+  }
+}
+// trick the proxy "in" check
+Collection.prototype.query = null;
+
+// Ensure instanceof works correctly
+// Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
+
+if (DEPRECATE_ARRAY_LIKE) {
+  IdentifierArray.prototype.DEPRECATED_CLASS_NAME = 'RecordArray';
+  Collection.prototype.DEPRECATED_CLASS_NAME = 'RecordArray';
+  const EmberObjectMethods = [
+    'addObserver',
+    'cacheFor',
+    'decrementProperty',
+    'get',
+    'getProperties',
+    'incrementProperty',
+    'notifyPropertyChange',
+    'removeObserver',
+    'set',
+    'setProperties',
+    'toggleProperty',
+  ];
+  EmberObjectMethods.forEach((method) => {
+    IdentifierArray.prototype[method] = function delegatedMethod(...args: unknown[]): unknown {
+      deprecate(
+        `The EmberObject ${method} method on the class ${this.DEPRECATED_CLASS_NAME} is deprecated. Use dot-notation javascript get/set access instead.`,
+        false,
+        {
+          id: 'ember-data:deprecate-array-like',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        }
+      );
+      return (Ember[method] as (...args: unknown[]) => unknown)(this, ...args);
+    };
+  });
+
+  IdentifierArray.prototype.addObject = function (obj: RecordInstance) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'addObject', 'push');
+    let index = this.indexOf(obj);
+    if (index === -1) {
+      this.push(obj);
+    }
+    return this;
+  };
+
+  IdentifierArray.prototype.addObjects = function (objs: RecordInstance[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'addObjects', 'push');
+    objs.forEach((obj: RecordInstance) => {
+      let index = this.indexOf(obj);
+      if (index === -1) {
+        this.push(obj);
+      }
+    });
+    return this;
+  };
+
+  IdentifierArray.prototype.popObject = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'popObject', 'pop');
+    return this.pop() as RecordInstance;
+  };
+
+  IdentifierArray.prototype.pushObject = function (obj: RecordInstance) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'pushObject', 'push');
+    this.push(obj);
+    return obj;
+  };
+
+  IdentifierArray.prototype.pushObjects = function (objs: RecordInstance[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'pushObjects', 'push');
+    this.push(...objs);
+    return this;
+  };
+
+  IdentifierArray.prototype.shiftObject = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'shiftObject', 'shift');
+    return this.shift()!;
+  };
+
+  IdentifierArray.prototype.unshiftObject = function (obj: RecordInstance) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'unshiftObject', 'unshift');
+    this.unshift(obj);
+    return obj;
+  };
+
+  IdentifierArray.prototype.unshiftObjects = function (objs: RecordInstance[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'unshiftObjects', 'unshift');
+    this.unshift(...objs);
+    return this;
+  };
+
+  IdentifierArray.prototype.objectAt = function (index: number) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'objectAt', 'at');
+    return this.at(index);
+  };
+
+  IdentifierArray.prototype.objectsAt = function (indeces: number[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'objectsAt', 'at');
+    return indeces.map((index) => this.at(index)!);
+  };
+
+  IdentifierArray.prototype.removeAt = function (index: number) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeAt', 'splice');
+    this.splice(index, 1);
+    return this;
+  };
+
+  IdentifierArray.prototype.insertAt = function (index: number, obj: RecordInstance) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'insertAt', 'splice');
+    this.splice(index, 0, obj);
+    return this;
+  };
+
+  IdentifierArray.prototype.removeObject = function (obj: RecordInstance) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeObject', 'splice');
+    this.splice(this.indexOf(obj), 1);
+    return this;
+  };
+
+  IdentifierArray.prototype.removeObjects = function (objs: RecordInstance[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeObjects', 'splice');
+    objs.forEach((obj) => this.splice(this.indexOf(obj), 1));
+    return this;
+  };
+
+  IdentifierArray.prototype.toArray = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'unshiftObjects', 'unshift');
+    return this.slice();
+  };
+
+  IdentifierArray.prototype.replace = function (idx: number, amt: number, objects?: RecordInstance[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'replace', 'splice');
+    if (objects) {
+      this.splice(idx, amt, ...objects);
+    } else {
+      this.splice(idx, amt);
+    }
+  };
+
+  IdentifierArray.prototype.clear = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'clear', 'length = 0');
+    this.splice(0, this.length);
+    return this;
+  };
+
+  IdentifierArray.prototype.setObjects = function (objects: RecordInstance[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'clear', 'length = 0');
+    assert(
+      `${this.DEPRECATED_CLASS_NAME}.setObjects expects to receive an array as its argument`,
+      Array.isArray(objects)
+    );
+    this.splice(0, this.length);
+    this.push(...objects);
+    return this;
+  };
+
+  IdentifierArray.prototype.reverseObjects = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'reverseObjects', 'reverse');
+    this.reverse();
+    return this;
+  };
+
+  IdentifierArray.prototype.compact = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'compact', 'filter');
+    return this.filter((v) => v !== null && v !== undefined);
+  };
+
+  IdentifierArray.prototype.any = function (callback, target) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'any', 'some');
+    return this.some(callback, target);
+  };
+
+  IdentifierArray.prototype.isAny = function (prop, value) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'isAny', 'some');
+    let hasValue = arguments.length === 2;
+    return this.some((v) => (hasValue ? v[prop] === value : v[prop] === true));
+  };
+
+  IdentifierArray.prototype.isEvery = function (prop, value) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'isEvery', 'every');
+    let hasValue = arguments.length === 2;
+    return this.every((v) => (hasValue ? v[prop] === value : v[prop] === true));
+  };
+
+  IdentifierArray.prototype.getEach = function (key: string) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'getEach', 'map');
+    return this.map((value) => get(value, key));
+  };
+
+  IdentifierArray.prototype.mapBy = function (key: string) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'mapBy', 'map');
+    return this.map((value) => get(value, key));
+  };
+
+  IdentifierArray.prototype.findBy = function (key: string, value?: unknown) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'findBy', 'find');
+    if (arguments.length === 2) {
+      return this.find((val) => {
+        return get(val, key) === value;
+      });
+    } else {
+      return this.find((val) => Boolean(get(val, key)));
+    }
+  };
+
+  IdentifierArray.prototype.filterBy = function (key: string, value?: unknown) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'filterBy', 'filter');
+    if (arguments.length === 2) {
+      return this.filter((value) => {
+        return Boolean(get(value, key));
+      });
+    }
+    return this.filter((value) => {
+      return Boolean(get(value, key));
+    });
+  };
+
+  IdentifierArray.prototype.sortBy = function (...sortKeys: string[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'sortBy', '.slice().sort');
+    return this.slice().sort((a, b) => {
+      for (let i = 0; i < sortKeys.length; i++) {
+        let key = sortKeys[i];
+        let propA = get(a, key);
+        let propB = get(b, key);
+        // return 1 or -1 else continue to the next sortKey
+        let compareValue = compare(propA, propB);
+
+        if (compareValue) {
+          return compareValue;
+        }
+      }
+      return 0;
+    });
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.invoke = function (key: string, ...args: unknown[]) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'invoke', 'forEach');
+    return this.map((value) => (value[key] as (...args: unknown[]) => unknown)(...args));
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.addArrayObserver = function () {
+    deprecateArrayLike(
+      this.DEPRECATED_CLASS_NAME,
+      'addArrayObserver',
+      'derived state or reacting at the change source'
+    );
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.removeArrayObserver = function () {
+    deprecateArrayLike(
+      this.DEPRECATED_CLASS_NAME,
+      'removeArrayObserver',
+      'derived state or reacting at the change source'
+    );
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.arrayContentWillChange = function () {
+    deprecateArrayLike(
+      this.DEPRECATED_CLASS_NAME,
+      'arrayContentWillChange',
+      'derived state or reacting at the change source'
+    );
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.arrayContentDidChange = function () {
+    deprecateArrayLike(
+      this.DEPRECATED_CLASS_NAME,
+      'arrayContentDidChange',
+      'derived state or reacting at the change source.'
+    );
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.reject = function (key: string, value?: unknown) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'reject', 'filter');
+    if (arguments.length === 2) {
+      return this.filter((value) => {
+        return !get(value, key);
+      });
+    }
+    return this.filter((value) => {
+      return !get(value, key);
+    });
+  };
+
+  IdentifierArray.prototype.rejectBy = function (key: string, value?: unknown) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'rejectBy', 'filter');
+    if (arguments.length === 2) {
+      return this.filter((value) => {
+        return !get(value, key);
+      });
+    }
+    return this.filter((value) => {
+      return !get(value, key);
+    });
+  };
+
+  IdentifierArray.prototype.setEach = function (key: string, value: unknown) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'setEach', 'forEach');
+    this.forEach((item) => set(item, key, value));
+  };
+
+  IdentifierArray.prototype.uniq = function () {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'uniq', 'filter');
+    // all current managed arrays are already enforced as unique
+    return this.slice();
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.uniqBy = function (key: string) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'uniqBy', 'filter');
+    // all current managed arrays are already enforced as unique
+    let seen = new Set();
+    let result: RecordInstance[] = [];
+    this.forEach((item) => {
+      let value = get(item, key);
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+      result.push(item);
+    });
+    return result;
+  };
+
+  IdentifierArray.prototype.without = function (value: RecordInstance) {
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'without', 'slice');
+    const newArr = this.slice();
+    const index = this.indexOf(value);
+    if (index !== -1) {
+      newArr.splice(index, 1);
+    }
+    return newArr;
+  };
+
+  // @ts-expect-error
+  IdentifierArray.prototype.firstObject = null;
+  // @ts-expect-error
+  IdentifierArray.prototype.lastObject = null;
+}
+
+type PromiseProxyRecord = { then(): void; content: RecordInstance | null | undefined };
+
+function assertRecordPassedToHasMany(record: RecordInstance | PromiseProxyRecord) {
+  assert(
+    `All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`,
+    (function () {
+      try {
+        recordIdentifierFor(record);
+        return true;
+      } catch {
+        return false;
+      }
+    })()
+  );
+}
+
+function extractIdentifierFromRecord(recordOrPromiseRecord: PromiseProxyRecord | RecordInstance | null) {
+  if (!recordOrPromiseRecord) {
+    return null;
+  }
+
+  if (isPromiseRecord(recordOrPromiseRecord)) {
+    let content = recordOrPromiseRecord.content;
+    assert(
+      'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo relationship.',
+      content !== undefined && content !== null
+    );
+    assertRecordPassedToHasMany(content);
+    return recordIdentifierFor(content);
+  }
+
+  assertRecordPassedToHasMany(recordOrPromiseRecord);
+  return recordIdentifierFor(recordOrPromiseRecord);
+}
+
+function isPromiseRecord(record: PromiseProxyRecord | RecordInstance): record is PromiseProxyRecord {
+  return !!record.then;
+}