@sima-land/isomorph 11.0.0-alpha.35 → 11.0.0-alpha.37

package/src/utils/axios/middleware/__test__/cookie.test.ts

@@ -0,0 +1,94 @@
+import { AxiosDefaults, InternalAxiosRequestConfig } from 'axios';
+import { Next } from 'middleware-axios';
+import { cookieMiddleware } from '../cookie';
+import { createCookieStore } from '../../../../http';
+
+describe('cookieMiddleware', () => {
+  it('should set cookie to config', async () => {
+    const store = createCookieStore('hello=world');
+
+    const middleware = cookieMiddleware(store);
+
+    const config: InternalAxiosRequestConfig = {
+      method: 'get',
+      url: '/test-cookie-middleware',
+      headers: { 'test-header': 'test-value' } as any,
+    };
+    const next: Next<unknown> = jest.fn(() =>
+      Promise.resolve({
+        data: null,
+        status: 200,
+        statusText: 'OK',
+        config,
+        headers: {},
+      }),
+    );
+    const defaults: AxiosDefaults = {
+      headers: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        patch: {},
+        common: {},
+        head: {},
+      },
+    };
+
+    expect(next).toHaveBeenCalledTimes(0);
+    await middleware(config, next, defaults);
+    expect(next).toHaveBeenCalledTimes(1);
+
+    expect(next).toHaveBeenCalledWith({
+      method: 'get',
+      url: '/test-cookie-middleware',
+      headers: {
+        'test-header': 'test-value',
+        Cookie: 'hello=world',
+      },
+    });
+  });
+
+  it('should handle set-cookie header', async () => {
+    const store = createCookieStore('hello=world');
+
+    const spy = jest.fn();
+    store.subscribe(spy);
+
+    const middleware = cookieMiddleware(store);
+
+    const config: InternalAxiosRequestConfig = {
+      method: 'get',
+      url: '/test-cookie-middleware',
+      headers: { 'test-header': 'test-value' } as any,
+    };
+    const next: Next<unknown> = jest.fn(() =>
+      Promise.resolve({
+        data: null,
+        status: 200,
+        statusText: 'OK',
+        config,
+        headers: {
+          'set-cookie': ['foo=bar', 'baz=123'],
+        } as any,
+      }),
+    );
+    const defaults: AxiosDefaults = {
+      headers: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        patch: {},
+        common: {},
+        head: {},
+      },
+    };
+
+    expect(next).toHaveBeenCalledTimes(0);
+    expect(spy).toHaveBeenCalledTimes(0);
+    await middleware(config, next, defaults);
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+});

package/src/utils/axios/middleware/__test__/log.test.ts

