@sima-land/isomorph 9.0.7 → 11.0.0-alpha.0

package/src/container/application.ts

@@ -0,0 +1,91 @@
+/* eslint-disable require-jsdoc, jsdoc/require-jsdoc */
+import type { Container, Provider, Resolve, Token } from './types';
+import type { Preset } from '../preset/types';
+import { createContainer, createToken, NothingBoundError } from '.';
+
+type ExtractType<T extends readonly Token<any>[]> = {
+  [index in keyof T]: T[index] extends T[number] ? ReturnType<T[index]['_resolve']> : never;
+};
+
+interface Binding<T> {
+  toValue: (value: T) => void;
+  toProvider: (provider: Provider<T>) => void;
+}
+
+export class Application {
+  private container?: Container;
+  private parent?: Application;
+  private presets: Preset[];
+  private providers: Map<Token<any>, Provider<any>>;
+
+  static readonly self = createToken('application/self');
+
+  constructor() {
+    this.providers = new Map();
+    this.presets = [];
+  }
+
+  bind<T>(token: Token<T>): Binding<T> {
+    return {
+      toValue: value => {
+        this.providers.set(token, () => value);
+      },
+      toProvider: provider => {
+        this.providers.set(token, provider);
+      },
+    };
+  }
+
+  get<T>(token: Token<T>): T {
+    try {
+      return this.getContainer().get(token);
+    } catch (error) {
+      if (error instanceof NothingBoundError && this.parent) {
+        return this.parent.get(token);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  private getContainer(): Container {
+    if (!this.container) {
+      this.container = this.configureContainer();
+    }
+
+    return this.container;
+  }
+
+  private configureContainer(): Container {
+    const container = createContainer();
+
+    container.set(Application.self, () => this);
+
+    for (const preset of this.presets) {
+      preset.apply(this);
+    }
+
+    const resolve: Resolve = token => this.get(token);
+
+    for (const [token, provider] of this.providers) {
+      container.set(token, () => provider(resolve));
+    }
+
+    return container;
+  }
+
+  attach(parent: Application): void {
+    this.parent = parent;
+  }
+
+  preset(preset: Preset): void {
+    this.presets.push(preset);
+  }
+
+  invoke<Tokens extends readonly Token<any>[]>(
+    tokens: [...Tokens],
+    fn: (...args: ExtractType<Tokens>) => void,
+  ): void {
+    fn(...(tokens.map(token => this.get(token)) as any));
+  }
+}

package/src/container/index.ts

@@ -0,0 +1,79 @@
+/* eslint-disable require-jsdoc, jsdoc/require-jsdoc */
+import type { Container, Provider, Token } from './types';
+
+/**
+ * Возвращает новый токен.
+ * @param name Имя токена для отладки в случае ошибок.
+ * @return Токен.
+ */
+export function createToken<T = never>(name?: string): Token<T> {
+  const key = Symbol(name);
+
+  return {
+    _key: key,
+    _resolve: (registry: Map<symbol, any>) => registry.get(key) as T,
+  };
+}
+
+export class NothingBoundError extends Error {
+  constructor(key: symbol) {
+    super(`Nothing bound to ${String(key)}`);
+    this.name = 'NothingBoundError';
+  }
+}
+
+export class CircularDependencyError extends Error {
+  constructor(trace: Token<any>[]) {
+    const names = trace.map(token => String(token._key)).join(' >> ');
+    super(`Circular dependency found, trace: ${names}`);
+    this.name = 'CircularDependencyError';
+  }
+}
+
+/**
+ * Возвращает новый DI-контейнер.
+ * @return DI-контейнер.
+ */
+export function createContainer(): Container {
+  const cache = new Map<symbol, any>();
+  const registry = new Map<symbol, Provider<any>>();
+
+  function resolve<T>(token: Token<T>, chain: Token<any>[]): T {
+    if (chain.includes(token)) {
+      throw new CircularDependencyError([...chain, token]);
+    } else {
+      chain.push(token);
+    }
+
+    if (cache.has(token._key)) {
+      return cache.get(token._key);
+    } else if (registry.has(token._key)) {
+      const provider = registry.get(token._key);
+
+      if (typeof provider !== 'function') {
+        throw new Error('Provider is not a function');
+      }
+
+      const value = provider(otherToken => resolve(otherToken, chain));
+
+      // всегда как singleton
+      cache.set(token._key, value);
+
+      return value;
+    } else {
+      throw new NothingBoundError(token._key);
+    }
+  }
+
+  const container = {
+    set<T>(token: Token<T>, provider: Provider<T>): void {
+      registry.set(token._key, provider);
+    },
+
+    get<T>(token: Token<T>): T {
+      return resolve(token, []);
+    },
+  };
+
+  return container;
+}

package/src/container/types.ts

@@ -0,0 +1,17 @@
+export interface Token<T> {
+  readonly _key: symbol;
+  readonly _resolve: (registry: Map<symbol, any>) => T;
+}
+
+export interface Resolve {
+  <T>(token: Token<T>): T;
+}
+
+export interface Provider<T> {
+  (resolve: Resolve): T;
+}
+
+export interface Container {
+  set: <T = never>(token: Token<T>, provider: Provider<T>) => void;
+  get: Resolve;
+}

package/src/error-tracker/browser.ts

@@ -0,0 +1,14 @@
+import type { SentryLib } from './types';
+import * as Sentry from '@sentry/browser';
+
+/**
+ * Возвращает новый набор из клиента Sentry и функций из пакета Sentry.
+ * @param options Опции создания клиента.
+ * @return Новый набор из клиента Sentry и функций из пакета Sentry.
+ */
+export function createSentryLib(options: Sentry.BrowserOptions): SentryLib {
+  return {
+    client: new Sentry.BrowserClient(options),
+    withScope: Sentry.withScope,
+  };
+}

package/src/error-tracker/node.ts

@@ -0,0 +1,14 @@
+import type { SentryLib } from './types';
+import * as Sentry from '@sentry/node';
+
+/**
+ * Возвращает новый набор из клиента Sentry и функций из пакета Sentry.
+ * @param options Опции создания клиента.
+ * @return Новый набор из клиента Sentry и функций из пакета Sentry.
+ */
+export function createSentryLib(options: Sentry.NodeOptions): SentryLib {
+  return {
+    client: new Sentry.NodeClient(options),
+    withScope: Sentry.withScope,
+  };
+}

package/src/error-tracker/types.ts

@@ -0,0 +1,22 @@
+import type { Client, Severity, Context, Extra } from '@sentry/types';
+import type { withScope as withScopeBrowser } from '@sentry/browser';
+import type { withScope as withScopeNode } from '@sentry/node';
+
+export interface SentryLib {
+  client: Client;
+  withScope: typeof withScopeBrowser | typeof withScopeNode;
+}
+
+export interface SentryErrorData {
+  level?: Severity;
+
+  context?: {
+    key: string;
+    data: Context | null;
+  };
+
+  extra?: {
+    key: string;
+    data: Extra | null;
+  };
+}

package/src/error-tracker/utils.ts

@@ -0,0 +1,18 @@
+import { SentryErrorData } from './types';
+
+/**
+ * Ошибка с данными для Sentry.
+ */
+export class SentryError extends Error {
+  data: SentryErrorData;
+
+  /**
+   * @param message Сообщение.
+   * @param data Данные.
+   */
+  constructor(message: string, data: SentryErrorData = {}) {
+    super(message);
+    this.data = data;
+    this.name = 'SentryError';
+  }
+}

package/src/http-client/middleware/cookie.ts

@@ -0,0 +1,73 @@
+import type { Request, Response } from 'express';
+import type { Middleware } from 'middleware-axios';
+
+export interface CookieStore {
+  set: (seCookie: string[]) => void;
+  asHeader: () => string;
+}
+
+/**
+ * Возвращает новый middleware для работы с cookie на сервере.
+ * @param request Входящий запрос.
+ * @param response Исходящий ответ.
+ * @return Middleware.
+ */
+export function collectCookieMiddleware(request: Request, response: Response): Middleware<any> {
+  const store = createCookieStore(request.get('cookie'));
+
+  return async function (config, next) {
+    const result = await next({
+      ...config,
+      headers: {
+        ...config.headers,
+        Cookie: store.asHeader(),
+      },
+    });
+
+    if (result.headers['set-cookie']) {
+      store.set(result.headers['set-cookie']);
+      response.setHeader('cookie', store.asHeader());
+    }
+  };
+}
+
+/**
+ * Возвращает новое хранилище cookie.
+ * @param initialCookie Начальное значение cookie.
+ * @return Хранилище cookie.
+ */
+export function createCookieStore(initialCookie?: string): CookieStore {
+  const data: Record<string, { name: string; value: string }> = {};
+
+  // eslint-disable-next-line require-jsdoc, jsdoc/require-jsdoc
+  function setItem(cookieItem: string) {
+    const [cookieName, cookieValue] = cookieItem.split('=').map(item => item.trim());
+
+    if (cookieName && cookieValue) {
+      data[cookieName] = { name: cookieName, value: cookieValue };
+    }
+  }
+
+  if (initialCookie && initialCookie.length) {
+    for (const item of initialCookie.split(';')) {
+      setItem(item);
+    }
+  }
+
+  // eslint-disable-next-line require-jsdoc, jsdoc/require-jsdoc
+  function set(setCookieHeaderValues: string[]): void {
+    for (const item of setCookieHeaderValues) {
+      const [cookie] = item.split(';');
+      setItem(cookie);
+    }
+  }
+
+  // eslint-disable-next-line require-jsdoc, jsdoc/require-jsdoc
+  function asHeader(): string {
+    return Object.values(data)
+      .map(cookie => `${cookie.name}=${cookie.value}`)
+      .join(';');
+  }
+
+  return { set, asHeader };
+}

package/src/{helpers/api/middlewares/trace-request-middleware.ts → http-client/middleware/tracing.ts}

@@ -1,45 +1,42 @@
-import type { AxiosRequestConfig } from 'axios';
+import type { AxiosDefaults, AxiosRequestConfig } from 'axios';
 import type { Middleware } from 'middleware-axios';
-import { Tracer, Tags, FORMAT_HTTP_HEADERS, SpanContext } from 'opentracing';
+import { Context, Tracer, SpanStatusCode } from '@opentelemetry/api';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
 
 /**
- * Создаёт middleware для трассировки запросов в API.
- * @param options Параметры для создания middleware.
- * @param options.tracer Объект трейсера.
- * @param options.context Объект родительского контекста.
- * @return Middleware для трассировки запросов в API.
+ * Возвращает новый middleware для трассировки исходящих запросов.
+ * @param tracer Трейсер.
+ * @param rootContext Контекст.
+ * @return Middleware.
  */
-const createTraceRequestMiddleware = ({ tracer, context }: {
-  tracer: Tracer;
-  context: SpanContext;
-}): Middleware<any> => async function (config, next, defaults) {
+export function tracingMiddleware(tracer: Tracer, rootContext: Context): Middleware<any> {
+  return async function (config, next, defaults) {
     const { method, url, foundId } = getRequestInfo(config, defaults);
+    const span = tracer.startSpan(`HTTP ${method} ${url}`, undefined, rootContext);
 
-    const span = tracer.startSpan(`HTTP ${method} ${url}`, {
-      childOf: context,
-    });
-
-    if (!config.headers) {
-      config.headers = {};
-    }
-
-    span.addTags({
-      [Tags.HTTP_URL]: url,
-      [Tags.HTTP_METHOD]: method,
-      'request.params': { ...config.params },
-      'request.headers': { ...config.headers },
+    span.setAttributes({
+      [SemanticAttributes.HTTP_URL]: url,
+      [SemanticAttributes.HTTP_METHOD]: method,
 
       // если нашли id - добавляем в теги
       ...(foundId && { 'request.id': foundId }),
     });
 
-    tracer.inject(span, FORMAT_HTTP_HEADERS, config.headers);
+    try {
+      await next(config);
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: 'HTTP Request failed',
+      });
 
-    const response = await next(config);
+      // не прячем ошибку
+      throw error;
+    }
 
-    span.setTag(Tags.HTTP_STATUS_CODE, response.status);
-    span.finish();
+    span.end();
   };
+}
 
 /**
  * Формирует базовые данные запроса.
@@ -48,9 +45,9 @@ const createTraceRequestMiddleware = ({ tracer, context }: {
  * @param defaults Базовый конфиг экземпляра Axios.
  * @return Базовые данные запроса.
  */
-const getRequestInfo = (
+export const getRequestInfo = (
   config: AxiosRequestConfig,
-  defaults: AxiosRequestConfig
+  defaults: AxiosDefaults,
 ): {
   method: string;
   url: string;
@@ -78,9 +75,5 @@ const getRequestInfo = (
 export const hideFirstId = (url: string): [string, number | undefined] => {
   const found = /\d{2,}/.exec(url);
 
-  return found
-    ? [url.replace(found[0], '{id}'), Number(found[0])]
-    : [url, undefined];
+  return found ? [url.replace(found[0], '{id}'), Number(found[0])] : [url, undefined];
 };
-
-export default createTraceRequestMiddleware;

package/src/http-client/types.ts

@@ -0,0 +1,8 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { AxiosInstanceWrapper } from 'middleware-axios';
+
+export type HttpClient = AxiosInstanceWrapper;
+
+export interface HttpClientFactory {
+  (config: AxiosRequestConfig): HttpClient;
+}

package/src/http-client/utils.ts

@@ -0,0 +1,76 @@
+import { getServiceHeaders, getXClientIp } from '../http-server/utils';
+import type { Request } from 'express';
+import type { BaseConfig } from '../config/types';
+import type { AxiosInstance } from 'axios';
+import type { AxiosInstanceWrapper, MethodName } from 'middleware-axios';
+
+// @todo передавать заголовки
+export type SauceResponse<T = any> =
+  | {
+      ok: true;
+      data: T;
+    }
+  | {
+      ok: false;
+      error: any;
+    };
+
+export interface SauceMethod<K extends MethodName> {
+  <T>(...args: Parameters<AxiosInstanceWrapper[K]>): Promise<SauceResponse<T>>;
+}
+
+export interface Sauce {
+  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 {
+  // eslint-disable-next-line require-jsdoc, jsdoc/require-jsdoc
+  function createMethod<Key extends MethodName>(methodName: Key) {
+    return async function <Data = any>(
+      ...args: Parameters<AxiosInstance[Key]>
+    ): Promise<SauceResponse<Data>> {
+      try {
+        const response = await instance[methodName](...(args as [any]));
+        return { ok: true, data: response.data };
+      } catch (error) {
+        return { ok: false, error };
+      }
+    };
+  }
+
+  return {
+    get: createMethod('get'),
+    delete: createMethod('delete'),
+    head: createMethod('head'),
+    options: createMethod('options'),
+    post: createMethod('post'),
+    put: createMethod('put'),
+    patch: createMethod('patch'),
+  };
+}
+
+/**
+ * Формирует заголовки для исходящих запросов с сервера по соглашению.
+ * @param config Конфиг.
+ * @param request Входящий запрос.
+ * @return Заголовки для исходящих запросов.
+ */
+export function getRequestHeaders(config: BaseConfig, request: Request): Record<string, string> {
+  return {
+    'X-Client-Ip': getXClientIp(request),
+    'User-Agent': `simaland-${config.appName}/${config.appVersion}`,
+    Cookie: request.get('cookie') || '',
+    ...getServiceHeaders(request),
+  };
+}

package/src/http-server/constants.ts

@@ -0,0 +1,4 @@
+export const RESPONSE_EVENT = {
+  renderStart: Symbol('render:start'),
+  renderFinish: Symbol('render:finish'),
+} as const;

package/src/http-server/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/http-server/middleware/logging.ts

@@ -0,0 +1,34 @@
+import type { Handler } from 'express';
+import type { BaseConfig } from '../../config/types';
+import type { Logger, ConventionalFluentInfo } from '../../logger/types';
+import { getXClientIp } from '../utils';
+import { toMilliseconds } from '../../utils/number';
+
+/**
+ * Возвращает новый middleware для логирования запросов.
+ * @param config Конфиг.
+ * @param logger Logger.
+ * @return Middleware.
+ */
+export function loggingMiddleware(config: BaseConfig, logger: Logger): Handler {
+  return function (req, res, next) {
+    const start = process.hrtime.bigint();
+
+    res.once('finish', () => {
+      const finish = process.hrtime.bigint();
+
+      const message: ConventionalFluentInfo = {
+        version: config.appVersion,
+        route: req.originalUrl,
+        method: req.method,
+        status: res.statusCode,
+        remote_ip: getXClientIp(req),
+        latency: toMilliseconds(finish - start),
+      };
+
+      logger.info(message);
+    });
+
+    next();
+  };
+}

package/src/http-server/middleware/metrics.ts

@@ -0,0 +1,87 @@
+import type { Request, Response, Handler } from 'express';
+import type { BaseConfig } from '../../config/types';
+import * as PromClient from 'prom-client';
+import { toMilliseconds } from '../../utils/number';
+import { RESPONSE_EVENT } from '../constants';
+import { ConventionalLabels } from '../../metrics/constants';
+
+/**
+ * Возвращает новый middleware для формирования метрик входящего запроса.
+ * @param config Конфиг.
+ * @param metrics Метрики - счетчик запросов и гистограмма длительности ответа.
+ * @return Middleware.
+ */
+export function responseMetricsMiddleware(
+  config: BaseConfig,
+  metrics: {
+    counter: PromClient.Counter<typeof ConventionalLabels.HTTP_RESPONSE[number]>;
+    histogram: PromClient.Histogram<typeof ConventionalLabels.HTTP_RESPONSE[number]>;
+  },
+): Handler {
+  // eslint-disable-next-line require-jsdoc, jsdoc/require-jsdoc
+  function resolveLabels(
+    req: Request,
+    res: Response,
+  ): Record<typeof ConventionalLabels.HTTP_RESPONSE[number], string | number> {
+    return {
+      version: config.appVersion,
+      route: req.baseUrl + req.path,
+      code: res.statusCode,
+      method: req.method,
+    };
+  }
+
+  return (req, res, next) => {
+    const start = process.hrtime.bigint();
+
+    metrics.counter.inc(resolveLabels(req, res), 1);
+
+    res.once('finish', () => {
+      const finish = process.hrtime.bigint();
+
+      metrics.histogram.observe(resolveLabels(req, res), toMilliseconds(finish - start));
+    });
+
+    next();
+  };
+}
+
+/**
+ * Возвращает новый middleware для формирования метрик рендеринга верстки.
+ * @param config Конфиг.
+ * @param metrics Метрики - гистограмма длительности рендеринга.
+ * @return Middleware.
+ */
+export function renderMetricsMiddleware(
+  config: BaseConfig,
+  metrics: {
+    histogram: PromClient.Histogram<typeof ConventionalLabels.SSR[number]>;
+  },
+): Handler {
+  return (req, res, next) => {
+    let start: bigint | undefined;
+
+    res.once(RESPONSE_EVENT.renderStart, () => {
+      start = process.hrtime.bigint();
+    });
+
+    res.once(RESPONSE_EVENT.renderFinish, () => {
+      if (typeof start !== 'bigint') {
+        throw Error('Looks like "render start" event not emitted');
+      }
+
+      const finish = process.hrtime.bigint();
+
+      metrics.histogram.observe(
+        {
+          version: config.appVersion,
+          method: req.method,
+          route: req.baseUrl + req.path,
+        },
+        toMilliseconds(finish - start),
+      );
+    });
+
+    next();
+  };
+}