@boarteam/boar-pack-common-backend 5.0.0 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boarteam/boar-pack-common-backend",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "NestJS Users module including permissions system, authentication strategies etc",
   "repository": "git@github.com:boarteam/boar-pack.git",
   "author": "Andrew Balakirev <balakirev.andrey@gmail.com>",
@@ -8,7 +8,6 @@
   "main": "dist/index",
   "types": "dist/index.d.ts",
   "files": [
-    "src",
     "dist"
   ],
   "publishConfig": {
@@ -19,7 +18,7 @@
     "build": "rm -rf dist && tsc --project tsconfig.build.json",
     "yalc:push": "yalc push"
   },
-  "gitHead": "311a9d2be89fb756e01331f4a70fc79af411e6f9",
+  "gitHead": "db759a35be3528d9970b7d2408d3b90d19bd7741",
   "dependencies": {
     "@nestjs/websockets": "^11.1.8",
     "lossless-json": "^4.3.0",

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './modules/scrypt/scrypt.module';
-export * from './modules/scrypt/scrypt.service';
-export * from './modules/schedule/schedule.module';
-export * from './modules/cluster';
-export * from './modules/websockets';
-export * as Tools from './tools';

package/src/modules/cluster/cluster.config.ts

@@ -1,38 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import cluster from "node:cluster";
-
-export type TClusterConfig = {
-  port: number;
-  worker?: string;
-  disableCluster?: boolean;
-};
-
-@Injectable()
-export class ClusterConfigService {
-  constructor(private configService: ConfigService) {
-  }
-
-  get config(): TClusterConfig {
-    const port = Number.parseInt(this.configService.get<string>('PORT') || '');
-    const worker = this.configService.get<string>('WORKER');
-    const disableCluster = this.configService.get<string>('DISABLE_CLUSTER') === 'true';
-
-    if (!disableCluster) {
-      if (!port) {
-        throw new Error('PORT env variable is not set');
-      }
-
-      if (cluster.isWorker && !worker) {
-        throw new Error('WORKER env variable is not set');
-      }
-
-    }
-
-    return {
-      port,
-      worker,
-      disableCluster,
-    };
-  }
-}

package/src/modules/cluster/cluster.interface.ts

@@ -1,25 +0,0 @@
-import { Cluster } from "node:cluster";
-import { Worker } from "cluster";
-
-export interface WorkerSettings {
-  workerId: string;
-  workerName?: string;
-  portIncrement: number | null;
-  port?: number | null;
-  extraEnv?: Record<string, string>;
-}
-
-export interface ClusterSettings {
-  clusterId: string;
-  appRole: string;
-  restartDelay?: number;
-}
-
-export interface ClusterInterface {
-  getSettings(): Promise<ClusterSettings>;
-  getWorkersSettings(): Promise<WorkerSettings[]>;
-  onWorkerRun?(worker: WorkerSettings, vars: Record<string, string>): void;
-  onWorkerExit?(worker: WorkerSettings, code: number, signal: string): void;
-  onWorkerListening?(worker: WorkerSettings): void;
-  onClusterMessage?(cluster: Cluster, worker: Worker, message: any): void;
-}

package/src/modules/cluster/cluster.module.ts

@@ -1,47 +0,0 @@
-import { Logger, Module, OnApplicationBootstrap } from '@nestjs/common';
-import { ClusterService } from "./cluster.service";
-import { nextTick } from "process";
-import { ConfigModule } from "@nestjs/config";
-import { ClusterConfigService, TClusterConfig } from "./cluster.config";
-
-@Module({
-  imports: [
-    ConfigModule,
-  ],
-  providers: [
-    ClusterConfigService,
-    ClusterService,
-  ],
-  exports: [
-    ClusterService,
-    ClusterConfigService,
-  ],
-})
-export class ClusterModule implements OnApplicationBootstrap {
-  private readonly logger = new Logger(ClusterModule.name);
-  private config: TClusterConfig;
-
-  constructor(
-    private readonly clusterService: ClusterService,
-    private readonly configService: ClusterConfigService,
-  ) {
-    this.config = configService.config;
-  }
-
-  async onApplicationBootstrap() {
-    if (this.config.disableCluster) {
-      this.logger.debug('Cluster is disabled');
-      return;
-    }
-
-    // We need to wait for event emitter to be initialized else broadcast will not work
-    nextTick(async () => {
-      try {
-        await this.clusterService.runClusters();
-      } catch (e) {
-        this.logger.error('Error while running clusters');
-        this.logger.error(e, e.stack);
-      }
-    });
-  }
-}

package/src/modules/cluster/cluster.service.ts

@@ -1,178 +0,0 @@
-import { Injectable, Logger, NotFoundException } from "@nestjs/common";
-import { ClusterInterface, ClusterSettings, WorkerSettings } from "./cluster.interface";
-import cluster from "node:cluster";
-import { ClusterConfigService, TClusterConfig } from "./cluster.config";
-import { Worker } from "cluster";
-
-type TWorkerVars = {
-  APP_ROLE: string;
-  WORKER: string;
-  WORKER_NAME: string;
-  PORT?: string;
-} & {
-  [key: string]: string;
-}
-
-@Injectable()
-export class ClusterService {
-  private readonly logger = new Logger(ClusterService.name);
-  private readonly STOP_WORKER = 'SIGKILL';
-  private readonly config: TClusterConfig;
-
-  private workersByClusters: Map<ClusterInterface, Map<Worker['id'], {
-    worker: Worker,
-    workerVars: TWorkerVars,
-  }>> = new Map();
-
-  constructor(
-    private readonly configService: ClusterConfigService,
-  ) {
-    this.config = this.configService.config;
-  }
-
-  public addCluster(cluster: ClusterInterface) {
-    this.workersByClusters.set(cluster, new Map());
-  }
-
-  public async runClusters(): Promise<void> {
-    const clusters = Array.from(this.workersByClusters.keys());
-    await Promise.allSettled(clusters.map(cluster => this.runCluster(cluster)));
-  }
-
-  private async runCluster(runningCluster: ClusterInterface) {
-    const clusterSettings = await runningCluster.getSettings();
-    const workersSettings = await runningCluster.getWorkersSettings();
-    workersSettings.forEach(settings => this.runWorker({
-      runningCluster,
-      clusterSettings,
-      workerSettings: settings
-    }));
-  }
-
-  private runWorker({
-    runningCluster,
-    clusterSettings,
-    workerSettings,
-    callback,
-  }: {
-    runningCluster: ClusterInterface,
-    clusterSettings: ClusterSettings,
-    workerSettings: WorkerSettings,
-    callback?: () => void,
-  }) {
-    const clusterWorkers = this.workersByClusters.get(runningCluster);
-
-    if (!clusterWorkers) {
-      throw new Error(`Cluster ${runningCluster.constructor.name} is not found`);
-    }
-
-    const workerName = workerSettings.workerName || workerSettings.workerId;
-    this.logger.log(`Starting worker ${workerName}...`);
-
-    const vars: TWorkerVars = {
-      APP_ROLE: clusterSettings.appRole,
-      WORKER: workerSettings.workerId,
-      WORKER_NAME: workerName,
-      ...workerSettings.extraEnv,
-    }
-
-    if (workerSettings.port) {
-      vars.PORT = String(workerSettings.port);
-    } else if (workerSettings.portIncrement !== null) {
-      vars.PORT = String(this.config.port + workerSettings.portIncrement);
-    }
-
-    runningCluster.onWorkerRun?.(workerSettings, vars);
-
-    const workerProcess = cluster.fork(vars);
-    clusterWorkers.set(workerProcess.id, {
-      worker: workerProcess,
-      workerVars: vars,
-    });
-
-    cluster.on('message', (worker, message) => {
-      runningCluster.onClusterMessage?.(cluster, worker, message);
-    })
-
-    workerProcess.on('exit', (code, signal) => {
-      clusterWorkers.delete(workerProcess.id);
-      runningCluster.onWorkerExit?.(workerSettings, code, signal);
-
-      this.logger.error(`Worker ${workerName} died with code ${code} and signal ${signal}`);
-
-      if (signal === this.STOP_WORKER) {
-        this.logger.log(`Worker ${workerName} was stopped and will not be restarted`);
-        return;
-      }
-
-      if (typeof clusterSettings.restartDelay === 'undefined') {
-        this.logger.log(`Restarting worker ${workerName} without delay...`);
-        this.startWorker(runningCluster, workerSettings.workerId).catch(err => {
-          this.logger.error(`Failed to restart worker ${workerName}: ${err}`);
-        });
-      } else {
-        this.logger.log(`Worker ${workerName} will be restarted in ${clusterSettings.restartDelay}ms...`);
-        setTimeout(() => {
-          this.logger.log(`Restarting worker ${workerName}...`);
-          this.startWorker(runningCluster, workerSettings.workerId).catch(err => {
-            this.logger.error(`Failed to restart worker ${workerName}: ${err}`);
-          });
-        }, clusterSettings.restartDelay);
-      }
-    });
-
-    workerProcess.once('listening', () => {
-      this.logger.log(`Worker ${workerName} started`);
-      callback?.();
-      runningCluster.onWorkerListening?.(workerSettings);
-    });
-  }
-
-  public async setWorkerState(cluster: ClusterInterface, workerId: string, state: boolean) {
-    const workers = this.workersByClusters.get(cluster);
-    if (!workers) {
-      throw new NotFoundException(`Cluster ${cluster.constructor.name} is not found`);
-    }
-
-    const workerDescriptor = Array.from(workers.values()).find(worker => worker.workerVars.WORKER === workerId);
-    if (!workerDescriptor) {
-      if (state) {
-        await this.startWorker(cluster, workerId);
-      } else {
-        this.logger.log(`Worker ${workerId} is not found and should be stopped - doing nothing`);
-      }
-    } else {
-      if (state) {
-        await this.updateWorker(workerDescriptor.worker, workerId);
-      } else {
-        await this.stopWorker(workerDescriptor.worker, workerId);
-      }
-    }
-  }
-
-  private async startWorker(runningCluster: ClusterInterface, workerId: string) {
-    const clusterSettings = await runningCluster.getSettings();
-    const workersSettings = await runningCluster.getWorkersSettings();
-    const workerSettings = workersSettings.find(settings => settings.workerId === workerId);
-
-    if (!workerSettings) {
-      throw new NotFoundException(`Settings for worker ${workerId} are not found`);
-    }
-
-    this.runWorker({
-      runningCluster,
-      clusterSettings,
-      workerSettings,
-    });
-  }
-
-  private async stopWorker(worker: Worker, workerId: string) {
-    this.logger.log(`Stopping worker ${workerId}...`);
-    worker.kill(this.STOP_WORKER);
-  }
-
-  private async updateWorker(worker: Worker, workerId: string) {
-    this.logger.log(`Updating worker ${workerId} by restarting...`);
-    worker.kill();
-  }
-}

package/src/modules/cluster/index.ts

@@ -1,4 +0,0 @@
-export * from './cluster.config';
-export * from './cluster.interface';
-export * from './cluster.module';
-export * from './cluster.service';

package/src/modules/schedule/schedule.module.ts

@@ -1,18 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ScheduleModule as NestScheduleModule } from "@nestjs/schedule";
-import ScheduleService from "./schedule.service";
-
-@Module({
-  imports: [
-    NestScheduleModule.forRoot(),
-  ],
-  providers: [
-    ScheduleService
-  ],
-  exports: [
-    ScheduleService,
-  ],
-})
-export class ScheduleModule {
-  constructor() {}
-}

