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

package/src/preset/node/node/utils/http-client/__test__/index.test.ts

@@ -0,0 +1,232 @@
+import { Context } from '@opentelemetry/api';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { Span, Tracer } from '@opentelemetry/sdk-trace-base';
+import { tracingMiddleware, getRequestInfo, hideFirstId, getRequestHeaders } from '..';
+import { BaseConfig } from '../../../../../../config';
+import { Request } from 'express';
+
+describe('tracingMiddleware', () => {
+  it('should handle success response', async () => {
+    let currentSpan: Span = null as any;
+
+    const tracer: Tracer = {
+      startSpan: jest.fn(() => {
+        const span: Span = {
+          setAttributes: jest.fn(),
+          setStatus: jest.fn(),
+          end: jest.fn(),
+        } as any;
+
+        currentSpan = span;
+
+        return span;
+      }),
+    } as any;
+
+    const context: Context = {} as any;
+
+    const middleware = tracingMiddleware(tracer, context);
+
+    expect(currentSpan).toBe(null);
+
+    const config = { url: '/api/v3/something' };
+    const next = () => Promise.resolve<any>({ ok: true, data: {} });
+    const defaults = { baseURL: 'https://www.test.com/', headers: {} as any };
+    await middleware(config, next, defaults);
+
+    expect(currentSpan.setAttributes).toBeCalledTimes(1);
+    expect(currentSpan.end).toBeCalledTimes(1);
+    expect(currentSpan.setStatus).toBeCalledTimes(0);
+  });
+
+  it('should handle failure response', async () => {
+    let currentSpan: Span = null as any;
+
+    const tracer: Tracer = {
+      startSpan: jest.fn(() => {
+        const span: Span = {
+          setAttributes: jest.fn(),
+          setStatus: jest.fn(),
+          end: jest.fn(),
+        } as any;
+
+        currentSpan = span;
+
+        return span;
+      }),
+    } as any;
+
+    const context: Context = {} as any;
+
+    const middleware = tracingMiddleware(tracer, context);
+
+    expect(currentSpan).toBe(null);
+
+    const config = { url: '/api/v3/12341241/something' };
+    const next = () => Promise.reject<any>({ ok: false, data: {} });
+    const defaults = { baseURL: 'https://www.test.com/', headers: {} as any };
+
+    await middleware(config, next, defaults).catch(() => Promise.resolve());
+
+    expect(currentSpan.setAttributes).toBeCalledTimes(1);
+    expect(currentSpan.setAttributes).toBeCalledWith({
+      [SemanticAttributes.HTTP_URL]: 'https://www.test.com/api/v3/{id}/something',
+      [SemanticAttributes.HTTP_METHOD]: 'GET',
+      'request.params': JSON.stringify({}),
+      'request.headers': JSON.stringify({}),
+      'request.id': 12341241,
+    });
+    expect(currentSpan.end).toBeCalledTimes(1);
+    expect(currentSpan.setStatus).toBeCalledTimes(1);
+  });
+});
+
+describe('getRequestInfo', () => {
+  it('should properly merge baseURL with url', () => {
+    const cases: Array<{ url: string; baseURL: string; expectedUrl: string }> = [
+      // baseURL и url
+      {
+        baseURL: 'https://www.base.com/',
+        url: '/user/current',
+        expectedUrl: 'https://www.base.com/user/current',
+      },
+      {
+        baseURL: 'https://www.base.com',
+        url: 'user/current',
+        expectedUrl: 'https://www.base.com/user/current',
+      },
+      {
+        baseURL: 'https://www.base.com',
+        url: '/user/current',
+        expectedUrl: 'https://www.base.com/user/current',
+      },
+      {
+        baseURL: 'https://www.base.com/',
+        url: 'admin/all',
+        expectedUrl: 'https://www.base.com/admin/all',
+      },
+
+      // только baseURL
+      {
+        baseURL: 'www.test.com',
+        url: '',
+        expectedUrl: 'www.test.com',
+      },
+      {
+        baseURL: 'www.test.com/',
+        url: '',
+        expectedUrl: 'www.test.com/',
+      },
+
+      // только url
+      {
+        baseURL: '',
+        url: '/hello/world',
+        expectedUrl: '/hello/world',
+      },
+      {
+        baseURL: '',
+        url: 'some/path',
+        expectedUrl: 'some/path',
+      },
+
+      // ничего
+      {
+        baseURL: '',
+        url: '',
+        expectedUrl: '[empty]',
+      },
+    ];
+
+    for (const { baseURL, url, expectedUrl } of cases) {
+      expect(getRequestInfo({ url }, { baseURL, headers: null as any }).url).toBe(expectedUrl);
+    }
+  });
+});
+
+describe('hideFirstId', () => {
+  const cases = [
+    {
+      input: '/api/v2/something/123456/some-bff/123456',
+      output: ['/api/v2/something/{id}/some-bff/123456', 123456],
+    },
+    {
+      input: '/api/v2/something/222/some-bff/333',
+      output: ['/api/v2/something/{id}/some-bff/333', 222],
+    },
+    {
+      input: '/api/v2/something/45320/some-bff',
+      output: ['/api/v2/something/{id}/some-bff', 45320],
+    },
+  ];
+
+  it('should replace first id only', () => {
+    cases.forEach(({ input, output }) => {
+      expect(hideFirstId(input)).toEqual(output);
+    });
+  });
+});
+
+describe('getRequestHeaders', () => {
+  it('should return headers', () => {
+    const config: BaseConfig = {
+      appName: 'foo',
+      appVersion: '0.0.1',
+      env: 'test',
+    };
+
+    const request: Request = {
+      socket: {
+        remoteAddress: '127.0.0.1',
+      },
+      headers: {
+        cookie: 'userid=12345',
+        'simaland-a': 'aaa',
+        'simaland-b': 'bbb',
+      },
+      get(key: string) {
+        return this.headers[key];
+      },
+      header(key: string) {
+        return this.headers[key];
+      },
+    } as any;
+
+    const result = getRequestHeaders(config, request);
+
+    expect(result).toEqual({
+      'X-Client-Ip': '127.0.0.1',
+      'User-Agent': `simaland-foo/0.0.1`,
+      Cookie: 'userid=12345',
+      'simaland-a': 'aaa',
+      'simaland-b': 'bbb',
+    });
+  });
+
+  it('should return headers when lot of data is undefined', () => {
+    const config: BaseConfig = {
+      appName: 'foo',
+      appVersion: '0.0.1',
+      env: 'test',
+    };
+
+    const request: Request = {
+      socket: {
+        remoteAddress: undefined,
+      },
+      headers: {},
+      get(key: string) {
+        return this.headers[key];
+      },
+      header(key: string) {
+        return this.headers[key];
+      },
+    } as any;
+
+    const result = getRequestHeaders(config, request);
+
+    expect(result).toEqual({
+      'User-Agent': `simaland-foo/0.0.1`,
+    });
+  });
+});

