@ember-data/store 4.10.0-alpha.4 → 4.10.0-alpha.6

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

@@ -1,34 +0,0 @@
-import { assert } from '@ember/debug';
-
-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';
-
-/*
- * Returns the RecordData instance associated with a given
- * Model or Identifier
- */
-
-const RecordDataForIdentifierCache = new Map<StableRecordIdentifier | RecordInstance, 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 | RecordInstance): 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/index.ts

@@ -1,59 +0,0 @@
-/**
-  @module @ember-data/store
-*/
-
-import { assert, deprecate } from '@ember/debug';
-
-import { DEPRECATE_HELPERS } from '@ember-data/private-build-infra/deprecations';
-
-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,
-  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.7', enabled: '4.7' },
-      }
-    );
-    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 {
-  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 './network/snapshot-record-array';
-
-// leaked for private use / test use, should investigate removing
-export { default as recordDataFor, removeRecordDataFor } from './caches/record-data-for';

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

@@ -1,240 +0,0 @@
-import { assert } from '@ember/debug';
-import { tracked } from '@glimmer/tracking';
-
-/**
-  @module @ember-data/store
-*/
-import RSVP, { resolve } from 'rsvp';
-
-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 { NotificationType } from '../managers/record-notification-manager';
-import { unsubscribe } from '../managers/record-notification-manager';
-import type Store from '../store-service';
-
-/**
-  @module @ember-data/store
-*/
-
-/**
-   A `RecordReference` is a low-level API that allows users and
-   addon authors to perform meta-operations on a record.
-
-   @class RecordReference
-   @public
-   @extends Reference
-*/
-export default class RecordReference {
-  declare store: Store;
-  // unsubscribe token given to us by the notification manager
-  ___token!: Object;
-  ___identifier: StableRecordIdentifier;
-
-  @tracked _ref = 0;
-
-  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' && notifiedKey === 'id')) {
-          this._ref++;
-        }
-      }
-    );
-  }
-
-  destroy() {
-    unsubscribe(this.___token);
-  }
-
-  get type(): string {
-    return this.identifier().type;
-  }
-
-  /**
-     The `id` of the record that this reference refers to.
-
-     Together, the `type` and `id` properties form a composite key for
-     the identity map.
-
-     Example
-
-     ```javascript
-     let userRef = store.getReference('user', 1);
-
-     userRef.id(); // '1'
-     ```
-
-     @method id
-    @public
-     @return {String} The id of the record.
-  */
-  id() {
-    this._ref; // consume the tracked prop
-    return this.___identifier.id;
-  }
-
-  /**
-     The `identifier` of the record that this reference refers to.
-
-     Together, the `type` and `id` properties form a composite key for
-     the identity map.
-
-     Example
-
-     ```javascript
-     let userRef = store.getReference('user', 1);
-
-     userRef.identifier(); // '1'
-     ```
-
-     @method identifier
-    @public
-     @return {String} The identifier of the record.
-  */
-  identifier(): StableRecordIdentifier {
-    return this.___identifier;
-  }
-
-  /**
-     How the reference will be looked up when it is loaded. Currently
-     this always returns `identity` to signify that a record will be
-     loaded by its `type` and `id`.
-
-     Example
-
-     ```javascript
-     const userRef = store.getReference('user', 1);
-
-     userRef.remoteType(); // 'identity'
-     ```
-
-     @method remoteType
-     @public
-     @return {String} 'identity'
-  */
-  remoteType(): 'identity' {
-    return 'identity';
-  }
-
-  /**
-    This API allows you to provide a reference with new data. The
-    simplest usage of this API is similar to `store.push`: you provide a
-    normalized hash of data and the object represented by the reference
-    will update.
-
-    If you pass a promise to `push`, Ember Data will not ask the adapter
-    for the data if another attempt to fetch it is made in the
-    interim. When the promise resolves, the underlying object is updated
-    with the new data, and the promise returned by *this function* is resolved
-    with that object.
-
-    For example, `recordReference.push(promise)` will be resolved with a
-    record.
-
-     Example
-
-     ```javascript
-     let userRef = store.getReference('user', 1);
-
-     // provide data for reference
-     userRef.push({
-       data: {
-         id: "1",
-         type: "user",
-         attributes: {
-           username: "@user"
-         }
-       }
-     }).then(function(user) {
-       userRef.value() === user;
-     });
-     ```
-
-    @method push
-    @public
-    @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
-    @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);
-    });
-  }
-
-  /**
-    If the entity referred to by the reference is already loaded, it is
-    present as `reference.value`. Otherwise the value returned by this function
-    is `null`.
-
-     Example
-
-     ```javascript
-     let userRef = store.getReference('user', 1);
-
-     userRef.value(); // user
-     ```
-
-     @method value
-    @public
-     @return {Model} the record for this RecordReference
-  */
-  value(): RecordInstance | null {
-    return this.store.peekRecord(this.___identifier);
-  }
-
-  /**
-     Triggers a fetch for the backing entity based on its `remoteType`
-     (see `remoteType` definitions per reference type).
-
-     Example
-
-     ```javascript
-     let userRef = store.getReference('user', 1);
-
-     // load user (via store.find)
-     userRef.load().then(...)
-     ```
-
-     @method load
-    @public
-     @return {Promise<record>} the record for this RecordReference
-  */
-  load() {
-    const id = this.id();
-    if (id !== null) {
-      return this.store.findRecord(this.type, id);
-    }
-    assert(`Unable to fetch record of type ${this.type} without an id`);
-  }
-
-  /**
-     Reloads the record if it is already loaded. If the record is not
-     loaded it will load the record via `store.findRecord`
-
-     Example
-
-     ```javascript
-     let userRef = store.getReference('user', 1);
-
-     // or trigger a reload
-     userRef.reload().then(...)
-     ```
-
-     @method reload
-    @public
-     @return {Promise<record>} the record for this RecordReference
-  */
-  reload() {
-    const id = this.id();
-    if (id !== null) {
-      return this.store.findRecord(this.type, id, { reload: true });
-    }
-    assert(`Unable to fetch record of type ${this.type} without an id`);
-  }
-}

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

