@zintrust/core 0.1.42 → 0.1.43

package/packages/workers/src/WorkerRegistry.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Worker Registry
+ * Central registry for all background workers with lifecycle management
+ * Sealed namespace for immutability
+ */
+import { type WorkerConfig, type WorkerStatus } from '../../../src/index.js';
+export type WorkerMetadata = {
+    name: string;
+    status: WorkerStatus;
+    version: string;
+    region: string;
+    queueName: string;
+    concurrency: number;
+    activeStatus?: boolean;
+    startedAt: Date | null;
+    stoppedAt: Date | null;
+    lastProcessedAt: Date | null;
+    restartCount: number;
+    processedCount: number;
+    errorCount: number;
+    lockKey: string | null;
+    priority: number;
+    memoryUsage: number;
+    cpuUsage: number;
+    circuitState: 'closed' | 'open' | 'half-open';
+    queues: ReadonlyArray<string>;
+    plugins: ReadonlyArray<string>;
+    datacenter: string;
+    canaryPercentage: number;
+    config: Partial<WorkerConfig>;
+};
+export type WorkerInstance = {
+    metadata: WorkerMetadata;
+    instance: unknown;
+    start: () => void;
+    stop: () => Promise<void>;
+    drain: () => Promise<void>;
+    sleep: () => Promise<void>;
+    wakeup: () => void;
+    getStatus: () => WorkerStatus;
+    getHealth: () => 'green' | 'yellow' | 'red';
+};
+export type RegisterWorkerOptions = {
+    name: string;
+    config: Partial<WorkerConfig>;
+    activeStatus?: boolean;
+    version?: string;
+    region?: string;
+    queues?: ReadonlyArray<string>;
+    factory: () => Promise<WorkerInstance>;
+};
+export type WorkerRegistrySnapshot = {
+    timestamp: Date;
+    totalWorkers: number;
+    runningWorkers: number;
+    stoppedWorkers: number;
+    sleepingWorkers: number;
+    unhealthyWorkers: number;
+    workers: ReadonlyArray<{
+        name: string;
+        status: WorkerStatus;
+        health: 'green' | 'yellow' | 'red';
+        uptime: number | null;
+        processedCount: number;
+        errorCount: number;
+    }>;
+};
+/**
+ * Worker Registry - Sealed namespace
+ */
+export declare const WorkerRegistry: Readonly<{
+    /**
+     * Register a worker with the registry
+     */
+    register(options: RegisterWorkerOptions): void;
+    /**
+     * Start a worker
+     */
+    start(name: string, version?: string): Promise<void>;
+    /**
+     * Stop a worker
+     */
+    stop(name: string): Promise<void>;
+    /**
+     * Restart a worker (stop + start)
+     */
+    restart(name: string): Promise<void>;
+    /**
+     * Sleep a worker (pause processing but keep lock)
+     */
+    sleep(name: string): Promise<void>;
+    /**
+     * Wakeup a worker (resume from sleep)
+     */
+    wakeup(name: string): Promise<void>;
+    /**
+     * Get worker status
+     */
+    status(name: string): WorkerMetadata | null;
+    /**
+     * List all registered workers
+     */
+    list(): ReadonlyArray<string>;
+    /**
+     * Update active status for a registered worker
+     */
+    setActiveStatus(name: string, activeStatus: boolean): void;
+    /**
+     * List all running workers
+     */
+    listRunning(): ReadonlyArray<string>;
+    /**
+     * Stop all running workers
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Get worker metrics
+     */
+    getMetrics(name: string): Pick<WorkerMetadata, "processedCount" | "errorCount" | "memoryUsage" | "cpuUsage"> | null;
+    /**
+     * Get worker health status
+     */
+    getHealth(name: string): "green" | "yellow" | "red" | null;
+    /**
+     * Get registry snapshot
+     */
+    getSnapshot(): WorkerRegistrySnapshot;
+    /**
+     * Get worker topology (cluster view)
+     */
+    getTopology(): Record<string, {
+        workers: string[];
+        count: number;
+    }>;
+    /**
+     * Unregister a worker and clear its instance
+     */
+    unregister(name: string): void;
+    /**
+     * Check if worker is registered
+     */
+    isRegistered(name: string): boolean;
+    /**
+     * Check if worker is running
+     */
+    isRunning(name: string): boolean;
+    /**
+     * Get worker instance (internal use)
+     */
+    getInstance(name: string): WorkerInstance | null;
+}>;
+//# sourceMappingURL=WorkerRegistry.d.ts.map

