@equinor/fusion-framework-module-http 6.1.0 → 6.2.0

package/dist/types/lib/operators/capitalize-request-method.operator.d.ts

@@ -0,0 +1,10 @@
+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 declare const capitalizeRequestMethodOperator: <T extends RequestInit>(options?: {
+    silent?: boolean;
+}) => ProcessOperator<T>;

package/dist/types/lib/operators/fetch-request.schema.d.ts

@@ -0,0 +1,170 @@
+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 declare const requestMethodCasing: () => z.ZodType<string>;
+/**
+ * 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 declare const requestMethodVerb: () => z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "CONNECT", "TRACE"]>;
+export declare const requestMethod: () => z.ZodPipeline<z.ZodType<string, z.ZodTypeDef, string>, z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "CONNECT", "TRACE"]>>;
+/**
+ * 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 declare const requestInitSchema: z.ZodObject<{
+    attributionReporting: z.ZodOptional<z.ZodObject<{
+        eventSourceEligible: z.ZodOptional<z.ZodBoolean>;
+        triggerEligible: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    }, {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    }>>;
+    body: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<Blob, z.ZodTypeDef, Blob>, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<FormData, z.ZodTypeDef, FormData>, z.ZodType<URLSearchParams, z.ZodTypeDef, URLSearchParams>, z.ZodType<ReadableStream<unknown>, z.ZodTypeDef, ReadableStream<unknown>>]>>;
+    browsingTopics: z.ZodOptional<z.ZodBoolean>;
+    cache: z.ZodOptional<z.ZodEnum<["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"]>>;
+    credentials: z.ZodOptional<z.ZodEnum<["omit", "same-origin", "include"]>>;
+    headers: z.ZodUnion<[z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodType<Headers, z.ZodTypeDef, Headers>]>;
+    integrity: z.ZodOptional<z.ZodString>;
+    keepalive: z.ZodOptional<z.ZodBoolean>;
+    method: z.ZodOptional<z.ZodPipeline<z.ZodType<string, z.ZodTypeDef, string>, z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "CONNECT", "TRACE"]>>>;
+    mode: z.ZodOptional<z.ZodEnum<["same-origin", "cors", "no-cors", "navigate", "websocket"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "high", "auto"]>>;
+    redirect: z.ZodOptional<z.ZodEnum<["follow", "error", "manual"]>>;
+    referrer: z.ZodOptional<z.ZodString>;
+    referrerPolicy: z.ZodOptional<z.ZodEnum<["no-referrer", "no-referrer-when-downgrade", "origin", "origin-when-cross-origin", "same-origin", "strict-origin", "strict-origin-when-cross-origin", "unsafe-url"]>>;
+    signal: z.ZodOptional<z.ZodType<AbortSignal, z.ZodTypeDef, AbortSignal>>;
+}, "strip", z.ZodTypeAny, {
+    body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    credentials?: "include" | "omit" | "same-origin" | undefined;
+    headers?: Headers | Record<string, string> | undefined;
+    integrity?: string | undefined;
+    keepalive?: boolean | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "CONNECT" | "TRACE" | undefined;
+    mode?: "cors" | "same-origin" | "navigate" | "no-cors" | "websocket" | undefined;
+    priority?: "auto" | "high" | "low" | undefined;
+    redirect?: "error" | "follow" | "manual" | undefined;
+    referrer?: string | undefined;
+    referrerPolicy?: "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+    signal?: AbortSignal | undefined;
+    attributionReporting?: {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    } | undefined;
+    browsingTopics?: boolean | undefined;
+}, {
+    body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    credentials?: "include" | "omit" | "same-origin" | undefined;
+    headers?: Headers | Record<string, string> | undefined;
+    integrity?: string | undefined;
+    keepalive?: boolean | undefined;
+    method?: string | undefined;
+    mode?: "cors" | "same-origin" | "navigate" | "no-cors" | "websocket" | undefined;
+    priority?: "auto" | "high" | "low" | undefined;
+    redirect?: "error" | "follow" | "manual" | undefined;
+    referrer?: string | undefined;
+    referrerPolicy?: "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+    signal?: AbortSignal | undefined;
+    attributionReporting?: {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    } | undefined;
+    browsingTopics?: boolean | undefined;
+}>;
+/**
+ * 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 declare const fetchRequestSchema: z.ZodObject<z.objectUtil.extendShape<{
+    attributionReporting: z.ZodOptional<z.ZodObject<{
+        eventSourceEligible: z.ZodOptional<z.ZodBoolean>;
+        triggerEligible: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    }, {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    }>>;
+    body: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<Blob, z.ZodTypeDef, Blob>, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>, z.ZodType<FormData, z.ZodTypeDef, FormData>, z.ZodType<URLSearchParams, z.ZodTypeDef, URLSearchParams>, z.ZodType<ReadableStream<unknown>, z.ZodTypeDef, ReadableStream<unknown>>]>>;
+    browsingTopics: z.ZodOptional<z.ZodBoolean>;
+    cache: z.ZodOptional<z.ZodEnum<["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"]>>;
+    credentials: z.ZodOptional<z.ZodEnum<["omit", "same-origin", "include"]>>;
+    headers: z.ZodUnion<[z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodType<Headers, z.ZodTypeDef, Headers>]>;
+    integrity: z.ZodOptional<z.ZodString>;
+    keepalive: z.ZodOptional<z.ZodBoolean>;
+    method: z.ZodOptional<z.ZodPipeline<z.ZodType<string, z.ZodTypeDef, string>, z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "CONNECT", "TRACE"]>>>;
+    mode: z.ZodOptional<z.ZodEnum<["same-origin", "cors", "no-cors", "navigate", "websocket"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "high", "auto"]>>;
+    redirect: z.ZodOptional<z.ZodEnum<["follow", "error", "manual"]>>;
+    referrer: z.ZodOptional<z.ZodString>;
+    referrerPolicy: z.ZodOptional<z.ZodEnum<["no-referrer", "no-referrer-when-downgrade", "origin", "origin-when-cross-origin", "same-origin", "strict-origin", "strict-origin-when-cross-origin", "unsafe-url"]>>;
+    signal: z.ZodOptional<z.ZodType<AbortSignal, z.ZodTypeDef, AbortSignal>>;
+}, {
+    uri: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    uri: string;
+    body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
+    path?: string | undefined;
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    credentials?: "include" | "omit" | "same-origin" | undefined;
+    headers?: Headers | Record<string, string> | undefined;
+    integrity?: string | undefined;
+    keepalive?: boolean | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "CONNECT" | "TRACE" | undefined;
+    mode?: "cors" | "same-origin" | "navigate" | "no-cors" | "websocket" | undefined;
+    priority?: "auto" | "high" | "low" | undefined;
+    redirect?: "error" | "follow" | "manual" | undefined;
+    referrer?: string | undefined;
+    referrerPolicy?: "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+    signal?: AbortSignal | undefined;
+    attributionReporting?: {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    } | undefined;
+    browsingTopics?: boolean | undefined;
+}, {
+    uri: string;
+    body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
+    path?: string | undefined;
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    credentials?: "include" | "omit" | "same-origin" | undefined;
+    headers?: Headers | Record<string, string> | undefined;
+    integrity?: string | undefined;
+    keepalive?: boolean | undefined;
+    method?: string | undefined;
+    mode?: "cors" | "same-origin" | "navigate" | "no-cors" | "websocket" | undefined;
+    priority?: "auto" | "high" | "low" | undefined;
+    redirect?: "error" | "follow" | "manual" | undefined;
+    referrer?: string | undefined;
+    referrerPolicy?: "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+    signal?: AbortSignal | undefined;
+    attributionReporting?: {
+        eventSourceEligible?: boolean | undefined;
+        triggerEligible?: boolean | undefined;
+    } | undefined;
+    browsingTopics?: boolean | undefined;
+}>;

package/dist/types/lib/operators/index.d.ts

@@ -1,4 +1,6 @@
 export { HttpRequestHandler } from './http-request-handler';
 export { HttpResponseHandler } from './http-response-handler';
 export { ProcessOperators } from './process-operators';
+export { capitalizeRequestMethodOperator } from './capitalize-request-method.operator';
+export { requestValidationOperator } from './request-validation.operator';
 export * from './types';

package/dist/types/lib/operators/process-operators.d.ts

@@ -40,6 +40,13 @@ export declare class ProcessOperators<T> implements IProcessOperators<T> {
      * @returns The instance of ProcessOperators for chaining.
      */
     set(key: string, operator: ProcessOperator<T>): ProcessOperators<T>;
