@warp-drive/core 5.8.0-alpha.4 → 5.8.0-alpha.40

package/dist/unpkg/prod/hooks-BfiqDg3O.js

@@ -0,0 +1,26 @@
+import { R as ReactiveResource } from "./promise-state-ipG60SdD.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 };

package/dist/unpkg/prod/index.js

@@ -0,0 +1,481 @@
+import { r as registerDerivations, S as SchemaService } from "./promise-state-ipG60SdD.js";
+export { e as cacheKeyFor, e as recordIdentifierFor, j as setIdentifierForgetMethod, h as setIdentifierGenerationMethod, k as setIdentifierResetMethod, i as setIdentifierUpdateMethod, l as setKeyInfoForResource, s as storeFor } from "./promise-state-ipG60SdD.js";
+import { i as instantiateRecord, t as teardownRecord } from "./hooks-BfiqDg3O.js";
+import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
+import { S as Store, C as CacheHandler } from "./handler-LAyD1Y5l.js";
+import { c as cloneResponseProperties, I as IS_CACHE_HANDLER, e as executeNextHandler, g as getRequestResult, u as upgradePromise, s as setPromiseResult, a as clearRequestResult } from "./request-CN2LxbYX.js";
+import { EnableHydration } from './types/request.js';
+import { DefaultCachePolicy } from './store.js';
+import './types/runtime.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) : () => {
+  throw new Error('No Fetch Implementation Found');
+};
+
+// clones a response in a way that should still
+// allow it to stream
+function cloneResponse(response, overrides) {
+  const props = cloneResponseProperties(response);
+  return new Response(response.body, Object.assign(props, overrides));
+}
+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']]);
+
+/**
+ * ```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 { RequestManager, Fetch } from '@warp-drive/core';
+ *
+ * const manager = new RequestManager()
+ *   .use([Fetch]);
+ * ```
+ *
+ * @public
+ */
+const Fetch = {
+  async request(context) {
+    let response;
+    try {
+      ({});
+      response = await _fetch(context.request.url, context.request);
+    } catch (e) {
+      if (e instanceof DOMException && e.name === 'AbortError') {
+        e.statusText = 'Aborted';
+        e.status = 20;
+        e.isRequestError = true;
+      } else {
+        e.statusText = 'Unknown Network Error';
+        e.status = 0;
+        if (!(e instanceof DOMException)) {
+          e.code = 0;
+        }
+        e.isRequestError = true;
+      }
+      throw e;
+    }
+    const isError = !response.ok || response.status >= 400;
+    const op = context.request.op;
+    const isMutationOp = Boolean(op && MUTATION_OPS.has(op));
+    if (!isError && !isMutationOp && response.status !== 204 && !response.headers.has('date')) {
+      {
+        const headers = new Headers(response.headers);
+        headers.set('date', new Date().toUTCString());
+        response = cloneResponse(response, {
+          headers
+        });
+      }
+    }
+    context.setResponse(response);
+    if (response.status === 204) {
+      return null;
+    }
+    let text = '';
+    // if we are in a mirage context, we cannot support streaming
+    {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let isStreaming = context.hasRequestedStream;
+      let stream = isStreaming ? new TransformStream() : null;
+      let writer = stream?.writable.getWriter();
+      if (isStreaming) {
+        // Listen for the abort event on the AbortSignal
+        context.request.signal?.addEventListener('abort', () => {
+          if (!isStreaming) {
+            return;
+          }
+          void stream.writable.abort('Request Aborted');
+          void stream.readable.cancel('Request Aborted');
+        });
+        context.setStream(stream.readable);
+      }
+      while (true) {
+        // we manually read the stream instead of using `response.json()`
+        // or `response.text()` because if we need to stream the body
+        // we need to be able to pass the stream along efficiently.
+        const {
+          done,
+          value
+        } = await reader.read();
+        if (done) {
+          if (isStreaming) {
+            isStreaming = false;
+            await writer.ready;
+            await writer.close();
+          }
+          break;
+        }
+        text += decoder.decode(value, {
+          stream: true
+        });
+
+        // if we are streaming, we want to pass the stream along
+        if (isStreaming) {
+          await writer.ready;
+          await writer.write(value);
+        } else if (context.hasRequestedStream) {
+          const encode = new TextEncoder();
+          isStreaming = true;
+          stream = new TransformStream();
+          // Listen for the abort event on the AbortSignal
+          // eslint-disable-next-line @typescript-eslint/no-loop-func
+          context.request.signal?.addEventListener('abort', () => {
+            if (!isStreaming) {
+              return;
+            }
+            void stream.writable.abort('Request Aborted');
+            void stream.readable.cancel('Request Aborted');
+          });
+          context.setStream(stream.readable);
+          writer = stream.writable.getWriter();
+          await writer.ready;
+          await writer.write(encode.encode(text));
+          await writer.ready;
+          await writer.write(value);
+        }
+      }
+      if (isStreaming) {
+        isStreaming = false;
+        await writer.ready;
+        await writer.close();
+      }
+    }
+    // if we are an error, we will want to throw
+    if (isError) {
+      let errorPayload;
+      try {
+        errorPayload = JSON.parse(text);
+      } catch {
+        // void;
+      }
+      // attempt errors discovery
+      const errors = Array.isArray(errorPayload) ? errorPayload : isDict(errorPayload) && Array.isArray(errorPayload.errors) ? errorPayload.errors : null;
+      const statusText = response.statusText || ERROR_STATUS_CODE_FOR.get(response.status) || 'Unknown Request Error';
+      const msg = `[${response.status} ${statusText}] ${context.request.method ?? 'GET'} (${response.type}) - ${response.url}`;
+      const error = errors ? new AggregateError(errors, msg) : new Error(msg);
+      error.status = response.status;
+      error.statusText = statusText;
+      error.isRequestError = true;
+      error.code = error.status;
+      error.name = error.statusText.replaceAll(' ', '') + 'Error';
+      error.content = errorPayload;
+      throw error;
+    } else {
+      return JSON.parse(text);
+    }
+  }
+};
+function isDict(v) {
+  return v !== null && typeof v === 'object';
+}
+
+/**
+ * ## Import
+ *
+ * ```js
+ * import { RequestManager } from '@warp-drive/core';
+ * ```
+ *
+ * For complete usage guide see the [RequestManager Documentation](/guides/).
+ *
+ * ## How It Works
+ *
+ * ```ts
+ * interface RequestManager {
+ *   request<T>(req: RequestInfo): Future<T>;
+ * }
+ * ```
+ *
+ * A RequestManager provides a request/response flow in which configured
+ * handlers are successively given the opportunity to handle, modify, or
+ * pass-along a request.
+ *
+ * <img src="/images/handlers-all-labeled.gif" alt="RequestManager Flow Animation" width="100%" />
+ *
+ * For example:
+ *
+ * ::: code-group
+ *
+ * ```ts [Setup.ts]
+ * import { RequestManager, Fetch } from '@warp-drive/core';
+ * import { AutoCompress } from '@warp-drive/utilities/handlers';
+ * import Auth from 'ember-simple-auth/handler';
+ *
+ * // ... create manager
+ * const manager = new RequestManager()
+ *    .use([Auth, new AutoCompress(), Fetch]); // [!code focus]
+ * ```
+ *
+ * ```ts [Usage.ts]
+ * import Config from './config';
+ *
+ * const { apiUrl } = Config;
+ *
+ * // ... 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;
+ * ```
+ *
+ * @public
+ */
+class RequestManager {
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * A map of pending requests from request.id to their
+   * associated CacheHandler promise.
+   *
+   * This queue is managed by the CacheHandler
+   *
+   * @internal
+   */
+
+  /** @internal */
+
+  constructor(options) {
+    Object.assign(this, options);
+    this._pending = new Map();
+    this._deduped = new Map();
+    this._handlers = [];
+  }
+
+  /**
+   * Register a handler to use for primary cache intercept.
+   *
+   * Only one such handler may exist. If using the same
+   * RequestManager as the Store instance the Store
+   * registers itself as a Cache handler.
+   *
+   * @public
+   */
+  useCache(cacheHandler) {
+    cacheHandler[IS_CACHE_HANDLER] = true;
+    this._handlers.unshift(cacheHandler);
+    return this;
+  }
+
+  /**
+   * Register handler(s) to use when a request is issued.
+   *
+   * Handlers will be invoked in the order they are registered.
+   * Each Handler is given the opportunity to handle the request,
+   * curry the request, or pass along a modified request.
+   *
+   * @public
+   */
+  use(newHandlers) {
+    const handlers = this._handlers;
+    handlers.push(...newHandlers);
+    return this;
+  }
+
+  /**
+   * Issue a Request.
+   *
+   * Returns a Future that fulfills with a StructuredDocument
+   *
+   * @public
+   */
+  request(request) {
+    const handlers = this._handlers;
+    const controller = request.controller || new AbortController();
+    if (request.controller) {
+      delete request.controller;
+    }
+    const requestId = peekUniversalTransient('REQ_ID') ?? 0;
+    setUniversalTransient('REQ_ID', requestId + 1);
+    const context = {
+      controller,
+      response: null,
+      stream: null,
+      hasRequestedStream: false,
+      id: requestId,
+      identifier: null,
+      requester: request[EnableHydration] && request.store ? request.store : this
+    };
+    const promise = executeNextHandler(handlers, request, 0, context);
+
+    // the cache handler will set the result of the request synchronously
+    // if it is able to fulfill the request from the cache
+    const cacheResult = getRequestResult(requestId);
+    // const promise1 = store.request(myRequest);
+    // const promise2 = store.request(myRequest);
+    // promise1 === promise2; // false
+    // either we need to make promise1 === promise2, or we need to make sure that
+    // we need to have a way to key from request to result
+    // such that we can lookup the result here and return it if it exists
+    const finalPromise = upgradePromise(promise.then(result => {
+      setPromiseResult(finalPromise, {
+        isError: false,
+        result
+      });
+      clearRequestResult(requestId);
+      return result;
+    }, error => {
+      setPromiseResult(finalPromise, {
+        isError: true,
+        result: error
+      });
+      clearRequestResult(requestId);
+      throw error;
+    }), promise);
+    if (cacheResult) {
+      setPromiseResult(finalPromise, cacheResult);
+    }
+    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);
+  }
+}
+
+/**
+ * This type exists for internal use only for
+ * where intimate contracts still exist either for
+ * the Test Suite or for Legacy code.
+ *
+ * @private
+ */
+
+/**
+ * @module
+ * @mergeModuleWith <project>
+ */
+
+/**
+ * Options for setting up a Store instance with `useRecommendedStore`.
+ */
+
+/**
+ * Creates a configured Store class with recommended defaults
+ * for schema handling, reactivity, caching, and request management.
+ *
+ * ```ts
+ * import { useRecommendedStore } from '@warp-drive/core';
+ * import { JSONAPICache } from '@warp-drive/json-api';
+ *
+ * export const Store = useRecommendedStore({
+ *   cache: JSONAPICache,
+ *   schemas: [],
+ * });
+ * ```
+ */
+function useRecommendedStore(options, StoreKlass = Store) {
+  return class AppStore extends StoreKlass {
+    requestManager = new RequestManager().use([...(options.handlers ?? []), Fetch]).useCache(CacheHandler);
+    lifetimes = options.policy ?? new DefaultCachePolicy({
+      apiCacheHardExpires: 15 * 60 * 1000,
+      // 15 minutes
+      apiCacheSoftExpires: 1 * 30 * 1000,
+      // 30 seconds
+      constraints: {
+        headers: {
+          'X-WarpDrive-Expires': true,
+          'Cache-Control': true,
+          Expires: true
+        }
+      }
+    });
+    createSchemaService() {
+      const schema = new SchemaService();
+      registerDerivations(schema);
+      if (options.schemas) schema.registerResources(options.schemas);
+      if (options.traits) {
+        for (const trait of options.traits) {
+          schema.registerTrait(trait);
+        }
+      }
+      if (options.derivations) {
+        for (const derivation of options.derivations) {
+          schema.registerDerivation(derivation);
+        }
+      }
+      if (options.transformations) {
+        for (const transformation of options.transformations) {
+          schema.registerTransformation(transformation);
+        }
+      }
+      if (options.hashFns) {
+        for (const hashFn of options.hashFns) {
+          schema.registerHashFn(hashFn);
+        }
+      }
+      if (options.CAUTION_MEGA_DANGER_ZONE_extensions) {
+        for (const extension of options.CAUTION_MEGA_DANGER_ZONE_extensions) {
+          schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
+        }
+      }
+      return schema;
+    }
+    createCache(capabilities) {
+      // eslint-disable-next-line new-cap
+      return new options.cache(capabilities);
+    }
+    instantiateRecord(key, createArgs) {
+      return instantiateRecord(this, key, createArgs);
+    }
+    teardownRecord(record) {
+      return teardownRecord(record);
+    }
+  };
+}
+export { CacheHandler, Fetch, RequestManager, Store, useRecommendedStore };