package/src/modules/schedule/schedule.service.ts

@@ -1,43 +0,0 @@
-import { Injectable, OnApplicationBootstrap } from "@nestjs/common";
-import { SchedulerRegistry } from "@nestjs/schedule";
-
-@Injectable()
-export class ScheduleService implements OnApplicationBootstrap {
-  constructor(private schedulerRegistry: SchedulerRegistry) {
-  }
-
-  onApplicationBootstrap() {
-    const isDisabled = process.env.SWAGGER === 'true';
-    // Disable all cron jobs, intervals and timeouts
-    if (isDisabled) {
-      this.stopAllCronJobs();
-      this.deleteAllIntervals();
-      this.deleteAllTimeouts();
-    }
-  }
-
-  private stopAllCronJobs() {
-    const jobs = this.schedulerRegistry.getCronJobs();
-
-    jobs.forEach(job => {
-        job.stop();
-      }
-    )
-  }
-
-  private deleteAllIntervals() {
-    const intervals = this.schedulerRegistry.getIntervals();
-    intervals.forEach(key => {
-      this.schedulerRegistry.deleteInterval(key);
-    });
-  }
-
-  private deleteAllTimeouts() {
-    const timeouts = this.schedulerRegistry.getTimeouts();
-    timeouts.forEach(key => {
-      this.schedulerRegistry.deleteTimeout(key);
-    });
-  }
-}
-
-export default ScheduleService;

