@biorate/nestjs-tools 1.127.0 → 1.128.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.128.0](https://github.com/biorate/core/compare/v1.127.0...v1.128.0) (2025-05-22)
+
+### Features
+
+- **nestjs-tools:** CRUD interfaces added ([9d9b5dc](https://github.com/biorate/core/commit/9d9b5dcdbdff20beb68799fc4fdbee61eec57d60))
+
 # [1.127.0](https://github.com/biorate/core/compare/v1.126.0...v1.127.0) (2025-05-22)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biorate/nestjs-tools",
-  "version": "1.127.0",
+  "version": "1.128.0",
   "description": "NestJS tools",
   "main": "dist",
   "scripts": {
@@ -42,5 +42,5 @@
     "http-proxy-middleware": "2.0.6",
     "on-headers": "1.0.2"
   },
-  "gitHead": "e24c2a741c423f4dd4117cedec092f7f7152e225"
+  "gitHead": "c4713de966cf9f55cac9adef4bfc3521c5368f02"
 }

package/src/app/application/index.ts

@@ -0,0 +1,2 @@
+export * from './service';
+export * from './ports';

package/src/app/application/ports/client.driven.port.ts

@@ -0,0 +1,5 @@
+export interface ClientDrivenPort {
+  getLang(lang: string, namespace: string): Record<string, string>;
+
+  setLang(data: Record<string, string>, lang: string, namespace: string): void;
+}

package/src/app/application/ports/crud.driven.port.ts

@@ -0,0 +1,60 @@
+export type CrudCreateDrivenPort<E> = {
+  create(data: E): E;
+};
+
+export type CrudFindOneDrivenPort<E, I> = {
+  findOne(id: I): E;
+};
+
+export type CrudFindManyDrivenPort<
+  E,
+  F = { offset: number; limit: number },
+  R = { total: number; offset: number; limit: number; items: E[] },
+> = {
+  findMany(filter?: F): R;
+};
+
+export type CrudUpdateOneDrivenPort<E, I, D = E> = {
+  updateOne(id: I, data: D): E;
+};
+
+export type CrudUpdateManyDrivenPort<E, C, D = E[]> = {
+  updateMany(criteria: C, data: D): E[];
+};
+
+export type CrudInsertOneDrivenPort<E> = {
+  insertOne(data: E): E;
+};
+
+export type CrudInsertManyDrivenPort<E, R = E[]> = {
+  insertOne(items: E[]): R;
+};
+
+export type CrudDeleteOneDrivenPort<I, R = boolean> = {
+  deleteOne(id: I): R;
+};
+
+export type CrudDeleteManyDrivenPort<CD, R = number> = {
+  deleteMany(criteria?: CD): R;
+};
+
+export type CrudDrivenPort<
+  Id,
+  Entity,
+  FindManyFilter,
+  InsertManyResult,
+  UpdateManyCriteria,
+  DeleteCriteria,
+  FindManyresult = Entity[],
+  UpdateData = Entity,
+  DeleteOneResult = boolean,
+  DeleteManyResult = number,
+> = CrudCreateDrivenPort<Entity> &
+  CrudFindOneDrivenPort<Entity, Id> &
+  CrudFindManyDrivenPort<Entity, FindManyFilter, FindManyresult> &
+  CrudUpdateOneDrivenPort<Entity, Id, UpdateData> &
+  CrudUpdateManyDrivenPort<Entity, UpdateManyCriteria, UpdateData[]> &
+  CrudInsertOneDrivenPort<Entity> &
+  CrudInsertManyDrivenPort<Entity, InsertManyResult> &
+  CrudDeleteOneDrivenPort<Id, DeleteOneResult> &
+  CrudDeleteManyDrivenPort<DeleteCriteria, DeleteManyResult>;

package/src/app/application/ports/index.ts

@@ -0,0 +1,3 @@
+export * from './crud.driven.port';
+export * from './metrics.driven.port';
+export * from './client.driven.port';

package/src/app/application/ports/metrics.driven.port.ts

@@ -0,0 +1,3 @@
+export interface MetricsDrivenPort {
+  get(): Promise<string>;
+}

package/src/app/application/service/client/get-locale.use-case.ts

@@ -0,0 +1,13 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Types } from '@biorate/inversion';
+import { ClientDrivenPort } from '../../ports';
+
+@Injectable()
+export class GetLocaleUseCase {
+  @Inject(Types.ClientDrivenPort)
+  protected readonly clientProvider: ClientDrivenPort;
+
+  public async execute(lang: string, namespace: string) {
+    return this.clientProvider.getLang(lang, namespace);
+  }
+}

package/src/app/application/service/client/index.ts

@@ -0,0 +1,2 @@
+export * from './get-locale.use-case';
+export * from './set-locale.use-case';

package/src/app/application/service/client/set-locale.use-case.ts

@@ -0,0 +1,13 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Types } from '@biorate/inversion';
+import { ClientDrivenPort } from '../../ports';
+
+@Injectable()
+export class SetLocaleUseCase {
+  @Inject(Types.ClientDrivenPort)
+  protected readonly clientProvider: ClientDrivenPort;
+
+  public async execute(data: Record<string, string>, lang: string, namespace: string) {
+    return this.clientProvider.setLang(data, lang, namespace);
+  }
+}

