@zintrust/workers 0.1.28 → 0.1.30

package/dist/WorkerShutdown.js

@@ -4,7 +4,7 @@
  * Centralized graceful shutdown handling for the worker management system.
  * Coordinates orderly shutdown of all worker modules and the WorkerFactory.
  */
-import { Logger } from '@zintrust/core';
+import { Cloudflare, Logger } from '@zintrust/core';
 import { WorkerFactory } from './WorkerFactory';
 // ============================================================================
 // Implementation
@@ -15,7 +15,43 @@ const state = {
     startedAt: null,
     reason: null,
 };
+const getDurableShutdownStub = () => {
+    const env = Cloudflare.getWorkersEnv();
+    if (env === null)
+        return null;
+    const namespace = env['WORKER_SHUTDOWN'];
+    if (!namespace ||
+        typeof namespace.idFromName !== 'function' ||
+        typeof namespace.get !== 'function') {
+        return null;
+    }
+    const id = namespace.idFromName('zintrust-shutdown');
+    return namespace.get(id) ?? null;
+};
+const requestDurableShutdown = async (reason = 'manual') => {
+    const stub = getDurableShutdownStub();
+    if (!stub) {
+        Logger.warn('Worker shutdown Durable Object binding not configured');
+        return false;
+    }
+    const res = await stub.fetch('https://worker-shutdown/shutdown', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ reason }),
+    });
+    return res.ok;
+};
+const getDurableShutdownState = async () => {
+    const stub = getDurableShutdownStub();
+    if (!stub)
+        return null;
+    const res = await stub.fetch('https://worker-shutdown/status');
+    if (!res.ok)
+        return null;
+    return (await res.json());
+};
 let shutdownHandlersRegistered = false;
+const signalHandlers = {};
 /**
  * Perform graceful shutdown of all worker modules
  */
@@ -72,7 +108,7 @@ function registerShutdownHandlers() {
     }
     Logger.debug('Registering worker management system shutdown handlers');
     // SIGTERM - graceful shutdown (Docker, systemd, etc.)
