@alacard-project/config-sdk 1.1.1 → 1.1.4

package/src/clients/config.client.ts

@@ -1,252 +0,0 @@
-import * as grpc from '@grpc/grpc-js';
-import { Kafka, Consumer, EachMessagePayload } from 'kafkajs';
-import * as path from 'path';
-import * as dotenv from 'dotenv';
-import CircuitBreaker from 'opossum';
-import { Logger } from '@nestjs/common';
-import { ConfigServiceClient } from '../generated/config';
-import { GetConfigRequest } from '../types/grpc.types';
-import { VaultClient } from './vault.client';
-import { ConfigOptions, ConfigUpdatedEvent } from '../types/config.types';
-
-export class ConfigClient {
-    private readonly logger: Logger = new Logger('ConfigSDK');
-    private configMap: Record<string, string> = {};
-    private consumer: Consumer | null = null;
-    private options: ConfigOptions;
-    private vaultClient: VaultClient | null = null;
-    private breaker: CircuitBreaker | null = null;
-    private static instance: ConfigClient | null = null;
-
-    private constructor(options: ConfigOptions) {
-        this.options = options;
-    }
-
-    public static async initialize(options: ConfigOptions): Promise<ConfigClient> {
-        if (this.instance) {
-            return this.instance;
-        }
-        const client = new ConfigClient(options);
-        await client.init();
-        this.instance = client;
-        return client;
-    }
-
-    public static getInstance(): ConfigClient {
-        if (!this.instance) {
-            throw new Error('[ConfigSDK] ConfigClient not initialized. Call initialize() first.');
-        }
-        return this.instance;
-    }
-
-    private async init(): Promise<void> {
-        const { serviceName, environment, grpcUrl, version = 'v1', useDotenvFallback = true } = this.options;
-
-        try {
-            // 1. Load from Process Env (Highest Priority for overrides)
-            this.loadProcessEnv();
-
-            // 2. Load from DotEnv (if enabled)
-            if (useDotenvFallback) {
-                this.loadDotEnv(environment);
-            }
-
-            // 3. Load from Vault (if configured)
-            if (this.options.vault) {
-                await this.loadVaultSecrets(serviceName);
-            }
-
-            // 4. Fetch Remote Config via gRPC (with Circuit Breaker)
-            await this.fetchRemoteConfig(serviceName, environment, grpcUrl, version);
-
-            // 5. Start Kafka Watcher (if configured)
-            if (this.options.kafkaBrokers && this.options.kafkaBrokers.length > 0) {
-                await this.startWatching();
-            }
-
-            this.logger.log(`Configuration initialized with ${Object.keys(this.configMap).length} keys`);
-        } catch (error: unknown) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.logger.error(`Critical initialization failure: ${errorMsg}. Service starting with loaded config.`);
-        }
-    }
-
-    private loadProcessEnv(): void {
-        const ALLOWED_ENV_PREFIXES = ['APP_', 'KAFKA_', 'DB_', 'REDIS_', 'GRPC_', 'PORT', 'NODE_ENV', 'DATABASE_URL'];
-        for (const [key, value] of Object.entries(process.env)) {
-            if (value && ALLOWED_ENV_PREFIXES.some(prefix => key.startsWith(prefix))) {
-                this.configMap[key] = value;
-            }
-        }
-    }
-
-    private loadDotEnv(environment: string): void {
-        // Only support standard .env and environment-specific .env
-        const envFiles = [`.env.${environment}`, '.env'];
-        for (const file of envFiles) {
-            const filePath = path.resolve(process.cwd(), file);
-            const result = dotenv.config({ path: filePath });
-            if (result.parsed) {
-                // Do not overwrite existing keys (process.env wins)
-                for (const [key, value] of Object.entries(result.parsed)) {
-                    if (!this.configMap[key]) {
-                        this.configMap[key] = value;
-                    }
-                }
-                this.logger.log(`Loaded variables from ${file}`);
-            }
-        }
-    }
-
-    private async loadVaultSecrets(serviceName: string): Promise<void> {
-        if (!this.options.vault) return;
-
-        this.vaultClient = new VaultClient(this.options.vault);
-        try {
-            const vaultSecrets = await this.vaultClient.getKVSecrets(`config-service/${serviceName}`);
-            // Vault secrets should overwrite env vars if needed, or fill gaps. 
-            // Usually Vault > Env, but here we treat Env > Vault for local overrides. 
-            // Let's adopt a safe merge: Existing keys (from Env) take precedence.
-            for (const [key, value] of Object.entries(vaultSecrets)) {
-                if (!this.configMap[key]) {
-                    this.configMap[key] = value as string;
-                }
-            }
-            this.logger.log(`Loaded secrets from Vault for ${serviceName}`);
-        } catch (error: unknown) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.logger.warn(`Vault secrets unavailable: ${errorMsg}. Continuing with local config.`);
-        }
-    }
-
-    private initCircuitBreaker(client: ConfigServiceClient): void {
-        const fetchFunction = (request: GetConfigRequest, metadata: grpc.Metadata) => {
-            return new Promise<Record<string, string>>((resolve, reject) => {
-                client.getConfig(request, metadata, (error, response) => {
-                    if (error) return reject(error);
-                    resolve(response.values || {});
-                });
-            });
-        };
-
-        this.breaker = new CircuitBreaker(fetchFunction, {
-            timeout: 5000, // 5s timeout
-            errorThresholdPercentage: 50, // 50% errors opens the breaker
-            resetTimeout: 10000, // wait 10s before trying again
-        });
-
-        this.breaker.on('open', () => this.logger.warn('Circuit Breaker (Config gRPC) is OPEN'));
-        this.breaker.on('halfOpen', () => this.logger.log('Circuit Breaker (Config gRPC) is HALF_OPEN'));
-        this.breaker.on('close', () => this.logger.log('Circuit Breaker (Config gRPC) is CLOSED'));
-    }
-
-    private async fetchRemoteConfig(serviceName: string, environment: string, grpcUrl: string, version: string): Promise<void> {
-        let credentials = grpc.credentials.createInsecure();
-        if (this.options.tls) {
-            credentials = grpc.credentials.createSsl(
-                this.options.tls.rootCert,
-                this.options.tls.clientKey,
-                this.options.tls.clientCert,
-            );
-        }
-
-        const client = new ConfigServiceClient(grpcUrl, credentials);
-
-        if (!this.breaker) {
-            this.initCircuitBreaker(client);
-        }
-
-        const request: GetConfigRequest = { serviceName, environment, version };
-        const metadata = new grpc.Metadata();
-        if (this.options.internalKey) {
-            metadata.set('x-internal-key', this.options.internalKey);
-        }
-
-        try {
-            const values = await this.breaker!.fire(request, metadata);
-            if (values) {
-                // Remote config fills in the gaps
-                for (const [key, value] of Object.entries(values)) {
-                    if (!this.configMap[key]) {
-                        this.configMap[key] = value as string;
-                    }
-                }
-                this.logger.log(`Remote config loaded from config-service`);
-            }
-        } catch (error: unknown) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.logger.warn(`Remote config (gRPC) failure: ${errorMsg}. Using local/vault fallback.`);
-        }
-    }
-
-    private async startWatching(): Promise<void> {
-        if (this.consumer) return;
-        try {
-            const kafka = new Kafka({
-                clientId: `config-sdk-${this.options.serviceName}`,
-                brokers: this.options.kafkaBrokers!,
-                retry: {
-                    retries: 5, // Retry up to 5 times
-                    maxRetryTime: 30000 // Max time spent retrying
-                }
-            });
-            const groupId = `config-watch-${this.options.serviceName}-${this.options.environment}`;
-            this.consumer = kafka.consumer({ groupId });
-            await this.consumer.connect();
-            await this.consumer.subscribe({ topic: 'config.updated', fromBeginning: false });
-
-            await this.consumer.run({
-                eachMessage: async ({ message }: EachMessagePayload) => {
-                    if (!message.value) return;
-                    try {
-                        const event: ConfigUpdatedEvent = JSON.parse(message.value.toString());
-                        if (event.service === 'global' || event.service === this.options.serviceName) {
-                            if (event.environment === this.options.environment) {
-                                this.logger.log(`Hot-reload: ${event.key} updated`);
-                                this.configMap[event.key] = event.value;
-                            }
-                        }
-                    } catch (err: unknown) {
-                        const errorMsg = err instanceof Error ? err.message : String(err);
-                        this.logger.error(`Failed to parse config update: ${errorMsg}`);
-                    }
-                },
-            });
-        } catch (error: unknown) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.logger.warn(`Config watch mode (Kafka) failed: ${errorMsg}`);
-        }
-    }
-
-    public get<T = string>(key: string, defaultValue?: T): T {
-        const val = this.configMap[key];
-
-        if (val === undefined || val === null) {
-            if (defaultValue !== undefined) {
-                return defaultValue;
-            }
-            // Strict mode: warn if key is missing and no default value
-            this.logger.warn(`Configuration key '${key}' not found and no default value provided.`);
-            return undefined as unknown as T;
-        }
-
-        return val as unknown as T;
-    }
-
-    public getInt(key: string, defaultValue: number = 0): number {
-        const val = this.get<string>(key);
-        if (!val) return defaultValue;
-        const parsed = parseInt(val, 10);
-        return isNaN(parsed) ? defaultValue : parsed;
-    }
-
-    public getBool(key: string, defaultValue: boolean = false): boolean {
-        const val = this.get<string>(key);
-        if (!val) return defaultValue;
-        return val.toLowerCase() === 'true' || val === '1';
-    }
-
-    public getAll(): Record<string, string> {
-        return { ...this.configMap };
-    }
-}

