@zintrust/workers 0.4.43 → 0.4.50

package/dist/WorkerFactory.js

@@ -3,7 +3,8 @@
  * Central factory for creating workers with all advanced features
  * Sealed namespace for immutability
  */
-import { Cloudflare, createRedisConnection, databaseConfig, Env, ErrorFactory, generateUuid, getBullMQSafeQueueName, isFunction, isNonEmptyString, isObject, JobStateTracker, Logger, NodeSingletons, queueConfig, registerDatabasesFromRuntimeConfig, useEnsureDbConnected, workersConfig, ZintrustLang, } from '@zintrust/core';
+import * as ZintrustCoreModule from '@zintrust/core';
+import { Cloudflare, createRedisConnection, databaseConfig, DatabaseConnectionRegistry, Env, ErrorFactory, generateUuid, getBullMQSafeQueueName, isFunction, isNonEmptyString, isObject, JobStateTracker, Logger, NodeSingletons, queueConfig, registerDatabasesFromRuntimeConfig, useEnsureDbConnected, workersConfig, ZintrustLang, } from '@zintrust/core';
 import { Worker } from 'bullmq';
 import { AutoScaler } from './AutoScaler.js';
 import { CanaryController } from './CanaryController.js';
@@ -34,6 +35,52 @@ const canUseProjectFileImports = () => typeof NodeSingletons?.fs?.writeFileSync
     typeof NodeSingletons?.fs?.existsSync === 'function' &&
     typeof NodeSingletons?.url?.pathToFileURL === 'function' &&
     typeof NodeSingletons?.path?.join === 'function';
