@zintrust/workers 0.1.31 → 0.1.43

package/dist/WorkerInit.js

@@ -7,10 +7,11 @@
  * - Sets up auto-scaling and health checks
  * - Ensures graceful startup and shutdown
  */
-import { Env, Logger, workersConfig } from '@zintrust/core';
+import { Env, Logger } from '@zintrust/core';
 import { ResourceMonitor } from './ResourceMonitor';
 import { WorkerFactory } from './WorkerFactory';
 import { WorkerShutdown } from './WorkerShutdown';
+import { keyPrefix } from './config/workerConfig';
 // ============================================================================
 // State
 // ============================================================================
@@ -50,6 +51,19 @@ function initializeResourceMonitoring(enableResourceMonitoring, resourceMonitori
     }
     return false;
 }
+const getPersistenceOverride = (driver) => {
+    if (driver === 'redis') {
+        return { driver: 'redis', keyPrefix: keyPrefix() };
+    }
+    if (driver === 'memory') {
+        return { driver: 'memory' };
+    }
+    return {
+        driver: 'database',
+        connection: Env.get('WORKER_PERSISTENCE_DB_CONNECTION', 'default') ?? 'default',
+        table: Env.get('WORKER_PERSISTENCE_TABLE', 'zintrust_workers') ?? 'zintrust_workers',
+    };
+};
 /**
  * Check if any workers have resource monitoring enabled
  */
@@ -65,6 +79,106 @@ function shouldStartResourceMonitoring() {
         return false;
     }
 }
