@ember-data/store 4.6.1 → 4.7.0

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

@@ -1,318 +0,0 @@
-/**
-  @module @ember-data/store
-*/
-import type NativeArray from '@ember/array/-private/native-array';
-import ArrayProxy from '@ember/array/proxy';
-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 { 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';
-
-function recordForIdentifier(store: Store, identifier: StableRecordIdentifier): RecordInstance {
-  return store._instanceCache.getRecord(identifier);
-}
-
-export interface RecordArrayCreateArgs {
-  modelName: string;
-  store: Store;
-  manager: RecordArrayManager;
-  content: NativeArray<StableRecordIdentifier>;
-  isLoaded: boolean;
-}
-
-/**
-  A record array is an array that contains records of a certain 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
-  @extends Ember.ArrayProxy
-*/
-export default class RecordArray extends ArrayProxy<StableRecordIdentifier, RecordInstance> {
-  /**
-    The array of client ids backing the record array. When a
-    record is requested from the record array, the record
-    for the client id at the same index is materialized, if
-    necessary, by the store.
-
-    @property content
-    @private
-    @type Ember.Array
-  */
-  declare content: NativeArray<StableRecordIdentifier>;
-  declare _getDeprecatedEventedInfo: () => string;
-  declare modelName: string;
-  /**
-    The flag to signal a `RecordArray` is finished loading data.
-
-    Example
-
-    ```javascript
-    let people = store.peekAll('person');
-    people.get('isLoaded'); // true
-    ```
-
-    @property isLoaded
-    @public
-    @type Boolean
-  */
-  declare isLoaded: boolean;
-  /**
-    The store that created this record array.
-
-    @property store
-    @private
-    @type Store
-    */
-  declare store: Store;
-  declare _updatingPromise: PromiseArray<RecordInstance, RecordArray> | null;
-  declare manager: RecordArrayManager;
-
-  /**
-    The flag to signal a `RecordArray` is currently loading data.
-    Example
-    ```javascript
-    let people = store.peekAll('person');
-    people.get('isUpdating'); // false
-    people.update();
-    people.get('isUpdating'); // true
-    ```
-    @property isUpdating
-    @public
-    @type Boolean
-  */
-  @tracked isUpdating: boolean = false;
-
-  init(props?: RecordArrayCreateArgs) {
-    assert(`Cannot initialize RecordArray with isUpdating`, !props || !('isUpdating' in props));
-    assert(`Cannot initialize RecordArray with isUpdating`, !props || !('_updatingPromise' in props));
-    super.init();
-
-    // TODO can we get rid of this?
-    this.set('content', this.content || null);
-    this._updatingPromise = null;
-  }
-
-  replace() {
-    throw new Error(
-      `The result of a server query (for all ${this.modelName} types) is immutable. To modify contents, use toArray()`
-    );
-  }
-
-  /**
-   The modelClass represented by this record array.
-
-   @property type
-    @public
-    @deprecated
-   @type {subclass of Model}
-   */
-
-  /**
-    Retrieves an object from the content by index.
-
-    @method objectAtContent
-    @private
-    @param {Number} index
-    @return {Model} record
-  */
-  objectAtContent(index: number): RecordInstance | undefined {
-    let identifier = get(this, 'content').objectAt(index);
-    return identifier ? recordForIdentifier(this.store, identifier) : undefined;
-  }
-
-  /**
-    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.get('isUpdating'); // false
-
-    people.update().then(function() {
-      people.get('isUpdating'); // false
-    });
-
-    people.get('isUpdating'); // true
-    ```
-
-    @method update
-    @public
-  */
-  update(): PromiseArray<RecordInstance, RecordArray> {
-    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, RecordArray> {
-    return this.store.findAll(this.modelName, { reload: true });
-  }
-
-  /**
-    Saves all of the records in the `RecordArray`.
-
-    Example
-
-    ```javascript
-    let messages = store.peekAll('message');
-    messages.forEach(function(message) {
-      message.set('hasBeenSeen', true);
-    });
-    messages.save();
-    ```
-
-    @method save
-    @public
-    @return {PromiseArray} promise
-  */
-  save(): PromiseArray<RecordInstance, RecordArray> {
-    let promiseLabel = `DS: RecordArray#save ${this.modelName}`;
-    let promise = Promise.all(this.invoke('save'), promiseLabel).then(
-      () => this,
-      null,
-      'DS: RecordArray#save return RecordArray'
-    );
-
-    return promiseArray<RecordInstance, RecordArray>(promise);
-  }
-
-  /**
-    @method _unregisterFromManager
-    @internal
-  */
-  _unregisterFromManager() {
-    this.manager.unregisterRecordArray(this);
-  }
-
-  willDestroy() {
-    this._unregisterFromManager();
-    this._dissociateFromOwnRecords();
-    // TODO: we should not do work during destroy:
-    //   * when objects are destroyed, they should simply be left to do
-    //   * if logic errors do to this, that logic needs to be more careful during
-    //    teardown (ember provides isDestroying/isDestroyed) for this reason
-    //   * the exception being: if an dominator has a reference to this object,
-    //     and must be informed to release e.g. e.g. removing itself from th
-    //     recordArrayMananger
-    set(this, 'content', null as unknown as NativeArray<StableRecordIdentifier>);
-    set(this, 'length', 0);
-    super.willDestroy();
-  }
-
-  /**
-    @method _createSnapshot
-    @private
-  */
-  _createSnapshot(options: FindOptions) {
-    // this is private for users, but public for ember-data internals
-    // meta will only be present for an AdapterPopulatedRecordArray
-    return new SnapshotRecordArray(this, null, options);
-  }
-
-  /**
-    @method _dissociateFromOwnRecords
-    @internal
-  */
-  _dissociateFromOwnRecords() {
-    this.content.forEach((identifier) => {
-      let recordArrays = this.manager.getRecordArraysForIdentifier(identifier);
-
-      if (recordArrays) {
-        recordArrays.delete(this);
-      }
-    });
-  }
-
-  /**
-    Adds identifiers to the `RecordArray` without duplicates
-
-    @method _pushIdentifiers
-    @internal
-    @param {StableRecordIdentifier[]} identifiers
-  */
-  _pushIdentifiers(identifiers: StableRecordIdentifier[]): void {
-    this.content.pushObjects(identifiers);
-  }
-
-  /**
-    Removes identifiers from the `RecordArray`.
-
-    @method _removeIdentifiers
-    @internal
-    @param {StableRecordIdentifier[]} identifiers
-  */
-  _removeIdentifiers(identifiers: StableRecordIdentifier[]): void {
-    this.content.removeObjects(identifiers);
-  }
-
-  /**
-    @method _takeSnapshot
-    @internal
-  */
-  _takeSnapshot(): Snapshot[] {
-    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-store-wrapper.ts

@@ -1,243 +0,0 @@
-import { importSync } from '@embroider/macros';
-
-import type { RelationshipDefinition } from '@ember-data/model/-private/relationship-meta';
-import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
-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 '@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
-*/
-
-function metaIsRelationshipDefinition(meta: RelationshipSchema): meta is RelationshipDefinition {
-  return typeof (meta as RelationshipDefinition)._inverseKey === 'function';
-}
-
-let peekGraph;
-if (HAS_RECORD_DATA_PACKAGE) {
-  let _peekGraph;
-  peekGraph = (wrapper) => {
-    _peekGraph =
-      _peekGraph ||
-      (importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')).peekGraph;
-    return _peekGraph(wrapper);
-  };
-}
-
-export default class RecordDataStoreWrapper implements StoreWrapper {
-  declare _willNotify: boolean;
-  declare _pendingNotifies: Map<StableRecordIdentifier, Map<string, string>>;
-  declare _store: Store;
-
-  constructor(_store: Store) {
-    this._store = _store;
-    this._willNotify = false;
-    this._pendingNotifies = new Map();
-  }
-
-  get identifierCache(): IdentifierCache {
-    return this._store.identifierCache;
-  }
-
-  _scheduleNotification(identifier: StableRecordIdentifier, key: string, kind: 'belongsTo' | 'hasMany') {
-    let pending = this._pendingNotifies.get(identifier);
-
-    if (!pending) {
-      pending = new Map();
-      this._pendingNotifies.set(identifier, pending);
-    }
-    pending.set(key, kind);
-
-    if (this._willNotify === true) {
-      return;
-    }
-
-    this._willNotify = true;
-    let backburner: any = this._store._backburner;
-
-    backburner.schedule('notify', this, this._flushNotifications);
-  }
-
-  notifyErrorsChange(type: string, id: string, lid: string | null): void;
-  notifyErrorsChange(type: string, id: string | null, lid: string): void;
-  notifyErrorsChange(type: string, id: string | null, lid: string | null): void {
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-
-    let internalModel = internalModelFactoryFor(this._store).peek(identifier);
-
-    if (internalModel) {
-      internalModel.notifyErrorsChange();
-    }
-  }
-
-  _flushNotifications(): void {
-    if (this._willNotify === false) {
-      return;
-    }
-
-    let pending = this._pendingNotifies;
-    this._pendingNotifies = new Map();
-    this._willNotify = false;
-    const factory = internalModelFactoryFor(this._store);
-
-    pending.forEach((map, identifier) => {
-      const internalModel = factory.peek(identifier);
-      if (internalModel) {
-        map.forEach((kind, key) => {
-          if (kind === 'belongsTo') {
-            internalModel.notifyBelongsToChange(key);
-          } else {
-            internalModel.notifyHasManyChange(key);
-          }
-        });
-      }
-    });
-  }
-
-  attributesDefinitionFor(type: string): AttributesSchema {
-    return this._store.getSchemaDefinitionService().attributesDefinitionFor({ type });
-  }
-
-  relationshipsDefinitionFor(type: string): RelationshipsSchema {
-    return this._store.getSchemaDefinitionService().relationshipsDefinitionFor({ type });
-  }
-
-  inverseForRelationship(type: string, key: string): string | null {
-    const modelClass = this._store.modelFor(type);
-    const definition = this.relationshipsDefinitionFor(type)[key];
-    if (!definition) {
-      return null;
-    }
-
-    if (metaIsRelationshipDefinition(definition)) {
-      return definition._inverseKey(this._store, modelClass);
-    } else if (definition.options && definition.options.inverse !== undefined) {
-      return definition.options.inverse;
-    } else {
-      return null;
-    }
-  }
-
-  inverseIsAsyncForRelationship(type: string, key: string): boolean {
-    const modelClass = this._store.modelFor(type);
-    const definition = this.relationshipsDefinitionFor(type)[key];
-    if (!definition) {
-      return false;
-    }
-
-    if (definition.options && definition.options.inverse === null) {
-      return false;
-    }
-    if ((definition as unknown as { inverseIsAsync?: boolean }).inverseIsAsync !== undefined) {
-      // TODO do we need to amend the RFC for this prop?
-      // else we should add it to the TS interface and document.
-      return !!(definition as unknown as { inverseIsAsync: boolean }).inverseIsAsync;
-    } else if (metaIsRelationshipDefinition(definition)) {
-      return definition._inverseIsAsync(this._store, modelClass);
-    } else {
-      return false;
-    }
-  }
-
-  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.notifyAttributes(key ? [key] : []);
-    }
-  }
-
-  notifyHasManyChange(type: string, id: string | null, lid: string, key: string): void;
-  notifyHasManyChange(type: string, id: string, lid: string | null | undefined, key: string): void;
-  notifyHasManyChange(type: string, id: string | null, lid: string | null | undefined, key: string): void {
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    this._scheduleNotification(identifier, key, 'hasMany');
-  }
-
-  notifyBelongsToChange(type: string, id: string | null, lid: string, key: string): void;
-  notifyBelongsToChange(type: string, id: string, lid: string | null | undefined, key: string): void;
-  notifyBelongsToChange(type: string, id: string | null, lid: string | null | undefined, key: string): void {
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-
-    this._scheduleNotification(identifier, key, 'belongsTo');
-  }
-
-  notifyStateChange(type: string, id: string, lid: string | null, key?: string): void;
-  notifyStateChange(type: string, id: string | null, lid: string, key?: string): void;
-  notifyStateChange(type: string, id: string | null, lid: string | null, 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.notifyStateChange(key);
-    }
-  }
-
-  recordDataFor(type: string, id: string, lid?: string | null): RecordData;
-  recordDataFor(type: string, id: string | null, lid: string): RecordData;
-  recordDataFor(type: string): RecordData;
-  recordDataFor(type: string, id?: string | null, lid?: string | null): RecordData {
-    let identifier: StableRecordIdentifier | { type: string };
-    let isCreate: boolean = false;
-    if (!id && !lid) {
-      isCreate = true;
-      identifier = { type };
-    } else {
-      const resource = constructResource(type, id, lid);
-      identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    }
-
-    return this._store._instanceCache.recordDataFor(identifier, isCreate);
-  }
-
-  setRecordId(type: string, id: string, lid: string) {
-    this._store._instanceCache.setRecordId(type, id, lid);
-  }
-
-  isRecordInUse(type: string, id: string | null, lid: string): boolean;
-  isRecordInUse(type: string, id: string, lid?: string | null): boolean;
-  isRecordInUse(type: string, id: string | null, lid?: string | null): boolean {
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-
-    const record = this._store._instanceCache.peek({ identifier, bucket: 'record' });
-
-    return record ? !(record.isDestroyed || record.isDestroying) : false;
-  }
-
-  disconnectRecord(type: string, id: string | null, lid: string): void;
-  disconnectRecord(type: string, id: string, lid?: string | null): void;
-  disconnectRecord(type: string, id: string | null, lid?: string | null): void {
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    if (HAS_RECORD_DATA_PACKAGE) {
-      let graph = peekGraph(this);
-      if (graph) {
-        graph.remove(identifier);
-      }
-    }
-    let internalModel = internalModelFactoryFor(this._store).peek(identifier);
-    if (internalModel) {
-      internalModel.destroyFromRecordData();
-    }
-  }
-}

package/addon/-private/record-notification-manager.ts

@@ -1,73 +0,0 @@
-import { DEBUG } from '@glimmer/env';
-
-import type { RecordIdentifier, StableRecordIdentifier } from '@ember-data/types/q/identifier';
-
-import type Store from './core-store';
-import WeakCache from './weak-cache';
-
-type UnsubscribeToken = Object;
-
-const Cache = new WeakCache<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>(
-  DEBUG ? 'subscribers' : ''
-);
-Cache._generator = () => new Map();
-const Tokens = new WeakCache<UnsubscribeToken, StableRecordIdentifier>(DEBUG ? 'identifier' : '');
-
-export type NotificationType =
-  | 'attributes'
-  | 'relationships'
-  | 'identity'
-  | 'errors'
-  | 'meta'
-  | 'unload'
-  | 'state'
-  | 'property'; // 'property' is an internal EmberData only transition period concept.
-
-export interface NotificationCallback {
-  (identifier: RecordIdentifier, notificationType: 'attributes' | 'relationships' | 'property', key?: string): void;
-  (identifier: RecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): void;
-  (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
-}
-
-export function unsubscribe(token: UnsubscribeToken) {
-  let identifier = Tokens.get(token);
-  if (!identifier) {
-    throw new Error('Passed unknown unsubscribe token to unsubscribe');
-  }
-  Tokens.delete(token);
-  const map = Cache.get(identifier);
-  map?.delete(token);
-}
-/*
-  Currently only support a single callback per identifier
-*/
-export default class NotificationManager {
-  constructor(private store: Store) {}
-
-  subscribe(identifier: RecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
-    let stableIdentifier = this.store.identifierCache.getOrCreateRecordIdentifier(identifier);
-    let map = Cache.lookup(stableIdentifier);
-    let unsubToken = {};
-    map.set(unsubToken, callback);
-    Tokens.set(unsubToken, stableIdentifier);
-    return unsubToken;
-  }
-
-  unsubscribe(token: UnsubscribeToken) {
-    unsubscribe(token);
-  }
-
-  notify(identifier: RecordIdentifier, value: 'attributes' | 'relationships' | 'property', key?: string): boolean;
-  notify(identifier: RecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): boolean;
-  notify(identifier: RecordIdentifier, value: NotificationType, key?: string): boolean {
-    let stableIdentifier = this.store.identifierCache.getOrCreateRecordIdentifier(identifier);
-    let callbackMap = Cache.get(stableIdentifier);
-    if (!callbackMap || !callbackMap.size) {
-      return false;
-    }
-    callbackMap.forEach((cb) => {
-      cb(stableIdentifier, value, key);
-    });
-    return true;
-  }
-}