@ember-data/store 4.4.0 → 4.5.0-alpha.2

package/addon/-private/system/ds-model-store.ts

@@ -7,9 +7,8 @@ import { DEBUG } from '@glimmer/env';
 import type DSModelClass from '@ember-data/model';
 
 import type { DSModel } from '../ts-interfaces/ds-model';
-import type { RecordIdentifier, StableRecordIdentifier } from '../ts-interfaces/identifier';
+import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
 import type { RecordDataRecordWrapper } from '../ts-interfaces/record-data-record-wrapper';
-import type { RelationshipsSchema } from '../ts-interfaces/record-data-schemas';
 import type { SchemaDefinitionService } from '../ts-interfaces/schema-definition-service';
 import CoreStore from './core-store';
 import type ShimModelClass from './model/shim-model-class';
@@ -108,14 +107,6 @@ class Store extends CoreStore {
     return this._relationshipsDefinitionFor({ type: modelName })[key];
   }
 
-  _attributesDefinitionFor(identifier: RecordIdentifier | { type: string }) {
-    return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
-  }
-
-  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
-    return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
-  }
-
   getSchemaDefinitionService(): SchemaDefinitionService {
     if (!this._schemaDefinitionService) {
       this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);

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

@@ -2,19 +2,24 @@
  * @module @ember-data/store
  */
 import { A } from '@ember/array';
-import { assert, warn } from '@ember/debug';
+import { assert, deprecate, warn } from '@ember/debug';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-import { default as RSVP, Promise } from 'rsvp';
+import { default as RSVP, resolve } from 'rsvp';
+
+import { DEPRECATE_RSVP_PROMISE } from '@ember-data/private-build-infra/deprecations';
 
 import type { CollectionResourceDocument, SingleResourceDocument } from '../ts-interfaces/ember-data-json-api';
 import type { FindRecordQuery, Request, SaveRecordMutation } from '../ts-interfaces/fetch-manager';
 import type { ExistingRecordIdentifier, RecordIdentifier, StableRecordIdentifier } from '../ts-interfaces/identifier';
+import type { MinimumSerializerInterface } from '../ts-interfaces/minimum-serializer-interface';
+import { FindOptions } from '../ts-interfaces/store';
 import type { Dict } from '../ts-interfaces/utils';
 import coerceId from './coerce-id';
 import type CoreStore from './core-store';
 import { errorsArrayToHash } from './errors-utils';
+import ShimModelClass from './model/shim-model-class';
 import RequestCache, { RequestPromise } from './request-cache';
 import type { PrivateSnapshot } from './snapshot';
 import Snapshot from './snapshot';
@@ -30,8 +35,15 @@ function payloadIsNotBlank(adapterPayload): boolean {
   }
 }
 
+type AdapterErrors = Error & { errors?: string[]; isAdapterError?: true };
+type SerializerWithParseErrors = MinimumSerializerInterface & {
+  extractErrors?(store: CoreStore, modelClass: ShimModelClass, error: AdapterErrors, recordId: string | null): any;
+};
+
 export const SaveOp: unique symbol = Symbol('SaveOp');
 
+export type FetchMutationOptions = FindOptions & { [SaveOp]: 'createRecord' | 'deleteRecord' | 'updateRecord' };
+
 interface PendingFetchItem {
   identifier: ExistingRecordIdentifier;
   queryRequest: Request;
@@ -44,7 +56,7 @@ interface PendingSaveItem {
   resolver: RSVP.Deferred<any>;
   snapshot: Snapshot;
   identifier: RecordIdentifier;
-  options: { [k: string]: unknown; [SaveOp]: 'createRecord' | 'saveRecord' | 'updateRecord' };
+  options: FetchMutationOptions;
   queryRequest: Request;
 }
 
@@ -78,7 +90,7 @@ export default class FetchManager {
 
     @internal
   */
-  scheduleSave(identifier: RecordIdentifier, options: any = {}): RSVP.Promise<null | SingleResourceDocument> {
+  scheduleSave(identifier: RecordIdentifier, options: FetchMutationOptions): Promise<null | SingleResourceDocument> {
     let promiseLabel = 'DS: Model#save ' + this;
     let resolver = RSVP.defer<null | SingleResourceDocument>(promiseLabel);
     let query: SaveRecordMutation = {
@@ -125,8 +137,8 @@ export default class FetchManager {
       typeof adapter[operation] === 'function'
     );
 
-    let promise = Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));
-    let serializer = store.serializerFor(modelName);
+    let promise = resolve().then(() => adapter[operation](store, modelClass, snapshot));
+    let serializer: SerializerWithParseErrors | null = store.serializerFor(modelName);
     let label = `DS: Extract and notify about ${operation} completion of ${internalModel}`;
 
     assert(
@@ -134,11 +146,26 @@ export default class FetchManager {
       promise !== undefined
     );
 
-    promise = guardDestroyedStore(promise, store, label);
-    promise = _guard(promise, _bind(_objectIsAlive, internalModel));
-
-    promise = promise.then(
+    promise = _guard(guardDestroyedStore(promise, store, label), _bind(_objectIsAlive, internalModel)).then(
       (adapterPayload) => {
+        if (!_objectIsAlive(internalModel)) {
+          if (DEPRECATE_RSVP_PROMISE) {
+            deprecate(
+              `A Promise while saving ${modelName} did not resolve by the time your model was destroyed. This will error in a future release.`,
+              false,
+              {
+                id: 'ember-data:rsvp-unresolved-async',
+                until: '5.0',
+                for: '@ember-data/store',
+                since: {
+                  available: '4.5',
+                  enabled: '4.5',
+                },
+              }
+            );
+          }
+        }
+
         if (adapterPayload) {
           return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
         }
@@ -147,7 +174,8 @@ export default class FetchManager {
         if (error && error.isAdapterError === true && error.code === 'InvalidError') {
           let parsedErrors = error.errors;
 
-          if (typeof serializer.extractErrors === 'function') {
+          // 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);
@@ -179,7 +207,7 @@ export default class FetchManager {
     }
   }
 
-  scheduleFetch(identifier: ExistingRecordIdentifier, options: any, shouldTrace: boolean): RSVP.Promise<any> {
+  scheduleFetch(identifier: ExistingRecordIdentifier, options: any, shouldTrace: boolean): Promise<any> {
     // TODO Probably the store should pass in the query object
 
     let query: FindRecordQuery = {
@@ -262,17 +290,16 @@ export default class FetchManager {
 
     let snapshot = new Snapshot(fetchItem.options, identifier, this._store);
     let klass = this._store.modelFor(identifier.type);
-
-    let promise = Promise.resolve().then(() => {
-      return adapter.findRecord(this._store, klass, identifier.id, snapshot);
-    });
-
     let id = identifier.id;
-
     let label = `DS: Handle Adapter#findRecord of '${modelName}' with id: '${id}'`;
 
-    promise = guardDestroyedStore(promise, this._store, label);
-    promise = promise.then(
+    let promise = guardDestroyedStore(
+      resolve().then(() => {
+        return adapter.findRecord(this._store, klass, identifier.id, snapshot);
+      }),
+      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`,
@@ -487,7 +514,7 @@ export default class FetchManager {
 
       let groups: Snapshot[][];
       if (adapter.groupRecordsForFindMany) {
-        groups = adapter.groupRecordsForFindMany(this, snapshots);
+        groups = adapter.groupRecordsForFindMany(this._store, snapshots);
       } else {
         groups = [snapshots];
       }