@equinor/fusion-framework-module-http 8.1.0-next.0 → 8.1.1

package/src/lib/client/types.ts

@@ -1,244 +0,0 @@
-import type { ObservableInput, Observable } from 'rxjs';
-import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators/types';
-
-/**
- * Represents a stream of response data.
- * @template T - The type of the response data.
- */
-export type StreamResponse<T> = Observable<T>;
-
-/**
- * A function that takes a `Response` object and returns an `ObservableInput` of type `T`.
- *
- * @template TResult - The type of the data contained in the response.
- * @template TResponse - The type of the response object.
- * @param response - The `Response` object to be processed.
- * @returns An `ObservableInput` of type `T`.
- */
-export type ResponseSelector<TResult = unknown, TResponse = Response> = (
-  response: TResponse,
-) => ObservableInput<TResult>;
-
-/**
- * Represents the parameters for a fetch request, including the URI and path.
- * @property {string} uri - The URI of the request.
- * @property {string} path - The path of the request.
- */
-export type FetchRequest = RequestInit & {
-  uri: string;
-  path: string;
-};
-
-/**
- * Represents a request with a JSON body.
- * @template TRequest - The base request type, which extends `FetchRequest`.
- * @property {object | string | null} [body] - The request body, which can be an object, a string, or null.
- */
-export type JsonRequest<TRequest extends FetchRequest = FetchRequest> = Omit<TRequest, 'body'> & {
-  body?: object | string | null;
-};
-
-/**
- * Represents the result of a blob operation, including the filename (if available) and the blob itself.
- * @property {string} [filename] - The filename of the blob, if available.
- * @property {Blob} blob - The blob data.
- */
-export type BlobResult = { filename?: string; blob: Blob };
-
-/**
- * Represents the response from a fetch request, including the response object and a JSON parsing method.
- * @template T - The type of the response data.
- * @property {Response} - The original Response object.
- * @property {() => Promise<T>} json - A method to parse the response body as JSON and return the data as type T.
- */
-export type FetchResponse<T = unknown> = Response & {
-  json(): Promise<T>;
-};
-
-/**
- * Represents the parameters for a fetch request, including the URI and path, as well as a selector function to transform the response.
- * @template TReturn - The type of the transformed response data.
- * @template TRequest - The type of the fetch request.
- * @template TResponse - The type of the fetch response.
- */
-export type FetchRequestInit<
-  TReturn = unknown,
-  TRequest = FetchRequest,
-  TResponse = FetchResponse<TReturn>,
-> = Omit<TRequest, 'uri' | 'path'> & {
-  /** response selector function */
-  selector?: ResponseSelector<TReturn, TResponse>;
-};
-
-/**
- * Represents the parameters for a fetch request, including the URI and path, as well as a selector function to transform the response.
- *
- * @template TReturn - The type of the transformed response data.
- * @template TRequest - The type of the fetch request.
- * @template TResponse - The type of the fetch response.
- */
-export type ClientRequestInit<T extends IHttpClient, TReturn = unknown> =
-  T extends IHttpClient<infer TRequest, infer TResponse>
-    ? FetchRequestInit<TReturn, TRequest, TResponse>
-    : never;
-
-/**
- * Represents the available execution methods for an HTTP client.
- */
-export type ExecutionMethod = 'fetch' | 'fetch$' | 'json' | 'json$';
-
-/**
- * Represents the type of the parameters for the execution methods of an `IHttpClient` instance.
- *
- * @template TMethod - The execution method of the `IHttpClient` instance, e.g. 'fetch', 'json'.
- * @template TClient - The type of the `IHttpClient` instance.
- */
-export type ExecutionMethodParameters<
-  TMethod extends ExecutionMethod = 'fetch',
-  TClient extends IHttpClient = IHttpClient,
-> = Parameters<TClient[TMethod]>;
-
-/**
- * Represents the type of the return value for the execution methods of an `IHttpClient` instance.
- *
- * @template TMethod - The execution method of the `IHttpClient` instance, e.g. 'fetch', 'json'.
- * @template TClient - The type of the `IHttpClient` instance.
- */
-export type ExecutionResponse<
-  TMethod extends ExecutionMethod = 'fetch',
-  TClient extends IHttpClient = IHttpClient,
-> = ReturnType<TClient[TMethod]>;
-
-/**
- * @template TRequest request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/request|request}
- * @template TResponse request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/response|response}
- */
-export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response> {
-  uri: string;
-  /**
-   * A pre-processor for requests made by the `IHttpClient` interface.
-   * This handler can be used to modify the request before it is sent, such as adding headers, authentication, or other transformations.
-   */
-  readonly requestHandler: IHttpRequestHandler<TRequest>;
-
-  /**
-   * A post-processor for responses received by the `IHttpClient` interface.
-   * This handler can be used to transform the response data after it is received, such as parsing JSON, handling errors, or other transformations.
-   */
-  readonly responseHandler: IHttpResponseHandler<TResponse>;
-
-  /**
-   * Observable stream of requests made by the `IHttpClient` interface.
-   * This stream can be used to observe and potentially modify the requests before they are sent.
-   */
-  readonly request$: Observable<TRequest>;
-
-  /**
-   * Observable stream of responses received by the `IHttpClient` interface.
-   * This stream can be used to observe and potentially handle the responses after they are received.
-   */
-  readonly response$: Observable<TResponse>;
-
-  /**
-   * Fetch a resource as an observable stream.
-   * This method simplifies the execution of a request and returns an observable stream of the response.
-   * The request will not be executed until the observable is subscribed to.
-   *
-   * @template T - The expected response type.
-   * @param path - The path to fetch the resource from.
-   * @param init - Optional request initialization options.
-   * @returns An observable stream of the response.
-   *
-   * @see {@link https://rxjs.dev/api/fetch/fromFetch|RxJS fromFetch}
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch|fetch}
-   */
-  fetch$<T = TResponse>(
-    path: string,
-    init?: FetchRequestInit<T, TRequest, TResponse>,
-  ): StreamResponse<T>;
-
-  /**
-   * Fetch a resource as a promise.
-   *
-   * @template T - The expected response type.
-   * @param path - The path to fetch the resource from.
-   * @param init - Optional request initialization options.
-   * @returns A promise that resolves to the fetched resource.
-   *
-   * @see {@link IHttpClient.fetch$}
-   */
-  fetch<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
-
-  /** @deprecated use {@link IHttpClient.fetch} */
-  fetchAsync<T = TResponse>(
-    path: string,
-    args?: FetchRequestInit<T, TRequest, TResponse>,
-  ): Promise<T>;
-
-  /**
-   * Fetches a resource as an observable stream.
-   * This method simplifies the execution of a request and returns an observable stream of the response.
-   * The request will not be executed until the observable is subscribed to.
-   *
-   * @template T - The expected response type.
-   * @param path - The path to fetch the resource from.
-   * @param init - Optional request initialization options, including the request body, headers, and response type.
-   * @returns An observable stream of the fetched resource.
-   *
-   * @see {@link IHttpClient.fetch$}
-   */
-  json$<T = unknown>(
-    path: string,
-    init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-  ): StreamResponse<T>;
-
-  /**
-   * Fetches a resource as a promise and returns the response as a JSON object.
-   *
-   * @template T - The expected response type.
-   * @param path - The path to fetch the resource from.
-   * @param init - Optional request initialization options, including the request body, headers, and response type.
-   * @returns A promise that resolves to the fetched resource as a JSON object.
-   *
-   * @see {@link IHttpClient.fetch} for fetching resources as an observable stream.
-   */
-  json<T = unknown>(
-    path: string,
-    init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-  ): Promise<T>;
-
-  /** @deprecated */
-  jsonAsync<T = unknown>(
-    path: string,
-    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-  ): Promise<T>;
-
-  /**
-   * Fetches a blob resource from the specified path and returns a Promise that resolves to the fetched blob data.
-   *
-   * @param path - The path to fetch the blob from.
-   * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
-   * @returns A Promise that resolves to the fetched blob data.
-   */
-  blob<T = BlobResult>(
-    path: string,
-    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-  ): Promise<T>;
-
-  /**
-   * Fetches a blob from the specified path and returns a stream response.
-   *
-   * @param path - The path to fetch the blob from.
-   * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
-   * @returns A stream response containing the fetched blob.
-   */
-  blob$<T = BlobResult>(
-    path: string,
-    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-  ): StreamResponse<T>;
-
-  /**
-   * Abort all ongoing requests for the current client.
-   */
-  abort(): void;
-}