@@ -0,0 +1,121 @@
+import { AxiosRequestConfig, AxiosDefaults, AxiosResponse } from 'axios';
+import { Next } from 'middleware-axios';
+import { logMiddleware, LogMiddlewareHandler } from '../log';
+
+function getFakeHandler(): LogMiddlewareHandler {
+  return {
+    beforeRequest: jest.fn(),
+    afterResponse: jest.fn(),
+    onCatch: jest.fn(),
+  };
+}
+
+function handlerNotUsed(handler: LogMiddlewareHandler): boolean {
+  const methods = [handler.beforeRequest, handler.afterResponse, handler.onCatch];
+
+  const callCount = methods.reduce<number>(
+    (acc, item) => acc + (item as jest.Mock).mock.calls.length,
+    0,
+  );
+
+  return callCount === 0;
+}
+
+describe('logMiddleware', () => {
+  let handler = getFakeHandler();
+
+  beforeEach(() => {
+    handler = getFakeHandler();
+  });
+
+  it('should works properly without error', async () => {
+    const config: AxiosRequestConfig<any> = {};
+
+    const defaults: AxiosDefaults<any> = {
+      headers: {} as any,
+      baseURL: 'https://sima.com/',
+    };
+
+    const response: AxiosResponse = {
+      status: 200,
+      statusText: '200',
+      data: {},
+      headers: {},
+      config: {} as any,
+    };
+
+    const next: Next<any> = jest.fn(() => Promise.resolve(response));
+
+    const middleware = logMiddleware(handler);
+
+    expect(handlerNotUsed(handler)).toBe(true);
+
+    await middleware(config, next, defaults);
+
+    expect(handler.beforeRequest).toBeCalledTimes(1);
+    expect(handler.beforeRequest).toBeCalledWith({ config, defaults });
+    expect(handler.afterResponse).toBeCalledTimes(1);
+    expect(handler.afterResponse).toBeCalledWith({ config, defaults, response });
+    expect(handler.onCatch).toBeCalledTimes(0);
+  });
+
+  it('should works properly with error', async () => {
+    const config: AxiosRequestConfig<any> = {};
+
+    const defaults: AxiosDefaults<any> = {
+      headers: {} as any,
+      baseURL: 'https://sima.com/',
+    };
+
+    const error = new Error('Some test error');
+
+    const next: Next<any> = jest.fn(() => Promise.reject(error));
+
+    const middleware = logMiddleware(handler);
+
+    expect(handlerNotUsed(handler)).toBe(true);
+
+    await middleware(config, next, defaults).catch(() => null);
+
+    expect(handler.beforeRequest).toBeCalledTimes(1);
+    expect(handler.beforeRequest).toBeCalledWith({ config, defaults });
+    expect(handler.afterResponse).toBeCalledTimes(0);
+    expect(handler.onCatch).toBeCalledTimes(1);
+    expect(handler.onCatch).toBeCalledWith({ config, defaults, error });
+  });
+
+  it('should handle handler factory', async () => {
+    const config: AxiosRequestConfig<any> = {};
+
+    const defaults: AxiosDefaults<any> = {
+      headers: {} as any,
+      baseURL: 'https://sima.com/',
+    };
+
+    const response: AxiosResponse = {
+      status: 200,
+      statusText: '200',
+      data: {},
+      headers: {},
+      config: {} as any,
+    };
+
+    const next: Next<any> = jest.fn(() => Promise.resolve(response));
+
+    const handlerFactory = jest.fn(() => handler);
+
+    const middleware = logMiddleware(handlerFactory);
+
+    expect(handlerNotUsed(handler)).toBe(true);
+
+    await middleware(config, next, defaults);
+
+    expect(handlerFactory).toBeCalledTimes(1);
+    expect(handlerFactory).toBeCalledWith({ config, defaults });
+    expect(handler.beforeRequest).toBeCalledTimes(1);
+    expect(handler.beforeRequest).toBeCalledWith({ config, defaults });
+    expect(handler.afterResponse).toBeCalledTimes(1);
+    expect(handler.afterResponse).toBeCalledWith({ config, defaults, response });
+    expect(handler.onCatch).toBeCalledTimes(0);
+  });
+});

package/src/utils/axios/middleware/cookie.ts

@@ -0,0 +1,26 @@
+import type { Middleware } from 'middleware-axios';
+import type { CookieStore } from '../../../http';
+
+/**
+ * Возвращает новый middleware для работы с cookie на сервере.
+ * @param store Хранилище.
+ * @return Middleware.
+ */
+export function cookieMiddleware(store: CookieStore): Middleware<any> {
+  return async (config, next) => {
+    const result = await next({
+      ...config,
+      headers: {
+        ...config.headers,
+
+        // @todo учитывать Domain, Path, Expires и тд
+        // @todo учитывать редиректы с куками
+        Cookie: store.getCookies(),
+      },
+    });
+
+    if (result.headers['set-cookie']) {
+      result.headers['set-cookie'].forEach(item => store.setCookie(item));
+    }
+  };
+}

package/src/utils/axios/middleware/log.ts

@@ -0,0 +1,52 @@
+import { AxiosResponse, AxiosRequestConfig, AxiosDefaults } from 'axios';
+import { Middleware } from 'middleware-axios';
+
+export interface SharedData {
+  config: AxiosRequestConfig;
+  defaults: AxiosDefaults;
+}
+
+export interface DoneSharedData extends SharedData {
+  response: AxiosResponse<unknown, unknown>;
+}
+
+export interface FailSharedData extends SharedData {
+  error: unknown;
+}
+
+export interface LogMiddlewareHandler {
+  beforeRequest: (data: SharedData) => Promise<void> | void;
+  afterResponse: (data: DoneSharedData) => Promise<void> | void;
+  onCatch: (data: FailSharedData) => Promise<void> | void;
+}
+
+export interface LogMiddlewareHandlerFactory {
+  (data: SharedData): LogMiddlewareHandler;
+}
+
+export type LogMiddlewareHandlerInit = LogMiddlewareHandler | LogMiddlewareHandlerFactory;
+
+/**
+ * Возвращает новый middleware для логирования запросов.
+ * @param handlerInit Обработчик.
+ * @return Middleware.
+ */
+export function logMiddleware(handlerInit: LogMiddlewareHandlerInit): Middleware<any> {
+  return async function log(config, next, defaults) {
+    const shared: SharedData = { config, defaults };
+    const handler = typeof handlerInit === 'function' ? handlerInit(shared) : handlerInit;
+
+    try {
+      await handler.beforeRequest(shared);
+
+      const response = await next(config);
+
+      await handler.afterResponse({ ...shared, response });
+    } catch (error) {
+      await handler.onCatch({ ...shared, error });
+
+      // ВАЖНО: не скрываем ошибку, сообщаем остальному миру про нее
+      throw error;
+    }
+  };
+}

