@ember-data/store 4.2.0-beta.0 → 4.3.0

package/addon/-private/system/store/record-data-store-wrapper.ts

@@ -1,9 +1,7 @@
-import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 import type { RelationshipDefinition } from '@ember-data/model/-private/system/relationships/relationship-meta';
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 
 import type { IdentifierCache } from '../../identifiers/cache';
-import { identifierCacheFor } from '../../identifiers/cache';
 import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
 import type { RecordData } from '../../ts-interfaces/record-data';
 import type {
@@ -45,7 +43,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   }
 
   get identifierCache(): IdentifierCache {
-    return identifierCacheFor(this._store);
+    return this._store.identifierCache;
   }
 
   _scheduleNotification(identifier: StableRecordIdentifier, key: string, kind: 'belongsTo' | 'hasMany') {
@@ -71,7 +69,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
 
     let internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
@@ -105,11 +103,11 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   }
 
   attributesDefinitionFor(type: string): AttributesSchema {
-    return this._store._attributesDefinitionFor(type);
+    return this._store._attributesDefinitionFor({ type });
   }
 
   relationshipsDefinitionFor(type: string): RelationshipsSchema {
-    return this._store._relationshipsDefinitionFor(type);
+    return this._store._relationshipsDefinitionFor({ type });
   }
 
   inverseForRelationship(type: string, key: string): string | null {
@@ -118,16 +116,13 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     if (!definition) {
       return null;
     }
-    if (CUSTOM_MODEL_CLASS) {
-      if (metaIsRelationshipDefinition(definition)) {
-        return definition._inverseKey(this._store, modelClass);
-      } else if (definition.options && definition.options.inverse !== undefined) {
-        return definition.options.inverse;
-      } else {
-        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 (definition as RelationshipDefinition)._inverseKey(this._store, modelClass);
+      return null;
     }
   }
 
@@ -137,21 +132,18 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     if (!definition) {
       return false;
     }
-    if (CUSTOM_MODEL_CLASS) {
-      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;
-      }
+
+    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 (definition as RelationshipDefinition)._inverseIsAsync(this._store, modelClass);
+      return false;
     }
   }
 
@@ -159,7 +151,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     let internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
     if (internalModel) {
@@ -171,7 +163,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     this._scheduleNotification(identifier, key, 'hasMany');
   }
 
@@ -179,7 +171,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
 
     this._scheduleNotification(identifier, key, 'belongsTo');
   }
@@ -188,7 +180,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     let internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
     if (internalModel) {
@@ -207,7 +199,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
       identifier = { type };
     } else {
       const resource = constructResource(type, id, lid);
-      identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+      identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     }
 
     return this._store.recordDataFor(identifier, isCreate);
