@nest-omni/core 3.1.1-9 → 3.1.2-0

package/setup/worker.decorator.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerProcessor = WorkerProcessor;
+exports.WorkerProcess = WorkerProcess;
+exports.WorkerOnQueueActive = WorkerOnQueueActive;
+exports.WorkerOnQueueCompleted = WorkerOnQueueCompleted;
+exports.WorkerOnQueueProgress = WorkerOnQueueProgress;
+exports.WorkerOnQueueFailed = WorkerOnQueueFailed;
+exports.WorkerOnQueueError = WorkerOnQueueError;
+exports.WorkerOnQueueWaiting = WorkerOnQueueWaiting;
+exports.WorkerOnQueueStalled = WorkerOnQueueStalled;
+exports.WorkerOnQueueRemoved = WorkerOnQueueRemoved;
+exports.WorkerOnQueueCleaned = WorkerOnQueueCleaned;
+exports.WorkerOnQueueDrained = WorkerOnQueueDrained;
+exports.WorkerOnQueuePaused = WorkerOnQueuePaused;
+exports.WorkerOnQueueResumed = WorkerOnQueueResumed;
+const bull_1 = require("@nestjs/bull");
+const mode_setup_1 = require("./mode.setup");
+function WorkerProcessor(queueName) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.Processor)(queueName);
+    }
+    return function (constructor) {
+        return constructor;
+    };
+}
+function WorkerProcess(name) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.Process)(name);
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueActive() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueActive)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueCompleted() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueCompleted)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueProgress() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueProgress)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueFailed() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueFailed)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueError() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueError)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueWaiting() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueWaiting)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueStalled() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueStalled)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueRemoved() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueRemoved)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueCleaned() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueCleaned)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueDrained() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueDrained)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueuePaused() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueuePaused)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueResumed() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueResumed)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}

package/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './serviceRegistryModule';
+export * from './services';

package/shared/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./serviceRegistryModule"), exports);
+__exportStar(require("./services"), exports);

package/shared/serviceRegistryModule.d.ts

@@ -0,0 +1,2 @@
+export declare class ServiceRegistryModule {
+}

package/shared/serviceRegistryModule.js