package/src/utils/axios/sauce/index.ts

@@ -0,0 +1,76 @@
+import axios, { AxiosInstance, AxiosResponse } from 'axios';
+import { safetyAsync, SafetyInfo } from '../..';
+import type { AxiosInstanceWrapper, MethodName } from 'middleware-axios';
+
+// @todo передавать заголовки ответа
+export type SauceResponse<T = any> =
+  | {
+      ok: true;
+      status: number;
+      data: T;
+    }
+  | {
+      ok: false;
+      status?: unknown; // unknown так как не факт что упали именно по статусу, например может быть exception
+      data?: unknown; // иногда хочется узнать, что прислал сервер вместе с ошибкой (например 422)
+      error: any;
+    };
+
+export interface SauceMethod<K extends MethodName | 'request'> {
+  <T>(...args: Parameters<(AxiosInstance | AxiosInstanceWrapper)[K]>): Promise<SauceResponse<T>>;
+}
+
+/**
+ * Обёртка над экземпляром axios.
+ * Все методы возвращают promise, который никогда переходят в состояние rejected.
+ */
+export interface Sauce {
+  readonly request: SauceMethod<'request'>;
+  readonly get: SauceMethod<'get'>;
+  readonly delete: SauceMethod<'delete'>;
+  readonly head: SauceMethod<'head'>;
+  readonly options: SauceMethod<'options'>;
+  readonly post: SauceMethod<'post'>;
+  readonly put: SauceMethod<'put'>;
+  readonly patch: SauceMethod<'patch'>;
+}
+
+/**
+ * Оборачивает экземпляр axios. Все методы обертки возвращают promise, которые никогда не попадают в состояние rejected.
+ * @param instance Экземпляр axios или AxiosInstanceWrapper.
+ * @return Обертка.
+ */
+export function sauce(instance: AxiosInstance | AxiosInstanceWrapper): Sauce {
+  return {
+    request: safetyAsync(instance.request, formatResultInfo),
+    get: safetyAsync(instance.get, formatResultInfo),
+    delete: safetyAsync(instance.delete, formatResultInfo),
+    head: safetyAsync(instance.head, formatResultInfo),
+    options: safetyAsync(instance.options, formatResultInfo),
+    post: safetyAsync(instance.post, formatResultInfo),
+    put: safetyAsync(instance.put, formatResultInfo),
+    patch: safetyAsync(instance.patch, formatResultInfo),
+  };
+}
+
+/**
+ * Функция форматирования результата, используемая в sauce.
+ * @param info Результат вызова метода экземпляра axios.
+ * @return Отформатированный ответ.
+ */
+export function formatResultInfo<T>(info: SafetyInfo<AxiosResponse<T>>): SauceResponse<T> {
+  if (info.ok) {
+    return {
+      ok: true,
+      data: info.result.data,
+      status: info.result.status,
+    };
+  } else {
+    return {
+      ok: false,
+      data: axios.isAxiosError(info.error) ? info.error.response?.data : undefined,
+      status: axios.isAxiosError(info.error) ? info.error.response?.status : undefined,
+      error: info.error,
+    };
+  }
+}

package/src/utils/axios/utils/__test__/index.test.ts

