@slango/ristretto 1.0.52 → 1.0.53

package/src/utils/request.spec.ts

@@ -1,180 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import {
-  MiddlewareNext,
-  PostResponseMiddlewareContext,
-  PreRequestMiddlewareContext,
-  usePostResponse,
-  usePreRequest,
-} from '../middleware/index.js';
-import { HttpError } from './HttpError.js';
-import { HttpMethod } from './httpMethod.js';
-import { request, RequestOptions } from './request.js';
-
-describe('request', () => {
-  const mockFetch = vi.fn();
-  globalThis.fetch = mockFetch;
-
-  afterEach(() => {
-    mockFetch.mockClear();
-  });
-
-  const mockedResponseFactory = <T extends Record<string, unknown>>(data: T) => ({
-    body: JSON.stringify(data),
-    json: () => Promise.resolve(data),
-    ok: true,
-  });
-
-  it('should make a successful GET request and return JSON response', async () => {
-    const mockResponseData = { message: 'Success' };
-    mockFetch.mockResolvedValueOnce(mockedResponseFactory(mockResponseData));
-
-    const options: RequestOptions = {
-      method: HttpMethod.GET,
-      url: '/api/data',
-    };
-
-    const result = await request<typeof mockResponseData>(HttpMethod.GET, options);
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith(`${window.location.origin}/api/data`, {
-      headers: undefined,
-      method: HttpMethod.GET,
-    });
-    expect(result).toEqual(mockResponseData);
-  });
-
-  it('should append query parameters to the URL', async () => {
-    const mockResponseData = { message: 'Success with query params' };
-    mockFetch.mockResolvedValueOnce(mockedResponseFactory(mockResponseData));
-
-    const options: RequestOptions = {
-      method: HttpMethod.GET,
-      searchParams: new URLSearchParams({ page: '1', search: 'test' }),
-      url: '/api/data',
-    };
-
-    const result = await request<typeof mockResponseData>(HttpMethod.GET, options);
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith(
-      `${window.location.origin}/api/data?page=1&search=test`,
-      {
-        headers: undefined,
-        method: HttpMethod.GET,
-      },
-    );
-    expect(result).toEqual(mockResponseData);
-  });
-
-  it('should throw an error if response is not ok', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      statusText: 'Not Found',
-    });
-
-    const options: RequestOptions = {
-      method: HttpMethod.GET,
-      url: '/api/notfound',
-    };
-
-    await expect(request(HttpMethod.GET, options)).rejects.toThrow(new HttpError(404, 'Not Found'));
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith(`${window.location.origin}/api/notfound`, {
-      headers: undefined,
-      method: HttpMethod.GET,
-    });
-  });
-
-  it('should include custom headers in the request', async () => {
-    const mockResponseData = { message: 'Success with headers' };
-    mockFetch.mockResolvedValueOnce(mockedResponseFactory(mockResponseData));
-
-    const options: RequestOptions = {
-      headers: {
-        Authorization: 'Bearer test-token',
-        'Content-Type': 'application/json',
-      },
-      method: HttpMethod.GET,
-      url: '/api/headers',
-    };
-
-    const result = await request<typeof mockResponseData>(HttpMethod.GET, options);
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith(`${window.location.origin}/api/headers`, {
-      headers: {
-        Authorization: 'Bearer test-token',
-        'Content-Type': 'application/json',
-      },
-      method: HttpMethod.GET,
-    });
-    expect(result).toEqual(mockResponseData);
-  });
-
-  it('should send JSON body in POST request', async () => {
-    const mockResponseData = { message: 'Success with JSON body' };
-    mockFetch.mockResolvedValueOnce(mockedResponseFactory(mockResponseData));
-
-    const options: RequestOptions = {
-      body: JSON.stringify({ key: 'value' }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      method: HttpMethod.POST,
-      url: '/api/post',
-    };
-
-    const result = await request<typeof mockResponseData>(HttpMethod.POST, options);
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith(`${window.location.origin}/api/post`, {
-      body: JSON.stringify({ key: 'value' }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      method: HttpMethod.POST,
-    });
-    expect(result).toEqual(mockResponseData);
-  });
-
-  it('should call middleware before and after the request', async () => {
-    const mockResponseData = { message: 'Middleware test' };
-    mockFetch.mockResolvedValueOnce({
-      ...mockedResponseFactory({ ...mockResponseData }),
-      status: 200,
-    });
-
-    const options: RequestOptions = {
-      method: HttpMethod.GET,
-      url: '/api/middleware',
-      headers: {
-        'X-Test-Header': 'TestValue',
-      },
-    };
-
-    const preRequestMiddleware = vi.fn(
-      async (ctx: PreRequestMiddlewareContext, next: MiddlewareNext) => {
-        expect(ctx.request.method).toBe(HttpMethod.GET);
-        expect((ctx.request.headers! as Record<string, string>)['X-Test-Header']).toBe('TestValue');
-        await next();
-      },
-    );
-    const postResponseMiddleware = vi.fn(
-      async (ctx: PostResponseMiddlewareContext, next: MiddlewareNext) => {
-        expect(ctx.response.ok).toBe(true);
-        expect(ctx.response.status).toBe(200);
-        expect(ctx.response.body).toBe(JSON.stringify(mockResponseData));
-        await next();
-      },
-    );
-    usePreRequest(preRequestMiddleware);
-    usePostResponse(postResponseMiddleware);
-
-    await request<typeof mockResponseData>(HttpMethod.GET, options);
-
-    expect(preRequestMiddleware).toHaveBeenCalledOnce();
-    expect(postResponseMiddleware).toHaveBeenCalledOnce();
-  });
-});