@@ -0,0 +1,170 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceRegistryModule = void 0;
+const path = require("path");
+const process = require("process");
+const bull_1 = require("@nestjs/bull");
+const nestjs_pino_1 = require("nestjs-pino");
+const config_1 = require("@nestjs/config");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const schedule_1 = require("@nestjs/schedule");
+const setup_1 = require("@sentry/nestjs/setup");
+const cache_1 = require("../cache");
+const transactional_1 = require("@nestjs-cls/transactional");
+const transactional_adapter_typeorm_1 = require("@nestjs-cls/transactional-adapter-typeorm");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const health_checker_1 = require("../health-checker");
+const nestjs_redis_1 = require("@songkeys/nestjs-redis");
+const services_1 = require("./services");
+const nestjs_cls_1 = require("nestjs-cls");
+const redis_lock_1 = require("../redis-lock");
+const typeorm_2 = require("typeorm");
+const vault_1 = require("../vault");
+const providers = [
+    services_1.ApiConfigService,
+    services_1.ValidatorService,
+    services_1.GeneratorService,
+    services_1.TranslationService,
+];
+if (!((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.ENV_FILE_PATH)) {
+    Promise.resolve().then(() => require('../setup/bootstrap.setup'));
+}
+services_1.ApiConfigService.rootPath = process.env.ROOT_PATH;
+const modules = [
+    setup_1.SentryModule.forRoot(),
+    vault_1.VaultModule,
+    config_1.ConfigModule.forRoot({
+        isGlobal: true,
+        cache: true,
+        expandVariables: false,
+        envFilePath: [process.env.ENV_FILE_PATH, process.env.BASE_ENV_FILE_PATH],
+    }),
+    nestjs_cls_1.ClsModule.forRoot({
+        global: true,
+        middleware: { mount: true, saveReq: true },
+        plugins: [
+            new transactional_1.ClsPluginTransactional({
+                imports: [typeorm_1.TypeOrmModule],
+                adapter: new transactional_adapter_typeorm_1.TransactionalAdapterTypeOrm({
+                    dataSourceToken: typeorm_2.DataSource,
+                }),
+                enableTransactionProxy: true,
+            }),
+        ],
+    }),
+    nestjs_pino_1.LoggerModule.forRootAsync({
+        inject: [services_1.ApiConfigService],
+        useFactory: (config) => config.pinoConfig,
+    }),
+    nestjs_i18n_1.I18nModule.forRootAsync({
+        inject: [services_1.ApiConfigService],
+        useFactory: (config) => ({
+            fallbackLanguage: config.fallbackLanguage,
+            loaderOptions: {
+                path: path.join(services_1.ApiConfigService.rootPath, '/i18n/'),
+                watch: config.isDev,
+            },
+            logging: config.isDev,
+        }),
+        resolvers: [new nestjs_i18n_1.QueryResolver(['lang']), nestjs_i18n_1.AcceptLanguageResolver],
+    }),
+    health_checker_1.HealthCheckerModule,
+    nestjs_redis_1.RedisModule.forRoot({
+        config: {
+            host: process.env.REDIS_HOST || 'localhost',
+            port: parseInt(process.env.REDIS_PORT) || 6379,
+            password: process.env.REDIS_PASSWORD,
+            db: parseInt(process.env.REDIS_DB) || 0,
+        },
+    }),
+];
+if (services_1.ApiConfigService.toBoolean(process.env.DB_ENABLED, true)) {
+    modules.push(typeorm_1.TypeOrmModule.forRootAsync({
+        inject: [services_1.ApiConfigService],
+        useFactory: (config) => config.typeormConfig,
+    }));
+}
+if (services_1.ApiConfigService.toBoolean(process.env.BULL_ENABLED)) {
+    modules.push(bull_1.BullModule.forRootAsync({
+        inject: [services_1.ApiConfigService],
+        useFactory: (config) => config.bullConfig,
+    }));
+}
+if (services_1.ApiConfigService.toBoolean(process.env.CACHE_ENABLED)) {
+    modules.push(cache_1.CacheModule.forRootAsync({
+        inject: [services_1.ApiConfigService, nestjs_redis_1.RedisService, typeorm_2.DataSource],
+        isGlobal: true,
+        useFactory: (config, redisService, dataSource) => __awaiter(void 0, void 0, void 0, function* () {
+            let redisClient = null;
+            try {
+                redisClient = redisService.getClient();
+            }
+            catch (error) {
+                console.error('Redis client not available for cache, using memory cache only:', error);
+            }
+            return {
+                isGlobal: true,
+                redisClient,
+                dataSource,
+                memoryTtl: config.getNumber('CACHE_TTL'),
+                memoryNamespace: config.getString('CACHE_NAMESPACE', 'default'),
+                enableCompression: config.getBoolean('CACHE_COMPRESSION_ENABLED', false),
+                compressionThreshold: config.getNumber('CACHE_COMPRESSION_THRESHOLD', 1024),
+            };
+        }),
+    }));
+}
+if (services_1.ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED) &&
+    services_1.ApiConfigService.toBoolean(process.env.REDIS_LOCK_ENABLED, true)) {
+    modules.push(redis_lock_1.RedisLockModule.forRootAsync({
+        inject: [services_1.ApiConfigService, nestjs_redis_1.RedisService],
+        isGlobal: true,
+        useFactory: (config, redisService) => __awaiter(void 0, void 0, void 0, function* () {
+            let redisClient = null;
+            try {
+                redisClient = redisService.getClient();
+            }
+            catch (error) {
+                console.error('Redis client not available for RedisLock, Redis Lock functionality will not work:', error);
+            }
+            return {
+                redisClient,
+                defaultTtl: config.getNumber('REDIS_LOCK_TTL', 300000),
+                defaultKeyPrefix: config.getString('REDIS_LOCK_KEY_PREFIX', 'lock'),
+                defaultRetryCount: config.getNumber('REDIS_LOCK_RETRY_COUNT', 3),
+                defaultRetryDelay: config.getNumber('REDIS_LOCK_RETRY_DELAY', 200),
+            };
+        }),
+    }));
+}
+if (services_1.ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED)) {
+    modules.push(schedule_1.ScheduleModule.forRoot());
+}
+let ServiceRegistryModule = class ServiceRegistryModule {
+};
+exports.ServiceRegistryModule = ServiceRegistryModule;
+exports.ServiceRegistryModule = ServiceRegistryModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers,
+        imports: modules,
+        exports: [...providers],
+    })
+], ServiceRegistryModule);