@@ -221,7 +213,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     const internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
     if (!internalModel) {
@@ -236,7 +228,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   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 = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     if (HAS_RECORD_DATA_PACKAGE) {
       let graph = peekGraph(this);
       if (graph) {

package/addon/-private/system/weak-cache.ts

@@ -0,0 +1,125 @@
+import { DEBUG } from '@glimmer/env';
+
+import { DEBUG_IDENTIFIER_BUCKET } from '../ts-interfaces/identifier';
+
+/*
+  DEBUG only fields. Keeping this in a separate interface
+  which Typescript then merges with the class definition allow us to
+  have a DEBUG only property without paying the cost of that field being
+  present and initialized (usually to void 0) in production.
+*/
+interface WeakCache<K extends object, V> extends WeakMap<K, V> {
+  _symbol: Symbol;
+  _fieldName: string;
+  _expectMsg?: (key: K) => string;
+  /*
+    The default Typescript Signature for WeakMap expects obj: K and
+    returns a boolean. This behavior isn't useful in our common case
+    where we want to use `has` to narrow by determining whether a
+    particular object is a key.
+
+    For instance, we use WeakMap key check to determine in some cases
+    whether an object given to us by a user is a RecordIdentifier or
+    a Record.
+  */
+  has(obj: unknown): obj is K;
+
+  /*
+    This is an exception to the interface being used for
+    DEBUG ony fields. In this case, only a few WeakCache's
+    will utilize the lookup behavior, so paying the cost in
+    the constructor signature / field initialization seemed
+    off.
+  */
+  _generator?: (key: K) => V;
+}
+
+/**
+ * @class WeakCache
+ * @extends WeakMap
+ * @internal
+ */
+class WeakCache<K extends object, V> extends WeakMap<K, V> {
+  constructor(_fieldName: string) {
+    super();
+    if (DEBUG) {
+      this._fieldName = _fieldName;
+      this._symbol = Symbol.for(_fieldName);
+    }
+  }
+
+  /**
+   * Retrieve the value for a key from the WeakCache with the expectation
+   * that the key exists. Throws the error generated by _expectMsg in DEBUG if
+   * that key does not exist.
+   *
+   * @method getWithError
+   * @param obj
+   * @internal
+   */
+  getWithError(obj: K): V {
+    let v = this.get(obj);
+
+    if (DEBUG && v === undefined) {
+      throw new Error(this._expectMsg!(obj));
+    }
+
+    return v as V;
+  }
+
+  /**
+   * Retrieve the value for a key from the WeakCache, or generate one
+   * using the configured _generator method if no value is yet present.
+   *
+   * @method lookup
+   * @param obj
+   * @internal
+   */
+  lookup(obj: K): V {
+    let v = super.get(obj);
+
+    if (v === undefined) {
+      v = this._generator!(obj);
+      super.set(obj, v);
+
+      if (DEBUG) {
+        if (obj[DEBUG_IDENTIFIER_BUCKET] && this._fieldName !== 'identifier-proxy-target') {
+          const target: K = obj[Symbol.for('identifier-proxy-target') as unknown as string] as K;
+          target[this._symbol as unknown as string] = v;
+        } else {
+          obj[this._symbol as unknown as string] = v;
+        }
+      }
+    }
+
+    return v;
+  }
+}
+
+class DebugWeakCache<K extends object, V> extends WeakCache<K, V> {
+  set(obj: K, value: V): this {
+    if (DEBUG && super.has(obj)) {
+      throw new Error(`${Object.prototype.toString.call(obj)} was already assigned a value for ${this._fieldName}`);
+    }
+    if (DEBUG) {
+      if (obj[DEBUG_IDENTIFIER_BUCKET] && this._fieldName !== 'identifier-proxy-target') {
+        const target: K = obj[Symbol.for('identifier-proxy-target') as unknown as string] as K;
+        target[this._symbol as unknown as string] = value;
+        // TODO the Proxy check here is entirely for ember-m3
+        // as it's attribute access tests fail since the symbol
+        // is an unexpected key received by it's proxies.
+        // we should address this upstream.
+      } else if (obj.constructor?.toString?.() !== 'MegamorphicModel') {
+        try {
+          obj[this._symbol as unknown as string] = value;
+        } catch {
+          // some keys are proxies that can't accept symbol values
+          // for instance records from ember-m3
+        }
+      }
+    }
+    return super.set(obj, value);
+  }
+}
+export type { DebugWeakCache };
+export default DEBUG ? DebugWeakCache : WeakCache;

package/addon/-private/ts-interfaces/fetch-manager.ts

@@ -1,7 +1,11 @@
+import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
+
 import type { RecordIdentifier } from './identifier';
 
 export interface Operation {
   op: string;
+  options: Dict<unknown> | undefined;
+  recordIdentifier: RecordIdentifier;
 }
 
 export interface FindRecordQuery extends Operation {

package/addon/-private/ts-interfaces/identifier.ts

@@ -113,7 +113,7 @@ export type StableRecordIdentifier = StableExistingRecordIdentifier | StableNewR
 
 /**
   Configures how unique identifier lid strings are generated by @ember-data/store.
-  
+
   This configuration MUST occur prior to the store instance being created.
 
   Takes a method which can expect to receive various data as its first argument
@@ -231,7 +231,7 @@ export type ForgetMethod = (identifier: StableIdentifier | StableRecordIdentifie
  ```js
  import { setIdentifierResetMethod } from '@ember-data/store';
  ```
- 
+
  Takes a method which can expect to be called when the parent application is destroyed.
 
  If you have properly used a WeakMap to encapsulate the state of your customization

package/addon/-private/ts-interfaces/minimum-adapter-interface.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-restricted-globals */
 // the above eslint rule checks return types. This is an interface
 // and we intend Promise whether it is Native or polyfilled is of
 // no consequence.

package/addon/-private/ts-interfaces/schema-definition-service.ts

@@ -7,6 +7,6 @@ import type { AttributesSchema, RelationshipsSchema } from './record-data-schema
 
 export interface SchemaDefinitionService {
   doesTypeExist(modelName: string): boolean;
-  attributesDefinitionFor(identifier: RecordIdentifier | string): AttributesSchema;
-  relationshipsDefinitionFor(identifier: RecordIdentifier | string): RelationshipsSchema;
+  attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema;
+  relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "4.2.0-beta.0",
+  "version": "4.3.0",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -17,41 +17,41 @@
     "start": "ember serve"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.2.0-beta.0",
-    "@ember-data/private-build-infra": "4.2.0-beta.0",
+    "@ember-data/canary-features": "4.3.0",
+    "@ember-data/private-build-infra": "4.3.0",
     "@ember/string": "^3.0.0",
     "@glimmer/tracking": "^1.0.4",
     "ember-auto-import": "^2.2.4",
     "ember-cached-decorator-polyfill": "^0.1.4",
-    "ember-cli-babel": "^7.26.6",
+    "ember-cli-babel": "^7.26.11",
     "ember-cli-path-utils": "^1.0.0",
-    "ember-cli-typescript": "^4.1.0"
+    "ember-cli-typescript": "^5.0.0"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.2.0-beta.0",
+    "@ember-data/unpublished-test-infra": "4.3.0",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "^2.6.0",
-    "@types/ember": "^3.16.5",
-    "@types/rsvp": "^4.0.3",
+    "@types/ember": "^4.0.0",
+    "@types/rsvp": "^4.0.4",
     "broccoli-asset-rev": "^3.0.0",
-    "ember-cli": "~3.26.1",
+    "ember-cli": "~4.1.1",
     "ember-cli-dependency-checker": "^3.2.0",
-    "ember-cli-htmlbars": "^5.1.2",
+    "ember-cli-htmlbars": "^6.0.1",
     "ember-cli-inject-live-reload": "^2.0.2",
     "ember-cli-sri": "^2.1.1",
     "ember-cli-terser": "~4.0.1",
     "ember-disable-prototype-extensions": "^1.1.3",
     "ember-export-application-global": "^2.0.1",
     "ember-load-initializers": "^2.1.1",
-    "ember-maybe-import-regenerator": "^0.1.6",
+    "ember-maybe-import-regenerator": "^1.0.0",
     "ember-qunit": "^5.1.5",
-    "ember-resolver": "^8.0.0",
-    "ember-source": "~3.28.6",
+    "ember-resolver": "^8.0.3",
+    "ember-source": "~4.3.0",
     "ember-source-channel-url": "^3.0.0",
-    "ember-try": "^1.4.0",
+    "ember-try": "^2.0.0",
     "loader.js": "^4.7.0",
-    "qunit": "^2.15.0",
-    "qunit-dom": "^1.6.0",
+    "qunit": "^2.17.0",
+    "qunit-dom": "^2.0.0",
     "webpack": "^5.37.1"
   },
   "engines": {

package/addon/-private/system/deprecated-evented.js

@@ -1,92 +0,0 @@
-import { deprecate } from '@ember/debug';
-import Evented from '@ember/object/evented';
-import Mixin from '@ember/object/mixin';
-import { DEBUG } from '@glimmer/env';
-
-import { DEPRECATE_EVENTED_API_USAGE } from '@ember-data/private-build-infra/deprecations';
-
-/**
-  @module @ember-data/store
-*/
-
-let INSTANCE_DEPRECATIONS;
-let lookupDeprecations;
-let DeprecatedEvented;
-
-if (DEBUG) {
-  INSTANCE_DEPRECATIONS = new WeakMap();
-
-  lookupDeprecations = function lookupInstanceDrecations(instance) {
-    let deprecations = INSTANCE_DEPRECATIONS.get(instance);
-
-    if (!deprecations) {
-      deprecations = {};
-      INSTANCE_DEPRECATIONS.set(instance, deprecations);
-    }
-
-    return deprecations;
-  };
-
-  /**
-   * `DeprecatedEvented` is a mixin that proxies to the `Ember.Evented`
-   * mixin while logging deprecations. It is used by classes that were previously instrumented with
-   * Evented whose evented APIs are now deprecated.
-   *
-   * @class DeprecatedEvented
-   * @private
-   * @uses Ember.Evented
-   */
-  DeprecatedEvented = Mixin.create(Evented, {
-    _has(name) {
-      return Evented.mixins[0].properties.has.call(this, name);
-    },
-
-    _on() {
-      return Evented.mixins[0].properties.on.call(this, ...arguments);
-    },
-
-    _deprecateEvented(eventName) {
-      let deprecations = lookupDeprecations(this);
-      const _deprecationData = this._getDeprecatedEventedInfo ? `on ${this._getDeprecatedEventedInfo()}` : '';
-      const deprecationMessage = _deprecationData ? `Called ${eventName} ${_deprecationData}` : eventName;
-      deprecate(deprecationMessage, deprecations[eventName], {
-        id: 'ember-data:evented-api-usage',
-        until: '4.0',
-        url: 'https://deprecations.emberjs.com/ember-data/v3.x/#deprecatingrecordlifecycleeventmethods',
-        for: '@ember-data/model',
-        since: {
-          available: '3.12',
-          enabled: '3.12',
-        },
-      });
-      deprecations[eventName] = true;
-    },
-
-    has(name) {
-      this._deprecateEvented(name);
-      return this._super(...arguments);
-    },
-
-    off(name, target, method) {
-      this._deprecateEvented(name);
-      return this._super(...arguments);
-    },
-
-    on(name, target, method) {
-      this._deprecateEvented(name);
-      return this._super(...arguments);
-    },
-
-    one(name, target, method) {
-      this._deprecateEvented(name);
-      return this._super(...arguments);
-    },
-
-    trigger(name) {
-      this._deprecateEvented(name);
-      return this._super(...arguments);
-    },
-  });
-}
-
-export default DEPRECATE_EVENTED_API_USAGE ? (DEBUG ? DeprecatedEvented : Evented) : {};