package/src/utils/request.ts

@@ -1,57 +0,0 @@
-import { runPostResponse, runPreRequest } from '../middleware/runner.js';
-import { AbortablePromise } from './abortableRequest.js';
-import { BaseURL, getDefaultBaseUrl } from './baseUrl.js';
-import { HttpError } from './HttpError.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 const request = async <Response>(
-  method: HttpMethod,
-  options: RequestOptions,
-): Promise<Response> => {
-  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 as Response;
-  }
-
-  return (await response.json()) as Response;
-};

package/src/utils/status.spec.ts

@@ -1,66 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { get } from '../index.js';
-import { HttpError } from './HttpError.js';
-import { HttpMethod } from './httpMethod.js';
-import { request, RequestOptionsWithoutUrl } from './request.js';
-import { withNotFoundAsNull } from './status.js';
-
-vi.mock('./request.js', () => ({
-  request: vi.fn(),
-}));
-
-const requestMock = vi.mocked(request);
-
-const getRequest = get('/api/data/get');
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('withNotFoundAsNull', () => {
-  it('should return the response when the request succeeds', async () => {
-    const mockResponse = { data: 'valid response' };
-    requestMock.mockResolvedValueOnce(mockResponse);
-
-    const fetchData = withNotFoundAsNull(getRequest);
-    const result = await fetchData();
-
-    expect(result).toEqual(mockResponse);
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.GET, { url: '/api/data/get' });
-  });
-
-  it('should return null when the request fails with 404', async () => {
-    requestMock.mockRejectedValueOnce(new HttpError(404, 'Not Found'));
-
-    const fetchData = withNotFoundAsNull(getRequest);
-    const result = await fetchData();
-
-    expect(result).toBeNull();
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.GET, { url: '/api/data/get' });
-  });
-
-  it('should throw an error when the request fails with an error other than 404', async () => {
-    requestMock.mockRejectedValueOnce(new HttpError(500, 'Internal Server Error'));
-
-    const fetchData = withNotFoundAsNull(getRequest);
-
-    await expect(fetchData()).rejects.toThrow(new HttpError(500, 'Internal Server Error'));
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.GET, { url: '/api/data/get' });
-  });
-
-  it('should forward request options when calling the request function', async () => {
-    const mockResponse = { data: 'valid response' };
-    requestMock.mockResolvedValueOnce(mockResponse);
-
-    const fetchData = withNotFoundAsNull(getRequest);
-    const options: RequestOptionsWithoutUrl = { headers: { Authorization: 'Bearer token' } };
-    const result = await fetchData(options);
-
-    expect(result).toEqual(mockResponse);
-    expect(requestMock).toHaveBeenCalledWith(HttpMethod.GET, {
-      url: '/api/data/get',
-      headers: { Authorization: 'Bearer token' },
-    });
-  });
-});