+const resolveAutoStartCandidates = (records) => {
+    return records.filter((record) => record.activeStatus !== false && record.autoStart === true);
+};
+const resolvePersistenceTargets = () => {
+    const configuredDriver = (Env.get('WORKER_PERSISTENCE_DRIVER', 'memory') || '')
+        .toLowerCase()
+        .trim();
+    const targets = configuredDriver === 'database'
+        ? [
+            { source: 'database', persistenceOverride: getPersistenceOverride('database') },
+            { source: 'redis', persistenceOverride: getPersistenceOverride('redis') },
+            { source: 'memory', persistenceOverride: { driver: 'memory' } },
+        ]
+        : [
+            { source: 'redis', persistenceOverride: getPersistenceOverride('redis') },
+            { source: 'memory', persistenceOverride: { driver: 'memory' } },
+        ];
+    // Sort so the configured driver comes first (priority)
+    return targets.sort((a, b) => {
+        const aIsConfigured = a.persistenceOverride.driver === configuredDriver;
+        const bIsConfigured = b.persistenceOverride.driver === configuredDriver;
+        if (aIsConfigured && !bIsConfigured)
+            return -1;
+        if (!aIsConfigured && bIsConfigured)
+            return 1;
+        return 0;
+    });
+};
+const collectAutoStartTasks = async () => {
+    const targets = resolvePersistenceTargets();
+    const tasks = [];
+    const seenWorkerNames = new Set();
+    for (const target of targets) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const records = await WorkerFactory.listPersistedRecords(target.persistenceOverride);
+            const candidates = resolveAutoStartCandidates(records);
+            Logger.debug('Auto-start discovery', {
+                source: target.source,
+                totalRecords: records.length,
+                candidateCount: candidates.length,
+            });
+            for (const record of candidates) {
+                if (seenWorkerNames.has(record.name)) {
+                    Logger.warn(`Worker ${record.name} appears in multiple persistence stores; keeping first discovered source and skipping duplicate from ${target.source}.`);
+                    continue;
+                }
+                seenWorkerNames.add(record.name);
+                tasks.push({
+                    ...record,
+                    persistenceOverride: target.persistenceOverride,
+                    source: target.source,
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.warn(`Auto-start discovery failed for ${target.source} persistence: ${message}`);
+        }
+    }
+    return tasks;
+};
+const isWorkerTrulyRunning = async (name) => {
+    const existing = WorkerFactory.get(name);
+    if (!existing)
+        return false;
+    const workerLike = existing.worker;
+    const isRunning = typeof workerLike.isRunning === 'function'
+        ? await Promise.resolve(workerLike.isRunning())
+        : false;
+    const isPaused = typeof workerLike.isPaused === 'function' ? workerLike.isPaused() : false;
+    return isRunning && !isPaused;
+};
+const autoStartOneWorker = async (record) => {
+    const existing = WorkerFactory.get(record.name);
+    if (existing) {
+        try {
+            if (await isWorkerTrulyRunning(record.name)) {
+                return { name: record.name, started: false, skipped: true };
+            }
+            Logger.warn(`Worker ${record.name} was registered but not truly running. Restarting to recover from stale state.`);
+            await WorkerFactory.restart(record.name, record.persistenceOverride);
+            return { name: record.name, started: true, skipped: false };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.warn(`Auto-start recovery failed for worker ${record.name}: ${message}`);
+            return { name: record.name, started: false, skipped: false };
+        }
+    }
+    try {
+        await WorkerFactory.startFromPersisted(record.name, record.persistenceOverride);
+        return { name: record.name, started: true, skipped: false };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Logger.warn(`Auto-start failed for worker ${record.name}: ${message}`);
+        return { name: record.name, started: false, skipped: false };
+    }
+};
 /**
  * Initialize the worker management system
  */
@@ -113,54 +227,19 @@ async function initialize(options = {}) {
     }
 }
 async function autoStartPersistedWorkers() {
-    // Check if auto-start is enabled globally via environment variable
+    const envAutoStart = Env.getBool('WORKER_AUTO_START', false);
+    const shouldAutoStart = envAutoStart;
     Logger.debug('Auto-start check', {
-        envAutoStart: Env.getBool('WORKER_AUTO_START', false),
-        configAutoStart: workersConfig.defaultWorker?.autoStart,
+        envAutoStart,
+        shouldAutoStart,
     });
-    if (workersConfig.defaultWorker?.autoStart !== true) {
+    if (!shouldAutoStart) {
         Logger.debug('Auto-start disabled - WORKER_AUTO_START is not true');
         return;
     }
     try {
-        const records = await WorkerFactory.listPersistedRecords();
-        Logger.debug('Found persisted records', {
-            count: records.length,
-            records: records.map((r) => ({ name: r.name, autoStart: r.autoStart })),
-        });
-        const candidates = records.filter((record) => {
-            if (record.activeStatus === false) {
-                return false;
-            }
-            // If autoStart is explicitly true, always include
-            if (record.autoStart === true) {
-                return true;
-            }
-            // If autoStart is null or undefined and global auto-start is enabled, include
-            if ((record.autoStart === null || record.autoStart === undefined) &&
-                workersConfig.defaultWorker?.autoStart === true) {
-                return true;
-            }
-            return false;
-        });
-        Logger.debug('Auto-start candidates', {
-            count: candidates.length,
-            candidates: candidates.map((c) => c.name),
-        });
-        const results = await Promise.all(candidates.map(async (record) => {
-            if (WorkerFactory.get(record.name)) {
-                return { name: record.name, started: false, skipped: true };
-            }
-            try {
-                await WorkerFactory.startFromPersisted(record.name);
-                return { name: record.name, started: true, skipped: false };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                Logger.warn(`Auto-start failed for worker ${record.name}: ${message}`);
-                return { name: record.name, started: false, skipped: false };
-            }
-        }));
+        const candidates = await collectAutoStartTasks();
+        const results = await Promise.all(candidates.map(async (record) => autoStartOneWorker(record)));
         const startedCount = results.filter((item) => item.started).length;
         const skippedCount = results.filter((item) => item.skipped).length;
         Logger.info('Auto-started persisted workers', {

package/dist/WorkerMetrics.js

@@ -33,7 +33,11 @@ const getValidClient = async () => {
     if (!redisClient) {
         redisClient = createRedisConnection(cachedConfig);
     }
-    return redisClient;
+    const client = redisClient;
+    if (!client) {
+        throw ErrorFactory.createConnectionError('Failed to initialize Redis client');
+    }
+    return client;
 };
 /**
  * Helper: Get Redis key for metrics

package/dist/WorkerRegistry.js

@@ -11,6 +11,11 @@ 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
  */
@@ -38,6 +43,9 @@ const scheduleStoppedWorkerCleanup = (name) => {
             cleanupTimers.delete(name);
         }
     }, STOPPED_WORKER_CLEANUP_DELAY);
+    if (isUnrefableTimer(timer)) {
+        timer.unref();
+    }
     cleanupTimers.set(name, timer);
 };
 /**

package/dist/WorkerShutdown.d.ts

@@ -24,11 +24,6 @@ interface IShutdownState {
     startedAt: Date | null;
     reason: string | null;
 }
-type DurableShutdownState = {
-    shuttingDown: boolean;
-    startedAt?: string;
-    reason?: string;
-};
 /**
  * Perform graceful shutdown of all worker modules
  */
@@ -70,13 +65,5 @@ export declare const WorkerShutdown: Readonly<{
      * Get current shutdown state
      */
     getShutdownState: typeof getShutdownState;
-    /**
-     * Request shutdown via Durable Object (Workers)
-     */
-    requestDurableShutdown: (reason?: string) => Promise<boolean>;
-    /**
-     * Read shutdown state from Durable Object (Workers)
-     */
-    getDurableShutdownState: () => Promise<DurableShutdownState | null>;
 }>;
 export {};

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 { Cloudflare, Logger } from '@zintrust/core';
+import { Logger } from '@zintrust/core';
 import { WorkerFactory } from './WorkerFactory';
 // ============================================================================
 // Implementation
@@ -15,41 +15,6 @@ 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 = {};
 /**
@@ -217,12 +182,4 @@ 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,
 });