@@ -1,148 +0,0 @@
-import { getOwner } from '@ember/application';
-import { deprecate } from '@ember/debug';
-
-import { importSync } from '@embroider/macros';
-
-import type Model from '@ember-data/model';
-import { HAS_MODEL_PACKAGE } from '@ember-data/private-build-infra';
-import { DEPRECATE_STRING_ARG_SCHEMAS } from '@ember-data/private-build-infra/deprecations';
-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 '../store-service';
-import normalizeModelName from '../utils/normalize-model-name';
-
-type ModelForMixin = (store: Store, normalizedModelName: string) => Model | null;
-
-let _modelForMixin: ModelForMixin;
-if (HAS_MODEL_PACKAGE) {
-  let _found;
-  _modelForMixin = function () {
-    if (!_found) {
-      _found = (importSync('@ember-data/model/-private') as typeof import('@ember-data/model/-private'))._modelForMixin;
-    }
-    return _found(...arguments);
-  };
-}
-
-export class DSModelSchemaDefinitionService {
-  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 {
-    let modelName, attributes;
-    if (DEPRECATE_STRING_ARG_SCHEMAS) {
-      if (typeof identifier === 'string') {
-        deprecate(
-          `attributesDefinitionFor expects either a record identifier or an argument of shape { type: string }, received a string.`,
-          false,
-          {
-            id: 'ember-data:deprecate-string-arg-schemas',
-            for: 'ember-data',
-            until: '5.0',
-            since: { enabled: '4.5', available: '4.5' },
-          }
-        );
-        modelName = identifier;
-      } else {
-        modelName = identifier.type;
-      }
-    } else {
-      modelName = identifier.type;
-    }
-
-    attributes = this._attributesDefCache[modelName];
-
-    if (attributes === undefined) {
-      let modelClass = this.store.modelFor(modelName);
-      let attributeMap = modelClass.attributes;
-
-      attributes = Object.create(null);
-      attributeMap.forEach((meta, name) => (attributes[name] = meta));
-      this._attributesDefCache[modelName] = attributes;
-    }
-
-    return attributes;
-  }
-
-  // Following the existing RD implementation
-  relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
-    let modelName, relationships;
-    if (DEPRECATE_STRING_ARG_SCHEMAS) {
-      if (typeof identifier === 'string') {
-        deprecate(
-          `relationshipsDefinitionFor expects either a record identifier or an argument of shape { type: string }, received a string.`,
-          false,
-          {
-            id: 'ember-data:deprecate-string-arg-schemas',
-            for: 'ember-data',
-            until: '5.0',
-            since: { enabled: '4.5', available: '4.5' },
-          }
-        );
-        modelName = identifier;
-      } else {
-        modelName = identifier.type;
-      }
-    } else {
-      modelName = identifier.type;
-    }
-
-    relationships = this._relationshipsDefCache[modelName];
-
-    if (relationships === undefined) {
-      let modelClass = this.store.modelFor(modelName);
-      relationships = modelClass.relationshipsObject || null;
-      this._relationshipsDefCache[modelName] = relationships;
-    }
-
-    return relationships;
-  }
-
-  doesTypeExist(modelName: string): boolean {
-    let normalizedModelName = normalizeModelName(modelName);
-    let factory = getModelFactory(this.store, this.store._modelFactoryCache, normalizedModelName);
-
-    return factory !== null;
-  }
-}
-
-export function getModelFactory(store: Store, cache, normalizedModelName: string): Model | null {
-  let factory = cache[normalizedModelName];
-
-  if (!factory) {
-    let owner: any = getOwner(store);
-    factory = owner.factoryFor(`model:${normalizedModelName}`);
-
-    if (!factory && HAS_MODEL_PACKAGE) {
-      //Support looking up mixins as base types for polymorphic relationships
-      factory = _modelForMixin(store, normalizedModelName);
-    }
-
-    if (!factory) {
-      // we don't cache misses in case someone wants to register a missing model
-      return null;
-    }
-
-    let klass = factory.class;
-
-    if (klass.isModel) {
-      let hasOwnModelNameSet = klass.modelName && Object.prototype.hasOwnProperty.call(klass, 'modelName');
-      if (!hasOwnModelNameSet) {
-        Object.defineProperty(klass, 'modelName', { value: normalizedModelName });
-      }
-    }
-
-    cache[normalizedModelName] = factory;
-  }
-
-  return factory;
-}

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

