@alacard-project/config-sdk 1.1.1 → 1.1.4

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './clients/config.client';
-export * from './clients/vault.client';
-export * from './modules/config.module';
-export * from './utils/nest-helpers';
-export * from './constants';
-export * from './enums/env.enum';
-export * from './types/config.types';
-export * from './types/grpc.types';

package/src/modules/config.module.ts

@@ -1,28 +0,0 @@
-import { DynamicModule, Module, Global, Provider } from '@nestjs/common';
-import { ConfigClient } from '../clients/config.client';
-import { ConfigOptions } from '../types/config.types';
-import { CONFIG_OPTIONS } from '../constants';
-
-@Global()
-@Module({})
-export class ConfigModule {
-    public static forRoot(options: ConfigOptions): DynamicModule {
-        const optionsProvider: Provider = {
-            provide: CONFIG_OPTIONS,
-            useValue: options,
-        };
-
-        const configClientProvider: Provider = {
-            provide: ConfigClient,
-            useFactory: async (): Promise<ConfigClient> => {
-                return await ConfigClient.initialize(options);
-            },
-        };
-
-        return {
-            module: ConfigModule,
-            providers: [optionsProvider, configClientProvider],
-            exports: [configClientProvider, optionsProvider],
-        };
-    }
-}

package/src/types/config.types.ts

@@ -1,38 +0,0 @@
-export interface VaultOptions {
-    address: string;
-    roleId: string;
-    secretId: string;
-    pkiPath?: string;
-}
-
-export interface VaultCerts {
-    ca: string;
-    certificate: string;
-    privateKey: string;
-}
-
-export interface TLSConfig {
-    rootCert: Buffer;
-    clientCert: Buffer;
-    clientKey: Buffer;
-}
-
-export interface ConfigOptions {
-    serviceName: string;
-    environment: string;
-    grpcUrl: string;
-    version?: string;
-    kafkaBrokers?: string[];
-    useDotenvFallback?: boolean;
-    internalKey?: string;
-    tls?: TLSConfig;
-    vault?: VaultOptions;
-}
-
-export interface ConfigUpdatedEvent {
-    service: string;
-    environment: string;
-    version: string;
-    key: string;
-    value: string;
-}

package/src/types/grpc.types.ts

@@ -1,15 +0,0 @@
-import {
-    GetConfigRequest as GeneratedGetConfigRequest,
-    ConfigResponse as GeneratedConfigResponse,
-    SetConfigRequest as GeneratedSetConfigRequest,
-    ListConfigsRequest as GeneratedListConfigsRequest,
-    ListConfigsResponse as GeneratedListConfigsResponse,
-    ServiceConfig as GeneratedServiceConfig
-} from '../generated/config';
-
-export interface GetConfigRequest extends GeneratedGetConfigRequest { }
-export interface ConfigResponse extends GeneratedConfigResponse { }
-export interface SetConfigRequest extends GeneratedSetConfigRequest { }
-export interface ListConfigsRequest extends GeneratedListConfigsRequest { }
-export interface ListConfigsResponse extends GeneratedListConfigsResponse { }
-export interface ServiceConfig extends GeneratedServiceConfig { }

package/src/types/types.ts

@@ -1,12 +0,0 @@
-export interface ConfigMap {
-  [key: string]: string;
-}
-
-export interface ConfigOptions {
-    serviceName: string;
-    environment: string;
-    grpcUrl: string;
-    version?: string;
-    kafkaBrokers?: string[];
-    useDotenvFallback?: boolean;
-}

package/src/utils/nest-helpers.ts

@@ -1,69 +0,0 @@
-import { Environment } from '../enums/env.enum';
-import { ConfigClient } from '../clients/config.client';
-
-export abstract class BaseConfigService {
-    constructor() { }
-
-    public get<T = string>(key: string, defaultValue?: T): T {
-        // 1. Try Config Client (if initialized)
-        try {
-            const client = ConfigClient.getInstance();
-            const val = client.get(key);
-            if (val !== undefined && val !== '') {
-                return val as unknown as T;
-            }
-        } catch (_e) {
-            // Client not initialized yet, fall through to process.env
-        }
-
-        // 2. Try process.env
-        const envVal = process.env[key];
-        if (envVal !== undefined) {
-            return envVal as unknown as T;
-        }
-
-        return defaultValue as T;
-    }
-
-    public getRequiredString(key: string): string {
-        const value = this.get<string>(key);
-        if (!value && process.env.NODE_ENV !== Environment.TEST) {
-            throw new Error(`Configuration Error: ${key} is required`);
-        }
-        return value || '';
-    }
-
-    public getRequiredNumber(key: string): number {
-        const value = this.get<string>(key);
-        if (!value && process.env.NODE_ENV !== Environment.TEST) {
-            throw new Error(`Configuration Error: ${key} is required`);
-        }
-        return parseInt(value || '0', 10);
-    }
-
-    public getOptionalString(key: string, defaultValue: string): string {
-        return this.get<string>(key, defaultValue) || defaultValue;
-    }
-
-    public getOptionalNumber(key: string, defaultValue: number): number {
-        const value = this.get<string>(key);
-        return value ? parseInt(value, 10) : defaultValue;
-    }
-
-    get environment(): Environment {
-        return this.get<Environment>('NODE_ENV', Environment.DEVELOPMENT) || Environment.DEVELOPMENT;
-    }
-
-    get databaseUrl(): string {
-        return this.getRequiredString('DATABASE_URL');
-    }
-
-    get kafkaBrokers(): string[] {
-        const brokers = this.get<string>('KAFKA_BROKERS', 'localhost:9092');
-        return (brokers || 'localhost:9092').split(',');
-    }
-
-    get isProduction(): boolean {
-        return this.environment === Environment.PRODUCTION;
-    }
-}

