@zintrust/core 2.4.1 → 2.4.2

package/src/microservices/ServiceAuthMiddleware.js

@@ -0,0 +1,248 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import * as crypto from '../node-singletons/crypto.js';
+/**
+ * API Key Authentication
+ */
+export const ApiKeyAuth = Object.freeze({
+    /**
+     * Create a new API key auth instance
+     */
+    create(apiKey) {
+        const generateSecureApiKeyDefault = () => {
+            return crypto.randomBytes(32).toString('hex');
+        };
+        const getApiKey = () => {
+            const envKey = Env.get('SERVICE_API_KEY');
+            const secureDefault = generateSecureApiKeyDefault();
+            if (envKey === undefined || envKey === secureDefault) {
+                Logger.warn('⚠️  WARNING: Using generated default API key. Set SERVICE_API_KEY environment variable in production!');
+                return secureDefault;
+            }
+            return envKey;
+        };
+        const key = apiKey ?? getApiKey();
+        return {
+            verify(token) {
+                return token === key;
+            },
+            generate() {
+                return crypto.randomBytes(32).toString('hex');
+            },
+        };
+    },
+});
+/**
+ * JWT Authentication
+ */
+export const JwtAuth = Object.freeze({
+    /**
+     * Create a new JWT auth instance
+     */
+    create(secret) {
+        const generateSecureJwtDefault = () => {
+            return crypto.randomBytes(32).toString('hex');
+        };
+        const getJwtSecret = () => {
+            const envSecret = Env.get('SERVICE_JWT_SECRET');
+            const secureDefault = generateSecureJwtDefault();
+            if (envSecret === undefined || envSecret === secureDefault) {
+                Logger.warn('⚠️  WARNING: Using generated default JWT secret. Set SERVICE_JWT_SECRET environment variable in production!');
+                return secureDefault;
+            }
+            return envSecret;
+        };
+        const jwtSecret = secret ?? getJwtSecret();
+        return {
+            sign(payload, _expiresIn = '1h') {
+                // Simplified JWT (in production, use jsonwebtoken library)
+                const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64');
+                const body = Buffer.from(JSON.stringify({ ...payload, iat: Date.now() })).toString('base64');
+                const signature = crypto
+                    .createHmac('sha256', jwtSecret)
+                    .update(`${header}.${body}`)
+                    .digest('base64');
+                return `${header}.${body}.${signature}`;
+            },
+            verify(token) {
+                try {
+                    const parts = token.split('.');
+                    if (parts.length !== 3)
+                        return null;
+                    const [header, body, signature] = parts;
+                    const expectedSignature = crypto
+                        .createHmac('sha256', jwtSecret)
+                        .update(`${header}.${body}`)
+                        .digest('base64');
+                    if (signature !== expectedSignature) {
+                        return null;
+                    }
+                    return JSON.parse(Buffer.from(body, 'base64').toString());
+                }
+                catch (error) {
+                    Logger.error('JWT verification failed', error);
+                    return null;
+                }
+            },
+        };
+    },
+});
+/**
+ * Custom Authentication (developer-defined)
+ */
+export const CustomAuth = Object.freeze({
+    /**
+     * Create a new custom auth instance
+     */
+    create(validator) {
+        return {
+            verify(token) {
+                return validator(token);
+            },
+        };
+    },
+});
+/**
+ * Create initial authentication context
+ */
+const createAuthContext = (strategy) => {
+    return {
+        isServiceCall: false,
+        strategy,
+        authenticated: strategy === 'none',
+    };
+};
+/**
+ * Attach context to request and proceed to next middleware
+ */
+const attachContextAndNext = (req, context, next) => {
+    req.context ??= {};
+    req.context['serviceAuth'] = context;
+    return next();
+};
+/**
+ * Finalize successful service authentication
+ */
+const finalizeServiceAuth = (req, context, next) => {
+    context.authenticated = true;
+    context.isServiceCall = true;
+    return attachContextAndNext(req, context, next);
+};
+/**
+ * Parse authorization header
+ */
+const parseAuthHeader = (req) => {
+    const authHeader = req.getHeader('authorization');
+    if (authHeader === undefined || typeof authHeader !== 'string') {
+        return null;
+    }
+    const parts = authHeader.split(' ');
+    if (parts.length !== 2) {
+        return null;
+    }
+    const scheme = parts[0];
+    const token = parts[1];
+    if (!scheme || !token) {
+        return null;
+    }
+    return { scheme, token };
+};
+/**
+ * Verify API Key strategy
+ */
+const verifyApiKeyStrategy = (apiKeyAuth, scheme, token) => {
+    if (scheme !== 'Bearer' || apiKeyAuth.verify(token) === false) {
+        return { authenticated: false, status: 403, error: 'Invalid API key' };
+    }
+    return { authenticated: true };
+};
+/**
+ * Verify JWT strategy
+ */
+const verifyJwtStrategy = (jwtAuth, scheme, token, context) => {
+    if (scheme !== 'Bearer') {
+        return {
+            authenticated: false,
+            status: 401,
+            error: 'Invalid authorization scheme',
+        };
+    }
+    const payload = jwtAuth.verify(token);
+    if (payload === null) {
+        return { authenticated: false, status: 403, error: 'Invalid JWT token' };
+    }
+    const serviceName = payload['serviceName'];
+    context.serviceName = typeof serviceName === 'string' ? serviceName : '';
+    return { authenticated: true };
+};
+/**
+ * Verify Custom strategy
+ */
+const verifyCustomStrategy = (customValidator, token) => {
+    if (customValidator === null || customValidator(token) === false) {
+        return { authenticated: false, status: 403, error: 'Authentication failed' };
+    }
+    return { authenticated: true };
+};
+/**
+ * Verify authentication strategy
+ */
+const verifyStrategy = (strategy, auth, context, deps) => {
+    switch (strategy) {
+        case 'api-key':
+            return verifyApiKeyStrategy(deps.apiKeyAuth, auth.scheme, auth.token);
+        case 'jwt':
+            return verifyJwtStrategy(deps.jwtAuth, auth.scheme, auth.token, context);
+        case 'custom':
+            return verifyCustomStrategy(deps.customValidator, auth.token);
+        default:
+            return { authenticated: false, status: 401, error: 'Unsupported strategy' };
+    }
+};
+const createServiceAuthMiddleware = () => {
+    let defaultApiKeyAuth = null;
+    let defaultJwtAuth = null;
+    let customValidator = null;
+    const getApiKeyAuth = () => {
+        defaultApiKeyAuth ??= ApiKeyAuth.create();
+        return defaultApiKeyAuth;
+    };
+    const getJwtAuth = () => {
+        defaultJwtAuth ??= JwtAuth.create();
+        return defaultJwtAuth;
+    };
+    return {
+        /**
+         * Register custom auth validator
+         */
+        registerCustomAuth(validator) {
+            customValidator = validator;
+        },
+        /**
+         * Middleware to authenticate service-to-service calls
+         */
+        middleware(strategy) {
+            return async (req, res, next) => {
+                const context = createAuthContext(strategy);
+                if (strategy === 'none') {
+                    return attachContextAndNext(req, context, next);
+                }
+                const auth = parseAuthHeader(req);
+                if (auth === null) {
+                    return res.setStatus(401).json({ error: 'Missing or invalid authorization header' });
+                }
+                const result = verifyStrategy(strategy, auth, context, {
+                    apiKeyAuth: getApiKeyAuth(),
+                    jwtAuth: getJwtAuth(),
+                    customValidator,
+                });
+                if (!result.authenticated) {
+                    return res.setStatus(result.status ?? 401).json({ error: result.error });
+                }
+                return finalizeServiceAuth(req, context, next);
+            };
+        },
+    };
+};
+export const ServiceAuthMiddleware = Object.freeze(createServiceAuthMiddleware());
+export default ServiceAuthMiddleware;