@@ -1,92 +0,0 @@
-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 '../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>>();
-
-export function getShimClass(store: Store, modelName: string): ShimModelClass {
-  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);
-  }
-
-  return shim;
-}
-
-function mapFromHash<T>(hash: Dict<T>): Map<string, T> {
-  let map = new Map();
-  for (let i in hash) {
-    if (Object.prototype.hasOwnProperty.call(hash, i)) {
-      map.set(i, hash[i]);
-    }
-  }
-  return map;
-}
-
-// Mimics the static apis of DSModel
-export default class ShimModelClass implements ModelSchema {
-  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 });
-    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));
-    return fields;
-  }
-
-  get attributes(): Map<string, AttributeSchema> {
-    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
-    return mapFromHash(attrs);
-  }
-
-  get relationshipsByName(): Map<string, RelationshipSchema> {
-    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.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
-    Object.keys(attrDefs).forEach((key) => {
-      callback.call(binding, key, attrDefs[key] as AttributeSchema);
-    });
-  }
-
-  eachRelationship<T>(
-    callback: (this: T | undefined, key: string, relationship: RelationshipSchema) => void,
-    binding?: T
-  ) {
-    let relationshipDefs = this.__store
-      .getSchemaDefinitionService()
-      .relationshipsDefinitionFor({ type: this.modelName });
-    Object.keys(relationshipDefs).forEach((key) => {
-      callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);
-    });
-  }
-
-  eachTransformedAttribute<T>(callback: (this: T | undefined, key: string, type: string) => void, binding?: T) {
-    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({ type: this.modelName });
-    Object.keys(attrDefs).forEach((key) => {
-      if (attrDefs[key]!.type) {
-        callback.call(binding, key, attrDefs[key]!.type);
-      }
-    });
-  }
-}