@ember-data/store 4.12.0-beta.6 → 4.12.0-beta.8

package/addon/{index-35424a6b.js → index-0d52354f.js}

@@ -35,6 +35,111 @@ import ObjectProxy from '@ember/object/proxy';
 function normalizeModelName$1(modelName) {
   return dasherize(modelName);
 }
+function getHydratedContent(store, request, document) {
+  if (Array.isArray(document.data)) {
+    const {
+      lid
+    } = document;
+    const {
+      recordArrayManager
+    } = store;
+    if (!lid) {
+      return recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document,
+        query: request
+      });
+    }
+    let managed = recordArrayManager._keyedArrays.get(lid);
+    if (!managed) {
+      managed = recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document
+      });
+      recordArrayManager._keyedArrays.set(lid, managed);
+    } else {
+      recordArrayManager.populateManagedArray(managed, document.data, document);
+    }
+    return managed;
+  } else {
+    return Object.assign({}, document, {
+      data: document.data ? store.peekRecord(document.data) : null
+    });
+  }
+}
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier) : false));
+}
+function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetch) {
+  const {
+    store
+  } = context.request;
+  const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
+  return next(context.request).then(document => {
+    store._enableAsyncFlush = true;
+    let response;
+    store._join(() => {
+      response = store.cache.put(document);
+      if (shouldFetch && shouldHydrate) {
+        response = getHydratedContent(store, context.request, response);
+      }
+    });
+    store._enableAsyncFlush = null;
+    if (shouldFetch) {
+      return response;
+    }
+  }, error => {
+    store._enableAsyncFlush = true;
+    store._join(() => {
+      store.cache.put(error);
+    });
+    store._enableAsyncFlush = null;
+
+    // TODO @runspired this is probably not the right thing to throw so make sure we add a test
+    if (!shouldBackgroundFetch) {
+      throw error;
+    }
+  });
+}
+const SkipCache = Symbol.for('ember-data:skip-cache');
+const EnableHydration = Symbol.for('ember-data:enable-hydration');
+const CacheHandler = {
+  request(context, next) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      return fetchContentAndHydrate(next, context, true, false);
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
+      void fetchContentAndHydrate(next, context, false, true);
+    }
+    if ('error' in peeked) {
+      throw peeked.error;
+    }
+    const shouldHydrate = context.request[EnableHydration] || false;
+    return Promise.resolve(shouldHydrate ? getHydratedContent(store, context.request, peeked.content) : peeked.content);
+  }
+};
 
 /*
  * Returns the Cache instance associated with a given
@@ -145,9 +250,13 @@ function installPolyfill() {
   @module @ember-data/store
 */
 const IDENTIFIERS = new Set();
+const DOCUMENTS = new Set();
 function isStableIdentifier(identifier) {
   return IDENTIFIERS.has(identifier);
 }
