@nest-omni/core 3.1.1-9 → 3.1.1

package/validators/phone-country-code.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsPhoneNumberWithCountryCode(validationOptions?: ValidationOptions): (object: NonNullable<unknown>, propertyName: string) => void;

package/validators/phone-country-code.validator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsPhoneNumberWithCountryCode = IsPhoneNumberWithCountryCode;
+const class_validator_1 = require("class-validator");
+function IsPhoneNumberWithCountryCode(validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.ValidateIf)((_, value) => !!value)(object, propertyName);
+        const countryCodePropertyName = 'countryCode';
+        (0, class_validator_1.registerDecorator)({
+            name: 'isPhoneNumberWithCountryCode',
+            target: object.constructor,
+            propertyName: propertyName,
+            constraints: [countryCodePropertyName],
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    const [countryCodePropertyName] = args.constraints;
+                    const countryCode = args.object[countryCodePropertyName];
+                    return (0, class_validator_1.isPhoneNumber)(value, countryCode);
+                },
+                defaultMessage(args) {
+                    const [countryCodePropertyName] = args.constraints;
+                    const countryCode = args.object[countryCodePropertyName];
+                    return `$property must be a valid phone number in the country code ${countryCode}`;
+                },
+            },
+        });
+    };
+}

package/validators/same-as.validator.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationOptions } from 'class-validator';
+export declare function SameAs(property: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/validators/same-as.validator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SameAs = SameAs;
+const class_validator_1 = require("class-validator");
+function SameAs(property, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'sameAs',
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints: [property],
+            validator: {
+                validate(value, args) {
+                    const [relatedPropertyName] = args.constraints;
+                    return (args === null || args === void 0 ? void 0 : args.object[relatedPropertyName]) === value;
+                },
+                defaultMessage() {
+                    return '$property must match $constraint1';
+                },
+            },
+        });
+    };
+}

package/validators/skip-empty.validator.d.ts

@@ -0,0 +1 @@
+export declare function SkipEmpty(field?: string): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/validators/skip-empty.validator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipEmpty = SkipEmpty;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const lodash_1 = require("lodash");
+function SkipEmpty(field) {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiProperty)({ required: false }), (0, class_validator_1.ValidateIf)((obj, value) => {
+        if (field) {
+            value = obj[field];
+        }
+        return !(value === null ||
+            value === undefined ||
+            ((0, lodash_1.isString)(value) && value.trim() === ''));
+    }));
+}

package/vault/index.d.ts

@@ -0,0 +1,4 @@
+export * from './vault-config.loader';
+export * from './vault-config.service';
+export * from './vault.module';
+export * from './interfaces/vault-options.interface';

package/vault/index.js

@@ -0,0 +1,20 @@
+"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("./vault-config.loader"), exports);
+__exportStar(require("./vault-config.service"), exports);
+__exportStar(require("./vault.module"), exports);
+__exportStar(require("./interfaces/vault-options.interface"), exports);

package/vault/interfaces/vault-options.interface.d.ts

@@ -0,0 +1,22 @@
+export interface VaultAuthOptions {
+    token?: string;
+    roleId?: string;
+    secretId?: string;
+    k8sRole?: string;
+    k8sServiceAccountToken?: string;
+}
+export interface VaultOptions {
+    endpoint: string;
+    auth: VaultAuthOptions;
+    secretPaths: string[];
+    namespace?: string;
+    apiVersion?: 'v1' | 'v2';
+    timeout?: number;
+    enableHotReload?: boolean;
+    hotReloadInterval?: number;
+    failOnError?: boolean;
+}
+export interface VaultConfig {
+    enabled: boolean;
+    options?: VaultOptions;
+}

package/vault/interfaces/vault-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/vault/vault-config.loader.d.ts

@@ -0,0 +1,13 @@
+export declare class VaultConfigLoader {
+    private static readonly logger;
+    private static vaultClient;
+    private static hotReloadTimer;
+    private static buildVaultOptions;
+    private static initializeVaultClient;
+    private static readSecrets;
+    static loadVaultConfig(): Promise<void>;
+    private static startHotReload;
+    static stopHotReload(): void;
+    static getVaultClient(): any;
+    static isConnected(): boolean;
+}

package/vault/vault-config.loader.js

