@biorate/nestjs-tools 1.126.0 → 1.128.0

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;
+  }
+}