package/src/utils/status.ts

@@ -1,15 +0,0 @@
-import { HttpError } from './HttpError.js';
-import { RequestOptionsWithoutUrl } from './request.js';
-
-export const withNotFoundAsNull =
-  <Response>(requestFn: (options?: RequestOptionsWithoutUrl) => Promise<Response>) =>
-  async (options?: RequestOptionsWithoutUrl): Promise<null | Response> => {
-    try {
-      return await requestFn(options);
-    } catch (error) {
-      if (error instanceof HttpError && error.status == 404) {
-        return null;
-      }
-      throw error;
-    }
-  };

package/src/utils/withBaseUrl.spec.ts

@@ -1,53 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { HttpMethod } from './httpMethod.js';
-import { request, RequestOptionsWithoutUrl } from './request.js';
-import { withBaseUrl } from './withBaseUrl.js';
-
-describe('withBaseUrl', () => {
-  const mockFetch = vi.fn();
-  globalThis.fetch = mockFetch;
-
-  afterEach(() => {
-    mockFetch.mockClear();
-  });
-
-  const mockedResponseFactory = <T extends Record<string, unknown>>(data: T) => ({
-    body: JSON.stringify(data),
-    json: () => Promise.resolve(data),
-    ok: true,
-  });
-
-  const baseRequest = (options?: RequestOptionsWithoutUrl) =>
-    request<{ message: string }>(HttpMethod.GET, { ...options, url: '/data' });
-
-  it('should apply default base URL when none provided in options', async () => {
-    const req = withBaseUrl('https://api.example.com')(baseRequest);
-    const mockResponseData = { message: 'Success' };
-    mockFetch.mockResolvedValueOnce(mockedResponseFactory(mockResponseData));
-
-    const result = await req();
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/data', {
-      headers: undefined,
-      method: HttpMethod.GET,
-    });
-    expect(result).toEqual(mockResponseData);
-  });
-
-  it('should allow overriding base URL in options', async () => {
-    const req = withBaseUrl('https://api.example.com')(baseRequest);
-    const mockResponseData = { message: 'Override' };
-    mockFetch.mockResolvedValueOnce(mockedResponseFactory(mockResponseData));
-
-    const result = await req({ baseUrl: 'https://override.example.com' });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    expect(mockFetch).toHaveBeenCalledWith('https://override.example.com/data', {
-      headers: undefined,
-      method: HttpMethod.GET,
-    });
-    expect(result).toEqual(mockResponseData);
-  });
-});

package/src/utils/withBaseUrl.ts

@@ -1,12 +0,0 @@
-import type { BaseURL } from './baseUrl.js';
-
-import { AbortablePromise } from './abortableRequest.js';
-import { Request, RequestOptionsWithoutUrl } from './request.js';
-
-export const withBaseUrl =
-  (baseUrl: BaseURL) =>
-  <Response, PromiseType extends AbortablePromise<Response> | Promise<Response>>(
-    req: Request<Response, PromiseType>,
-  ): Request<Response, PromiseType> =>
-  (options: RequestOptionsWithoutUrl = {}) =>
-    req({ baseUrl, ...options });

package/tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "exclude": ["node_modules", "dist", "src/**/*.spec.ts"]
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@slango.configs/typescript/default.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "types": ["node"]
-  },
-  "include": ["**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/vitest.config.js

@@ -1 +0,0 @@
-export { default } from '@slango.configs/vitest/browser';