@zintrust/core 0.4.17 → 0.4.19

package/src/microservices/ServiceHealthMonitor.js

@@ -0,0 +1,383 @@
+/**
+ * Service Health Check and Monitoring System
+ * Provides per-service and aggregated health status with detailed diagnostics
+ */
+import { Logger } from '../config/logger.js';
+import { validateUrl } from '../security/UrlValidator.js';
+/**
+ * Health Check Endpoint Handler
+ * Each service should expose this as GET /health
+ */
+export const HealthCheckHandler = Object.freeze({
+    /**
+     * Create a new health check handler instance
+     */
+    create(serviceName, version, port, domain, dependencies = [], checkDatabase) {
+        /**
+         * Perform full health check
+         */
+        const performHealthCheck = async (startTime) => {
+            const result = {
+                service: serviceName,
+                domain,
+                port,
+                status: 'healthy',
+                timestamp: new Date().toISOString(),
+                responseTime: 0,
+                version,
+                checks: {
+                    http: true,
+                    database: undefined,
+                    dependencies: {},
+                },
+            };
+            await checkDatabaseHealth(result, checkDatabase);
+            await checkDependenciesHealth(result, dependencies);
+            result.responseTime = Date.now() - startTime;
+            return result;
+        };
+        return {
+            /**
+             * Handle health check request
+             * Returns JSON with service health status
+             */
+            async handle(_req, res) {
+                const startTime = Date.now();
+                try {
+                    const result = await performHealthCheck(startTime);
+                    const statusCode = getStatusCode(result.status);
+                    res.setStatus(statusCode).json(result);
+                }
+                catch (err) {
+                    Logger.error('Health check handler error:', err);
+                    const result = {
+                        service: serviceName,
+                        domain,
+                        port,
+                        status: 'unhealthy',
+                        timestamp: new Date().toISOString(),
+                        responseTime: Date.now() - startTime,
+                        version,
+                        checks: { http: false },
+                        message: err.message,
+                    };
+                    res.setStatus(503).json(result);
+                }
+            },
+        };
+    },
+});
+/**
+ * Get status code based on health status
+ */
+function getStatusCode(status) {
+    if (status === 'healthy')
+        return 200;
+    if (status === 'degraded')
+        return 202;
+    return 503;
+}
+/**
+ * Check single dependency service
+ */
+async function checkDependencyService(depService) {
+    try {
+        // In a real environment, we would resolve the service URL
+        // For now, we assume it's on localhost with a standard port mapping or discovery
+        const url = `http://localhost:7777/health?service=${depService}`;
+        // SSRF Protection
+        validateUrl(url);
+        const depResponse = await fetch(url, {
+            signal: AbortSignal.timeout(2000),
+        });
+        return depResponse.ok;
+    }
+    catch (error) {
+        Logger.error(`Dependency health check failed for ${depService}`, error);
+        return false;
+    }
+}
+/**
+ * Check all dependencies health
+ */
+async function checkDependenciesHealth(result, dependencies) {
+    if (dependencies.length === 0)
+        return;
+    result.checks.dependencies ??= {};
+    const checks = await Promise.all(dependencies.map(async (depService) => ({
+        depService,
+        isHealthy: await checkDependencyService(depService),
+    })));
+    for (const { depService, isHealthy } of checks) {
+        result.checks.dependencies[depService] = isHealthy;
+        if (!isHealthy) {
+            result.status = 'degraded';
+        }
+    }
+}
+/**
+ * Check database health
+ */
+async function checkDatabaseHealth(result, checkDatabase) {
+    if (checkDatabase === undefined)
+        return;
+    try {
+        result.checks.database = await checkDatabase();
+        if (!result.checks.database) {
+            result.status = 'degraded';
+            result.message = 'Database connection failed';
+        }
+    }
+    catch (err) {
+        Logger.error('Database health check failed:', err);
+        result.checks.database = false;
+        result.status = 'unhealthy';
+        result.message = 'Database check error';
+    }
+}
+/**
+ * Service Health Monitor
+ * Monitors multiple services and provides aggregated health status
+ */
+export const ServiceHealthMonitor = Object.freeze({
+    /**
+     * Create a new service health monitor instance
+     */
+    create(healthCheckUrls, // serviceName -> healthCheckUrl
+    intervalMs = 30000 // Check every 30 seconds
+    ) {
+        let checkIntervalId;
+        const lastResults = new Map();
+        return createMonitorObject(healthCheckUrls, intervalMs, lastResults, () => checkIntervalId, (id) => {
+            checkIntervalId = id;
+        });
+    },
+});
+/**
+ * Create the monitor object with methods
+ */
+function createMonitorObject(healthCheckUrls, intervalMs, lastResults, getIntervalId, setIntervalId) {
+    const self = {
+        /**
+         * Start continuous health monitoring
+         */
+        start() {
+            startMonitoring(intervalMs, async () => self.checkAll(), getIntervalId, setIntervalId);
+        },
+        /**
+         * Stop health monitoring
+         */
+        stop() {
+            stopMonitoring(getIntervalId, setIntervalId);
+        },
+        /**
+         * Check all services
+         */
+        async checkAll() {
+            const status = await runAllChecks(healthCheckUrls, lastResults);
+            logHealthSummary(status);
+            return status;
+        },
+        /**
+         * Get last known status of all services
+         */
+        getLastStatus() {
+            const results = Array.from(lastResults.values());
+            return calculateAggregatedStatus(results);
+        },
+        /**
+         * Get health status for specific service
+         */
+        getServiceStatus(serviceName) {
+            return lastResults.get(serviceName);
+        },
+        /**
+         * Check if all services are healthy
+         */
+        areAllHealthy() {
+            return checkAllHealthy(lastResults, healthCheckUrls);
+        },
+        /**
+         * Check if service is healthy
+         */
+        isServiceHealthy(serviceName) {
+            const status = self.getServiceStatus(serviceName);
+            return status?.status === 'healthy';
+        },
+    };
+    return self;
+}
+/**
+ * Start monitoring logic
+ */
+function startMonitoring(intervalMs, checkAll, getIntervalId, setIntervalId) {
+    if (getIntervalId() !== undefined) {
+        Logger.warn('Health monitoring already started');
+        return;
+    }
+    Logger.info('🏥 Starting service health monitoring');
+    let inFlight = false;
+    const safeCheckAll = async () => {
+        if (inFlight)
+            return;
+        inFlight = true;
+        try {
+            await checkAll();
+        }
+        catch (err) {
+            Logger.error('Service health monitoring tick failed:', err);
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+    void safeCheckAll(); // Initial check
+    const id = setInterval(() => {
+        void safeCheckAll();
+    }, intervalMs);
+    // Node: allow process to exit; other runtimes may not support unref()
+    if (isUnrefableTimer(id)) {
+        id.unref();
+    }
+    setIntervalId(id);
+}
+function isUnrefableTimer(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'unref' in value && typeof value.unref === 'function';
+}
+/**
+ * Stop monitoring logic
+ */
+function stopMonitoring(getIntervalId, setIntervalId) {
+    const id = getIntervalId();
+    if (id !== undefined) {
+        clearInterval(id);
+        setIntervalId(undefined);
+        Logger.info('🛑 Health monitoring stopped');
+    }
+}
+/**
+ * Check if all services are healthy
+ */
+function checkAllHealthy(lastResults, healthCheckUrls) {
+    const results = Array.from(lastResults.values());
+    if (results.length === 0 && Object.keys(healthCheckUrls).length > 0) {
+        return false;
+    }
+    return results.length > 0 && results.every((r) => r.status === 'healthy');
+}
+/**
+ * Check single service
+ */
+async function checkService(serviceName, url) {
+    const startTime = Date.now();
+    try {
+        const response = await fetch(url, {
+            signal: AbortSignal.timeout(5000),
+        });
+        await response.json();
+        return {
+            service: serviceName,
+            domain: 'unknown',
+            port: 0,
+            status: 'healthy',
+            timestamp: new Date().toISOString(),
+            responseTime: Date.now() - startTime,
+            version: 'unknown',
+            checks: { http: true },
+        };
+    }
+    catch (err) {
+        Logger.error(`Service health check failed for ${serviceName}:`, err);
+        return {
+            service: serviceName,
+            domain: 'unknown',
+            port: 0,
+            status: 'stopped',
+            timestamp: new Date().toISOString(),
+            responseTime: Date.now() - startTime,
+            version: 'unknown',
+            checks: { http: false },
+            message: `Service check failed: ${err.message}`,
+        };
+    }
+}
+/**
+ * Calculate aggregated health status from results
+ */
+function calculateAggregatedStatus(results) {
+    const healthy = results.filter((r) => r.status === 'healthy').length;
+    const degraded = results.filter((r) => r.status === 'degraded').length;
+    const unhealthy = results.filter((r) => r.status === 'unhealthy').length;
+    return {
+        timestamp: new Date().toISOString(),
+        totalServices: results.length,
+        healthy,
+        degraded,
+        unhealthy,
+        services: results,
+    };
+}
+/**
+ * Log health summary
+ */
+function logHealthSummary(status) {
+    if (status.unhealthy > 0) {
+        Logger.warn(`⚠️  Health check: ${status.healthy} healthy, ${status.degraded} degraded, ${status.unhealthy} unhealthy`);
+    }
+    else if (status.degraded > 0) {
+        Logger.warn(`⚠️  Health check: ${status.healthy} healthy, ${status.degraded} degraded`);
+    }
+    else {
+        Logger.info(`✅ All ${status.healthy} services healthy`);
+    }
+}
+/**
+ * Health Check Aggregator Endpoint
+ * Exposes aggregated health status at GET /health/services
+ */
+export const HealthCheckAggregator = Object.freeze({
+    /**
+     * Create a new health check aggregator instance
+     */
+    create(monitor) {
+        return {
+            /**
+             * Handle aggregated health check request
+             */
+            // eslint-disable-next-line @typescript-eslint/require-await
+            async handle(_req, res) {
+                const status = monitor.getLastStatus();
+                let statusCode;
+                if (status.unhealthy > 0) {
+                    statusCode = 503;
+                }
+                else if (status.degraded > 0) {
+                    statusCode = 202;
+                }
+                else {
+                    statusCode = 200;
+                }
+                res.setStatus(statusCode).json(status);
+            },
+        };
+    },
+});
+/**
+ * Run all service health checks
+ */
+async function runAllChecks(healthCheckUrls, lastResults) {
+    const checks = Object.entries(healthCheckUrls).map(async ([serviceName, url]) => checkService(serviceName, url));
+    const results = await Promise.all(checks);
+    // Store results
+    results.forEach((result) => {
+        lastResults.set(result.service, result);
+    });
+    return calculateAggregatedStatus(results);
+}
+export default {
+    HealthCheckHandler,
+    ServiceHealthMonitor,
+    HealthCheckAggregator,
+};

package/src/microservices/ServiceManifest.d.ts

@@ -0,0 +1,65 @@
+import type { RoutesModule } from '../boot/registry/type';
+export interface ServiceManifestEntry {
+    id: string;
+    domain: string;
+    name: string;
+    prefix?: string;
+    configRoot?: string;
+    loadEnv?: boolean;
+    version?: string;
+    description?: string;
+    port?: number;
+    healthCheck?: string;
+    monolithEnabled?: boolean;
+    loadRoutes?: () => Promise<RoutesModule>;
+}
+export interface ActiveServiceRuntime {
+    id: string;
+    domain: string;
+    name: string;
+    configRoot?: string;
+}
+export interface ProjectRuntimeModule {
+    serviceManifest?: ReadonlyArray<ServiceManifestEntry>;
+    activeService?: ActiveServiceRuntime;
+}
+export declare const getServiceId: (domain: string, name: string) => string;
+export declare const getDefaultServicePrefix: (domain: string, name: string) => string;
+export declare const getServicePrefix: (args: {
+    prefix?: unknown;
+    domain?: unknown;
+    name?: unknown;
+}) => string;
+export declare const isCanonicalServiceId: (value: unknown) => value is string;
+export declare const toCanonicalServiceId: (args: {
+    id?: unknown;
+    domain?: unknown;
+    name?: unknown;
+}) => string;
+export declare const isServiceManifestEntry: (value: unknown) => value is ServiceManifestEntry;
+export declare const normalizeServiceManifest: (value: unknown) => ReadonlyArray<ServiceManifestEntry>;
+export declare const normalizeActiveServiceRuntime: (value: unknown) => ActiveServiceRuntime | undefined;
+export declare const normalizeProjectRuntimeModule: (value: unknown) => ProjectRuntimeModule;
+export declare const serviceMatchesAllowList: (serviceId: string, serviceName: string, allowList: ReadonlyArray<string>) => boolean;
+declare const _default: Readonly<{
+    getServiceId: (domain: string, name: string) => string;
+    getDefaultServicePrefix: (domain: string, name: string) => string;
+    getServicePrefix: (args: {
+        prefix?: unknown;
+        domain?: unknown;
+        name?: unknown;
+    }) => string;
+    isCanonicalServiceId: (value: unknown) => value is string;
+    toCanonicalServiceId: (args: {
+        id?: unknown;
+        domain?: unknown;
+        name?: unknown;
+    }) => string;
+    isServiceManifestEntry: (value: unknown) => value is ServiceManifestEntry;
+    normalizeServiceManifest: (value: unknown) => ReadonlyArray<ServiceManifestEntry>;
+    normalizeActiveServiceRuntime: (value: unknown) => ActiveServiceRuntime | undefined;
+    normalizeProjectRuntimeModule: (value: unknown) => ProjectRuntimeModule;
+    serviceMatchesAllowList: (serviceId: string, serviceName: string, allowList: ReadonlyArray<string>) => boolean;
+}>;
+export default _default;
+//# sourceMappingURL=ServiceManifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceManifest.d.ts","sourceRoot":"","sources":["../../../src/microservices/ServiceManifest.ts"],"names":[],"mappings":"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"}

package/src/microservices/ServiceManifest.js

@@ -0,0 +1,119 @@
+import { isArray, isFunction, isNonEmptyString, isObject } from '../helper/index.js';
+export const getServiceId = (domain, name) => `${domain}/${name}`;
+export const getDefaultServicePrefix = (domain, name) => `/${getServiceId(domain, name)}`;
+const normalizeServicePrefix = (value) => {
+    const trimmed = value.trim();
+    if (trimmed === '' || trimmed === '/')
+        return '/';
+    const segments = trimmed
+        .split('/')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+    if (segments.length === 0)
+        return '/';
+    return `/${segments.join('/')}`;
+};
+export const getServicePrefix = (args) => {
+    if (typeof args.prefix === 'string')
+        return normalizeServicePrefix(args.prefix);
+    const domain = isNonEmptyString(args.domain) ? args.domain : 'default';
+    const name = isNonEmptyString(args.name) ? args.name : 'unknown';
+    return getDefaultServicePrefix(domain, name);
+};
+export const isCanonicalServiceId = (value) => {
+    if (!isNonEmptyString(value))
+        return false;
+    const segments = value.split('/');
+    return segments.length === 2 && segments.every((segment) => segment.trim().length > 0);
+};
+export const toCanonicalServiceId = (args) => {
+    if (isCanonicalServiceId(args.id))
+        return args.id;
+    const domain = isNonEmptyString(args.domain) ? args.domain : 'default';
+    const name = isNonEmptyString(args.name) ? args.name : 'unknown';
+    return getServiceId(domain, name);
+};
+export const isServiceManifestEntry = (value) => {
+    if (!isObject(value))
+        return false;
+    if (!isCanonicalServiceId(value['id']))
+        return false;
+    if (!isNonEmptyString(value['domain']))
+        return false;
+    if (!isNonEmptyString(value['name']))
+        return false;
+    const prefix = value['prefix'];
+    if (prefix !== undefined && typeof prefix !== 'string') {
+        return false;
+    }
+    const configRoot = value['configRoot'];
+    if (configRoot !== undefined && typeof configRoot !== 'string') {
+        return false;
+    }
+    const loadEnv = value['loadEnv'];
+    if (loadEnv !== undefined && typeof loadEnv !== 'boolean') {
+        return false;
+    }
+    const loadRoutes = value['loadRoutes'];
+    if (loadRoutes !== undefined && !isFunction(loadRoutes)) {
+        return false;
+    }
+    return true;
+};
+export const normalizeServiceManifest = (value) => {
+    if (!isArray(value))
+        return [];
+    return value.filter(isServiceManifestEntry).map((entry) => ({
+        ...entry,
+        id: toCanonicalServiceId(entry),
+        prefix: getServicePrefix(entry),
+        ...(isNonEmptyString(entry.configRoot) ? { configRoot: entry.configRoot } : {}),
+        loadEnv: entry.loadEnv !== false,
+        monolithEnabled: entry.monolithEnabled !== false,
+    }));
+};
+export const normalizeActiveServiceRuntime = (value) => {
+    if (!isObject(value))
+        return undefined;
+    if (!isNonEmptyString(value['domain']))
+        return undefined;
+    if (!isNonEmptyString(value['name']))
+        return undefined;
+    const configRoot = isNonEmptyString(value['configRoot']) ? value['configRoot'] : undefined;
+    return Object.freeze({
+        id: toCanonicalServiceId(value),
+        domain: value['domain'],
+        name: value['name'],
+        ...(configRoot === undefined ? {} : { configRoot }),
+    });
+};
+export const normalizeProjectRuntimeModule = (value) => {
+    if (!isObject(value)) {
+        return Object.freeze({});
+    }
+    return Object.freeze({
+        ...(Object.hasOwn(value, 'serviceManifest')
+            ? { serviceManifest: normalizeServiceManifest(value['serviceManifest']) }
+            : {}),
+        ...(Object.hasOwn(value, 'activeService')
+            ? { activeService: normalizeActiveServiceRuntime(value['activeService']) }
+            : {}),
+    });
+};
+export const serviceMatchesAllowList = (serviceId, serviceName, allowList) => {
+    if (allowList.length === 0)
+        return true;
+    return allowList.includes(serviceId) || allowList.includes(serviceName);
+};
+export default Object.freeze({
+    getServiceId,
+    getDefaultServicePrefix,
+    getServicePrefix,
+    isCanonicalServiceId,
+    toCanonicalServiceId,
+    isServiceManifestEntry,
+    normalizeServiceManifest,
+    normalizeActiveServiceRuntime,
+    normalizeProjectRuntimeModule,
+    serviceMatchesAllowList,
+});

package/src/middleware/AuthMiddleware.d.ts

@@ -0,0 +1,12 @@
+import { type MiddlewareFailureResponder } from './MiddlewareFailureResponder';
+import type { Middleware } from './MiddlewareStack';
+export interface AuthOptions {
+    headerName?: string;
+    message?: string;
+    onUnauthorized?: MiddlewareFailureResponder;
+}
+export declare const AuthMiddleware: Readonly<{
+    create(options?: AuthOptions): Middleware;
+}>;
+export default AuthMiddleware;
+//# sourceMappingURL=AuthMiddleware.d.ts.map

package/src/middleware/AuthMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthMiddleware.d.ts","sourceRoot":"","sources":["../../../src/middleware/AuthMiddleware.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,0BAA0B,CAAC;CAC7C;AAED,eAAO,MAAM,cAAc;qBACT,WAAW,GAAQ,UAAU;EAsB7C,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/src/middleware/AuthMiddleware.js

@@ -0,0 +1,23 @@
+import { respondWithMiddlewareFailure, } from './MiddlewareFailureResponder.js';
+export const AuthMiddleware = Object.freeze({
+    create(options = {}) {
+        const headerName = (options.headerName ?? 'authorization').toLowerCase();
+        const message = options.message ?? 'Unauthorized';
+        return async (req, res, next) => {
+            const header = req.getHeader(headerName);
+            const value = Array.isArray(header) ? header[0] : header;
+            if (typeof value !== 'string' || value.trim() === '') {
+                await respondWithMiddlewareFailure(req, res, options.onUnauthorized, {
+                    middleware: 'auth',
+                    reason: 'missing_authorization_header',
+                    statusCode: 401,
+                    message,
+                    body: { error: message },
+                });
+                return;
+            }
+            await next();
+        };
+    },
+});
+export default AuthMiddleware;