@biorate/nestjs-tools 1.169.1 → 2.0.0

package/src/http/controllers/probe.ts

@@ -1,26 +0,0 @@
-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/locales.ts

@@ -1,15 +0,0 @@
-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/interceptors/routes-interceptor.ts

@@ -1,39 +0,0 @@
-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/interceptors/tracing-interceptor.ts

@@ -1,74 +0,0 @@
-import stringify from 'json-stringify-safe';
-import { tap, catchError } from 'rxjs';
-import { trace, Span } from '@biorate/opentelemetry';
-import {
-  Injectable,
-  NestInterceptor,
-  ExecutionContext,
-  CallHandler,
-} from '@nestjs/common';
-import { inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-
-@Injectable()
-export class TracingInterceptor implements NestInterceptor {
-  @inject(Types.Config) protected readonly config: IConfig;
-
-  protected stringify(data: unknown) {
-    return typeof data === 'object' ? stringify(data) : String(data);
-  }
-
-  protected excluded(url: string) {
-    const excluded = this.config.get<(string | RegExp)[]>(
-      'TracingInterceptor.excluded',
-      [],
-    );
-    for (const item of excluded) {
-      if (typeof item === 'string' && url.startsWith(item)) return true;
-      if (item instanceof RegExp && item.test(url)) return true;
-    }
-    return false;
-  }
-
-  protected http(span: Span, context: ExecutionContext, next: CallHandler) {
-    const host = context.switchToHttp();
-    const req = host.getRequest();
-    const res = host.getResponse();
-    if (this.excluded(req.url)) return next.handle();
-    span.setAttribute('incoming.request.url', this.stringify(req.url));
-    span.setAttribute('incoming.request.body', this.stringify(req.body));
-    span.setAttribute('incoming.request.headers', this.stringify(req.headers));
-    span.setAttribute('incoming.request.method', this.stringify(req.method));
-    span.setAttribute('incoming.request.params', this.stringify(req.params));
-    span.setAttribute('incoming.request.query', this.stringify(req.query));
-    return next.handle().pipe(
-      catchError((e) => {
-        span.setAttribute('incoming.response.headers', this.stringify(res.headers));
-        span.setAttribute('incoming.response.statusCode', this.stringify(res.statusCode));
-        span.setAttribute('incoming.response.errorCode', this.stringify(e.code));
-        span.setAttribute('incoming.response.data', this.stringify(e?.response?.data));
-        throw e;
-      }),
-      tap((data) => {
-        span.setAttribute('incoming.response.headers', this.stringify(res.headers));
-        span.setAttribute('incoming.response.statusCode', this.stringify(res.statusCode));
-        span.setAttribute('incoming.response.data', this.stringify(data));
-      }),
-    );
-  }
-
-  protected ws(span: Span, context: ExecutionContext, next: CallHandler) {
-    return next.handle();
-  }
-
-  protected rpc(span: Span, context: ExecutionContext, next: CallHandler) {
-    return next.handle();
-  }
-
-  public intercept(context: ExecutionContext, next: CallHandler) {
-    const span = trace.getActiveSpan();
-    if (!span) return next.handle();
-    const type = context.getType();
-    return this[type](span, context, next);
-  }
-}

package/src/middlewares/proxy-middleware.ts

@@ -1,78 +0,0 @@
-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, Counter, Histogram, Prometheus } from '@biorate/prometheus';
-import { time } from '@biorate/tools';
-import { inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-
-@Injectable()
-export class ProxyPrometheusMiddleware {
-  @inject(Types.Config) private config: IConfig;
-
-  @counter({
-    name: 'http_proxy_server_requests_seconds_count',
-    help: 'Http proxy server requests count',
-    labelNames: ['method', 'uri', 'status'],
-  })
-  private counter: Counter;
-
-  private handler: RequestHandler;
-
-  private time = new WeakMap<Request, { time: () => number }>();
-
-  private static histogram: Histogram;
-
-  public static create(options?: Options) {
-    return new this(options).handler;
-  }
-
-  private constructor(options: Options = {}) {
-    const { onProxyReq, onProxyRes } = pick(options, 'onProxyReq', 'onProxyRes');
-    if (!ProxyPrometheusMiddleware.histogram)
-      ProxyPrometheusMiddleware.histogram = new Histogram({
-        name: 'http_proxy_server_requests_seconds',
-        help: 'Http proxy server requests seconds bucket',
-        labelNames: ['method', 'uri', 'status'],
-        buckets: this.config.get<number[]>(
-          'ProxyPrometheusMiddleware.histogram.buckets',
-          [0.005, 0.01, 0.02, 0.05, 0.1, 0.3, 0.5, 1, 2, 3, 5, 10],
-        ),
-        registers: [Prometheus.registry],
-      });
-    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();
-        ProxyPrometheusMiddleware.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

@@ -1,41 +0,0 @@
-// @ts-ignore
-import 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

@@ -1,73 +0,0 @@
-// @ts-ignore
-import onHeaders from 'on-headers';
-import { Injectable, NestMiddleware } from '@nestjs/common';
-import { inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-import { Prometheus, Histogram } from '@biorate/prometheus';
-import { Request, Response, NextFunction } from 'express';
-import { time } from '@biorate/tools';
-import { RoutesInterceptor } from '../interceptors';
-
-@Injectable()
-export class ResponseTimeMiddleware implements NestMiddleware {
-  @inject(Types.Config) private config: IConfig;
-
-  private readonly suffix: boolean;
-
-  private readonly header: string;
-
-  private readonly digits: number;
-
-  private static 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,
-    );
-    if (!ResponseTimeMiddleware.histogram)
-      ResponseTimeMiddleware.histogram = new Histogram({
-        name: 'http_server_requests_seconds',
-        help: 'Http server requests seconds bucket',
-        labelNames: ['method', 'uri', 'status'],
-        buckets: this.config.get<number[]>(
-          'ResponseTimeMiddleware.histogram.buckets',
-          [0.005, 0.01, 0.02, 0.05, 0.1, 0.3, 0.5, 1, 2, 3, 5, 10],
-        ),
-        registers: [Prometheus.registry],
-      });
-  }
-
-  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);
-      ResponseTimeMiddleware.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

@@ -1,36 +0,0 @@
-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/roles.ts

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

package/tests/__snapshots__/index.spec.ts.snap

@@ -1,44 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`nestjs-tools > AllExceptionsFilter 1`] = `[Function]`;
-
-exports[`nestjs-tools > AuthBasic 1`] = `[Function]`;
-
-exports[`nestjs-tools > AuthGuardProvider 1`] = `[Function]`;
-
-exports[`nestjs-tools > GetLocalesDTO 1`] = `[Function]`;
-
-exports[`nestjs-tools > LocalesController 1`] = `[Function]`;
-
-exports[`nestjs-tools > MetricsController 1`] = `[Function]`;
-
-exports[`nestjs-tools > PostLocalesDTO 1`] = `[Function]`;
-
-exports[`nestjs-tools > ProbeController 1`] = `[Function]`;
-
-exports[`nestjs-tools > ProxyPrometheusMiddleware 1`] = `[Function]`;
-
-exports[`nestjs-tools > ROLES_KEY 1`] = `Symbol(RolesKey)`;
-
-exports[`nestjs-tools > RequestCountMiddleware 1`] = `[Function]`;
-
-exports[`nestjs-tools > ResponseTimeMiddleware 1`] = `[Function]`;
-
-exports[`nestjs-tools > Roles 1`] = `[Function]`;
-
-exports[`nestjs-tools > RolesGuardProvider 1`] = `[Function]`;
-
-exports[`nestjs-tools > RoutesInterceptor 1`] = `[Function]`;
-
-exports[`nestjs-tools > TracingInterceptor 1`] = `[Function]`;
-
-exports[`nestjs-tools > UnsupportedProtocolError 1`] = `[Function]`;
-
-exports[`nestjs-tools > UserRoles 1`] = `
-{
-  "1": "Basic",
-  "2": "Admin",
-  "Admin": 2,
-  "Basic": 1,
-}
-`;

package/tests/index.spec.ts

@@ -1,61 +0,0 @@
-import { expect } from 'vitest';
-import {
-  AuthBasic,
-  Roles,
-  UserRoles,
-  AllExceptionsFilter,
-  RoutesInterceptor,
-  ProxyPrometheusMiddleware,
-  RequestCountMiddleware,
-  ResponseTimeMiddleware,
-  AuthGuardProvider,
-  RolesGuardProvider,
-  LocalesController,
-  MetricsController,
-  ProbeController,
-  PostLocalesDTO,
-  GetLocalesDTO,
-  UnsupportedProtocolError,
-  TracingInterceptor,
-  ROLES_KEY,
-} from '../src';
-
-describe('nestjs-tools', () => {
-  it('AuthBasic', () => expect(AuthBasic).toMatchSnapshot());
-
-  it('Roles', () => expect(Roles).toMatchSnapshot());
-
-  it('UserRoles', () => expect(UserRoles).toMatchSnapshot());
-
-  it('AllExceptionsFilter', () => expect(AllExceptionsFilter).toMatchSnapshot());
-
-  it('RoutesInterceptor', () => expect(RoutesInterceptor).toMatchSnapshot());
-
-  it('ProxyPrometheusMiddleware', () =>
-    expect(ProxyPrometheusMiddleware).toMatchSnapshot());
-
-  it('RequestCountMiddleware', () => expect(RequestCountMiddleware).toMatchSnapshot());
-
-  it('ResponseTimeMiddleware', () => expect(ResponseTimeMiddleware).toMatchSnapshot());
-
-  it('AuthGuardProvider', () => expect(AuthGuardProvider).toMatchSnapshot());
-
-  it('RolesGuardProvider', () => expect(RolesGuardProvider).toMatchSnapshot());
-
-  it('LocalesController', () => expect(LocalesController).toMatchSnapshot());
-
-  it('MetricsController', () => expect(MetricsController).toMatchSnapshot());
-
-  it('ProbeController', () => expect(ProbeController).toMatchSnapshot());
-
-  it('PostLocalesDTO', () => expect(PostLocalesDTO).toMatchSnapshot());
-
-  it('GetLocalesDTO', () => expect(GetLocalesDTO).toMatchSnapshot());
-
-  it('UnsupportedProtocolError', () =>
-    expect(UnsupportedProtocolError).toMatchSnapshot());
-
-  it('TracingInterceptor', () => expect(TracingInterceptor).toMatchSnapshot());
-
-  it('ROLES_KEY', () => expect(ROLES_KEY).toMatchSnapshot());
-});

package/tsconfig.build.json

@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["index.ts", "src/**/*"],
-  "exclude": ["node_modules", "dist", "tests", "**/*spec.ts"]
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "strict": true,
-    "strictPropertyInitialization": false
-  },
-  "include": ["index.ts", "src/**/*", "tests/**/*"],
-  "exclude": ["node_modules", "dist"]
-}