@slango/ristretto 1.0.52 → 1.0.54

package/src/middleware/runner.ts

@@ -1,65 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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}`,
-    });
-  });
-});

package/src/utils/auth.ts

@@ -1,16 +0,0 @@
-import { AbortablePromise } from './abortableRequest.js';
-import { Request, RequestOptionsWithoutUrl } from './request.js';
-
-export const withBearerToken =
-  (bearerToken: string) =>
-  <Response, PromiseType extends AbortablePromise<Response> | Promise<Response>>(
-    req: Request<Response, PromiseType>,
-  ) =>
-  (options: Omit<RequestOptionsWithoutUrl, 'body'> = {}) =>
-    req({
-      ...options,
-      headers: {
-        ...options.headers,
-        Authorization: `Bearer ${bearerToken}`,
-      },
-    });

package/src/utils/baseUrl.ts

@@ -1,17 +0,0 @@
-type AbsoluteURLString = `${Lowercase<'http' | 'https'>}://${string}`;
-
-export type BaseURL = AbsoluteURLString | URL;
-
-export const getDefaultBaseUrl = (): string => {
-  const baseUrl =
-    typeof window === 'undefined' ? process.env.BASE_URL || '' : window.location.origin;
-
-  if (!baseUrl) {
-    throw new Error('BASE_URL is not defined');
-  }
-
-  return baseUrl;
-};
-
-// Helper to preset a base URL on requests.
-export { withBaseUrl } from './withBaseUrl.js';

package/src/utils/body.spec.ts

@@ -1,123 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { patch, post, put } from '../index.js';
-import { JsonObjectWithFile, withFormDataBody, withJsonBody } from './body.js';
-import { HttpMethod } from './httpMethod.js';
-import { request } from './request.js';
-
-vi.mock('./request.js', () => ({
-  request: vi.fn(),
-}));
-
-const requestMock = vi.mocked(request);
-
-const postRequest = post('/api/data/post');
-const putRequest = put('/api/data/put');
-const patchRequest = patch('/api/data/patch');
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-const formDataToObject = (formData: FormData) => {
-  const obj: JsonObjectWithFile = {};
-  for (const [key, value] of formData.entries()) {
-    if (obj[key]) {
-      obj[key] = Array.isArray(obj[key]) ? [...obj[key], value] : [obj[key], value];
-    } else {
-      obj[key] = value;
-    }
-  }
-  return obj;
-};
-
-describe('withJsonBody', () => {
-  it('should set JSON body and content-type header', async () => {
-    const jsonBody = { key: 'value' };
-    await withJsonBody(jsonBody)(postRequest)();
-    const requestBody = requestMock.mock.calls[0][1].body as string;
-
-    expect(requestBody).toBe(JSON.stringify(jsonBody));
-  });
-
-  it('should merge existing headers', async () => {
-    const jsonBody = { key: 'value' };
-    await withJsonBody(jsonBody)(putRequest)({ headers: { Authorization: 'Bearer token' } });
-
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.PUT, {
-      body: JSON.stringify(jsonBody),
-      headers: {
-        Authorization: 'Bearer token',
-        'content-type': 'application/json',
-      },
-      url: '/api/data/put',
-    });
-  });
-});
-
-describe('withFormDataBody', () => {
-  it('should set FormData body with simple key-value pairs', async () => {
-    const body = { key: 'value' };
-    await withFormDataBody(body)(patchRequest)();
-    const requestBody = requestMock.mock.calls[0][1].body as FormData;
-
-    const formData = new FormData();
-    formData.append('key', 'value');
-
-    expect(formDataToObject(requestBody)).toEqual(formDataToObject(formData));
-  });
-
-  it('should handle nested objects in FormData', async () => {
-    const body = { user: { age: 25, name: 'Alice' } };
-    await withFormDataBody(body)(postRequest)();
-    const requestBody = requestMock.mock.calls[0][1].body as FormData;
-
-    const formData = new FormData();
-    formData.append('user[name]', 'Alice');
-    formData.append('user[age]', '25');
-
-    expect(formDataToObject(requestBody)).toEqual(formDataToObject(formData));
-  });
-
-  it('should handle arrays in FormData', async () => {
-    const body = { tags: ['tag1', 'tag2'] };
-    await withFormDataBody(body)(putRequest)();
-    const requestBody = requestMock.mock.calls[0][1].body as FormData;
-
-    const formData = new FormData();
-    formData.append('tags[0]', 'tag1');
-    formData.append('tags[1]', 'tag2');
-
-    expect(formDataToObject(requestBody)).toEqual(formDataToObject(formData));
-  });
-
-  it('should handle File and Blob objects in FormData', async () => {
-    const file = new File(['file contents'], 'test.txt');
-    const body = { file };
-    await withFormDataBody(body)(patchRequest)();
-    const requestBody = requestMock.mock.calls[0][1].body as FormData;
-
-    const formData = new FormData();
-    formData.append('file', file);
-
-    expect(formDataToObject(requestBody)).toEqual(formDataToObject(formData));
-  });
-
-  it('should merge existing headers', async () => {
-    const jsonBody = { key: 'value' };
-    await withFormDataBody(jsonBody)(putRequest)({ headers: { Authorization: 'Bearer token' } });
-    const requestBody = requestMock.mock.calls[0][1].body as FormData;
-
-    const formData = new FormData();
-    formData.append('key', 'value');
-
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.PUT, {
-      body: expect.any(FormData) as FormData,
-      headers: {
-        Authorization: 'Bearer token',
-      },
-      url: '/api/data/put',
-    });
-    expect(formDataToObject(requestBody)).toEqual(formDataToObject(formData));
-  });
-});