package/test/config.client.spec.ts

@@ -1,108 +0,0 @@
-import { ConfigClient } from '../src/clients/config.client';
-import * as grpc from '@grpc/grpc-js';
-import { Kafka } from 'kafkajs';
-import CircuitBreaker from 'opossum';
-
-// Mock gRPC generated code
-jest.mock('../src/generated/config', () => ({
-    ConfigServiceClient: jest.fn().mockImplementation(() => ({
-        getConfig: jest.fn().mockImplementation((req, meta, cb) => {
-            cb(null, { values: { REMOTE_KEY: 'REMOTE_VALUE' } });
-        }),
-    })),
-}));
-
-jest.mock('@grpc/grpc-js');
-jest.mock('kafkajs');
-jest.mock('opossum');
-jest.mock('dotenv', () => ({
-    config: jest.fn().mockReturnValue({ parsed: { DOTENV_KEY: 'DOTENV_VALUE' } })
-}));
-
-describe('ConfigClient', () => {
-    const options = {
-        serviceName: 'test-service',
-        environment: 'test',
-        grpcUrl: 'localhost:50051',
-        kafkaBrokers: ['localhost:9092'],
-    };
-
-    let client: ConfigClient;
-    let mockConsumer: any;
-
-    beforeEach(async () => {
-        jest.clearAllMocks();
-
-        // Mock Kafka
-        mockConsumer = {
-            connect: jest.fn().mockResolvedValue(undefined),
-            subscribe: jest.fn().mockResolvedValue(undefined),
-            run: jest.fn().mockResolvedValue(undefined),
-        };
-        (Kafka as any).mockImplementation(() => ({
-            consumer: () => mockConsumer,
-        }));
-
-        // Mock CircuitBreaker
-        (CircuitBreaker as any).mockImplementation((fn: any) => ({
-            fire: jest.fn().mockImplementation((...args: any[]) => fn(...args)),
-            on: jest.fn(),
-        }));
-
-        // Mock grpc
-        (grpc.credentials.createInsecure as any).mockReturnValue({});
-
-        // Reset singleton
-        (ConfigClient as any).instance = null;
-    });
-
-    it('should initialize and load config from various sources', async () => {
-        process.env.APP_TEST_KEY = 'ENV_VALUE';
-
-        client = await ConfigClient.initialize(options);
-
-        expect(client.get('APP_TEST_KEY')).toBe('ENV_VALUE');
-        expect(client.get('REMOTE_KEY')).toBe('REMOTE_VALUE');
-        expect(client.get('DOTENV_KEY')).toBe('DOTENV_VALUE');
-    });
-
-    it('should return default value if key not found', async () => {
-        client = await ConfigClient.initialize(options);
-        expect(client.get('NON_EXISTENT', 'DEFAULT')).toBe('DEFAULT');
-    });
-
-    it('should handle numeric and boolean values', async () => {
-        client = await ConfigClient.initialize(options);
-        (client as any).configMap['INT_KEY'] = '42';
-        (client as any).configMap['BOOL_KEY'] = 'true';
-
-        expect(client.getInt('INT_KEY')).toBe(42);
-        expect(client.getBool('BOOL_KEY')).toBe(true);
-    });
-
-    it('should handle hot-reload from Kafka', async () => {
-        let kafkaHandler: any;
-        mockConsumer.run.mockImplementation(({ eachMessage }: any) => {
-            kafkaHandler = eachMessage;
-            return Promise.resolve();
-        });
-
-        client = await ConfigClient.initialize(options);
-
-        expect(kafkaHandler).toBeDefined();
-
-        // Simulate Kafka message
-        await kafkaHandler({
-            message: {
-                value: Buffer.from(JSON.stringify({
-                    service: 'test-service',
-                    environment: 'test',
-                    key: 'HOT_KEY',
-                    value: 'HOT_VALUE'
-                }))
-            }
-        });
-
-        expect(client.get('HOT_KEY')).toBe('HOT_VALUE');
-    });
-});

package/test/vault.client.spec.ts

@@ -1,62 +0,0 @@
-import { VaultClient } from '../src/clients/vault.client';
-import axios from 'axios';
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('VaultClient', () => {
-    const options = {
-        address: 'http://localhost:8200',
-        roleId: 'role-id',
-        secretId: 'secret-id',
-    };
-
-    let client: VaultClient;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockedAxios.create.mockReturnValue(mockedAxios as any);
-        client = new VaultClient(options);
-    });
-
-    it('should login and get secrets', async () => {
-        mockedAxios.post.mockResolvedValueOnce({
-            data: {
-                auth: {
-                    client_token: 'test-token',
-                    lease_duration: 3600,
-                },
-            },
-        });
-
-        mockedAxios.get.mockResolvedValueOnce({
-            data: {
-                data: {
-                    data: {
-                        KEY: 'VALUE',
-                    },
-                },
-            },
-        });
-
-        const secrets = await client.getKVSecrets('path');
-        expect(secrets).toEqual({ KEY: 'VALUE' });
-        expect(mockedAxios.post).toHaveBeenCalledWith('/auth/approle/login', expect.any(Object));
-        expect(mockedAxios.get).toHaveBeenCalledWith('/secret/data/path');
-    });
-
-    it('should handle 404 for secrets', async () => {
-        mockedAxios.post.mockResolvedValueOnce({
-            data: {
-                auth: { client_token: 't', lease_duration: 3600 },
-            },
-        });
-
-        mockedAxios.get.mockRejectedValueOnce({
-            response: { status: 404 },
-        });
-
-        const secrets = await client.getKVSecrets('missing');
-        expect(secrets).toEqual({});
-    });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "CommonJS",
-        "target": "ES2022",
-        "declaration": true,
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "moduleResolution": "node"
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}