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

package/addon/-private/system/record-array-manager.js

@@ -7,6 +7,8 @@ import { assert } from '@ember/debug';
 import { get, set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
 
+import { REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT } from '@ember-data/canary-features';
+
 import isStableIdentifier from '../identifiers/is-stable-identifier';
 import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
 import { internalModelFactoryFor } from './store/internal-model-factory';
@@ -25,10 +27,11 @@ export function recordArraysForIdentifier(identifierOrInternalModel) {
 }
 
 const pendingForIdentifier = new Set([]);
+const IMDematerializing = new WeakMap();
 
 const getIdentifier = function getIdentifier(identifierOrInternalModel) {
   let i = identifierOrInternalModel;
-  if (!isStableIdentifier(identifierOrInternalModel)) {
+  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !isStableIdentifier(identifierOrInternalModel)) {
     // identifier may actually be an internalModel
     // but during materialization we will get an identifier that
     // has already been removed from the identifiers cache yet
@@ -39,7 +42,18 @@ const getIdentifier = function getIdentifier(identifierOrInternalModel) {
   return i;
 };
 
+// REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT only
 const peekIMCache = function peekIMCache(cache, identifier) {
+  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
+    let im = IMDematerializing.get(identifier);
+    if (im === undefined) {
+      // if not im._isDematerializing
+      im = cache.peek(identifier);
+    }
+
+    return im;
+  }
+
   return cache.peek(identifier);
 };
 
@@ -337,6 +351,14 @@ class RecordArrayManager {
     let modelName = identifier.type;
     identifier = getIdentifier(identifier);
 
+    if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
+      const cache = internalModelFactoryFor(this.store);
+      const im = peekIMCache(cache, identifier);
+      if (im && im._isDematerializing) {
+        IMDematerializing.set(identifier, im);
+      }
+    }
+
     if (pendingForIdentifier.has(identifier)) {
       return;
     }
@@ -406,10 +428,15 @@ const updateLiveRecordArray = function updateLiveRecordArray(store, recordArray,
 };
 
 const pushIdentifiers = function pushIdentifiers(recordArray, identifiers, cache) {
-  recordArray._pushIdentifiers(identifiers);
+  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !recordArray._pushIdentifiers) {
+    // deprecate('not allowed to use this intimate api any more');
+    recordArray._pushInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
+  } else {
+    recordArray._pushIdentifiers(identifiers);
+  }
 };
 const removeIdentifiers = function removeIdentifiers(recordArray, identifiers, cache) {
-  if (!recordArray._removeIdentifiers) {
+  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !recordArray._removeIdentifiers) {
     // deprecate('not allowed to use this intimate api any more');
     recordArray._removeInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
   } else {

package/addon/-private/system/references/belongs-to.ts

@@ -4,6 +4,7 @@ import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 import { DEPRECATE_BELONGS_TO_REFERENCE_PUSH } from '@ember-data/private-build-infra/deprecations';
 import type { BelongsToRelationship } from '@ember-data/record-data/-private';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
@@ -56,22 +57,26 @@ export default class BelongsToReference extends Reference {
     this.parent = parent!.recordReference;
     this.parentIdentifier = parentIdentifier;
 
-    this.#token = store._notificationManager.subscribe(
-      parentIdentifier,
-      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
-          this._ref++;
+    if (CUSTOM_MODEL_CLASS) {
+      this.#token = store._notificationManager.subscribe(
+        parentIdentifier,
+        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+          if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+            this._ref++;
+          }
         }
-      }
-    );
+      );
+    }
 
     // TODO inverse
   }
 
   destroy() {
-    unsubscribe(this.#token);
-    if (this.#relatedToken) {
-      unsubscribe(this.#relatedToken);
+    if (CUSTOM_MODEL_CLASS) {
+      unsubscribe(this.#token);
+      if (this.#relatedToken) {
+        unsubscribe(this.#relatedToken);
+      }
     }
   }
 
@@ -142,7 +147,17 @@ export default class BelongsToReference extends Reference {
    @return {String} The id of the record in this belongsTo relationship.
    */
   id(): string | null {
-    return this._relatedIdentifier?.id || null;
+    if (CUSTOM_MODEL_CLASS) {
+      return this._relatedIdentifier?.id || null;
+    }
+    let resource = this._resource();
+    if (resource && resource.data) {
+      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
+
+      return identifier.id;
+    }
+
+    return null;
   }
 
   _resource() {

package/addon/-private/system/references/has-many.ts

@@ -4,6 +4,7 @@ import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 import type { ManyRelationship } from '@ember-data/record-data/-private';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 
@@ -57,24 +58,28 @@ export default class HasManyReference extends Reference {
 
     this.parent = internalModelFactoryFor(store).peek(parentIdentifier)!.recordReference;
 
-    this.#token = store._notificationManager.subscribe(
-      parentIdentifier,
-      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
-          this._ref++;
+    if (CUSTOM_MODEL_CLASS) {
+      this.#token = store._notificationManager.subscribe(
+        parentIdentifier,
+        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+          if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+            this._ref++;
+          }
         }
-      }
-    );
-    this.#relatedTokenMap = new Map();
+      );
+      this.#relatedTokenMap = new Map();
+    }
     // TODO inverse
   }
 
   destroy() {
-    unsubscribe(this.#token);
-    this.#relatedTokenMap.forEach((token) => {
-      unsubscribe(token);
-    });
-    this.#relatedTokenMap.clear();
+    if (CUSTOM_MODEL_CLASS) {
+      unsubscribe(this.#token);
+      this.#relatedTokenMap.forEach((token) => {
+        unsubscribe(token);
+      });
+      this.#relatedTokenMap.clear();
+    }
   }
 
   @cached
