@slango/ristretto 1.0.0

package/dist/utils/queryParams.d.ts

@@ -0,0 +1,8 @@
+import { AbortablePromise } from './abortableRequest.js';
+import { Request } from './request.js';
+export type QueryParams = Record<string, QueryParamValue | QueryParamValue[]>;
+type QueryParamValue = boolean | null | number | string | undefined;
+export declare const queryParamsToURLSearchParams: (query: QueryParams) => URLSearchParams;
+export declare const withQueryParams: <Query extends QueryParams>(query: Query) => <Response, PromiseType extends AbortablePromise<Response> | Promise<Response>>(req: Request<Response, PromiseType>) => Request<Response, PromiseType>;
+export {};
+//# sourceMappingURL=queryParams.d.ts.map

package/dist/utils/queryParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryParams.d.ts","sourceRoot":"","sources":["../../src/utils/queryParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,EAAE,CAAC,CAAC;AAC9E,KAAK,eAAe,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAEpE,eAAO,MAAM,4BAA4B,GAAI,OAAO,WAAW,KAAG,eAYjE,CAAC;AAEF,eAAO,MAAM,eAAe,GACzB,KAAK,SAAS,WAAW,EAAE,OAAO,KAAK,MACvC,QAAQ,EAAE,WAAW,SAAS,gBAAgB,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,EAC3E,KAAK,OAAO,CAAC,QAAQ,EAAE,WAAW,CAAC,KAClC,OAAO,CAAC,QAAQ,EAAE,WAAW,CAM/B,CAAC"}

package/dist/utils/queryParams.js

@@ -0,0 +1,19 @@
+export const queryParamsToURLSearchParams = (query) => {
+    const params = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            value.forEach((v) => params.append(key, String(v)));
+        }
+        else if (value !== null && value !== undefined) {
+            params.append(key, String(value));
+        }
+    });
+    return params;
+};
+export const withQueryParams = (query) => (req) => (options = {}) => {
+    return req({
+        ...options,
+        searchParams: queryParamsToURLSearchParams(query),
+    });
+};
+//# sourceMappingURL=queryParams.js.map

package/dist/utils/queryParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryParams.js","sourceRoot":"","sources":["../../src/utils/queryParams.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,KAAkB,EAAmB,EAAE;IAClF,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;IAErC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,CAAC;aAAM,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACjD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACpC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAC1B,CAA4B,KAAY,EAAE,EAAE,CAC5C,CACE,GAAmC,EACH,EAAE,CACpC,CAAC,OAAO,GAAG,EAAE,EAAE,EAAE;IACf,OAAO,GAAG,CAAC;QACT,GAAG,OAAO;QACV,YAAY,EAAE,4BAA4B,CAAC,KAAK,CAAC;KAClD,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/utils/request.d.ts

@@ -0,0 +1,15 @@
+import { AbortablePromise } from './abortableRequest.js';
+import { BaseURL } from './baseUrl.js';
+import { HttpMethod } from './httpMethod.js';
+type PathOnly = `../${string}` | `./${string}` | `/${string}`;
+export type RequestURL = BaseURL | PathOnly;
+export type Request<Response, PromiseType extends AbortablePromise<Response> | Promise<Response>> = (options?: RequestOptionsWithoutUrl) => PromiseType;
+export type RequestOptions = RequestInit & {
+    searchParams?: URLSearchParams;
+    url: RequestURL;
+    baseUrl?: BaseURL;
+};
+export type RequestOptionsWithoutUrl = Omit<RequestOptions, 'url'>;
+export declare const request: <Response>(method: HttpMethod, options: RequestOptions) => Promise<Response>;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/dist/utils/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/utils/request.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAqB,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,KAAK,QAAQ,GAAG,MAAM,MAAM,EAAE,GAAG,KAAK,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,CAAC;AAE9D,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5C,MAAM,MAAM,OAAO,CACjB,QAAQ,EACR,WAAW,SAAS,gBAAgB,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,IAChE,CAAC,OAAO,CAAC,EAAE,wBAAwB,KAAK,WAAW,CAAC;AAExD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IACzC,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,GAAG,EAAE,UAAU,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;AAEnE,eAAO,MAAM,OAAO,GAAU,QAAQ,EACpC,QAAQ,UAAU,EAClB,SAAS,cAAc,KACtB,OAAO,CAAC,QAAQ,CA8BlB,CAAC"}

