eh-commons 0.0.1-testing.1

package/dist/utils/console-logger.class.d.ts

@@ -0,0 +1,9 @@
+export declare class ConsoleLogger {
+    private static logLevels;
+    static info(...msg: unknown[]): void;
+    static error(...msg: unknown[]): void;
+    static warn(...msg: unknown[]): void;
+    static debug(...msg: unknown[]): void;
+    private static _log;
+    private static _logPrefix;
+}

package/dist/utils/console-logger.class.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const config_util_class_1 = require("./config-util.class");
+const logsEnabledKeyword = 'APP__LOGS__ENABLE';
+const logLevelsKeyword = 'APP__LOGS__LEVELS';
+const levelColors = {
+    info: "\x1b[32m",
+    warn: "\x1b[33m",
+    error: '\x1b[31m',
+    debug: '\x1b[36m',
+};
+class ConsoleLogger {
+    static info(...msg) {
+        this._log('info', ...msg);
+    }
+    static error(...msg) {
+        this._log('error', ...msg);
+    }
+    static warn(...msg) {
+        this._log('warn', ...msg);
+    }
+    static debug(...msg) {
+        this._log('debug', ...msg);
+    }
+    static _log(level, ...logs) {
+        const enabled = config_util_class_1.ConfigUtil.get(logsEnabledKeyword);
+        if (!(enabled == 'true' || enabled == '1') || !this.logLevels.includes(level))
+            return;
+        if (console[level])
+            console[level](...this._logPrefix(level), ...logs, '\x1b[0m');
+    }
+    static _logPrefix(level) {
+        return ['\x1b[33m', '[G3]  -  ', '\x1b[0m', `${new Date().toLocaleDateString()} ${new Date().toLocaleTimeString()}   `, levelColors[level], level.toUpperCase(), '   '];
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+ConsoleLogger.logLevels = config_util_class_1.ConfigUtil.get(logLevelsKeyword) || "";
+//# sourceMappingURL=console-logger.class.js.map

package/dist/utils/console-logger.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-logger.class.js","sourceRoot":"","sources":["../../src/utils/console-logger.class.ts"],"names":[],"mappings":";;;AAAA,2DAAiD;AACjD,MAAM,kBAAkB,GAAG,mBAAmB,CAAC;AAC/C,MAAM,gBAAgB,GAAG,mBAAmB,CAAC;AAE7C,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,UAAU;CAClB,CAAA;AACD,MAAa,aAAa;IAGjB,MAAM,CAAC,IAAI,CAAC,GAAG,GAAc;QAClC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;IAC5B,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,GAAG,GAAc;QACnC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,CAAC;IAC7B,CAAC;IAEM,MAAM,CAAC,IAAI,CAAC,GAAG,GAAc;QAClC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;IAC5B,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,GAAG,GAAc;QACnC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,CAAC;IAC7B,CAAC;IAEO,MAAM,CAAC,IAAI,CAAC,KAA0C,EAAE,GAAG,IAAe;QAChF,MAAM,OAAO,GAAG,8BAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QACnD,IAAI,CAAC,CAAC,OAAO,IAAI,MAAM,IAAI,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO;QAEtF,IAAI,OAAO,CAAC,KAAK,CAAC;YAChB,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,SAAS,CAAC,CAAC;IAElE,CAAC;IAEO,MAAM,CAAC,UAAU,CAAC,KAAa;QACrC,OAAO,CAAC,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,CAAA;IACzK,CAAC;;AA9BH,sCA+BC;AA9BgB,uBAAS,GAAG,8BAAU,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "eh-commons",
+  "type": "commonjs",
+  "version": "0.0.1-testing.01",
+  "description": "eh-commons",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublish": "tsc",
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/node": "^18.15.11",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "^6.18.1",
+    "eslint": "^8.56.0",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.3.7",
+    "@nestjs/config": "^3.1.1",
+    "@nestjs/core": "^10.3.1",
+    "@nestjs/mongoose": "^10.0.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
+    "express": "^4.18.2",
+    "ioredis": "^5.3.2",
+    "kafkajs": "^2.2.4",
+    "mongoose": "^8.0.4",
+    "rxjs": "^7.8.1"
+  }
+}

package/src/clients/logger.client.ts

