@warp-drive/core 5.8.0-beta.0 → 5.8.0-beta.1

package/dist/unpkg/prod-deprecated/handler-CCIu4sQ3.js

@@ -0,0 +1,334 @@
+import { v as createReactiveDocument } from "./schema-CJcjHv0E.js";
+import { SkipCache, EnableHydration } from './types/request.js';
+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.cacheKeyManager.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', null);
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: true
+          },
+          promise
+        });
+        queueMicrotask(() => {
+          store.notifications.notify(identifier, 'state', null);
+        });
+      }
+      store.requestManager._pending.set(context.id, promise);
+      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', null);
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: false
+          },
+          promise
+        });
+        queueMicrotask(() => {
+          store.notifications.notify(identifier, 'state', null);
+        });
+      }
+      store.requestManager._pending.set(context.id, promise);
+    }
+    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) {
+    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 createReactiveDocument(store, null, {
+    request,
+    document
+  });
+}
+function updateCacheForSuccess(store, request, options, document) {
+  let response = null;
+  if (isMutation(request)) {
+    if (Array.isArray(request.records)) {
+      response = store.cache.didCommit(request.records, document);
+    } else if (request.data?.record) {
+      // legacy fallback, the data option should no longer be used for this
+      response = store.cache.didCommit(request.data.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;
+    if (Array.isArray(context.request.records)) {
+      store.cache.commitWasRejected(context.request.records, errors);
+    } else if (context.request.data?.record) {
+      // legacy fallback, the data option should no longer be used for this
+      store.cache.commitWasRejected(context.request.data.record, errors);
+    } else {
+      store.cache.put(error);
+    }
+  } 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;
+    if (Array.isArray(context.request.records)) {
+      context.request.records.forEach(record => {
+        store.cache.willCommit(record, context);
+      });
+    } else if (context.request.data?.record) {
+      // legacy fallback, the data option should no longer be used for this
+      store.cache.willCommit(context.request.data.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;
+  }
+
+  // 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/unpkg/prod-deprecated/hooks-Dv4Np0MY.js

@@ -0,0 +1,26 @@
+import { u as ReactiveResource } from "./schema-CJcjHv0E.js";
+import { D as Destroy } from "./-private-3C1OkYtZ.js";
+function instantiateRecord(store, identifier, createArgs) {
+  const schema = store.schema;
+  const resourceSchema = schema.resource(identifier);
+  const legacy = resourceSchema?.legacy ?? false;
+  const editable = legacy;
+  const record = new ReactiveResource({
+    store,
+    resourceKey: identifier,
+    modeName: legacy ? 'legacy' : 'polaris',
+    legacy: legacy,
+    editable: editable,
+    path: null,
+    field: null,
+    value: null
+  });
+  if (createArgs && editable) {
+    Object.assign(record, createArgs);
+  }
+  return record;
+}
+function teardownRecord(record) {
+  record[Destroy]();
+}
+export { instantiateRecord as i, teardownRecord as t };