@alacard-project/config-sdk 1.0.4 → 1.0.6

package/dist/clients/config.client.d.ts

@@ -0,0 +1,18 @@
+import { ConfigOptions } from '../types/config.types';
+export declare class ConfigClient {
+    private readonly logger;
+    private configMap;
+    private consumer;
+    private options;
+    private vaultClient;
+    private static instance;
+    private constructor();
+    static initialize(options: ConfigOptions): Promise<ConfigClient>;
+    static getInstance(): ConfigClient;
+    private init;
+    private fetchRemoteConfig;
+    private startWatching;
+    get(key: string, defaultValue?: string): string;
+    getInt(key: string, defaultValue?: number): number;
+    getAll(): Record<string, string>;
+}

package/dist/clients/config.client.js

@@ -0,0 +1,187 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigClient = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const kafkajs_1 = require("kafkajs");
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const common_1 = require("@nestjs/common");
+const config_1 = require("../generated/config");
+const vault_client_1 = require("./vault.client");
+class ConfigClient {
+    logger = new common_1.Logger('ConfigSDK');
+    configMap = {};
+    consumer = null;
+    options;
+    vaultClient = null;
+    static instance = null;
+    constructor(options) {
+        this.options = options;
+    }
+    static async initialize(options) {
+        const client = new ConfigClient(options);
+        await client.init();
+        this.instance = client;
+        return client;
+    }
+    static getInstance() {
+        if (!this.instance) {
+            throw new Error('[ConfigSDK] ConfigClient not initialized. Call initialize() first.');
+        }
+        return this.instance;
+    }
+    async init() {
+        const { serviceName, environment, grpcUrl, version = 'v1', useDotenvFallback = true } = this.options;
+        try {
+            if (useDotenvFallback) {
+                const envFile = `.env.${environment}`;
+                dotenv.config({ path: path.resolve(process.cwd(), envFile) });
+                const ALLOWED_ENV_PREFIXES = ['APP_', 'KAFKA_', 'DB_', 'REDIS_', 'GRPC_', 'PORT', 'NODE_ENV'];
+                for (const [key, value] of Object.entries(process.env)) {
+                    if (value && ALLOWED_ENV_PREFIXES.some(prefix => key.startsWith(prefix))) {
+                        this.configMap[key] = value;
+                    }
+                }
+                this.logger.log(`Loaded ${Object.keys(this.configMap).length} variables from .env`);
+            }
+            if (this.options.vault) {
+                this.vaultClient = new vault_client_1.VaultClient(this.options.vault);
+                try {
+                    const vaultSecrets = await this.vaultClient.getKVSecrets(`config-service/${serviceName}`);
+                    Object.assign(this.configMap, vaultSecrets);
+                    this.logger.log(`Loaded secrets from Vault KV for ${serviceName}`);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to load secrets from Vault: ${error.message}`);
+                }
+                if (this.options.vault.pkiPath && !this.options.tls) {
+                    try {
+                        const certs = await this.vaultClient.issueCertificate(serviceName);
+                        this.options.tls = {
+                            rootCert: Buffer.from(certs.ca),
+                            clientCert: Buffer.from(certs.certificate),
+                            clientKey: Buffer.from(certs.privateKey),
+                        };
+                        this.logger.log(`Dynamic mTLS certificate issued from Vault PKI`);
+                    }
+                    catch (error) {
+                        this.logger.warn(`Failed to issue certificate from Vault: ${error.message}`);
+                    }
+                }
+            }
+            await this.fetchRemoteConfig(serviceName, environment, grpcUrl, version);
+            if (this.options.kafkaBrokers && this.options.kafkaBrokers.length > 0) {
+                await this.startWatching();
+            }
+        }
+        catch (error) {
+            this.logger.error(`Critical initialization failure: ${error.message}`);
+            throw error;
+        }
+    }
+    async fetchRemoteConfig(serviceName, environment, grpcUrl, version) {
+        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 config_1.ConfigServiceClient(grpcUrl, credentials);
+        return new Promise((resolve) => {
+            const request = { serviceName, environment, version };
+            const metadata = new grpc.Metadata();
+            if (this.options.internalKey) {
+                metadata.set('x-internal-key', this.options.internalKey);
+            }
+            client.getConfig(request, metadata, (error, response) => {
+                if (error) {
+                    this.logger.warn(`Failed to fetch remote config from gRPC: ${error.message}. Using fallback.`);
+                    return resolve();
+                }
+                if (response && response.values) {
+                    Object.assign(this.configMap, response.values);
+                    this.logger.log(`Remote config loaded for ${serviceName} (${environment}, ${version})`);
+                }
+                resolve();
+            });
+        });
+    }
+    async startWatching() {
+        if (this.consumer)
+            return;
+        try {
+            const kafka = new kafkajs_1.Kafka({
+                clientId: `config-sdk-${this.options.serviceName}`,
+                brokers: this.options.kafkaBrokers,
+            });
+            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 });
+            const handler = async ({ message }) => {
+                if (!message.value)
+                    return;
+                try {
+                    const event = JSON.parse(message.value.toString());
+                    if (event.service === 'global' || event.service === this.options.serviceName) {
+                        if (event.environment === this.options.environment && event.version === (this.options.version || 'v1')) {
+                            this.logger.log(`Hot-reload: ${event.key} updated`);
+                            this.configMap[event.key] = event.value;
+                        }
+                    }
+                }
+                catch (err) {
+                    this.logger.error(`Failed to parse config update event: ${err.message}`);
+                }
+            };
+            await this.consumer.run({
+                eachMessage: handler,
+            });
+        }
+        catch (error) {
+            this.logger.error(`Watch mode failed: ${error.message}`);
+        }
+    }
+    get(key, defaultValue = '') {
+        return this.configMap[key] || defaultValue;
+    }
+    getInt(key, defaultValue = 0) {
+        const val = this.get(key);
+        return val ? parseInt(val, 10) : defaultValue;
+    }
+    getAll() {
+        return { ...this.configMap };
+    }
+}
+exports.ConfigClient = ConfigClient;

package/dist/clients/vault.client.d.ts

@@ -0,0 +1,12 @@
+import { VaultOptions, VaultCerts } from '../types/config.types';
+export declare class VaultClient {
+    private readonly logger;
+    private http;
+    private options;
+    private token;
+    private tokenExpiry;
+    constructor(options: VaultOptions);
+    private login;
+    getKVSecrets(path: string): Promise<Record<string, string>>;
+    issueCertificate(commonName: string): Promise<VaultCerts>;
+}

package/dist/clients/vault.client.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const common_1 = require("@nestjs/common");
+class VaultClient {
+    logger = new common_1.Logger('VaultSDK');
+    http;
+    options;
+    token = null;
+    tokenExpiry = 0;
+    constructor(options) {
+        this.options = options;
+        this.http = axios_1.default.create({
+            baseURL: `${options.address}/v1`,
+        });
+    }
+    async login() {
+        if (this.token && Date.now() < this.tokenExpiry) {
+            return;
+        }
+        try {
+            const response = 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) {
+            const errorMsg = error.response?.data?.errors?.[0] || error.message;
+            this.logger.error(`Vault login failed: ${errorMsg}`);
+            throw new Error(`Vault login failed: ${errorMsg}`);
+        }
+    }
+    async getKVSecrets(path) {
+        await this.login();
+        try {
+            const response = await this.http.get(`/secret/data/${path}`);
+            return response.data.data.data;
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                this.logger.warn(`Secret not found at path: ${path}`);
+                return {};
+            }
+            this.logger.error(`Failed to fetch secrets from path ${path}: ${error.message}`);
+            throw new Error(`Failed to fetch secrets: ${error.message}`);
+        }
+    }
+    async issueCertificate(commonName) {
+        await this.login();
+        const pkiPath = this.options.pkiPath || 'pki/issue/config-service';
+        try {
+            const response = await this.http.post(pkiPath, {
+                common_name: commonName,
+            });
+            const { ca_chain, certificate, private_key } = response.data.data;
+            return {
+                ca: ca_chain[0] || '',
+                certificate: certificate,
+                privateKey: private_key,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to issue certificate for ${commonName}: ${error.message}`);
+            throw new Error(`Failed to issue certificate: ${error.message}`);
+        }
+    }
+}
+exports.VaultClient = VaultClient;

package/dist/config.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { ConfigOptions } from './config-client';
+export declare class ConfigModule {
+    static forRoot(options: ConfigOptions): DynamicModule;
+}

package/dist/config.module.js

@@ -0,0 +1,75 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_client_1 = require("./config-client");
+const constants_1 = require("./constants");
+let ConfigModule = (() => {
+    let _classDecorators = [(0, common_1.Global)(), (0, common_1.Module)({})];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ConfigModule = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ConfigModule = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        static forRoot(options) {
+            const optionsProvider = {
+                provide: constants_1.CONFIG_OPTIONS,
+                useValue: options,
+            };
+            const configClientProvider = {
+                provide: config_client_1.ConfigClient,
+                useFactory: async () => {
+                    return await config_client_1.ConfigClient.initialize(options);
+                },
+            };
+            return {
+                module: ConfigModule,
+                providers: [optionsProvider, configClientProvider],
+                exports: [configClientProvider, optionsProvider],
+            };
+        }
+    };
+    return ConfigModule = _classThis;
+})();
+exports.ConfigModule = ConfigModule;

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const CONFIG_OPTIONS = "CONFIG_OPTIONS";

