@yobytechautomation/config-lib 0.1.3

package/dist/abstract-config.service.d.ts

@@ -0,0 +1,54 @@
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import type { BaseConfigService } from './base-config.service';
+import type { ProcessEnv } from './types';
+export declare abstract class AbstractConfigService implements BaseConfigService {
+    protected readonly env: ProcessEnv;
+    constructor();
+    getDatabaseConfig(): TypeOrmModuleOptions;
+    abstract getPort(): number;
+    abstract getMode(): string;
+    /**
+     * Per-service hooks for DB config
+     */
+    protected abstract getDatabaseEntities(): any[];
+    protected getDatabaseMigrations(): string[];
+    protected getDatabaseSynchronize(): boolean;
+    protected getDatabaseLogging(): boolean;
+    getConsulConfig(): {
+        host: string;
+        port: number;
+        secure: boolean;
+        serviceName: string;
+        serviceHost: string;
+        servicePort: number;
+    };
+    getRedisConfig(): {
+        host: string;
+        port: number;
+        password: string | undefined;
+        username: string | undefined;
+        db: number;
+    };
+    getJWTConfig(): {
+        accessTokenSecret: string;
+        accessTokenExpIn: number;
+        refreshTokenSecret: string;
+        refreshTokenExpIn: number;
+    };
+    getJUtilConfig(): {
+        accessLogMaxAgeDays: number;
+        accessLogMaxSizeMb: number;
+        authServiceUrl: string;
+    };
+    getMailConfig(): {
+        mailPort: number;
+        mailSecure: string;
+        mailHost: string;
+        mailUser: string;
+        mailPass: string;
+        mailFrom: string;
+        mailDir: string;
+        mailOrigin: string;
+    };
+    getKAFKAConfig(): any;
+}

