@zintrust/workers 0.4.3 → 0.4.27

package/src/dashboard/workers-api.ts

@@ -278,6 +278,10 @@ async function getWorkersFromMixedPersistence(
       ...transformToWorkerData(redisRecords, 'redis'),
     ];
 
+    if (workers.length === 0) {
+      return getWorkersFromFileFallback(limit, query.includeInactive === true);
+    }
+
     return {
       workers,
       total:
@@ -312,6 +316,11 @@ async function getWorkersFromSinglePersistence(
       { driver: normalizedDriver },
       { offset, limit, includeInactive: query.includeInactive }
     );
+
+    if (driverRecords.length === 0) {
+      return getWorkersFromFileFallback(limit, query.includeInactive === true);
+    }
+
     const workers = transformToWorkerData(driverRecords, normalizedDriver);
 
     return {
@@ -333,6 +342,35 @@ async function getWorkersFromSinglePersistence(
   }
 }
 
+async function getWorkersFromFileFallback(
+  limit: number,
+  includeInactive: boolean
+): Promise<PersistenceResult> {
+  try {
+    const discovered = await WorkerFactory.listFileBackedRecords();
+    const filtered = includeInactive
+      ? discovered
+      : discovered.filter((record) => record.activeStatus !== false);
+
+    return {
+      workers: transformToWorkerData(filtered, 'memory'),
+      total: filtered.length,
+      drivers: getAvailableDriversFromDrivers(['memory']),
+      effectiveLimit: limit,
+      prePaginated: false,
+    };
+  } catch (error) {
+    Logger.debug('File-backed worker fallback failed', error);
+    return {
+      workers: [],
+      total: 0,
+      drivers: getAvailableDriversFromDrivers(['memory']),
+      effectiveLimit: limit,
+      prePaginated: false,
+    };
+  }
+}
+
 const normalizeDriver = (driver: string): WorkerDriver => {
   if (driver === 'db' || driver === 'database') return 'database';
   if (driver === 'redis') return 'redis';
@@ -527,17 +565,17 @@ async function getQueueData(): Promise<QueueData> {
     // Get queue statistics based on QUEUE_DRIVER
     switch (queueDriver) {
       case 'redis':
-        return getRedisQueueData();
+        return await getRedisQueueData();
       case 'database':
-        return getDatabaseQueueData();
+        return await getDatabaseQueueData();
       case 'db':
-        return getDatabaseQueueData();
+        return await getDatabaseQueueData();
       default:
-        return getMemoryQueueData();
+        return await getMemoryQueueData();
     }
   } catch (error) {
     Logger.error('Error fetching queue data:', error);
-    return getMemoryQueueData();
+    return await getMemoryQueueData();
   }
 }
 
@@ -603,7 +641,12 @@ async function getDatabaseQueueData(): Promise<QueueData> {
     const db = await useEnsureDbConnected();
 
     // Get queue statistics from actual database tables using proper query builder
-    const queueStats = (await db
+    const queueStats: {
+      totalQueues: number;
+      totalJobs: number;
+      processingJobs: number;
+      failedJobs: number;
+    } | null = await db
       .table('queue_jobs')
       .select('COUNT(DISTINCT queue) as totalQueues')
       .selectAs('COUNT(*)', 'totalJobs')
@@ -612,12 +655,7 @@ async function getDatabaseQueueData(): Promise<QueueData> {
         'processingJobs'
       )
       .selectAs('SUM(CASE WHEN failed_at IS NOT NULL THEN 1 ELSE 0 END)', 'failedJobs')
-      .first()) as {
-      totalQueues: number;
-      totalJobs: number;
-      processingJobs: number;
-      failedJobs: number;
-    } | null;
+      .first();
 
     const stats = queueStats || {
       totalQueues: 0,
@@ -733,7 +771,9 @@ async function enrichWithDetails(workers: WorkerData[]): Promise<WorkerData[]> {
 async function buildWorkerDetails(worker: WorkerData): Promise<WorkerData> {
   try {
     const persistenceOverride = resolvePersistenceOverride(worker.driver);
-    const persisted = await WorkerFactory.getPersisted(worker.name, persistenceOverride);
+    const persisted =
+      (await WorkerFactory.getPersisted(worker.name, persistenceOverride)) ??
+      (await WorkerFactory.getFileBackedRecord(worker.name));
     const health = await getWorkerHealthSnapshot(worker.name, worker.health);
     const metrics = await getWorkerMetricsSnapshot(worker.name, worker);
     const configuration = buildWorkerConfiguration(worker, persisted);
@@ -896,6 +936,13 @@ export async function getWorkerDetails(name: string, driver?: string): Promise<W
     }
   }
 
+  if (!worker) {
+    const fileBacked = await WorkerFactory.getFileBackedRecord(name);
+    if (fileBacked) {
+      worker = buildWorkerFromRecord(fileBacked, 'memory');
+    }
+  }
+
   if (!worker) {
     throw ErrorFactory.createWorkerError(`Worker ${name} not found`);
   }

package/src/index.ts

@@ -44,7 +44,12 @@ export type {
   WorkerFactoryConfig,
   WorkerPersistenceConfig,
 } from './WorkerFactory';
-export { WorkerInit } from './WorkerInit';
+export {
+  buildFileBackedAutoStartTasks,
+  selectAutoStartNames,
+  selectAutoStartTasks,
+  WorkerInit,
+} from './WorkerInit';
 export { WorkerShutdown } from './WorkerShutdown';
 
 // HTTP Controllers & Routes

package/src/register.ts

@@ -1,9 +1,12 @@
-import type { CliCommandProvider } from '@zintrust/core/cli';
-
 type Registry = {
   register: (id: string, provider: CliCommandProvider) => void;
 };
 
+type CliCommandProvider = {
+  getCommand: () => unknown;
+  name?: string;
+};
+
 type WorkerCommandsModule = {
   WorkerCommands: {
     createWorkerListCommand: () => CliCommandProvider;
@@ -17,7 +20,12 @@ type WorkerCommandsModule = {
 };
 
 const commandModule = (await (async (): Promise<WorkerCommandsModule> => {
-  return (await import('@zintrust/core/cli')) as unknown as WorkerCommandsModule;
+  const workerCommandsSpecifier = '@zintrust/core/worker-commands';
+  try {
+    return (await import(workerCommandsSpecifier)) as unknown as WorkerCommandsModule;
+  } catch {
+    return (await import('@zintrust/core/cli')) as unknown as WorkerCommandsModule;
+  }
 })()) satisfies WorkerCommandsModule;
 
 const getWorkerProviders = (): Array<[string, CliCommandProvider]> => {
@@ -56,12 +64,12 @@ registerWorkerCliCommands({
 });
 
 try {
-  const core = (await import('@zintrust/core/cli')) as unknown as {
+  const coreCli = (await import('@zintrust/core/cli')) as unknown as {
     OptionalCliCommandRegistry?: Registry;
   };
 
-  if (core.OptionalCliCommandRegistry !== undefined) {
-    registerWorkerCliCommands(core.OptionalCliCommandRegistry);
+  if (coreCli.OptionalCliCommandRegistry !== undefined) {
+    registerWorkerCliCommands(coreCli.OptionalCliCommandRegistry);
   }
 } catch {
   // no-op