package/dist/utils/request.js

@@ -0,0 +1,28 @@
+import { runPostResponse, runPreRequest } from '../middleware/runner.js';
+import { getDefaultBaseUrl } from './baseUrl.js';
+import { HttpError } from './HttpError.js';
+export const request = async (method, options) => {
+    const fetchOptions = {
+        method,
+        ...options,
+    };
+    const middlewareContext = { request: fetchOptions };
+    await runPreRequest(middlewareContext);
+    const { searchParams, url, baseUrl, ...requestOptions } = fetchOptions;
+    const fullUrl = new URL(url, baseUrl || getDefaultBaseUrl());
+    if (searchParams) {
+        searchParams.forEach((value, key) => {
+            fullUrl.searchParams.append(key, value);
+        });
+    }
+    const response = await fetch(fullUrl.toString(), requestOptions);
+    await runPostResponse({ ...middlewareContext, response });
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText);
+    }
+    if (response.status === 204 || !response.body) {
+        return undefined;
+    }
+    return (await response.json());
+};
+//# sourceMappingURL=request.js.map

package/dist/utils/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../../src/utils/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAEzE,OAAO,EAAW,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,MAAM,CAAC,MAAM,OAAO,GAAG,KAAK,EAC1B,MAAkB,EAClB,OAAuB,EACJ,EAAE;IACrB,MAAM,YAAY,GAAG;QACnB,MAAM;QACN,GAAG,OAAO;KACX,CAAC;IACF,MAAM,iBAAiB,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC;IACpD,MAAM,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAEvC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,GAAG,YAAY,CAAC;IAEvE,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,GAAG,EAAE,OAAO,IAAI,iBAAiB,EAAE,CAAC,CAAC;IAC7D,IAAI,YAAY,EAAE,CAAC;QACjB,YAAY,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YAClC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,cAAc,CAAC,CAAC;IAEjE,MAAM,eAAe,CAAC,EAAE,GAAG,iBAAiB,EAAE,QAAQ,EAAE,CAAC,CAAC;IAE1D,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC5D,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC9C,OAAO,SAAqB,CAAC;IAC/B,CAAC;IAED,OAAO,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAa,CAAC;AAC7C,CAAC,CAAC"}

package/dist/utils/status.d.ts

@@ -0,0 +1,3 @@
+import { RequestOptionsWithoutUrl } from './request.js';
+export declare const withNotFoundAsNull: <Response>(requestFn: (options?: RequestOptionsWithoutUrl) => Promise<Response>) => (options?: RequestOptionsWithoutUrl) => Promise<null | Response>;
+//# sourceMappingURL=status.d.ts.map

package/dist/utils/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/utils/status.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAExD,eAAO,MAAM,kBAAkB,GAC5B,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,wBAAwB,KAAK,OAAO,CAAC,QAAQ,CAAC,MACxE,UAAU,wBAAwB,KAAG,OAAO,CAAC,IAAI,GAAG,QAAQ,CASlE,CAAC"}

package/dist/utils/status.js

@@ -0,0 +1,13 @@
+import { HttpError } from './HttpError.js';
+export const withNotFoundAsNull = (requestFn) => async (options) => {
+    try {
+        return await requestFn(options);
+    }
+    catch (error) {
+        if (error instanceof HttpError && error.status == 404) {
+            return null;
+        }
+        throw error;
+    }
+};
+//# sourceMappingURL=status.js.map