package/packages/workers/src/WorkerRegistry.d.ts.map

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

package/packages/workers/src/WorkerRegistry.js

@@ -0,0 +1,396 @@
+/**
+ * Worker Registry
+ * Central registry for all background workers with lifecycle management
+ * Sealed namespace for immutability
+ */
+import { ErrorFactory, Logger } from '../../../src/index.js';
+import { AnomalyDetection } from './AnomalyDetection.js';
+// Internal storage
+const workers = new Map();
+const registrations = new Map();
+// Cleanup configuration
+const STOPPED_WORKER_CLEANUP_DELAY = 5 * 60 * 1000; // 5 minutes
+const cleanupTimers = new Map();
+const isUnrefableTimer = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'unref' in value && typeof value.unref === 'function';
+};
+/**
+ * Helper: Schedule cleanup of stopped worker
+ */
+const scheduleStoppedWorkerCleanup = (name) => {
+    // Clear existing timer if any
+    const existingTimer = cleanupTimers.get(name);
+    if (existingTimer) {
+        clearTimeout(existingTimer);
+    }
+    // Schedule new cleanup with proper cleanup handling
+    // eslint-disable-next-line no-restricted-syntax
+    const timer = setTimeout(() => {
+        try {
+            const instance = workers.get(name);
+            if (instance && instance.metadata.status === 'stopped') {
+                Logger.info(`Auto-cleaning up stopped worker: ${name}`);
+                workers.delete(name);
+                registrations.delete(name);
+            }
+        }
+        catch (error) {
+            Logger.error(`Error during auto-cleanup of worker ${name}`, error);
+        }
+        finally {
+            cleanupTimers.delete(name);
+        }
+    }, STOPPED_WORKER_CLEANUP_DELAY);
+    if (isUnrefableTimer(timer)) {
+        timer.unref();
+    }
+    cleanupTimers.set(name, timer);
+};
+/**
+ * Helper: Cancel cleanup timer
+ */
+const cancelCleanupTimer = (name) => {
+    const timer = cleanupTimers.get(name);
+    if (timer) {
+        clearTimeout(timer);
+        cleanupTimers.delete(name);
+    }
+};
+/**
+ * Helper: Calculate uptime in seconds
+ */
+const calculateUptime = (startedAt) => {
+    if (!startedAt)
+        return null;
+    return Math.floor((Date.now() - startedAt.getTime()) / 1000);
+};
+/**
+ * Helper: Validate worker name
+ */
+const validateWorkerName = (name) => {
+    if (!name || typeof name !== 'string') {
+        throw ErrorFactory.createWorkerError('Worker name must be a non-empty string');
+    }
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        throw ErrorFactory.createWorkerError('Worker name must contain only lowercase letters, numbers, and hyphens');
+    }
+};
+/**
+ * Worker Registry - Sealed namespace
+ */
+export const WorkerRegistry = Object.freeze({
+    /**
+     * Register a worker with the registry
+     */
+    register(options) {
+        validateWorkerName(options.name);
+        if (registrations.has(options.name)) {
+            Logger.warn(`Worker "${options.name}" is already registered. Skipping.`);
+            return;
+        }
+        registrations.set(options.name, options);
+        Logger.info(`Worker "${options.name}" registered successfully`);
+    },
+    /**
+     * Start a worker
+     */
+    async start(name, version) {
+        validateWorkerName(name);
+        const registration = registrations.get(name);
+        if (!registration) {
+            throw ErrorFactory.createWorkerError(`Worker "${name}" is not registered`);
+        }
+        if (registration.activeStatus === false) {
+            throw ErrorFactory.createWorkerError(`Worker "${name}" is inactive`);
+        }
+        if (workers.has(name)) {
+            const existing = workers.get(name);
+            if (existing?.metadata.status === 'running') {
+                Logger.warn(`Worker "${name}" is already running`);
+                return;
+            }
+        }
+        const versionSuffix = version === undefined ? '' : ` version ${version}`;
+        Logger.info(`Starting worker "${name}"${versionSuffix}...`);
+        try {
+            const instance = await registration.factory();
+            instance.metadata.status = 'starting';
+            instance.metadata.version = version ?? '1.0.0';
+            // Cancel any pending cleanup timer when worker restarts
+            cancelCleanupTimer(name);
+            workers.set(name, instance);
+            instance.start();
+            instance.metadata.status = 'running';
+            instance.metadata.startedAt = new Date();
+            instance.metadata.stoppedAt = null;
+            Logger.info(`Worker "${name}" started successfully`);
+        }
+        catch (error) {
+            Logger.error(`Failed to start worker "${name}"`, error);
+            throw error;
+        }
+    },
+    /**
+     * Stop a worker
+     */
+    async stop(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (!instance) {
+            Logger.warn(`Worker "${name}" is not running`);
+            return;
+        }
+        if (instance.metadata.status === 'stopped') {
+            Logger.warn(`Worker "${name}" is already stopped`);
+            return;
+        }
+        Logger.info(`Stopping worker "${name}"...`);
+        try {
+            instance.metadata.status = 'stopping';
+            await instance.stop();
+            instance.metadata.status = 'stopped';
+            instance.metadata.stoppedAt = new Date();
+            AnomalyDetection.cleanup(name);
+            // Schedule automatic cleanup for stopped worker
+            scheduleStoppedWorkerCleanup(name);
+            Logger.info(`Worker "${name}" stopped successfully`);
+        }
+        catch (error) {
+            Logger.error(`Failed to stop worker "${name}"`, error);
+            throw error;
+        }
+    },
+    /**
+     * Restart a worker (stop + start)
+     */
+    async restart(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (instance) {
+            await WorkerRegistry.stop(name);
+            instance.metadata.restartCount += 1;
+        }
+        await WorkerRegistry.start(name);
+        Logger.info(`Worker "${name}" restarted successfully`);
+    },
+    /**
+     * Sleep a worker (pause processing but keep lock)
+     */
+    async sleep(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (!instance) {
+            throw ErrorFactory.createWorkerError(`Worker "${name}" is not running`);
+        }
+        if (instance.metadata.status === 'sleeping') {
+            Logger.warn(`Worker "${name}" is already sleeping`);
+            return;
+        }
+        Logger.info(`Putting worker "${name}" to sleep...`);
+        try {
+            await instance.sleep();
+            instance.metadata.status = 'sleeping';
+            Logger.info(`Worker "${name}" is now sleeping`);
+        }
+        catch (error) {
+            Logger.error(`Failed to sleep worker "${name}"`, error);
+            throw error;
+        }
+    },
+    /**
+     * Wakeup a worker (resume from sleep)
+     */
+    async wakeup(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (!instance) {
+            throw ErrorFactory.createWorkerError(`Worker "${name}" is not found`);
+        }
+        if (instance.metadata.status !== 'sleeping') {
+            Logger.warn(`Worker "${name}" is not sleeping (status: ${instance.metadata.status})`);
+            return;
+        }
+        Logger.info(`Waking up worker "${name}"...`);
+        try {
+            instance.wakeup();
+            instance.metadata.status = 'running';
+            Logger.info(`Worker "${name}" is now awake and running`);
+        }
+        catch (error) {
+            Logger.error(`Failed to wake up worker "${name}"`, error);
+            throw error;
+        }
+    },
+    /**
+     * Get worker status
+     */
+    status(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (!instance) {
+            return null;
+        }
+        return { ...instance.metadata };
+    },
+    /**
+     * List all registered workers
+     */
+    list() {
+        const names = [];
+        for (const [name, registration] of registrations.entries()) {
+            if (registration.activeStatus === false)
+                continue;
+            names.push(name);
+        }
+        return names;
+    },
+    /**
+     * Update active status for a registered worker
+     */
+    setActiveStatus(name, activeStatus) {
+        const registration = registrations.get(name);
+        if (!registration)
+            return;
+        registrations.set(name, { ...registration, activeStatus });
+    },
+    /**
+     * List all running workers
+     */
+    listRunning() {
+        const running = [];
+        for (const [name, instance] of workers.entries()) {
+            if (instance.metadata.status === 'running') {
+                running.push(name);
+            }
+        }
+        return running;
+    },
+    /**
+     * Stop all running workers
+     */
+    async stopAll() {
+        Logger.info('Stopping all running workers...');
+        const running = WorkerRegistry.listRunning();
+        const tasks = running.map(async (name) => WorkerRegistry.stop(name));
+        try {
+            await Promise.all(tasks);
+            Logger.info(`Stopped ${running.length} workers successfully`);
+        }
+        catch (error) {
+            Logger.error('Failed to stop some workers', error);
+            throw error;
+        }
+    },
+    /**
+     * Get worker metrics
+     */
+    getMetrics(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (!instance) {
+            return null;
+        }
+        return {
+            processedCount: instance.metadata.processedCount,
+            errorCount: instance.metadata.errorCount,
+            memoryUsage: instance.metadata.memoryUsage,
+            cpuUsage: instance.metadata.cpuUsage,
+        };
+    },
+    /**
+     * Get worker health status
+     */
+    getHealth(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (!instance) {
+            return null;
+        }
+        return instance.getHealth();
+    },
+    /**
+     * Get registry snapshot
+     */
+    getSnapshot() {
+        const allWorkers = Array.from(workers.entries()).map(([name, instance]) => ({
+            name,
+            status: instance.metadata.status,
+            health: instance.getHealth(),
+            uptime: calculateUptime(instance.metadata.startedAt),
+            processedCount: instance.metadata.processedCount,
+            errorCount: instance.metadata.errorCount,
+        }));
+        const statusCounts = allWorkers.reduce((acc, w) => {
+            if (w.status === 'running')
+                acc.running++;
+            else if (w.status === 'stopped')
+                acc.stopped++;
+            else if (w.status === 'sleeping')
+                acc.sleeping++;
+            if (w.health === 'red')
+                acc.unhealthy++;
+            return acc;
+        }, { running: 0, stopped: 0, sleeping: 0, unhealthy: 0 });
+        return {
+            timestamp: new Date(),
+            totalWorkers: registrations.size,
+            runningWorkers: statusCounts.running,
+            stoppedWorkers: statusCounts.stopped,
+            sleepingWorkers: statusCounts.sleeping,
+            unhealthyWorkers: statusCounts.unhealthy,
+            workers: allWorkers,
+        };
+    },
+    /**
+     * Get worker topology (cluster view)
+     */
+    getTopology() {
+        const topology = {};
+        for (const [name, instance] of workers.entries()) {
+            const region = instance.metadata.region;
+            if (topology[region].count <= 0) {
+                topology[region] = { workers: [], count: 0 };
+            }
+            topology[region].workers.push(name);
+            topology[region].count++;
+        }
+        return topology;
+    },
+    /**
+     * Unregister a worker and clear its instance
+     */
+    unregister(name) {
+        validateWorkerName(name);
+        const instance = workers.get(name);
+        if (instance?.metadata.status === 'running') {
+            Logger.warn(`Worker "${name}" is still running during unregister`);
+        }
+        // Cancel any pending cleanup timer
+        cancelCleanupTimer(name);
+        workers.delete(name);
+        registrations.delete(name);
+        AnomalyDetection.cleanup(name);
+        Logger.info(`Worker "${name}" unregistered`);
+    },
+    /**
+     * Check if worker is registered
+     */
+    isRegistered(name) {
+        return registrations.has(name);
+    },
+    /**
+     * Check if worker is running
+     */
+    isRunning(name) {
+        const instance = workers.get(name);
+        return instance?.metadata.status === 'running';
+    },
+    /**
+     * Get worker instance (internal use)
+     */
+    getInstance(name) {
+        return workers.get(name) ?? null;
+    },
+});

