@boarteam/boar-pack-common-backend 2.1.3

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@boarteam/boar-pack-common-backend",
+  "version": "2.1.3",
+  "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>",
+  "license": "MIT",
+  "main": "src/index",
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^9.0.0",
+    "@nestjs/core": "^9.0.0",
+    "typeorm": "^0.2.25"
+  },
+  "scripts": {
+    "yalc:push": "yalc push"
+  },
+  "gitHead": "392553082a2f9f0124d05eaa11d0cdb6079766e1",
+  "dependencies": {
+    "@nestjs/websockets": "^10.3.9"
+  }
+}

package/src/index.ts

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

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,178 @@
+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

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

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,41 @@
+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

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

package/src/modules/websockets/index.ts

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

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

@@ -0,0 +1,163 @@
+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 {
+        this.logger.verbose(msg);
+        event = parse(String(msg), 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<T>(client: WebSocket, data: T): 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

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

package/src/modules/websockets/websockets.module.ts

@@ -0,0 +1,13 @@
+import { Module } from "@nestjs/common";
+import { WebsocketsClients } from "./websockets.clients";
+
+@Module({
+  providers: [
+    WebsocketsClients,
+  ],
+  exports: [
+    WebsocketsClients,
+  ],
+})
+export class WebsocketsModule {
+}

package/src/tools/index.ts

@@ -0,0 +1,4 @@
+export * from './named-logger';
+export * from './select-query-builder.extension';
+export * from './typeorm.execption-filter';
+export * from './virtual-column.decorator';

package/src/tools/named-logger.ts

@@ -0,0 +1,14 @@
+import { ConsoleLogger } from "@nestjs/common";
+
+export class NamedLogger extends ConsoleLogger {
+  private readonly prefix: string;
+
+  constructor(prefix?: string) {
+    super();
+    this.prefix = prefix || 'Nest';
+  }
+
+  formatPid(pid: number): string {
+    return `[${this.prefix}] ${pid}  - `;
+  }
+}

package/src/tools/select-query-builder.extension.ts

@@ -0,0 +1,28 @@
+import { SelectQueryBuilder } from 'typeorm';
+import { VIRTUAL_COLUMN_KEY } from './virtual-column.decorator';
+
+declare module 'typeorm' {
+  interface SelectQueryBuilder<Entity> {
+    // @ts-ignore
+    executeEntitiesAndRawResults(): Promise<{ entities: Entity[]; raw: any[] }>;
+  }
+}
+
+// @ts-ignore
+const originExecute = SelectQueryBuilder.prototype.executeEntitiesAndRawResults;
+// @ts-ignore
+SelectQueryBuilder.prototype.executeEntitiesAndRawResults = async function (
+  queryRunner,
+) {
+  // @ts-ignore
+  const { entities, raw } = await originExecute.call(this, queryRunner);
+  entities.forEach((entity, index) => {
+    const metaInfo = Reflect.getMetadata(VIRTUAL_COLUMN_KEY, entity) ?? {};
+    const item = raw[index];
+
+    for (const [propertyKey, name] of Object.entries<string>(metaInfo)) {
+      entity[propertyKey] = item[name];
+    }
+  });
+  return { entities, raw };
+};

package/src/tools/typeorm.execption-filter.ts

@@ -0,0 +1,56 @@
+import { ArgumentsHost, Catch, ExceptionFilter, Logger } from "@nestjs/common";
+import { QueryFailedError } from "typeorm";
+import { BaseExceptionFilter } from "@nestjs/core";
+
+enum ErrorCode {
+  // pg
+  UniqueViolation = '23505',
+
+  // mysql
+  FailedRemovingByForeignKey = 'ER_ROW_IS_REFERENCED',
+  FailedRemovingByForeignKey2 = 'ER_ROW_IS_REFERENCED_2',
+}
+
+@Catch(QueryFailedError)
+export class TypeOrmExceptionFilter extends BaseExceptionFilter implements ExceptionFilter {
+  private static uniqueConstraintMessages: Record<string, string> = {}
+
+  public static setUniqueConstraintMessage(constraint: string, message: string) {
+    this.uniqueConstraintMessages[constraint] = message;
+  }
+
+  private readonly logger = new Logger(TypeOrmExceptionFilter.name);
+
+  catch(exception: QueryFailedError, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const { code, constraint }: { code: string, constraint: string } = exception as any || {};
+
+    this.logger.error(`QueryFailedError: ${exception.message}, code: ${code}, constraint: ${constraint}`);
+
+    switch (code) {
+      case ErrorCode.UniqueViolation:
+        response
+          .status(400)
+          .json({
+            statusCode: 400,
+            message: TypeOrmExceptionFilter.uniqueConstraintMessages[constraint] || 'The record already exists',
+            error: 'Bad Request',
+          });
+        return;
+
+      case ErrorCode.FailedRemovingByForeignKey:
+      case ErrorCode.FailedRemovingByForeignKey2:
+        response
+          .status(400)
+          .json({
+            statusCode: 400,
+            message: 'System cannot remove the record, please remove all related records first',
+            error: 'Bad Request',
+          });
+        return;
+    }
+
+    return super.catch(exception, host);
+  }
+}

package/src/tools/virtual-column.decorator.ts

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+
+export const VIRTUAL_COLUMN_KEY = Symbol('VIRTUAL_COLUMN_KEY');
+
+export function VirtualColumn(name?: string): PropertyDecorator {
+  return (target, propertyKey) => {
+    const metaInfo = Reflect.getMetadata(VIRTUAL_COLUMN_KEY, target) || {};
+
+    metaInfo[propertyKey] = name ?? propertyKey;
+
+    Reflect.defineMetadata(VIRTUAL_COLUMN_KEY, metaInfo, target);
+  };
+}