package/dist/utils/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/utils/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,MAAM,CAAC,MAAM,kBAAkB,GAC7B,CAAW,SAAoE,EAAE,EAAE,CACnF,KAAK,EAAE,OAAkC,EAA4B,EAAE;IACrE,IAAI,CAAC;QACH,OAAO,MAAM,SAAS,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,SAAS,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;YACtD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC"}

package/eslint.config.js

@@ -0,0 +1 @@
+export { default } from '@slango.configs/eslint/typescript-isomorphic.js';

package/lint-staged.config.js

@@ -0,0 +1 @@
+export { default } from '@slango.configs/lint-staged/typescript.js';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@slango/ristretto",
+  "version": "1.0.0",
+  "private": false,
+  "description": "Opinionated rest client",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./abortable": {
+      "import": "./dist/abortable/index.js",
+      "types": "./dist/abortable/index.d.ts"
+    },
+    "./middleware": {
+      "import": "./dist/middleware/index.js",
+      "types": "./dist/middleware/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@slango/ts-utils": "1.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "24.2.0",
+    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/ui": "3.2.4",
+    "eslint": "9.32.0",
+    "type-fest": "4.41.0",
+    "typescript": "5.9.2",
+    "vitest": "3.2.4",
+    "@slango.configs/typescript": "1.0.4",
+    "@slango.configs/vitest": "1.0.21",
+    "@slango.configs/eslint": "1.0.28"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:force": "tsc -p tsconfig.build.json --incremental false",
+    "build:watch": "tsc -p tsconfig.build.json --watch",
+    "build:check": "tsc --noEmit",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix --max-warnings 0",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --run --coverage",
+    "test:ui": "vitest --ui"
+  }
+}

package/src/abortable/index.ts

@@ -0,0 +1,48 @@
+import { AbortablePromise, abortableRequest } from '../utils/abortableRequest.js';
+import { HttpMethod } from '../utils/httpMethod.js';
+import { Request as BaseRequest, RequestOptionsWithoutUrl, RequestURL } from '../utils/request.js';
+
+export type { AbortablePromise } from '../utils/abortableRequest.js';
+export { withBearerToken } from '../utils/auth.js';
+export type { BaseURL } from '../utils/baseUrl.js';
+export { withFormDataBody, withJsonBody } from '../utils/body.js';
+export { HttpError } from '../utils/HttpError.js';
+export { withQueryParams } from '../utils/queryParams.js';
+export type { RequestOptionsWithoutUrl, RequestURL } from '../utils/request.js';
+export { withNotFoundAsNull } from '../utils/status.js';
+
+export type Request<Response> = BaseRequest<Response, AbortablePromise<Response>>;
+
+const abortableRequestFactory =
+  (method: HttpMethod) =>
+  <Response>(url: RequestURL) =>
+  (options?: RequestOptionsWithoutUrl): AbortablePromise<Response> =>
+    abortableRequest<Response>(method, { ...options, url });
+
+export const get = abortableRequestFactory(HttpMethod.GET);
+
+export const del = abortableRequestFactory(HttpMethod.DELETE);
+
+export const post = abortableRequestFactory(HttpMethod.POST);
+
+export const put = abortableRequestFactory(HttpMethod.PUT);
+
+export const patch = abortableRequestFactory(HttpMethod.PATCH);
+
+export const withTransformer =
+  <Input, Output>(transformFn: (input: Input) => Output) =>
+  (req: Request<Input>): Request<Output> =>
+  (options?: RequestOptionsWithoutUrl) => {
+    const abortablePromise = req(options);
+
+    const wrappedPromise = abortablePromise.then((result: Input) =>
+      transformFn ? transformFn(result) : result,
+    ) as AbortablePromise<Output>;
+
+    if ('abort' in abortablePromise) {
+      // Assign the abort function if it's an AbortablePromise
+      wrappedPromise.abort = abortablePromise.abort;
+    }
+
+    return wrappedPromise;
+  };

package/src/index.ts

