@ember-data/model 4.8.0-alpha.0 → 4.8.0-alpha.3

package/addon/-private/notify-changes.ts

@@ -1,7 +1,7 @@
 import { cacheFor } from '@ember/object/internals';
 
 import type Store from '@ember-data/store';
-import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
+import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 
 import type Model from './model';

package/addon/-private/promise-many-array.ts

@@ -1,6 +1,6 @@
 import ArrayMixin, { NativeArray } from '@ember/array';
 import type ArrayProxy from '@ember/array/proxy';
-import { assert } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { tracked } from '@glimmer/tracking';
 import Ember from 'ember';
@@ -9,8 +9,10 @@ import { resolve } from 'rsvp';
 
 import type { ManyArray } from 'ember-data/-private';
 
-import type { InternalModel } from '@ember-data/store/-private';
+import { DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS } from '@ember-data/private-build-infra/deprecations';
+import { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
+import { FindOptions } from '@ember-data/types/q/store';
 
 export interface HasManyProxyCreateArgs {
   promise: Promise<ManyArray>;
@@ -24,16 +26,10 @@ export interface HasManyProxyCreateArgs {
   This class is returned as the result of accessing an async hasMany relationship
   on an instance of a Model extending from `@ember-data/model`.
 
-  A PromiseManyArray is an array-like proxy that also proxies certain method calls
-  to the underlying ManyArray in addition to being "promisified".
+  A PromiseManyArray is an iterable proxy that allows templates to consume related
+  ManyArrays and update once their contents are no longer pending.
 
-  Right now we proxy:
-
-    * `reload()`
-    * `createRecord()`
-
-  This promise-proxy behavior is primarily to ensure that async relationship interact
-  nicely with templates. In your JS code you should resolve the promise first.
+  In your JS code you should resolve the promise first.
 
   ```js
   const comments = await post.comments;
@@ -42,10 +38,14 @@ export interface HasManyProxyCreateArgs {
   @class PromiseManyArray
   @public
 */
-export default interface PromiseManyArray extends Omit<ArrayProxy<InternalModel, RecordInstance>, 'destroy'> {}
+export default interface PromiseManyArray extends Omit<ArrayProxy<StableRecordIdentifier, RecordInstance>, 'destroy'> {
+  createRecord(): RecordInstance;
+  reload(options: FindOptions): PromiseManyArray;
+}
 export default class PromiseManyArray {
   declare promise: Promise<ManyArray> | null;
   declare isDestroyed: boolean;
+  // @deprecated (isDestroyed is not deprecated)
   declare isDestroying: boolean;
 
   constructor(promise: Promise<ManyArray>, content?: ManyArray) {
@@ -90,6 +90,8 @@ export default class PromiseManyArray {
 
   /**
    * Iterate the proxied content. Called by the glimmer iterator in #each
+   * We do not guarantee that forEach will always be available. This
+   * may eventually be made to use Symbol.Iterator once glimmer supports it.
    *
    * @method forEach
    * @param cb
@@ -103,6 +105,19 @@ export default class PromiseManyArray {
     }
   }
 
+  /**
+   * Reload the relationship
+   * @method reload
+   * @public
+   * @param options
+   * @returns
+   */
+  reload(options: FindOptions) {
+    assert('You are trying to reload an async manyArray before it has been created', this.content);
+    this.content.reload(options);
+    return this;
+  }
+
   //----  Properties/Methods from the PromiseProxyMixin that we will keep as our API
 
   /**
@@ -201,19 +216,6 @@ export default class PromiseManyArray {
     return this.content ? this.content.meta : undefined;
   }
 
-  /**
-   * Reload the relationship
-   * @method reload
-   * @public
-   * @param options
-   * @returns
-   */
-  reload(options) {
-    assert('You are trying to reload an async manyArray before it has been created', this.content);
-    this.content.reload(options);
-    return this;
-  }
-
   //---- Our own stuff
 
   _update(promise: Promise<ManyArray>, content?: ManyArray) {
@@ -227,22 +229,55 @@ export default class PromiseManyArray {
   static create({ promise, content }: HasManyProxyCreateArgs): PromiseManyArray {
     return new this(promise, content);
   }
+}
 
-  // Methods on ManyArray which people should resolve the relationship first before calling
-  createRecord(...args) {
+if (DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS) {
+  PromiseManyArray.prototype.createRecord = function createRecord(...args) {
+    deprecate(
+      `The createRecord method on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`,
+      false,
+      {
+        id: 'ember-data:deprecate-promise-many-array-behaviors',
+        until: '5.0',
+        since: { enabled: '4.8', available: '4.8' },
+        for: 'ember-data',
+      }
+    );
     assert('You are trying to createRecord on an async manyArray before it has been created', this.content);
     return this.content.createRecord(...args);
-  }
-
-  // Properties/Methods on ArrayProxy we should deprecate
-
-  get firstObject() {
-    return this.content ? this.content.firstObject : undefined;
-  }
+  };
 
-  get lastObject() {
-    return this.content ? this.content.lastObject : undefined;
-  }
+  Object.defineProperty(PromiseManyArray.prototype, 'firstObject', {
+    get() {
+      deprecate(
+        `The firstObject property on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`,
+        false,
+        {
+          id: 'ember-data:deprecate-promise-many-array-behaviors',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        }
+      );
+      return this.content ? this.content.firstObject : undefined;
+    },
+  });
+
+  Object.defineProperty(PromiseManyArray.prototype, 'lastObject', {
+    get() {
+      deprecate(
+        `The lastObject property on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`,
+        false,
+        {
+          id: 'ember-data:deprecate-promise-many-array-behaviors',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        }
+      );
+      return this.content ? this.content.lastObject : undefined;
+    },
+  });
 }
 
 function tapPromise(proxy: PromiseManyArray, promise: Promise<ManyArray>) {
@@ -268,78 +303,101 @@ function tapPromise(proxy: PromiseManyArray, promise: Promise<ManyArray>) {
   );
 }
 
-const EmberObjectMethods = [
-  'addObserver',
-  'cacheFor',
-  'decrementProperty',
-  'get',
-  'getProperties',
-  'incrementProperty',
-  'notifyPropertyChange',
-  'removeObserver',
-  'set',
-  'setProperties',
-  'toggleProperty',
-];
-EmberObjectMethods.forEach((method) => {
-  PromiseManyArray.prototype[method] = function delegatedMethod(...args) {
-    return Ember[method](this, ...args);
-  };
-});
-
-const InheritedProxyMethods = [
-  'addArrayObserver',
-  'addObject',
-  'addObjects',
-  'any',
-  'arrayContentDidChange',
-  'arrayContentWillChange',
-  'clear',
-  'compact',
-  'every',
-  'filter',
-  'filterBy',
-  'find',
-  'findBy',
-  'getEach',
-  'includes',
-  'indexOf',
-  'insertAt',
-  'invoke',
-  'isAny',
-  'isEvery',
-  'lastIndexOf',
-  'map',
-  'mapBy',
-  'objectAt',
-  'objectsAt',
-  'popObject',
-  'pushObject',
-  'pushObjects',
-  'reduce',
-  'reject',
-  'rejectBy',
-  'removeArrayObserver',
-  'removeAt',
-  'removeObject',
-  'removeObjects',
-  'replace',
-  'reverseObjects',
-  'setEach',
-  'setObjects',
-  'shiftObject',
-  'slice',
-  'sortBy',
-  'toArray',
-  'uniq',
-  'uniqBy',
-  'unshiftObject',
-  'unshiftObjects',
-  'without',
-];
-InheritedProxyMethods.forEach((method) => {
-  PromiseManyArray.prototype[method] = function proxiedMethod(...args) {
-    assert(`Cannot call ${method} before content is assigned.`, this.content);
-    return this.content[method](...args);
-  };
-});
+if (DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS) {
+  const EmberObjectMethods = [
+    'addObserver',
+    'cacheFor',
+    'decrementProperty',
+    'get',
+    'getProperties',
+    'incrementProperty',
+    'notifyPropertyChange',
+    'removeObserver',
+    'set',
+    'setProperties',
+    'toggleProperty',
+  ];
+  EmberObjectMethods.forEach((method) => {
+    PromiseManyArray.prototype[method] = function delegatedMethod(...args) {
+      deprecate(
+        `The ${method} method on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`,
+        false,
+        {
+          id: 'ember-data:deprecate-promise-many-array-behaviors',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        }
+      );
+      return Ember[method](this, ...args);
+    };
+  });
+
+  const InheritedProxyMethods = [
+    'addArrayObserver',
+    'addObject',
+    'addObjects',
+    'any',
+    'arrayContentDidChange',
+    'arrayContentWillChange',
+    'clear',
+    'compact',
+    'every',
+    'filter',
+    'filterBy',
+    'find',
+    'findBy',
+    'getEach',
+    'includes',
+    'indexOf',
+    'insertAt',
+    'invoke',
+    'isAny',
+    'isEvery',
+    'lastIndexOf',
+    'map',
+    'mapBy',
+    // TODO update RFC to note objectAt was deprecated (forEach was left for iteration)
+    'objectAt',
+    'objectsAt',
+    'popObject',
+    'pushObject',
+    'pushObjects',
+    'reduce',
+    'reject',
+    'rejectBy',
+    'removeArrayObserver',
+    'removeAt',
+    'removeObject',
+    'removeObjects',
+    'replace',
+    'reverseObjects',
+    'setEach',
+    'setObjects',
+    'shiftObject',
+    'slice',
+    'sortBy',
+    'toArray',
+    'uniq',
+    'uniqBy',
+    'unshiftObject',
+    'unshiftObjects',
+    'without',
+  ];
+  InheritedProxyMethods.forEach((method) => {
+    PromiseManyArray.prototype[method] = function proxiedMethod(...args) {
+      deprecate(
+        `The ${method} method on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`,
+        false,
+        {
+          id: 'ember-data:deprecate-promise-many-array-behaviors',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        }
+      );
+      assert(`Cannot call ${method} before content is assigned.`, this.content);
+      return this.content[method](...args);
+    };
+  });
+}

package/addon/-private/record-state.ts

@@ -5,14 +5,17 @@ import { cached, tracked } from '@glimmer/tracking';
 
 import type Store from '@ember-data/store';
 import { storeFor } from '@ember-data/store';
-import { errorsArrayToHash, recordIdentifierFor } from '@ember-data/store/-private';
-import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
-import type RequestCache from '@ember-data/store/-private/request-cache';
+import { recordIdentifierFor } from '@ember-data/store/-private';
+import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
+import type RequestCache from '@ember-data/store/-private/network/request-cache';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordData } from '@ember-data/types/q/record-data';
 
 type Model = InstanceType<typeof import('./model')>;
 
+const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
+const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
+const PRIMARY_ATTRIBUTE_KEY = 'base';
 function isInvalidError(error) {
   return error && error.isAdapterError === true && error.code === 'InvalidError';
 }
@@ -101,8 +104,9 @@ export function tagged(_target, key, desc) {
 }
 
 /**
-Historically InternalModel managed a state machine
-the currentState for which was reflected onto Model.
+Historically EmberData managed a state machine
+for each record, the currentState for which
+was reflected onto Model.
 
 This implements the flags and stateName for backwards compat
 with the state tree that used to be possible (listed below).
@@ -150,6 +154,7 @@ export default class RecordState {
   declare recordData: RecordData;
   declare _errorRequests: any[];
   declare _lastError: any;
+  declare handler: object;
 
   constructor(record: Model) {
     const store = storeFor(record)!;
@@ -176,7 +181,6 @@ export default class RecordState {
             break;
           case 'rejected':
             this.isSaving = false;
-
             this._lastError = req;
             if (!(req.response && isInvalidError(req.response.data))) {
               this._errorRequests.push(req);
@@ -230,47 +234,67 @@ export default class RecordState {
       }
     }
 
-    notifications.subscribe(identity, (identifier: StableRecordIdentifier, type: NotificationType, key?: string) => {
-      switch (type) {
-        case 'state':
-          this.notify('isNew');
-          this.notify('isDeleted');
-          this.notify('isDirty');
-          break;
-        case 'attributes':
-          this.notify('isEmpty');
-          this.notify('isDirty');
-          break;
-        case 'unload':
-          this.notify('isNew');
-          this.notify('isDeleted');
-          break;
-        case 'errors':
-          // we only hit this if a foreign RecordData notifies
-          // errors changed. Our own implementation does not
-          // take this path currently, but we should probably
-          // fix that.
-          this.updateInvalidErrors();
-          this.notify('isValid');
-          break;
+    this.handler = notifications.subscribe(
+      identity,
+      (identifier: StableRecordIdentifier, type: NotificationType, key?: string) => {
+        switch (type) {
+          case 'state':
+            this.notify('isNew');
+            this.notify('isDeleted');
+            this.notify('isDirty');
+            break;
+          case 'attributes':
+            this.notify('isEmpty');
+            this.notify('isDirty');
+            break;
+          case 'unload':
+            this.notify('isNew');
+            this.notify('isDeleted');
+            break;
+          case 'errors':
+            this.updateInvalidErrors(this.record.errors);
+            this.notify('isValid');
+            break;
+        }
       }
-    });
+    );
+  }
+
+  destroy() {
+    storeFor(this.record)!._notificationManager.unsubscribe(this.handler);
   }
 
   notify(key) {
     getTag(this, key).notify();
   }
 
-  updateInvalidErrors() {
-    let jsonApiErrors = this.recordData.getErrors!(this.identifier);
+  updateInvalidErrors(errors) {
+    assert(
+      `Expected the RecordData instance for ${this.identifier}  to implement getErrors(identifier)`,
+      typeof this.recordData.getErrors === 'function'
+    );
+    let jsonApiErrors = this.recordData.getErrors(this.identifier);
 
-    const { errors } = this.record;
     errors.clear();
-    let newErrors = errorsArrayToHash(jsonApiErrors);
-    let errorKeys = Object.keys(newErrors);
 
-    for (let i = 0; i < errorKeys.length; i++) {
-      errors.add(errorKeys[i], newErrors[errorKeys[i]]);
+    for (let i = 0; i < jsonApiErrors.length; i++) {
+      let error = jsonApiErrors[i];
+
+      if (error.source && error.source.pointer) {
+        let keyMatch = error.source.pointer.match(SOURCE_POINTER_REGEXP);
+        let key: string | undefined;
+
+        if (keyMatch) {
+          key = keyMatch[2];
+        } else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) {
+          key = PRIMARY_ATTRIBUTE_KEY;
+        }
+
+        if (key) {
+          let errMsg = error.detail || error.title;
+          errors.add(key, errMsg);
+        }
+      }
     }
   }
 
@@ -289,7 +313,6 @@ export default class RecordState {
     return !this.isLoaded && this.pendingCount > 0 && this.fulfilledCount === 0;
   }
 
-  // TODO @runspired handle "unloadRecord" see note in InternalModel
   @tagged
   get isLoaded() {
     if (this.isNew) {

package/addon/-private/references/belongs-to.ts

@@ -8,8 +8,8 @@ import type { BelongsToRelationship } from '@ember-data/record-data/-private';
 import type Store from '@ember-data/store';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 import { recordIdentifierFor } from '@ember-data/store/-private';
-import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
-import type { DebugWeakCache } from '@ember-data/store/-private/weak-cache';
+import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
+import type { DebugWeakCache } from '@ember-data/store/-private/utils/weak-cache';
 import type {
   LinkObject,
   Links,
@@ -125,7 +125,7 @@ export default class BelongsToReference {
    `type()` and `id()` methods form a composite key for the identity
    map. This can be used to access the id of an async relationship
    without triggering a fetch that would normally happen if you
-   attempted to use `record.get('relationship.id')`.
+   attempted to use `record.relationship.id`.
 
    Example
 
@@ -277,7 +277,7 @@ export default class BelongsToReference {
   }
 
   _resource() {
-    return this.store._instanceCache.recordDataFor(this.#identifier, false).getBelongsTo(this.key);
+    return this.store._instanceCache.getRecordData(this.#identifier).getBelongsTo(this.key);
   }
 
   /**
@@ -404,7 +404,7 @@ export default class BelongsToReference {
 
   /**
    `value()` synchronously returns the current value of the belongs-to
-   relationship. Unlike `record.get('relationshipName')`, calling
+   relationship. Unlike `record.relationshipName`, calling
    `value()` on a reference does not trigger a fetch if the async
    relationship is not yet loaded. If the relationship is not loaded
    it will always return `null`.

package/addon/-private/references/has-many.ts

@@ -11,8 +11,8 @@ import type { ManyRelationship } from '@ember-data/record-data/-private';
 import type Store from '@ember-data/store';
 import { recordIdentifierFor } from '@ember-data/store';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
-import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
-import type { DebugWeakCache } from '@ember-data/store/-private/weak-cache';
+import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
+import type { DebugWeakCache } from '@ember-data/store/-private/utils/weak-cache';
 import type {
   CollectionResourceDocument,
   CollectionResourceRelationship,
@@ -131,7 +131,7 @@ export default class HasManyReference {
   }
 
   _resource() {
-    return this.store._instanceCache.recordDataFor(this.#identifier, false).getHasMany(this.key);
+    return this.store._instanceCache.getRecordData(this.#identifier).getHasMany(this.key);
   }
 
   /**
@@ -435,16 +435,14 @@ export default class HasManyReference {
 
     let members = this.hasManyRelationship.currentState;
 
-    //TODO @runspired determine isLoaded via a better means
     return members.every((identifier) => {
-      let internalModel = this.store._instanceCache._internalModelForResource(identifier);
-      return internalModel.isLoaded === true;
+      return this.store._instanceCache.recordIsLoaded(identifier, true) === true;
     });
   }
 
   /**
    `value()` synchronously returns the current value of the has-many
-   relationship. Unlike `record.get('relationshipName')`, calling
+   relationship. Unlike `record.relationshipName`, calling
    `value()` on a reference does not trigger a fetch if the async
    relationship is not yet loaded. If the relationship is not loaded
    it will always return `null`.
@@ -474,7 +472,7 @@ export default class HasManyReference {
 
    let commentsRef = post.hasMany('comments');
 
-   post.get('comments').then(function(comments) {
+   post.comments.then(function(comments) {
      commentsRef.value() === comments
    })
    ```

package/addon/-private/relationship-meta.ts

@@ -1,9 +1,9 @@
+import { dasherize } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
 
 import { singularize } from 'ember-inflector';
 
 import type Store from '@ember-data/store';
-import { normalizeModelName } from '@ember-data/store/-private';
 import type { RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 
 /**
@@ -11,7 +11,7 @@ import type { RelationshipSchema } from '@ember-data/types/q/record-data-schemas
 */
 
 function typeForRelationshipMeta(meta) {
-  let modelName = normalizeModelName(meta.type || meta.key);
+  let modelName = dasherize(meta.type || meta.key);
 
   if (meta.kind === 'hasMany') {
     modelName = singularize(modelName);

package/index.js

@@ -17,6 +17,7 @@ module.exports = Object.assign({}, addonBaseConfig, {
       '@ember-data/store/-private',
       '@ember-data/store/-debug',
       '@embroider/macros',
+      '@ember/string',
       '@embroider/macros/es-compat',
 
       '@ember/application',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/model",
-  "version": "4.8.0-alpha.0",
+  "version": "4.8.0-alpha.3",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -18,9 +18,9 @@
     "test:node": "mocha"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.8.0-alpha.0",
-    "@ember-data/private-build-infra": "4.8.0-alpha.0",
-    "@ember-data/store": "4.8.0-alpha.0",
+    "@ember-data/canary-features": "4.8.0-alpha.3",
+    "@ember-data/private-build-infra": "4.8.0-alpha.3",
+    "@ember-data/store": "4.8.0-alpha.3",
     "@ember/edition-utils": "^1.2.0",
     "@ember/string": "^3.0.0",
     "@embroider/macros": "^1.8.3",
@@ -34,7 +34,7 @@
     "inflection": "~1.13.2"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.8.0-alpha.0",
+    "@ember-data/unpublished-test-infra": "4.8.0-alpha.3",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "~2.7.0",
     "broccoli-asset-rev": "^3.0.0",
@@ -61,8 +61,7 @@
     "webpack": "^5.74.0"
   },
   "engines": {
-    "node": "^14.8.0 || 16.* || >= 18.*",
-    "yarn": "1.22.19"
+    "node": "^14.8.0 || 16.* || >= 18.*"
   },
   "ember-addon": {
     "configPath": "tests/dummy/config"