package/shared/services/api-config.service.d.ts

@@ -0,0 +1,54 @@
+import { ConfigService } from '@nestjs/config';
+import type { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import session from 'express-session';
+import { Params } from 'nestjs-pino';
+import { BullRootModuleOptions } from '@nestjs/bull/dist/interfaces/bull-module-options.interface';
+import { AxiosProxyConfig } from 'axios';
+import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+export declare class ApiConfigService {
+    private configService;
+    static rootPath: string;
+    constructor(configService: ConfigService);
+    get isDev(): boolean;
+    get apiVersion(): string;
+    get isProd(): boolean;
+    get isSit(): boolean;
+    get isUat(): boolean;
+    get isTest(): boolean;
+    get nodeEnv(): string;
+    get fallbackLanguage(): string;
+    get typeormConfig(): TypeOrmModuleOptions;
+    get documentationEnabled(): boolean;
+    get documentationPath(): string;
+    get viewsEnabled(): boolean;
+    get sessionEnabled(): boolean;
+    get corsEnabled(): boolean;
+    get corsConfig(): CorsOptions;
+    get sessionConfig(): session.SessionOptions;
+    get authConfig(): {
+        privateKey: string;
+        publicKey: string;
+        jwtExpirationTime: number;
+    };
+    get appConfig(): {
+        port: string;
+    };
+    get apiKey(): string;
+    get ioRedisConfig(): {
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        db: number;
+    };
+    get isRedisEnabled(): boolean;
+    get bullConfig(): BullRootModuleOptions;
+    get pinoConfig(): Params;
+    get axiosProxyConfig(): AxiosProxyConfig | false;
+    static getRootPath(): string;
+    static toBoolean(value: string, defaultValue?: any): boolean;
+    getNumber(key: string, defaultValue?: number): number;
+    getBoolean(key: string, defaultValue?: boolean): boolean;
+    getString(key: string, defaultValue?: string): string;
+    private get;
+}

package/shared/services/api-config.service.js

@@ -0,0 +1,287 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ApiConfigService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConfigService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const lodash_1 = require("lodash");
+const connect_redis_1 = require("connect-redis");
+const ioredis_1 = require("ioredis");
+const common_2 = require("../../common");
+let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+    get isDev() {
+        return this.nodeEnv === 'dev';
+    }
+    get apiVersion() {
+        return this.getString('API_VERSION');
+    }
+    get isProd() {
+        return this.nodeEnv === 'prod';
+    }
+    get isSit() {
+        return this.nodeEnv === 'sit';
+    }
+    get isUat() {
+        return this.nodeEnv === 'uat';
+    }
+    get isTest() {
+        return this.nodeEnv === 'test';
+    }
+    get nodeEnv() {
+        return this.getString('NODE_ENV');
+    }
+    get fallbackLanguage() {
+        return this.getString('FALLBACK_LANGUAGE');
+    }
+    get typeormConfig() {
+        return {
+            autoLoadEntities: true,
+            type: 'mysql',
+            host: this.getString('DB_HOST'),
+            port: this.getNumber('DB_PORT'),
+            username: this.getString('DB_USERNAME'),
+            entityPrefix: this.getString('DB_PREFIX', '').toLowerCase(),
+            password: this.getString('DB_PASSWORD'),
+            database: this.getString('DB_DATABASE'),
+            subscribers: [],
+            synchronize: this.isDev,
+            migrationsRun: true,
+            logging: this.getBoolean('DB_LOG_ENABLED'),
+            logger: this.isDev ? 'formatted-console' : 'simple-console',
+            maxQueryExecutionTime: 3000,
+            namingStrategy: new common_2.SnakeNamingStrategy(),
+            timezone: this.getString('TZ'),
+            cache: this.getBoolean('DB_CACHE_ENABLED')
+                ? {
+                    type: 'ioredis',
+                    options: this.ioRedisConfig,
+                }
+                : false,
+        };
+    }
+    get documentationEnabled() {
+        return this.getBoolean('SWAGGER_ENABLED');
+    }
+    get documentationPath() {
+        return this.getString('SWAGGER_PATH');
+    }
+    get viewsEnabled() {
+        return this.getBoolean('VIEWS_ENABLED');
+    }
+    get sessionEnabled() {
+        return this.getBoolean('SESSION_ENABLED');
+    }
+    get corsEnabled() {
+        try {
+            return this.getBoolean('CORS_ENABLED', false);
+        }
+        catch (error) {
+            console.log(error);
+            return false;
+        }
+    }
+    get corsConfig() {
+        const allowedDomains = this.getString('CORS_ORIGIN').split(',');
+        return {
+            origin: (origin, callback) => {
+                if (!origin) {
+                    return callback(null, true);
+                }
+                const isAllowed = allowedDomains.some((domain) => {
+                    if (domain.includes('*')) {
+                        const regexPattern = domain
+                            .replace(/\./g, '\\.')
+                            .replace(':*', '(:\\d+)?')
+                            .replace('*\\.', '(.*\\.)?');
+                        const fullRegex = new RegExp(`^https?:\/\/${regexPattern}$`, 'i');
+                        return fullRegex.test(origin);
+                    }
+                    return origin === domain || origin.startsWith(`${domain}:`);
+                });
+                isAllowed
+                    ? callback(null, origin)
+                    : callback(new common_1.BadRequestException('Not allowed by CORS'));
+            },
+            methods: this.getString('CORS_METHODS'),
+            allowedHeaders: this.getString('CORS_ALLOWED_HEADERS'),
+            exposedHeaders: this.getString('CORS_EXPOSED_HEADERS'),
+            credentials: this.getBoolean('CORS_CREDENTIALS'),
+            optionsSuccessStatus: 200,
+        };
+    }
+    get sessionConfig() {
+        const config = {
+            secret: this.getString('SESSION_KEY'),
+            resave: false,
+            saveUninitialized: false,
+        };
+        if (this.getBoolean('SESSION_REDIS_ENABLED')) {
+            const redisClient = new ioredis_1.default(this.ioRedisConfig);
+            config.store = new connect_redis_1.RedisStore({
+                client: redisClient,
+                prefix: this.getString('SESSION_REDIS_PREFIX'),
+            });
+        }
+        return config;
+    }
+    get authConfig() {
+        return {
+            privateKey: this.getString('JWT_PRIVATE_KEY'),
+            publicKey: this.getString('JWT_PUBLIC_KEY'),
+            jwtExpirationTime: this.getNumber('JWT_EXPIRATION_TIME'),
+        };
+    }
+    get appConfig() {
+        return {
+            port: this.getString('PORT'),
+        };
+    }
+    get apiKey() {
+        return this.getString('API_KEY');
+    }
+    get ioRedisConfig() {
+        return {
+            host: this.getString('REDIS_HOST'),
+            port: this.getNumber('REDIS_PORT'),
+            username: this.getString('REDIS_USERNAME'),
+            password: this.getString('REDIS_PASSWORD'),
+            db: this.getNumber('REDIS_DB'),
+        };
+    }
+    get isRedisEnabled() {
+        return (this.getBoolean('BULL_ENABLED') ||
+            this.getBoolean('CACHE_ENABLED') ||
+            this.getBoolean('DB_CACHE_ENABLED') ||
+            (this.sessionEnabled && this.getBoolean('SESSION_REDIS_ENABLED')));
+    }
+    get bullConfig() {
+        return {
+            redis: Object.assign(Object.assign({}, this.ioRedisConfig), { retryStrategy: (times) => Math.min(times * 1000, 5000) }),
+            prefix: this.getString('BULL_PREFIX'),
+            defaultJobOptions: {
+                removeOnComplete: true,
+                removeOnFail: true,
+                attempts: this.getNumber('BULL_JOB_ATTEMPTS', 5),
+                backoff: {
+                    type: 'exponential',
+                    delay: this.getNumber('BULL_JOB_BACKOFF_DELAY_MS', 5000),
+                },
+                timeout: this.getNumber('BULL_JOB_TIMEOUT_MS', 30 * 1000),
+            },
+            settings: {
+                maxStalledCount: 2,
+                guardInterval: 5000,
+                retryProcessDelay: 1000,
+            },
+            limiter: {
+                max: this.getNumber('BULL_MAX_CONCURRENT_JOBS', 100),
+                duration: 1000,
+            },
+        };
+    }
+    get pinoConfig() {
+        const transport = this.isDev
+            ? {
+                target: 'pino-pretty',
+            }
+            : null;
+        return {
+            pinoHttp: {
+                genReqId: (req) => req.id,
+                transport,
+                level: this.isDev ? 'debug' : 'info',
+                customLogLevel: function (res) {
+                    if (res.statusCode >= 500)
+                        return 'error';
+                    if (res.statusCode >= 400)
+                        return 'warn';
+                    return 'info';
+                },
+                wrapSerializers: true,
+                customProps: (req, res) => {
+                    return {
+                        env: this.nodeEnv,
+                        appName: this.getString('NAME'),
+                        user: req === null || req === void 0 ? void 0 : req.user,
+                        'req.body': req === null || req === void 0 ? void 0 : req.body,
+                        'res.body': res === null || res === void 0 ? void 0 : res.body,
+                    };
+                },
+                redact: {
+                    paths: ['req.headers.authorization', 'req.headers.apikey'],
+                    remove: true,
+                },
+            },
+        };
+    }
+    get axiosProxyConfig() {
+        if (!this.getBoolean('DIRECT_PROXY_ENABLED')) {
+            return false;
+        }
+        return {
+            host: this.getString('DIRECT_PROXY_HOST'),
+            port: this.getNumber('DIRECT_PROXY_PORT'),
+        };
+    }
+    static getRootPath() {
+        if (!ApiConfigService_1.rootPath) {
+            throw new Error(`rootPath is not set`);
+        }
+        return ApiConfigService_1.rootPath;
+    }
+    static toBoolean(value, defaultValue = null) {
+        try {
+            return Boolean(JSON.parse(value));
+        }
+        catch (_a) {
+            if (!(0, lodash_1.isNil)(defaultValue)) {
+                return defaultValue;
+            }
+            throw new Error(`value:${value} - is not a boolean`);
+        }
+    }
+    getNumber(key, defaultValue) {
+        const value = this.get(key, defaultValue);
+        try {
+            return Number(value);
+        }
+        catch (_a) {
+            throw new Error(`key:${key}, value:${value} - is not a number`);
+        }
+    }
+    getBoolean(key, defaultValue) {
+        const value = this.get(key, defaultValue);
+        return ApiConfigService_1.toBoolean(value);
+    }
+    getString(key, defaultValue) {
+        const value = this.get(key, defaultValue);
+        return value.replace(/\\n/g, '\n');
+    }
+    get(key, defaultValue) {
+        const value = this.configService.get(key);
+        if ((0, lodash_1.isNil)(value)) {
+            if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            throw new Error(`key:'${key}' - environment does not set`);
+        }
+        return value;
+    }
+};
+exports.ApiConfigService = ApiConfigService;
+exports.ApiConfigService = ApiConfigService = ApiConfigService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], ApiConfigService);

package/shared/services/generator.service.d.ts

@@ -0,0 +1,4 @@
+export declare class GeneratorService {
+    uuid(): string;
+    fileName(ext: string): string;
+}