package/dist/abstract-config.service.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractConfigService = void 0;
+const env_utils_1 = require("./env-utils");
+class AbstractConfigService {
+    constructor() {
+        this.env = (0, env_utils_1.loadEnv)();
+    }
+    getDatabaseConfig() {
+        const sslEnabled = (0, env_utils_1.getEnvValue)(this.env, 'POSTGRES_SSL_ENABLED', false) === 'true';
+        return {
+            type: 'postgres',
+            host: (0, env_utils_1.getEnvValue)(this.env, 'POSTGRES_HOST'),
+            port: parseInt((0, env_utils_1.getEnvValue)(this.env, 'POSTGRES_PORT', false) || '5432', 10),
+            username: (0, env_utils_1.getEnvValue)(this.env, 'POSTGRES_USER'),
+            password: (0, env_utils_1.getEnvValue)(this.env, 'POSTGRES_PASSWORD'),
+            database: (0, env_utils_1.getEnvValue)(this.env, 'POSTGRES_DATABASE'),
+            entities: this.getDatabaseEntities(),
+            migrations: this.getDatabaseMigrations(),
+            synchronize: this.getDatabaseSynchronize(),
+            logging: this.getDatabaseLogging(),
+            ssl: sslEnabled ? { rejectUnauthorized: false } : undefined,
+        };
+    }
+    getDatabaseMigrations() {
+        return [__dirname + '/../migration/*{.ts,.js}'];
+    }
+    getDatabaseSynchronize() {
+        return false;
+    }
+    getDatabaseLogging() {
+        return true;
+    }
+    getConsulConfig() {
+        return {
+            host: (0, env_utils_1.getEnvValue)(this.env, 'CONSUL_HOST', false) || '127.0.0.1',
+            port: parseInt((0, env_utils_1.getEnvValue)(this.env, 'CONSUL_PORT', false) || '8500', 10),
+            secure: (0, env_utils_1.getEnvValue)(this.env, 'CONSUL_SECURE', false) === 'true',
+            serviceName: (0, env_utils_1.getEnvValue)(this.env, 'SERVICE_NAME', false) || 'sdc-user-service',
+            serviceHost: (0, env_utils_1.getEnvValue)(this.env, 'SERVICE_HOST', false) || '127.0.0.1',
+            servicePort: parseInt((0, env_utils_1.getEnvValue)(this.env, 'SERVICE_PORT', false) || '3000', 10),
+        };
+    }
+    getRedisConfig() {
+        return {
+            host: (0, env_utils_1.getEnvValue)(this.env, 'REDIS_HOST', false) || 'localhost',
+            port: parseInt((0, env_utils_1.getEnvValue)(this.env, 'REDIS_PORT') || '6379', 10),
+            password: (0, env_utils_1.getEnvValue)(this.env, 'REDIS_PASSWORD', false) || undefined,
+            username: (0, env_utils_1.getEnvValue)(this.env, 'REDIS_USERNAME', false) || undefined,
+            db: parseInt((0, env_utils_1.getEnvValue)(this.env, 'REDIS_DB', false) || '0'),
+        };
+    }
+    getJWTConfig() {
+        return {
+            accessTokenSecret: (0, env_utils_1.getEnvValue)(this.env, 'JWT_ACCESS_TOKEN_SECRET', false) || '',
+            accessTokenExpIn: parseInt((0, env_utils_1.getEnvValue)(this.env, 'JWT_ACCESS_TOKEN_EXP', false) || '3600', 10),
+            refreshTokenSecret: (0, env_utils_1.getEnvValue)(this.env, 'JWT_REFRESH_TOKEN_SECRET', false) || '',
+            refreshTokenExpIn: parseInt((0, env_utils_1.getEnvValue)(this.env, 'JWT_REFRESH_TOKEN_EXP', false) || '86400', 10),
+        };
+    }
+    getJUtilConfig() {
+        return {
+            accessLogMaxAgeDays: parseInt((0, env_utils_1.getEnvValue)(this.env, 'ACCESS_LOG_MAX_AGE_DAYS', false) || '7', 10),
+            accessLogMaxSizeMb: parseInt((0, env_utils_1.getEnvValue)(this.env, 'ACCESS_LOG_MAX_SIZE_MB', false) || '10', 10),
+            authServiceUrl: (0, env_utils_1.getEnvValue)(this.env, 'AUTH_SERVICE_URL', false) ||
+                'http://localhost:3000',
+        };
+    }
+    getMailConfig() {
+        return {
+            mailPort: parseInt((0, env_utils_1.getEnvValue)(this.env, 'MAIL_PORT', false) || '0', 10),
+            mailSecure: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_SECURE', false) || '',
+            mailHost: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_HOST', false) || '',
+            mailUser: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_USER', false) || '',
+            mailPass: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_PASS', false) || '',
+            mailFrom: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_FROM', false) || '',
+            mailDir: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_DIR', false) || '',
+            mailOrigin: (0, env_utils_1.getEnvValue)(this.env, 'MAIL_ORIGIN', false) || '',
+        };
+    }
+    getKAFKAConfig() {
+        const config = {
+            brokers: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_BROKERS', false)
+                ? (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_BROKERS', false)
+                    .split(',')
+                    .map((b) => b.trim())
+                : ['202.137.208.36:9095'],
+            clientId: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_CLIENT_ID', false) || 'sdc-dev-client',
+            groupId: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_GROUP_ID', false) || 'sdc-dev-group',
+            topicName: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_TOPIC_NAME', false) || 'sdc-dev-topic',
+        };
+        const sslEnabled = (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SSL_ENABLED', false) === 'true';
+        if (sslEnabled) {
+            const fs = require('fs');
+            config.ssl = {
+                rejectUnauthorized: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SSL_REJECT_UNAUTHORIZED', false) !==
+                    'false',
+            };
+            const caPath = (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SSL_CA_PATH', false);
+            if (caPath) {
+                config.ssl.ca = fs.readFileSync(caPath, 'utf8');
+            }
+            const certPath = (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SSL_CERT_PATH', false);
+            if (certPath) {
+                config.ssl.cert = fs.readFileSync(certPath, 'utf8');
+            }
+            const keyPath = (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SSL_KEY_PATH', false);
+            if (keyPath) {
+                config.ssl.key = fs.readFileSync(keyPath, 'utf8');
+            }
+        }
+        const saslEnabled = (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SASL_ENABLED', false) === 'true';
+        if (saslEnabled) {
+            config.sasl = {
+                mechanism: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SASL_MECHANISM', false) || 'plain',
+                username: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SASL_USERNAME', false) || '',
+                password: (0, env_utils_1.getEnvValue)(this.env, 'KAFKA_SASL_PASSWORD', false) || '',
+            };
+        }
+        return config;
+    }
+}
+exports.AbstractConfigService = AbstractConfigService;

package/dist/base-config.service.d.ts

@@ -0,0 +1,60 @@
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+export interface BaseConfigService {
+    getDatabaseConfig(): TypeOrmModuleOptions;
+    getPort(): number;
+    getMode(): string;
+    getConsulConfig(): {
+        host: string;
+        port: number;
+        secure: boolean;
+        serviceName: string;
+        serviceHost: string;
+        servicePort: number;
+    };
+    getRedisConfig(): {
+        host: string;
+        port: number;
+        password?: string;
+        username?: string;
+        db?: number;
+    };
+    getJWTConfig(): {
+        accessTokenSecret: string;
+        accessTokenExpIn: number;
+        refreshTokenSecret: string;
+        refreshTokenExpIn: number;
+    };
+    getJUtilConfig(): {
+        accessLogMaxAgeDays: number;
+        accessLogMaxSizeMb: number;
+        authServiceUrl: string;
+    };
+    getMailConfig(): {
+        mailPort: number;
+        mailSecure: string;
+        mailHost: string;
+        mailUser: string;
+        mailPass: string;
+        mailFrom: string;
+        mailDir: string;
+        mailOrigin: string;
+    };
+    getKAFKAConfig(): {
+        clientId: string;
+        brokers: string[];
+        groupId: string;
+        topicName: string;
+        ssl?: {
+            rejectUnauthorized: boolean;
+            ca?: string;
+            cert?: string;
+            key?: string;
+        };
+        sasl?: {
+            mechanism: string;
+            username: string;
+            password: string;
+        };
+    };
+}
+export declare const BASE_CONFIG_SERVICE: unique symbol;

package/dist/base-config.service.js

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

package/dist/env-utils.d.ts

@@ -0,0 +1,9 @@
+import type { ProcessEnv } from './types';
+export type Mode = 'local' | 'dev' | 'uat' | 'prod' | string;
+export declare function resolveMode(defaultMode?: Mode): Mode;
+export declare function loadEnv(mode?: Mode): ProcessEnv;
+export declare function getEnvValue(env: ProcessEnv, key: string, throwOnMissing?: boolean): string;
+export declare function getPostgresSSLConfig(env: ProcessEnv, sslEnabledKey?: string): {
+    ca: string;
+    rejectUnauthorized: boolean;
+} | undefined;

package/dist/env-utils.js

@@ -0,0 +1,70 @@
+"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.resolveMode = resolveMode;
+exports.loadEnv = loadEnv;
+exports.getEnvValue = getEnvValue;
+exports.getPostgresSSLConfig = getPostgresSSLConfig;
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+function resolveMode(defaultMode = 'dev') {
+    const mode = process.env.MODE || process.env.NODE_ENV || defaultMode;
+    return mode.toLowerCase();
+}
+function loadEnv(mode = resolveMode()) {
+    const envFile = path.resolve(process.cwd(), `.env.${mode.toLowerCase()}`);
+    dotenv.config({ path: envFile });
+    return process.env;
+}
+function getEnvValue(env, key, throwOnMissing = true) {
+    const value = env[key];
+    if (!value && throwOnMissing) {
+        throw new Error(`Missing env var: ${key}`);
+    }
+    return value !== null && value !== void 0 ? value : '';
+}
+function getPostgresSSLConfig(env, sslEnabledKey = 'POSTGRES_SSL_ENABLED') {
+    var _a;
+    const sslEnabled = ((_a = getEnvValue(env, sslEnabledKey, false)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'true';
+    return sslEnabled
+        ? {
+            ca: fs
+                .readFileSync(getEnvValue(env, 'POSTGRES_SSL_CA_PATH'))
+                .toString(),
+            rejectUnauthorized: true,
+        }
+        : undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './env-utils';
+export * from './base-config.service';
+export * from './abstract-config.service';
+export * from './nest-config-provider';

package/dist/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("./env-utils"), exports);
+__exportStar(require("./base-config.service"), exports);
+__exportStar(require("./abstract-config.service"), exports);
+__exportStar(require("./nest-config-provider"), exports);

package/dist/nest-config-provider.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from '@nestjs/common';
+import { BaseConfigService } from './base-config.service';
+import { Mode } from './env-utils';
+export type ConfigServiceFactory<T extends BaseConfigService> = () => T;
+export interface ConfigProviderOptions<T extends BaseConfigService> {
+    modeFactories: Partial<Record<Mode, ConfigServiceFactory<T>>> & {
+        local?: ConfigServiceFactory<T>;
+        dev?: ConfigServiceFactory<T>;
+        uat?: ConfigServiceFactory<T>;
+        prod?: ConfigServiceFactory<T>;
+    };
+    defaultMode?: Mode;
+}
+export declare function createBaseConfigProvider<T extends BaseConfigService>(options: ConfigProviderOptions<T>): Provider<T>;

package/dist/nest-config-provider.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBaseConfigProvider = createBaseConfigProvider;
+const base_config_service_1 = require("./base-config.service");
+const env_utils_1 = require("./env-utils");
+function createBaseConfigProvider(options) {
+    const mode = (0, env_utils_1.resolveMode)(options.defaultMode);
+    return {
+        provide: base_config_service_1.BASE_CONFIG_SERVICE,
+        useFactory: () => {
+            var _a, _b;
+            const factory = (_b = (_a = options.modeFactories[mode]) !== null && _a !== void 0 ? _a : options.modeFactories[mode.toLowerCase()]) !== null && _b !== void 0 ? _b : options.modeFactories[(0, env_utils_1.resolveMode)(options.defaultMode)];
+            if (!factory) {
+                throw new Error(`No BaseConfigService factory configured for mode: ${mode}`);
+            }
+            return factory();
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1 @@
+export type ProcessEnv = Record<string, string | undefined>;

package/dist/types.js

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

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@yobytechautomation/config-lib",
+  "version": "0.1.3",
+  "description": "Shared multi-environment configuration helpers for SDC NestJS services",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "license": "MIT",
+  "keywords": [
+    "nest",
+    "nestjs",
+    "config",
+    "env",
+    "sdc"
+  ],
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0 || ^10.0.0 || ^9.0.0",
+    "@nestjs/typeorm": "^11.0.0 || ^10.0.0 || ^9.0.0",
+    "dotenv": "^16.0.0",
+    "typeorm": "^0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "rimraf": "^6.0.0",
+    "typescript": "^5.0.0"
+  }
+}