package/src/app/application/service/index.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './metrics';

package/src/app/application/service/metrics/get-metrics.use-case.ts

@@ -0,0 +1,13 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Types } from '@biorate/inversion';
+import { MetricsDrivenPort } from '../../ports';
+
+@Injectable()
+export class GetMetricsUseCase {
+  @Inject(Types.MetricsDrivenPort)
+  protected readonly metricsProvider: MetricsDrivenPort;
+
+  public async execute() {
+    return this.metricsProvider.get();
+  }
+}

package/src/app/application/service/metrics/index.ts

@@ -0,0 +1 @@
+export * from './get-metrics.use-case';

package/src/app/index.ts

@@ -0,0 +1,2 @@
+export * from './application';
+export * from './infrastructure';

package/src/app/infrastructure/adapters/client.repository.adapter.ts

@@ -0,0 +1,34 @@
+import { mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { Injectable } from '@nestjs/common';
+import { path } from '@biorate/tools';
+import { ClientDrivenPort } from '../../application';
+
+@Injectable()
+export class ClientRepositoryAdapter implements ClientDrivenPort {
+  public getLang(lang: string, namespace: string) {
+    try {
+      return JSON.parse(
+        readFileSync(
+          path.create(process.cwd(), 'locales', namespace, `${lang}.json`),
+          'utf-8',
+        ),
+      );
+    } catch {
+      return {};
+    }
+  }
+
+  public setLang(data: Record<string, string>, lang: string, namespace: string) {
+    try {
+      const directory = path.create(process.cwd(), 'locales', namespace);
+      mkdirSync(directory, { recursive: true });
+      writeFileSync(
+        path.create(directory, `${lang}.json`),
+        JSON.stringify(data, null, '  '),
+        'utf-8',
+      );
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+}

package/src/app/infrastructure/adapters/index.ts

@@ -0,0 +1,2 @@
+export * from './client.repository.adapter';
+export * from './metrics.repository.adapter';

package/src/app/infrastructure/adapters/metrics.repository.adapter.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common';
+import { inject, Types } from '@biorate/inversion';
+import { IPrometheus } from '@biorate/prometheus';
+import { MetricsDrivenPort } from '../../application';
+
+@Injectable()
+export class MetricsRepositoryAdapter implements MetricsDrivenPort {
+  @inject(Types.Prometheus) protected prometheus: IPrometheus;
+
+  public get() {
+    return this.prometheus.registry.metrics();
+  }
+}

package/src/app/infrastructure/controllers/client.controller.ts

@@ -0,0 +1,28 @@
+import { Controller, Get, Post, Param, Body, Header } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import { GetLocaleUseCase, SetLocaleUseCase } from '../../application';
+import { GetLocalesDTO, PostLocalesDTO } from './dto';
+
+@ApiTags('Client')
+@Controller('client')
+export class ClientController {
+  public constructor(
+    protected readonly getLoc: GetLocaleUseCase,
+    protected readonly setLoc: SetLocaleUseCase,
+  ) {}
+
+  @Get('locale/:lang/:namespace')
+  @ApiOperation({ summary: 'Get locale' })
+  protected getLocale(@Param() param: GetLocalesDTO) {
+    return this.getLoc.execute(param.lang, param.namespace);
+  }
+
+  @Post('locale/:lang/:namespace')
+  @ApiOperation({ summary: 'Put locale' })
+  protected async postLocale(
+    @Param() param: PostLocalesDTO,
+    @Body() body: Record<string, string>,
+  ) {
+    return this.setLoc.execute(body, param.lang, param.namespace);
+  }
+}

package/src/app/infrastructure/controllers/dto/index.ts

@@ -0,0 +1 @@
+export * from './locales';

package/src/app/infrastructure/controllers/dto/locales.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString } from 'class-validator';
+import { ILocalesDTO } from '../../../../../interfaces';
+
+export class GetLocalesDTO implements ILocalesDTO {
+  @IsString()
+  @ApiProperty({ type: String, required: true })
+  lang: string;
+
+  @IsString()
+  @ApiProperty({ type: String, required: true })
+  namespace: string;
+}
+
+export class PostLocalesDTO extends GetLocalesDTO {}

package/src/app/infrastructure/controllers/index.ts

@@ -0,0 +1,3 @@
+export * from './metrics.controller';
+export * from './client.controller';
+export * from './probe.controller';

package/src/app/infrastructure/controllers/metrics.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, Get, Header } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import { GetMetricsUseCase } from '../../application';
+
+@ApiTags('Metrics')
+@Controller('metrics')
+export class MetricsController {
+  public constructor(protected readonly getMetrics: GetMetricsUseCase) {}
+
+  @Get()
+  @Header('content-type', 'text/plain')
+  @ApiOperation({ summary: 'Prometheus metrics hook' })
+  protected async metrics() {
+    return this.getMetrics.execute();
+  }
+}

package/src/app/infrastructure/controllers/probe.controller.ts

@@ -0,0 +1,18 @@
+import { Controller, Get } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+
+@ApiTags('Probe')
+@Controller('probe')
+export class ProbeController {
+  @Get('readiness')
+  @ApiOperation({ summary: 'Readiness probe' })
+  protected readiness() {
+    return 1;
+  }
+
+  @Get('healthz')
+  @ApiOperation({ summary: 'Healthz probe' })
+  protected healthz() {
+    return 1;
+  }
+}

package/src/app/infrastructure/index.ts

@@ -0,0 +1,3 @@
+export * from './adapters';
+// export * from './controllers';
+export * as controllers from './controllers';

package/src/decorators/auth.ts

@@ -0,0 +1,9 @@
+import { UseGuards } from '@nestjs/common';
+import { ApiBasicAuth } from '@nestjs/swagger';
+import { AuthGuardProvider } from '../providers';
+
+export const AuthBasic =
+  () => (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => {
+    ApiBasicAuth()(target, propertyKey!, descriptor!);
+    UseGuards(AuthGuardProvider)(target, propertyKey!, descriptor!);
+  };

package/src/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './roles';
+export * from './auth';

package/src/decorators/roles.ts

@@ -0,0 +1,12 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const ROLES_KEY = Symbol('RolesKey');
+
+export const Roles = (...roles: number[]) =>
+  SetMetadata(
+    ROLES_KEY,
+    roles.reduce((memo, item) => {
+      memo |= item;
+      return memo;
+    }, 0),
+  );

package/src/enums/index.ts

@@ -0,0 +1 @@
+export * from './user';

package/src/enums/user.ts

@@ -0,0 +1 @@
+export { UserRoles } from '../../interfaces';

package/src/errors.ts

@@ -0,0 +1,13 @@
+import { BaseError } from '@biorate/errors';
+
+export class UnsupportedProtocolError extends BaseError {
+  public constructor(name: string) {
+    super(`Unsupported protocol: [%s]`, [name]);
+  }
+}
+
+export class AxiosRequestError extends BaseError {
+  public constructor(code: number, error: string, message: string) {
+    super(`Axios request error (%s) [%s]: %s`, [code, error, message]);
+  }
+}

package/src/filters/all-exception-filter.ts

@@ -0,0 +1,91 @@
+import { AxiosError } from '@biorate/axios';
+import { BaseError } from '@biorate/errors';
+import { WebSocket } from 'ws';
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  BadRequestException,
+} from '@nestjs/common';
+import { AxiosRequestError, UnsupportedProtocolError } from '../errors';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  public catch(exception: Error, host: ArgumentsHost) {
+    const type = host.getType();
+    const method = <`_${typeof type}`>`_${type}`;
+    if (!this[method]) throw new UnsupportedProtocolError(host.getType());
+    this[method](exception, host);
+  }
+
+  private _http(exception: Error, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const meta = (exception as BaseError)?.meta;
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : meta?.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
+    this.log(exception);
+    response.status(status).json({
+      status,
+      code: this.code(exception),
+      hint: this.hint(exception),
+      path: request.url,
+      meta: meta?.meta,
+    });
+  }
+
+  private _ws(exception: Error, host: ArgumentsHost) {
+    const ctx = host.switchToWs();
+    const socket = ctx.getClient<WebSocket>();
+    const meta = (exception as BaseError)?.meta;
+    const status = meta?.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
+    this.log(exception);
+    socket.send(
+      //TODO: add serializers factory
+      JSON.stringify({
+        event: 'error',
+        data: {
+          status,
+          code: this.code(exception),
+          hint: this.hint(exception),
+          meta: meta?.meta,
+        },
+      }),
+    );
+  }
+
+  private _rpc(exception: Error, host: ArgumentsHost) {
+    throw new UnsupportedProtocolError('rpc');
+  }
+
+  private code(exception: Error) {
+    return (<BaseError>exception).code ?? exception.constructor.name;
+  }
+
+  private hint(exception: Error) {
+    return (
+      (
+        (<BadRequestException>exception)?.getResponse?.() as {
+          message?: [string];
+        }
+      )?.message ?? (<BaseError>exception).message
+    );
+  }
+
+  protected log(exception: Error) {
+    if (exception instanceof AxiosError)
+      console.error(
+        new AxiosRequestError(
+          exception?.response?.data?.statusCode,
+          exception?.response?.data?.error,
+          exception?.response?.data?.message,
+        ),
+      );
+    else console.error(exception.stack);
+  }
+}