@@ -0,0 +1,34 @@
+import { HttpMethod } from './utils/httpMethod.js';
+import {
+  Request as BaseRequest,
+  request,
+  RequestOptionsWithoutUrl,
+  RequestURL,
+} from './utils/request.js';
+
+export { withBearerToken } from './utils/auth.js';
+export type { BaseURL } from './utils/baseUrl.js';
+export { withFormDataBody, withJsonBody } from './utils/body.js';
+export { HttpError } from './utils/HttpError.js';
+export { withQueryParams } from './utils/queryParams.js';
+export type { RequestOptionsWithoutUrl, RequestURL } from './utils/request.js';
+
+export { withNotFoundAsNull } from './utils/status.js';
+
+export type Request<Response> = BaseRequest<Response, Promise<Response>>;
+
+const requestFactory =
+  (method: HttpMethod) =>
+  <Response>(url: RequestURL): Request<Response> =>
+  (options?: RequestOptionsWithoutUrl): Promise<Response> =>
+    request<Response>(method, { ...options, url });
+
+export const get = requestFactory(HttpMethod.GET);
+
+export const del = requestFactory(HttpMethod.DELETE);
+
+export const post = requestFactory(HttpMethod.POST);
+
+export const put = requestFactory(HttpMethod.PUT);
+
+export const patch = requestFactory(HttpMethod.PATCH);

package/src/middleware/index.ts

@@ -0,0 +1,20 @@
+import { Promisable } from 'type-fest';
+
+import { RequestOptions } from '../utils/request.js';
+
+export type PreRequestMiddlewareContext = {
+  request: RequestOptions;
+};
+
+export type PostResponseMiddlewareContext = PreRequestMiddlewareContext & {
+  response: Response;
+};
+
+export type MiddlewareNext = (error?: Error) => Promisable<void>;
+
+export type Middleware<Context> = (ctx: Context, next: MiddlewareNext) => Promisable<void>;
+
+export {
+  addPostResponseMiddleware as usePostResponse,
+  addPreRequestMiddleware as usePreRequest,
+} from './runner.js';