package/src/utils/body.ts

@@ -1,74 +0,0 @@
-import { JsonPrimitive as BaseJsonPrimitive, JsonObject, JsonValue } from 'type-fest';
-
-import { AbortablePromise } from './abortableRequest.js';
-import { Request, RequestOptionsWithoutUrl } from './request.js';
-
-// undefined is not allowed in JsonObjectWithFile (because it is not allowed in Json)
-export type JsonObjectWithFile = {
-  [Key in string]: JsonValueWithFile;
-} & {
-  [Key in string]?: JsonValueWithFile;
-};
-type JsonArrayWithFile = JsonValueWithFile[] | readonly JsonValueWithFile[];
-type JsonPrimitiveWithFile = BaseJsonPrimitive | Blob | File;
-type JsonValueWithFile = JsonArrayWithFile | JsonObjectWithFile | JsonPrimitiveWithFile;
-
-const isJsonObject = (value: unknown): value is JsonObject =>
-  typeof value === 'object' && !Array.isArray(value);
-
-const jsonToFormData = (
-  json: JsonObjectWithFile,
-  formData = new FormData(),
-  parentKey = '',
-): FormData => {
-  const appendValue = (key: string, value: unknown) => {
-    if (value instanceof File || value instanceof Blob) {
-      formData.append(key, value);
-    } else if (isJsonObject(value)) {
-      // Recursive call for nested objects
-      jsonToFormData(value, formData, key);
-    } else {
-      formData.append(key, value as Blob | string);
-    }
-  };
-
-  Object.entries(json).forEach(([key, value]) => {
-    const fullKey = parentKey ? `${parentKey}[${key}]` : key;
-
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => appendValue(`${fullKey}[${index}]`, item));
-    } else {
-      appendValue(fullKey, value);
-    }
-  });
-
-  return formData;
-};
-
-export type Body = BodyInit | JsonValueWithFile;
-
-export const withJsonBody =
-  <Body extends JsonValue>(fixedBody: Body) =>
-  <Response, PromiseType extends AbortablePromise<Response> | Promise<Response>>(
-    req: Request<Response, PromiseType>,
-  ) =>
-  (options: Omit<RequestOptionsWithoutUrl, 'body'> = {}) =>
-    req({
-      ...options,
-      body: JSON.stringify(fixedBody),
-      headers: {
-        ...options.headers,
-        'content-type': 'application/json',
-      },
-    });
-
-export const withFormDataBody =
-  <Body extends JsonObjectWithFile>(fixedBody: Body) =>
-  <Response, PromiseType extends AbortablePromise<Response> | Promise<Response>>(
-    req: Request<Response, PromiseType>,
-  ) =>
-  (options: Omit<RequestOptionsWithoutUrl, 'body'> = {}) =>
-    req({
-      ...options,
-      body: jsonToFormData(fixedBody),
-    });