package/src/lib/index.ts

@@ -1,3 +0,0 @@
-export * from './client';
-export * from './operators';
-export * from './selectors';

package/src/lib/operators/HttpMiddlewareHandler.ts

@@ -1,58 +0,0 @@
-import { firstValueFrom, from, of } from 'rxjs';
-import type { Observable, ObservableInput } from 'rxjs';
-
-import type { HttpMiddleware, HttpMiddlewareNext, IHttpMiddlewareHandler } from './types';
-
-/**
- * Normalizes a step's result to a `Promise`, so a middleware calling `next(...)` never has to
- * branch on whether the next step short-circuited with a plain `Response` or reached all the
- * way to an Observable-returning network call.
- */
-function toPromise(result: Response | ObservableInput<Response>): Promise<Response> {
-  return result instanceof Response ? Promise.resolve(result) : firstValueFrom(from(result));
-}
-
-/**
- * Composes registered {@link HttpMiddleware} into a single execution pipeline wrapping the
- * network call, so retries, caching, telemetry, or circuit-breaking can wrap `_performFetch`
- * without touching request or response payload transforms.
- *
- * @see {@link HttpClient}
- */
-export class HttpMiddlewareHandler implements IHttpMiddlewareHandler {
-  #middleware: HttpMiddleware[];
-
-  /**
-   * Constructs a handler, optionally cloning another handler's registered middleware.
-   * @param source - An existing handler to clone the registered middleware from.
-   */
-  constructor(source?: IHttpMiddlewareHandler) {
-    this.#middleware = source ? [...source.middleware] : [];
-  }
-
-  /** @inheritdoc */
-  get middleware(): readonly HttpMiddleware[] {
-    return this.#middleware;
-  }
-
-  /** @inheritdoc */
-  use(middleware: HttpMiddleware): HttpMiddlewareHandler {
-    this.#middleware.push(middleware);
-    return this;
-  }
-
-  /** @inheritdoc */
-  process(uri: string, init: RequestInit, terminal: HttpMiddlewareNext): Observable<Response> {
-    // wrap outward-in so the first-registered middleware is outermost, matching a conventional middleware chain
-    const chain = this.#middleware.reduceRight<HttpMiddlewareNext>(
-      (next, middleware) => (nextUri, nextInit) =>
-        middleware(nextUri, nextInit, (u, i) => toPromise(next(u, i))),
-      terminal,
-    );
-    const result = chain(uri, init);
-    // a middleware may short-circuit with a plain Response (no ObservableInput wrapping needed)
-    return result instanceof Response ? of(result) : from(result);
-  }
-}
-
-export default HttpMiddlewareHandler;

