@biorate/nestjs-tools 1.24.1 → 1.24.2

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.24.2](https://github.com/biorate/core/compare/v1.24.1...v1.24.2) (2023-02-02)
+
+
+### Bug Fixes
+
+* **nestjs-tools:** types ([483830d](https://github.com/biorate/core/commit/483830dee914458b547502e69134f99caa54317d))
+
+
+
+
+
 ## [1.24.1](https://github.com/biorate/core/compare/v1.24.0...v1.24.1) (2023-02-02)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biorate/nestjs-tools",
-  "version": "1.24.1",
+  "version": "1.24.2",
   "description": "NestJS tools",
   "main": "dist",
   "scripts": {
@@ -40,5 +40,5 @@
     "@types/express": "^4.17.16",
     "@types/on-headers": "^1.0.0"
   },
-  "gitHead": "136827e50d8e8cd280c1e9af9e0e7d5391af9894"
+  "gitHead": "a092d680f5d8df4473a8f07ed038b2fabe20f9a9"
 }

package/src/decorators/auth.ts

@@ -0,0 +1,14 @@
+import { UseGuards } from '@nestjs/common';
+import { ApiBasicAuth } from '@nestjs/swagger';
+import { AuthGuardProvider } from '../providers';
+
+export const AuthBasic =
+  () =>
+  (
+    target: Record<string | symbol, unknown>,
+    propertyKey?: string | symbol,
+    descriptor?: TypedPropertyDescriptor<unknown>,
+  ) => {
+    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,13 @@
+import { SetMetadata } from '@nestjs/common';
+import { UserRoles } from '../enums';
+
+export const ROLES_KEY = Symbol('RolesKey');
+
+export const Roles = (...roles: UserRoles[]) =>
+  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,4 @@
+export enum UserRoles {
+  Basic = 1 << 0,
+  Admin = 1 << 1,
+}

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

@@ -0,0 +1,47 @@
+import { BaseError } from '@biorate/errors';
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  BadRequestException,
+} from '@nestjs/common';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  public catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : (exception as BaseError)?.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,
+    });
+  }
+
+  private code(exception: unknown) {
+    return (<BaseError>exception).code ?? (<Error>exception).constructor.name;
+  }
+
+  private hint(exception: unknown) {
+    return (
+      (
+        (<BadRequestException>exception)?.getResponse?.() as unknown as {
+          message?: [string];
+        }
+      )?.message ?? (<BaseError>exception).message
+    );
+  }
+
+  private log(exception: unknown) {
+    console.error(exception);
+  }
+}

package/src/filters/index.ts

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

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './decorators';
+export * from './enums';
+export * from './filters';
+export * from './interceptors';
+export * from './middlewares';
+export * from './providers';

package/src/interceptors/index.ts

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

package/src/interceptors/routes-interceptor.ts

@@ -0,0 +1,30 @@
+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) {
+    RoutesInterceptor.map.set(context.switchToHttp().getRequest(), {
+      path: normalize(
+        join(
+          '/',
+          this.reflector.get<string>(PATH_METADATA, context.getClass()),
+          this.reflector.get<string>(PATH_METADATA, context.getHandler()),
+        ),
+      ),
+    });
+    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 * as httpProxy 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', 'url', 'status'],
+  })
+  private counter: Counter;
+
+  @histogram({
+    name: 'http_proxy_server_requests_seconds',
+    help: 'Http proxy server requests seconds bucket',
+    labelNames: ['method', 'url', 'status'],
+    buckets: [5, 10, 20, 50, 100, 300, 500, 1000, 2000, 3000, 5000, 10000],
+  })
+  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: httpProxy.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,
+            url: req.baseUrl,
+            status: res.statusCode,
+          })
+          .inc();
+        this.histogram
+          .labels({
+            method: req.method,
+            url: req.baseUrl,
+            status: res.statusCode,
+          })
+          .observe(diff!.time());
+        return onProxyRes?.(proxyRes, req, res);
+      },
+    });
+  }
+}

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

@@ -0,0 +1,29 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { counter, Counter } from '@biorate/prometheus';
+import { Request, Response, NextFunction } from 'express';
+import onHeaders from 'on-headers';
+import { RoutesInterceptor } from '../interceptors';
+
+@Injectable()
+export class RequestCountMiddleware implements NestMiddleware {
+  @counter({
+    name: 'http_server_requests_seconds_count',
+    help: 'Http server requests count',
+    labelNames: ['method', 'url', '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,
+          url: route?.path ?? (req.baseUrl || req.originalUrl),
+          status: res.statusCode,
+        })
+        .inc();
+    });
+    next();
+  }
+}

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

@@ -0,0 +1,53 @@
+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 onHeaders from 'on-headers';
+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', 'url', 'status'],
+    buckets: [5, 10, 20, 50, 100, 300, 500, 1000, 2000, 3000, 5000, 10000],
+  })
+  private histogram: Histogram;
+
+  public constructor() {
+    this.suffix = this.config.get<boolean>('app.middleware.ResponseTime.suffix', true);
+    this.header = this.config.get<string>(
+      'app.middleware.ResponseTime.header',
+      'x-response-time',
+    );
+    this.digits = this.config.get<number>('app.middleware.ResponseTime.digits', 3);
+  }
+
+  public use(req: Request, res: Response, next: NextFunction) {
+    const diff = time.diff();
+    onHeaders(res, () => {
+      const time = diff();
+      const route = RoutesInterceptor.map.get(req);
+      this.histogram
+        .labels({
+          method: req.method,
+          url: route?.path ?? (req.baseUrl || req.originalUrl),
+          status: res.statusCode,
+        })
+        .observe(time);
+      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 } | void>(
+      'app.auth.basic',
+      undefined,
+    );
+    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;
+  }
+}