@@ -201,7 +206,21 @@ export default class HasManyReference extends Reference {
    @return {Array} The ids in this has-many relationship
    */
   ids(): Array<string | null> {
-    return this._relatedIdentifiers.map((identifier) => identifier.id);
+    if (CUSTOM_MODEL_CLASS) {
+      return this._relatedIdentifiers.map((identifier) => identifier.id);
+    }
+
+    let resource = this._resource();
+
+    if (resource && resource.data) {
+      return resource.data.map((resourceIdentifier) => {
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+
+        return identifier.id;
+      });
+    }
+
+    return [];
   }
 
   /**

package/addon/-private/system/references/record.ts

@@ -3,6 +3,8 @@ import { cached, tracked } from '@glimmer/tracking';
 
 import RSVP, { resolve } from 'rsvp';
 
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
+
 import type { SingleResourceDocument } from '../../ts-interfaces/ember-data-json-api';
 import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
 import type { RecordInstance } from '../../ts-interfaces/record-instance';
@@ -30,18 +32,22 @@ export default class RecordReference extends Reference {
 
   constructor(public store: CoreStore, identifier: StableRecordIdentifier) {
     super(store, identifier);
-    this.#token = store._notificationManager.subscribe(
-      identifier,
-      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
-          this._ref++;
+    if (CUSTOM_MODEL_CLASS) {
+      this.#token = store._notificationManager.subscribe(
+        identifier,
+        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+          if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+            this._ref++;
+          }
         }
-      }
-    );
+      );
+    }
   }
 
   destroy() {
-    unsubscribe(this.#token);
+    if (CUSTOM_MODEL_CLASS) {
+      unsubscribe(this.#token);
+    }
   }
 
   public get type(): string {
@@ -79,7 +85,15 @@ export default class RecordReference extends Reference {
      @return {String} The id of the record.
   */
   id() {
-    return this._id;
+    if (CUSTOM_MODEL_CLASS) {
+      return this._id;
+    }
+    let identifier = this.identifier();
+    if (identifier) {
+      return identifier.id;
+    }
+
+    return null;
   }
 
   /**

package/addon/-private/system/snapshot.ts

@@ -4,6 +4,7 @@
 import { assert } from '@ember/debug';
 import { get } from '@ember/object';
 
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 
 import type { DSModel, DSModelSchema, ModelSchema } from '../ts-interfaces/ds-model';
@@ -64,9 +65,10 @@ export default class Snapshot implements Snapshot {
     let internalModel = (this._internalModel = _store._internalModelForResource(identifier));
     this.modelName = identifier.type;
 
-    // TODO add public docs once this FF is on
-    this.identifier = identifier;
-
+    if (CUSTOM_MODEL_CLASS) {
+      // TODO add public docs once this FF is on
+      this.identifier = identifier;
+    }
     /*
       If the internalModel does not yet have a record, then we are
       likely a snapshot being provided to a find request, so we
@@ -149,15 +151,26 @@ export default class Snapshot implements Snapshot {
     }
     let record = this.record;
     let attributes = (this.__attributes = Object.create(null));
-    let attrs = Object.keys(this._store._attributesDefinitionFor(this.modelName, this.identifier));
-    attrs.forEach((keyName) => {
-      if (schemaIsDSModel(this.type)) {
-        // if the schema is for a DSModel then the instance is too
-        attributes[keyName] = get(record as DSModel, keyName);
-      } else {
-        attributes[keyName] = recordDataFor(this._internalModel).getAttr(keyName);
-      }
-    });
+    let attrs: string[];
+
+    if (CUSTOM_MODEL_CLASS) {
+      attrs = Object.keys(this._store._attributesDefinitionFor(this.modelName, this.identifier));
+    } else {
+      attrs = Object.keys(this._store._attributesDefinitionFor(this.modelName));
+    }
+    if (CUSTOM_MODEL_CLASS) {
+      attrs.forEach((keyName) => {
+        if (schemaIsDSModel(this.type)) {
+          // if the schema is for a DSModel then the instance is too
+          attributes[keyName] = get(record as DSModel, keyName);
+        } else {
+          attributes[keyName] = recordDataFor(this._internalModel).getAttr(keyName);
+        }
+      });
+    } else {
+      // When CUSTOM_MODEL_CLASS is false `record` must be DSModel
+      (record as DSModel).eachAttribute((keyName) => (attributes[keyName] = get(record as DSModel, keyName)));
+    }
 
     return attributes;
   }
@@ -174,6 +187,9 @@ export default class Snapshot implements Snapshot {
   }
 
   get isNew(): boolean {
+    if (!CUSTOM_MODEL_CLASS) {
+      throw new Error('isNew is only available when custom model class ff is on');
+    }
     return this._internalModel.isNew();
   }
 
@@ -317,7 +333,7 @@ export default class Snapshot implements Snapshot {
     }
 
     const graphFor = require('@ember-data/record-data/-private').graphFor;
-    const { identifier } = this;
+    const { identifier } = CUSTOM_MODEL_CLASS ? this : this._internalModel;
     const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);
 
     assert(
@@ -416,7 +432,7 @@ export default class Snapshot implements Snapshot {
     }
 
     const graphFor = require('@ember-data/record-data/-private').graphFor;
-    const { identifier } = this;
+    const { identifier } = CUSTOM_MODEL_CLASS ? this : this._internalModel;
     const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);
     assert(
       `You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`,
@@ -472,10 +488,15 @@ export default class Snapshot implements Snapshot {
     @public
   */
   eachAttribute(callback: (key: string, meta: AttributeSchema) => void, binding?: unknown): void {
-    let attrDefs = this._store._attributesDefinitionFor(this.modelName, this.identifier);
-    Object.keys(attrDefs).forEach((key) => {
-      callback.call(binding, key, attrDefs[key] as AttributeSchema);
-    });
+    if (CUSTOM_MODEL_CLASS) {
+      let attrDefs = this._store._attributesDefinitionFor(this.modelName, this.identifier);
+      Object.keys(attrDefs).forEach((key) => {
+        callback.call(binding, key, attrDefs[key] as AttributeSchema);
+      });
+    } else {
+      // in the non CUSTOM_MODEL_CLASS world we only have DSModel instances
+      (this.record as DSModel).eachAttribute(callback, binding);
+    }
   }
 
   /**
@@ -496,10 +517,15 @@ export default class Snapshot implements Snapshot {
     @public
   */
   eachRelationship(callback: (key: string, meta: RelationshipSchema) => void, binding?: unknown): void {
-    let relationshipDefs = this._store._relationshipsDefinitionFor(this.modelName, this.identifier);
-    Object.keys(relationshipDefs).forEach((key) => {
-      callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);
-    });
+    if (CUSTOM_MODEL_CLASS) {
+      let relationshipDefs = this._store._relationshipsDefinitionFor(this.modelName, this.identifier);
+      Object.keys(relationshipDefs).forEach((key) => {
+        callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);
+      });
+    } else {
+      // in the non CUSTOM_MODEL_CLASS world we only have DSModel instances
+      (this.record as DSModel).eachRelationship(callback, binding);
+    }
   }
 
   /**

package/addon/-private/system/store/finders.js

@@ -1,8 +1,11 @@
-import { assert, deprecate } from '@ember/debug';
+import { assert, deprecate, warn } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
 import { Promise } from 'rsvp';
 
+import { REQUEST_SERVICE } from '@ember-data/canary-features';
+
+import coerceId from '../coerce-id';
 import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './common';
 import { normalizeResponseHelper } from './serializer-response';
 
@@ -18,7 +21,60 @@ function payloadIsNotBlank(adapterPayload) {
   }
 }
 
-export function _find() {}
+export function _find(adapter, store, modelClass, id, internalModel, options) {
+  if (REQUEST_SERVICE) {
+    assert(`Requests made when REQUEST_SERVICE=true should not use the legacy finders`);
+  }
+  let snapshot = internalModel.createSnapshot(options);
+  let { modelName } = internalModel;
+  let promise = Promise.resolve().then(() => {
+    return adapter.findRecord(store, modelClass, id, snapshot);
+  });
+  let label = `DS: Handle Adapter#findRecord of '${modelName}' with id: '${id}'`;
+  const { identifier } = internalModel;
+
+  promise = guardDestroyedStore(promise, store, label);
+
+  return 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`,
+        payloadIsNotBlank(adapterPayload)
+      );
+      let serializer = store.serializerFor(modelName);
+      let payload = normalizeResponseHelper(serializer, store, modelClass, 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',
+        }
+      );
+
+      // ensure that regardless of id returned we assign to the correct record
+      payload.data.lid = identifier.lid;
+
+      return store._push(payload);
+    },
+    (error) => {
+      internalModel.send('notFound');
+      if (internalModel.currentState.isEmpty) {
+        internalModel.unloadRecord();
+      }
+
+      throw error;
+    },
+    `DS: Extract payload of '${modelName}'`
+  );
+}
 
 export function _findMany(adapter, store, modelName, ids, internalModels, optionsMap) {
   let snapshots = internalModels.map((internalModel) => internalModel.createSnapshot(optionsMap.get(internalModel)));

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

@@ -1,3 +1,4 @@
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 import type { RelationshipDefinition } from '@ember-data/model/-private/system/relationships/relationship-meta';
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 
@@ -117,13 +118,16 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     if (!definition) {
       return null;
     }
-
-    if (metaIsRelationshipDefinition(definition)) {
-      return definition._inverseKey(this._store, modelClass);
-    } else if (definition.options && definition.options.inverse !== undefined) {
-      return definition.options.inverse;
+    if (CUSTOM_MODEL_CLASS) {
+      if (metaIsRelationshipDefinition(definition)) {
+        return definition._inverseKey(this._store, modelClass);
+      } else if (definition.options && definition.options.inverse !== undefined) {
+        return definition.options.inverse;
+      } else {
+        return null;
+      }
     } else {
-      return null;
+      return (definition as RelationshipDefinition)._inverseKey(this._store, modelClass);
     }
   }
 
@@ -133,18 +137,21 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     if (!definition) {
       return false;
     }
-
-    if (definition.options && definition.options.inverse === null) {
-      return false;
-    }
-    if ((definition as unknown as { inverseIsAsync?: boolean }).inverseIsAsync !== undefined) {
-      // TODO do we need to amend the RFC for this prop?
-      // else we should add it to the TS interface and document.
-      return !!(definition as unknown as { inverseIsAsync: boolean }).inverseIsAsync;
-    } else if (metaIsRelationshipDefinition(definition)) {
-      return definition._inverseIsAsync(this._store, modelClass);
+    if (CUSTOM_MODEL_CLASS) {
+      if (definition.options && definition.options.inverse === null) {
+        return false;
+      }
+      if ((definition as unknown as { inverseIsAsync?: boolean }).inverseIsAsync !== undefined) {
+        // TODO do we need to amend the RFC for this prop?
+        // else we should add it to the TS interface and document.
+        return !!(definition as unknown as { inverseIsAsync: boolean }).inverseIsAsync;
+      } else if (metaIsRelationshipDefinition(definition)) {
+        return definition._inverseIsAsync(this._store, modelClass);
+      } else {
+        return false;
+      }
     } else {
-      return false;
+      return (definition as RelationshipDefinition)._inverseIsAsync(this._store, modelClass);
     }
   }
 

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

@@ -1,11 +1,7 @@
-import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
-
 import type { RecordIdentifier } from './identifier';
 
 export interface Operation {
   op: string;
-  options: Dict<unknown> | undefined;
-  recordIdentifier: RecordIdentifier;
 }
 
 export interface FindRecordQuery extends Operation {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "4.2.0-alpha.8",
+  "version": "4.2.0",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -17,8 +17,8 @@
     "start": "ember serve"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.2.0-alpha.8",
-    "@ember-data/private-build-infra": "4.2.0-alpha.8",
+    "@ember-data/canary-features": "4.2.0",
+    "@ember-data/private-build-infra": "4.2.0",
     "@ember/string": "^3.0.0",
     "@glimmer/tracking": "^1.0.4",
     "ember-auto-import": "^2.2.4",
@@ -28,30 +28,30 @@
     "ember-cli-typescript": "^4.1.0"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.2.0-alpha.8",
+    "@ember-data/unpublished-test-infra": "4.2.0",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "^2.6.0",
     "@types/ember": "^3.16.5",
     "@types/rsvp": "^4.0.3",
     "broccoli-asset-rev": "^3.0.0",
-    "ember-cli": "~4.1.1",
+    "ember-cli": "~3.26.1",
     "ember-cli-dependency-checker": "^3.2.0",
-    "ember-cli-htmlbars": "^6.0.1",
+    "ember-cli-htmlbars": "^5.1.2",
     "ember-cli-inject-live-reload": "^2.0.2",
     "ember-cli-sri": "^2.1.1",
     "ember-cli-terser": "~4.0.1",
     "ember-disable-prototype-extensions": "^1.1.3",
     "ember-export-application-global": "^2.0.1",
     "ember-load-initializers": "^2.1.1",
-    "ember-maybe-import-regenerator": "^1.0.0",
+    "ember-maybe-import-regenerator": "^0.1.6",
     "ember-qunit": "^5.1.5",
-    "ember-resolver": "^8.0.3",
-    "ember-source": "~4.0.0",
+    "ember-resolver": "^8.0.0",
+    "ember-source": "~3.28.6",
     "ember-source-channel-url": "^3.0.0",
     "ember-try": "^1.4.0",
     "loader.js": "^4.7.0",
     "qunit": "^2.15.0",
-    "qunit-dom": "^2.0.0",
+    "qunit-dom": "^1.6.0",
     "webpack": "^5.37.1"
   },
   "engines": {