@pcg/core 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,2171 @@
+import { Catch, ConsoleLogger, Global, HttpException, HttpServer, HttpStatus, Inject, Injectable, Module, ValidationPipe } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { Brackets, DataSource, DefaultNamingStrategy, In, IsNull } from "typeorm";
+import { getConfigToken, registerAs } from "@nestjs/config";
+import { createRandomString, pluralToSingular, singularToPlural, snakeCase } from "@pcg/text-kit";
+import { Type as Type$1, plainToInstance } from "class-transformer";
+import { IsBoolean, IsEnum, IsNumber, IsOptional, IsString, Min, validateSync } from "class-validator";
+import { ArgsType, Field, Int, ObjectType } from "@nestjs/graphql";
+import { isFunction, isObject as isObject$1, isPlainObject } from "@nestjs/common/utils/shared.utils";
+import { GraphQLError } from "graphql";
+import { AbstractLogger } from "typeorm/logger/AbstractLogger.js";
+import * as winston from "winston";
+import { Logger as Logger$1, createLogger, format } from "winston";
+import clc from "cli-color";
+import fg from "fast-glob";
+import { parse } from "accept-language-parser";
+import { GqlArgumentsHost } from "@nestjs/graphql/dist/services/gql-arguments-host";
+
+//#region src/enums/app-env.enum.ts
+/**
+* Application environment enum
+*/
+let AppEnv = /* @__PURE__ */ function(AppEnv$1) {
+	/**
+	* Local environment.
+	* Used for local development on your machine.
+	*/
+	AppEnv$1["LOCAL"] = "local";
+	/**
+	* Test environment.
+	* Used when running tests.
+	*/
+	AppEnv$1["TEST"] = "test";
+	/**
+	* Development environment.
+	* Used when deploying to a development server.
+	* Development server provide early access to new features.
+	*/
+	AppEnv$1["DEVELOPMENT"] = "development";
+	/**
+	* Stage environment.
+	* Used when deploying to a stage server.
+	* Stage is a pre-production environment.
+	*/
+	AppEnv$1["STAGE"] = "stage";
+	/**
+	* Production environment.
+	* Used when deploying to a production server.
+	*/
+	AppEnv$1["PRODUCTION"] = "production";
+	return AppEnv$1;
+}({});
+
+//#endregion
+//#region src/enums/app-mode.enum.ts
+let AppMode = /* @__PURE__ */ function(AppMode$1) {
+	AppMode$1["STANDALONE"] = "standalone";
+	AppMode$1["PARENT"] = "parent";
+	AppMode$1["CHILD"] = "child";
+	return AppMode$1;
+}({});
+
+//#endregion
+//#region src/tools/env.ts
+/**
+* Validate environment variables using class-validator
+*
+* @param cls - class with environment variables
+* @throws Error if validation fails
+* @returns validated config as typed object
+* @example
+* ```ts
+* export class AppConfigEnvironmentVariables {
+*  @Type(() => Number)
+*  @IsNumber()
+*  PORT = 3000;
+* }
+*
+* const env = validateEnv(AppConfigEnvironmentVariables); // typed object
+* // env.PORT is now a number
+* ```
+*/
+const validateEnv = (cls) => {
+	const validatedConfig = plainToInstance(cls, process.env, { enableImplicitConversion: true });
+	const errors = validateSync(validatedConfig, { skipMissingProperties: false });
+	if (errors.length > 0) throw new Error(errors.toString());
+	return validatedConfig;
+};
+/**
+* Returns a string with a dash prefix based on the current environment.
+* If the environment is development or local, returns '-dev'.
+* If the environment is stage, returns '-stage'.
+* Otherwise, returns an empty string.
+*
+* @returns a string with a dash prefix based on the current environment
+* @example
+* ```typescript
+* const name = `my-app${withDashEnv()}`;
+* ```
+*/
+const withDashEnv = () => {
+	if (process.env.APP_ENV === AppEnv.DEVELOPMENT || process.env.APP_ENV === AppEnv.LOCAL || process.env.APP_ENV === AppEnv.TEST) return "-dev";
+	if (process.env.APP_ENV === AppEnv.STAGE) return "-stage";
+	return "";
+};
+/**
+* Returns a string with a dash prefix based on the current environment.
+* If the environment is development or local, returns '.dev'.
+* If the environment is stage, returns '.stage'.
+* Otherwise, returns an empty string.
+*
+* @returns a string with a dot prefix based on the current environment
+* @example
+* ```typescript
+* const name = `config${withDotEnv()}`;
+* ```
+*/
+const withDotEnv = () => {
+	if (process.env.APP_ENV === AppEnv.DEVELOPMENT || process.env.APP_ENV === AppEnv.LOCAL || process.env.APP_ENV === AppEnv.TEST) return ".dev";
+	if (process.env.APP_ENV === AppEnv.STAGE) return ".stage";
+	return "";
+};
+/**
+* Returns a string with a colon prefix based on the current environment.
+* If the environment is development or local, returns ':dev'.
+* If the environment is stage, returns ':stage'.
+* Otherwise, returns an empty string.
+*
+* @returns a string with a colon prefix based on the current environment
+* @example
+* ```typescript
+* const name = `my:app${withColonEnv()}`;
+* ```
+*/
+const withColonEnv = () => {
+	if (process.env.APP_ENV === AppEnv.DEVELOPMENT || process.env.APP_ENV === AppEnv.LOCAL || process.env.APP_ENV === AppEnv.TEST) return ":dev";
+	if (process.env.APP_ENV === AppEnv.STAGE) return ":stage";
+	return "";
+};
+/**
+* Returns a string with an underscore prefix based on the current environment.
+* If the environment is development or local, returns '_dev'.
+* If the environment is stage, returns '_stage'.
+* Otherwise, returns an empty string.
+*
+* @returns a string with an underscore prefix based on the current environment
+* @example
+* ```typescript
+* const name = `my_app${withUnderscoreEnv()}`;
+* ```
+*/
+const withUnderscoreEnv = () => {
+	if (process.env.APP_ENV === AppEnv.DEVELOPMENT || process.env.APP_ENV === AppEnv.LOCAL || process.env.APP_ENV === AppEnv.TEST) return "_dev";
+	if (process.env.APP_ENV === AppEnv.STAGE) return "_stage";
+	return "";
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/configs/app.config.ts
+var _ref$4;
+/**
+* NestJS injection token for app config
+*/
+const APP_CONFIG_TOKEN = "APP_CONFIG_TOKEN";
+const InjectAppConfig = () => Inject(getConfigToken(APP_CONFIG_TOKEN));
+/**
+* Application config environment variables
+*/
+var AppConfigEnvironmentVariables = class {
+	/**
+	* Application port
+	* @example
+	* ```yaml
+	* PORT: 3000
+	* ```
+	*/
+	PORT = 3e3;
+	/**
+	* Application host
+	* @example
+	* ```yaml
+	* APP_HOST: 'https://app-api.example.com'
+	* # or
+	* APP_HOST: 'http://localhost:3000'
+	* ```
+	*/
+	APP_HOST;
+	/**
+	* Application UI host
+	* @example
+	* ```yaml
+	* APP_UI_HOST: 'https://app.example.com'
+	* # or
+	* APP_UI_HOST: 'http://localhost:4200'
+	* ```
+	*/
+	APP_UI_HOST;
+	/**
+	* Application environment. Can be 'local', 'development', 'stage', 'production'
+	* @example
+	* ```yaml
+	* APP_ENV: 'local'
+	* ```
+	*/
+	APP_ENV;
+	/**
+	* Application service account id (user with type SA in users table)
+	* @example
+	* ```yaml
+	* APP_SERVICE_ACCOUNT_ID: 'hcu:xxxxxxxxxxx'
+	* ```
+	*/
+	APP_SERVICE_ACCOUNT_ID;
+	/**
+	* Application fallback language
+	* @example
+	* ```yaml
+	* FALLBACK_LANGUAGE: 'es'
+	* ```
+	*/
+	FALLBACK_LANGUAGE = "en";
+};
+__decorate([
+	Type$1(() => Number),
+	IsNumber(),
+	__decorateMetadata("design:type", Object)
+], AppConfigEnvironmentVariables.prototype, "PORT", void 0);
+__decorate([
+	IsOptional(),
+	IsString(),
+	__decorateMetadata("design:type", String)
+], AppConfigEnvironmentVariables.prototype, "APP_HOST", void 0);
+__decorate([
+	IsOptional(),
+	IsString(),
+	__decorateMetadata("design:type", String)
+], AppConfigEnvironmentVariables.prototype, "APP_UI_HOST", void 0);
+__decorate([IsEnum(AppEnv), __decorateMetadata("design:type", typeof (_ref$4 = typeof AppEnv !== "undefined" && AppEnv) === "function" ? _ref$4 : Object)], AppConfigEnvironmentVariables.prototype, "APP_ENV", void 0);
+__decorate([
+	IsOptional(),
+	IsString(),
+	__decorateMetadata("design:type", String)
+], AppConfigEnvironmentVariables.prototype, "APP_SERVICE_ACCOUNT_ID", void 0);
+__decorate([
+	IsOptional(),
+	IsString(),
+	__decorateMetadata("design:type", Object)
+], AppConfigEnvironmentVariables.prototype, "FALLBACK_LANGUAGE", void 0);
+/**
+* Create Main Application Config
+* @example
+* ```ts
+* // src/config/index.ts
+*
+* import { createAppConfig } from '#/dist/configs';
+*
+* export const appConfig = createAppConfig({
+*  name: 'Jetstream',
+*  shortname: 'js',
+* });
+* ```
+*/
+const createAppConfig = (opts) => {
+	return registerAs(APP_CONFIG_TOKEN, () => {
+		const env = validateEnv(AppConfigEnvironmentVariables);
+		return {
+			env: env.APP_ENV,
+			name: opts.name,
+			shortname: opts.shortname,
+			port: env.PORT,
+			host: env.APP_HOST,
+			mode: opts.mode || AppMode.STANDALONE,
+			uiHost: env.APP_UI_HOST,
+			appServiceAccountId: env.APP_SERVICE_ACCOUNT_ID,
+			fallbackLanguage: env.FALLBACK_LANGUAGE
+		};
+	});
+};
+
+//#endregion
+//#region src/enums/app-server.enum.ts
+/**
+* Enum for the NestJS server mode
+*/
+let AppServer = /* @__PURE__ */ function(AppServer$1) {
+	/**
+	* NestJS HTTP server with GraphQL
+	*/
+	AppServer$1["HTTP"] = "http";
+	/**
+	* NestJS gRPC server
+	*/
+	AppServer$1["GRPC"] = "grpc";
+	/**
+	* NestJS WebSocket server
+	*/
+	AppServer$1["WS"] = "ws";
+	/**
+	* Run as a worker
+	*/
+	AppServer$1["WORKER"] = "worker";
+	/**
+	* Run as an agent
+	*/
+	AppServer$1["AGENT"] = "agent";
+	/**
+	* Run as an bot (e.g. Slack bot)
+	*/
+	AppServer$1["BOT"] = "bot";
+	/**
+	* Run as Cloud Run job
+	*/
+	AppServer$1["CLOUDRUN_JOB"] = "cloudrun-job";
+	return AppServer$1;
+}({});
+
+//#endregion
+//#region src/enums/worker-mode.enum.ts
+let WorkerMode = /* @__PURE__ */ function(WorkerMode$1) {
+	/**
+	* Run jobs in loop
+	*/
+	WorkerMode$1["LOOP"] = "loop";
+	/**
+	* Run one job and exit
+	*/
+	WorkerMode$1["ONE_JOB"] = "one-job";
+	return WorkerMode$1;
+}({});
+
+//#endregion
+//#region src/tools/generate-entity-id.ts
+/**
+* Generates a unique entity identifier by combining product name, entity prefix, delimiter, and random string.
+*
+* @param product - The product short name to include in the entity ID (e.g., 'fwd' for Forward)
+* @param prefix - The entity type prefix to include in the entity ID (e.g., 'u' for user, 'org' for organization)
+* @param delimiter - The delimiter to separate components (default: ':')
+* @param size - The length of the random string component (default: 11)
+* @returns A formatted entity ID string in the format: `${product}${prefix}${delimiter}${randomString}`
+*
+* @example
+* ```typescript
+* generateEntityId('fwd', 'org')
+* // Returns: 'fwdorg:A1b2C3d4E5f'
+*
+* generateEntityId('myapp', 'u', '_', 8)
+* // Returns: 'myappuser_A1b2C3d4'
+* ```
+*/
+const generateEntityId = (product, prefix, delimiter = ":", size = 11) => {
+	return `${product}${prefix}${delimiter}${createRandomString(size)}`;
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+//#region src/modules/id/id.service.ts
+let IdService = class IdService$1 {
+	constructor(appConfig) {
+		this.appConfig = appConfig;
+	}
+	/**
+	* Returns a delimiter string based on the current environment.
+	* This delimiter is used in constructing the entity IDs.
+	* The delimiter is ':dev:' for development environments,
+	* :stage:' for staging environments and ':' for other environments.
+	*
+	* This allows for better differentiation and traceability of entities across various environments.
+	*/
+	get delimiter() {
+		switch (this.appConfig.env) {
+			case AppEnv.TEST: return ":test:";
+			case AppEnv.DEVELOPMENT: return ":dev:";
+			case AppEnv.STAGE: return ":stage:";
+			default: return ":";
+		}
+	}
+	/**
+	* Generates unique id for entity
+	* @param prefix - entity id prefix in database (e.g. 'u' for users)
+	* @param app - app shortname (e.g. 'js')
+	* @returns id in format 'jsu:xxxxxxxxxxx' or 'jsu:stage:xxxxxxxxxxx' for staging environment
+	*/
+	generateEntityId(prefix, app) {
+		return generateEntityId(app ?? this.appConfig.shortname, prefix, this.delimiter, 11);
+	}
+	/**
+	* Generates unique id with length 11
+	* @returns id in format 'xxxxxxxxxxx'
+	*/
+	generateId(size) {
+		return createRandomString(size);
+	}
+};
+IdService = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(getConfigToken(APP_CONFIG_TOKEN))),
+	__decorateMetadata("design:paramtypes", [Object])
+], IdService);
+
+//#endregion
+//#region src/modules/id/id.module.ts
+let IdModule = class IdModule$1 {};
+IdModule = __decorate([Global(), Module({
+	providers: [IdService],
+	exports: [IdService]
+})], IdModule);
+
+//#endregion
+//#region src/errors/nest-error.ts
+/**
+* Custom error class for NestJS applications that extends the native Error class.
+*
+* This error class provides additional context and structured error handling
+* capabilities beyond the standard Error object.
+*
+* @example
+* ```typescript
+* throw new NestError({
+*   key: 'AUTH_USER_NOT_FOUND',
+*   message: 'User with the specified ID was not found',
+*   context: { userId: '123' },
+*   cause: originalError
+* });
+* ```
+*/
+var NestError = class extends Error {
+	key;
+	context;
+	httpStatusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+	silent;
+	constructor(opts) {
+		super(opts.message, opts.cause instanceof Error ? { cause: opts.cause } : void 0);
+		this.name = "NestError";
+		this.key = opts.key;
+		this.context = opts.context;
+		this.silent = opts.silent ?? false;
+	}
+};
+
+//#endregion
+//#region src/errors/bad-request.error.ts
+var BadRequestError = class extends NestError {
+	constructor(opts) {
+		super(opts);
+		this.name = "BadRequestError";
+		this.httpStatusCode = 400;
+	}
+};
+
+//#endregion
+//#region src/errors/not-found.error.ts
+var NotFoundError = class extends NestError {
+	constructor(opts) {
+		super(opts);
+		this.name = "NotFoundError";
+		this.httpStatusCode = 404;
+	}
+};
+
+//#endregion
+//#region src/pagination/constants.ts
+/**
+* Pagination default limit value
+*/
+const PAGINATION_DEFAULT_LIMIT = 20;
+
+//#endregion
+//#region src/errors/forbidden.error.ts
+var ForbiddenError = class extends NestError {
+	constructor(opts) {
+		super(opts);
+		this.name = "ForbiddenError";
+		this.httpStatusCode = 403;
+	}
+};
+
+//#endregion
+//#region src/errors/access-denied.error.ts
+var AccessDeniedError = class extends ForbiddenError {
+	constructor(opts) {
+		super({
+			key: "AUTH_ACCESS_DENIED",
+			message: opts.message || `Access denied: you don't have permission to perform "${opts.action}" action`,
+			context: opts.context
+		});
+		this.name = "AccessDeniedError";
+	}
+};
+
+//#endregion
+//#region src/errors/input-validation.error.ts
+var InputValidationError = class extends NestError {
+	constructor(errors) {
+		super({
+			message: "Input validation failed",
+			key: "NST_INPUT_VALIDATION_ERROR",
+			context: errors ? { errors } : void 0
+		});
+		this.name = "InputValidationError";
+		this.httpStatusCode = 400;
+	}
+};
+
+//#endregion
+//#region src/errors/unauthorized.error.ts
+var UnauthorizedError = class extends NestError {
+	constructor(opts) {
+		super(opts);
+		this.name = "UnauthorizedError";
+		this.httpStatusCode = 401;
+	}
+};
+
+//#endregion
+//#region src/pagination/cursor/cursor-pagination.types.ts
+let CursorPaginationPageInfo = class CursorPaginationPageInfo$1 {
+	/**
+	* The cursor to the first item in the list
+	*/
+	startCursor;
+	/**
+	* The cursor to the last item in the list
+	*/
+	endCursor;
+	/**
+	* Whether there are more items in the list before the start cursor
+	*/
+	hasPreviousPage;
+	/**
+	* Whether there are more items in the list after the end cursor
+	*/
+	hasNextPage;
+};
+__decorate([Field(() => String, { nullable: true }), __decorateMetadata("design:type", Object)], CursorPaginationPageInfo.prototype, "startCursor", void 0);
+__decorate([Field(() => String, { nullable: true }), __decorateMetadata("design:type", Object)], CursorPaginationPageInfo.prototype, "endCursor", void 0);
+__decorate([Field(() => Boolean, { nullable: true }), __decorateMetadata("design:type", Boolean)], CursorPaginationPageInfo.prototype, "hasPreviousPage", void 0);
+__decorate([Field(() => Boolean, { nullable: true }), __decorateMetadata("design:type", Boolean)], CursorPaginationPageInfo.prototype, "hasNextPage", void 0);
+CursorPaginationPageInfo = __decorate([ObjectType()], CursorPaginationPageInfo);
+
+//#endregion
+//#region src/pagination/cursor/cursor-pagination.input.ts
+let CursorPaginationInput = class CursorPaginationInput$1 {
+	/**
+	* The amount of items to be requested per page from the start
+	* @example
+	* ```graphql
+	* query {
+	*  messages(first: 3) {
+	*   edges {
+	*    cursor
+	*    node {
+	*     id
+	*    }
+	*   }
+	*  }
+	* }
+	* ```
+	*/
+	first;
+	/**
+	* The cursor to start the pagination
+	* @example
+	* ```graphql
+	* query {
+	*  messages(first: 3, after: "xxx") {
+	*   edges {
+	*    cursor
+	*    node {
+	*     id
+	*    }
+	*   }
+	*  }
+	* }
+	* ```
+	*/
+	after;
+	/**
+	* The amount of items to be requested per page from the end
+	* @example
+	* ```graphql
+	* query {
+	*  messages(last: 2) {
+	*   edges {
+	*    cursor
+	*    node {
+	*     id
+	*    }
+	*   }
+	*  }
+	* }
+	* ```
+	*/
+	last;
+	/**
+	* The cursor to end the pagination
+	* @example
+	* ```graphql
+	* query {
+	*  messages(last: 2, before: "xxx") {
+	*   edges {
+	*    cursor
+	*    node {
+	*     id
+	*    }
+	*   }
+	*  }
+	* }
+	* ```
+	*/
+	before;
+};
+__decorate([
+	Field(() => Int, { nullable: true }),
+	Min(1),
+	IsOptional(),
+	__decorateMetadata("design:type", Number)
+], CursorPaginationInput.prototype, "first", void 0);
+__decorate([Field(() => String, { nullable: true }), __decorateMetadata("design:type", String)], CursorPaginationInput.prototype, "after", void 0);
+__decorate([
+	Field(() => Int, { nullable: true }),
+	Min(1),
+	IsOptional(),
+	__decorateMetadata("design:type", Number)
+], CursorPaginationInput.prototype, "last", void 0);
+__decorate([Field(() => String, { nullable: true }), __decorateMetadata("design:type", String)], CursorPaginationInput.prototype, "before", void 0);
+CursorPaginationInput = __decorate([ArgsType()], CursorPaginationInput);
+
+//#endregion
+//#region src/pagination/offset/offset-pagination.helpers.ts
+/**
+* Extract sort field name and sort direction from orderBy string.
+* @example
+* const orderBy = 'createdAt_ASC';
+*
+* // sort.fieldName = 'createdAt', sort.direction = 'ASC'; sort.columnName = 'created_at';
+* const sort = extractSortParams(orderBy);
+*/
+const extractSortParams = (orderBy) => {
+	const slices = orderBy.split("_");
+	if (slices.length !== 2) throw new Error("Invalid orderBy argument");
+	return {
+		fieldName: slices[0],
+		direction: slices[1],
+		columnName: snakeCase(slices[0])
+	};
+};
+
+//#endregion
+//#region src/pagination/offset/offset-pagination.input.ts
+let OffsetPaginationInput = class OffsetPaginationInput$1 {
+	/**
+	* the amount of items to be requested per page
+	*/
+	limit;
+	/**
+	* @default 1
+	* the page that is requested
+	*/
+	page = 1;
+};
+__decorate([Field(() => Int, {
+	description: "the amount of items to be requested per page",
+	defaultValue: PAGINATION_DEFAULT_LIMIT,
+	nullable: true
+}), __decorateMetadata("design:type", Number)], OffsetPaginationInput.prototype, "limit", void 0);
+__decorate([Field(() => Int, {
+	defaultValue: 1,
+	description: "the page that is requested"
+}), __decorateMetadata("design:type", Number)], OffsetPaginationInput.prototype, "page", void 0);
+OffsetPaginationInput = __decorate([ArgsType()], OffsetPaginationInput);
+
+//#endregion
+//#region src/pagination/offset/offset-pagination.types.ts
+let OffsetPaginationPageInfo = class OffsetPaginationPageInfo$1 {
+	/**
+	* The total amount of pages
+	* (total items / limit)
+	*/
+	totalPages;
+	/**
+	* The total amount of items
+	*/
+	totalItems;
+	/**
+	* The current page
+	*/
+	page;
+	/**
+	* The amount of items to be requested per page
+	*/
+	limit;
+};
+__decorate([Field(() => Int, { description: "The total amount of pages (total items / limit)" }), __decorateMetadata("design:type", Number)], OffsetPaginationPageInfo.prototype, "totalPages", void 0);
+__decorate([Field(() => Int, { description: "The total amount of items" }), __decorateMetadata("design:type", Number)], OffsetPaginationPageInfo.prototype, "totalItems", void 0);
+__decorate([Field(() => Int, { description: "The current page" }), __decorateMetadata("design:type", Number)], OffsetPaginationPageInfo.prototype, "page", void 0);
+__decorate([Field(() => Int, { description: "The amount of items to be requested per page" }), __decorateMetadata("design:type", Number)], OffsetPaginationPageInfo.prototype, "limit", void 0);
+OffsetPaginationPageInfo = __decorate([ObjectType()], OffsetPaginationPageInfo);
+
+//#endregion
+//#region src/tools/stringify-opts.ts
+/**
+* Converts an object into a human-readable string representation.
+*
+* Takes an object and transforms it into a string where each key-value pair
+* is formatted as "key JSON-value" and all pairs are joined with " and ".
+*
+* @param opts - The object to stringify
+* @returns A string representation of the object with entries joined by " and "
+*
+* @example
+* ```ts
+* stringifyOpts({ name: 'John', age: 30 })
+* // Returns: 'name "John" and age 30'
+* ```
+*/
+const stringifyOpts = (opts) => {
+	return Object.entries(opts).map(([key, value]) => `${key} ${JSON.stringify(value)}`).join(" and ");
+};
+
+//#endregion
+//#region src/logger/logger.constants.ts
+/**
+* Injection token for Winston logger module configuration options
+*/
+const NESTKIT_LOGGER_MODULE_OPTIONS = "NestKitLoggerModuleOptions";
+/**
+* Injection token for the Winston logger instance provider
+*/
+const NESTKIT_WINSTON_LOGGER_PROVIDER = "NestKitLogger";
+/**
+* Injection token for the main NestKit logger provider
+*/
+const NESTKIT_LOGGER_PROVIDER = "NestKitLogger";
+/**
+* Injection token for the NestJS system logger provider
+*/
+const NESTKIT_SYSTEM_LOGGER_PROVIDER = "NestKitSystemLogger";
+/**
+* Injection token for the logger factory provider
+*/
+const NESTKIT_LOGGER_FACTORY_PROVIDER = "NestKitLoggerFactory";
+
+//#endregion
+//#region src/tools/is-object.ts
+/**
+* Checks if the given value is an object (not an array).
+* @param {unknown} obj - The value to check.
+* @returns {boolean} Returns true if `obj` is an object, false otherwise.
+* @example
+* isObject({ a: 1 });  // Returns true
+* isObject([1, 2, 3]);  // Returns false
+*/
+const isObject = (obj) => obj !== null && !!obj && typeof obj === "object" && !Array.isArray(obj);
+
+//#endregion
+//#region src/logger/classes/logger.ts
+/**
+* Logger with context for NestJS (from NestKit)
+*/
+var Logger = class Logger {
+	constructor(winstonLogger, context = {}) {
+		this.winstonLogger = winstonLogger;
+		this.context = context;
+	}
+	/**
+	* Created child logger with specific context
+	* @param context - object with scope, action and other data
+	* @returns - new logger with context
+	* @example
+	* ```ts
+	* class SomeService {
+	*  logger: Logger;
+	*
+	*  constructor(
+	*   @InjectLoggerFactory() private readonly loggerFactory: LoggerFactory,
+	* ) {
+	*  // Create logger for this service
+	*  this.winstonLogger = this.winstonLoggerFactory.create({
+	*   scope: SomeService.name,
+	*  })
+	* }
+	*
+	* // Create child logger for some method
+	* getOne(id: string) {
+	*   const logger = this.winstonLogger.child({
+	*    action: this.someMethod.name,
+	*    id,
+	*   });
+	* }
+	* ```
+	*/
+	child(context) {
+		return new Logger(this.winstonLogger, {
+			...this.context,
+			...context
+		});
+	}
+	/**
+	* Created child logger for nest service method
+	* Automatically parse service method context and add it to logger context
+	* @param name - service method name
+	* @param ctx - service method context
+	* @param other - custom logger context
+	* @returns - new logger with context
+	*/
+	forMethod(name, ctx, other) {
+		const context = { action: name };
+		if (ctx) {
+			Object.assign(context, { requestId: ctx.requestId });
+			if (!ctx.user) throw new Error("User is required for strict method context. Use guards: @UseGuards(JwtAuthGuard) or @UseGuards(GraphQLJwtAuthGuard)");
+			Object.assign(context, {
+				requestId: ctx.requestId,
+				userId: ctx.user.id
+			});
+		}
+		if (other) Object.assign(context, other);
+		return this.child(context);
+	}
+	setContext(...args) {
+		if (args.length === 2 && typeof args[0] === "string" && typeof args[1] !== "undefined") {
+			const key = args[0];
+			const value = args[1];
+			this.context[key] = value;
+		} else this.context = {
+			...this.context,
+			...args[0]
+		};
+	}
+	/**
+	* Get logger context data
+	* @returns - logger context
+	*/
+	getContext() {
+		return structuredClone(this.context);
+	}
+	log(...args) {
+		if (isObject(args[0])) this.winstonLogger.log({
+			...this.context,
+			...args[0]
+		});
+		else this.winstonLogger.log({
+			level: args[0],
+			message: args[1],
+			...this.context,
+			...args[2]
+		});
+	}
+	info(...args) {
+		if (typeof args[0] === "string") this.winstonLogger.info({
+			message: args[0],
+			...this.context,
+			...args[1]
+		});
+		else this.winstonLogger.info({
+			...this.context,
+			...args[0]
+		});
+	}
+	error(...args) {
+		if (args[0] instanceof NestError) {
+			const err = args[0];
+			this.winstonLogger.error({
+				...this.context,
+				...args[1],
+				...this.destructureError(err)
+			});
+		} else if (args[0] instanceof Error) {
+			const err = args[0];
+			this.winstonLogger.error({
+				...this.context,
+				...args[1],
+				...this.destructureError(err)
+			});
+		} else if (typeof args[0] === "string" && args[1] instanceof Error) {
+			const message = args[0];
+			const err = args[1];
+			this.winstonLogger.error({
+				message,
+				...this.context,
+				...args[2],
+				error: this.destructureError(err)
+			});
+		} else if (typeof args[0] === "string") {
+			const message = args[0];
+			this.winstonLogger.error({
+				message,
+				...this.context,
+				...args[1]
+			});
+		}
+	}
+	/**
+	* Creates plain object from error
+	* @see {@link DestructuredError}
+	*/
+	destructureError(error) {
+		const errorObject = {};
+		if (error instanceof NestError) {
+			errorObject.message = error.message;
+			errorObject.stack = error.stack;
+			errorObject.context = error.context;
+			errorObject.statusCode = error.httpStatusCode;
+			errorObject.errorKey = error.key;
+			if (error.cause instanceof Error) errorObject.cause = this.destructureError(error.cause);
+		} else if (error instanceof Error) {
+			errorObject.message = error.message;
+			errorObject.stack = error.stack;
+		}
+		if (error instanceof HttpException) {
+			errorObject.statusCode = error.getStatus();
+			const response = error.getResponse();
+			if (isObject(response)) {
+				if (response.key) errorObject.errorKey = response.key;
+				if (response.context) {
+					if (!errorObject.context) errorObject.context = {};
+					errorObject.context = {
+						...errorObject.context,
+						...response.context
+					};
+				}
+				if (response.error) errorObject.cause = this.destructureError(response.error);
+			}
+			return errorObject;
+		} else if (error instanceof GraphQLError) {
+			const ctx = JSON.parse(JSON.stringify({
+				locations: error.locations,
+				positions: error.positions,
+				source: error.source
+			}));
+			errorObject.context = {
+				...errorObject.context,
+				...ctx
+			};
+		}
+		return errorObject;
+	}
+	warn(...args) {
+		if (typeof args[0] === "string") this.winstonLogger.warn({
+			message: args[0],
+			...this.context,
+			...args[1]
+		});
+		else this.winstonLogger.warn({
+			...this.context,
+			...args[0]
+		});
+	}
+	debug(...args) {
+		if (typeof args[0] === "string") this.winstonLogger.debug({
+			message: args[0],
+			...this.context,
+			...args[1]
+		});
+		else this.winstonLogger.debug({
+			...this.context,
+			...args[0]
+		});
+	}
+	verbose(...args) {
+		if (typeof args[0] === "string") this.winstonLogger.verbose({
+			message: args[0],
+			...this.context,
+			...args[1]
+		});
+		else this.winstonLogger.verbose({
+			...this.context,
+			...args[0]
+		});
+	}
+};
+
+//#endregion
+//#region src/logger/classes/nest-system-logger.ts
+var _ref$3;
+let NestSystemLogger = class NestSystemLogger$1 extends ConsoleLogger {
+	logger;
+	printMessages(messages, context, logLevel) {
+		for (const message of messages) this.logger.log(this.getWinstonLogLevel(logLevel), this.stringifyMessage(message), { scope: context });
+	}
+	stringifyMessage(message) {
+		if (isFunction(message)) return this.stringifyMessage(message());
+		if (isPlainObject(message) || Array.isArray(message)) return JSON.stringify(message, (key, value) => typeof value === "bigint" ? value.toString() : value, 2);
+		return String(message);
+	}
+	getWinstonLogLevel(level) {
+		switch (level) {
+			case "log": return "info";
+			case "verbose": return "verbose";
+			case "debug": return "debug";
+			case "warn": return "warn";
+			case "error": return "error";
+			default: return "info";
+		}
+	}
+};
+__decorate([Inject(NESTKIT_LOGGER_PROVIDER), __decorateMetadata("design:type", typeof (_ref$3 = typeof Logger !== "undefined" && Logger) === "function" ? _ref$3 : Object)], NestSystemLogger.prototype, "logger", void 0);
+NestSystemLogger = __decorate([Injectable()], NestSystemLogger);
+
+//#endregion
+//#region src/logger/classes/typeorm-logger.ts
+var TypeOrmLoggerOptions = class {
+	enabled;
+	logger;
+	levels;
+};
+var TypeOrmLogger = class extends AbstractLogger {
+	logger;
+	constructor(opts) {
+		super(opts.enabled && opts.levels ? opts.levels : false);
+		this.logger = opts.logger;
+	}
+	/**
+	* Write log to specific output.
+	*/
+	writeLog(level, logMessage) {
+		const messages = this.prepareLogMessages(logMessage, { highlightSql: false });
+		for (const message of messages) switch (message.type ?? level) {
+			case "log":
+			case "query":
+			case "schema-build":
+				this.logger.debug(String(message.message), this.getCtx(message));
+				break;
+			case "migration":
+			case "info":
+				if (message.prefix) this.logger.info(`${message.prefix} ${message.message}`, this.getCtx(message));
+				else this.logger.info(String(message.message), this.getCtx(message));
+				break;
+			case "warn":
+			case "query-slow":
+				if (message.prefix) this.logger.warn(`${message.prefix} ${message.message}`, this.getCtx(message));
+				else this.logger.warn(String(message.message), this.getCtx(message));
+				break;
+			case "error":
+			case "query-error":
+				if (message.prefix) this.logger.error(`[${message.prefix}] ${message.message}`, this.getCtx(message));
+				else this.logger.error(String(message.message), this.getCtx(message));
+				break;
+		}
+	}
+	getCtx(message) {
+		const ctx = { ...message.additionalInfo };
+		if (Array.isArray(ctx.parameters)) ctx.parameters = message.parameters;
+		return ctx;
+	}
+};
+
+//#endregion
+//#region src/logger/classes/logger-factory.ts
+/**
+* Logger factory for creating loggers with predefined context
+* Factory is singleton, so it keep original winston `Logger` instance
+* and is can be injected to any service
+*/
+var LoggerFactory = class {
+	constructor(winstonLogger, context = {}) {
+		this.winstonLogger = winstonLogger;
+		this.context = context;
+	}
+	/**
+	* Created new logger with specific context merge it with global context
+	* @param context - specific action with scope, and other data
+	* @returns - new logger with context
+	* @example
+	* ```ts
+	* class SomeService {
+	*  logger: Logger;
+	*
+	*  constructor(
+	*   @InjectLoggerFactory() private readonly loggerFactory: LoggerFactory,
+	* ) {
+	*  // Create logger for this service
+	*  this.logger = this.loggerFactory.create({
+	*   scope: SomeService.name,
+	*  })
+	* }
+	* ```
+	*/
+	create(context = {}) {
+		return new Logger(this.winstonLogger, {
+			...this.context,
+			...context
+		});
+	}
+	createTypeOrmLogger(opts) {
+		return new TypeOrmLogger({
+			logger: this.create({ scope: "TypeORM" }),
+			...opts
+		});
+	}
+};
+
+//#endregion
+//#region src/logger/logger.providers.ts
+/**
+* Syntax sugar. Injects logger via NESTKIT_LOGGER_PROVIDER token
+* @example
+* ```ts
+* class SomeService {
+*  constructor(
+*   @InjectLogger() private readonly logger: Logger
+*  ) {}
+* ```
+*/
+const InjectLogger = () => Inject(NESTKIT_LOGGER_PROVIDER);
+/**
+* Syntax sugar. Injects winston logger factory by WINSTON_MODULE_FACTORY_PROVIDER token
+* @example
+* ```ts
+* class SomeService {
+*  constructor(
+*   @InjectLoggerFactory() private readonly loggerFactory: LoggerFactory
+*  ) {}
+* ```
+*/
+const InjectLoggerFactory = () => Inject(NESTKIT_LOGGER_FACTORY_PROVIDER);
+const createNestLogger = (loggerOpts) => {
+	return new Logger$1(createLogger(loggerOpts));
+};
+const createLoggerProviders = (loggerOpts) => {
+	return [
+		{
+			provide: NESTKIT_WINSTON_LOGGER_PROVIDER,
+			useFactory: () => createLogger(loggerOpts)
+		},
+		{
+			provide: NESTKIT_LOGGER_PROVIDER,
+			useFactory: (logger) => {
+				return new Logger$1(logger);
+			},
+			inject: [NESTKIT_WINSTON_LOGGER_PROVIDER]
+		},
+		{
+			provide: NESTKIT_SYSTEM_LOGGER_PROVIDER,
+			useClass: NestSystemLogger
+		},
+		{
+			provide: NESTKIT_LOGGER_FACTORY_PROVIDER,
+			useFactory: (logger) => {
+				return new LoggerFactory(logger);
+			},
+			inject: [NESTKIT_WINSTON_LOGGER_PROVIDER]
+		}
+	];
+};
+const createLoggerAsyncProviders = (options) => {
+	const providers = [
+		{
+			provide: NESTKIT_WINSTON_LOGGER_PROVIDER,
+			useFactory: (loggerOpts) => createLogger(loggerOpts),
+			inject: [NESTKIT_LOGGER_MODULE_OPTIONS]
+		},
+		{
+			provide: NESTKIT_LOGGER_PROVIDER,
+			useFactory: (logger) => {
+				return new Logger$1(logger);
+			},
+			inject: [NESTKIT_WINSTON_LOGGER_PROVIDER]
+		},
+		{
+			provide: NESTKIT_SYSTEM_LOGGER_PROVIDER,
+			useClass: NestSystemLogger
+		},
+		{
+			provide: NESTKIT_LOGGER_FACTORY_PROVIDER,
+			useFactory: (logger) => {
+				return new LoggerFactory(logger);
+			},
+			inject: [NESTKIT_WINSTON_LOGGER_PROVIDER]
+		}
+	];
+	if (options.useClass) {
+		const useClass = options.useClass;
+		providers.push(...[{
+			provide: NESTKIT_LOGGER_MODULE_OPTIONS,
+			useFactory: async (optionsFactory) => await optionsFactory.createLoggerModuleOptions(),
+			inject: [useClass]
+		}, {
+			provide: useClass,
+			useClass
+		}]);
+	}
+	if (options.useFactory) providers.push({
+		provide: NESTKIT_LOGGER_MODULE_OPTIONS,
+		useFactory: options.useFactory,
+		inject: options.inject || []
+	});
+	return providers;
+};
+
+//#endregion
+//#region src/logger/logger.module.ts
+var _LoggerModule;
+let LoggerModule = _LoggerModule = class LoggerModule$1 {
+	static forRoot(options) {
+		const providers = createLoggerProviders(options);
+		return {
+			module: _LoggerModule,
+			providers,
+			exports: providers
+		};
+	}
+	static forRootAsync(options) {
+		const providers = createLoggerAsyncProviders(options);
+		return {
+			module: _LoggerModule,
+			imports: options.imports,
+			providers,
+			exports: providers
+		};
+	}
+	static createLogger(options) {
+		return createNestLogger(options);
+	}
+};
+LoggerModule = _LoggerModule = __decorate([Global(), Module({})], LoggerModule);
+
+//#endregion
+//#region src/logger/winston.tools.ts
+const nestLikeColorScheme = {
+	log: clc.greenBright,
+	info: clc.greenBright,
+	error: clc.red,
+	warn: clc.yellow,
+	debug: clc.magentaBright,
+	verbose: clc.cyanBright
+};
+/**
+* Create a pretty message for the logger with nest-like formatting
+* Use recursion to print child errors
+* @param vars - message variables
+* @returns - formatted message
+* @example
+* [Jetstream]  - 6/10/2022, 4:33:42 PM      ERROR [VideoService.createOutput] Failed to create cloudlfare output
+*/
+const createPrettyMessage = ({ appName, action, level, timestamp, message, scope, stack, errorKey, context, parentPath, cause, deep = 0 }) => {
+	if ("undefined" !== typeof timestamp) try {
+		if (timestamp === new Date(timestamp).toISOString()) timestamp = new Date(timestamp).toLocaleString();
+	} catch {}
+	const color = nestLikeColorScheme[level] || ((text) => text);
+	if (errorKey) message += ` [${errorKey}]`;
+	const sAppName = color(`[${appName}]`);
+	const sTimestamp = timestamp ? `${timestamp} ` : "";
+	const sLevel = color(level.toUpperCase());
+	let path = "";
+	let sPath = "";
+	if ("undefined" !== typeof scope && "undefined" !== typeof action) path = `${scope}.${action}`;
+	else if ("undefined" !== typeof scope) path = scope;
+	else if ("undefined" !== typeof action) path = action;
+	if (path && parentPath) path = `${parentPath} --> ${path}`;
+	else if (parentPath) path = parentPath;
+	if (path) sPath = clc.yellow(` [${path}]`);
+	const sMessage = color(` ${message}`);
+	const sStack = "undefined" !== typeof stack ? color(`\n ${stack}`) : "";
+	let sRecursion = "";
+	if (cause) {
+		const { action: action$1, scope: scope$1,...context$1 } = cause?.context || {};
+		/**
+		* Print child errors recursively
+		*/
+		sRecursion = cause ? `\n${createPrettyMessage({
+			appName,
+			action: action$1,
+			level,
+			timestamp,
+			message: cause.message ?? message,
+			scope: scope$1,
+			stack: cause.stack,
+			errorKey: cause.errorKey,
+			context: context$1,
+			parentPath: path,
+			cause: cause.cause,
+			deep: deep + 1
+		})}` : "";
+	}
+	const sContext = context && Object.keys(context).length > 0 ? color(` -- ${JSON.stringify(context, null, 2)}`) : "";
+	return `${sAppName}  - ${sTimestamp}     ${sLevel}${sPath}${sMessage}${sStack}${sContext}${sRecursion}`;
+};
+/**
+* Create a nest-like console format
+* @param appName - App name (Jetstream, WHATSBIBLE, etc.)
+* @returns Winston format
+*/
+const nestLikeConsoleFormat = (appName = "Nest") => format.printf(({ level, timestamp, message, scope, action, stack, errorKey, statusCode, error: cause,...context }) => {
+	return createPrettyMessage({
+		appName,
+		action,
+		level,
+		timestamp,
+		message,
+		stack,
+		context,
+		scope,
+		errorKey,
+		statusCode,
+		cause,
+		deep: 0
+	});
+});
+
+//#endregion
+//#region src/configs/logger.config.ts
+/**
+* NestJS injection token for Logger config
+*/
+const LOGGER_CONFIG_TOKEN = "LOGGER_CONFIG_TOKEN";
+const InjectLoggerConfig = () => Inject(getConfigToken(LOGGER_CONFIG_TOKEN));
+/**
+* Create NestJS Logger config
+* @example
+* ```ts
+* // src/config/index.ts
+*
+* import { createLoggerConfig } from '#/dist/configs';
+*
+* export const LoggerConfig = createLoggerConfig();
+* ```
+*/
+const createLoggerConfig = (opts) => {
+	return registerAs(LOGGER_CONFIG_TOKEN, () => {
+		const format$1 = [
+			winston.format.splat(),
+			winston.format.timestamp(),
+			nestLikeConsoleFormat(opts.appName)
+		];
+		const winstonOptions = { transports: [] };
+		if (!Array.isArray(winstonOptions.transports)) return winstonOptions;
+		if (opts.useConsole) winstonOptions.transports.push(new winston.transports.Console({
+			level: opts.consoleLevel ?? "debug",
+			format: winston.format.combine(...format$1)
+		}));
+		if (opts.transports) winstonOptions.transports.push(...opts.transports);
+		return winstonOptions;
+	});
+};
+
+//#endregion
+//#region src/abstracts/nestjs-service.ts
+var _ref$2;
+/**
+* Abstract service class for NestJS services
+* Automatically initializes logger with the constructor name as scope
+*/
+var NestJsService = class {
+	loggerFactory;
+	logger;
+	/**
+	* Initialize logger using the constructor name as scope
+	*/
+	onModuleInit() {
+		this.logger = this.loggerFactory.create({ scope: this.constructor.name });
+	}
+};
+__decorate([InjectLoggerFactory(), __decorateMetadata("design:type", typeof (_ref$2 = typeof LoggerFactory !== "undefined" && LoggerFactory) === "function" ? _ref$2 : Object)], NestJsService.prototype, "loggerFactory", void 0);
+
+//#endregion
+//#region src/abstracts/nestjs-resource-service.ts
+var _ref$1, _ref2$1;
+var NestJsResourceService = class extends NestJsService {
+	constructor(params) {
+		super();
+		this.params = params;
+	}
+	idService;
+	dataSource;
+	get repository() {
+		return this.dataSource.getRepository(this.params.entity.type);
+	}
+	generateEntityId() {
+		return this.idService.generateEntityId(this.params.entity.idPrefix);
+	}
+	get entityName() {
+		return this.params.entity.type.name;
+	}
+	get alias() {
+		return this.params.entity.alias;
+	}
+	async getOneBy(opts) {
+		const logger = this.logger.child({
+			action: this.getOneBy.name,
+			...opts
+		});
+		if (Object.values(opts).filter((v) => v).length === 0) throw new BadRequestError({
+			message: "Empty options",
+			key: "NST_GET_ONE_BY_EMPTY_OPTIONS",
+			context: logger.getContext()
+		});
+		return await this.repository.findOneBy({ ...opts });
+	}
+	async getOne(id) {
+		return await this.getOneBy({ id });
+	}
+	async getOneByOrFail(opts, ctx) {
+		const logger = this.logger.forMethod(this.getOneByOrFail.name, ctx, { ...opts });
+		const item = await this.getOneBy(opts);
+		if (!item) throw new NotFoundError({
+			message: `${this.entityName} with ${stringifyOpts(opts)} not found`,
+			key: "NST_CHANNELS_NOT_FOUND",
+			context: logger.getContext()
+		});
+		return item;
+	}
+	async getOneOrFail(id, ctx) {
+		return await this.getOneByOrFail({ id }, ctx);
+	}
+	applyFilterToQuery(query, filter) {
+		if (!filter) return;
+		if (filter.search) query.andWhere(`${this.alias}.title LIKE :search`, { search: `%${filter.search}%` });
+	}
+	applySearchToQuery(query, search) {
+		if (!search) return;
+		query.andWhere(`${this.alias}.title LIKE :search`, { search: `%${search}%` });
+	}
+	applyOrderByToQuery(query, orderBy) {
+		const sort = extractSortParams(orderBy);
+		query.addOrderBy(`${this.alias}.${sort.columnName}`, sort.direction);
+	}
+};
+__decorate([Inject(IdService), __decorateMetadata("design:type", typeof (_ref$1 = typeof IdService !== "undefined" && IdService) === "function" ? _ref$1 : Object)], NestJsResourceService.prototype, "idService", void 0);
+__decorate([InjectDataSource(), __decorateMetadata("design:type", typeof (_ref2$1 = typeof DataSource !== "undefined" && DataSource) === "function" ? _ref2$1 : Object)], NestJsResourceService.prototype, "dataSource", void 0);
+
+//#endregion
+//#region src/db/snake-naming.strategy.ts
+/**
+* Snake case naming strategy for typeorm.
+* Determines table and column names from class and property names.
+*/
+var SnakeNamingStrategy = class extends DefaultNamingStrategy {
+	/**
+	* Create a table name from a class name.
+	* @param className - The class name of the entity
+	* @param customName - The custom table name
+	* @returns The table name
+	* @example Create table name from class name
+	* ```ts
+	* @Entity()
+	* class User {}
+	* // returns 'users'
+	*
+	* @Entity('custom_table_name')
+	* class User {}
+	* // returns 'custom_table_name'
+	*
+	*```
+	*/
+	tableName(className, customName) {
+		if (customName) return customName;
+		const snakeClassName = snakeCase(className);
+		if (snakeClassName.includes("_to_")) return snakeClassName;
+		const parts = snakeClassName.split("_");
+		if (parts.length === 1) return singularToPlural(snakeClassName);
+		return parts.map((name, i) => i === 0 ? name : singularToPlural(name)).join("_");
+	}
+	/**
+	* Create a column name from a property name.
+	* @param propertyName - The property name of the entity
+	* @param customName - The custom column name
+	* @param embeddedPrefixes - The embedded prefixes
+	* @returns The table column name
+	* @example Create column name from property name
+	* ```ts
+	* @Entity()
+	* class User {
+	*  @Column()
+	*  firstName: string; // returns 'first_name'
+	*
+	*  @Column('custom_last_name')
+	*  lastName: string; // returns 'custom_last_name'
+	* }
+	* ```
+	*/
+	columnName(propertyName, customName, embeddedPrefixes = []) {
+		return snakeCase(embeddedPrefixes.concat("").join("_")) + (customName ? customName : snakeCase(propertyName));
+	}
+	relationName(propertyName) {
+		return snakeCase(propertyName);
+	}
+	joinColumnName(relationName, referencedColumnName) {
+		return snakeCase(relationName + "_" + referencedColumnName);
+	}
+	/**
+	* Create join table name for many-to-many relations.
+	* @returns join table name
+	* @example
+	* ```ts
+	* @Entity()
+	* class Post {
+	*  @ManyToMany(() => Theme) // post_to_theme
+	*  themes: Theme[];
+	* }
+	*
+	*/
+	joinTableName(firstTableName, secondTableName) {
+		return snakeCase(pluralToSingular(firstTableName) + "_to_" + pluralToSingular(secondTableName));
+	}
+	joinTableColumnName(tableName, propertyName, columnName) {
+		return snakeCase(pluralToSingular(tableName) + "_" + (columnName ? columnName : propertyName));
+	}
+	eagerJoinRelationAlias(alias, propertyPath) {
+		return alias + "__" + propertyPath.replace(".", "_");
+	}
+	/**
+	* Create a primary key name.
+	* @param tableOrName - The table or table name
+	* @param columnNames - The column names
+	* @returns The primary key name
+	* @example
+	* ```ts
+	* @Entity()
+	* class User {
+	*  @PrimaryColumn()
+	*  id: string;
+	* }
+	*
+	* // returns 'pk_users__id'
+	*/
+	primaryKeyName(tableOrName, columnNames) {
+		tableOrName = typeof tableOrName === "string" ? tableOrName : tableOrName.name;
+		let name = tableOrName;
+		for (const column of columnNames) name += `__${column}`;
+		name = this.simplifyName(name);
+		return `pk_${name}`;
+	}
+	/**
+	* Create a foreign key name.
+	* @param tableOrName - The table or table name
+	* @param columnNames - The column names
+	* @returns The foreign key name
+	* @example
+	* ```ts
+	* @Entity()
+	* class User {
+	*  @PrimaryColumn()
+	*  id: string;
+	* }
+	* @Entity()
+	* class Post {
+	*  @PrimaryColumn()
+	*  id: string;
+	*
+	*  @ManyToOne(() => User, user => user.posts)
+	*  user: User;
+	* }
+	*
+	* // returns 'fk_posts__user_id__users__id'
+	* ```
+	*/
+	foreignKeyName(tableOrName, columnNames) {
+		tableOrName = typeof tableOrName === "string" ? tableOrName : tableOrName.name;
+		let name = tableOrName;
+		for (const column of columnNames) name += `__${column}`;
+		name = this.simplifyName(name);
+		return `fk_${name}`;
+	}
+	/**
+	* Create an index name.
+	* @param tableOrName - The table or table name
+	* @param columnNames - The column names
+	* @returns The index name
+	* @example
+	* ```ts
+	* @Entity()
+	* class User {
+	*  @Index()
+	*  @Column()
+	*  email: string;
+	* }
+	* // returns 'idx_users__email'
+	* ```
+	*/
+	indexName(tableOrName, columnNames) {
+		tableOrName = typeof tableOrName === "string" ? tableOrName : tableOrName.name;
+		let name = tableOrName;
+		for (const column of columnNames) name += `__${column}`;
+		name = this.simplifyName(name);
+		return `idx_${name}`;
+	}
+	/**
+	* Create a unique constraint name.
+	* @param tableOrName - The table or table name
+	* @param columnNames - The column names
+	* @returns The unique constraint name
+	* @example
+	* ```ts
+	* @Entity()
+	* class User {
+	*  @Unique()
+	*  @Column()
+	*  email: string;
+	* }
+	* // returns 'uq_users__email'
+	* ```
+	*/
+	uniqueConstraintName(tableOrName, columnNames) {
+		tableOrName = typeof tableOrName === "string" ? tableOrName : tableOrName.name;
+		let name = tableOrName;
+		for (const column of columnNames) name += `__${column}`;
+		name = this.simplifyName(name);
+		return `uq_${name}`;
+	}
+	simplifyName(name) {
+		if (name.length > 50) return name.split("__").map((piece) => {
+			if (piece.includes("_to_")) return piece.split("_").map((p) => p[0]).join("");
+			return piece;
+		}).join("__");
+		return name;
+	}
+};
+
+//#endregion
+//#region src/configs/db.config.ts
+/**
+* NestJS injection token for postgres db config
+*/
+const DB_CONFIG_TOKEN = "DB_CONFIG_TOKEN";
+const InjectDbConfig = () => Inject(getConfigToken(DB_CONFIG_TOKEN));
+/**
+* Postgres db config environment variables
+*/
+var DbConfigEnvironmentVariables = class {
+	/**
+	* Postgres host
+	* @example
+	* ```yaml
+	* POSTGRES_HOST: 'localhost'
+	* ```
+	*/
+	POSTGRES_HOST;
+	/**
+	* Postgres port
+	* @example
+	* ```yaml
+	* POSTGRES_PORT: 5432
+	* ```
+	*/
+	POSTGRES_PORT;
+	/**
+	* Postgres user
+	* @example
+	* ```yaml
+	* POSTGRES_USER: 'app'
+	* ```
+	*/
+	POSTGRES_USER;
+	/**
+	* Postgres password
+	* @example
+	* ```yaml
+	* POSTGRES_PASS: 'qwerty'
+	* ```
+	*/
+	POSTGRES_PASS;
+	/**
+	* Postgres database name
+	* @example
+	* ```yaml
+	* POSTGRES_DB: 'jetstream'
+	* ```
+	*/
+	POSTGRES_DB;
+	/**
+	* Enable postgres logging
+	* @example
+	* ```yaml
+	* POSTGRES_IS_LOGGING_ENABLED: "true"
+	* ```
+	*/
+	POSTGRES_IS_LOGGING_ENABLED;
+};
+__decorate([IsString(), __decorateMetadata("design:type", String)], DbConfigEnvironmentVariables.prototype, "POSTGRES_HOST", void 0);
+__decorate([
+	Type$1(() => Number),
+	IsNumber(),
+	__decorateMetadata("design:type", Number)
+], DbConfigEnvironmentVariables.prototype, "POSTGRES_PORT", void 0);
+__decorate([IsString(), __decorateMetadata("design:type", String)], DbConfigEnvironmentVariables.prototype, "POSTGRES_USER", void 0);
+__decorate([IsString(), __decorateMetadata("design:type", String)], DbConfigEnvironmentVariables.prototype, "POSTGRES_PASS", void 0);
+__decorate([IsString(), __decorateMetadata("design:type", String)], DbConfigEnvironmentVariables.prototype, "POSTGRES_DB", void 0);
+__decorate([
+	Type$1(() => Boolean),
+	IsOptional(),
+	IsBoolean(),
+	__decorateMetadata("design:type", Boolean)
+], DbConfigEnvironmentVariables.prototype, "POSTGRES_IS_LOGGING_ENABLED", void 0);
+/**
+* Postgres Database Config
+*/
+const createDbConfig = (opts) => {
+	return registerAs(DB_CONFIG_TOKEN, () => {
+		const env = validateEnv(DbConfigEnvironmentVariables);
+		const entities = [...opts?.entities ?? ["dist/**/*.entity.js", "node_modules/@deep/nest-kit/dist/modules/**/*.entity.js"]];
+		return {
+			type: "postgres",
+			logging: env.POSTGRES_IS_LOGGING_ENABLED,
+			host: env.POSTGRES_HOST,
+			port: env.POSTGRES_PORT,
+			username: env.POSTGRES_USER,
+			password: env.POSTGRES_PASS,
+			database: env.POSTGRES_DB,
+			synchronize: false,
+			migrations: ["dist/migrations/*.js"],
+			subscribers: ["dist/**/*.entity-subscriber.js"],
+			migrationsRun: true,
+			namingStrategy: new SnakeNamingStrategy(),
+			...opts,
+			entities: fg.sync(entities)
+		};
+	});
+};
+
+//#endregion
+//#region src/tools/compose.ts
+function compose(baseClass, ...mixins) {
+	return mixins.reduce((currentClass, mixin) => mixin(currentClass), baseClass);
+}
+
+//#endregion
+//#region src/tools/convert-to-bigint.ts
+/**
+* Converts a number or string value to a BigInt, preserving null and undefined values.
+*
+* @param value - The value to convert. Can be a number, string, undefined, or null.
+* @returns The converted BigInt value, or the original value if it was null or undefined.
+*
+* @example
+* ```typescript
+* convertToBigInt(123) // returns 123n
+* convertToBigInt("456") // returns 456n
+* convertToBigInt(null) // returns null
+* convertToBigInt(undefined) // returns undefined
+* ```
+*
+* @throws {RangeError} Throws when the input cannot be converted to a valid BigInt.
+*/
+const convertToBigInt = (value) => {
+	if (value === null) return value;
+	if (typeof value === "undefined") return value;
+	return BigInt(value);
+};
+
+//#endregion
+//#region src/tools/fetch-total-with-query.ts
+/**
+* Returns total count of items with typeorm query
+* @param query - typeorm query builder
+* @returns total count of items
+*/
+/**
+* Returns total count of items with typeorm query
+* @param query - typeorm query builder
+* @returns total count of items
+*/
+const fetchTotalWithQuery = async (query) => {
+	const totalQueryBuilder = query.clone();
+	totalQueryBuilder.offset(void 0).limit(void 0).skip(void 0).take(void 0).orderBy();
+	const hasDistinctOn = totalQueryBuilder.expressionMap.selectDistinctOn && totalQueryBuilder.expressionMap.selectDistinctOn.length > 0;
+	const isGrouped = totalQueryBuilder.expressionMap.groupBys && totalQueryBuilder.expressionMap.groupBys.length > 0;
+	if (hasDistinctOn || isGrouped) {
+		const subQuery = totalQueryBuilder.getQuery();
+		return (await query.connection.createQueryBuilder().select("COUNT(*)", "rowsCount").from(`(${subQuery})`, "subQuery").setParameters(totalQueryBuilder.getParameters()).getRawOne())?.rowsCount ?? 0;
+	}
+	return await totalQueryBuilder.getCount();
+};
+
+//#endregion
+//#region src/tools/create-list-meta.ts
+/**
+* Create list meta object
+* @returns list meta object
+* @example
+* class UsersService {
+*  async getMany(opts: GetManyUsersOptions): Promise<[User[], ListMeta]> {
+*    ...
+*   return Promise.all([
+*     query.getMany(),
+*     createListMeta<User>({
+*       query,
+*       needCountTotal,
+*       limit,
+*       offset,
+*     }),
+*   ]);
+* }
+*/
+const createListMeta = async ({ query, needCountTotal = false, limit, offset }) => {
+	const meta = {
+		limit,
+		offset
+	};
+	if (needCountTotal) meta.total = await fetchTotalWithQuery(query);
+	return meta;
+};
+
+//#endregion
+//#region src/tools/define-statuses.ts
+/**
+* Define statuses. Returns array of statuses from filter or default statuses
+* @param statuses - array of statuses from filter. Can be undefined
+* @param defaultStatuses - array of default statuses
+* @returns final array of statuses
+* @example
+* const statuses = defineStatuses(['active', 'pending'], ['active']);
+* // statuses = ['active', 'pending']
+*
+* const statuses = defineStatuses(undefined, ['active']);
+* // statuses = ['active']
+*/
+const defineStatuses = (statuses, defaultStatuses) => {
+	return Array.isArray(statuses) ? statuses : defaultStatuses;
+};
+
+//#endregion
+//#region src/tools/get-request-language.ts
+const getRequestLanguage = (req, fallbackLanguage) => {
+	const headers = req?.headers;
+	return parse(headers["accept-language"])?.[0]?.code ?? fallbackLanguage;
+};
+
+//#endregion
+//#region src/tools/postgres/locale-to-pg-collate.ts
+/**
+* Converts a locale string to a PostgreSQL collation identifier.
+*
+* @param locale - The locale string to convert (e.g., 'uk', 'en')
+* @returns The PostgreSQL collation identifier (e.g., 'uk_UA', 'en_US')
+*
+* @example
+* ```typescript
+* localeToPgCollate('uk') // returns 'uk_UA'
+* localeToPgCollate('en') // returns 'en_US'
+* ```
+*/
+const localeToPgCollate = (locale) => {
+	let collate = "en_US";
+	if (locale === "uk") collate = "uk_UA";
+	return collate;
+};
+
+//#endregion
+//#region src/tools/remove-undefined-properties.ts
+const removeUndefinedProperties = (obj) => {
+	const result = {};
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== void 0) result[key] = obj[key];
+	return result;
+};
+
+//#endregion
+//#region src/tools/request-id.ts
+const generateRequestId = (appShortName) => {
+	return `${appShortName}req:${createRandomString()}`;
+};
+const extractRequestId = (req) => {
+	const headers = req?.headers;
+	if (headers?.["x-request-id"]) return headers["x-request-id"];
+	if (headers["x-cloud-trace-context"]) return req.appShortname + `req:${headers["x-cloud-trace-context"]}`;
+	return generateRequestId(req.appShortname);
+};
+
+//#endregion
+//#region src/tools/wait.ts
+/**
+* Pauses execution for a specified amount of time using a Promise.
+* @param ms - The amount of time to pause in milliseconds.
+* @returns A Promise that resolves after the specified amount of time has elapsed.
+* @deprecated use wait instead
+*/
+const pauseWithPromise = async (ms) => {
+	return await new Promise((resolve) => {
+		setTimeout(() => {
+			resolve();
+		}, ms);
+	});
+};
+/**
+* Pauses execution for a specified amount of time using a Promise.
+* @param ms - The amount of time to pause in milliseconds.
+* @returns A Promise that resolves after the specified amount of time has elapsed.
+*/
+const wait = async (ms) => {
+	return await new Promise((resolve) => {
+		setTimeout(() => {
+			resolve();
+		}, ms);
+	});
+};
+
+//#endregion
+//#region src/tools/typeorm/add-filter.ts
+/**
+* Adds a filter condition to a TypeORM SelectQueryBuilder based on the provided field and value(s).
+*
+* Handles three types of filtering:
+* - Single value filtering: when a single non-null value is provided
+* - Multiple value filtering: when an array of values is provided
+* - Null value filtering: when null is explicitly provided as the filter value
+*
+* @template T - The entity type that extends ObjectLiteral
+* @template K - The field name key type that must be a string key of T
+*
+* @param query - The TypeORM SelectQueryBuilder instance to add the filter to
+* @param fieldName - The name of the field to filter by, must be a valid key of entity T
+* @param valueOrValues - The filter value(s). Can be:
+*   - A single value of type T[K]
+*   - An array of values of type T[K]
+*   - null to filter for null values
+*   - An array containing null values
+* @example
+* ```typescript
+* // Single value filter
+* addFilterByField(queryBuilder, 'status', 'active');
+* // Multiple values filter
+* addFilterByField(queryBuilder, 'id', [1, 2, 3]);
+* // Null value filter
+* addFilterByField(queryBuilder, 'deletedAt', null);
+* ```
+*
+* @returns void - Modifies the query builder in place
+*/
+const addFilterByField = (query, fieldName, valueOrValues) => {
+	if (Array.isArray(valueOrValues)) addMultipleFilter(query, fieldName, valueOrValues);
+	else if (valueOrValues === null) addNullableFilter(query, fieldName);
+	else addSingleFilter(query, fieldName, valueOrValues);
+};
+/**
+* Adds a filter to a TypeORM query that matches multiple values for a given column,
+* including support for null values.
+*
+* @template T - The entity type that extends ObjectLiteral
+* @template K - The key type that must be both a key of T and a string
+* @param query - The TypeORM SelectQueryBuilder instance to add the filter to
+* @param columnName - The name of the column to filter on
+* @param values - An array of values to match, which may include null
+*
+* @remarks
+* This function creates an OR condition that matches any of the provided values.
+* If the values array includes null, a separate null check is added to the filter.
+* Non-null values are handled using TypeORM's `In` operator.
+*
+* @example
+* ```typescript
+* const query = repository.createQueryBuilder('user');
+* addMultipleFilter(query, 'status', ['active', 'pending', null]);
+* // Generates: WHERE (status IS NULL OR status IN ('active', 'pending'))
+* ```
+*/
+const addMultipleFilter = (query, columnName, values) => {
+	query.andWhere(new Brackets((subQuery) => {
+		if (values.includes(null)) addNullValueToMultipleFilter(subQuery, columnName);
+		const notNullValues = values.filter((v) => v !== null);
+		subQuery.orWhere({ [columnName]: In(notNullValues) });
+	}));
+};
+/**
+* Adds a single filter condition to a TypeORM SelectQueryBuilder.
+*
+* @template T - The entity type that extends ObjectLiteral
+* @template K - The column name type, constrained to string keys of T
+*
+* @param query - The SelectQueryBuilder instance to add the filter to
+* @param columnName - The name of the column to filter on
+* @param value - The value to filter by, must match the type of the column
+*
+* @returns void
+*
+* @example
+* ```typescript
+* const query = repository.createQueryBuilder('user');
+* addSingleFilter(query, 'email', 'user@example.com');
+* // Results in: WHERE user.email = 'user@example.com'
+* ```
+*/
+const addSingleFilter = (query, columnName, value) => {
+	query.andWhere({ [columnName]: value });
+};
+/**
+* Adds a nullable filter to a TypeORM query builder.
+*
+* This function applies a WHERE clause that filters for NULL values in the specified column.
+* The filter is combined with existing conditions using AND logic.
+*
+* @template T - The entity type that extends ObjectLiteral
+* @param query - The TypeORM SelectQueryBuilder instance to add the filter to
+* @param columnName - The name of the column to check for NULL values
+* @returns void
+*
+* @example
+* ```typescript
+* const query = repository.createQueryBuilder('user');
+* addNullableFilter(query, 'deletedAt');
+* // Results in: WHERE deletedAt IS NULL
+* ```
+*/
+const addNullableFilter = (query, columnName) => {
+	query.andWhere({ [columnName]: IsNull() });
+};
+/**
+* Adds an OR condition to the query to check if the specified column is NULL.
+*
+* This function is used to extend filtering logic by adding a null value check
+* as an alternative condition in a WHERE clause.
+*
+* @param query - The TypeORM WhereExpressionBuilder instance to which the null condition will be added
+* @param columnName - The name of the database column to check for NULL values
+*
+* @returns void
+*
+* @example
+* ```typescript
+* const queryBuilder = repository.createQueryBuilder('user');
+* addNullValueToMultipleFilter(queryBuilder, 'deletedAt');
+* // Results in: WHERE ... OR deletedAt IS NULL
+* ```
+*/
+const addNullValueToMultipleFilter = (query, columnName) => {
+	query.orWhere({ [columnName]: IsNull() });
+};
+
+//#endregion
+//#region src/tools/typeorm/is-alias-already-busy.ts
+/**
+* Checks if a given alias is already used in the query builder's join attributes.
+*
+* This utility function inspects the query builder's expression map to determine
+* whether a specific alias name has already been assigned to any join attribute.
+* This is useful to avoid alias conflicts when building complex TypeORM queries.
+*
+* @template T - The entity type that extends ObjectLiteral
+* @param {SelectQueryBuilder<T>} query - The TypeORM SelectQueryBuilder instance to check
+* @param {string} alias - The alias name to search for in the join attributes
+* @returns {boolean} True if the alias is already used in any join attribute, false otherwise
+*
+* @example
+* ```typescript
+* const query = repository.createQueryBuilder('user');
+* const isBusy = isAliasAlreadyBusy(query, 'profile');
+* if (!isBusy) {
+*   query.leftJoinAndSelect('user.profile', 'profile');
+* }
+* ```
+*/
+const isAliasAlreadyBusy = (query, alias) => query.expressionMap.joinAttributes.some((a) => a.alias.name === alias);
+
+//#endregion
+//#region src/tools/typeorm/ensure-inner-join.ts
+/**
+* Ensures an inner join is added to the TypeORM query builder only if the alias is not already in use.
+*
+* This function checks if the specified alias is already being used in the query builder.
+* If the alias is available, it adds an inner join with the provided entity, alias, and optional condition.
+* If the alias is already busy, the function returns without making any changes to the query.
+*
+* @template T - The entity type that extends ObjectLiteral
+* @param query - The TypeORM SelectQueryBuilder instance to add the inner join to
+* @param entity - The entity class (Function) or entity name (string) to join
+* @param alias - The alias to use for the joined entity
+* @param condition - Optional join condition as a string
+* @returns void
+*
+* @example
+* ```typescript
+* const query = repository.createQueryBuilder('user');
+* ensureInnerJoin(query, Profile, 'profile', 'profile.userId = user.id');
+* ```
+*/
+const ensureInnerJoin = (query, entity, alias, condition) => {
+	if (isAliasAlreadyBusy(query, alias)) return;
+	query.innerJoin(entity, alias, condition);
+};
+
+//#endregion
+//#region src/tools/typeorm/ensure-left-join.ts
+/**
+* Ensures a left join is added to a TypeORM query builder if the alias is not already in use.
+*
+* This function checks if the specified alias is already being used in the query.
+* If the alias is available, it performs a left join with the provided entity, alias, and optional condition.
+* If the alias is already busy, the function returns early without modifying the query.
+*
+* @template T - The entity type that extends ObjectLiteral
+* @param query - The TypeORM SelectQueryBuilder instance to add the left join to
+* @param entity - The entity class (Function) or table name (string) to join
+* @param alias - The alias name to use for the joined entity
+* @param condition - Optional join condition as a string (e.g., "alias.id = entity.foreignId")
+* @returns void
+*
+* @example
+* ```typescript
+* ensureLeftJoin(queryBuilder, User, 'user', 'user.id = post.userId');
+* ```
+*/
+const ensureLeftJoin = (query, entity, alias, condition) => {
+	if (isAliasAlreadyBusy(query, alias)) return;
+	query.leftJoin(entity, alias, condition);
+};
+
+//#endregion
+//#region src/validation/validation-pipe.ts
+var NestKitValidationPipe = class extends ValidationPipe {
+	createExceptionFactory() {
+		return (validationErrors = []) => {
+			if (!this.isDetailedOutputDisabled) return new InputValidationError(validationErrors);
+			return new InputValidationError();
+		};
+	}
+};
+
+//#endregion
+//#region src/exceptions/http-exceptions.filter.ts
+var _ref, _ref2, _HttpExceptionFilter;
+let HttpExceptionFilter = _HttpExceptionFilter = class HttpExceptionFilter$1 {
+	logger;
+	constructor(applicationRef, loggerFactory) {
+		this.applicationRef = applicationRef;
+		this.loggerFactory = loggerFactory;
+		this.logger = this.loggerFactory.create({ scope: _HttpExceptionFilter.name });
+	}
+	catch(exception, host) {
+		const type = GqlArgumentsHost.create(host).getType();
+		const response = exception.getResponse();
+		if (!response?.silent) if (isObject$1(response)) {
+			const logger = this.loggerFactory.create(response.context);
+			if (response.error instanceof Error) logger.error(response.message, response.error);
+			else logger.error(exception);
+		} else this.logger.error(exception);
+		if (type !== "http") return exception;
+		/**
+		* If request is http, then we need to send response to client
+		*/
+		let body;
+		if (isObject$1(response)) {
+			body = {
+				key: response.key,
+				message: response.message,
+				context: response.context,
+				statusCode: exception.getStatus()
+			};
+			if (response.error instanceof Error && process.env.NODE_ENV !== AppEnv.PRODUCTION) body.stack = response.error.stack;
+		} else body = {
+			statusCode: exception.getStatus(),
+			message: response
+		};
+		this.applicationRef.reply(host.getArgByIndex(1), body, exception.getStatus());
+	}
+};
+HttpExceptionFilter = _HttpExceptionFilter = __decorate([Catch(HttpException), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof HttpServer !== "undefined" && HttpServer) === "function" ? _ref : Object, typeof (_ref2 = typeof LoggerFactory !== "undefined" && LoggerFactory) === "function" ? _ref2 : Object])], HttpExceptionFilter);
+
+//#endregion
+export { APP_CONFIG_TOKEN, AccessDeniedError, AppConfigEnvironmentVariables, AppEnv, AppMode, AppServer, BadRequestError, DB_CONFIG_TOKEN, ForbiddenError, HttpExceptionFilter, InjectAppConfig, InjectDbConfig, InjectLogger, InjectLoggerConfig, InjectLoggerFactory, InputValidationError, LOGGER_CONFIG_TOKEN, Logger, LoggerFactory, LoggerModule, NESTKIT_LOGGER_FACTORY_PROVIDER, NESTKIT_LOGGER_MODULE_OPTIONS, NESTKIT_LOGGER_PROVIDER, NESTKIT_SYSTEM_LOGGER_PROVIDER, NESTKIT_WINSTON_LOGGER_PROVIDER, NestError, NestJsResourceService, NestJsService, NestKitValidationPipe, NestSystemLogger, NotFoundError, TypeOrmLogger, TypeOrmLoggerOptions, UnauthorizedError, WorkerMode, addFilterByField, compose, convertToBigInt, createAppConfig, createDbConfig, createListMeta, createLoggerAsyncProviders, createLoggerConfig, createLoggerProviders, createNestLogger, createPrettyMessage, defineStatuses, ensureInnerJoin, ensureLeftJoin, extractRequestId, fetchTotalWithQuery, generateEntityId, generateRequestId, getRequestLanguage, isAliasAlreadyBusy, isObject, localeToPgCollate, nestLikeConsoleFormat, pauseWithPromise, removeUndefinedProperties, stringifyOpts, validateEnv, wait, withColonEnv, withDashEnv, withDotEnv, withUnderscoreEnv };
+//# sourceMappingURL=index.js.map