@ember-data/store 4.7.0-beta.1 → 4.8.0-alpha.2

package/addon/-private/core-store.ts

@@ -1788,7 +1788,10 @@ class Store extends Service {
       if (DEBUG) {
         assertDestroyingStore(this, 'recordWasInvalid');
       }
-      internalModel.adapterDidInvalidate(parsedErrors, error);
+      error = error || new Error(`unknown invalid error`);
+      error = typeof error === 'string' ? new Error(error) : error;
+      error._parsedErrors = parsedErrors;
+      internalModel.adapterDidInvalidate(error);
     }
     assert(`store.recordWasInvalid has been removed`);
   }
@@ -2182,7 +2185,8 @@ class Store extends Service {
 
           //We first make sure the primary data has been updated
           //TODO try to move notification to the user to the end of the runloop
-          internalModel.adapterDidCommit(data);
+          internalModel._recordData.didCommit(data);
+          this.recordArrayManager.recordDidChange(internalModel.identifier);
 
           if (payload && payload.included) {
             this._push({ data: null, included: payload.included });
@@ -2191,12 +2195,14 @@ class Store extends Service {
         return record;
       },
       (e) => {
-        if (typeof e === 'string') {
-          throw e;
+        let err = e;
+        if (!e) {
+          err = new Error(`Unknown Error Occurred During Request`);
+        } else if (typeof e === 'string') {
+          err = new Error(e);
         }
-        const { error, parsedErrors } = e;
-        internalModel.adapterDidInvalidate(parsedErrors, error);
-        throw error;
+        internalModel.adapterDidInvalidate(err);
+        throw err;
       }
     );
   }

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

@@ -22,7 +22,6 @@ import type { Dict } from '@ember-data/types/q/utils';
 import coerceId from './coerce-id';
 import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './common';
 import type Store from './core-store';
-import { errorsArrayToHash } from './errors-utils';
 import ShimModelClass from './model/shim-model-class';
 import RequestCache from './request-cache';
 import { normalizeResponseHelper } from './serializer-response';
@@ -170,24 +169,7 @@ export default class FetchManager {
         if (adapterPayload) {
           return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
         }
-      },
-      function (error) {
-        if (error && error.isAdapterError === true && error.code === 'InvalidError') {
-          let parsedErrors = error.errors;
-
-          // TODO deprecate extractErrors being called and/or make it part of the public interface
-          if (serializer && typeof serializer.extractErrors === 'function') {
-            parsedErrors = serializer.extractErrors(store, modelClass, error, snapshot.id);
-          } else {
-            parsedErrors = errorsArrayToHash(error.errors);
-          }
-
-          throw { error, parsedErrors };
-        } else {
-          throw { error };
-        }
-      },
-      label
+      }
     );
     resolver.resolve(promise);
   }
@@ -326,38 +308,32 @@ export default class FetchManager {
       }),
       this._store,
       label
-    ).then(
-      (adapterPayload) => {
-        assert(
-          `You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`,
-          !!payloadIsNotBlank(adapterPayload)
-        );
-        let serializer = this._store.serializerFor(modelName);
-        let payload = normalizeResponseHelper(serializer, this._store, klass, adapterPayload, id, 'findRecord');
-        assert(
-          `Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`,
-          !Array.isArray(payload.data)
-        );
-        assert(
-          `The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`,
-          'data' in payload && payload.data !== null && typeof payload.data === 'object'
-        );
+    ).then((adapterPayload) => {
+      assert(
+        `You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`,
+        !!payloadIsNotBlank(adapterPayload)
+      );
+      let serializer = this._store.serializerFor(modelName);
+      let payload = normalizeResponseHelper(serializer, this._store, klass, adapterPayload, id, 'findRecord');
+      assert(
+        `Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`,
+        !Array.isArray(payload.data)
+      );
+      assert(
+        `The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`,
+        'data' in payload && payload.data !== null && typeof payload.data === 'object'
+      );
 
-        warn(
-          `You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`,
-          coerceId(payload.data.id) === coerceId(id),
-          {
-            id: 'ds.store.findRecord.id-mismatch',
-          }
-        );
+      warn(
+        `You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`,
+        coerceId(payload.data.id) === coerceId(id),
+        {
+          id: 'ds.store.findRecord.id-mismatch',
+        }
+      );
 
-        return payload;
-      },
-      (error) => {
-        throw error;
-      },
-      `DS: Extract payload of '${modelName}'`
-    );
+      return payload;
+    });
 
     fetchItem.resolver.resolve(promise);
   }

package/addon/-private/index.ts