package/src/microservices/ServiceBundler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Service Bundler - Creates optimized, independent microservice packages
+ * Target: Each service < 1MB for serverless deployment
+ */
+export interface BundleConfig {
+    serviceName: string;
+    domain: string;
+    outputDir: string;
+    targetSize?: number;
+    includeTests?: boolean;
+    includeDocs?: boolean;
+}
+export interface BundleResult {
+    serviceName: string;
+    sizeBytes: number;
+    sizeMB: number;
+    files: number;
+    location: string;
+    optimized: boolean;
+}
+export interface IServiceBundler {
+    bundleService(config: BundleConfig): Promise<BundleResult>;
+    bundleAll(domain: string, services: string[], outputDir?: string): Promise<BundleResult[]>;
+    createServiceImage(serviceName: string, domain: string, registry?: string): Promise<string>;
+}
+export interface IServiceBundlerManager {
+    getInstance(): IServiceBundler;
+    bundleService(config: BundleConfig): Promise<BundleResult>;
+    bundleAll(domain: string, services: string[], outputDir?: string): Promise<BundleResult[]>;
+    createServiceImage(serviceName: string, domain: string, registry?: string): Promise<string>;
+    create(): IServiceBundler;
+}
+/**
+ * Service bundler for independent deployment
+ */
+export declare const ServiceBundler: IServiceBundlerManager;
+/**
+ * CLI command to bundle services
+ */
+export declare function bundleServices(domain: string, services: string): Promise<void>;
+export declare const bundleService: (config: BundleConfig) => Promise<BundleResult>;
+export declare const bundleAll: (domain: string, services: string[], outputDir?: string) => Promise<BundleResult[]>;
+export declare const createServiceImage: (serviceName: string, domain: string, registry?: string) => Promise<string>;
+export default ServiceBundler;
+//# sourceMappingURL=ServiceBundler.d.ts.map