package/dist/constants/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_OPTIONS = void 0;
+exports.CONFIG_OPTIONS = 'CONFIG_OPTIONS';

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const CONFIG_OPTIONS = "CONFIG_OPTIONS";

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_OPTIONS = void 0;
+exports.CONFIG_OPTIONS = 'CONFIG_OPTIONS';

package/dist/enums/env.enum.d.ts

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

package/dist/enums/env.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+var Environment;
+(function (Environment) {
+    Environment["DEVELOPMENT"] = "development";
+    Environment["STAGING"] = "staging";
+    Environment["PRODUCTION"] = "production";
+    Environment["TEST"] = "test";
+    Environment["LOCAL"] = "local";
+})(Environment || (exports.Environment = Environment = {}));

package/dist/generated/config.d.ts

@@ -0,0 +1,116 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+export interface GetConfigRequest {
+    serviceName: string;
+    environment: string;
+    version: string;
+}
+export interface ConfigResponse {
+    values: {
+        [key: string]: string;
+    };
+}
+export interface ConfigResponse_ValuesEntry {
+    key: string;
+    value: string;
+}
+export interface SetConfigRequest {
+    serviceName: string;
+    environment: string;
+    key: string;
+    value: string;
+}
+export interface ListConfigsRequest {
+    environment: string;
+}
+export interface ServiceConfig {
+    serviceName: string;
+    values: {
+        [key: string]: string;
+    };
+}
+export interface ServiceConfig_ValuesEntry {
+    key: string;
+    value: string;
+}
+export interface ListConfigsResponse {
+    configs: ServiceConfig[];
+}
+export declare const GetConfigRequest: MessageFns<GetConfigRequest>;
+export declare const ConfigResponse: MessageFns<ConfigResponse>;
+export declare const ConfigResponse_ValuesEntry: MessageFns<ConfigResponse_ValuesEntry>;
+export declare const SetConfigRequest: MessageFns<SetConfigRequest>;
+export declare const ListConfigsRequest: MessageFns<ListConfigsRequest>;
+export declare const ServiceConfig: MessageFns<ServiceConfig>;
+export declare const ServiceConfig_ValuesEntry: MessageFns<ServiceConfig_ValuesEntry>;
+export declare const ListConfigsResponse: MessageFns<ListConfigsResponse>;
+export type ConfigServiceService = typeof ConfigServiceService;
+export declare const ConfigServiceService: {
+    readonly getConfig: {
+        readonly path: "/config.ConfigService/GetConfig";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetConfigRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetConfigRequest;
+        readonly responseSerialize: (value: ConfigResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ConfigResponse;
+    };
+    readonly setConfig: {
+        readonly path: "/config.ConfigService/SetConfig";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SetConfigRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SetConfigRequest;
+        readonly responseSerialize: (value: ConfigResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ConfigResponse;
+    };
+    readonly listConfigs: {
+        readonly path: "/config.ConfigService/ListConfigs";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListConfigsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListConfigsRequest;
+        readonly responseSerialize: (value: ListConfigsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ListConfigsResponse;
+    };
+};
+export interface ConfigServiceServer extends UntypedServiceImplementation {
+    getConfig: handleUnaryCall<GetConfigRequest, ConfigResponse>;
+    setConfig: handleUnaryCall<SetConfigRequest, ConfigResponse>;
+    listConfigs: handleUnaryCall<ListConfigsRequest, ListConfigsResponse>;
+}
+export interface ConfigServiceClient extends Client {
+    getConfig(request: GetConfigRequest, callback: (error: ServiceError | null, response: ConfigResponse) => void): ClientUnaryCall;
+    getConfig(request: GetConfigRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ConfigResponse) => void): ClientUnaryCall;
+    getConfig(request: GetConfigRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ConfigResponse) => void): ClientUnaryCall;
+    setConfig(request: SetConfigRequest, callback: (error: ServiceError | null, response: ConfigResponse) => void): ClientUnaryCall;
+    setConfig(request: SetConfigRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ConfigResponse) => void): ClientUnaryCall;
+    setConfig(request: SetConfigRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ConfigResponse) => void): ClientUnaryCall;
+    listConfigs(request: ListConfigsRequest, callback: (error: ServiceError | null, response: ListConfigsResponse) => void): ClientUnaryCall;
+    listConfigs(request: ListConfigsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ListConfigsResponse) => void): ClientUnaryCall;
+    listConfigs(request: ListConfigsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ListConfigsResponse) => void): ClientUnaryCall;
+}
+export declare const ConfigServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): ConfigServiceClient;
+    service: typeof ConfigServiceService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};