@@ -0,0 +1,57 @@
+import { Kafka, Producer, RecordMetadata, TopicMessages } from 'kafkajs';
+import { Observable, catchError, from, map, mergeMap, of } from 'rxjs';
+
+export class LoggerClient {
+  private kafka: Kafka;
+  private kafkaTopic: string;
+  private producer: Producer;
+  constructor(
+    kafkaBrokers: string[],
+    kafkaClientId: string,
+    kafkaLogTopic: string,
+  ) {
+    this.kafkaTopic = kafkaLogTopic;
+    this.kafka = new Kafka({ brokers: kafkaBrokers, clientId: kafkaClientId });
+    this.producer = this.kafka.producer();
+  }
+
+  private connectProducer(): Observable<void> {
+    return from(this.producer.connect());
+  }
+  private disconnectProducer(): Observable<void> {
+    return from(this.producer.disconnect());
+  }
+  private sendLog(log: any, key?: string): Observable<RecordMetadata[]> {
+    let messageString = JSON.stringify(log);
+    return this.connectProducer().pipe(
+      mergeMap(() => {
+        return this.send(messageString, key).pipe(
+          map((recordMetadata) => {
+            this.disconnectProducer().subscribe();
+            return recordMetadata;
+          }),
+        );
+      }),
+      catchError((err) => {
+        return of(err);
+      }),
+    );
+  }
+
+  private send(
+    messageString: string,
+    key?: string,
+  ): Observable<RecordMetadata[]> {
+    return from(
+      this.producer.send({
+        topic: this.kafkaTopic,
+        messages: [
+          {
+            key,
+            value: messageString,
+          },
+        ],
+      }),
+    );
+  }
+}

package/src/clients/session.client.ts