package/src/modules/scrypt/scrypt.config.ts

@@ -1,36 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import Joi from "joi";
-
-export type TScryptConfig = {
-  salt: string;
-  iv: string;
-};
-
-@Injectable()
-export class ScryptConfigService {
-  private ivSchema = Joi.string().length(16).hex();
-
-  constructor(private configService: ConfigService) {
-  }
-
-  get config(): TScryptConfig {
-    const salt = this.configService.get<string>('SCRYPT_SALT');
-    const iv = this.configService.get<string>('SCRYPT_IV');
-
-    if (!salt || !iv) {
-      throw new Error('SCRYPT_SALT or SCRYPT_IV env variables are not set');
-    }
-
-    const { error } = this.ivSchema.validate(iv);
-    if (error) {
-      console.error('IV is invalid:', error.details[0].message);
-      throw new Error('IV is invalid, check SCRYPT_IV env variable');
-    }
-
-    return {
-      salt,
-      iv,
-    };
-  }
-}

package/src/modules/scrypt/scrypt.module.ts

@@ -1,20 +0,0 @@
-import { Module } from '@nestjs/common';
-import ScryptService from "./scrypt.service";
-import { ScryptConfigService } from "./scrypt.config";
-import { ConfigModule } from "@nestjs/config";
-
-@Module({
-  imports: [
-    ConfigModule,
-  ],
-  controllers: [],
-  providers: [
-    ScryptService,
-    ScryptConfigService,
-  ],
-  exports: [
-    ScryptService,
-  ],
-})
-export class ScryptModule {
-}