@@ -2,6 +2,12 @@
   @module @ember-data/store
 */
 
+import { assert, deprecate } from '@ember/debug';
+
+import { DEPRECATE_HELPERS } from '@ember-data/private-build-infra/deprecations';
+
+import _normalize from './normalize-model-name';
+
 export { default as Store, storeFor } from './core-store';
 
 export { recordIdentifierFor } from './internal-model-factory';
@@ -14,10 +20,24 @@ export {
   setIdentifierResetMethod,
 } from './identifier-cache';
 
-export { default as normalizeModelName } from './normalize-model-name';
-export { default as coerceId } from './coerce-id';
+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.8', enabled: '4.8' },
+      }
+    );
+    return _normalize(modelName);
+  }
+  assert(`normalizeModelName support has been removed`);
+}
 
-export { errorsHashToArray, errorsArrayToHash } from './errors-utils';
+export { default as coerceId } from './coerce-id';
 
 // `ember-data-model-fragments` relies on `InternalModel`
 export { default as InternalModel } from './model/internal-model';

package/addon/-private/model/internal-model.ts

@@ -5,13 +5,14 @@ import { DEBUG } from '@glimmer/env';
 import { HAS_MODEL_PACKAGE } from '@ember-data/private-build-infra';
 import type { DSModel } from '@ember-data/types/q/ds-model';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { MinimumSerializerInterface } from '@ember-data/types/q/minimum-serializer-interface';
 import type { ChangedAttributesHash, RecordData } from '@ember-data/types/q/record-data';
 import type { JsonApiResource, JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 
 import type Store from '../core-store';
-import { errorsHashToArray } from '../errors-utils';
 import { internalModelFactoryFor } from '../internal-model-factory';
+import type ShimModelClass from './shim-model-class';
 
 /**
   @module @ember-data/store
@@ -27,6 +28,11 @@ function isDSModel(record: RecordInstance | null): record is DSModel {
   );
 }
 
+type AdapterErrors = Error & { errors?: unknown[]; isAdapterError?: true; code?: string };
+type SerializerWithParseErrors = MinimumSerializerInterface & {
+  extractErrors?(store: Store, modelClass: ShimModelClass, error: AdapterErrors, recordId: string | null): any;
+};
+
 export default class InternalModel {
   declare _id: string | null;
   declare modelName: string;
@@ -91,7 +97,10 @@ export default class InternalModel {
       let newIdentifier = { type: this.identifier.type, lid: this.identifier.lid, id: value };
       // TODO potentially this needs to handle merged result
       this.store.identifierCache.updateRecordIdentifier(this.identifier, newIdentifier);
-      this.notifyPropertyChange('id');
+      if (this.hasRecord) {
+        // TODO this should likely *mostly* be the a different bucket
+        this.store._notificationManager.notify(this.identifier, 'property', 'id');
+      }
     }
   }
 
@@ -392,16 +401,6 @@ export default class InternalModel {
     }
   }
 
-  notifyPropertyChange(key: string) {
-    if (this.hasRecord) {
-      // TODO this should likely *mostly* be the `attributes` bucket
-      // but it seems for local mutations we rely on computed updating
-      // iteself when set. As we design our own thing we may need to change
-      // that.
-      this.store._notificationManager.notify(this.identifier, 'property', key);
-    }
-  }
-
   notifyStateChange(key?: string) {
     if (this.hasRecord) {
       this.store._notificationManager.notify(this.identifier, 'state');
@@ -533,52 +532,26 @@ export default class InternalModel {
     this._isUpdatingId = false;
   }
 
-  didError() {}
-
-  /*
-    If the adapter did not return a hash in response to a commit,
-    merge the changed attributes and relationships into the existing
-    saved data.
-  */
-  adapterDidCommit(data) {
-    this._recordData.didCommit(data);
-    this.store.recordArrayManager.recordDidChange(this.identifier);
-  }
-
-  hasErrors(): boolean {
-    // TODO add assertion forcing consuming RecordData's to implement getErrors
-    if (this._recordData.getErrors) {
-      return this._recordData.getErrors(this.identifier).length > 0;
-    } else {
-      let record = this.store._instanceCache.peek({ identifier: this.identifier, bucket: 'record' });
-      // we can't have errors if we never tried loading
-      if (!record) {
-        return false;
+  // FOR USE DURING COMMIT PROCESS
+  adapterDidInvalidate(error: Error & { errors?: JsonApiValidationError[]; isAdapterError?: true; code?: string }) {
+    if (error && error.isAdapterError === true && error.code === 'InvalidError') {
+      let serializer = this.store.serializerFor(this.modelName) as SerializerWithParseErrors;
+
+      // TODO @deprecate extractErrors being called
+      // TODO remove extractErrors from the default serializers.
+      if (serializer && typeof serializer.extractErrors === 'function') {
+        let errorsHash = serializer.extractErrors(this.store, this.store.modelFor(this.modelName), error, this.id);
+        error.errors = errorsHashToArray(errorsHash);
       }
-      let errors = (record as DSModel).errors;
-      return errors.length > 0;
     }
-  }
 
-  // FOR USE DURING COMMIT PROCESS
-  adapterDidInvalidate(parsedErrors, error?) {
-    // TODO @runspired this should be handled by RecordState
-    // and errors should be dirtied but lazily fetch if at
-    // all possible. We should only notify errors here.
-    let attribute;
-    if (error && parsedErrors) {
-      // TODO add assertion forcing consuming RecordData's to implement getErrors
-      if (!this._recordData.getErrors) {
-        let record = this.store._instanceCache.getRecord(this.identifier) as DSModel;
-        let errors = record.errors;
-        for (attribute in parsedErrors) {
-          if (Object.prototype.hasOwnProperty.call(parsedErrors, attribute)) {
-            errors.add(attribute, parsedErrors[attribute]);
-          }
-        }
-      }
+    if (error.errors) {
+      assert(
+        `Expected the RecordData implementation for ${this.identifier} to have a getErrors(identifier) method for retreiving errors.`,
+        typeof this._recordData.getErrors === 'function'
+      );
 
-      let jsonApiErrors: JsonApiValidationError[] = errorsHashToArray(parsedErrors);
+      let jsonApiErrors: JsonApiValidationError[] = error.errors;
       if (jsonApiErrors.length === 0) {
         jsonApiErrors = [{ title: 'Invalid Error', detail: '', source: { pointer: '/data' } }];
       }
@@ -588,15 +561,40 @@ export default class InternalModel {
     }
   }
 
-  notifyErrorsChange() {
-    this.store._notificationManager.notify(this.identifier, 'errors');
+  toString() {
+    return `<${this.modelName}:${this.id}>`;
   }
+}
 
-  adapterDidError() {
-    this._recordData.commitWasRejected();
-  }
+function makeArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 
-  toString() {
-    return `<${this.modelName}:${this.id}>`;
+const PRIMARY_ATTRIBUTE_KEY = 'base';
+
+function errorsHashToArray(errors): JsonApiValidationError[] {
+  const out: JsonApiValidationError[] = [];
+
+  if (errors) {
+    Object.keys(errors).forEach((key) => {
+      let messages = makeArray(errors[key]);
+      for (let i = 0; i < messages.length; i++) {
+        let title = 'Invalid Attribute';
+        let pointer = `/data/attributes/${key}`;
+        if (key === PRIMARY_ATTRIBUTE_KEY) {
+          title = 'Invalid Document';
+          pointer = `/data`;
+        }
+        out.push({
+          title: title,
+          detail: messages[i],
+          source: {
+            pointer: pointer,
+          },
+        });
+      }
+    });
   }
+
+  return out;
 }

package/addon/-private/normalize-model-name.ts

@@ -4,9 +4,6 @@ import { dasherize } from '@ember/string';
   @module @ember-data/store
 */
 
-// All modelNames are dasherized internally. Changing this function may
-// require changes to other normalization hooks (such as typeForRoot).
-
 /**
  This method normalizes a modelName into the format Ember Data uses
  internally by dasherizing it.
@@ -14,6 +11,7 @@ import { dasherize } from '@ember/string';
   @method normalizeModelName
   @static
   @public
+  @deprecated
   @for @ember-data/store
   @param {String} modelName
   @return {String} normalizedModelName

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

@@ -75,11 +75,7 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
 
-    let internalModel = internalModelFactoryFor(this._store).peek(identifier);
-
-    if (internalModel) {
-      internalModel.notifyErrorsChange();
-    }
+    this._store._notificationManager.notify(identifier, 'errors');
   }
 
   _flushNotifications(): void {

package/addon/-private/request-cache.ts

@@ -62,7 +62,7 @@ export default class RequestCache {
             state: 'rejected',
             request: queryRequest,
             type,
-            response: { data: error && error.error },
+            response: { data: error },
           } as InternalRequest;
           finalizedRequest[Touching] = request[Touching];
           this._addDone(finalizedRequest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "4.7.0-beta.1",
+  "version": "4.8.0-alpha.2",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -17,8 +17,8 @@
     "start": "ember serve"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.7.0-beta.1",
-    "@ember-data/private-build-infra": "4.7.0-beta.1",
+    "@ember-data/canary-features": "4.8.0-alpha.2",
+    "@ember-data/private-build-infra": "4.8.0-alpha.2",
     "@ember/string": "^3.0.0",
     "@embroider/macros": "^1.8.3",
     "@glimmer/tracking": "^1.1.2",
@@ -29,7 +29,7 @@
     "ember-cli-typescript": "^5.1.0"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.7.0-beta.1",
+    "@ember-data/unpublished-test-infra": "4.8.0-alpha.2",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "~2.7.0",
     "@types/ember": "^4.0.0",

package/addon/-private/errors-utils.js

@@ -1,146 +0,0 @@
-/**
-  @module @ember-data/adapter/error
-*/
-
-const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
-const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
-const PRIMARY_ATTRIBUTE_KEY = 'base';
-
-function makeArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-
-/**
-  Convert an hash of errors into an array with errors in JSON-API format.
-   ```javascript
-  import DS from 'ember-data';
-
-   const { errorsHashToArray } = DS;
-
-   let errors = {
-    base: 'Invalid attributes on saving this record',
-    name: 'Must be present',
-    age: ['Must be present', 'Must be a number']
-  };
-   let errorsArray = errorsHashToArray(errors);
-  // [
-  //   {
-  //     title: "Invalid Document",
-  //     detail: "Invalid attributes on saving this record",
-  //     source: { pointer: "/data" }
-  //   },
-  //   {
-  //     title: "Invalid Attribute",
-  //     detail: "Must be present",
-  //     source: { pointer: "/data/attributes/name" }
-  //   },
-  //   {
-  //     title: "Invalid Attribute",
-  //     detail: "Must be present",
-  //     source: { pointer: "/data/attributes/age" }
-  //   },
-  //   {
-  //     title: "Invalid Attribute",
-  //     detail: "Must be a number",
-  //     source: { pointer: "/data/attributes/age" }
-  //   }
-  // ]
-  ```
-  @method errorsHashToArray
-  @for @ember-data/adapter/error
-  @static
-  @public
-  @param {Object} errors hash with errors as properties
-  @return {Array} array of errors in JSON-API format
-*/
-export function errorsHashToArray(errors) {
-  let out = [];
-
-  if (errors) {
-    Object.keys(errors).forEach((key) => {
-      let messages = makeArray(errors[key]);
-      for (let i = 0; i < messages.length; i++) {
-        let title = 'Invalid Attribute';
-        let pointer = `/data/attributes/${key}`;
-        if (key === PRIMARY_ATTRIBUTE_KEY) {
-          title = 'Invalid Document';
-          pointer = `/data`;
-        }
-        out.push({
-          title: title,
-          detail: messages[i],
-          source: {
-            pointer: pointer,
-          },
-        });
-      }
-    });
-  }
-
-  return out;
-}
-
-/**
-  Convert an array of errors in JSON-API format into an object.
-
-  ```javascript
-  import DS from 'ember-data';
-
-  const { errorsArrayToHash } = DS;
-
-  let errorsArray = [
-    {
-      title: 'Invalid Attribute',
-      detail: 'Must be present',
-      source: { pointer: '/data/attributes/name' }
-    },
-    {
-      title: 'Invalid Attribute',
-      detail: 'Must be present',
-      source: { pointer: '/data/attributes/age' }
-    },
-    {
-      title: 'Invalid Attribute',
-      detail: 'Must be a number',
-      source: { pointer: '/data/attributes/age' }
-    }
-  ];
-
-  let errors = errorsArrayToHash(errorsArray);
-  // {
-  //   "name": ["Must be present"],
-  //   "age":  ["Must be present", "must be a number"]
-  // }
-  ```
-
-  @method errorsArrayToHash
-  @static
-  @for @ember-data/adapter/error
-  @public
-  @param {Array} errors array of errors in JSON-API format
-  @return {Object}
-*/
-export function errorsArrayToHash(errors) {
-  let out = {};
-
-  if (errors) {
-    errors.forEach((error) => {
-      if (error.source && error.source.pointer) {
-        let key = error.source.pointer.match(SOURCE_POINTER_REGEXP);
-
-        if (key) {
-          key = key[2];
-        } else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) {
-          key = PRIMARY_ATTRIBUTE_KEY;
-        }
-
-        if (key) {
-          out[key] = out[key] || [];
-          out[key].push(error.detail || error.title);
-        }
-      }
-    });
-  }
-
-  return out;
-}