@ember-data/store 4.8.0-alpha.6 → 4.8.0-beta.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

@@ -7,7 +7,8 @@ import { resolve } from 'rsvp';
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import { LOG_INSTANCE_CACHE } from '@ember-data/private-build-infra/debugging';
 import { DEPRECATE_V1_RECORD_DATA, DEPRECATE_V1CACHE_STORE_APIS } from '@ember-data/private-build-infra/deprecations';
-import type { Graph, peekGraph } from '@ember-data/record-data/-private/graph/index';
+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,
@@ -128,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;
 
@@ -178,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
@@ -210,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
@@ -220,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;
         }
 
         /*
@@ -259,7 +214,8 @@ export class InstanceCache {
       }
       */
 
-        return intendedIdentifier;
+        this.unloadRecord(staleIdentifier);
+        return keptIdentifier;
       }
     );
   }
@@ -365,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/managers/record-data-manager.ts

@@ -6,7 +6,7 @@ import type {
   SingleResourceRelationship,
 } from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
-import type { ChangedAttributesHash, RecordData, RecordDataV1 } from '@ember-data/types/q/record-data';
+import type { ChangedAttributesHash, MergeOperation, RecordData, RecordDataV1 } from '@ember-data/types/q/record-data';
 import type { JsonApiResource, JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
 import type { Dict } from '@ember-data/types/q/utils';
 
@@ -128,6 +128,25 @@ export class NonSingletonRecordDataManager implements RecordData {
     return recordData.pushData(identifier, data, hasRecord);
   }
 
+  /**
+   * Perform an operation on the cache to update the remote state.
+   *
+   * Note: currently the only valid operation is a MergeOperation
+   * which occurs when a collision of identifiers is detected.
+   *
+   * @method sync
+   * @public
+   * @param op the operation to perform
+   * @returns {void}
+   */
+  sync(op: MergeOperation): void {
+    const recordData = this.#recordData;
+    if (this.#isDeprecated(recordData)) {
+      return;
+    }
+    recordData.sync(op);
+  }
+
   /**
    * Update resource data with a local mutation. Currently supports operations
    * on relationships only.
@@ -740,6 +759,10 @@ export class SingletonRecordDataManager implements RecordData {
     return this.#recordData(identifier).pushData(identifier, data, hasRecord);
   }
 
+  sync(op: MergeOperation): void {
+    this.#recordData(op.record).sync(op);
+  }
+
   clientDidCreate(identifier: StableRecordIdentifier, options?: Dict<unknown>): Dict<unknown> {
     return this.#recordData(identifier).clientDidCreate(identifier, options);
   }

package/addon/-private/store-service.ts

@@ -407,15 +407,53 @@ class Store extends Service {
    * for use when information about a resource's schema needs
    * to be queried.
    *
-   * This method can only be called once and needs to be called before
-   * `getSchemaDefinitionService` is called when using `@ember-data/model`.
+   * This method can only be called more than once, but only one schema
+   * definition service may exist. Therefore if you wish to chain services
+   * you must lookup the existing service and close over it with the new
+   * service by calling `getSchemaDefinitionService` prior to registration.
+   *
+   * For Example:
+   *
+   * ```ts
+   * import Store from '@ember-data/store';
+   *
+   * class SchemaDelegator {
+   *   constructor(schema) {
+   *     this._schema = schema;
+   *   }
+   *
+   *   doesTypeExist(type: string): boolean {
+   *     if (AbstractSchemas.has(type)) {
+   *       return true;
+   *     }
+   *     return this._schema.doesTypeExist(type);
+   *   }
+   *
+   *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+   *     return this._schema.attributesDefinitionFor(identifier);
+   *   }
+   *
+   *   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+   *     const schema = AbstractSchemas.get(identifier.type);
+   *     return schema || this._schema.relationshipsDefinitionFor(identifier);
+   *   }
+   * }
+   *
+   * export default class extends Store {
+   *   constructor(...args) {
+   *     super(...args);
+   *
+   *     const schema = this.getSchemaDefinitionService();
+   *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
+   *   }
+   * }
+   * ```
    *
    * @method registerSchemaDefinitionService
    * @param {SchemaDefinitionService} schema
    * @public
    */
   registerSchemaDefinitionService(schema: SchemaDefinitionService) {
-    assert(`Cannot register a schema definition service when one already exists`, !this._schemaDefinitionService);
     this._schemaDefinitionService = schema;
   }
 
@@ -2575,16 +2613,6 @@ class Store extends Service {
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
 
-    if (HAS_RECORD_DATA_PACKAGE) {
-      const peekGraph = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).peekGraph;
-      let graph = peekGraph(this);
-      if (graph) {
-        graph.willDestroy();
-      }
-    }
-
     this.unloadAll();
 
     if (DEBUG) {

package/addon/-private/utils/uuid-polyfill.ts

@@ -1,71 +1,73 @@
 /**
   @module @ember-data/store
 */
-const isFastBoot = typeof FastBoot !== 'undefined';
-const CRYPTO: Crypto = isFastBoot ? (FastBoot.require('crypto') as Crypto) : window.crypto;
-
 interface FastbootCrypto {
   randomFillSync(v: Uint8Array): Uint8Array;
 }
 
-if (!CRYPTO.randomUUID) {
-  // we might be able to optimize this by requesting more bytes than we need at a time
-  const rng = function (): Uint8Array {
-    // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
-    let rnds8 = new Uint8Array(16);
+export default function installPolyfill() {
+  const isFastBoot = typeof FastBoot !== 'undefined';
+  const CRYPTO: Crypto = isFastBoot ? (FastBoot.require('crypto') as Crypto) : window.crypto;
 
-    if (!CRYPTO.getRandomValues && !isFastBoot) {
-      throw new Error(`Unable to generate bytes for UUID`);
-    }
+  if (!CRYPTO.randomUUID) {
+    // we might be able to optimize this by requesting more bytes than we need at a time
+    const rng = function (): Uint8Array {
+      // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
+      let rnds8 = new Uint8Array(16);
 
-    return CRYPTO.getRandomValues
-      ? CRYPTO.getRandomValues(rnds8)
-      : (CRYPTO as unknown as FastbootCrypto).randomFillSync(rnds8);
-  };
+      if (!CRYPTO.getRandomValues && !isFastBoot) {
+        throw new Error(`Unable to generate bytes for UUID`);
+      }
 
-  /*
-   * Convert array of 16 byte values to UUID string format of the form:
-   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
-   */
-  const byteToHex: string[] = [];
-  for (let i = 0; i < 256; ++i) {
-    byteToHex[i] = (i + 0x100).toString(16).substr(1);
-  }
+      return CRYPTO.getRandomValues
+        ? CRYPTO.getRandomValues(rnds8)
+        : (CRYPTO as unknown as FastbootCrypto).randomFillSync(rnds8);
+    };
 
-  const bytesToUuid = function (buf: Uint8Array) {
-    let bth = byteToHex;
-    // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
-    return [
-      bth[buf[0]],
-      bth[buf[1]],
-      bth[buf[2]],
-      bth[buf[3]],
-      '-',
-      bth[buf[4]],
-      bth[buf[5]],
-      '-',
-      bth[buf[6]],
-      bth[buf[7]],
-      '-',
-      bth[buf[8]],
-      bth[buf[9]],
-      '-',
-      bth[buf[10]],
-      bth[buf[11]],
-      bth[buf[12]],
-      bth[buf[13]],
-      bth[buf[14]],
-      bth[buf[15]],
-    ].join('');
-  };
+    /*
+     * Convert array of 16 byte values to UUID string format of the form:
+     * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+     */
+    const byteToHex: string[] = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex[i] = (i + 0x100).toString(16).substr(1);
+    }
+
+    const bytesToUuid = function (buf: Uint8Array) {
+      let bth = byteToHex;
+      // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
+      return [
+        bth[buf[0]],
+        bth[buf[1]],
+        bth[buf[2]],
+        bth[buf[3]],
+        '-',
+        bth[buf[4]],
+        bth[buf[5]],
+        '-',
+        bth[buf[6]],
+        bth[buf[7]],
+        '-',
+        bth[buf[8]],
+        bth[buf[9]],
+        '-',
+        bth[buf[10]],
+        bth[buf[11]],
+        bth[buf[12]],
+        bth[buf[13]],
+        bth[buf[14]],
+        bth[buf[15]],
+      ].join('');
+    };
 
-  CRYPTO.randomUUID = function uuidv4(): string {
-    let rnds = rng();
+    CRYPTO.randomUUID = function uuidv4(): string {
+      let rnds = rng();
 
-    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-    rnds[6] = (rnds[6] & 0x0f) | 0x40;
-    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+      // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+      rnds[6] = (rnds[6] & 0x0f) | 0x40;
+      rnds[8] = (rnds[8] & 0x3f) | 0x80;
 
-    return bytesToUuid(rnds);
-  };
+      return bytesToUuid(rnds);
+    };
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "4.8.0-alpha.6",
+  "version": "4.8.0-beta.0",
   "description": "The core of EmberData. Provides the Store service which coordinates the cache with the network and presentation layers.",
   "keywords": [
     "ember-addon"
@@ -21,8 +21,8 @@
     "start": "ember serve"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.8.0-alpha.6",
-    "@ember-data/private-build-infra": "4.8.0-alpha.6",
+    "@ember-data/canary-features": "4.8.0-beta.0",
+    "@ember-data/private-build-infra": "4.8.0-beta.0",
     "@ember/string": "^3.0.0",
     "@embroider/macros": "^1.8.3",
     "@glimmer/tracking": "^1.1.2",
@@ -33,7 +33,7 @@
     "ember-cli-typescript": "^5.1.0"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.8.0-alpha.6",
+    "@ember-data/unpublished-test-infra": "4.8.0-beta.0",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "~2.7.0",
     "@types/ember": "^4.0.1",