package/src/modules/scrypt/scrypt.service.ts

@@ -1,41 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { ScryptConfigService, TScryptConfig } from "./scrypt.config";
-import { promisify } from "util";
-import { createCipheriv, scrypt } from "crypto";
-
-@Injectable()
-export class ScryptService {
-  private config: TScryptConfig;
-
-  constructor(
-    private scryptConfig: ScryptConfigService,
-  ) {
-    this.config = this.scryptConfig.config;
-  }
-
-  async encrypt(str: string): Promise<string> {
-    const key = (await promisify(scrypt)(this.config.salt, 'salt', 32)) as Buffer;
-    const cipher = createCipheriv('aes-256-ctr', key, this.config.iv);
-
-    const encrypted = Buffer.concat([
-      cipher.update(str),
-      cipher.final(),
-    ]);
-
-    return encrypted.toString('base64');
-  }
-
-  async decrypt(str: string): Promise<string> {
-    const key = (await promisify(scrypt)(this.config.salt, 'salt', 32)) as Buffer;
-    const decipher = createCipheriv('aes-256-ctr', key, this.config.iv);
-
-    const decrypted = Buffer.concat([
-      decipher.update(str, 'base64'),
-      decipher.final(),
-    ]);
-
-    return decrypted.toString();
-  }
-}
-
-export default ScryptService;

package/src/modules/websockets/dto/websockets.dto.ts

@@ -1,12 +0,0 @@
-export interface WebsocketsEventDto {
-  event: string;
-  data: any;
-}
-
-export class WebsocketsErrorEventDto implements WebsocketsEventDto {
-  event: 'error';
-  data: {
-    message: string;
-    details?: any;
-  };
-}

package/src/modules/websockets/index.ts

@@ -1,2 +0,0 @@
-export * from './websockets.exception-filter';
-export * from './dto/websockets.dto';

package/src/modules/websockets/websockets.clients.ts