package/src/middleware/runner.spec.ts

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  MiddlewareNext,
+  PostResponseMiddlewareContext,
+  PreRequestMiddlewareContext,
+} from './index.js';
+import {
+  addPostResponseMiddleware,
+  addPreRequestMiddleware,
+  clearPostResponseMiddlewares,
+  clearPreRequestMiddlewares,
+  removePostResponseMiddleware,
+  removePreRequestMiddleware,
+  runPostResponse,
+  runPreRequest,
+} from './runner.js';
+
+const createPreRequestContext = (): PreRequestMiddlewareContext => ({
+  request: { url: 'https://example.com', method: 'GET', headers: {} },
+});
+
+const createPostResponseContext = (): PostResponseMiddlewareContext => ({
+  request: { url: 'https://example.com', method: 'GET', headers: {} },
+  response: new Response(null, { status: 200 }),
+});
+
+describe('runner.ts', () => {
+  beforeEach(() => {
+    clearPostResponseMiddlewares();
+    clearPreRequestMiddlewares();
+  });
+
+  it('should add and remove pre-request middleware', async () => {
+    const middleware1 = vi.fn((ctx, next: MiddlewareNext) => next());
+    const middleware2 = vi.fn();
+
+    addPreRequestMiddleware(middleware1);
+    addPreRequestMiddleware(middleware2);
+    await runPreRequest(createPreRequestContext());
+    expect(middleware1).toHaveBeenCalledTimes(1);
+    expect(middleware2).toHaveBeenCalledTimes(1);
+
+    removePreRequestMiddleware(middleware2);
+    await runPreRequest(createPreRequestContext());
+    expect(middleware1).toHaveBeenCalledTimes(2);
+    expect(middleware2).toHaveBeenCalledTimes(1);
+  });
+
+  it('should add and remove post-request middleware', async () => {
+    const middleware1 = vi.fn((ctx, next: MiddlewareNext) => next());
+    const middleware2 = vi.fn();
+
+    addPostResponseMiddleware(middleware1);
+    addPostResponseMiddleware(middleware2);
+    await runPostResponse(createPostResponseContext());
+    expect(middleware1).toHaveBeenCalledTimes(1);
+    expect(middleware2).toHaveBeenCalledTimes(1);
+
+    removePostResponseMiddleware(middleware2);
+    await runPostResponse(createPostResponseContext());
+    expect(middleware1).toHaveBeenCalledTimes(2);
+    expect(middleware2).toHaveBeenCalledTimes(1);
+  });
+
+  it('should run pre-request middlewares in order and modify context', async () => {
+    const middleware1 = vi.fn(async (ctx: PreRequestMiddlewareContext, next: MiddlewareNext) => {
+      (ctx.request.headers! as Record<string, string>)['X-Test'] = 'Middleware1';
+      (ctx.request.headers! as Record<string, string>)['X-Override'] = 'Middleware1';
+      await next();
+    });
+    const middleware2 = vi.fn(async (ctx: PreRequestMiddlewareContext, next: MiddlewareNext) => {
+      (ctx.request.headers! as Record<string, string>)['X-Chain'] = 'Middleware2';
+      (ctx.request.headers! as Record<string, string>)['X-Override'] = 'Middleware2';
+      await next();
+    });
+
+    addPreRequestMiddleware(middleware1);
+    addPreRequestMiddleware(middleware2);
+
+    const context = createPreRequestContext();
+    await runPreRequest(context);
+
+    expect(middleware1).toHaveBeenCalledOnce();
+    expect(middleware2).toHaveBeenCalledOnce();
+    expect(context.request.headers).toEqual({
+      'X-Test': 'Middleware1',
+      'X-Chain': 'Middleware2',
+      'X-Override': 'Middleware2',
+    });
+  });
+
+  it('should run post-response middlewares in order and modify context', async () => {
+    const middleware1 = vi.fn(async (ctx: PostResponseMiddlewareContext, next: MiddlewareNext) => {
+      ctx.response.headers.set('X-Test', 'Middleware1');
+      ctx.response.headers.set('X-Override', 'Middleware1');
+      await next();
+    });
+    const middleware2 = vi.fn(async (ctx: PostResponseMiddlewareContext, next: MiddlewareNext) => {
+      ctx.response.headers.set('X-Chain', 'Middleware2');
+      ctx.response.headers.set('X-Override', 'Middleware2');
+
+      await next();
+    });
+
+    addPostResponseMiddleware(middleware1);
+    addPostResponseMiddleware(middleware2);
+
+    const context = createPostResponseContext();
+    await runPostResponse(context);
+
+    expect(middleware1).toHaveBeenCalledOnce();
+    expect(middleware2).toHaveBeenCalledOnce();
+    expect(context.response.headers.get('X-Test')).toBe('Middleware1');
+    expect(context.response.headers.get('X-Chain')).toBe('Middleware2');
+    expect(context.response.headers.get('X-Override')).toBe('Middleware2');
+  });
+
+  it('should handle errors in pre-request middlewares and stop pipeline', async () => {
+    const middleware1 = vi.fn(async (ctx: PreRequestMiddlewareContext, next: MiddlewareNext) => {
+      await next();
+    });
+    const errorMiddleware = vi.fn(() => {
+      throw new Error('Test error');
+    });
+    const middleware2 = vi.fn(async (ctx: PreRequestMiddlewareContext, next: MiddlewareNext) => {
+      await next();
+    });
+
+    addPreRequestMiddleware(middleware1);
+    addPreRequestMiddleware(errorMiddleware);
+    addPreRequestMiddleware(middleware2);
+
+    const context = createPreRequestContext();
+
+    await expect(runPreRequest(context)).rejects.toThrow('Test error');
+
+    expect(middleware1).toHaveBeenCalledOnce();
+    expect(errorMiddleware).toHaveBeenCalledOnce();
+    expect(middleware2).not.toHaveBeenCalled();
+
+    removePreRequestMiddleware(middleware1);
+    removePreRequestMiddleware(errorMiddleware);
+    removePreRequestMiddleware(middleware2);
+  });
+
+  it('should handle errors in post-response middlewares and stop pipeline', async () => {
+    const middleware1 = vi.fn(async (ctx: PostResponseMiddlewareContext, next: MiddlewareNext) => {
+      await next();
+    });
+    const errorMiddleware = vi.fn(() => {
+      throw new Error('Test error');
+    });
+    const middleware2 = vi.fn(async (ctx: PostResponseMiddlewareContext, next: MiddlewareNext) => {
+      await next();
+    });
+
+    addPostResponseMiddleware(middleware1);
+    addPostResponseMiddleware(errorMiddleware);
+    addPostResponseMiddleware(middleware2);
+
+    const context = createPostResponseContext();
+
+    await expect(runPostResponse(context)).rejects.toThrow('Test error');
+
+    expect(middleware1).toHaveBeenCalledOnce();
+    expect(errorMiddleware).toHaveBeenCalledOnce();
+    expect(middleware2).not.toHaveBeenCalled();
+
+    removePostResponseMiddleware(middleware1);
+    removePostResponseMiddleware(errorMiddleware);
+    removePostResponseMiddleware(middleware2);
+  });
+});