package/src/filters/index.ts

@@ -0,0 +1 @@
+export * from './all-exception-filter';

package/src/http/controllers/index.ts

@@ -0,0 +1,3 @@
+export * from './probe';
+export * from './metrics';
+export * from './locales';

package/src/http/controllers/locales.ts

@@ -0,0 +1,79 @@
+import { Controller, Get, Post, Param, Body, Header } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import { path } from '@biorate/tools';
+import { promises as fs, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { merge } from 'lodash';
+import { GetLocalesDTO, PostLocalesDTO } from '../dto';
+
+@ApiTags('Locales')
+@Controller('locales')
+export class LocalesController {
+  protected static async getFile(namespace: string, lang: string) {
+    try {
+      return JSON.parse(
+        await fs.readFile(
+          path.create(process.cwd(), 'locales', namespace, `${lang}.json`),
+          'utf-8',
+        ),
+      );
+    } catch {
+      return {};
+    }
+  }
+
+  protected static getFileSync(namespace: string, lang: string) {
+    try {
+      return JSON.parse(
+        readFileSync(
+          path.create(process.cwd(), 'locales', namespace, `${lang}.json`),
+          'utf-8',
+        ),
+      );
+    } catch {
+      return {};
+    }
+  }
+
+  protected static putFile(
+    namespace: string,
+    lang: string,
+    data: Record<string, string>,
+  ) {
+    try {
+      const directory = path.create(process.cwd(), 'locales', namespace);
+      mkdirSync(directory, { recursive: true });
+      writeFileSync(
+        path.create(directory, `${lang}.json`),
+        JSON.stringify(data, null, '  '),
+        'utf-8',
+      );
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+
+  @Get(':lang/:namespace')
+  @Header(
+    'Deprecation',
+    'Use domain controller instead [@biorate/nestjs-tools >= v1.121.0]',
+  )
+  @ApiOperation({ summary: 'Get locales', deprecated: true })
+  protected get(@Param() param: GetLocalesDTO) {
+    return LocalesController.getFile(param.namespace, param.lang);
+  }
+
+  @Post(':lang/:namespace')
+  @Header(
+    'Deprecation',
+    'Use domain controller instead [@biorate/nestjs-tools >= v1.121.0]',
+  )
+  @ApiOperation({ summary: 'Put locales', deprecated: true })
+  protected async post(
+    @Param() param: PostLocalesDTO,
+    @Body() body: Record<string, string>,
+  ) {
+    const data = LocalesController.getFileSync(param.namespace, param.lang);
+    const result = merge(data, body);
+    LocalesController.putFile(param.namespace, param.lang, result);
+  }
+}

package/src/http/controllers/metrics.ts

@@ -0,0 +1,21 @@
+import { inject, Types } from '@biorate/inversion';
+import { Controller, Get, Header } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import { IPrometheus } from '@biorate/prometheus';
+
+@ApiTags('Metrics')
+@Controller('metrics')
+export class MetricsController {
+  @inject(Types.Prometheus) protected prometheus: IPrometheus;
+
+  @Get()
+  @Header('content-type', 'text/plain')
+  @Header(
+    'Deprecation',
+    'Use domain controller instead [@biorate/nestjs-tools >= v1.121.0]',
+  )
+  @ApiOperation({ summary: 'Prometheus metrics hook', deprecated: true })
+  protected async metrics() {
+    return this.prometheus.registry.metrics();
+  }
+}

package/src/http/controllers/probe.ts

@@ -0,0 +1,26 @@
+import { Controller, Get, Header } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+
+@ApiTags('Probe')
+@Controller('probe')
+export class ProbeController {
+  @Get('readiness')
+  @Header(
+    'Deprecation',
+    'Use domain controller instead [@biorate/nestjs-tools >= v1.121.0]',
+  )
+  @ApiOperation({ summary: 'Readiness probe', deprecated: true })
+  protected readiness() {
+    return 1;
+  }
+
+  @Get('healthz')
+  @Header(
+    'Deprecation',
+    'Use domain controller instead [@biorate/nestjs-tools >= v1.121.0]',
+  )
+  @ApiOperation({ summary: 'Healthz probe', deprecated: true })
+  protected healthz() {
+    return 1;
+  }
+}

package/src/http/dto/index.ts

@@ -0,0 +1 @@
+export * from './locales';

package/src/http/dto/locales.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString } from 'class-validator';
+import { ILocalesDTO } from '../../../interfaces';
+
+export class GetLocalesDTO implements ILocalesDTO {
+  @IsString()
+  @ApiProperty({ type: String, required: true })
+  lang: string;
+
+  @IsString()
+  @ApiProperty({ type: String, required: true })
+  namespace: string;
+}
+
+export class PostLocalesDTO extends GetLocalesDTO {}

package/src/http/index.ts

@@ -0,0 +1,2 @@
+export * from './controllers';
+export * from './dto';

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './decorators';
+export * from './enums';
+export * from './filters';
+export * from './interceptors';
+export * from './middlewares';
+export * from './providers';
+export * from './errors';
+export * from './http';
+export * from './app';

package/src/interceptors/index.ts

@@ -0,0 +1 @@
+export * from './routes-interceptor';

package/src/interceptors/routes-interceptor.ts

@@ -0,0 +1,39 @@
+import { join, normalize } from 'path/posix';
+import { Reflector } from '@nestjs/core';
+import { PATH_METADATA } from '@nestjs/common/constants';
+import { Request } from 'express';
+import {
+  Injectable,
+  ExecutionContext,
+  CallHandler,
+  NestInterceptor,
+} from '@nestjs/common';
+
+@Injectable()
+export class RoutesInterceptor implements NestInterceptor {
+  public static readonly map = new WeakMap<Request, { path: string }>();
+
+  private readonly reflector = new Reflector();
+
+  public intercept(context: ExecutionContext, next: CallHandler) {
+    const namespaces = this.reflector.get<string | string[]>(
+      PATH_METADATA,
+      context.getClass(),
+    );
+    const routes = this.reflector.get<string | string[]>(
+      PATH_METADATA,
+      context.getHandler(),
+    );
+    RoutesInterceptor.map.set(context.switchToHttp().getRequest(), {
+      path: normalize(
+        join(
+          '/',
+          Array.isArray(namespaces) ? namespaces[0] : namespaces,
+          Array.isArray(routes) ? routes[0] : routes,
+          '/',
+        ).slice(0, -1),
+      ),
+    });
+    return next.handle();
+  }
+}

package/src/middlewares/index.ts

@@ -0,0 +1,3 @@
+export * from './proxy-middleware';
+export * from './request-count-middleware';
+export * from './response-time-middleware';

package/src/middlewares/proxy-middleware.ts

@@ -0,0 +1,69 @@
+import http from 'http';
+import type { ServerOptions } from 'http-proxy';
+import { pick, omit } from 'lodash';
+import { Request, Response } from 'express';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import { Options, RequestHandler } from 'http-proxy-middleware/dist/types';
+import { Injectable } from '@nestjs/common';
+import { counter, histogram, Counter, Histogram } from '@biorate/prometheus';
+import { time } from '@biorate/tools';
+
+@Injectable()
+export class ProxyPrometheusMiddleware {
+  @counter({
+    name: 'http_proxy_server_requests_seconds_count',
+    help: 'Http proxy server requests count',
+    labelNames: ['method', 'uri', 'status'],
+  })
+  private counter: Counter;
+
+  @histogram({
+    name: 'http_proxy_server_requests_seconds',
+    help: 'Http proxy server requests seconds bucket',
+    labelNames: ['method', 'uri', 'status'],
+    buckets: [0.005, 0.01, 0.02, 0.05, 0.1, 0.3, 0.5, 1, 2, 3, 5, 10],
+  })
+  private histogram: Histogram;
+
+  private handler: RequestHandler;
+
+  private time = new WeakMap<Request, { time: () => number }>();
+
+  public static create(options?: Options) {
+    return new this(options).handler;
+  }
+
+  private constructor(options: Options = {}) {
+    const { onProxyReq, onProxyRes } = pick(options, 'onProxyReq', 'onProxyRes');
+    this.handler = createProxyMiddleware({
+      ...omit(options, 'onProxyReq', 'onProxyRes'),
+      onProxyReq: (
+        proxyReq: http.ClientRequest,
+        req: Request,
+        res: Response,
+        options: ServerOptions,
+      ) => {
+        this.time.set(req, { time: time.diff() });
+        return onProxyReq?.(proxyReq, req, res, options);
+      },
+      onProxyRes: (proxyRes: http.IncomingMessage, req: Request, res: Response) => {
+        const diff = this.time.get(req);
+        this.counter
+          .labels({
+            method: req.method,
+            uri: req.baseUrl,
+            status: res.statusCode,
+          })
+          .inc();
+        this.histogram
+          .labels({
+            method: req.method,
+            uri: req.baseUrl,
+            status: res.statusCode,
+          })
+          .observe(time.msTo(diff!.time(), 's'));
+        return onProxyRes?.(proxyRes, req, res);
+      },
+    });
+  }
+}

package/src/middlewares/request-count-middleware.ts

@@ -0,0 +1,41 @@
+// @ts-ignore
+import * as onHeaders from 'on-headers';
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { counter, Counter } from '@biorate/prometheus';
+import { inject, Types } from '@biorate/inversion';
+import { IConfig } from '@biorate/config';
+import { Request, Response, NextFunction } from 'express';
+import { RoutesInterceptor } from '../interceptors';
+
+@Injectable()
+export class RequestCountMiddleware implements NestMiddleware {
+  @inject(Types.Config) private config: IConfig;
+
+  @counter({
+    name: 'http_server_requests_seconds_count',
+    help: 'Http server requests count',
+    labelNames: ['method', 'uri', 'status'],
+  })
+  private counter: Counter;
+
+  public use(req: Request, res: Response, next: NextFunction) {
+    onHeaders(res, () => {
+      const route = RoutesInterceptor.map.get(req);
+      this.counter
+        .labels({
+          method: req.method,
+          uri:
+            route?.path ??
+            (this.config.get<boolean>(
+              'app.middleware.RequestCountMiddleware.log-base-url',
+              false,
+            )
+              ? req.baseUrl || req.originalUrl
+              : '/'),
+          status: res.statusCode,
+        })
+        .inc();
+    });
+    next();
+  }
+}

package/src/middlewares/response-time-middleware.ts

@@ -0,0 +1,68 @@
+// @ts-ignore
+import * as onHeaders from 'on-headers';
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { inject, Types } from '@biorate/inversion';
+import { IConfig } from '@biorate/config';
+import { histogram, Histogram } from '@biorate/prometheus';
+import { Request, Response, NextFunction } from 'express';
+import { RoutesInterceptor } from '../interceptors';
+import { time } from '@biorate/tools';
+
+@Injectable()
+export class ResponseTimeMiddleware implements NestMiddleware {
+  @inject(Types.Config) private config: IConfig;
+
+  private readonly suffix: boolean;
+
+  private readonly header: string;
+
+  private readonly digits: number;
+
+  @histogram({
+    name: 'http_server_requests_seconds',
+    help: 'Http server requests seconds bucket',
+    labelNames: ['method', 'uri', 'status'],
+    buckets: [0.005, 0.01, 0.02, 0.05, 0.1, 0.3, 0.5, 1, 2, 3, 5, 10],
+  })
+  private histogram: Histogram;
+
+  public constructor() {
+    this.suffix = this.config.get<boolean>(
+      'app.middleware.ResponseTimeMiddleware.suffix',
+      true,
+    );
+    this.header = this.config.get<string>(
+      'app.middleware.ResponseTimeMiddleware.header',
+      'x-response-time',
+    );
+    this.digits = this.config.get<number>(
+      'app.middleware.ResponseTimeMiddleware.digits',
+      3,
+    );
+  }
+
+  public use(req: Request, res: Response, next: NextFunction) {
+    const diff = time.diff();
+    const msTo = time.msTo;
+    onHeaders(res, () => {
+      const time = diff();
+      const route = RoutesInterceptor.map.get(req);
+      this.histogram
+        .labels({
+          method: req.method,
+          uri:
+            route?.path ??
+            (this.config.get<boolean>(
+              'app.middleware.ResponseTimeMiddleware.log-base-url',
+              false,
+            )
+              ? req.baseUrl || req.originalUrl
+              : '/'),
+          status: res.statusCode,
+        })
+        .observe(msTo(time, 's'));
+      res.setHeader(this.header, time.toFixed(this.digits) + (this.suffix ? 'ms' : ''));
+    });
+    next();
+  }
+}

package/src/providers/auth.ts

@@ -0,0 +1,36 @@
+import { inject, Types } from '@biorate/inversion';
+import { IConfig } from '@biorate/config';
+import {
+  Injectable,
+  CanActivate,
+  ExecutionContext,
+  UnauthorizedException,
+} from '@nestjs/common';
+
+@Injectable()
+export class AuthGuardProvider implements CanActivate {
+  @inject(Types.Config) private config: IConfig;
+
+  public canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const config = this.config.get<{ [key: string]: string } | null>(
+      'app.auth.basic',
+      null,
+    );
+    if (!config) return true;
+    let username: string, password: string;
+    try {
+      [username, password] = Buffer.from(
+        request.headers.authorization.replace('Basic ', ''),
+        'base64',
+      )
+        .toString('utf-8')
+        .split(':');
+    } catch {
+      throw new UnauthorizedException();
+    }
+    if (!username || !password) throw new UnauthorizedException();
+    if (config[username] === password) return true;
+    throw new UnauthorizedException();
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,2 @@
+export * from './roles';
+export * from './auth';

package/src/providers/roles.ts

@@ -0,0 +1,34 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { ROLES_KEY } from '../decorators';
+import { UserRoles } from '../enums';
+
+@Injectable()
+export class RolesGuardProvider implements CanActivate {
+  constructor(private reflector: Reflector) {}
+  /**
+   * @description - This method for override
+   * @example
+   * ```ts
+   * const request = context.switchToHttp().getRequest();
+   * const { login, sessionId } = request.cookies;
+   * if (!login || !sessionId) throw new AuthorizationNotAuthorizedError();
+   * // get user from db, or somewhere else
+   * if (!user) throw new AuthorizationNotAuthorizedError();
+   * return user.role;
+   * ```
+   */
+  protected async getUser(context: ExecutionContext) {
+    return { role: UserRoles.Basic | UserRoles.Admin };
+  }
+
+  public async canActivate(context: ExecutionContext) {
+    const roles = this.reflector.getAllAndOverride<number>(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (roles === undefined) return true;
+    const user = await this.getUser(context);
+    return (user.role & roles) === roles;
+  }
+}