+    /**
+     * 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>;
     /**
      * Retrieves an operator from the collection by its key.
      * @param key The key of the operator to retrieve.

package/dist/types/lib/operators/request-validation.operator.d.ts

@@ -0,0 +1,33 @@
+import type { ProcessOperator } from './types';
+import type { FetchRequest } from '../client/types';
+/**
+ * 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 declare 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.
+     *
+     * @note this option is only applicable when the `parse` option is enabled.
+     */
+    strict?: boolean;
+}) => ProcessOperator<T>;

package/dist/types/lib/operators/types.d.ts

@@ -35,6 +35,12 @@ export interface IProcessOperators<T> {
      * @returns The updated collection of process operators.
      */
     set(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
+    /**
+     * Removes a process operator from the collection.
+     * @param key The key of the operator to remove.
+     * @returns The updated collection of process operators.
+     */
+    remove(key: string): IProcessOperators<T>;
     /**
      * Gets a process operator from the collection.
      * @param key The key of the operator to retrieve.

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.1.0";
+export declare const version = "6.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-http",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "",
   "main": "dist/esm/index.js",
   "types": "index.d.ts",
@@ -55,6 +55,7 @@
   },
   "dependencies": {
     "rxjs": "^7.8.1",
+    "zod": "^3.23.8",
     "@equinor/fusion-framework-module": "^4.3.5",
     "@equinor/fusion-framework-module-msal": "^3.1.5"
   },

package/src/configurator.ts

@@ -1,4 +1,8 @@
-import { HttpRequestHandler } from './lib/operators';
+import {
+    capitalizeRequestMethodOperator,
+    requestValidationOperator,
+    HttpRequestHandler,
+} from './lib/operators';
 
 import type { FetchRequest, IHttpClient } from './lib/client';
 import type { IHttpRequestHandler, IHttpResponseHandler } from './lib/operators';
@@ -132,9 +136,14 @@ export class HttpClientConfigurator<TClient extends IHttpClient>
     readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
 
     /** default request handler for http clients, applied on creation */
-    readonly defaultHttpRequestHandler = new HttpRequestHandler<
-        HttpClientRequestInitType<TClient>
-    >();
+    readonly defaultHttpRequestHandler = new HttpRequestHandler<HttpClientRequestInitType<TClient>>(
+        {
+            // convert all request methods to uppercase
+            ['capitalize-method']: capitalizeRequestMethodOperator(),
+            // validate the request object
+            ['request-validation']: requestValidationOperator(),
+        },
+    );
 
     /**
      * Create a instance of http configuration

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

@@ -0,0 +1,22 @@
+import { requestMethodCasing } from './fetch-request.schema';
+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();
+
+        if (error && !options?.silent) {
+            error.errors.forEach((e) => console.warn(e.message));
+        }
+
+        return request;
+    };

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

@@ -0,0 +1,119 @@
+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> => {
+    return z.custom<string>(
+        (value?: string) => value === value?.toUpperCase(),
+        (value: string) => ({
+            code: z.ZodIssueCode.custom,
+            validation: 'uppercase',
+            path: ['method'],
+            message: [
+                `Provided HTTP method '${value}' 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'],
+        {
+            errorMap: (error) => {
+                const { received, options } = error as z.ZodInvalidEnumValueIssue;
+                return {
+                    message: [
+                        'Invalid request method.',
+                        `Expected '${options.join(' | ')}', but received '${received}'.`,
+                        'See RFC 2615 Section 9 for more information',
+                        'https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html',
+                    ].join(' '),
+                };
+            },
+        },
+    );
+};
+
+export const requestMethod = () => requestMethodCasing().pipe(requestMethodVerb());
+
+/**
+ * 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,5 +1,7 @@
 export { HttpRequestHandler } from './http-request-handler';
 export { HttpResponseHandler } from './http-response-handler';
 export { ProcessOperators } from './process-operators';
+export { capitalizeRequestMethodOperator } from './capitalize-request-method.operator';
+export { requestValidationOperator } from './request-validation.operator';
 
 export * from './types';

package/src/lib/operators/process-operators.ts

@@ -63,6 +63,17 @@ export class ProcessOperators<T> implements IProcessOperators<T> {
         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.

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { ProcessOperator } from './types';
+import type { FetchRequest } from '../client/types';
+import { fetchRequestSchema } from './fetch-request.schema';
+
+/**
+ * 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.
+         *
+         * @note 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) {
+            if (parse) {
+                throw error;
+            }
+            console.error('Invalid request options', (error as z.ZodError).message);
+        }
+    };

package/src/lib/operators/types.ts

@@ -40,6 +40,13 @@ export interface IProcessOperators<T> {
      */
     set(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
 
+    /**
+     * Removes a process operator from the collection.
+     * @param key The key of the operator to remove.
+     * @returns The updated collection of process operators.
+     */
+    remove(key: string): IProcessOperators<T>;
+
     /**
      * Gets a process operator from the collection.
      * @param key The key of the operator to retrieve.

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '6.1.0';
+export const version = '6.2.0';

package/tests/operators.test.ts

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { describe, it, expect, vi } from 'vitest';
+import {
+    capitalizeRequestMethodOperator,
+    ProcessOperator,
+    requestValidationOperator,
+} from '../src/lib/operators';
+import { FetchRequest } from '../src/lib';
+
+const executeOperator = <R, O extends ProcessOperator<FetchRequest, R>>(
+    operator: O,
+    request: Parameters<O>[0],
+): Promise<ReturnType<O>> => {
+    return new Promise((resolve, rejects) => {
+        try {
+            resolve(operator(request) as ReturnType<O>);
+        } catch (error) {
+            rejects(error);
+        }
+    });
+};
+
+describe('capitalizeRequestMethodOperator', () => {
+    it('should capitalize request method', async () => {
+        const consoleWarn = vi.spyOn(console, 'warn').mockImplementationOnce((msg) => {
+            expect(msg).toMatch(/RFC 7231/);
+        });
+
+        const operator = capitalizeRequestMethodOperator();
+
+        const result = executeOperator(operator, { method: 'get' });
+
+        expect(result).resolves.toMatchObject({ method: 'GET' });
+        expect(consoleWarn).toHaveBeenCalled();
+    });
+});
+
+describe('requestValidationOperator', () => {
+    /**
+     * A mock FetchRequest object used for testing purposes.
+     */
+    const mockRequest: FetchRequest = Object.freeze({
+        method: 'GET',
+        uri: 'https://foo.bar',
+        path: 'api',
+    });
+
+    it('should pass validation for valid request parameters', async () => {
+        const operator = requestValidationOperator();
+
+        const result = executeOperator(operator, mockRequest);
+
+        expect(result).resolves.toBeUndefined();
+    });
+
+    it('should parse valid request parameters', async () => {
+        const operator = requestValidationOperator({ parse: true });
+
+        const result = executeOperator(operator, mockRequest);
+
+        expect(result).resolves.toStrictEqual(mockRequest);
+    });
+
+    it('should allow additional properties when strict validation is disabled', async () => {
+        const operator = requestValidationOperator({ parse: true });
+
+        const result = executeOperator(operator, {
+            ...mockRequest,
+            // @ts-expect-error
+            additionalProperty: 'some-value',
+        });
+
+        expect(result).resolves.toMatchObject(mockRequest);
+        expect(result).resolves.toHaveProperty('additionalProperty', 'some-value');
+    });
+
+    it('should remove additional properties when strict validation is enabled', async () => {
+        const operator = requestValidationOperator({ parse: true, strict: true });
+
+        const result = executeOperator(operator, {
+            ...mockRequest,
+            // @ts-expect-error
+            additionalProperty: 'some-value',
+            method: 'GET',
+        });
+
+        expect(result).resolves.toStrictEqual(mockRequest);
+        expect(result).resolves.not.toHaveProperty('additionalProperty');
+    });
+
+    it('should throw an error for invalid request parameters', async () => {
+        const operator = requestValidationOperator({ parse: true });
+
+        const result = executeOperator(operator, {
+            ...mockRequest,
+            method: 'GETS', // invalid method
+        });
+
+        expect(result).rejects.toThrowError('RFC 2615');
+    });
+});