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

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

@@ -1,9 +1,11 @@
 import { getOwner, setOwner } from '@ember/application';
 import { assert, deprecate } 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';
@@ -67,7 +69,7 @@ class Store extends CoreStore {
     // for factorFor factory/class split
     let klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;
     if (!klass || !klass.isModel) {
-      if (!this.getSchemaDefinitionService().doesTypeExist(modelName)) {
+      if (!CUSTOM_MODEL_CLASS || !this.getSchemaDefinitionService().doesTypeExist(modelName)) {
         throw new EmberError(`No model was found for '${modelName}' and no schema handles the type`);
       }
       return getShimClass(this, modelName);
@@ -101,34 +103,83 @@ class Store extends CoreStore {
       typeof modelName === 'string'
     );
 
-    return this.getSchemaDefinitionService().doesTypeExist(modelName);
+    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;
+    }
   }
 
   _relationshipMetaFor(modelName: string, id: string | null, key: string) {
-    return this._relationshipsDefinitionFor(modelName)[key];
+    if (CUSTOM_MODEL_CLASS) {
+      return this._relationshipsDefinitionFor(modelName)[key];
+    } else {
+      let modelClass = this.modelFor(modelName);
+      let relationshipsByName = get(modelClass, 'relationshipsByName');
+      return relationshipsByName.get(key);
+    }
   }
 
   _attributesDefinitionFor(modelName: string, identifier?: StableRecordIdentifier) {
-    if (identifier) {
-      return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
+    if (CUSTOM_MODEL_CLASS) {
+      if (identifier) {
+        return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
+      } else {
+        return this.getSchemaDefinitionService().attributesDefinitionFor(modelName);
+      }
     } else {
-      return this.getSchemaDefinitionService().attributesDefinitionFor(modelName);
+      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;
     }
   }
 
   _relationshipsDefinitionFor(modelName: string, identifier?: StableRecordIdentifier): RelationshipsSchema {
-    if (identifier) {
-      return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
+    if (CUSTOM_MODEL_CLASS) {
+      if (identifier) {
+        return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
+      } else {
+        return this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);
+      }
     } else {
-      return this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);
+      let relationships = this._relationshipsDefCache[modelName];
+
+      if (relationships === undefined) {
+        let modelClass = this.modelFor(modelName);
+        relationships = get(modelClass, 'relationshipsObject') || null;
+        this._relationshipsDefCache[modelName] = relationships;
+      }
+
+      return relationships;
     }
   }
 
   getSchemaDefinitionService(): SchemaDefinitionService {
-    if (!this._schemaDefinitionService) {
-      this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
+    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';
     }
-    return this._schemaDefinitionService;
   }
 }
 

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

@@ -501,10 +501,10 @@ export default class FetchManager {
     }
   }
 
-  getPendingFetch(identifier: StableRecordIdentifier, options) {
-    let pendingRequests = this.requestCache.getPendingRequestsForRecord(identifier).filter((req) => {
-      return req.type === 'query' && isSameRequest(options, req.request.data[0].options);
-    });
+  getPendingFetch(identifier: StableRecordIdentifier) {
+    let pendingRequests = this.requestCache
+      .getPendingRequestsForRecord(identifier)
+      .filter((req) => req.type === 'query');
 
     if (pendingRequests.length > 0) {
       return pendingRequests[0][RequestPromise];
@@ -532,8 +532,3 @@ 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;
-}