package/src/middleware/runner.ts

@@ -0,0 +1,65 @@
+import {
+  Middleware,
+  MiddlewareNext,
+  PostResponseMiddlewareContext,
+  PreRequestMiddlewareContext,
+} from './index.js';
+
+export type PostResponseMiddleWare = Middleware<PostResponseMiddlewareContext>;
+export type PreRequestMiddleWare = Middleware<PreRequestMiddlewareContext>;
+
+const preRequestMiddlewares: PreRequestMiddleWare[] = [];
+const postResponseMiddlewares: PostResponseMiddleWare[] = [];
+
+export const addPreRequestMiddleware = (middleware: PreRequestMiddleWare) => {
+  preRequestMiddlewares.push(middleware);
+};
+
+export const addPostResponseMiddleware = (middleware: PostResponseMiddleWare) => {
+  postResponseMiddlewares.push(middleware);
+};
+
+export const removePreRequestMiddleware = (middleware: PreRequestMiddleWare) => {
+  const index = preRequestMiddlewares.findIndex((m) => m === middleware);
+  if (index !== -1) preRequestMiddlewares.splice(index, 1);
+};
+
+export const removePostResponseMiddleware = (middleware: PostResponseMiddleWare) => {
+  const index = postResponseMiddlewares.findIndex((m) => m === middleware);
+  if (index !== -1) postResponseMiddlewares.splice(index, 1);
+};
+
+export const clearPreRequestMiddlewares = () => {
+  preRequestMiddlewares.length = 0;
+};
+
+export const clearPostResponseMiddlewares = () => {
+  postResponseMiddlewares.length = 0;
+};
+
+const runMiddlewares = <Context>(middlewares: Middleware<Context>[]) => {
+  return async (context: Context): Promise<void> => {
+    let index = 0;
+
+    const next: MiddlewareNext = async (error?: Error) => {
+      if (error) {
+        throw error;
+      }
+
+      if (index < middlewares.length) {
+        const currentMiddleware = middlewares[index];
+        index++;
+        try {
+          await currentMiddleware(context, next);
+        } catch (err) {
+          await next(err as Error);
+        }
+      }
+    };
+
+    await next();
+  };
+};
+
+export const runPreRequest = runMiddlewares(preRequestMiddlewares);
+export const runPostResponse = runMiddlewares(postResponseMiddlewares);

package/src/utils/HttpError.ts

@@ -0,0 +1,9 @@
+export class HttpError extends Error {
+  public readonly status: number;
+
+  constructor(status: number, message: string) {
+    super(message);
+    this.name = 'HttpError';
+    this.status = status;
+  }
+}