package/src/microservices/ServiceBundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceBundler.d.ts","sourceRoot":"","sources":["../../../src/microservices/ServiceBundler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC3F,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7F;AAED,MAAM,WAAW,sBAAsB;IACrC,WAAW,IAAI,eAAe,CAAC;IAC/B,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC3F,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5F,MAAM,IAAI,eAAe,CAAC;CAC3B;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,wBAiEvB,CAAC;AAmSL;;GAEG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAcpF;AAED,eAAO,MAAM,aAAa,GAAU,QAAQ,YAAY,KAAG,OAAO,CAAC,YAAY,CAC3B,CAAC;AACrD,eAAO,MAAM,SAAS,GACpB,QAAQ,MAAM,EACd,UAAU,MAAM,EAAE,EAClB,YAAY,MAAM,KACjB,OAAO,CAAC,YAAY,EAAE,CAAwE,CAAC;AAClG,eAAO,MAAM,kBAAkB,GAC7B,aAAa,MAAM,EACnB,QAAQ,MAAM,EACd,WAAW,MAAM,KAChB,OAAO,CAAC,MAAM,CAC+D,CAAC;AAEjF,eAAe,cAAc,CAAC"}

package/src/microservices/ServiceBundler.js

@@ -0,0 +1,299 @@
+/**
+ * Service Bundler - Creates optimized, independent microservice packages
+ * Target: Each service < 1MB for serverless deployment
+ */
+import { Logger } from '../config/logger.js';
+import fs from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+/**
+ * Service bundler for independent deployment
+ */
+export const ServiceBundler = Object.freeze(() => {
+    let instance;
+    return {
+        getInstance() {
+            instance ??= this.create();
+            return instance;
+        },
+        async bundleService(config) {
+            return this.getInstance().bundleService(config);
+        },
+        async bundleAll(domain, services, outputDir) {
+            return this.getInstance().bundleAll(domain, services, outputDir);
+        },
+        async createServiceImage(serviceName, domain, registry) {
+            return this.getInstance().createServiceImage(serviceName, domain, registry);
+        },
+        /**
+         * Create a new service bundler instance
+         */
+        create() {
+            return {
+                /**
+                 * Bundle a single microservice
+                 */
+                async bundleService(config) {
+                    return runBundleService(config);
+                },
+                /**
+                 * Bundle multiple services
+                 */
+                async bundleAll(domain, services, outputDir = 'dist/services') {
+                    return runBundleAll(domain, services, outputDir, async (c) => this.bundleService(c));
+                },
+                /**
+                 * Create Docker image for service
+                 */
+                async createServiceImage(serviceName, domain, registry = 'localhost:5000') {
+                    return runCreateServiceImage(serviceName, domain, registry);
+                },
+            };
+        },
+    };
+})();
+/**
+ * Run bundle for a single service
+ */
+// eslint-disable-next-line @typescript-eslint/require-await
+async function runBundleService(config) {
+    const { serviceName, domain, outputDir, targetSize = 1 } = config;
+    Logger.info(`\n📦 Bundling service: ${serviceName}`);
+    const serviceDir = `services/${domain}/${serviceName}`;
+    const bundleDir = path.join(outputDir, `${domain}-${serviceName}`);
+    prepareBundleDirectory(bundleDir);
+    const { totalSize, fileCount } = copyServiceFiles(serviceDir, bundleDir);
+    const metadata = generateBundleMetadata(serviceName, domain, totalSize, fileCount, targetSize);
+    fs.writeFileSync(path.join(bundleDir, 'bundle.json'), JSON.stringify(metadata, null, 2));
+    logBundleSummary(totalSize, fileCount, targetSize);
+    return {
+        serviceName,
+        sizeBytes: totalSize,
+        sizeMB: Number.parseFloat((totalSize / (1024 * 1024)).toFixed(2)),
+        files: fileCount,
+        location: bundleDir,
+        optimized: totalSize < targetSize * 1024 * 1024,
+    };
+}
+/**
+ * Run bundle for all services
+ */
+async function runBundleAll(domain, services, outputDir, bundleServiceFn) {
+    Logger.info(`\n📦 Bundling ${services.length} services for domain: ${domain}`);
+    const promises = services.map(async (service) => {
+        try {
+            return await bundleServiceFn({
+                serviceName: service,
+                domain,
+                outputDir,
+            });
+        }
+        catch (error) {
+            Logger.error(`Failed to bundle ${service}:`, error);
+            return null;
+        }
+    });
+    const allResults = await Promise.all(promises);
+    const results = allResults.filter((r) => r !== null);
+    // Print summary
+    printBundleSummary(results);
+    return results;
+}
+/**
+ * Run create service image
+ */
+// eslint-disable-next-line @typescript-eslint/require-await
+async function runCreateServiceImage(serviceName, domain, registry) {
+    const serviceDir = `services/${domain}/${serviceName}`;
+    const imageTag = `${registry}/${domain}-${serviceName}:latest`;
+    Logger.info(`\n🐳 Creating Docker image: ${imageTag}`);
+    // Generate minimal Dockerfile
+    const dockerfile = generateDockerfile(serviceName);
+    fs.writeFileSync(path.join(serviceDir, 'Dockerfile'), dockerfile);
+    Logger.info(`  ✓ Dockerfile created at ${serviceDir}/Dockerfile`);
+    Logger.info(`  To build: docker build -t ${imageTag} ${serviceDir}`);
+    return imageTag;
+}
+/**
+ * Copy directory recursively
+ */
+function copyDirectory(src, dest) {
+    if (fs.existsSync(dest) === false) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const files = fs.readdirSync(src);
+    for (const file of files) {
+        const srcPath = path.join(src, file);
+        const destPath = path.join(dest, file);
+        const stats = fs.statSync(srcPath);
+        if (stats.isDirectory() === true) {
+            copyDirectory(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Get directory size
+ */
+function getDirectorySize(dir) {
+    if (fs.existsSync(dir) === false)
+        return 0;
+    let size = 0;
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stats = fs.statSync(filePath);
+        if (stats.isDirectory() === true) {
+            size += getDirectorySize(filePath);
+        }
+        else {
+            size += stats.size;
+        }
+    }
+    return size;
+}
+/**
+ * Count files in directory
+ */
+function countFiles(dir) {
+    if (fs.existsSync(dir) === false)
+        return 0;
+    let count = 0;
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stats = fs.statSync(filePath);
+        if (stats.isDirectory() === true) {
+            count += countFiles(filePath);
+        }
+        else {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Prepare bundle directory
+ */
+function prepareBundleDirectory(bundleDir) {
+    if (fs.existsSync(bundleDir) === true) {
+        fs.rmSync(bundleDir, { recursive: true });
+    }
+    fs.mkdirSync(bundleDir, { recursive: true });
+}
+/**
+ * Copy service files to bundle directory
+ */
+function copyServiceFiles(serviceDir, bundleDir) {
+    const filesToCopy = [
+        { src: `${serviceDir}/dist`, dest: `${bundleDir}/dist` },
+        { src: `${serviceDir}/package.json`, dest: `${bundleDir}/package.json` },
+        {
+            src: `${serviceDir}/service.config.json`,
+            dest: `${bundleDir}/service.config.json`,
+        },
+        { src: `${serviceDir}/.env.example`, dest: `${bundleDir}/.env.example` },
+    ];
+    let totalSize = 0;
+    let fileCount = 0;
+    for (const { src, dest } of filesToCopy) {
+        if (fs.existsSync(src) === true) {
+            const stats = fs.statSync(src);
+            if (stats.isDirectory() === true) {
+                copyDirectory(src, dest);
+                totalSize += getDirectorySize(dest);
+                fileCount += countFiles(dest);
+            }
+            else {
+                fs.copyFileSync(src, dest);
+                totalSize += stats.size;
+                fileCount++;
+            }
+        }
+    }
+    return { totalSize, fileCount };
+}
+/**
+ * Generate bundle metadata
+ */
+function generateBundleMetadata(serviceName, domain, totalSize, fileCount, targetSize) {
+    return {
+        service: serviceName,
+        domain,
+        timestamp: new Date().toISOString(),
+        sizeBytes: totalSize,
+        files: fileCount,
+        optimized: totalSize < targetSize * 1024 * 1024,
+    };
+}
+/**
+ * Log bundle summary
+ */
+function logBundleSummary(totalSize, fileCount, targetSize) {
+    const sizeMB = (totalSize / (1024 * 1024)).toFixed(2);
+    Logger.info(`  ✓ Size: ${sizeMB} MB (${fileCount} files)`);
+    if (totalSize > targetSize * 1024 * 1024) {
+        Logger.warn(`  ⚠️  Bundle exceeds ${targetSize} MB target - consider optimizing`);
+    }
+}
+/**
+ * Print bundle summary
+ */
+function printBundleSummary(results) {
+    Logger.info('\n📊 Bundle Summary');
+    Logger.info('━'.repeat(60));
+    let totalSize = 0;
+    let totalFiles = 0;
+    for (const result of results) {
+        const status = result.optimized === true ? '✅' : '⚠️ ';
+        Logger.info(`${status} ${result.serviceName.padEnd(20)} ${result.sizeMB.toFixed(2)} MB (${result.files} files)`);
+        totalSize += result.sizeBytes;
+        totalFiles += result.files;
+    }
+    Logger.info('━'.repeat(60));
+    const totalMB = (totalSize / (1024 * 1024)).toFixed(2);
+    Logger.info(`Total: ${totalMB} MB across ${totalFiles} files\n`);
+}
+/**
+ * Generate minimal Dockerfile
+ */
+function generateDockerfile(serviceName) {
+    return String.raw `FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package.json ./
+RUN npm install --production --ignore-scripts
+
+COPY dist ./dist
+
+ENV NODE_ENV=production
+ENV SERVICE_NAME=${serviceName}
+
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
+  CMD node -e "require('node:http').get('http://localhost:7777/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"
+
+EXPOSE 3000
+
+CMD ["node", "dist/src/Kernel.js"]
+`;
+}
+/**
+ * CLI command to bundle services
+ */
+export async function bundleServices(domain, services) {
+    const serviceList = services.split(',').map((s) => s.trim());
+    const results = await ServiceBundler.getInstance().bundleAll(domain, serviceList, 'dist/services');
+    const allOptimized = results.every((r) => r.optimized);
+    if (allOptimized) {
+        Logger.info('✅ All services optimized for serverless deployment!');
+    }
+    else {
+        Logger.info('⚠️  Some services exceed 1MB target - consider further optimization');
+    }
+}
+export const bundleService = async (config) => ServiceBundler.getInstance().bundleService(config);
+export const bundleAll = async (domain, services, outputDir) => ServiceBundler.getInstance().bundleAll(domain, services, outputDir);
+export const createServiceImage = async (serviceName, domain, registry) => ServiceBundler.getInstance().createServiceImage(serviceName, domain, registry);
+export default ServiceBundler;

package/src/microservices/ServiceHealthMonitor.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Service Health Check and Monitoring System
+ * Provides per-service and aggregated health status with detailed diagnostics
+ */
+import type { IRequest } from '../http/Request';
+import type { IResponse } from '../http/Response';
+export interface HealthCheckResult {
+    service: string;
+    domain: string;
+    port: number;
+    status: 'healthy' | 'degraded' | 'unhealthy' | 'stopped';
+    timestamp: string;
+    responseTime: number;
+    version: string;
+    checks: {
+        http: boolean;
+        database?: boolean;
+        dependencies?: Record<string, boolean>;
+    };
+    message?: string;
+}
+export interface AggregatedHealthStatus {
+    timestamp: string;
+    totalServices: number;
+    healthy: number;
+    degraded: number;
+    unhealthy: number;
+    services: HealthCheckResult[];
+}
+export interface IHealthCheckHandler {
+    handle(req: IRequest, res: IResponse): Promise<void>;
+}
+/**
+ * Health Check Endpoint Handler
+ * Each service should expose this as GET /health
+ */
+export declare const HealthCheckHandler: Readonly<{
+    /**
+     * Create a new health check handler instance
+     */
+    create(serviceName: string, version: string, port: number, domain: string, dependencies?: string[], checkDatabase?: () => Promise<boolean>): IHealthCheckHandler;
+}>;
+export interface IServiceHealthMonitor {
+    start(): void;
+    stop(): void;
+    checkAll(): Promise<AggregatedHealthStatus>;
+    getLastStatus(): AggregatedHealthStatus;
+    getServiceStatus(serviceName: string): HealthCheckResult | undefined;
+    areAllHealthy(): boolean;
+    isServiceHealthy(serviceName: string): boolean;
+}
+/**
+ * Service Health Monitor
+ * Monitors multiple services and provides aggregated health status
+ */
+export declare const ServiceHealthMonitor: Readonly<{
+    /**
+     * Create a new service health monitor instance
+     */
+    create(healthCheckUrls: Record<string, string>, intervalMs?: number): IServiceHealthMonitor;
+}>;
+export interface IHealthCheckAggregator {
+    handle(req: IRequest, res: IResponse): Promise<void>;
+}
+/**
+ * Health Check Aggregator Endpoint
+ * Exposes aggregated health status at GET /health/services
+ */
+export declare const HealthCheckAggregator: Readonly<{
+    /**
+     * Create a new health check aggregator instance
+     */
+    create(monitor: IServiceHealthMonitor): IHealthCheckAggregator;
+}>;
+declare const _default: {
+    HealthCheckHandler: Readonly<{
+        /**
+         * Create a new health check handler instance
+         */
+        create(serviceName: string, version: string, port: number, domain: string, dependencies?: string[], checkDatabase?: () => Promise<boolean>): IHealthCheckHandler;
+    }>;
+    ServiceHealthMonitor: Readonly<{
+        /**
+         * Create a new service health monitor instance
+         */
+        create(healthCheckUrls: Record<string, string>, intervalMs?: number): IServiceHealthMonitor;
+    }>;
+    HealthCheckAggregator: Readonly<{
+        /**
+         * Create a new health check aggregator instance
+         */
+        create(monitor: IServiceHealthMonitor): IHealthCheckAggregator;
+    }>;
+};
+export default _default;
+//# sourceMappingURL=ServiceHealthMonitor.d.ts.map

package/src/microservices/ServiceHealthMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceHealthMonitor.d.ts","sourceRoot":"","sources":["../../../src/microservices/ServiceHealthMonitor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,IAAI,EAAE,OAAO,CAAC;QACd,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACxC,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtD;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;OAEG;wBAEY,MAAM,WACV,MAAM,QACT,MAAM,UACJ,MAAM,iBACA,MAAM,EAAE,kBACN,MAAM,OAAO,CAAC,OAAO,CAAC,GACrC,mBAAmB;EA0DtB,CAAC;AAkFH,MAAM,WAAW,qBAAqB;IACpC,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IACb,QAAQ,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC5C,aAAa,IAAI,sBAAsB,CAAC;IACxC,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAAC;IACrE,aAAa,IAAI,OAAO,CAAC;IACzB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;CAChD;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;OAEG;4BAEgB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,eAC3B,MAAM,GACjB,qBAAqB;EAcxB,CAAC;AA6NH,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtD;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAChC;;OAEG;oBACa,qBAAqB,GAAG,sBAAsB;EAsB9D,CAAC;;;QAxbD;;WAEG;4BAEY,MAAM,WACV,MAAM,QACT,MAAM,UACJ,MAAM,iBACA,MAAM,EAAE,kBACN,MAAM,OAAO,CAAC,OAAO,CAAC,GACrC,mBAAmB;;;QA2JtB;;WAEG;gCAEgB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,eAC3B,MAAM,GACjB,qBAAqB;;;QAoPxB;;WAEG;wBACa,qBAAqB,GAAG,sBAAsB;;;AA6ChE,wBAIE"}