@slango/ristretto 1.0.0

package/src/utils/auth.ts

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

@@ -0,0 +1,16 @@
+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;
+};
+
+// TODO: We neeed a withBaseUrl helper

package/src/utils/body.spec.ts

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

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

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

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

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

package/src/utils/request.spec.ts

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

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

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

@@ -0,0 +1,15 @@
+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/tsconfig.build.json

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