package/packages/workers/src/WorkerShutdown.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Worker Shutdown Coordinator
+ *
+ * Centralized graceful shutdown handling for the worker management system.
+ * Coordinates orderly shutdown of all worker modules and the WorkerFactory.
+ */
+export interface IShutdownOptions {
+    /**
+     * Timeout for graceful shutdown in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Whether to force exit after timeout
+     */
+    forceExit?: boolean;
+    /**
+     * Signal that triggered shutdown (SIGTERM, SIGINT, etc.)
+     */
+    signal?: string;
+}
+interface IShutdownState {
+    isShuttingDown: boolean;
+    completedAt: Date | null;
+    startedAt: Date | null;
+    reason: string | null;
+}
+/**
+ * Perform graceful shutdown of all worker modules
+ */
+declare function shutdown(options?: IShutdownOptions): Promise<void>;
+/**
+ * Register process signal handlers for graceful shutdown
+ */
+declare function registerShutdownHandlers(): void;
+/**
+ * Unregister process signal handlers (for hot reload/testing)
+ */
+declare function unregisterShutdownHandlers(): void;
+/**
+ * Check if system is currently shutting down
+ */
+declare function isShuttingDown(): boolean;
+/**
+ * Get current shutdown state
+ */
+declare function getShutdownState(): Readonly<IShutdownState>;
+export declare const WorkerShutdown: Readonly<{
+    /**
+     * Perform graceful shutdown of all worker modules
+     */
+    shutdown: typeof shutdown;
+    /**
+     * Register process signal handlers for graceful shutdown
+     */
+    registerShutdownHandlers: typeof registerShutdownHandlers;
+    /**
+     * Unregister process signal handlers (for hot reload/testing)
+     */
+    unregisterShutdownHandlers: typeof unregisterShutdownHandlers;
+    /**
+     * Check if system is currently shutting down
+     */
+    isShuttingDown: typeof isShuttingDown;
+    /**
+     * Get current shutdown state
+     */
+    getShutdownState: typeof getShutdownState;
+}>;
+export {};
+//# sourceMappingURL=WorkerShutdown.d.ts.map

package/packages/workers/src/WorkerShutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerShutdown.d.ts","sourceRoot":"","sources":["../../../../packages/workers/src/WorkerShutdown.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,cAAc;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAsBD;;GAEG;AACH,iBAAe,QAAQ,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDrE;AAED;;GAEG;AACH,iBAAS,wBAAwB,IAAI,IAAI,CA8DxC;AAED;;GAEG;AACH,iBAAS,0BAA0B,IAAI,IAAI,CAiB1C;AAED;;GAEG;AACH,iBAAS,cAAc,IAAI,OAAO,CAEjC;AAED;;GAEG;AACH,iBAAS,gBAAgB,IAAI,QAAQ,CAAC,cAAc,CAAC,CAEpD;AAMD,eAAO,MAAM,cAAc;IACzB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;EAEH,CAAC"}