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

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

@@ -1,15 +1,13 @@
 import { getOwner, setOwner } from '@ember/application';
-import { assert, deprecate } from '@ember/debug';
+import { assert } from '@ember/debug';
 import EmberError from '@ember/error';
-import { get } from '@ember/object';
 import { isPresent } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
 
-import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 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';
@@ -69,7 +67,7 @@ class Store extends CoreStore {
     // for factorFor factory/class split
     let klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;
     if (!klass || !klass.isModel) {
-      if (!CUSTOM_MODEL_CLASS || !this.getSchemaDefinitionService().doesTypeExist(modelName)) {
+      if (!this.getSchemaDefinitionService().doesTypeExist(modelName)) {
         throw new EmberError(`No model was found for '${modelName}' and no schema handles the type`);
       }
       return getShimClass(this, modelName);
@@ -103,83 +101,26 @@ class Store extends CoreStore {
       typeof modelName === 'string'
     );
 
-    if (CUSTOM_MODEL_CLASS) {
-      return this.getSchemaDefinitionService().doesTypeExist(modelName);
-    } else {
-      assert(`You need to pass a model name to the store's hasModelFor method`, isPresent(modelName));
-      assert(
-        `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
-        typeof modelName === 'string'
-      );
-      let normalizedModelName = normalizeModelName(modelName);
-      let factory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);
-
-      return factory !== null;
-    }
+    return this.getSchemaDefinitionService().doesTypeExist(modelName);
   }
 
   _relationshipMetaFor(modelName: string, id: string | null, key: string) {
-    if (CUSTOM_MODEL_CLASS) {
-      return this._relationshipsDefinitionFor(modelName)[key];
-    } else {
-      let modelClass = this.modelFor(modelName);
-      let relationshipsByName = get(modelClass, 'relationshipsByName');
-      return relationshipsByName.get(key);
-    }
+    return this._relationshipsDefinitionFor({ type: modelName })[key];
   }
 
-  _attributesDefinitionFor(modelName: string, identifier?: StableRecordIdentifier) {
-    if (CUSTOM_MODEL_CLASS) {
-      if (identifier) {
-        return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
-      } else {
-        return this.getSchemaDefinitionService().attributesDefinitionFor(modelName);
-      }
-    } else {
-      let attributes = this._attributesDefCache[modelName];
-
-      if (attributes === undefined) {
-        let modelClass = this.modelFor(modelName);
-        let attributeMap = get(modelClass, 'attributes');
-
-        attributes = Object.create(null);
-        attributeMap.forEach((meta, name) => (attributes[name] = meta));
-        this._attributesDefCache[modelName] = attributes;
-      }
-
-      return attributes;
-    }
+  _attributesDefinitionFor(identifier: RecordIdentifier | { type: string }) {
+    return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
   }
 
-  _relationshipsDefinitionFor(modelName: string, identifier?: StableRecordIdentifier): RelationshipsSchema {
-    if (CUSTOM_MODEL_CLASS) {
-      if (identifier) {
-        return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
-      } else {
-        return this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);
-      }
-    } else {
-      let relationships = this._relationshipsDefCache[modelName];
-
-      if (relationships === undefined) {
-        let modelClass = this.modelFor(modelName);
-        relationships = get(modelClass, 'relationshipsObject') || null;
-        this._relationshipsDefCache[modelName] = relationships;
-      }
-
-      return relationships;
-    }
+  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+    return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
   }
 
   getSchemaDefinitionService(): SchemaDefinitionService {
-    if (CUSTOM_MODEL_CLASS) {
-      if (!this._schemaDefinitionService) {
-        this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
-      }
-      return this._schemaDefinitionService;
-    } else {
-      throw 'schema service is only available when custom model class feature flag is on';
+    if (!this._schemaDefinitionService) {
+      this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
     }
+    return this._schemaDefinitionService;
   }
 }
 
@@ -188,48 +129,16 @@ let assertDestroyedStoreOnly: Function;
 
 if (DEBUG) {
   assertDestroyingStore = function assertDestroyedStore(store, method) {
-    if (!store.shouldAssertMethodCallsOnDestroyedStore) {
-      deprecate(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !(store.isDestroying || store.isDestroyed),
-        {
-          id: 'ember-data:method-calls-on-destroyed-store',
-          until: '3.8',
-          for: '@ember-data/store',
-          since: {
-            available: '3.8',
-            enabled: '3.8',
-          },
-        }
-      );
-    } else {
-      assert(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !(store.isDestroying || store.isDestroyed)
-      );
-    }
+    assert(
+      `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
+      !(store.isDestroying || store.isDestroyed)
+    );
   };
   assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
-    if (!store.shouldAssertMethodCallsOnDestroyedStore) {
-      deprecate(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !store.isDestroyed,
-        {
-          id: 'ember-data:method-calls-on-destroyed-store',
-          until: '3.8',
-          for: '@ember-data/store',
-          since: {
-            available: '3.8',
-            enabled: '3.8',
-          },
-        }
-      );
-    } else {
-      assert(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !store.isDestroyed
-      );
-    }
+    assert(
+      `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
+      !store.isDestroyed
+    );
   };
 }
 

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

@@ -20,6 +20,7 @@ import type { PrivateSnapshot } from './snapshot';
 import Snapshot from './snapshot';
 import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './store/common';
 import { normalizeResponseHelper } from './store/serializer-response';
+import WeakCache from './weak-cache';
 
 function payloadIsNotBlank(adapterPayload): boolean {
   if (Array.isArray(adapterPayload)) {
@@ -455,7 +456,7 @@ export default class FetchManager {
     let identifiers = new Array(totalItems);
     let seeking: { [id: string]: PendingFetchItem } = Object.create(null);
 
-    let optionsMap = new WeakMap<RecordIdentifier, Dict<unknown>>();
+    let optionsMap = new WeakCache<RecordIdentifier, Dict<unknown>>(DEBUG ? 'fetch-options' : '');
 
     for (let i = 0; i < totalItems; i++) {
       let pendingItem = pendingFetchItems[i];
@@ -501,10 +502,10 @@ export default class FetchManager {
     }
   }
 
-  getPendingFetch(identifier: StableRecordIdentifier) {
-    let pendingRequests = this.requestCache
-      .getPendingRequestsForRecord(identifier)
-      .filter((req) => req.type === 'query');
+  getPendingFetch(identifier: StableRecordIdentifier, options) {
+    let pendingRequests = this.requestCache.getPendingRequestsForRecord(identifier).filter((req) => {
+      return req.type === 'query' && isSameRequest(options, req.request.data[0].options);
+    });
 
     if (pendingRequests.length > 0) {
       return pendingRequests[0][RequestPromise];
@@ -532,3 +533,8 @@ function assertIsString(id: string | null): asserts id is string {
     }
   }
 }
+
+// this function helps resolve whether we have a pending request that we should use instead
+function isSameRequest(options: Dict<unknown> = {}, reqOptions: Dict<unknown> = {}) {
+  return options.include === reqOptions.include;
+}