package/src/lib/operators/HttpRequestHandler.ts

@@ -1,29 +0,0 @@
-import { ProcessOperators } from './ProcessOperators';
-import { requestOperatorHeader } from './request-operator-header';
-
-import type { FetchRequest } from '../client';
-
-/**
- * Extends the `ProcessOperators` class to handle HTTP requests.
- *
- * This class provides a method to set a header that will apply to all requests made by the `HttpClient`.
- *
- * @see {@link ProcessOperators}
- *
- * @template T - The type of the fetch request, which extends `FetchRequest`.
- */
-export class HttpRequestHandler<T extends FetchRequest = FetchRequest> extends ProcessOperators<T> {
-  /**
-   * Sets a header that will apply to all requests made by the `HttpClient`.
-   *
-   * @param key - The name of the header to set.
-   * @param value - The value of the header to set.
-   * @returns The current `HttpRequestHandler` instance, allowing for method chaining.
-   */
-  setHeader(key: string, value: string): HttpRequestHandler<T> {
-    const operator = requestOperatorHeader<T>(key, value);
-    return this.set(`header-${key}`, operator) as HttpRequestHandler<T>;
-  }
-}
-
-export default HttpRequestHandler;

package/src/lib/operators/HttpResponseHandler.ts

@@ -1,11 +0,0 @@
-import { ProcessOperators } from './ProcessOperators';
-
-/**
- * The `HttpResponseHandler` class extends the `ProcessOperators` class and is responsible for handling HTTP responses.
- * It provides a common interface for processing HTTP responses, allowing for consistent error handling and response transformation.
- *
- * @template T - The type of the HTTP response. Defaults to `Response`.
- */
-export class HttpResponseHandler<T = Response> extends ProcessOperators<T> {}
-
-export default HttpResponseHandler;