-    process.on('SIGTERM', async () => {
+    signalHandlers.sigterm = async () => {
         Logger.info('📨 Received SIGTERM signal');
         try {
             await shutdown({ signal: 'SIGTERM', timeout: 30000, forceExit: true });
@@ -80,7 +116,8 @@ function registerShutdownHandlers() {
         catch (error) {
             Logger.error('Error during SIGTERM shutdown', error);
         }
-    });
+    };
+    process.on('SIGTERM', signalHandlers.sigterm);
     // SIGINT - user interrupt (Ctrl+C) - REMOVED: handled by bootstrap.ts to prevent race condition
     // process.on('SIGINT', async () => {
     //   Logger.info('📨 Received SIGINT signal');
@@ -91,7 +128,7 @@ function registerShutdownHandlers() {
     //   }
     // });
     // SIGHUP - terminal closed
-    process.on('SIGHUP', async () => {
+    signalHandlers.sighup = async () => {
         Logger.info('📨 Received SIGHUP signal');
         try {
             await shutdown({ signal: 'SIGHUP', timeout: 30000, forceExit: true });
@@ -99,9 +136,10 @@ function registerShutdownHandlers() {
         catch (error) {
             Logger.error('Error during SIGHUP shutdown', error);
         }
-    });
+    };
+    process.on('SIGHUP', signalHandlers.sighup);
     // Handle uncaught errors during shutdown
-    process.on('uncaughtException', async (error) => {
+    signalHandlers.uncaughtException = async (error) => {
         Logger.error('💥 Uncaught exception during worker operations', error);
         try {
             await shutdown({ signal: 'uncaughtException', timeout: 10000, forceExit: true });
@@ -110,16 +148,39 @@ function registerShutdownHandlers() {
             // Ignore errors during emergency shutdown
         }
         process.exit(1);
-    });
-    process.on('unhandledRejection', (reason) => {
+    };
+    process.on('uncaughtException', signalHandlers.uncaughtException);
+    signalHandlers.unhandledRejection = (reason) => {
         // Only log the error - don't shut down the entire application
         Logger.error('💥 Unhandled promise rejection detected', reason);
         Logger.warn('⚠️  This error has been logged but will not shut down the server');
         Logger.warn('⚠️  Check the error context and fix the underlying issue');
-    });
+    };
+    process.on('unhandledRejection', signalHandlers.unhandledRejection);
     shutdownHandlersRegistered = true;
     Logger.debug('Worker management system shutdown handlers registered');
 }
+/**
+ * Unregister process signal handlers (for hot reload/testing)
+ */
+function unregisterShutdownHandlers() {
+    if (!shutdownHandlersRegistered)
+        return;
+    if (signalHandlers.sigterm)
+        process.off('SIGTERM', signalHandlers.sigterm);
+    if (signalHandlers.sighup)
+        process.off('SIGHUP', signalHandlers.sighup);
+    if (signalHandlers.uncaughtException)
+        process.off('uncaughtException', signalHandlers.uncaughtException);
+    if (signalHandlers.unhandledRejection)
+        process.off('unhandledRejection', signalHandlers.unhandledRejection);
+    signalHandlers.sigterm = undefined;
+    signalHandlers.sighup = undefined;
+    signalHandlers.uncaughtException = undefined;
+    signalHandlers.unhandledRejection = undefined;
+    shutdownHandlersRegistered = false;
+    Logger.debug('Worker management system shutdown handlers unregistered');
+}
 /**
  * Check if system is currently shutting down
  */
@@ -144,6 +205,10 @@ export const WorkerShutdown = Object.freeze({
      * Register process signal handlers for graceful shutdown
      */
     registerShutdownHandlers,
+    /**
+     * Unregister process signal handlers (for hot reload/testing)
+     */
+    unregisterShutdownHandlers,
     /**
      * Check if system is currently shutting down
      */
@@ -152,4 +217,12 @@ export const WorkerShutdown = Object.freeze({
      * Get current shutdown state
      */
     getShutdownState,
+    /**
+     * Request shutdown via Durable Object (Workers)
+     */
+    requestDurableShutdown,
+    /**
+     * Read shutdown state from Durable Object (Workers)
+     */
+    getDurableShutdownState,
 });

package/dist/WorkerShutdownDurableObject.d.ts

@@ -0,0 +1,12 @@
+type DurableObjectState = {
+    storage: {
+        get: (key: string) => Promise<unknown>;
+        put: (key: string, value: unknown) => Promise<void>;
+    };
+};
+export declare class ZinTrustWorkerShutdownDurableObject {
+    private readonly state;
+    constructor(state: DurableObjectState);
+    fetch(request: Request): Promise<Response>;
+}
+export {};

package/dist/WorkerShutdownDurableObject.js

@@ -0,0 +1,41 @@
+import { Logger } from '@zintrust/core';
+const loadState = async (state) => {
+    const stored = (await state.storage.get('shutdown'));
+    return stored ?? { shuttingDown: false };
+};
+const saveState = async (state, value) => {
+    await state.storage.put('shutdown', value);
+};
+// eslint-disable-next-line no-restricted-syntax
+export class ZinTrustWorkerShutdownDurableObject {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        const path = url.pathname;
+        if (request.method === 'GET' && path === '/status') {
+            const current = await loadState(this.state);
+            return new Response(JSON.stringify(current), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            });
+        }
+        if (request.method === 'POST' && path === '/shutdown') {
+            const payload = (await request.json().catch(() => ({})));
+            const next = {
+                shuttingDown: true,
+                startedAt: new Date().toISOString(),
+                reason: payload.reason ?? 'manual',
+            };
+            await saveState(this.state, next);
+            Logger.info('Worker shutdown requested via Durable Object', next);
+            return new Response(JSON.stringify({ ok: true }), {
+                status: 202,
+                headers: { 'content-type': 'application/json' },
+            });
+        }
+        return new Response('Not Found', { status: 404 });
+    }
+}