package/src/utils/abortableRequest.spec.ts

@@ -0,0 +1,50 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { abortableRequest } from './abortableRequest.js';
+import { HttpMethod } from './httpMethod.js';
+import { request, RequestOptions } from './request.js';
+
+vi.mock('./request', () => ({
+  request: vi.fn(),
+}));
+
+const requestMock = vi.mocked(request);
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('abortableRequest', () => {
+  it('should create a request with the given method and options', async () => {
+    const method = HttpMethod.GET;
+    const options: RequestOptions = {
+      headers: { 'Content-Type': 'application/json' },
+      url: '/api/test',
+    };
+    const mockResponse = Promise.resolve('response');
+    requestMock.mockReturnValue(mockResponse);
+
+    const result = abortableRequest(method, options);
+
+    expect(request).toHaveBeenCalledWith(method, {
+      ...options,
+      signal: expect.any(AbortSignal) as AbortSignal,
+    });
+    await expect(result).resolves.toBe('response');
+  });
+
+  it('should abort the request when abort is called', async () => {
+    const method = HttpMethod.POST;
+    const options: RequestOptions = { url: '/api/test' };
+
+    const mockedResponse = new Promise((_, reject) => {
+      setTimeout(() => reject(new DOMException('Aborted', 'AbortError')));
+    });
+    requestMock.mockReturnValueOnce(mockedResponse);
+
+    const abortable = abortableRequest(method, options);
+    abortable.abort();
+
+    await expect(abortable).rejects.toThrowError('Aborted');
+  });
+});

package/src/utils/abortableRequest.ts

@@ -0,0 +1,22 @@
+import { HttpMethod } from './httpMethod.js';
+import { request, RequestOptions } from './request.js';
+
+export interface AbortablePromise<Response> extends Promise<Response> {
+  abort: () => void;
+}
+
+export const abortableRequest = <Response>(
+  method: HttpMethod,
+  options: RequestOptions,
+): AbortablePromise<Response> => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+
+  const r = request(method, {
+    signal,
+    ...options,
+  }) as AbortablePromise<Response>;
+  r.abort = () => controller.abort();
+
+  return r;
+};

package/src/utils/auth.spec.ts

@@ -0,0 +1,58 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { get, post, put } from '../index.js';
+import { withBearerToken } from './auth.js';
+import { request } from './request.js';
+
+vi.mock('./request.js', () => ({
+  request: vi.fn(),
+}));
+
+const requestMock = vi.mocked(request);
+
+const getRequest = get('/api/data/get');
+const postRequest = post('/api/data/post');
+const putRequest = put('/api/data/put');
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('withBearerToken', () => {
+  it('should add the Authorization header with the provided bearer token', async () => {
+    const bearerToken = 'test-token';
+    await withBearerToken(bearerToken)(getRequest)();
+    const requestHeaders = requestMock.mock.calls[0][1].headers!;
+
+    expect(requestHeaders).toEqual({
+      Authorization: `Bearer ${bearerToken}`,
+    });
+  });
+
+  it('should merge the Authorization header with existing headers', async () => {
+    const bearerToken = 'test-token';
+    await withBearerToken(bearerToken)(postRequest)({
+      headers: { 'X-Test': 'Value' },
+    });
+    const requestHeaders = requestMock.mock.calls[0][1].headers!;
+
+    expect(requestHeaders).toEqual({
+      Authorization: `Bearer ${bearerToken}`,
+      'X-Test': 'Value',
+    });
+  });
+
+  it('should override any existing Authorization header with the provided bearer token', async () => {
+    const bearerToken = 'new-token';
+    await withBearerToken(bearerToken)(putRequest)({
+      headers: {
+        Authorization: `Bearer Test Test`,
+      },
+    });
+    const requestHeaders = requestMock.mock.calls[0][1].headers!;
+
+    expect(requestHeaders).toEqual({
+      Authorization: `Bearer ${bearerToken}`,
+    });
+  });
+});