package/src/lib/operators/ProcessOperators.ts

@@ -1,113 +0,0 @@
-import { from, of } from 'rxjs';
-import type { Observable } from 'rxjs';
-import { last, mergeScan } from 'rxjs/operators';
-import type { IProcessOperators, ProcessOperator } from './types';
-
-/**
- * ProcessOperators class manages a collection of process operators
- * and provides methods to add, set, get, and process these operators.
- * It implements the IProcessOperators interface for type T.
- *
- * @template T The type of data that the process operators work with
- */
-export class ProcessOperators<T> implements IProcessOperators<T> {
-  /**
-   * A record of process operators keyed by a string.
-   * This property is used to store and manage the collection of process operators
-   * that are used by the `ProcessOperators` class.
-   */
-  protected _operators: Record<string, ProcessOperator<T>>;
-
-  /**
-   * Accessor for the collection of process operators.
-   * @returns The record of process operators.
-   */
-  get operators(): Record<string, ProcessOperator<T>> {
-    return this._operators;
-  }
-
-  /**
-   * Constructs a new instance of the ProcessOperators class.
-   * @param operators - An optional object containing process operators.
-   *                    It can be either an instance of IProcessOperators<T> or a record of string keys and ProcessOperator<T> values.
-   */
-  constructor(operators?: IProcessOperators<T> | Record<string, ProcessOperator<T>>) {
-    // accept either a raw operators record or another IProcessOperators instance to clone from
-    if (operators && 'operators' in operators) {
-      this._operators = { ...operators.operators };
-    } else {
-      this._operators = operators ?? {};
-    }
-  }
-
-  /**
-   * Adds a new operator to the collection.
-   * @param key The key under which the operator is stored.
-   * @param operator The operator to be added.
-   * @returns The instance of ProcessOperators for chaining.
-   * @throws Error if an operator with the same key already exists.
-   */
-  add(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
-    // guard against silently overwriting an existing operator under the same key
-    if (Object.keys(this._operators).includes(key))
-      throw Error(`Operator [${key}] already defined`);
-    return this.set(key, operator);
-  }
-
-  /**
-   * Sets or updates an operator in the collection.
-   * @param key The key under which the operator is stored.
-   * @param operator The operator to be set.
-   * @returns The instance of ProcessOperators for chaining.
-   */
-  set(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
-    this._operators[key] = operator;
-    return this;
-  }
-
-  /**
-   * Removes an operator from the collection by its key.
-   *
-   * @param key - The key of the operator to remove.
-   * @returns The current instance of `ProcessOperators` for method chaining.
-   */
-  remove(key: string): ProcessOperators<T> {
-    delete this._operators[key];
-    return this;
-  }
-
-  /**
-   * Retrieves an operator from the collection by its key.
-   * @param key The key of the operator to retrieve.
-   * @returns The retrieved operator.
-   */
-  get(key: string): ProcessOperator<T> {
-    return this._operators[key];
-  }
-
-  /**
-   * Processes an input request through the chain of operators.
-   * @param request The request to be processed.
-   * @returns An Observable of the processed request.
-   */
-  process(request: T): Observable<T> {
-    const operators = Object.values(this._operators);
-    /** if no operators registered, just return the observable value */
-    if (!operators.length) {
-      return of(request);
-    }
-    // feed the request through each operator sequentially, keeping the previous value when one returns void
-    return from(Object.values(this._operators)).pipe(
-      mergeScan(
-        // resolve current operator and return result or previous if void
-        (value, operator) => Promise.resolve(operator(value)).then((x) => x ?? value),
-        // initial value
-        request,
-        // only allow concurrency of one operator
-        1,
-      ),
-      // output result of last operator
-      last(),
-    );
-  }
-}

