@warp-drive/core 5.6.0-alpha.5 → 5.6.0-beta.1

package/dist/handler-C2T-IyJK.js

@@ -0,0 +1,339 @@
+import { J as ReactiveDocument } from "./request-state-CjLph1LP.js";
+import { SkipCache, EnableHydration } from './types/request.js';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
+}
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
+function cloneError(error) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+function getPriority(identifier, deduped, priority) {
+  if (identifier) {
+    const existing = deduped.get(identifier);
+    if (existing) {
+      return existing.priority;
+    }
+  }
+  return priority;
+}
+
+/**
+ * A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
+ *
+ * This handler will only run when a request has supplied a `store` instance. Requests
+ * issued by the store via `store.request()` will automatically have the `store` instance
+ * attached to the request.
+ *
+ * ```ts
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET'
+ * });
+ * ```
+ *
+ * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+ * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+ * return a `Document` instance that will automatically update the UI when the cache is updated
+ * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+ *
+ * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+ * means that if desired you can issue requests that utilize the cache without needing to also
+ * utilize Record instances if desired.
+ *
+ * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+ * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+ * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+ * approach of WarpDrive allows for this flexibility.
+ *
+ * ```ts
+ * import { EnableHydration } from '@warp-drive/core/types/request';
+ *
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET',
+ *   [EnableHydration]: true
+ * });
+ *
+ */
+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);
+    if (identifier) {
+      context.setIdentifier(identifier);
+    }
+
+    // used to dedupe existing requests that match
+    const DEDUPE = store.requestManager._deduped;
+    const activeRequest = identifier && DEDUPE.get(identifier);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      if (activeRequest) {
+        activeRequest.priority = {
+          blocking: true
+        };
+        return activeRequest.promise;
+      }
+      let promise = fetchContentAndHydrate(next, context, identifier, {
+        blocking: true
+      });
+      if (identifier) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: true
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      return promise;
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
+      let promise = activeRequest?.promise || fetchContentAndHydrate(next, context, identifier, {
+        blocking: false
+      });
+      if (identifier && !activeRequest) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: false
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      store.requestManager._pending.set(context.id, promise);
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a peeked request to be present`);
+      }
+    })(peeked) : {};
+    const shouldHydrate = context.request[EnableHydration] || false;
+    context.setResponse(peeked.response);
+    if ('error' in peeked) {
+      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        identifier
+      }, peeked.content) : peeked.content;
+      const newError = cloneError(peeked);
+      newError.content = content;
+      throw newError;
+    }
+    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+      shouldHydrate,
+      identifier
+    }, peeked.content) : peeked.content;
+    return result;
+  }
+};
+function maybeUpdateUiObjects(store, request, options, document) {
+  const {
+    identifier
+  } = options;
+  if (!document || !options.shouldHydrate) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The CacheHandler expected response content but none was found`);
+      }
+    })(!options.shouldHydrate) : {};
+    return document ?? null;
+  }
+  if (identifier) {
+    return store._instanceCache.getDocument(identifier);
+  }
+
+  // if we don't have an identifier, we give the document
+  // its own local cache
+  return new ReactiveDocument(store, null, {
+    request,
+    document
+  });
+}
+function updateCacheForSuccess(store, request, options, document) {
+  let response = null;
+  if (isMutation(request)) {
+    const record = request.data?.record || request.records?.[0];
+    if (record) {
+      response = store.cache.didCommit(record, document);
+
+      // a mutation combined with a 204 has no cache impact when no known records were involved
+      // a createRecord with a 201 with an empty response and no known records should similarly
+      // have no cache impact
+    } else if (isCacheAffecting(document)) {
+      response = store.cache.put(document);
+    }
+  } else {
+    response = store.cache.put(document);
+  }
+  return maybeUpdateUiObjects(store, request, options, response);
+}
+function handleFetchSuccess(store, context, options, document) {
+  const {
+    request
+  } = context;
+  store.requestManager._pending.delete(context.id);
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForSuccess(store, request, options, document);
+  });
+  store._enableAsyncFlush = null;
+  if (store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    return response;
+  } else {
+    store.notifications._flush();
+  }
+}
+function updateCacheForError(store, context, options, error) {
+  let response;
+  if (isMutation(context.request)) {
+    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+    // currently we let the response remain undefiend.
+    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+    const record = context.request.data?.record || context.request.records?.[0];
+    store.cache.commitWasRejected(record, errors);
+  } else {
+    response = store.cache.put(error);
+    return maybeUpdateUiObjects(store, context.request, options, response);
+  }
+}
+function handleFetchError(store, context, options, error) {
+  store.requestManager._pending.delete(context.id);
+  if (context.request.signal?.aborted) {
+    throw error;
+  }
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForError(store, context, options, error);
+  });
+  store._enableAsyncFlush = null;
+  if (options.identifier && store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, error.response, options.identifier, store);
+  }
+  if (isMutation(context.request)) {
+    throw error;
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    const newError = cloneError(error);
+    newError.content = response;
+    throw newError;
+  } else {
+    store.notifications._flush();
+  }
+}
+function fetchContentAndHydrate(next, context, identifier, priority) {
+  const {
+    store
+  } = context.request;
+  const shouldHydrate = context.request[EnableHydration] || false;
+  const options = {
+    shouldHydrate,
+    identifier,
+    priority
+  };
+  let isMut = false;
+  if (isMutation(context.request)) {
+    isMut = true;
+    // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
+    const record = context.request.data?.record || context.request.records?.[0];
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected to receive a list of records included in the ${context.request.op} request`);
+      }
+    })(record || !shouldHydrate) : {};
+    if (record) {
+      store.cache.willCommit(record, context);
+    }
+  }
+  if (store.lifetimes?.willRequest) {
+    store.lifetimes.willRequest(context.request, identifier, store);
+  }
+  const promise = next(context.request).then(document => {
+    return handleFetchSuccess(store, context, options, document);
+  }, error => {
+    return handleFetchError(store, context, options, error);
+  });
+  if (!isMut) {
+    return promise;
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a mutation`);
+    }
+  })(isMutation(context.request)) : {};
+
+  // for mutations we need to enqueue the promise with the requestStateService
+  // TODO should we enque a request per record in records?
+  const record = context.request.data?.record || context.request.records?.[0];
+  return store._requestCache._enqueue(promise, {
+    data: [{
+      op: 'saveRecord',
+      recordIdentifier: record,
+      options: undefined
+    }]
+  });
+}
+export { CacheHandler as C };

