@warp-drive/utilities 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/active-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-record.js","names":["recordIdentifierFor","buildBaseURL","pluralize","underscore","copyForwardUrlOptions","macroCondition","getGlobalConfig","isExisting","identifier","id","type","deleteRecord","record","options","WarpDrive","env","DEBUG","test","Error","urlOptions","op","resourcePath","url","headers","Headers","append","method","data","records","createRecord","updateRecord","patch"],"sources":["../src/-private/active-record/find-record.ts","../src/-private/active-record/query.ts","../src/-private/active-record/save-record.ts"],"sourcesContent":["import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type {\n  FindRecordOptions,\n  FindRecordRequestOptions,\n  RemotelyAccessibleIdentifier,\n} from '@warp-drive/core/types/request';\n\nimport { buildBaseURL, buildQueryParams, type FindRecordUrlOptions } from '../../index.ts';\nimport { pluralize, underscore } from '../../string.ts';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to fetch a single resource by a known id or identifier\n * configured for the url and header expectations of most ActiveRecord APIs.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const data = await store.request(findRecord('person', '1'));\n * ```\n *\n * **With Options**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **With an Identifier**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });\n * const data = await store.request(options);\n * ```\n *\n * @public\n * @param identifier\n * @param options\n */\nexport function findRecord<T>(\n  identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T>, T>;\nexport function findRecord(\n  identifier: RemotelyAccessibleIdentifier,\n  options?: FindRecordOptions\n): FindRecordRequestOptions;\nexport function findRecord<T>(\n  type: TypeFromInstance<T>,\n  id: string,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T>, T>;\nexport function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;\nexport function findRecord(\n  arg1: string | RemotelyAccessibleIdentifier,\n  arg2: string | FindRecordOptions | undefined,\n  arg3?: FindRecordOptions\n): FindRecordRequestOptions {\n  const identifier: RemotelyAccessibleIdentifier = typeof arg1 === 'string' ? { type: arg1, id: arg2 as string } : arg1;\n  const options = ((typeof arg1 === 'string' ? arg3 : arg2) || {}) as FindRecordOptions;\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: FindRecordUrlOptions = {\n    identifier,\n    op: 'findRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url: options.include?.length\n      ? `${url}?${buildQueryParams({ include: options.include }, options.urlParamsSettings)}`\n      : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'findRecord',\n    records: [identifier],\n  };\n}\n\n/** @deprecated use {@link ReactiveDataDocument} instead */\nexport type FindRecordResultDocument<T> = ReactiveDataDocument<T>;\n","import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { QueryParamsSource } from '@warp-drive/core/types/params';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { ConstrainedRequestOptions, QueryRequestOptions } from '@warp-drive/core/types/request';\n\nimport { buildBaseURL, buildQueryParams, type QueryUrlOptions } from '../../index.ts';\nimport { pluralize, underscore } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to query for resources, usually by a primary\n * type, configured for the url and header expectations of most ActiveRecord APIs.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const data = await store.request(query('person'));\n * ```\n *\n * **With Query Params**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const options = query('person', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });\n * const data = await store.request(options);\n * ```\n *\n * @public\n * @param identifier\n * @param query\n * @param options\n */\nexport function query<T>(\n  type: TypeFromInstance<T>,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions<ReactiveDataDocument<T[]>>;\nexport function query(\n  type: string,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions;\nexport function query(\n  type: string,\n  // oxlint-disable-next-line no-shadow\n  query: QueryParamsSource = {},\n  options: ConstrainedRequestOptions = {}\n): QueryRequestOptions {\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: QueryUrlOptions = {\n    identifier: { type },\n    op: 'query',\n    resourcePath: pluralize(underscore(type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n  const queryString = buildQueryParams(query, options.urlParamsSettings);\n\n  return {\n    url: queryString ? `${url}?${queryString}` : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'query',\n  };\n}\n","import { recordIdentifierFor } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { TypedRecordInstance } from '@warp-drive/core/types/record';\nimport type {\n  ConstrainedRequestOptions,\n  CreateRequestOptions,\n  DeleteRequestOptions,\n  UpdateRequestOptions,\n} from '@warp-drive/core/types/request';\n\nimport {\n  buildBaseURL,\n  type CreateRecordUrlOptions,\n  type DeleteRecordUrlOptions,\n  type UpdateRecordUrlOptions,\n} from '../../index.ts';\nimport { pluralize, underscore } from '../../string';\nimport { copyForwardUrlOptions } from '../builder-utils.ts';\n\nfunction isExisting(identifier: ResourceKey): identifier is PersistedResourceKey {\n  return 'id' in identifier && identifier.id !== null && 'type' in identifier && identifier.type !== null;\n}\n\n/**\n * Builds request options to delete record for resources,\n * configured for the url, method and header expectations of ActiveRecord APIs.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const data = await store.request(deleteRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const options = deleteRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @public\n * @param record\n * @param options\n */\nexport function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;\nexport function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;\nexport function deleteRecord(record: unknown, options: ConstrainedRequestOptions = {}): DeleteRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot delete a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: DeleteRecordUrlOptions = {\n    identifier: identifier,\n    op: 'deleteRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'DELETE',\n    headers,\n    op: 'deleteRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to create new record for resources,\n * configured for the url, method and header expectations of most ActiveRecord APIs.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const data = await store.request(createRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const options = createRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @public\n * @param record\n * @param options\n */\nexport function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;\nexport function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;\nexport function createRecord(record: unknown, options: ConstrainedRequestOptions = {}): CreateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n\n  const urlOptions: CreateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'createRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'POST',\n    headers,\n    op: 'createRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to update existing record for resources,\n * configured for the url, method and header expectations of most ActiveRecord APIs.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const data = await store.request(updateRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const options = updateRecord(person, { patch: true });\n * const data = await store.request(options);\n * ```\n *\n * @public\n * @param record\n * @param options\n */\nexport function updateRecord<T extends TypedRecordInstance, RT extends TypedRecordInstance = T>(\n  record: T,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions<ReactiveDataDocument<RT>, T>;\nexport function updateRecord(\n  record: unknown,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions;\nexport function updateRecord(\n  record: unknown,\n  options: ConstrainedRequestOptions & { patch?: boolean } = {}\n): UpdateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot update a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: UpdateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'updateRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: options.patch ? 'PATCH' : 'PUT',\n    headers,\n    op: 'updateRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n"],"mappings":"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"}

package/dist/builder-utils-BkXwUT0x.js

@@ -0,0 +1,16 @@
+//#region src/-private/builder-utils.ts
+function copyForwardUrlOptions(urlOptions, options) {
+	if ("host" in options) urlOptions.host = options.host;
+	if ("namespace" in options) urlOptions.namespace = options.namespace;
+	if ("resourcePath" in options) urlOptions.resourcePath = options.resourcePath;
+}
+function extractCacheOptions(options) {
+	const cacheOptions = {};
+	if ("reload" in options) cacheOptions.reload = options.reload;
+	if ("backgroundReload" in options) cacheOptions.backgroundReload = options.backgroundReload;
+	return cacheOptions;
+}
+
+//#endregion
+export { extractCacheOptions as n, copyForwardUrlOptions as t };
+//# sourceMappingURL=builder-utils-BkXwUT0x.js.map

package/dist/builder-utils-BkXwUT0x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-utils-BkXwUT0x.js","names":[],"sources":["../src/-private/builder-utils.ts"],"sourcesContent":["import type { CacheOptions, ConstrainedRequestOptions } from '@warp-drive/core/types/request';\n\nimport type { UrlOptions } from '../index.ts';\n\nexport function copyForwardUrlOptions(urlOptions: UrlOptions, options: ConstrainedRequestOptions): void {\n  if ('host' in options) {\n    urlOptions.host = options.host;\n  }\n  if ('namespace' in options) {\n    urlOptions.namespace = options.namespace;\n  }\n  if ('resourcePath' in options) {\n    urlOptions.resourcePath = options.resourcePath;\n  }\n}\n\nexport function extractCacheOptions(options: ConstrainedRequestOptions): CacheOptions {\n  const cacheOptions: CacheOptions = {};\n  if ('reload' in options) {\n    cacheOptions.reload = options.reload;\n  }\n  if ('backgroundReload' in options) {\n    cacheOptions.backgroundReload = options.backgroundReload;\n  }\n  return cacheOptions;\n}\n"],"mappings":";AAIA,SAAgB,sBAAsB,YAAwB,SAA0C;CACtG,IAAI,UAAU,SACZ,WAAW,OAAO,QAAQ;CAE5B,IAAI,eAAe,SACjB,WAAW,YAAY,QAAQ;CAEjC,IAAI,kBAAkB,SACpB,WAAW,eAAe,QAAQ;AAEtC;AAEA,SAAgB,oBAAoB,SAAkD;CACpF,MAAM,eAA6B,CAAC;CACpC,IAAI,YAAY,SACd,aAAa,SAAS,QAAQ;CAEhC,IAAI,sBAAsB,SACxB,aAAa,mBAAmB,QAAQ;CAE1C,OAAO;AACT"}

package/dist/derivations.d.ts

@@ -0,0 +1,30 @@
+import { Type } from "@warp-drive/core/types/symbols";
+import { ReactiveResource } from "@warp-drive/core/reactive";
+//#region src/derivations.d.ts
+interface ConcatDerivation {
+  (record: ReactiveResource & {
+    [key: string]: unknown;
+  }, options: Record<string, unknown> | null, _prop: string): string;
+  [Type]: "concat";
+}
+/**
+ * A derivation for use by {@link ReactiveResource} that joins the given fields
+ * with the optional separator (or '' if no separator is provided).
+ *
+ * Generally you should not need to import and use this function directly.
+ *
+ * @example
+ * {
+ *   name: 'fullName',
+ *   kind: 'derived',
+ *   type: 'concat',
+ *   options: {
+ *     fields: ['firstName', 'lastName'],
+ *     separator: ' ',
+ *   },
+ * }
+ */
+declare const concat: ConcatDerivation;
+//#endregion
+export { concat };
+//# sourceMappingURL=derivations.d.ts.map

package/dist/derivations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivations.d.ts","names":[],"sources":["../src/derivations.ts"],"mappings":";;;UAGU;GAEN,QAAQ;;KACR,SAAS,gCACT;GAED;;;;;;;;;;;;;;;;;;;cAoBU,QAAQ"}

package/dist/derivations.js

@@ -1,30 +1,30 @@
-import { Type } from '@warp-drive/core/types/symbols';
+import { Type } from "@warp-drive/core/types/symbols";
 
+//#region src/derivations.ts
 /**
- * A derivation for use by {@link ReactiveResource} that joins the given fields
- * with the optional separator (or '' if no separator is provided).
- *
- * Generally you should not need to import and use this function directly.
- *
- * @example
- * {
- *   name: 'fullName',
- *   kind: 'derived',
- *   type: 'concat',
- *   options: {
- *     fields: ['firstName', 'lastName'],
- *     separator: ' ',
- *   },
- * }
- */
+* A derivation for use by {@link ReactiveResource} that joins the given fields
+* with the optional separator (or '' if no separator is provided).
+*
+* Generally you should not need to import and use this function directly.
+*
+* @example
+* {
+*   name: 'fullName',
+*   kind: 'derived',
+*   type: 'concat',
+*   options: {
+*     fields: ['firstName', 'lastName'],
+*     separator: ' ',
+*   },
+* }
+*/
 const concat = (record, options, _prop) => {
-  if (!options) {
-    throw new Error(`options is required`);
-  }
-  // SAFETY: we cast internally to a more specific type, for our own use
-  // SAFETY: but provide the more general signature to the schema service
-  const opts = options;
-  return opts.fields.map(field => record[field]).join(opts.separator ?? '');
+	if (!options) throw new Error(`options is required`);
+	const opts = options;
+	return opts.fields.map((field) => record[field]).join(opts.separator ?? "");
 };
-concat[Type] = 'concat';
-export { concat };
+concat[Type] = "concat";
+
+//#endregion
+export { concat };
+//# sourceMappingURL=derivations.js.map

package/dist/derivations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivations.js","names":["Type","concat","record","options","_prop","Error","opts","fields","map","field","join","separator"],"sources":["../src/derivations.ts"],"sourcesContent":["import type { ReactiveResource } from '@warp-drive/core/reactive';\nimport { Type } from '@warp-drive/core/types/symbols';\n\ninterface ConcatDerivation {\n  (\n    record: ReactiveResource & { [key: string]: unknown },\n    options: Record<string, unknown> | null,\n    _prop: string\n  ): string;\n  [Type]: 'concat';\n}\n\n/**\n * A derivation for use by {@link ReactiveResource} that joins the given fields\n * with the optional separator (or '' if no separator is provided).\n *\n * Generally you should not need to import and use this function directly.\n *\n * @example\n * {\n *   name: 'fullName',\n *   kind: 'derived',\n *   type: 'concat',\n *   options: {\n *     fields: ['firstName', 'lastName'],\n *     separator: ' ',\n *   },\n * }\n */\nexport const concat: ConcatDerivation = (\n  record: ReactiveResource & { [key: string]: unknown },\n  options: Record<string, unknown> | null,\n  _prop: string\n) => {\n  if (!options) {\n    throw new Error(`options is required`);\n  }\n  // SAFETY: we cast internally to a more specific type, for our own use\n  // SAFETY: but provide the more general signature to the schema service\n  const opts = options as { fields: string[]; separator?: string };\n  return opts.fields.map((field) => record[field]).join(opts.separator ?? '');\n};\nconcat[Type] = 'concat';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,MAAaC,UACXC,QACAC,SACAC,UACG;CACH,IAAI,CAACD,SACH,MAAM,IAAIE,MAAM,qBAAqB;CAIvC,MAAMC,OAAOH;CACb,OAAOG,KAAKC,OAAOC,KAAKC,UAAUP,OAAOO,MAAM,CAAC,CAACC,KAAKJ,KAAKK,aAAa,EAAE;AAC5E;AACAV,OAAOD,QAAQ"}

package/dist/handlers.d.ts

@@ -0,0 +1,283 @@
+import { RequestContext, StructuredDataDocument } from "@warp-drive/core/types/request";
+import { Future, Handler, NextFn } from "@warp-drive/core/request";
+//#region src/-private/handlers/auto-compress.d.ts
+/**
+ * Whether the browser supports `ReadableStream` as a request body
+ * in a `POST` request.
+ *
+ * @group Constants
+ */
+declare const SupportsRequestStreams: boolean;
+interface Constraints {
+  /**
+   * The minimum size at which to compress blobs
+   *
+   * @default 1000
+   */
+  Blob?: number;
+  /**
+   * The minimum size at which to compress array buffers
+   *
+   * @default 1000
+   */
+  ArrayBuffer?: number;
+  /**
+   * The minimum size at which to compress typed arrays
+   *
+   * @default 1000
+   */
+  TypedArray?: number;
+  /**
+   * The minimum size at which to compress data views
+   *
+   * @default 1000
+   */
+  DataView?: number;
+  /**
+   * The minimum size at which to compress strings
+   *
+   * @default 1000
+   */
+  String?: number;
+}
+/**
+ * Options for configuring the AutoCompress handler.
+ *
+ */
+interface CompressionOptions {
+  /**
+   * The compression format to use. Must be a valid
+   * compression format supported by [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+   *
+   * The default is `gzip`.
+   *
+   */
+  format?: CompressionFormat;
+  /**
+   * Some browsers support `ReadableStream` as a request body. This option
+   * enables passing the compression stream as the request body instead of
+   * the final compressed body when the browser supports doing so.
+   *
+   * This comes with several caveats:
+   *
+   * - the request will be put into `duplex: 'half'` mode. This should be
+   *   transparent to you, but it is worth noting.
+   * - the request mode cannot be `no-cors` as requests with a `ReadableStream`
+   *   have no content length and thus are a new form of request that triggers
+   *   cors requirements and a preflight request.
+   * - http/1.x is not supported.
+   *
+   * For additional reading about the restrictions of using `ReadableStream`
+   * as a request body, see the [Chromium Documentation](https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#restrictions)
+   *
+   * Streaming can be enabled per-request in browsers which support it by
+   * setting `request.options.allowStreaming` to `true`.
+   *
+   * Streaming can be forced even when the browser does not support it by setting
+   * `request.options.forceStreaming` to `true`. This is useful if later handlers
+   * in the chain can handle the request body as a stream.
+   *
+   * @default false
+   */
+  allowStreaming?: boolean;
+  /**
+   * If `true`, the request will be forced into streaming mode even
+   * if the browser does not support it. This is useful if later handlers
+   * in the chain can handle the request body as a stream.
+   *
+   * @default false
+   */
+  forceStreaming?: boolean;
+  /**
+   * The constraints for the request body. This is used to determine
+   * whether to compress the request body or not.
+   *
+   * The defaults are:
+   *
+   * ```ts
+   * {
+   *   Blob: 1000, // blob.size
+   *   ArrayBuffer: 1000, // buffer.byteLength
+   *   TypedArray: 1000, // array.byteLength
+   *   DataView: 1000, // view.byteLength
+   *   String: 1000, // string.length
+   * }
+   * ```
+   *
+   * The following body types are never compressed unless explicitly
+   * configured by the request:
+   * - `FormData`
+   * - `URLSearchParams`
+   * - `ReadableStream`
+   *
+   * A request.options.compress value of `false` will disable
+   * compression for a request body of any type. While a value of
+   * `true` will enable compression for the request.
+   *
+   * An undefined value will use the default, a value of `0` will
+   * enable compression for all values, and a value of `-1` will
+   * disable compression.
+   *
+   */
+  constraints?: Constraints;
+}
+/**
+ * A request handler that automatically compresses the request body
+ * if the request body is a string, array buffer, blob, or form data.
+ *
+ * This uses the [CompressionStream API](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+ *
+ * The compression format as well as the kinds of data to compress can be
+ * configured using the `format` and `constraints` options.
+ *
+ * ```diff
+ * +import { AutoCompress } from '@ember-data/request-utils/handlers';
+ * import Fetch from '@ember-data/request/fetch';
+ * import RequestManager from '@ember-data/request';
+ * import Store from '@ember-data/store';
+ *
+ * class AppStore extends Store {
+ *   requestManager = new RequestManager()
+ *     .use([
+ * +       new AutoCompress(),
+ *        Fetch
+ *     ]);
+ * }
+ * ```
+ *
+ * @group Handlers
+ * @public
+ * @since 5.5.0
+ */
+declare class AutoCompress implements Handler {
+  /**
+   * The resolved options this handler was configured with, with all
+   * defaults (including `constraints` defaults) applied.
+   */
+  options: Required<CompressionOptions> & {
+    /**
+     * The resolved size constraints used to decide whether to compress a given request body.
+     */
+    constraints: Required<Constraints>;
+  };
+  constructor(options?: CompressionOptions);
+  request<T>({ request }: RequestContext, next: NextFn<T>): Promise<T> | Future<T>;
+}
+//#endregion
+//#region src/-private/handlers/gated.d.ts
+/**
+ * If CheckFn returns true, the wrapped handler will be used.
+ * If CheckFn returns false, the wrapped handler will be skipped.
+ */
+type CheckFn = (context: RequestContext) => boolean;
+/**
+ *
+ * @group Handlers
+ * @public
+ */
+declare class Gate implements Handler {
+  /**
+   * The wrapped handler to invoke when {@link Gate.checkFn | checkFn} returns `true`.
+   */
+  handler: Handler;
+  /**
+   * The predicate used to decide whether {@link Gate.handler | handler} should run for a given request.
+   */
+  checkFn: CheckFn;
+  constructor(handler: Handler, checkFn: CheckFn);
+  request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T>;
+}
+//#endregion
+//#region src/-private/handlers/meta-doc.d.ts
+/**
+ * MetaDocHandler processes requests that are marked as meta requests.
+ *
+ * It treats the response body as "entirely meta" transforming
+ *
+ * ```ts
+ * {
+ *   some: "key",
+ *   another: "thing"
+ * }
+ * ```
+ *
+ * into
+ *
+ * ```ts
+ * {
+ * 	 meta: {
+ *     some: "key",
+ *     another: "thing"
+ *   }
+ * }
+ * ```
+ *
+ * To activate this handler, a request should specify
+ *
+ * ```ts
+ * options.isMetaRequest = true
+ * ```
+ *
+ * For instance
+ *
+ * ```ts
+ * store.request({
+ *   url: '/example',
+ *   options: {
+ *     isMetaRequest: true
+ *   }
+ * });
+ * ```
+ *
+ * Errors are not processed by this handler, so if the request fails and the error response
+ * is not in {json:api} format additional processing may be needed.
+ *
+ * @group Handlers
+ */
+declare const MetaDocHandler: Handler;
+//#endregion
+//#region src/-private/handlers/utils.d.ts
+/**
+ * A unique identifier for the current browser tab
+ * useful for observability/tracing and deduping
+ * across multiple tabs.
+ *
+ * @group Constants
+ */
+declare const TAB_ID: string;
+/**
+ * The epoch seconds at which the tab id was generated
+ *
+ * @group Constants
+ */
+declare const TAB_ASSIGNED: number;
+/**
+ * Adds the `X-Amzn-Trace-Id` header to support observability
+ * tooling around request routing.
+ *
+ * This makes use of the {@link TAB_ID} and {@link TAB_ASSIGNED}
+ * to enable tracking the browser tab of origin across multiple requests.
+ *
+ * Follows the template: `Root=1-${now}-${uuidv4};TabId=1-${epochSeconds}-${tab-uuid}`
+ *
+ * @group Utility Functions
+ */
+declare function addTraceHeader(headers: Headers): Headers;
+/**
+ * Source: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html
+ * As of 2024-12-05 the maximum URL length is 8192 bytes.
+ *
+ * @group Constants
+ */
+declare const MAX_URL_LENGTH = 8192;
+/**
+ * This assertion takes a URL and throws an error if the URL is longer than the maximum URL length.
+ *
+ * See also {@link MAX_URL_LENGTH}
+ *
+ * @group Utility Functions
+ */
+declare function assertInvalidUrlLength(url: string | undefined): void;
+//#endregion
+export { AutoCompress, Gate, MAX_URL_LENGTH, MetaDocHandler, SupportsRequestStreams, TAB_ASSIGNED, TAB_ID, addTraceHeader, assertInvalidUrlLength };
+//# sourceMappingURL=handlers.d.ts.map

package/dist/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","names":[],"sources":["../src/-private/handlers/auto-compress.ts","../src/-private/handlers/gated.ts","../src/-private/handlers/meta-doc.ts","../src/-private/handlers/utils.ts"],"mappings":";;;;;;;;;cAca;UAgBH;;;;;;EAMR;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA;;;;;;UAOQ;;;;;;;;EAQR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BT;;;;;;;;EASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCH,wBAAwB;;;;;EAKnC,SAAiB,SAAS;;;;IAIxB,aAAa,SAAS;;EAGxB,YAAY,UAAS;EAUrB,QAAQ,KAAK,WAAW,gBAAgB,MAAM,OAAO,KAAK,QAAQ,KAAK,OAAO;;;;;;;;KCxM3E,WAAW,SAAS;;;;;;cAOZ,gBAAgB;;;;EAI3B,SAAiB;;;;EAIjB,SAAiB;EAEjB,YAAY,SAAS,SAAS,SAAS;EAKvC,QAAQ,aAAa,SAAS,gBAAgB,MAAM,OAAO,KAAK,QAAQ,IAAI,uBAAuB,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCoBrG,gBAAgB;;;;;;;;;;cCdhB;;;;;;cAMA;;;;;;;;;;;;iBAaG,eAAe,SAAS,UAAU;;;;;;;cAarC;;;;;;;;iBASG,uBAAuB"}