@@ -0,0 +1,89 @@
+import { applyAxiosDefaults } from '..';
+
+describe('applyAxiosDefaults', () => {
+  it('should merge config and defaults properly', () => {
+    const result = applyAxiosDefaults(
+      {
+        url: 'currency/',
+      },
+      {
+        baseURL: 'https://www.data.com/',
+        headers: {
+          common: {},
+          delete: {},
+          get: { bar: 'bar-value' },
+          head: {},
+          post: {},
+          put: {},
+          patch: {},
+          options: {},
+          purge: {},
+          link: {},
+          unlink: {},
+        },
+      },
+    );
+
+    expect(result.url).toBe('currency/');
+    expect(result.baseURL).toBe('https://www.data.com/');
+  });
+
+  it('should merge config and defaults properly when headers provided but method is not', () => {
+    const result = applyAxiosDefaults(
+      {
+        url: 'currency/',
+        headers: { foo: 'foo-value' },
+      },
+      {
+        baseURL: 'https://www.data.com/',
+        headers: {
+          common: {},
+          delete: {},
+          get: { bar: 'bar-value' },
+          head: {},
+          post: {},
+          put: {},
+          patch: {},
+          options: {},
+          purge: {},
+          link: {},
+          unlink: {},
+        },
+      },
+    );
+
+    expect(result.url).toBe('currency/');
+    expect(result.baseURL).toBe('https://www.data.com/');
+    expect(result.headers).toEqual({ foo: 'foo-value', bar: 'bar-value' });
+  });
+
+  it('should merge config and defaults properly when method provided', () => {
+    const result = applyAxiosDefaults(
+      {
+        method: 'post',
+        url: 'currency/',
+        headers: { foo: 'foo-value' },
+      },
+      {
+        baseURL: 'https://www.data.com/',
+        headers: {
+          common: {},
+          delete: {},
+          get: { bar: 'bar-value' },
+          head: {},
+          post: { baz: 'baz-value' },
+          put: {},
+          patch: {},
+          options: {},
+          purge: {},
+          link: {},
+          unlink: {},
+        },
+      },
+    );
+
+    expect(result.url).toBe('currency/');
+    expect(result.baseURL).toBe('https://www.data.com/');
+    expect(result.headers).toEqual({ foo: 'foo-value', baz: 'baz-value' });
+  });
+});

package/src/utils/axios/utils/index.ts

@@ -0,0 +1,26 @@
+import type { AxiosDefaults, AxiosRequestConfig } from 'axios';
+
+/**
+ * Сливает в один объект конфиг и настройки по умолчанию.
+ * @param config Конфигурация запроса.
+ * @param defaults Настройки по умолчанию для экземпляра axios.
+ * @return Уточненная итоговая конфигурация.
+ * @todo Было бы круто заменить на axios/core/mergeConfig (https://github.com/axios/axios/blob/v1.x/lib/core/mergeConfig.js).
+ */
+export function applyAxiosDefaults(
+  config: AxiosRequestConfig,
+  defaults: AxiosDefaults,
+): Omit<AxiosRequestConfig, 'method'> & Pick<Required<AxiosRequestConfig>, 'method'> {
+  const { headers: headersDefaults, ...restDefaults } = defaults;
+  const method = config.method || defaults.method || 'get';
+
+  return {
+    method,
+    ...restDefaults,
+    ...config,
+    headers: {
+      ...headersDefaults[method.toLowerCase() as keyof typeof defaults.headers],
+      ...config.headers,
+    },
+  };
+}

package/src/utils/express/handler/health-check.ts

@@ -0,0 +1,13 @@
+import type { Handler } from 'express';
+
+/**
+ * Возвращает обработчик, отвечающий данными о времени работы приложения.
+ * @return Обработчик http-запроса.
+ */
+export function healthCheck(): Handler {
+  const startTime = Date.now();
+
+  return (req, res) => {
+    res.json({ uptime: Date.now() - startTime });
+  };
+}

package/src/utils/express/index.ts

@@ -0,0 +1,2 @@
+export { healthCheck } from './handler/health-check';
+export { composeMiddleware } from './utils';

package/src/utils/express/utils/index.ts

@@ -0,0 +1,18 @@
+import type { Handler } from 'express';
+
+/**
+ * Объединяет промежуточные слои в один.
+ * @param list Промежуточные слои.
+ * @return Промежуточный слой.
+ */
+export function composeMiddleware(list: Handler[]) {
+  return list.reduce((a, b) => (req, res, next) => {
+    a(req, res, err => {
+      if (err) {
+        return next(err);
+      }
+
+      b(req, res, next);
+    });
+  });
+}

package/src/utils/function.ts