package/src/utils/httpMethod.ts

@@ -1,11 +0,0 @@
-export enum HttpMethod {
-  CONNECT = 'CONNECT',
-  DELETE = 'DELETE',
-  GET = 'GET',
-  HEAD = 'HEAD',
-  OPTIONS = 'OPTIONS',
-  PATCH = 'PATCH',
-  POST = 'POST',
-  PUT = 'PUT',
-  TRACE = 'TRACE',
-}

package/src/utils/queryParams.spec.ts

@@ -1,75 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { get, patch, post, put } from '../index.js';
-import { HttpMethod } from './httpMethod.js';
-import { QueryParams, withQueryParams } from './queryParams.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');
-const patchRequest = patch('/api/data/patch');
-
-const compareSearchParams = (reference: URLSearchParams, value: URLSearchParams) => {
-  const referenceArray = Array.from(reference.entries());
-  const valueArray = Array.from(value.entries());
-  expect(referenceArray.length).toEqual(valueArray.length);
-  expect(valueArray).toEqual(expect.arrayContaining(referenceArray));
-};
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('withQueryParams', () => {
-  it('should add single query parameters to the request URL', async () => {
-    const query: QueryParams = { baz: 42, foo: 'bar' };
-    await withQueryParams(query)(getRequest)();
-    const requestSearchParams = requestMock.mock.calls[0][1].searchParams!;
-
-    compareSearchParams(requestSearchParams, new URLSearchParams('foo=bar&baz=42'));
-  });
-
-  it('should handle array values in query parameters', async () => {
-    const query: QueryParams = { foo: ['bar', 'baz'] };
-    await withQueryParams(query)(postRequest)();
-    const requestSearchParams = requestMock.mock.calls[0][1].searchParams!;
-
-    compareSearchParams(requestSearchParams, new URLSearchParams('foo=bar&foo=baz'));
-  });
-
-  it('should ignore null and undefined values in query parameters', async () => {
-    const query: QueryParams = { baz: null, foo: 'bar', qux: undefined };
-    await withQueryParams(query)(putRequest)();
-    const requestSearchParams = requestMock.mock.calls[0][1].searchParams!;
-
-    compareSearchParams(requestSearchParams, new URLSearchParams('foo=bar'));
-  });
-
-  it('should handle boolean values in query parameters', async () => {
-    const query: QueryParams = { bar: false, foo: true };
-    await withQueryParams(query)(patchRequest)();
-    const requestSearchParams = requestMock.mock.calls[0][1].searchParams!;
-
-    compareSearchParams(requestSearchParams, new URLSearchParams('foo=true&bar=false'));
-  });
-
-  it('should merge query parameters with existing options', async () => {
-    const query: QueryParams = { foo: 'bar' };
-    await withQueryParams(query)(getRequest)({ headers: { Authorization: 'Bearer token' } });
-    const requestSearchParams = requestMock.mock.calls[0][1].searchParams!;
-
-    compareSearchParams(requestSearchParams, new URLSearchParams('foo=bar'));
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.GET, {
-      headers: { Authorization: 'Bearer token' },
-      searchParams: expect.any(URLSearchParams) as URLSearchParams,
-      url: '/api/data/get',
-    });
-  });
-});

package/src/utils/queryParams.ts

@@ -1,31 +0,0 @@
-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 const queryParamsToURLSearchParams = (query: QueryParams): URLSearchParams => {
-  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 extends QueryParams>(query: Query) =>
-  <Response, PromiseType extends AbortablePromise<Response> | Promise<Response>>(
-    req: Request<Response, PromiseType>,
-  ): Request<Response, PromiseType> =>
-  (options = {}) => {
-    return req({
-      ...options,
-      searchParams: queryParamsToURLSearchParams(query),
-    });
-  };