@ember-data/store 4.8.0-alpha.5 → 4.9.0-alpha.0

package/addon/-debug/index.js

@@ -1,6 +1,8 @@
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
+import { DEPRECATE_NON_EXPLICIT_POLYMORPHISM } from '@ember-data/private-build-infra/deprecations';
+
 /*
   Assert that `addedRecord` has a valid type so it can be added to the
   relationship of the `record`.
@@ -29,18 +31,38 @@ if (DEBUG) {
   };
 
   assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
-    store = store._store ? store._store : store; // allow usage with storeWrapper
-    let addedModelName = addedIdentifier.type;
-    let parentModelName = parentIdentifier.type;
-    let key = parentDefinition.key;
-    let relationshipModelName = parentDefinition.type;
-    let relationshipClass = store.modelFor(relationshipModelName);
-    let addedClass = store.modelFor(addedModelName);
-
-    let assertionMessage = `The '${addedModelName}' type does not implement '${relationshipModelName}' and thus cannot be assigned to the '${key}' relationship in '${parentModelName}'. Make it a descendant of '${relationshipModelName}' or use a mixin of the same name.`;
-    let isPolymorphic = checkPolymorphic(relationshipClass, addedClass);
-
-    assert(assertionMessage, isPolymorphic);
+    let asserted = false;
+
+    if (parentDefinition.inverseIsImplicit) {
+      return;
+    }
+    if (parentDefinition.isPolymorphic) {
+      let meta = store.getSchemaDefinitionService().relationshipsDefinitionFor(addedIdentifier)[
+        parentDefinition.inverseKey
+      ];
+      if (meta?.options?.as) {
+        asserted = true;
+        assert(
+          `The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`,
+          meta.options.as === parentDefinition.type
+        );
+      }
+    }
+
+    if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM && !asserted) {
+      store = store._store ? store._store : store; // allow usage with storeWrapper
+      let addedModelName = addedIdentifier.type;
+      let parentModelName = parentIdentifier.type;
+      let key = parentDefinition.key;
+      let relationshipModelName = parentDefinition.type;
+      let relationshipClass = store.modelFor(relationshipModelName);
+      let addedClass = store.modelFor(addedModelName);
+
+      let assertionMessage = `The '${addedModelName}' type does not implement '${relationshipModelName}' and thus cannot be assigned to the '${key}' relationship in '${parentModelName}'. Make it a descendant of '${relationshipModelName}' or use a mixin of the same name.`;
+      let isPolymorphic = checkPolymorphic(relationshipClass, addedClass);
+
+      assert(assertionMessage, isPolymorphic);
+    }
   };
 }
 

package/addon/-private/caches/identifier-cache.ts

@@ -4,7 +4,7 @@
 import { assert, warn } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
-import { getOwnConfig, importSync, macroCondition } from '@embroider/macros';
+import { getOwnConfig, macroCondition } from '@embroider/macros';
 
 import { LOG_IDENTIFIERS } from '@ember-data/private-build-infra/debugging';
 import type { ExistingResourceObject, ResourceIdentifierObject } from '@ember-data/types/q/ember-data-json-api';
@@ -25,6 +25,7 @@ import coerceId from '../utils/coerce-id';
 import { DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '../utils/identifer-debug-consts';
 import isNonEmptyString from '../utils/is-non-empty-string';
 import normalizeModelName from '../utils/normalize-model-name';
+import installPolyfill from '../utils/uuid-polyfill';
 
 const IDENTIFIERS = new Set();
 
@@ -36,7 +37,7 @@ const isFastBoot = typeof FastBoot !== 'undefined';
 const _crypto: Crypto = isFastBoot ? (FastBoot.require('crypto') as Crypto) : window.crypto;
 
 if (macroCondition(getOwnConfig<{ polyfillUUID: boolean }>().polyfillUUID)) {
-  importSync('./utils/uuid-polyfill');
+  installPolyfill();
 }
 
 function uuidv4(): string {

package/addon/-private/caches/instance-cache.ts

@@ -4,11 +4,11 @@ import { DEBUG } from '@glimmer/env';
 import { importSync } from '@embroider/macros';
 import { resolve } from 'rsvp';
 
-import { V2CACHE_SINGLETON_MANAGER } from '@ember-data/canary-features';
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import { LOG_INSTANCE_CACHE } from '@ember-data/private-build-infra/debugging';
-import { DEPRECATE_V1CACHE_STORE_APIS } from '@ember-data/private-build-infra/deprecations';
-import type { Graph, peekGraph } from '@ember-data/record-data/-private/graph/index';
+import { DEPRECATE_V1_RECORD_DATA, DEPRECATE_V1CACHE_STORE_APIS } from '@ember-data/private-build-infra/deprecations';
+import type { Graph } from '@ember-data/record-data/-private/graph/graph';
+import type { peekGraph } from '@ember-data/record-data/-private/graph/index';
 import type {
   ExistingResourceIdentifierObject,
   ExistingResourceObject,
@@ -129,44 +129,6 @@ export class InstanceCache {
     reference: new WeakMap<StableRecordIdentifier, RecordReference>(),
   };
 
-  recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted: boolean = false) {
-    const recordData = this.__instances.recordData.get(identifier);
-    if (!recordData) {
-      return false;
-    }
-    const isNew = recordData.isNew(identifier);
-    const isEmpty = recordData.isEmpty(identifier);
-
-    // if we are new we must consider ourselves loaded
-    if (isNew) {
-      return !recordData.isDeleted(identifier);
-    }
-    // even if we have a past request, if we are now empty we are not loaded
-    // typically this is true after an unloadRecord call
-
-    // if we are not empty, not new && we have a fulfilled request then we are loaded
-    // we should consider allowing for something to be loaded that is simply "not empty".
-    // which is how RecordState currently handles this case; however, RecordState is buggy
-    // in that it does not account for unloading.
-    return filterDeleted && recordData.isDeletionCommitted(identifier) ? false : !isEmpty;
-
-    /*
-    const req = this.store.getRequestStateService();
-    const fulfilled = req.getLastRequestForRecord(identifier);
-    const isLocallyLoaded = !isEmpty;
-    const isLoading =
-      !isLocallyLoaded &&
-      fulfilled === null &&
-      req.getPendingRequestsForRecord(identifier).some((req) => req.type === 'query');
-
-    if (isEmpty || (filterDeleted && recordData.isDeletionCommitted(identifier)) || isLoading) {
-      return false;
-    }
-
-    return true;
-    */
-  }
-
   constructor(store: Store) {
     this.store = store;
 
@@ -179,25 +141,24 @@ export class InstanceCache {
 
     store.identifierCache.__configureMerge(
       (identifier: StableRecordIdentifier, matchedIdentifier: StableRecordIdentifier, resourceData) => {
-        let intendedIdentifier = identifier;
+        let keptIdentifier = identifier;
         if (identifier.id !== matchedIdentifier.id) {
-          intendedIdentifier =
-            'id' in resourceData && identifier.id === resourceData.id ? identifier : matchedIdentifier;
+          keptIdentifier = 'id' in resourceData && identifier.id === resourceData.id ? identifier : matchedIdentifier;
         } else if (identifier.type !== matchedIdentifier.type) {
-          intendedIdentifier =
+          keptIdentifier =
             'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;
         }
-        let altIdentifier = identifier === intendedIdentifier ? matchedIdentifier : identifier;
+        let staleIdentifier = identifier === keptIdentifier ? matchedIdentifier : identifier;
 
         // check for duplicate entities
-        let imHasRecord = this.__instances.record.has(intendedIdentifier);
-        let otherHasRecord = this.__instances.record.has(altIdentifier);
-        let imRecordData = this.__instances.recordData.get(intendedIdentifier) || null;
-        let otherRecordData = this.__instances.recordData.get(altIdentifier) || null;
+        let keptHasRecord = this.__instances.record.has(keptIdentifier);
+        let staleHasRecord = this.__instances.record.has(staleIdentifier);
+        let keptRecordData = this.__instances.recordData.get(keptIdentifier) || null;
+        let staleRecordData = this.__instances.recordData.get(staleIdentifier) || null;
 
         // we cannot merge entities when both have records
         // (this may not be strictly true, we could probably swap the recordData the record points at)
-        if (imHasRecord && otherHasRecord) {
+        if (keptHasRecord && staleHasRecord) {
           // TODO we probably don't need to throw these errors anymore
           // we can probably just "swap" what data source the abandoned
           // record points at so long as
@@ -211,7 +172,7 @@ export class InstanceCache {
               }:${String(matchedIdentifier.id)} (${matchedIdentifier.lid})'`
             );
           }
-          // TODO @runspired determine when this is even possible
+
           assert(
             `Failed to update the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${
               identifier.lid
@@ -221,33 +182,26 @@ export class InstanceCache {
           );
         }
 
-        // remove "other" from cache
-        if (otherHasRecord) {
-          // TODO probably need to release other things
+        let recordData = keptRecordData || staleRecordData;
+
+        if (recordData) {
+          recordData.sync({
+            op: 'mergeIdentifiers',
+            record: staleIdentifier,
+            value: keptIdentifier,
+          });
+        } else if (HAS_RECORD_DATA_PACKAGE) {
+          // TODO notify cache always, this requires it always being a singleton
+          // and not ever specific to one record-data
+          this.store.__private_singleton_recordData?.sync({
+            op: 'mergeIdentifiers',
+            record: staleIdentifier,
+            value: keptIdentifier,
+          });
         }
 
-        if (imRecordData === null && otherRecordData === null) {
-          // nothing more to do
-          return intendedIdentifier;
-
-          // only the other has a RecordData
-          // OR only the other has a Record
-        } else if (
-          (imRecordData === null && otherRecordData !== null) ||
-          (imRecordData && !imHasRecord && otherRecordData && otherHasRecord)
-        ) {
-          if (imRecordData) {
-            // TODO check if we are retained in any async relationships
-            // TODO probably need to release other things
-            // im.destroy();
-          }
-          imRecordData = otherRecordData!;
-          // TODO do we need to notify the id change?
-          // TODO swap recordIdentifierFor result?
-
-          // just use im
-        } else {
-          // otherIm.destroy();
+        if (staleRecordData === null) {
+          return keptIdentifier;
         }
 
         /*
@@ -260,7 +214,8 @@ export class InstanceCache {
       }
       */
 
-        return intendedIdentifier;
+        this.unloadRecord(staleIdentifier);
+        return keptIdentifier;
       }
     );
   }
@@ -324,23 +279,23 @@ export class InstanceCache {
           identifier.lid,
           this._storeWrapper
         );
-        if (V2CACHE_SINGLETON_MANAGER) {
+        if (DEPRECATE_V1_RECORD_DATA) {
+          recordData = new NonSingletonRecordDataManager(this.store, recordDataInstance, identifier);
+        } else {
           recordData = this.__cacheManager =
             this.__cacheManager || new NonSingletonRecordDataManager(this.store, recordDataInstance, identifier);
-        } else {
-          recordData = new NonSingletonRecordDataManager(this.store, recordDataInstance, identifier);
         }
       } else {
         let recordDataInstance = this.store.createRecordDataFor(identifier, this._storeWrapper);
-        if (V2CACHE_SINGLETON_MANAGER) {
+        if (DEPRECATE_V1_RECORD_DATA) {
+          recordData = new NonSingletonRecordDataManager(this.store, recordDataInstance, identifier);
+        } else {
           if (DEBUG) {
-            recordData = this.__cacheManager = this.__cacheManager || new SingletonRecordDataManager(this.store);
+            recordData = this.__cacheManager = this.__cacheManager || new SingletonRecordDataManager();
             (recordData as SingletonRecordDataManager)._addRecordData(identifier, recordDataInstance as RecordData);
           } else {
             recordData = recordDataInstance as RecordData;
           }
-        } else {
-          recordData = new NonSingletonRecordDataManager(this.store, recordDataInstance, identifier);
         }
       }
       setRecordDataFor(identifier, recordData);
@@ -366,6 +321,44 @@ export class InstanceCache {
     return reference;
   }
 
+  recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted: boolean = false) {
+    const recordData = this.__instances.recordData.get(identifier);
+    if (!recordData) {
+      return false;
+    }
+    const isNew = recordData.isNew(identifier);
+    const isEmpty = recordData.isEmpty(identifier);
+
+    // if we are new we must consider ourselves loaded
+    if (isNew) {
+      return !recordData.isDeleted(identifier);
+    }
+    // even if we have a past request, if we are now empty we are not loaded
+    // typically this is true after an unloadRecord call
+
+    // if we are not empty, not new && we have a fulfilled request then we are loaded
+    // we should consider allowing for something to be loaded that is simply "not empty".
+    // which is how RecordState currently handles this case; however, RecordState is buggy
+    // in that it does not account for unloading.
+    return filterDeleted && recordData.isDeletionCommitted(identifier) ? false : !isEmpty;
+
+    /*
+    const req = this.store.getRequestStateService();
+    const fulfilled = req.getLastRequestForRecord(identifier);
+    const isLocallyLoaded = !isEmpty;
+    const isLoading =
+      !isLocallyLoaded &&
+      fulfilled === null &&
+      req.getPendingRequestsForRecord(identifier).some((req) => req.type === 'query');
+
+    if (isEmpty || (filterDeleted && recordData.isDeletionCommitted(identifier)) || isLoading) {
+      return false;
+    }
+
+    return true;
+    */
+  }
+
   createSnapshot(identifier: StableRecordIdentifier, options: FindOptions = {}): Snapshot {
     return new Snapshot(options, identifier, this.store);
   }

package/addon/-private/index.ts

@@ -18,6 +18,7 @@ export {
   setIdentifierUpdateMethod,
   setIdentifierForgetMethod,
   setIdentifierResetMethod,
+  isStableIdentifier,
 } from './caches/identifier-cache';
 
 export function normalizeModelName(modelName: string) {
@@ -41,12 +42,15 @@ export function normalizeModelName(modelName: string) {
 // to also eliminate
 export { default as coerceId } from './utils/coerce-id';
 
-export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './proxies/promise-proxies';
-
-export { default as RecordArray } from './record-arrays/record-array';
-export { default as AdapterPopulatedRecordArray } from './record-arrays/adapter-populated-record-array';
-
-export { default as RecordArrayManager } from './managers/record-array-manager';
+export {
+  default as RecordArray,
+  default as IdentifierArray,
+  Collection as AdapterPopulatedRecordArray,
+  SOURCE,
+  MUTATE,
+  IDENTIFIER_ARRAY_TAG,
+} from './record-arrays/identifier-array';
+export { default as RecordArrayManager, fastPush } from './managers/record-array-manager';
 
 // // Used by tests
 export { default as SnapshotRecordArray } from './network/snapshot-record-array';

package/addon/-private/legacy-model-support/shim-model-class.ts

@@ -15,6 +15,7 @@ export function getShimClass(store: Store, modelName: string): ShimModelClass {
     shims = Object.create(null) as Dict<ShimModelClass>;
     AvailableShims.set(store, shims);
   }
+
   let shim = shims[modelName];
   if (shim === undefined) {
     shim = shims[modelName] = new ShimModelClass(store, modelName);