package/dist/index.js

@@ -1,20 +1,12 @@
-import { setLogging, getRuntimeConfig } from "./types/runtime.js";
-import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-DE5sFezZ.js";
-import { macroCondition, getGlobalConfig, importSync } from '@embroider/macros';
-import { peekUniversalTransient, setUniversalTransient } from "./types/-private.js";
-
-/**
- * A basic Fetch Handler which converts a request into a
- * `fetch` call presuming the response to be `json`.
- *
- * ```ts
- * import Fetch from '@ember-data/request/fetch';
- *
- * manager.use([Fetch]);
- * ```
- *
- * @module
- */
+import { setLogging, getRuntimeConfig } from './types/runtime.js';
+import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-COmAnXUQ.js";
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+import { w as waitFor } from "./configure-B48bFHOl.js";
+import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
+export { S as Store, r as recordIdentifierFor, N as setIdentifierForgetMethod, K as setIdentifierGenerationMethod, O as setIdentifierResetMethod, L as setIdentifierUpdateMethod, P as setKeyInfoForResource, s as storeFor } from "./request-state-CjLph1LP.js";
+export { C as CacheHandler } from "./handler-C2T-IyJK.js";
+import '@ember/debug';
+import './utils/string.js';
 
 // Lazily close over fetch to avoid breaking Mirage
 const _fetch = typeof fetch !== 'undefined' ? (...args) => fetch(...args) : typeof FastBoot !== 'undefined' ? (...args) => FastBoot.require('node-fetch')(...args) : () => {
@@ -35,16 +27,20 @@ const MUTATION_OPS = new Set(['updateRecord', 'createRecord', 'deleteRecord']);
 const ERROR_STATUS_CODE_FOR = new Map([[400, 'Bad Request'], [401, 'Unauthorized'], [402, 'Payment Required'], [403, 'Forbidden'], [404, 'Not Found'], [405, 'Method Not Allowed'], [406, 'Not Acceptable'], [407, 'Proxy Authentication Required'], [408, 'Request Timeout'], [409, 'Conflict'], [410, 'Gone'], [411, 'Length Required'], [412, 'Precondition Failed'], [413, 'Payload Too Large'], [414, 'URI Too Long'], [415, 'Unsupported Media Type'], [416, 'Range Not Satisfiable'], [417, 'Expectation Failed'], [419, 'Page Expired'], [420, 'Enhance Your Calm'], [421, 'Misdirected Request'], [422, 'Unprocessable Entity'], [423, 'Locked'], [424, 'Failed Dependency'], [425, 'Too Early'], [426, 'Upgrade Required'], [428, 'Precondition Required'], [429, 'Too Many Requests'], [430, 'Request Header Fields Too Large'], [431, 'Request Header Fields Too Large'], [450, 'Blocked By Windows Parental Controls'], [451, 'Unavailable For Legal Reasons'], [500, 'Internal Server Error'], [501, 'Not Implemented'], [502, 'Bad Gateway'], [503, 'Service Unavailable'], [504, 'Gateway Timeout'], [505, 'HTTP Version Not Supported'], [506, 'Variant Also Negotiates'], [507, 'Insufficient Storage'], [508, 'Loop Detected'], [509, 'Bandwidth Limit Exceeded'], [510, 'Not Extended'], [511, 'Network Authentication Required']]);
 
 /**
- * A basic handler which converts a request into a
+ * ```ts
+ * import { Fetch } from '@warp-drive/core';
+ * ```
+ *
+ * A basic Fetch Handler which converts a request into a
  * `fetch` call presuming the response to be `json`.
  *
  * ```ts
- * import Fetch from '@ember-data/request/fetch';
+ * import { RequestManager, Fetch } from '@warp-drive/core';
  *
- * manager.use([Fetch]);
+ * const manager = new RequestManager()
+ *   .use([Fetch]);
  * ```
  *
- * @class Fetch
  * @public
  */
 const Fetch = {
@@ -187,84 +183,9 @@ const Fetch = {
 function isDict(v) {
   return v !== null && typeof v === 'object';
 }
-
-/**
- * ```js
- * import RequestManager from '@ember-data/request';
- * ```
- *
- * A RequestManager provides a request/response flow in which configured
- * handlers are successively given the opportunity to handle, modify, or
- * pass-along a request.
- *
- * ```ts
- * interface RequestManager {
- *   request<T>(req: RequestInfo): Future<T>;
- * }
- * ```
- *
- * For example:
- *
- * ```ts
- * import RequestManager from '@ember-data/request';
- * import Fetch from '@ember-data/request/fetch';
- * import Auth from 'ember-simple-auth/ember-data-handler';
- * import Config from './config';
- *
- * const { apiUrl } = Config;
- *
- * // ... create manager
- * const manager = new RequestManager().use([Auth, Fetch]);
- *
- * // ... execute a request
- * const response = await manager.request({
- *   url: `${apiUrl}/users`
- * });
- * ```
- *
- * ### Futures
- *
- * The return value of `manager.request` is a `Future`, which allows
- * access to limited information about the request while it is still
- * pending and fulfills with the final state when the request completes.
- *
- * A `Future` is cancellable via `abort`.
- *
- * Handlers may optionally expose a `ReadableStream` to the `Future` for
- * streaming data; however, when doing so the future should not resolve
- * until the response stream is fully read.
- *
- * ```ts
- * interface Future<T> extends Promise<StructuredDocument<T>> {
- *   abort(): void;
- *
- *   async getStream(): ReadableStream | null;
- * }
- * ```
- *
- * ### StructuredDocuments
- *
- * A Future resolves with a `StructuredDataDocument` or rejects with a `StructuredErrorDocument`.
- *
- * ```ts
- * interface StructuredDataDocument<T> {
- *   request: ImmutableRequestInfo;
- *   response: ImmutableResponseInfo;
- *   content: T;
- * }
- * interface StructuredErrorDocument extends Error {
- *   request: ImmutableRequestInfo;
- *   response: ImmutableResponseInfo;
- *   error: string | object;
- * }
- * type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
- * ```
- *
- * @class RequestManager
- * @public
- */
 class RequestManager {
   #handlers = [];
+  /** @internal */
 
   /**
    * A map of pending requests from request.id to their
@@ -275,6 +196,8 @@ class RequestManager {
    * @internal
    */
 
+  /** @internal */
+
   constructor(options) {
     Object.assign(this, options);
     this._pending = new Map();
@@ -289,8 +212,6 @@ class RequestManager {
    * registers itself as a Cache handler.
    *
    * @public
-   * @param {Handler[]} cacheHandler
-   * @return {ThisType}
    */
   useCache(cacheHandler) {
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
@@ -328,7 +249,7 @@ class RequestManager {
         throw new Error(`\`RequestManager.use(<Handler[]>)\` expects an array of handlers, but was called with \`${typeof newHandlers}\``);
       }
       newHandlers.forEach((handler, index) => {
-        if (!handler || typeof handler !== 'object' || typeof handler.request !== 'function') {
+        if (!handler || typeof handler !== 'function' && typeof handler !== 'object' || typeof handler.request !== 'function') {
           throw new Error(`\`RequestManager.use(<Handler[]>)\` expected to receive an array of handler objects with request methods, by the handler at index ${index} does not conform.`);
         }
       });
@@ -375,10 +296,7 @@ class RequestManager {
     const cacheResult = getRequestResult(requestId);
     if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
       if (!request.disableTestWaiter) {
-        const {
-          waitForPromise
-        } = importSync('@ember/test-waiters');
-        const newPromise = waitForPromise(promise);
+        const newPromise = waitFor(promise);
         const finalPromise = upgradePromise(newPromise.then(result => {
           setPromiseResult(finalPromise, {
             isError: false,
@@ -427,11 +345,26 @@ class RequestManager {
     }
     return finalPromise;
   }
+
+  /**
+   * This method exists so that the RequestManager can be created
+   * can be created by container/factory systems that expect to
+   * call a static `create` method to instantiate the class.
+   *
+   * Using `new RequestManager()` directly is preferred.
+   *
+   * @private
+   */
   static create(options) {
     return new this(options);
   }
 }
 
+/**
+ * @module
+ * @mergeModuleWith <project>
+ */
+
 // @ts-expect-error adding to globalThis
 globalThis.setWarpDriveLogging = setLogging;
 

package/dist/reactive/-private.js

@@ -0,0 +1 @@
+export { E as Editable, L as Legacy } from "../symbols-SIstXMLI.js";