package/src/clients/vault.client.ts

@@ -1,82 +0,0 @@
-import axios, { AxiosInstance, AxiosResponse } from 'axios';
-import { Logger } from '@nestjs/common';
-import { VaultOptions, VaultCerts } from '../types/config.types';
-
-export class VaultClient {
-    private readonly logger: Logger = new Logger('VaultSDK');
-    private http: AxiosInstance;
-    private options: VaultOptions;
-    private token: string | null = null;
-    private tokenExpiry: number = 0;
-
-    constructor(options: VaultOptions) {
-        this.options = options;
-        this.http = axios.create({
-            baseURL: `${options.address}/v1`,
-        });
-    }
-
-    private async login(): Promise<void> {
-        if (this.token && Date.now() < this.tokenExpiry) {
-            return;
-        }
-
-        try {
-            const response: AxiosResponse = await this.http.post('/auth/approle/login', {
-                role_id: this.options.roleId,
-                secret_id: this.options.secretId,
-            });
-
-            const { client_token, lease_duration } = response.data.auth;
-            this.token = client_token;
-            this.tokenExpiry = Date.now() + (lease_duration - 60) * 1000;
-
-            this.http.defaults.headers.common['X-Vault-Token'] = this.token;
-            this.logger.log('Successfully authenticated with Vault AppRole');
-        } catch (error: unknown) {
-            const errorMsg = error instanceof Error ? (error as any).response?.data?.errors?.[0] || error.message : String(error);
-            this.logger.error(`Vault login failed: ${errorMsg}`);
-            throw new Error(`Vault login failed: ${errorMsg}`);
-        }
-    }
-
-    public async getKVSecrets(path: string): Promise<Record<string, string>> {
-        await this.login();
-        try {
-            const response: AxiosResponse = await this.http.get(`/secret/data/${path}`);
-            return response.data.data.data;
-        } catch (error: unknown) {
-            if (error && typeof error === 'object' && 'response' in error) {
-                const axiosError = error as { response?: { status?: number } };
-                if (axiosError.response?.status === 404) {
-                    this.logger.warn(`Secret not found at path: ${path}`);
-                    return {};
-                }
-            }
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.logger.error(`Failed to fetch secrets from path ${path}: ${errorMsg}`);
-            throw new Error(`Failed to fetch secrets: ${errorMsg}`);
-        }
-    }
-
-    public async issueCertificate(commonName: string): Promise<VaultCerts> {
-        await this.login();
-        const pkiPath = this.options.pkiPath || 'pki/issue/config-service';
-        try {
-            const response: AxiosResponse = await this.http.post(pkiPath, {
-                common_name: commonName,
-            });
-
-            const { ca_chain, certificate, private_key } = response.data.data;
-            return {
-                ca: (ca_chain as string[])[0] || '',
-                certificate: certificate as string,
-                privateKey: private_key as string,
-            };
-        } catch (error: unknown) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.logger.error(`Failed to issue certificate for ${commonName}: ${errorMsg}`);
-            throw new Error(`Failed to issue certificate: ${errorMsg}`);
-        }
-    }
-}

package/src/constants/index.ts

@@ -1 +0,0 @@
-export const CONFIG_OPTIONS = 'CONFIG_OPTIONS';

package/src/enums/env.enum.ts

@@ -1,7 +0,0 @@
-export enum Environment {
-    DEVELOPMENT = 'development',
-    STAGING = 'staging',
-    PRODUCTION = 'production',
-    TEST = 'test',
-    LOCAL = 'local',
-}