package/src/lib/operators/capitalize-request-method-operator.ts

@@ -1,26 +0,0 @@
-import { requestMethodCasing } from './fetch-request.schemas';
-import type { ProcessOperator } from './types';
-
-/**
- * Ensures that the HTTP method of the given request is in uppercase.
- *
- * @param request - The HTTP request object to process.
- * @returns A new request object with the HTTP method in uppercase.
- */
-export const capitalizeRequestMethodOperator =
-  <T extends RequestInit>(options?: { silent?: boolean }): ProcessOperator<T> =>
-  (request): T => {
-    const { error, success, data } = requestMethodCasing().safeParse(request.method);
-
-    request.method = success ? data : request.method?.toUpperCase();
-
-    // surface schema validation issues as warnings when not running silently
-    if (error && !options?.silent) {
-      // one warning per issue so callers can see exactly what failed to validate
-      for (const e of error.issues) {
-        console.warn(e.message);
-      }
-    }
-
-    return request;
-  };

package/src/lib/operators/fetch-request.schemas.ts

@@ -1,104 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Validates that the provided HTTP method string is in uppercase.
- *
- * @link https://www.rfc-editor.org/rfc/rfc7231#section-4.1
- */
-export const requestMethodCasing = (): z.ZodType<string | undefined> => {
-  return z
-    .string()
-    .optional()
-    .refine((value) => value === undefined || value === value?.toUpperCase(), {
-      message: [
-        'Provided HTTP method must be in uppercase.',
-        'See RFC 7231 Section 4.1 for more information',
-        'https://www.rfc-editor.org/rfc/rfc7231#section-4.1',
-      ].join(' '),
-    });
-};
-
-/**
- * Creates a Zod enum schema for HTTP request methods.
- *
- * The schema validates that the value is one of the standard HTTP methods:
- * 'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE'.
- *
- * If the validation fails, a custom error message is returned, indicating the
- * expected methods and the received value. The error message also references
- * RFC 2616 for more information.
- *
- * @link https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html
- */
-export const requestMethodVerb = () => {
-  return z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE'], {
-    message:
-      'Invalid request method. Expected one of: GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD, CONNECT, TRACE. See RFC 2615 Section 9 for more information: https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html',
-  });
-};
-
-export const requestMethod = () => requestMethodVerb().optional();
-
-/**
- * Schema for validating the initialization options of a request.
- *
- * @link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request
- *
- * This schema is used to ensure that the request options conform to the expected structure and types.
- */
-export const requestInitSchema = z.object({
-  attributionReporting: z
-    .object({
-      eventSourceEligible: z.boolean().optional(),
-      triggerEligible: z.boolean().optional(),
-    })
-    .optional(),
-  body: z
-    .union([
-      z.string(),
-      z.instanceof(Blob),
-      z.instanceof(ArrayBuffer),
-      z.instanceof(FormData),
-      z.instanceof(URLSearchParams),
-      z.instanceof(ReadableStream),
-    ])
-    .optional(),
-  browsingTopics: z.boolean().optional(),
-  cache: z
-    .enum(['default', 'no-store', 'reload', 'no-cache', 'force-cache', 'only-if-cached'])
-    .optional(),
-  credentials: z.enum(['omit', 'same-origin', 'include']).optional(),
-  headers: z.record(z.string(), z.string()).optional().or(z.instanceof(Headers)),
-  integrity: z.string().optional(),
-  keepalive: z.boolean().optional(),
-  method: requestMethod().optional(),
-  mode: z.enum(['same-origin', 'cors', 'no-cors', 'navigate', 'websocket']).optional(),
-  priority: z.enum(['low', 'high', 'auto']).optional(),
-  redirect: z.enum(['follow', 'error', 'manual']).optional(),
-  referrer: z.string().optional(),
-  referrerPolicy: z
-    .enum([
-      'no-referrer',
-      'no-referrer-when-downgrade',
-      'origin',
-      'origin-when-cross-origin',
-      'same-origin',
-      'strict-origin',
-      'strict-origin-when-cross-origin',
-      'unsafe-url',
-    ])
-    .optional(),
-  signal: z.instanceof(AbortSignal).optional(),
-});
-
-/**
- * Schema for validating fetch request configurations.
- *
- * This schema extends the `requestInitSchema` and adds additional properties:
- * - `uri`: A required string representing the URI of the request.
- * - `path`: An optional string representing the path of the request.
- */
-export const fetchRequestSchema = requestInitSchema.extend({
-  uri: z.string(),
-  path: z.string().optional(),
-});