@@ -0,0 +1,246 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultConfigLoader = void 0;
+const common_1 = require("@nestjs/common");
+class VaultConfigLoader {
+    static buildVaultOptions() {
+        var _a;
+        const enabled = process.env.VAULT_ENABLED === 'true';
+        if (!enabled) {
+            this.logger.log('Vault is disabled (VAULT_ENABLED != true)');
+            return null;
+        }
+        const endpoint = process.env.VAULT_ENDPOINT;
+        const secretPaths = ((_a = process.env.VAULT_SECRET_PATHS) === null || _a === void 0 ? void 0 : _a.split(',').map(p => p.trim())) || [];
+        if (!endpoint) {
+            this.logger.warn('Vault enabled but VAULT_ENDPOINT is not set');
+            return null;
+        }
+        if (secretPaths.length === 0) {
+            this.logger.warn('Vault enabled but VAULT_SECRET_PATHS is empty');
+            return null;
+        }
+        const auth = {};
+        if (process.env.VAULT_TOKEN) {
+            auth.token = process.env.VAULT_TOKEN;
+            this.logger.log('Using Vault Token authentication');
+        }
+        else if (process.env.VAULT_ROLE_ID && process.env.VAULT_SECRET_ID) {
+            auth.roleId = process.env.VAULT_ROLE_ID;
+            auth.secretId = process.env.VAULT_SECRET_ID;
+            this.logger.log('Using Vault AppRole authentication');
+        }
+        else if (process.env.VAULT_K8S_ROLE) {
+            auth.k8sRole = process.env.VAULT_K8S_ROLE;
+            auth.k8sServiceAccountToken = process.env.VAULT_K8S_SA_TOKEN;
+            this.logger.log('Using Vault Kubernetes authentication');
+        }
+        else {
+            this.logger.warn('Vault enabled but no valid authentication method configured');
+            return null;
+        }
+        const options = {
+            endpoint,
+            auth,
+            secretPaths,
+            namespace: process.env.VAULT_NAMESPACE,
+            apiVersion: process.env.VAULT_API_VERSION || 'v2',
+            timeout: parseInt(process.env.VAULT_TIMEOUT || '5000', 10),
+            enableHotReload: process.env.VAULT_HOT_RELOAD === 'true',
+            hotReloadInterval: parseInt(process.env.VAULT_HOT_RELOAD_INTERVAL || '300', 10),
+            failOnError: process.env.VAULT_FAIL_ON_ERROR !== 'false',
+        };
+        this.logger.log(`Vault configuration loaded: ${secretPaths.length} secret path(s)`);
+        return options;
+    }
+    static initializeVaultClient(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let vault;
+            try {
+                vault = yield Promise.resolve().then(() => require('node-vault'));
+                vault = vault.default || vault;
+            }
+            catch (error) {
+                throw new Error('node-vault package not installed. Run: npm install node-vault');
+            }
+            const client = vault({
+                endpoint: options.endpoint,
+                namespace: options.namespace,
+                requestOptions: {
+                    timeout: options.timeout,
+                },
+            });
+            try {
+                if (options.auth.token) {
+                    client.token = options.auth.token;
+                    this.logger.log('Vault Token authentication configured');
+                }
+                else if (options.auth.roleId && options.auth.secretId) {
+                    const result = yield client.approleLogin({
+                        role_id: options.auth.roleId,
+                        secret_id: options.auth.secretId,
+                    });
+                    client.token = result.auth.client_token;
+                    this.logger.log('Vault AppRole authentication successful');
+                }
+                else if (options.auth.k8sRole) {
+                    let jwt = options.auth.k8sServiceAccountToken;
+                    if (!jwt) {
+                        const fs = yield Promise.resolve().then(() => require('fs'));
+                        const K8S_SA_TOKEN_PATH = '/var/run/secrets/kubernetes.io/serviceaccount/token';
+                        if (fs.existsSync(K8S_SA_TOKEN_PATH)) {
+                            jwt = fs.readFileSync(K8S_SA_TOKEN_PATH, 'utf8');
+                        }
+                        else {
+                            throw new Error('Kubernetes service account token not found');
+                        }
+                    }
+                    const result = yield client.kubernetesLogin({
+                        role: options.auth.k8sRole,
+                        jwt,
+                    });
+                    client.token = result.auth.client_token;
+                    this.logger.log('Vault Kubernetes authentication successful');
+                }
+                else {
+                    throw new Error('No valid Vault authentication method configured');
+                }
+                yield client.tokenLookupSelf();
+                this.logger.log('Vault authentication verified');
+                return client;
+            }
+            catch (error) {
+                this.logger.error('Vault authentication failed', error);
+                throw error;
+            }
+        });
+    }
+    static readSecrets(client, secretPath, apiVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logger.debug(`Reading secrets from: ${secretPath}`);
+                const result = yield client.read(secretPath);
+                if (!result || !result.data) {
+                    this.logger.warn(`No data found at path: ${secretPath}`);
+                    return {};
+                }
+                const secrets = apiVersion === 'v2' ? result.data.data : result.data;
+                if (!secrets || typeof secrets !== 'object') {
+                    this.logger.warn(`Invalid secret format at path: ${secretPath}`);
+                    return {};
+                }
+                const secretCount = Object.keys(secrets).length;
+                this.logger.log(`Loaded ${secretCount} secret(s) from ${secretPath}`);
+                return secrets;
+            }
+            catch (error) {
+                this.logger.error(`Failed to read secrets from path: ${secretPath}`, error.message);
+                return {};
+            }
+        });
+    }
+    static loadVaultConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = this.buildVaultOptions();
+            if (!options) {
+                this.logger.log('Skipping Vault configuration loading');
+                return;
+            }
+            try {
+                this.logger.log(`Connecting to Vault at ${options.endpoint}`);
+                this.vaultClient = yield this.initializeVaultClient(options);
+                const allSecrets = {};
+                for (const secretPath of options.secretPaths) {
+                    const secrets = yield this.readSecrets(this.vaultClient, secretPath, options.apiVersion);
+                    Object.assign(allSecrets, secrets);
+                }
+                let injectedCount = 0;
+                let overriddenCount = 0;
+                for (const [key, value] of Object.entries(allSecrets)) {
+                    const hadPreviousValue = key in process.env;
+                    process.env[key] = String(value);
+                    if (hadPreviousValue) {
+                        overriddenCount++;
+                        this.logger.debug(`Override ${key} with Vault value`);
+                    }
+                    else {
+                        injectedCount++;
+                    }
+                }
+                this.logger.log(`Vault configuration loaded: ${injectedCount} new, ${overriddenCount} overridden`);
+                if (options.enableHotReload) {
+                    this.startHotReload(options);
+                }
+            }
+            catch (error) {
+                this.logger.error('Failed to load Vault configuration', error.message);
+                if (options.failOnError) {
+                    this.logger.error('Application startup failed due to Vault error');
+                    throw error;
+                }
+                else {
+                    this.logger.warn('Continuing without Vault configuration (VAULT_FAIL_ON_ERROR=false)');
+                }
+            }
+        });
+    }
+    static startHotReload(options) {
+        this.logger.log(`Starting Vault hot reload with interval: ${options.hotReloadInterval}s`);
+        if (this.hotReloadTimer) {
+            clearInterval(this.hotReloadTimer);
+        }
+        this.hotReloadTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logger.debug('Reloading Vault configuration...');
+                const allSecrets = {};
+                for (const secretPath of options.secretPaths) {
+                    const secrets = yield this.readSecrets(this.vaultClient, secretPath, options.apiVersion);
+                    Object.assign(allSecrets, secrets);
+                }
+                let changedCount = 0;
+                for (const [key, value] of Object.entries(allSecrets)) {
+                    const newValue = String(value);
+                    if (process.env[key] !== newValue) {
+                        this.logger.log(`Configuration changed: ${key}`);
+                        process.env[key] = newValue;
+                        changedCount++;
+                    }
+                }
+                if (changedCount > 0) {
+                    this.logger.log(`Hot reload completed: ${changedCount} configuration(s) updated`);
+                }
+                else {
+                    this.logger.debug('Hot reload completed: no changes detected');
+                }
+            }
+            catch (error) {
+                this.logger.error('Failed to reload Vault configuration', error.message);
+            }
+        }), options.hotReloadInterval * 1000);
+    }
+    static stopHotReload() {
+        if (this.hotReloadTimer) {
+            clearInterval(this.hotReloadTimer);
+            this.hotReloadTimer = null;
+            this.logger.log('Vault hot reload stopped');
+        }
+    }
+    static getVaultClient() {
+        return this.vaultClient;
+    }
+    static isConnected() {
+        return this.vaultClient !== null && this.vaultClient !== undefined;
+    }
+}
+exports.VaultConfigLoader = VaultConfigLoader;
+VaultConfigLoader.logger = new common_1.Logger(VaultConfigLoader.name);
+VaultConfigLoader.hotReloadTimer = null;