+const getProcessorPackageBridgeGlobal = () => {
+    return globalThis;
+};
+const isValidBridgeExportName = (value) => {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(value);
+};
+const resolveRuntimeBridgeModule = (specifier) => {
+    if (specifier === '@zintrust/core') {
+        return ZintrustCoreModule;
+    }
+    return null;
+};
+const resolveRuntimeBridgeUrl = (specifier) => {
+    if (!isNodeRuntime() || !canUseProjectFileImports())
+        return null;
+    const bridgeModule = resolveRuntimeBridgeModule(specifier);
+    if (bridgeModule === null)
+        return null;
+    const dir = ensureProcessorSpecDir();
+    if (dir === null)
+        return null;
+    const bridgeGlobal = getProcessorPackageBridgeGlobal();
+    bridgeGlobal.__zintrustProcessorPackageBridges__ ??= new Map();
+    bridgeGlobal.__zintrustProcessorPackageBridges__.set(specifier, bridgeModule);
+    const safeName = specifier.replaceAll('@', '').replaceAll('/', '-');
+    const filePath = path.join(dir, `${safeName}.bridge.mjs`);
+    const exportLines = Object.keys(bridgeModule)
+        .filter((key) => key !== 'default' && isValidBridgeExportName(key))
+        .sort((a, b) => a.localeCompare(b))
+        .map((key) => `export const ${key} = bridge[${JSON.stringify(key)}];`);
+    const code = [
+        'const bridgeMap = globalThis.__zintrustProcessorPackageBridges__;',
+        `const bridge = bridgeMap?.get(${JSON.stringify(specifier)}) ?? {};`,
+        'export default bridge;',
+        ...exportLines,
+        '',
+    ].join('\n');
+    try {
+        NodeSingletons.fs.writeFileSync(filePath, code, 'utf8');
+        return NodeSingletons.url.pathToFileURL(filePath).href;
+    }
+    catch (error) {
+        Logger.debug(`Failed to write processor bridge for ${specifier}`, error);
+        return null;
+    }
+};
 const buildCandidatesForSpecifier = (specifier, root) => {
     if (specifier === '@zintrust/core') {
         return [
@@ -80,6 +127,9 @@ const resolveLocalPackageFallback = (specifier) => {
 const resolvePackageSpecifierUrl = (specifier) => {
     if (!isNodeRuntime() || !canUseProjectFileImports())
         return null;
+    const bridgeUrl = resolveRuntimeBridgeUrl(specifier);
+    if (bridgeUrl)
+        return bridgeUrl;
     if (typeof NodeSingletons?.module?.createRequire !== 'function') {
         return resolveLocalPackageFallback(specifier);
     }
@@ -1494,19 +1544,25 @@ const resolvePersistenceConfig = (config) => {
     throw ErrorFactory.createConfigError('WORKER_PERSISTENCE_DRIVER must be one of memory, redis, or database');
 };
 const resolveDbClientFromEnv = async (connectionName = 'default') => {
-    const connect = async () => await useEnsureDbConnected(undefined, connectionName);
-    try {
-        return await connect();
-    }
-    catch (error) {
-        Logger.error('Worker persistence failed to resolve database connection', error);
+    // Eagerly populate the registry when the requested connection is not yet
+    // registered.  On both the Cloudflare Workers runtime and Node, the registry
+    // may be empty when called from the workers-persistence path because
+    // registerDatabasesFromRuntimeConfig has not yet run for this connection. The
+    // old pattern of connecting first (which always fails) then registering as a
+    // fallback produced spurious [DEBUG] noise on every fresh start.
+    if (DatabaseConnectionRegistry.get(connectionName) === undefined) {
+        try {
+            registerDatabasesFromRuntimeConfig(databaseConfig);
+        }
+        catch (registrationError) {
+            Logger.warn(`[WorkerPersistence] Runtime database registration failed for connection '${connectionName}'`, registrationError);
+        }
     }
     try {
-        registerDatabasesFromRuntimeConfig(databaseConfig);
-        return await connect();
+        return await useEnsureDbConnected(undefined, connectionName);
     }
     catch (error) {
-        Logger.error('Worker persistence failed after registering runtime databases', error);
+        Logger.error('Worker persistence failed to resolve database connection', error);
         throw ErrorFactory.createConfigError(`Worker persistence requires a database client. Register connection '${connectionName}' or pass infrastructure.persistence.client.`);
     }
 };

package/dist/dashboard/workers-api.js

@@ -457,6 +457,12 @@ async function getRedisQueueData() {
             throw ErrorFactory.createConfigError('Redis driver not configured');
         }
         const monitor = QueueMonitor.create({
+            knownQueues: async () => {
+                const records = await WorkerFactory.listPersistedRecords();
+                return Array.from(new Set(records
+                    .map((record) => record.queueName)
+                    .filter((queueName) => typeof queueName === 'string'))).sort((left, right) => left.localeCompare(right));
+            },
             redis: {
                 host: redisConfig.host || 'localhost',
                 port: redisConfig.port || 6379,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/workers",
-  "version": "0.4.43",
+  "version": "0.4.50",
   "description": "Worker orchestration and background job management for ZinTrust.",
   "private": false,
   "type": "module",
@@ -40,7 +40,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.4.43",
+    "@zintrust/core": ">=0.4.0 <0.5.0",
     "@zintrust/queue-monitor": "*",
     "@zintrust/queue-redis": "*"
   },
@@ -73,4 +73,4 @@
     "prom-client": "^15.1.3",
     "simple-statistics": "^7.8.9"
   }
-}
+}

package/src/WorkerFactory.ts

@@ -4,10 +4,12 @@
  * Sealed namespace for immutability
  */
 
+import * as ZintrustCoreModule from '@zintrust/core';
 import {
   Cloudflare,
   createRedisConnection,
   databaseConfig,
+  DatabaseConnectionRegistry,
   Env,
   ErrorFactory,
   generateUuid,
@@ -55,6 +57,10 @@ import {
 
 const path = NodeSingletons.path;
 
+type ProcessorPackageBridgeGlobal = typeof globalThis & {
+  __zintrustProcessorPackageBridges__?: Map<string, Record<string, unknown>>;
+};
+
 const isNodeRuntime = (): boolean =>
   typeof process !== 'undefined' && Boolean(process.versions?.node);
 
@@ -70,6 +76,59 @@ const canUseProjectFileImports = (): boolean =>
   typeof NodeSingletons?.url?.pathToFileURL === 'function' &&
   typeof NodeSingletons?.path?.join === 'function';
 
+const getProcessorPackageBridgeGlobal = (): ProcessorPackageBridgeGlobal => {
+  return globalThis as ProcessorPackageBridgeGlobal;
+};
+
+const isValidBridgeExportName = (value: string): boolean => {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(value);
+};
+
+const resolveRuntimeBridgeModule = (specifier: string): Record<string, unknown> | null => {
+  if (specifier === '@zintrust/core') {
+    return ZintrustCoreModule as Record<string, unknown>;
+  }
+
+  return null;
+};
+
+const resolveRuntimeBridgeUrl = (specifier: string): string | null => {
+  if (!isNodeRuntime() || !canUseProjectFileImports()) return null;
+
+  const bridgeModule = resolveRuntimeBridgeModule(specifier);
+  if (bridgeModule === null) return null;
+
+  const dir = ensureProcessorSpecDir();
+  if (dir === null) return null;
+
+  const bridgeGlobal = getProcessorPackageBridgeGlobal();
+  bridgeGlobal.__zintrustProcessorPackageBridges__ ??= new Map<string, Record<string, unknown>>();
+  bridgeGlobal.__zintrustProcessorPackageBridges__.set(specifier, bridgeModule);
+
+  const safeName = specifier.replaceAll('@', '').replaceAll('/', '-');
+  const filePath = path.join(dir, `${safeName}.bridge.mjs`);
+  const exportLines = Object.keys(bridgeModule)
+    .filter((key) => key !== 'default' && isValidBridgeExportName(key))
+    .sort((a, b) => a.localeCompare(b))
+    .map((key) => `export const ${key} = bridge[${JSON.stringify(key)}];`);
+
+  const code = [
+    'const bridgeMap = globalThis.__zintrustProcessorPackageBridges__;',
+    `const bridge = bridgeMap?.get(${JSON.stringify(specifier)}) ?? {};`,
+    'export default bridge;',
+    ...exportLines,
+    '',
+  ].join('\n');
+
+  try {
+    NodeSingletons.fs.writeFileSync(filePath, code, 'utf8');
+    return NodeSingletons.url.pathToFileURL(filePath).href;
+  } catch (error) {
+    Logger.debug(`Failed to write processor bridge for ${specifier}`, error);
+    return null;
+  }
+};
+
 const buildCandidatesForSpecifier = (specifier: string, root: string): string[] => {
   if (specifier === '@zintrust/core') {
     return [
@@ -117,6 +176,10 @@ const resolveLocalPackageFallback = (specifier: string): string | null => {
 
 const resolvePackageSpecifierUrl = (specifier: string): string | null => {
   if (!isNodeRuntime() || !canUseProjectFileImports()) return null;
+
+  const bridgeUrl = resolveRuntimeBridgeUrl(specifier);
+  if (bridgeUrl) return bridgeUrl;
+
   if (typeof NodeSingletons?.module?.createRequire !== 'function') {
     return resolveLocalPackageFallback(specifier);
   }
@@ -2164,20 +2227,27 @@ const resolvePersistenceConfig = (
 };
 
 const resolveDbClientFromEnv = async (connectionName = 'default'): Promise<IDatabase> => {
-  const connect = async (): Promise<IDatabase> =>
-    await useEnsureDbConnected(undefined, connectionName);
-
-  try {
-    return await connect();
-  } catch (error) {
-    Logger.error('Worker persistence failed to resolve database connection', error);
+  // Eagerly populate the registry when the requested connection is not yet
+  // registered.  On both the Cloudflare Workers runtime and Node, the registry
+  // may be empty when called from the workers-persistence path because
+  // registerDatabasesFromRuntimeConfig has not yet run for this connection. The
+  // old pattern of connecting first (which always fails) then registering as a
+  // fallback produced spurious [DEBUG] noise on every fresh start.
+  if (DatabaseConnectionRegistry.get(connectionName) === undefined) {
+    try {
+      registerDatabasesFromRuntimeConfig(databaseConfig);
+    } catch (registrationError) {
+      Logger.warn(
+        `[WorkerPersistence] Runtime database registration failed for connection '${connectionName}'`,
+        registrationError
+      );
+    }
   }
 
   try {
-    registerDatabasesFromRuntimeConfig(databaseConfig);
-    return await connect();
+    return await useEnsureDbConnected(undefined, connectionName);
   } catch (error) {
-    Logger.error('Worker persistence failed after registering runtime databases', error);
+    Logger.error('Worker persistence failed to resolve database connection', error);
     throw ErrorFactory.createConfigError(
       `Worker persistence requires a database client. Register connection '${connectionName}' or pass infrastructure.persistence.client.`
     );

package/src/dashboard/workers-api.ts

@@ -591,6 +591,16 @@ async function getRedisQueueData(): Promise<QueueData> {
     }
 
     const monitor = QueueMonitor.create({
+      knownQueues: async () => {
+        const records = await WorkerFactory.listPersistedRecords();
+        return Array.from(
+          new Set(
+            records
+              .map((record) => record.queueName)
+              .filter((queueName) => typeof queueName === 'string')
+          )
+        ).sort((left, right) => left.localeCompare(right));
+      },
       redis: {
         host: redisConfig.host || 'localhost',
         port: redisConfig.port || 6379,

package/src/types/queue-monitor.d.ts

@@ -24,6 +24,9 @@ declare module '@zintrust/queue-monitor' {
     autoRefresh?: boolean;
     refreshIntervalMs?: number;
     redis?: Record<string, unknown>;
+    knownQueues?:
+      | ReadonlyArray<string>
+      | (() => Promise<ReadonlyArray<string>> | ReadonlyArray<string>);
   };
 
   export type QueueMonitorApi = {