@@ -1,164 +0,0 @@
-import { Injectable, Logger, Scope } from "@nestjs/common";
-import WebSocket from "ws";
-import { isSafeNumber, parse } from "lossless-json";
-
-export type TBaseConfig<EventType> = {
-  url: string;
-  onOpen?: () => void;
-  onMessage?: (event: EventType) => void;
-  onClose?: () => void;
-  getEventError?: (event: EventType) => string | null | undefined;
-  reconnectTimeout?: number;
-  ignoreInvalidJson?: boolean;
-};
-
-export enum WsErrorCodes {
-  ConnectionClosed = 1000,
-  InvalidJson = 4000,
-  ErrorMessage = 4001,
-  Unauthorized = 4003,
-}
-
-@Injectable({ scope: Scope.TRANSIENT })
-export class WebsocketsClients<IncomeEventType,
-  OutgoingEventType = any,
-  ConfigType extends TBaseConfig<IncomeEventType> = TBaseConfig<IncomeEventType>,
-  > {
-  private readonly logger = new Logger(WebsocketsClients.name);
-  private readonly clients = new WeakMap<WebSocket, ConfigType>();
-
-  constructor() {
-  }
-
-  private toSafeNumberOrString(value: string): number | string {
-    return isSafeNumber(value) ? parseFloat(value) : value;
-  }
-
-  public connect(config: ConfigType): WebSocket {
-    this.logger.log(`Connecting to ${config.url}...`);
-    const ws = new WebSocket(config.url);
-
-    this.clients.set(ws, config);
-
-    ws.on('open', async () => {
-      this.logger.log(`Connected to ${config.url}`);
-      try {
-        await config.onOpen?.();
-      } catch (e) {
-        this.logger.error(`Error, while calling onOpen for ${config.url} socket`);
-        this.logger.error(e);
-        ws.close(WsErrorCodes.ErrorMessage, e.toString());
-      }
-    });
-
-    ws.on('error', (error) => {
-      this.logger.error(`Error for ${config.url} socket:`);
-      this.logger.error(error);
-      ws.close();
-    });
-
-    ws.on('close', (code, reason) => {
-      this.onClose(ws, config, code, reason);
-    });
-
-    ws.on('message', (msg: Buffer) => {
-      let event: IncomeEventType;
-      try {
-        const str = String(msg);
-        this.logger.verbose(str);
-        event = parse(str, null, this.toSafeNumberOrString) as IncomeEventType;
-      } catch (e) {
-        this.logger.error(`Error, while parsing message from WS server ${msg}`);
-        this.logger.error(e, e.stack);
-        if (!config.ignoreInvalidJson) {
-          ws?.close(WsErrorCodes.InvalidJson, "Invalid JSON");
-        }
-        return;
-      }
-
-      const errorMessage = config.getEventError?.(event);
-      if (errorMessage) {
-        this.logger.error(`Error from WS server: ${errorMessage}`);
-        ws.close(WsErrorCodes.ErrorMessage, errorMessage);
-        return;
-      }
-
-      config.onMessage?.(event);
-    });
-
-    return ws;
-  }
-
-  private onClose(ws: WebSocket, config: ConfigType | undefined, code: number, reason: Buffer) {
-    this.logger.log(`${config?.url} socket closed with code ${code} and reason: ${reason.toString()}`);
-    ws.removeAllListeners();
-    config?.onClose?.();
-    this.clients.delete(ws);
-  }
-
-  public close(client: WebSocket): Promise<void> {
-    const config = this.clients.get(client);
-    if (typeof config?.reconnectTimeout === "number") {
-      clearTimeout(config.reconnectTimeout);
-    }
-
-    if (client.readyState === WebSocket.CLOSED) {
-      this.onClose(client, config, WsErrorCodes.ConnectionClosed, Buffer.from("Closed by client"));
-      return Promise.resolve();
-    }
-
-    return new Promise((resolve) => {
-      client.once('close', () => resolve());
-      client.close();
-    });
-  }
-
-  public reconnect(client: WebSocket, timeout: number) {
-    const config = this.clients.get(client);
-    if (!config) {
-      throw new Error(`Can't reconnect, config not found`);
-    }
-
-    config.reconnectTimeout = setTimeout(() => {
-      this.connect(config);
-    }, timeout) as unknown as number;
-  }
-
-  public send(client: WebSocket, data: OutgoingEventType): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const send = () => {
-        client.send(JSON.stringify(data), (err) => {
-          if (err) {
-            this.logger.error(`Error sending data to WS server`);
-            this.logger.error(err);
-            reject(err);
-            return;
-          }
-
-          resolve();
-        });
-      }
-
-      if (client.readyState !== WebSocket.OPEN) {
-        const timeout = setTimeout(() => {
-          reject(new Error(`Can't send data to WS server, because client is not connected`));
-        }, 1000);
-
-        client.once('open', () => {
-          clearTimeout(timeout);
-          send();
-        });
-
-        return;
-      }
-
-      try {
-        send();
-      } catch (e) {
-        this.logger.error(`Error, while sending data to WS server`);
-        this.logger.error(e);
-        reject(e);
-      }
-    });
-  }
-}

package/src/modules/websockets/websockets.exception-filter.ts

@@ -1,19 +0,0 @@
-import { Catch, ArgumentsHost } from '@nestjs/common';
-import { BaseWsExceptionFilter, WsException } from '@nestjs/websockets';
-import { WebsocketsErrorEventDto } from "./dto/websockets.dto";
-
-@Catch()
-export class WebsocketsExceptionFilter extends BaseWsExceptionFilter {
-  catch(exception: Error | WsException, host: ArgumentsHost) {
-    const client = host.switchToWs().getClient();
-    client.send(JSON.stringify({
-      event: 'error',
-      data: {
-        message: exception.message,
-        details: exception instanceof WsException ? (exception.getError() as any)?.details : undefined,
-      },
-    } as WebsocketsErrorEventDto));
-
-    super.catch(exception, host);
-  }
-}