package/vault/vault-config.service.d.ts

@@ -0,0 +1,18 @@
+export declare class VaultConfigService {
+    private readonly logger;
+    private vaultClient;
+    constructor();
+    isAvailable(): boolean;
+    getSecret(path: string, key?: string): Promise<any>;
+    setSecret(path: string, data: Record<string, any>): Promise<void>;
+    deleteSecret(path: string): Promise<void>;
+    listSecrets(path: string): Promise<string[]>;
+    healthCheck(): Promise<boolean>;
+    getStatus(): Promise<{
+        initialized: boolean;
+        sealed: boolean;
+        standby: boolean;
+        version: string;
+    } | null>;
+    renewToken(increment?: number): Promise<void>;
+}

package/vault/vault-config.service.js

@@ -0,0 +1,174 @@
+"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 __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 VaultConfigService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultConfigService = void 0;
+const common_1 = require("@nestjs/common");
+const vault_config_loader_1 = require("./vault-config.loader");
+let VaultConfigService = VaultConfigService_1 = class VaultConfigService {
+    constructor() {
+        this.logger = new common_1.Logger(VaultConfigService_1.name);
+        this.vaultClient = vault_config_loader_1.VaultConfigLoader.getVaultClient();
+        if (!this.vaultClient) {
+            this.logger.warn('Vault client not initialized. VaultConfigService methods will throw errors.');
+        }
+    }
+    isAvailable() {
+        return vault_config_loader_1.VaultConfigLoader.isConnected();
+    }
+    getSecret(path, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                throw new Error('Vault client not initialized. Check VAULT_ENABLED configuration.');
+            }
+            try {
+                const apiVersion = process.env.VAULT_API_VERSION || 'v2';
+                const result = yield this.vaultClient.read(path);
+                if (!result || !result.data) {
+                    throw new Error(`No data found at path: ${path}`);
+                }
+                const data = apiVersion === 'v2' ? result.data.data : result.data;
+                if (!data || typeof data !== 'object') {
+                    throw new Error(`Invalid secret format at path: ${path}`);
+                }
+                if (key) {
+                    if (!(key in data)) {
+                        throw new Error(`Key '${key}' not found in secret at path: ${path}`);
+                    }
+                    return data[key];
+                }
+                return data;
+            }
+            catch (error) {
+                this.logger.error(`Failed to read secret from Vault: ${path}`, error.message);
+                throw error;
+            }
+        });
+    }
+    setSecret(path, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                throw new Error('Vault client not initialized. Check VAULT_ENABLED configuration.');
+            }
+            try {
+                const apiVersion = process.env.VAULT_API_VERSION || 'v2';
+                if (apiVersion === 'v2') {
+                    yield this.vaultClient.write(path, { data });
+                }
+                else {
+                    yield this.vaultClient.write(path, data);
+                }
+                this.logger.log(`Successfully wrote secret to Vault: ${path}`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to write secret to Vault: ${path}`, error.message);
+                throw error;
+            }
+        });
+    }
+    deleteSecret(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                throw new Error('Vault client not initialized. Check VAULT_ENABLED configuration.');
+            }
+            try {
+                yield this.vaultClient.delete(path);
+                this.logger.log(`Successfully deleted secret from Vault: ${path}`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to delete secret from Vault: ${path}`, error.message);
+                throw error;
+            }
+        });
+    }
+    listSecrets(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                throw new Error('Vault client not initialized. Check VAULT_ENABLED configuration.');
+            }
+            try {
+                const result = yield this.vaultClient.list(path);
+                if (!result || !result.data || !result.data.keys) {
+                    return [];
+                }
+                return result.data.keys;
+            }
+            catch (error) {
+                this.logger.error(`Failed to list secrets from Vault: ${path}`, error.message);
+                throw error;
+            }
+        });
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                return false;
+            }
+            try {
+                const health = yield this.vaultClient.health();
+                return health && !health.sealed;
+            }
+            catch (error) {
+                this.logger.error('Vault health check failed', error.message);
+                return false;
+            }
+        });
+    }
+    getStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                return null;
+            }
+            try {
+                const health = yield this.vaultClient.health();
+                return {
+                    initialized: health.initialized || false,
+                    sealed: health.sealed || false,
+                    standby: health.standby || false,
+                    version: health.version || 'unknown',
+                };
+            }
+            catch (error) {
+                this.logger.error('Failed to get Vault status', error.message);
+                return null;
+            }
+        });
+    }
+    renewToken(increment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.vaultClient) {
+                throw new Error('Vault client not initialized. Check VAULT_ENABLED configuration.');
+            }
+            try {
+                yield this.vaultClient.tokenRenewSelf({ increment });
+                this.logger.log('Vault token renewed successfully');
+            }
+            catch (error) {
+                this.logger.error('Failed to renew Vault token', error.message);
+                throw error;
+            }
+        });
+    }
+};
+exports.VaultConfigService = VaultConfigService;
+exports.VaultConfigService = VaultConfigService = VaultConfigService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], VaultConfigService);

package/vault/vault.module.d.ts

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

package/vault/vault.module.js

@@ -0,0 +1,21 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultModule = void 0;
+const common_1 = require("@nestjs/common");
+const vault_config_service_1 = require("./vault-config.service");
+let VaultModule = class VaultModule {
+};
+exports.VaultModule = VaultModule;
+exports.VaultModule = VaultModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [vault_config_service_1.VaultConfigService],
+        exports: [vault_config_service_1.VaultConfigService],
+    })
+], VaultModule);