@ember-data/store 4.4.0-alpha.8 → 4.4.0

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

@@ -7,8 +7,9 @@ import { DEBUG } from '@glimmer/env';
 import type DSModelClass from '@ember-data/model';
 
 import type { DSModel } from '../ts-interfaces/ds-model';
-import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
+import type { RecordIdentifier, 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';
@@ -107,6 +108,14 @@ 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,24 +2,19 @@
  * @module @ember-data/store
  */
 import { A } from '@ember/array';
-import { assert, deprecate, warn } from '@ember/debug';
+import { assert, warn } from '@ember/debug';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-import { default as RSVP, resolve } from 'rsvp';
-
-import { DEPRECATE_RSVP_PROMISE } from '@ember-data/private-build-infra/deprecations';
+import { default as RSVP, Promise } from 'rsvp';
 
 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';
@@ -35,15 +30,8 @@ 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;
@@ -56,7 +44,7 @@ interface PendingSaveItem {
   resolver: RSVP.Deferred<any>;
   snapshot: Snapshot;
   identifier: RecordIdentifier;
-  options: FetchMutationOptions;
+  options: { [k: string]: unknown; [SaveOp]: 'createRecord' | 'saveRecord' | 'updateRecord' };
   queryRequest: Request;
 }
 
@@ -90,7 +78,7 @@ export default class FetchManager {
 
     @internal
   */
-  scheduleSave(identifier: RecordIdentifier, options: FetchMutationOptions): Promise<null | SingleResourceDocument> {
+  scheduleSave(identifier: RecordIdentifier, options: any = {}): RSVP.Promise<null | SingleResourceDocument> {
     let promiseLabel = 'DS: Model#save ' + this;
     let resolver = RSVP.defer<null | SingleResourceDocument>(promiseLabel);
     let query: SaveRecordMutation = {
@@ -137,8 +125,8 @@ export default class FetchManager {
       typeof adapter[operation] === 'function'
     );
 
-    let promise = resolve().then(() => adapter[operation](store, modelClass, snapshot));
-    let serializer: SerializerWithParseErrors | null = store.serializerFor(modelName);
+    let promise = Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));
+    let serializer = store.serializerFor(modelName);
     let label = `DS: Extract and notify about ${operation} completion of ${internalModel}`;
 
     assert(
@@ -146,26 +134,11 @@ export default class FetchManager {
       promise !== undefined
     );
 
-    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',
-                },
-              }
-            );
-          }
-        }
+    promise = guardDestroyedStore(promise, store, label);
+    promise = _guard(promise, _bind(_objectIsAlive, internalModel));
 
+    promise = promise.then(
+      (adapterPayload) => {
         if (adapterPayload) {
           return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
         }
@@ -174,8 +147,7 @@ export default class FetchManager {
         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') {
+          if (typeof serializer.extractErrors === 'function') {
             parsedErrors = serializer.extractErrors(store, modelClass, error, snapshot.id);
           } else {
             parsedErrors = errorsArrayToHash(error.errors);
@@ -207,7 +179,7 @@ export default class FetchManager {
     }
   }
 
-  scheduleFetch(identifier: ExistingRecordIdentifier, options: any, shouldTrace: boolean): Promise<any> {
+  scheduleFetch(identifier: ExistingRecordIdentifier, options: any, shouldTrace: boolean): RSVP.Promise<any> {
     // TODO Probably the store should pass in the query object
 
     let query: FindRecordQuery = {
@@ -290,16 +262,17 @@ 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}'`;
 
-    let promise = guardDestroyedStore(
-      resolve().then(() => {
-        return adapter.findRecord(this._store, klass, identifier.id, snapshot);
-      }),
-      this._store,
-      label
-    ).then(
+    promise = guardDestroyedStore(promise, this._store, label);
+    promise = promise.then(
       (adapterPayload) => {
         assert(
           `You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`,
@@ -514,7 +487,7 @@ export default class FetchManager {
 
       let groups: Snapshot[][];
       if (adapter.groupRecordsForFindMany) {
-        groups = adapter.groupRecordsForFindMany(this._store, snapshots);
+        groups = adapter.groupRecordsForFindMany(this, snapshots);
       } else {
         groups = [snapshots];
       }