package/src/preset/node/node/utils/http-client/index.ts

@@ -0,0 +1,129 @@
+import type { AxiosDefaults, AxiosRequestConfig } from 'axios';
+import type { Middleware } from 'middleware-axios';
+import { Context, Tracer, SpanStatusCode } from '@opentelemetry/api';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { BaseConfig } from '../../../../../config';
+import { Request } from 'express';
+import { getClientIp } from '../http-server';
+import { displayUrl } from '../../../../isomorphic/utils';
+
+/**
+ * Возвращает новый middleware для трассировки исходящих запросов.
+ * @param tracer Трейсер.
+ * @param rootContext Контекст.
+ * @return Middleware.
+ */
+export function tracingMiddleware(tracer: Tracer, rootContext: Context): Middleware<any> {
+  return async function trace(config, next, defaults) {
+    const { method, url, foundId } = getRequestInfo(config, defaults);
+    const span = tracer.startSpan(`HTTP ${method} ${url}`, undefined, rootContext);
+
+    span.setAttributes({
+      [SemanticAttributes.HTTP_URL]: url,
+      [SemanticAttributes.HTTP_METHOD]: method,
+      'request.params': JSON.stringify({
+        ...defaults.params,
+        ...config.params,
+      }),
+      'request.headers': JSON.stringify({
+        ...defaults.headers[method.toLowerCase() as 'get'],
+        ...config.headers,
+      }),
+
+      // если нашли id - добавляем в теги
+      ...(foundId && { 'request.id': foundId }),
+    });
+
+    try {
+      await next(config);
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: 'HTTP Request failed',
+      });
+
+      span.end();
+
+      // не прячем ошибку
+      throw error;
+    }
+
+    span.end();
+  };
+}
+
+/**
+ * Формирует базовые данные запроса.
+ * Заменяет первое найденное число в url на "{id}", возвращая его в результате.
+ * @param config Axios-конфиг запроса.
+ * @param defaults Базовый конфиг экземпляра Axios.
+ * @return Базовые данные запроса.
+ */
+export function getRequestInfo(
+  config: AxiosRequestConfig,
+  defaults: AxiosDefaults,
+): {
+  method: string;
+  url: string;
+  foundId?: number;
+} {
+  const method = (config.method || 'GET').toUpperCase();
+  const baseURL = config.baseURL || defaults.baseURL || '';
+
+  // ВАЖНО: абстрагируем id только в url игнорируя baseURL
+  const [url, foundId] = hideFirstId(config.url || defaults.url || '');
+
+  return {
+    method,
+    url: displayUrl(baseURL, url),
+    foundId,
+  };
+}
+
+/**
+ * Преобразует строку вида:
+ * "/api/v2/something/123456/some-bff/123456"
+ * в строку вида:
+ * "/api/v2/something/{id}/some-bff/123456"
+ * и возвращает кортеж с этой строкой и вырезанным числом в случае если оно найдено.
+ * @param url Url.
+ * @return Кортеж со строкой и результатом поиска числа.
+ */
+export function hideFirstId(url: string): [string, number | undefined] {
+  const found = /\d{2,}/.exec(url);
+
+  return found ? [url.replace(found[0], '{id}'), Number(found[0])] : [url, undefined];
+}
+
+/**
+ * Формирует заголовки для исходящих запросов с сервера по соглашению.
+ * @param config Конфиг.
+ * @param request Входящий запрос.
+ * @return Заголовки для исходящих запросов.
+ */
+export function getRequestHeaders(config: BaseConfig, request: Request): Record<string, string> {
+  const result: Record<string, string> = {
+    'User-Agent': `simaland-${config.appName}/${config.appVersion}`,
+  };
+
+  const clientIp = getClientIp(request);
+  if (clientIp) {
+    result['X-Client-Ip'] = clientIp;
+  }
+
+  const cookie = request.get('cookie');
+  if (cookie) {
+    result.Cookie = cookie;
+  }
+
+  // добавляем специфичные заголовки
+  for (const key of Object.keys(request.headers)) {
+    const value = request.header(key);
+
+    if (key.toLowerCase().indexOf('simaland-') === 0 && value) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}

package/src/preset/node/node/utils/http-server/index.ts

@@ -0,0 +1,17 @@
+import type { Request } from 'express';
+import net from 'node:net';
+
+/**
+ * Определяет IP входящего запроса.
+ * @param request Входящий запрос.
+ * @return IP.
+ */
+export function getClientIp(request: Request): string | undefined {
+  const headerValue =
+    request.get('x-client-ip') ||
+    request.get('x-forwarded-for') ||
+    request.socket.remoteAddress ||
+    '';
+
+  return net.isIP(headerValue) ? headerValue : undefined;
+}

package/src/preset/node/node/utils/index.ts

@@ -0,0 +1,2 @@
+export { tracingMiddleware } from './http-client';
+export { getClientIp } from './http-server';

package/src/preset/web/index.ts

@@ -0,0 +1,40 @@
+import { createPreset, Preset } from '../../di';
+import { KnownToken } from '../../tokens';
+import { PresetTuner } from '../isomorphic/types';
+import {
+  provideBaseConfig,
+  provideSagaMiddleware,
+  provideHttpClientLogHandler,
+} from '../isomorphic/providers';
+import {
+  provideBridgeClientSide,
+  provideConfigSource,
+  provideHttpClientFactory,
+  provideKnownHttpApiHosts,
+  provideLogger,
+} from './providers';
+
+/**
+ * Возвращает preset с зависимостями для frontend-микросервисов в браузере.
+ * @param customize Получит функцию с помощью которой можно переопределить предустановленные провайдеры.
+ * @return Preset.
+ */
+export function PresetWeb(customize?: PresetTuner): Preset {
+  // ВАЖНО: используем .set() вместо аргумента defaults функции createPreset из-за скорости
+  const preset = createPreset();
+
+  preset.set(KnownToken.Config.source, provideConfigSource);
+  preset.set(KnownToken.Config.base, provideBaseConfig);
+  preset.set(KnownToken.logger, provideLogger);
+  preset.set(KnownToken.sagaMiddleware, provideSagaMiddleware);
+  preset.set(KnownToken.Http.Client.factory, provideHttpClientFactory);
+  preset.set(KnownToken.Http.Client.Middleware.Log.handler, provideHttpClientLogHandler);
+  preset.set(KnownToken.SsrBridge.clientSide, provideBridgeClientSide);
+  preset.set(KnownToken.Http.Api.knownHosts, provideKnownHttpApiHosts);
+
+  if (customize) {
+    customize({ override: preset.set.bind(preset) });
+  }
+
+  return preset;
+}

package/src/preset/web/providers/index.ts

@@ -0,0 +1,108 @@
+import {
+  BrowserClient,
+  Hub,
+  defaultIntegrations,
+  defaultStackParser,
+  makeFetchTransport,
+} from '@sentry/browser';
+import { ConfigSource, createConfigSource } from '../../../config';
+import { Resolve } from '../../../di';
+import { Logger, createLogger } from '../../../log';
+import { KnownToken } from '../../../tokens';
+import { createSentryHandler } from '../../../log/handler/sentry';
+import { BridgeClientSide, SsrBridge } from '../../../utils/ssr';
+import { KnownHttpApiKey, StrictMap } from '../../isomorphic/types';
+import { HttpApiHostPool, HttpStatus } from '../../isomorphic/utils';
+import { CreateAxiosDefaults } from 'axios';
+import { create } from 'middleware-axios';
+import { logMiddleware } from '../../../utils/axios';
+
+/**
+ * Провайдер источника конфигурации.
+ * @return Источник конфигурации.
+ */
+export function provideConfigSource(): ConfigSource {
+  // ВАЖНО: по умолчанию рассчитываем на process.env который предоставляется сборщиком (например webpack)
+  if (typeof process !== 'undefined' && process.env) {
+    return createConfigSource(process.env);
+  }
+
+  return createConfigSource({});
+}
+
+/**
+ * Провайдер Logger'а.
+ * @param resolve Функция для получения зависимости по токену.
+ * @return Logger.
+ */
+export function provideLogger(resolve: Resolve): Logger {
+  const source = resolve(KnownToken.Config.source);
+
+  const client = new BrowserClient({
+    transport: makeFetchTransport,
+    stackParser: defaultStackParser,
+    dsn: source.require('PUBLIC_SENTRY_DSN'),
+    release: source.require('SENTRY_RELEASE'),
+    environment: source.require('PUBLIC_SENTRY_ENVIRONMENT'),
+    integrations: [...defaultIntegrations],
+  });
+
+  const hub = new Hub(client);
+
+  hub.setTag('url', window.location.href);
+
+  const logger = createLogger();
+
+  logger.subscribe(createSentryHandler(hub));
+
+  return logger;
+}
+
+/**
+ * Провайдер клиентской части "моста" для передачи данных между сервером и клиентом.
+ * @param resolve Функция для получения зависимости по токену.
+ * @return Клиентская часть "моста".
+ */
+export function provideBridgeClientSide(resolve: Resolve): BridgeClientSide<unknown> {
+  const config = resolve(KnownToken.Config.base);
+
+  return SsrBridge.resolve(config.appName);
+}
+
+/**
+ * Провайдер известных http-хостов.
+ * @param resolve Функция для получения зависимости по токену.
+ * @return Пул известных http-хостов.
+ */
+export function provideKnownHttpApiHosts(resolve: Resolve): StrictMap<KnownHttpApiKey> {
+  const source = resolve(KnownToken.Config.source);
+
+  return new HttpApiHostPool<KnownHttpApiKey>(
+    {
+      ilium: 'PUBLIC_API_URL_ILIUM',
+      simaV3: 'PUBLIC_API_URL_SIMALAND_V3',
+      simaV4: 'PUBLIC_API_URL_SIMALAND_V4',
+      simaV6: 'PUBLIC_API_URL_SIMALAND_V6',
+    },
+    source,
+  );
+}
+
+/**
+ * Провайдер фабрики http-клиентов.
+ * @param resolve Функция для получения зависимости по токену.
+ * @return Фабрика.
+ */
+export function provideHttpClientFactory(resolve: Resolve) {
+  const logHandler = resolve(KnownToken.Http.Client.Middleware.Log.handler);
+
+  return function createHttpClient(config: CreateAxiosDefaults = {}) {
+    // @todo убрать as any
+    const client = create(config as any);
+
+    client.use(HttpStatus.axiosMiddleware());
+    client.use(logMiddleware(logHandler));
+
+    return client;
+  };
+}

package/src/tokens.ts

@@ -0,0 +1,112 @@
+import { createToken } from './di';
+
+// ВАЖНО: чтобы токенами можно было пользоваться независимо от среды исполнения - импортировать надо только типы
+import type * as express from 'express';
+import type { ConfigSource, BaseConfig } from './config/types';
+import type { Logger } from './log/types';
+import type { Cache } from './cache/types';
+import type { LogMiddlewareHandlerInit } from './utils/axios/middleware/log';
+import type { SagaExtendedMiddleware } from './utils/redux-saga';
+import type { BridgeClientSide, BridgeServerSide } from './utils/ssr';
+import type { Tracer } from '@opentelemetry/api';
+import type { BasicTracerProvider, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import type { Resource } from '@opentelemetry/resources';
+import type { ElementType, ReactNode } from 'react';
+import type {
+  HandlerContext,
+  KnownHttpApiKey,
+  PageAssets,
+  StrictMap,
+} from './preset/isomorphic/types';
+import type { SpecificExtras } from './preset/node/handler/utils';
+import type { CreateAxiosDefaults } from 'axios';
+import type { AxiosInstanceWrapper } from 'middleware-axios';
+
+export const KnownToken = {
+  // config
+  Config: {
+    source: createToken<ConfigSource>('config/source'),
+    base: createToken<BaseConfig>('config/base'),
+  },
+
+  // cache
+  cache: createToken<Cache>('cache'),
+
+  // log
+  logger: createToken<Logger>('logger'),
+
+  // saga runner
+  // @todo переименовать в Redux.Middleware.saga?
+  sagaMiddleware: createToken<SagaExtendedMiddleware>('saga-middleware'),
+
+  // tracing
+  Tracing: {
+    tracer: createToken<Tracer>('tracing/tracer'),
+    spanExporter: createToken<SpanExporter>('tracing/span-exporter'),
+    tracerProvider: createToken<BasicTracerProvider>('tracing/tracer-provider'),
+
+    // @todo перенести в KnownToken.Telemetry.Resource?
+    tracerProviderResource: createToken<Resource>('tracing/resource'),
+  },
+
+  // metrics
+  Metrics: {
+    httpApp: createToken<express.Application>('metrics/http-app'),
+  },
+
+  // http
+  Http: {
+    Api: {
+      knownHosts: createToken<StrictMap<KnownHttpApiKey>>('http/api/known-hosts'),
+    },
+
+    // @todo переименовать в Axios?
+    Client: {
+      factory:
+        createToken<(defaults?: CreateAxiosDefaults) => AxiosInstanceWrapper>('client/factory'),
+      Middleware: {
+        Log: {
+          handler: createToken<LogMiddlewareHandlerInit>('log/handler'),
+        },
+      },
+    },
+
+    // @todo переименовать в Express?
+    Server: {
+      factory: createToken<() => express.Application>('server/factory'),
+      Handlers: {
+        healthCheck: createToken<express.Handler>('handler/health-check'),
+      },
+      Middleware: {
+        request: createToken<express.Handler>('middleware/request'),
+        log: createToken<express.Handler>('middleware/log'),
+        tracing: createToken<express.Handler>('middleware/tracing'),
+        metrics: createToken<express.Handler>('middleware/metrics'),
+        error: createToken<express.ErrorRequestHandler>('middleware/error'),
+      },
+    },
+
+    // @todo переименовать в ExpressHandler?
+    Handler: {
+      main: createToken<() => void>('handler/main'),
+      context: createToken<HandlerContext>('handler/context'),
+      Request: {
+        specificParams: createToken<Record<string, unknown>>('request/specific-params'),
+      },
+      Response: {
+        specificExtras: createToken<SpecificExtras>('response/specific-extras'),
+      },
+      Page: {
+        assets: createToken<PageAssets | (() => PageAssets | Promise<PageAssets>)>('page/assets'),
+        helmet: createToken<ElementType<{ children: ReactNode }>>('page/helmet'),
+        render: createToken<() => JSX.Element | Promise<JSX.Element>>('page/render'),
+      },
+    },
+  },
+
+  // SSR
+  SsrBridge: {
+    clientSide: createToken<BridgeClientSide<unknown>>('ssr-bridge/client-side'),
+    serverSide: createToken<BridgeServerSide>('ssr-bridge/server-side'),
+  },
+} as const;

package/src/utils/axios/index.ts

@@ -0,0 +1,12 @@
+export { type Sauce, type SauceResponse, sauce, formatResultInfo } from './sauce';
+export { applyAxiosDefaults } from './utils';
+export {
+  type SharedData,
+  type DoneSharedData,
+  type FailSharedData,
+  type LogMiddlewareHandler,
+  type LogMiddlewareHandlerFactory,
+  type LogMiddlewareHandlerInit,
+  logMiddleware,
+} from './middleware/log';
+export { cookieMiddleware } from './middleware/cookie';