@warp-drive-mirror/core 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/unpkg/prod/index.js

@@ -1,483 +1,3 @@
-import { r as registerDerivations, S as SchemaService } from "./schema-BSkHyoWz.js";
-export { a as cacheKeyFor, a as recordIdentifierFor, d as setIdentifierForgetMethod, b as setIdentifierGenerationMethod, e as setIdentifierResetMethod, c as setIdentifierUpdateMethod, f as setKeyInfoForResource, s as storeFor } from "./schema-BSkHyoWz.js";
-import { instantiateRecord, teardownRecord } from './reactive.js';
-import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
-import "./-leaked-DUONXQDB.js";
-import { c as cloneResponseProperties, I as IS_CACHE_HANDLER, e as executeNextHandler, u as upgradePromise } from "./request-BrJSCG6r.js";
-import { EnableHydration } from './types/request.js';
-import { g as getRequestResult, s as setPromiseResult, c as clearRequestResult } from "./promise-cache-DIT8Ypjq.js";
-import { DefaultCachePolicy } from './store.js';
-import { S as Store, C as CacheHandler } from "./handler-EU_8ncB2.js";
-import './types/runtime.js';
+import { D as setIdentifierUpdateMethod, E as setIdentifierResetMethod, I as storeFor, O as setKeyInfoForResource, P as recordIdentifierFor, T as setIdentifierGenerationMethod, _ as Store, g as CacheHandler, n as RequestManager, r as Fetch, t as useRecommendedStore, w as setIdentifierForgetMethod } from "./src-nFHlZgKa.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-mirror/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-mirror/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-mirror/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-mirror/core';
- * import { AutoCompress } from '@warp-drive-mirror/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-mirror/core';
- * import { JSONAPICache } from '@warp-drive-mirror/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 };
+export { CacheHandler, Fetch, RequestManager, Store, recordIdentifierFor as cacheKeyFor, recordIdentifierFor, setIdentifierForgetMethod, setIdentifierGenerationMethod, setIdentifierResetMethod, setIdentifierUpdateMethod, setKeyInfoForResource, storeFor, useRecommendedStore };

package/dist/unpkg/prod/reactive/-private.js

@@ -1 +1,3 @@
-export { C as Context } from "../-private-sql1_mdx.js";
+import { r as Context } from "../-private-B36B1ztP.js";
+
+export { Context };

package/dist/unpkg/prod/reactive.js

@@ -1,30 +1,5 @@
-import { v as ReactiveResource } from "./schema-BSkHyoWz.js";
-export { S as SchemaService, w as checkout, z as commit, y as fromIdentity, r as registerDerivations, x as withDefaults } from "./schema-BSkHyoWz.js";
-import { D as Destroy } from "./-private-sql1_mdx.js";
-export { a as Checkout } from "./-private-sql1_mdx.js";
-export { k as createRequestSubscription, m as getPromiseState, l as getRequestState } from "./-leaked-DUONXQDB.js";
-import './types/-private.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, teardownRecord };
+import { d as getRequestState, t as getPromiseState, u as createRequestSubscription } from "./-private-DHco-h0q.js";
+import { t as Checkout } from "./-private-B36B1ztP.js";
+import { a as fromIdentity, c as instantiateRecord, d as commit, i as SchemaService, l as teardownRecord, o as registerDerivations, s as withDefaults, u as checkout } from "./src-nFHlZgKa.js";
+
+export { Checkout, SchemaService, checkout, commit, createRequestSubscription, fromIdentity, getPromiseState, getRequestState, instantiateRecord, registerDerivations, teardownRecord, withDefaults };