@@ -0,0 +1,57 @@
+interface SafetyDoneInfo<T> {
+  ok: true;
+  result: T;
+}
+
+interface SafetyFailInfo {
+  ok: false;
+  error: unknown;
+}
+
+export type SafetyInfo<T> = SafetyDoneInfo<T> | SafetyFailInfo;
+
+interface SafetyFormatter<T, F> {
+  (info: SafetyInfo<T>): F | Promise<F>;
+}
+
+/**
+ * Возвращает функцию, результатом которой является promise, который никогда не переходит в состояние rejected.
+ * При перехвате исключения результат будет содержать ошибку.
+ * @param fn Оборачиваемая функция.
+ * @return Функция.
+ */
+export function safetyAsync<T, P extends any[]>(
+  fn: (...args: P) => Promise<T>,
+): (...args: P) => Promise<SafetyInfo<T>>;
+
+/**
+ * Возвращает функцию, результатом которой является promise, который никогда не переходит в состояние rejected.
+ * При перехвате исключения результат будет содержать ошибку.
+ * @param fn Оборачиваемая функция.
+ * @param format Получив базовую информацию об ответе должна вернуть отформатированную информацию.
+ * @return Функция.
+ */
+export function safetyAsync<T, P extends any[], F>(
+  fn: (...args: P) => Promise<T>,
+  format: SafetyFormatter<T, F>,
+): (...args: P) => Promise<F>;
+
+/**
+ * Возвращает функцию, результатом которой является promise, который никогда не переходит в состояние rejected.
+ * При перехвате исключения результат будет содержать ошибку.
+ * @param fn Оборачиваемая функция.
+ * @param format Получив базовую информацию об ответе должна вернуть отформатированную информацию.
+ * @return Функция.
+ */
+export function safetyAsync<T, P extends any[], F>(
+  fn: (...args: P) => Promise<T>,
+  format: SafetyFormatter<T, F> = value => value as F,
+): (...args: P) => Promise<F> {
+  return async function safetyWrapper(...args: P) {
+    try {
+      return format({ ok: true, result: await fn(...args) });
+    } catch (error) {
+      return format({ ok: false, error });
+    }
+  };
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export { safetyAsync, type SafetyInfo } from './function';
+export { toMilliseconds } from './math';

package/src/utils/math.ts

@@ -0,0 +1,8 @@
+/**
+ * Переводит наносекунды в миллисекунды.
+ * @param nanoseconds Наносекунды.
+ * @return Миллисекунды.
+ */
+export function toMilliseconds(nanoseconds: bigint): number {
+  return Number(nanoseconds / 1000000n);
+}

package/src/utils/react/error-handlers/__test__/__snapshots__/index.test.tsx.snap

@@ -0,0 +1,27 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ErrorBoundary should call captureException 1`] = `<div />`;
+
+exports[`ErrorBoundary should render children component 1`] = `
+<div>
+  <div>
+    Normal component
+  </div>
+</div>
+`;
+
+exports[`ErrorBoundary should render fallback component 1`] = `
+<div>
+  <div>
+    Fallback
+  </div>
+</div>
+`;
+
+exports[`SafeSuspense should render with props 1`] = `
+<div>
+  <div>
+    Normal component
+  </div>
+</div>
+`;

package/src/utils/react/error-handlers/__test__/index.test.tsx

@@ -0,0 +1,63 @@
+import { render } from '@testing-library/react';
+import { ErrorBoundary, SafeSuspense } from '..';
+
+describe('ErrorBoundary', () => {
+  const error = new Error('Test error');
+
+  const FailedComponent = () => {
+    throw error;
+  };
+
+  it('should render children component', () => {
+    const { container } = render(
+      <ErrorBoundary fallback={null}>
+        <div>Normal component</div>
+      </ErrorBoundary>,
+    );
+
+    expect(container.textContent).toContain('Normal component');
+    expect(container).toMatchSnapshot();
+  });
+
+  it('should render fallback component', () => {
+    const { container } = render(
+      <ErrorBoundary fallback={<div>Fallback</div>}>
+        <>
+          <div>Normal component</div>
+          <FailedComponent />
+        </>
+      </ErrorBoundary>,
+    );
+
+    expect(container.textContent).toContain('Fallback');
+    expect(container).toMatchSnapshot();
+  });
+
+  it('should call captureException', () => {
+    const handlerException = jest.fn();
+
+    const { container } = render(
+      <ErrorBoundary fallback={null} onError={handlerException}>
+        <>
+          <div>Normal component</div>
+          <FailedComponent />
+        </>
+      </ErrorBoundary>,
+    );
+
+    expect(handlerException).toBeCalledWith(error, { componentStack: expect.any(String) });
+    expect(container).toMatchSnapshot();
+  });
+});
+
+describe('SafeSuspense', () => {
+  it('should render with props', () => {
+    const { container } = render(
+      <SafeSuspense fallback={<div>Fallback</div>} onError={jest.fn()}>
+        <div>Normal component</div>
+      </SafeSuspense>,
+    );
+
+    expect(container).toMatchSnapshot();
+  });
+});