+function isDocumentIdentifier(identifier) {
+  return DOCUMENTS.has(identifier);
+}
 const isFastBoot = typeof FastBoot !== 'undefined';
 const _crypto = isFastBoot ? FastBoot.require('crypto') : window.crypto;
 if (macroCondition(getOwnConfig().polyfillUUID)) {
@@ -180,20 +289,31 @@ function setIdentifierResetMethod(method) {
   configuredResetMethod = method;
 }
 function defaultGenerationMethod(data, bucket) {
-  if (isNonEmptyString(data.lid)) {
-    return data.lid;
-  }
-  if (data.id !== undefined) {
-    let {
-      type,
-      id
-    } = data;
-    // TODO: add test for id not a string
-    if (isNonEmptyString(coerceId(id))) {
-      return `@lid:${normalizeModelName$1(type)}-${id}`;
+  if (bucket === 'record') {
+    if (isNonEmptyString(data.lid)) {
+      return data.lid;
     }
+    if (data.id !== undefined) {
+      let {
+        type,
+        id
+      } = data;
+      // TODO: add test for id not a string
+      if (isNonEmptyString(coerceId(id))) {
+        return `@lid:${normalizeModelName$1(type)}-${id}`;
+      }
+    }
+    return uuidv4();
+  } else if (bucket === 'document') {
+    if (!data.url) {
+      return null;
+    }
+    if (!data.method || data.method.toUpperCase() === 'GET') {
+      return data.url;
+    }
+    return null;
   }
-  return uuidv4();
+  assert(`Unknown bucket ${bucket}`, false);
 }
 function defaultEmptyCallback(...args) {}
 let DEBUG_MAP;
@@ -218,7 +338,8 @@ class IdentifierCache {
   constructor() {
     this._cache = {
       lids: new Map(),
-      types: Object.create(null)
+      types: Object.create(null),
+      documents: new Map()
     };
     // we cache the user configuredGenerationMethod at init because it must
     // be configured prior and is not allowed to be changed
@@ -392,6 +513,36 @@ class IdentifierCache {
     return this._getRecordIdentifier(resource, false);
   }
 
+  /**
+    Returns the DocumentIdentifier for the given Request, creates one if it does not yet exist.
+    Returns `null` if the request does not have a `cacheKey` or `url`.
+     @method getOrCreateDocumentIdentifier
+    @param request
+    @returns {StableDocumentIdentifier | null}
+    @public
+  */
+  getOrCreateDocumentIdentifier(request) {
+    let cacheKey = request.cacheOptions?.key;
+    if (!cacheKey) {
+      cacheKey = this._generate(request, 'document');
+    }
+    if (!cacheKey) {
+      return null;
+    }
+    let identifier = this._cache.documents.get(cacheKey);
+    if (identifier === undefined) {
+      identifier = {
+        lid: cacheKey
+      };
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
+        Object.freeze(identifier);
+      }
+      DOCUMENTS.add(identifier);
+      this._cache.documents.set(cacheKey, identifier);
+    }
+    return identifier;
+  }
+
   /**
     Returns the Identifier for the given Resource, creates one if it does not yet exist.
      Specifically this means that we:
@@ -559,6 +710,9 @@ class IdentifierCache {
     }
   }
   destroy() {
+    this._cache.documents.forEach(identifier => {
+      DOCUMENTS.delete(identifier);
+    });
     this._reset();
   }
 }
@@ -727,9 +881,9 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   return desc;
 }
 let tokenId = 0;
-const CacheOperations$1 = new Set(['added', 'removed', 'state', 'updated']);
+const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
 function isCacheOperationValue(value) {
-  return CacheOperations$1.has(value);
+  return CacheOperations.has(value);
 }
 function runLoopIsFlushing() {
   //@ts-expect-error
@@ -792,8 +946,9 @@ class NotificationManager {
    * @param {NotificationCallback} callback
    * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
    */
+
   subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier));
+    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
     let map = Cache.get(identifier);
     if (!map) {
       map = new Map();
@@ -833,7 +988,7 @@ class NotificationManager {
 
   notify(identifier, value, key) {
     assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
-    if (!isStableIdentifier(identifier)) {
+    if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
       if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
         // eslint-disable-next-line no-console
         console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
@@ -842,7 +997,7 @@ class NotificationManager {
     }
     if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
       // eslint-disable-next-line no-console
-      console.log(`Buffering Notify: ${String(identifier)}\t${value}\t${key || ''}`);
+      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
     }
     const hasSubscribers = Boolean(Cache.get(identifier)?.size);
     if (isCacheOperationValue(value) || hasSubscribers) {
@@ -894,7 +1049,7 @@ class NotificationManager {
 
     // TODO for documents this will need to switch based on Identifier kind
     if (isCacheOperationValue(value)) {
-      let callbackMap = Cache.get('resource');
+      let callbackMap = Cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
       if (callbackMap) {
         callbackMap.forEach(cb => {
           cb(identifier, value);
@@ -2273,7 +2428,7 @@ class LegacyWrapper {
     });
   }
   notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
 
     // TODO do we still get value from this?
     if (namespace === 'relationships' && key) {
@@ -2540,7 +2695,7 @@ class V2CacheStoreWrapper {
     });
   }
   notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
 
     // TODO do we still get value from this?
     if (namespace === 'relationships' && key) {
@@ -4712,75 +4867,18 @@ class Store {
    */
 
   /**
-   * Provides access to the IdentifierCache instance
-   * for this store.
-   *
-   * The IdentifierCache can be used to generate or
-   * retrieve a stable unique identifier for any resource.
-   *
-   * @property {IdentifierCache} identifierCache
-   * @public
-   */
-
-  /**
-   * Provides access to the requestManager instance associated
-   * with this Store instance.
-   *
-   * When using `ember-data` this property is automatically
-   * set to an instance of `RequestManager`. When not using `ember-data`
-   * you must configure this property yourself, either by declaring
-   * it as a service or by initializing it.
-   *
-   * ```ts
-   * import Store, { CacheHandler } from '@ember-data/store';
-   * import RequestManager from '@ember-data/request';
-   * import Fetch from '@ember/data/request/fetch';
-   *
-   * class extends Store {
-   *   constructor() {
-   *     super(...arguments);
-   *     this.requestManager = new RequestManager();
-   *     this.requestManager.use([Fetch]);
-   *     this.requestManager.useCache(CacheHandler);
-   *   }
-   * }
-   * ```
-   *
-   * @public
-   * @property {RequestManager} requestManager
-   */
-
-  /**
-   * A Property which an App may set to provide a Lifetimes Service
-   * to control when a cached request becomes stale.
-   *
-   * Note, when defined, these methods will only be invoked if `key` `url` and `method`
-   * are all present.
-   *
-   * `isSoftExpired` will only be invoked if `isHardExpired` returns `false`.
-   *
-   * ```ts
-   * store.lifetimes = {
-   *   // make the request and ignore the current cache state
-   *   isHardExpired(key: string, url: string, method?: HTTPMethod): boolean {
-   *     return false;
-   *   }
+   * Provides access to the SchemaService instance
+   * for this Store instance.
    *
-   *   // make the request in the background if true, return cache state
-   *   isSoftExpired(key: string, url: string, method: HTTPMethod): boolean {
-   *     return false;
-   *   }
-   * }
-   * ```
+   * The SchemaService can be used to query for
+   * information about the schema of a resource.
    *
+   * @property {SchemaService} schema
    * @public
-   * @property {LivetimesService|undefined} lifetimes
    */
-
-  // Private
-
-  // DEBUG-only properties
-
+  get schema() {
+    return this.getSchemaDefinitionService();
+  }
   /**
     @method init
     @private
@@ -4889,7 +4987,8 @@ class Store {
     // because constructor doesn't allow for this to run after
     // the user has had the chance to set the prop.
     let opts = {
-      store: this
+      store: this,
+      [EnableHydration]: true
     };
     if (macroCondition(getOwnConfig().env.TESTING)) {
       if (this.DISABLE_WAITER) {
@@ -4992,25 +5091,27 @@ class Store {
    */
   getSchemaDefinitionService() {
     if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      if (!this._schemaDefinitionService) {
+      if (!this._schema) {
         // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
         // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
-        this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
+        this._schema = new DSModelSchemaDefinitionService(this);
       }
     }
-    assert(`You must registerSchemaDefinitionService with the store to use custom model classes`, this._schemaDefinitionService);
-    return this._schemaDefinitionService;
+    assert(`You must registerSchemaDefinitionService with the store to use custom model classes`, this._schema);
+    return this._schema;
   }
 
   /**
-   * Allows an app to register a custom SchemaDefinitionService
+   * DEPRECATED - Use `registerSchema` instead.
+   *
+   * Allows an app to register a custom SchemaService
    * for use when information about a resource's schema needs
    * to be queried.
    *
    * 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.
+   * service by accessing `store.schema` prior to registration.
    *
    * For Example:
    *
@@ -5043,18 +5144,73 @@ class Store {
    *   constructor(...args) {
    *     super(...args);
    *
-   *     const schema = this.getSchemaDefinitionService();
+   *     const schema = this.schema;
    *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
    *   }
    * }
    * ```
    *
    * @method registerSchemaDefinitionService
-   * @param {SchemaDefinitionService} schema
+   * @param {SchemaService} schema
+   * @deprecated
    * @public
    */
   registerSchemaDefinitionService(schema) {
-    this._schemaDefinitionService = schema;
+    this._schema = schema;
+  }
+  /**
+   * Allows an app to register a custom SchemaService
+   * for use when information about a resource's schema needs
+   * to be queried.
+   *
+   * 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 accessing `store.schema` 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.schema;
+   *     this.registerSchema(new SchemaDelegator(schema));
+   *   }
+   * }
+   * ```
+   *
+   * @method registerSchema
+   * @param {SchemaService} schema
+   * @public
+   */
+  registerSchema(schema) {
+    this._schema = schema;
   }
 
   /**
@@ -5585,6 +5741,9 @@ class Store {
       data: {
         record: identifier,
         options
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -5799,6 +5958,9 @@ class Store {
         type: normalizeModelName$1(modelName),
         query,
         options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -5901,6 +6063,9 @@ class Store {
         type: normalizeModelName$1(modelName),
         query,
         options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -6071,6 +6236,9 @@ class Store {
       data: {
         type: normalizeModelName$1(modelName),
         options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -6459,6 +6627,9 @@ class Store {
       data: {
         options,
         record: identifier
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     }).then(document => document.content);
   }
@@ -6798,127 +6969,6 @@ function secretInit(record, cache, identifier, store) {
   StoreMap.set(record, store);
   setCacheFor(record, cache);
 }
-const CacheOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
-function getHydratedContent(store, request, document) {
-  if (!request.op || !CacheOperations.has(request.op)) {
-    return document;
-  }
-  if (Array.isArray(document.data)) {
-    const {
-      lid
-    } = document;
-    const {
-      recordArrayManager
-    } = store;
-    if (!lid) {
-      return recordArrayManager.createArray({
-        identifiers: document.data,
-        doc: document,
-        query: request
-      });
-    }
-    let managed = recordArrayManager._keyedArrays.get(lid);
-    if (!managed) {
-      managed = recordArrayManager.createArray({
-        identifiers: document.data,
-        doc: document
-      });
-      recordArrayManager._keyedArrays.set(lid, managed);
-    } else {
-      recordArrayManager.populateManagedArray(managed, document.data, document);
-    }
-    return managed;
-  } else {
-    switch (request.op) {
-      case 'findBelongsTo':
-      case 'queryRecord':
-      case 'findRecord':
-        return document.data ? store.peekRecord(document.data) : null;
-      default:
-        return document.data;
-    }
-  }
-}
-function calcShouldFetch(store, request, hasCachedValue, lid) {
-  const {
-    cacheOptions,
-    url,
-    method
-  } = request;
-  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false);
-}
-function calcShouldBackgroundFetch(store, request, willFetch, lid) {
-  const {
-    cacheOptions,
-    url,
-    method
-  } = request;
-  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && lid && url && method ? store.lifetimes.isSoftExpired(lid, url, method) : false));
-}
-function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetch) {
-  const {
-    store
-  } = context.request;
-  return next(context.request).then(document => {
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      response = store.cache.put(document);
-      if (shouldFetch) {
-        response = getHydratedContent(store, context.request, response);
-      }
-    });
-    store._enableAsyncFlush = null;
-    if (shouldFetch) {
-      return response;
-    }
-  }, error => {
-    store._enableAsyncFlush = true;
-    store._join(() => {
-      store.cache.put(error);
-    });
-    store._enableAsyncFlush = null;
-
-    // TODO @runspired this is probably not the right thing to throw so make sure we add a test
-    if (!shouldBackgroundFetch) {
-      throw error;
-    }
-  });
-}
-const CacheHandler = {
-  request(context, next) {
-    // if we are a legacy request or did not originate from the store, skip cache handling
-    if (!context.request.store || context.request.op && CacheOperations.has(context.request.op) && !context.request.url) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const {
-      cacheOptions,
-      url,
-      method
-    } = context.request;
-    const lid = cacheOptions?.key || method === 'GET' && url ? url : null;
-    const peeked = lid ? store.cache.peekRequest({
-      lid
-    }) : null;
-
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, lid)) {
-      return fetchContentAndHydrate(next, context, true, false);
-    }
-
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, lid)) {
-      void fetchContentAndHydrate(next, context, false, true);
-    }
-    if ('error' in peeked) {
-      throw peeked.error;
-    }
-    return Promise.resolve(getHydratedContent(store, context.request, peeked.content));
-  }
-};
 function normalizeModelName(modelName) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HELPERS)) {
     deprecate(`the helper function normalizeModelName is deprecated. You should use model names that are already normalized, or use string helpers of your own. This function is primarily an alias for dasherize from @ember/string.`, false, {