@@ -0,0 +1,42 @@
+import * as IORedis from 'ioredis';
+
+import { ISessionUserData } from '../models/interfaces/session/session-data.interface';
+
+export class SessionClient {
+  private redisClient: IORedis.Redis;
+
+  constructor(client: IORedis.Redis) {
+    this.redisClient = client;
+  }
+
+  public get(key: string): Promise<string> {
+    return this.redisClient.get(key);
+  }
+
+  public set(key: string, value: string): Promise<string> {
+    return this.redisClient.set(key, value);
+  }
+
+  public delete(key: string): Promise<number> {
+    return this.redisClient.del(key);
+  }
+
+  private parseUser(jsonString: string): ISessionUserData | null {
+    try {
+      const parsedUser: ISessionUserData = JSON.parse(jsonString);
+      return parsedUser;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private parse<T>(jsonString: string): T | null {
+    try {
+      const result: T = JSON.parse(jsonString);
+      return result;
+    } catch (error) {
+      return null;
+    }
+  }
+
+}

package/src/constraints/is-map-of-strings.constraint.ts

@@ -0,0 +1,26 @@
+import { ValidationArguments, ValidatorConstraint, ValidatorConstraintInterface } from 'class-validator';
+
+@ValidatorConstraint({ name: 'IsMapOfStrings', async: false })
+export class IsMapOfStringsConstraint implements ValidatorConstraintInterface {
+  validate(value: any, args: ValidationArguments): boolean {
+    if (!value || typeof value !== 'object') {
+      return false;
+    }
+
+    if (!Object.keys(value).length) {
+      return false;
+    }
+
+    for (let key in value) {
+      if (typeof value[key] !== 'string') {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  defaultMessage(args: ValidationArguments): string {
+    return `${args.property} must be a map object with string values.`;
+  }
+}

package/src/constraints/is-route.constraint.ts

@@ -0,0 +1,14 @@
+import { ValidationArguments, ValidatorConstraint, ValidatorConstraintInterface } from 'class-validator';
+
+@ValidatorConstraint({ name: 'IsRoute', async: false })
+export class IsRouteConstraint implements ValidatorConstraintInterface {
+  validate(value: any, args: ValidationArguments): boolean {
+    //const routePattern = /^\/[\w\/]+(\?.+)?$/;
+    const routePattern = /^\/[\w-\/]+(\?.+)?$/;
+    return typeof value === 'string' && routePattern.test(value);
+  }
+
+  defaultMessage(args: ValidationArguments): string {
+    return `${args.property} must be a valid route string.`;
+  }
+}

package/src/decorators/is-map-of-strings.decorator.ts

@@ -0,0 +1,10 @@
+import { Validate } from "class-validator";
+import { IsMapOfStringsConstraint } from "../constraints/is-map-of-strings.constraint";
+
+export function IsMapOfStrings() {
+  return function (object: Record<string, any>, propertyName: string): void {
+    Validate(IsMapOfStringsConstraint, {
+      message: `${propertyName} must be a map object with string values.`,
+    })(object, propertyName);
+  };
+}

package/src/decorators/is-route.decorator.ts

@@ -0,0 +1,8 @@
+import { Validate } from 'class-validator';
+import { IsRouteConstraint } from '../constraints/is-route.constraint';
+
+export function IsRoute() {
+  return function (object: Record<string, any>, propertyName: string): void {
+    Validate(IsRouteConstraint, { message: `${propertyName} must be a valid route string.` })(object, propertyName);
+  };
+}

package/src/exceptions/custom.exception.ts

@@ -0,0 +1,16 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+import { Response } from 'express';
+import { RESTError, RESTResponseBody } from '../models/wrappers/rest-wrapper.class';
+
+class HandledException extends HttpException {
+  constructor(private readonly _errors: RESTError[], private readonly _statusCode?: HttpStatus) {
+    super({ errors: _errors }, _statusCode || HttpStatus.BAD_REQUEST);
+  }
+
+  public send(response: Response) {
+    const responseBody = RESTResponseBody.fail(this._errors, this._statusCode || HttpStatus.BAD_REQUEST);
+    response.status(this._statusCode).json(responseBody);
+  }
+}
+
+export { HandledException };

package/src/factories/exception.factory.ts

@@ -0,0 +1,14 @@
+import { HttpStatus } from '@nestjs/common';
+import { ValidationError } from 'class-validator';
+import { HandledException } from '../exceptions/custom.exception';
+import { RESTError } from '../models/wrappers/rest-wrapper.class';
+
+function validationExceptionFactory(_errors: ValidationError[]): HandledException {
+  const error = new RESTError('DATA_VALIDATION');
+  _errors.forEach((i: any) => {
+    error.validation = i;
+  });
+  return new HandledException([error], HttpStatus.UNPROCESSABLE_ENTITY);
+}
+
+export { validationExceptionFactory };

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

@@ -0,0 +1,192 @@
+import { ArgumentsHost, ExceptionFilter, HttpStatus } from '@nestjs/common';
+import { HandledException } from '../exceptions/custom.exception';
+import { RESTError } from '../models/wrappers/rest-wrapper.class';
+
+export class BaseExceptionsFilter implements ExceptionFilter {
+  private _debug: boolean = false;
+
+  constructor(debug: boolean) {
+    this._debug = debug;
+  }
+
+  catch(exception: any, host: ArgumentsHost) {
+    const context = host.switchToHttp();
+    const response = context.getResponse<Response>();
+
+    if (this._debug) {
+      console.log('BaseExceptionsFilter - name:', exception.constructor.name);
+    }
+
+    let handledException: HandledException | any = null;
+
+    try {
+      switch (exception.constructor.name) {
+        case 'HandledException':
+          handledException = exception;
+          break;
+        case 'RESTError':
+          handledException = new HandledException(exception, exception.statusCode || HttpStatus.BAD_REQUEST);
+          break;
+        case 'BadRequestException':
+          handledException = new HandledException(
+            [new RESTError('BadRequestException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'UnauthorizedException':
+          handledException = new HandledException(
+            [new RESTError('UnauthorizedException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'NotFoundException':
+          handledException = new HandledException(
+            [new RESTError('METHOD_NOT_FOUND', exception.message)],
+            HttpStatus.METHOD_NOT_ALLOWED,
+          );
+          break;
+        case 'ForbiddenException':
+          handledException = new HandledException(
+            [new RESTError('INVALID_API_TOKEN', 'invalid X-API-TOKEN received in headers')],
+            HttpStatus.FORBIDDEN,
+          );
+          break;
+        case 'NotAcceptableException':
+          handledException = new HandledException(
+            [new RESTError('NotAcceptableException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'RequestTimeoutException':
+          handledException = new HandledException(
+            [new RESTError('RequestTimeoutException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'ConflictException':
+          handledException = new HandledException(
+            [new RESTError('ConflictException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'GoneException':
+          handledException = new HandledException(
+            [new RESTError('GoneException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'HttpVersionNotSupportedException':
+          handledException = new HandledException(
+            [new RESTError('HttpVersionNotSupportedException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'PayloadTooLargeException':
+          handledException = new HandledException(
+            [new RESTError('PayloadTooLargeException', exception.constructor.name)],
+            HttpStatus.PAYLOAD_TOO_LARGE,
+          );
+          break;
+        case 'UnsupportedMediaTypeException':
+          handledException = new HandledException(
+            [new RESTError('UnsupportedMediaTypeException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'UnprocessableEntityException':
+          handledException = new HandledException(
+            [new RESTError('UnprocessableEntityException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'InternalServerErrorException':
+          handledException = new HandledException(
+            [new RESTError('InternalServerErrorException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'NotImplementedException':
+          handledException = new HandledException(
+            [new RESTError('NotImplementedException', exception.constructor.name)],
+            HttpStatus.NOT_IMPLEMENTED,
+          );
+          break;
+        case 'ImATeapotException':
+          handledException = new HandledException(
+            [new RESTError('ImATeapotException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'MethodNotAllowedException':
+          handledException = new HandledException(
+            [new RESTError('MethodNotAllowedException', exception.constructor.name)],
+            HttpStatus.METHOD_NOT_ALLOWED,
+          );
+          break;
+        case 'BadGatewayException':
+          handledException = new HandledException(
+            [new RESTError('BadGatewayException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'ServiceUnavailableException':
+          handledException = new HandledException(
+            [new RESTError('ServiceUnavailableException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'GatewayTimeoutException':
+          handledException = new HandledException(
+            [new RESTError('GatewayTimeoutException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'PreconditionFailedException':
+          handledException = new HandledException(
+            [new RESTError('PreconditionFailedException', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'TypeError':
+          handledException = new HandledException(
+            [new RESTError('TYPE_ERROR', exception.message)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'MongoError':
+          handledException = new HandledException(
+            [new RESTError('MONGO_ERROR', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'CastError':
+          handledException = new HandledException(
+            [new RESTError('CAST_ERROR', exception.message)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        case 'ValidationError':
+          handledException = new HandledException(
+            [new RESTError('VALIDATION_ERROR', exception.message)],
+            HttpStatus.UNPROCESSABLE_ENTITY,
+          );
+          break;
+        case 'MongoServerError':
+          handledException = new HandledException(
+            [new RESTError('MONGO_SERVER_ERROR', exception.message)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+          break;
+        default:
+          handledException = new HandledException(
+            [new RESTError('UNKNOWN_EXCEPTION', exception.constructor.name)],
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          );
+      }
+    } catch (ex) {
+      handledException = new HandledException([new RESTError('FILTER_EXCEPTION', ex)], HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+
+    handledException.send(response);
+  }
+}

package/src/functions/escape-regex.function.ts

@@ -0,0 +1,5 @@
+export function escapeRegex(text: string) {
+  // Escape characters with special meaning either inside or outside character sets.
+  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+  return text.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+}

package/src/functions/generate-uuid.function.ts

@@ -0,0 +1,7 @@
+export function generateUUID(): string {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      const r = (Math.random() * 16) | 0;
+      const v = c === 'x' ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }

package/src/functions/json-size.function.ts

@@ -0,0 +1,9 @@
+export function sizeOfJson(object: any): number {
+  // Convert the object to a JSON string
+  const jsonString = JSON.stringify(object);
+
+  // Get the length of the JSON string in bytes
+  const bytes = new TextEncoder().encode(jsonString).length;
+
+  return bytes;
+}

package/src/functions/random-range.function.ts

@@ -0,0 +1,6 @@
+export function getRandomNumberFromRange(min: number, max: number){
+    if (min >= max) {
+        throw new Error("The minimum value must be less than the maximum value");
+    }
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}

package/src/functions/transliterate-geo-to-latin.ts

@@ -0,0 +1,42 @@
+export function translitGeorgiaToLatin(georgianText: string) {
+  const georgianChars: { [key: string]: string } = {
+    ა: 'a',
+    ბ: 'b',
+    გ: 'g',
+    დ: 'd',
+    ე: 'e',
+    ვ: 'v',
+    ზ: 'z',
+    თ: 't',
+    ი: 'i',
+    კ: 'k',
+    ლ: 'l',
+    მ: 'm',
+    ნ: 'n',
+    ო: 'o',
+    პ: 'p',
+    ჟ: 'zh',
+    რ: 'r',
+    ს: 's',
+    ტ: 't',
+    უ: 'u',
+    ფ: 'p',
+    ქ: 'q',
+    ღ: 'gh',
+    ყ: 'q',
+    შ: 'sh',
+    ჩ: 'ch',
+    ც: 'ts',
+    ძ: 'dz',
+    წ: 'ts',
+    ჭ: 'ch',
+    ხ: 'kh',
+    ჯ: 'j',
+    ჰ: 'h',
+  };
+
+  return georgianText
+    .split('')
+    .map((char) => georgianChars[char] || char)
+    .join('');
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+import { IsMapOfStringsConstraint } from './constraints/is-map-of-strings.constraint';
+import { IsRouteConstraint } from './constraints/is-route.constraint';
+import { IsMapOfStrings } from './decorators/is-map-of-strings.decorator';
+import { IsRoute } from './decorators/is-route.decorator';
+import { HandledException } from './exceptions/custom.exception';
+import { validationExceptionFactory } from './factories/exception.factory';
+import { BaseExceptionsFilter } from './filters/base-exception.filter';
+import { RecordDTO } from './models/dtos/record.dto';
+import { StateParamDTO } from './models/dtos/state-params.dto';
+import { RecordState } from './models/enums/record-state.enum';
+//import { IBase } from './models/interfaces/base.interface';
+import { IRecord } from './models/interfaces/record.interface';
+import {
+  RESTError,
+  RESTPage,
+  RESTPaging,
+  RESTRequestBody,
+  RESTResponseBody,
+  RESTResult,
+  RESTSort,
+  SortDirection,
+} from './models/wrappers/rest-wrapper.class';
+import { ConfigUtil } from './utils/config-util.class';
+import { ISession } from './models/interfaces/session/session.interface';
+import { ISessionUserData } from './models/interfaces/session/session-data.interface';
+import { SessionClient } from './clients/session.client';
+import { RedisService } from './modules/cache/services/redis.service';
+import { SessionService } from './modules/cache/services/session.service';
+import { CacheModule } from './modules/cache/cache.module';
+import { PermissionGuard } from './modules/cache/guards/permission.guard';
+import { generateUUID } from './functions/generate-uuid.function';
+import { Permission } from './modules/cache/reflector/permission.reflector';
+import { PermissionsIncludeStrategy } from './models/enums/permission-include-strategy.enum';
+import { PermissionGuardConfig } from './models/wrappers/permission-guard-config.wrapper';
+import { ClientPermissions } from './models/wrappers/client-permissions.wrapper';
+import { Record } from './models/embedded/record.embedded';
+import { ValidateMongoIdPipe } from './pipes/validate-mongo-id.pipe';
+import { escapeRegex } from './functions/escape-regex.function';
+import { translitGeorgiaToLatin } from './functions/transliterate-geo-to-latin';
+import { getRandomNumberFromRange } from './functions/random-range.function';
+import { sizeOfJson } from './functions/json-size.function';
+import { HTTPMethod } from './models/enums/http-method.enum';
+import { LogModule } from './modules/log/log.module';
+import { LogService } from './modules/log/services/log.service';
+import { LoggerClient } from './clients/logger.client';
+//import { Stage } from './models/enums/stage.enum';
+import { Env } from './models/enums/env.enum';
+import { ConsoleLogger } from './utils/console-logger.class';
+export {
+  IsMapOfStringsConstraint,
+  IsRouteConstraint,
+  IsMapOfStrings,
+  IsRoute,
+  HandledException,
+  validationExceptionFactory,
+  BaseExceptionsFilter,
+  RecordDTO,
+  StateParamDTO,
+  RecordState,
+  //IBase,
+  IRecord,
+  SortDirection,
+  RESTSort,
+  RESTPaging,
+  RESTRequestBody,
+  RESTPage,
+  RESTResult,
+  RESTError,
+  RESTResponseBody,
+  ConfigUtil,
+  ISession,
+  ISessionUserData,
+  SessionClient,
+  RedisService,
+  SessionService,
+  CacheModule,
+  PermissionGuard,
+  generateUUID,
+  Permission,
+  PermissionsIncludeStrategy,
+  PermissionGuardConfig,
+  ClientPermissions,
+  Record,
+  ValidateMongoIdPipe,
+  escapeRegex,
+  translitGeorgiaToLatin,
+  getRandomNumberFromRange,
+  sizeOfJson,
+  HTTPMethod,
+  LogModule,
+  LogService,
+  LoggerClient,
+  //Stage,
+  Env,
+  ConsoleLogger,
+};

package/src/models/dtos/record.dto.ts

@@ -0,0 +1,12 @@
+import { IsBoolean, IsEnum, IsOptional } from 'class-validator';
+import { RecordState } from '../enums/record-state.enum';
+
+export class RecordDTO {
+  @IsOptional()
+  @IsEnum(RecordState, { each: true })
+  public states: RecordState[];
+
+  @IsOptional()
+  @IsBoolean()
+  public deleted: boolean;
+}