package/src/lib/operators/index.ts

@@ -1,9 +0,0 @@
-export { HttpRequestHandler } from './HttpRequestHandler';
-export { HttpResponseHandler } from './HttpResponseHandler';
-export { HttpMiddlewareHandler } from './HttpMiddlewareHandler';
-export { ProcessOperators } from './ProcessOperators';
-export { capitalizeRequestMethodOperator } from './capitalize-request-method-operator';
-export { requestValidationOperator } from './request-validation-operator';
-export { sseMap } from './sse-map.operator';
-
-export * from './types';

package/src/lib/operators/request-operator-header.ts

@@ -1,19 +0,0 @@
-import type { FetchRequest } from '../client';
-import type { ProcessOperator } from './types';
-
-/**
- * Creates a process operator that adds a header to the request.
- *
- * @param key - The header key to add.
- * @param value - The header value to add.
- * @returns A process operator that adds the specified header to the request.
- */
-export const requestOperatorHeader =
-  <T extends FetchRequest = FetchRequest>(key: string, value: string): ProcessOperator<T> =>
-  (request) => {
-    const headers = new Headers(request.headers);
-    headers.append(key, value);
-    return { ...request, headers };
-  };
-
-export default requestOperatorHeader;

package/src/lib/operators/request-validation-operator.ts

@@ -1,51 +0,0 @@
-import type { z } from 'zod';
-import type { ProcessOperator } from './types';
-import type { FetchRequest } from '../client/types';
-import { fetchRequestSchema } from './fetch-request.schemas';
-
-/**
- * Validates the given request using the `requestInitSchema`.
- *
- * By default, the validation is not strict, meaning that additional properties
- * not defined in the schema will be allowed and passed through without causing validation errors.
- * Also the operator will not modify the request object, it will only log an error message if the validation fails.
- *
- * @link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request
- *
- * @param request - The request object to be validated.
- * @returns The validated request object if validation is successful.
- * @throws Will log an error message if the request validation fails.
- */
-export const requestValidationOperator =
-  <T extends FetchRequest>(options?: {
-    /**
-     * When enabled, the function will return the parsed result.
-     * This means that if the request object passes validation,
-     * the parsed and potentially transformed request object will be returned.
-     * If this option is not enabled, the function will not return anything
-     * even if the request object is valid.
-     */
-    parse?: boolean;
-    /**
-     * When set to true, the validation will be strict, meaning that any additional properties
-     * not defined in the schema will cause the validation to fail. If set to false or omitted,
-     * additional properties will be allowed and passed through without causing validation errors.
-     *
-     * @remarks this option is only applicable when the `parse` option is enabled.
-     */
-    strict?: boolean;
-  }): ProcessOperator<T> =>
-  (request) => {
-    const { strict, parse } = options ?? {};
-    const schema = strict ? fetchRequestSchema : fetchRequestSchema.passthrough();
-    try {
-      const result = schema.parse(request) as T;
-      return parse ? result : void 0;
-    } catch (error) {
-      // re-throw so callers relying on `parse` can react to validation failures directly
-      if (parse) {
-        throw error;
-      }
-      console.error('Invalid request options', (error as z.ZodError).message);
-    }
-  };