@zintrust/core 2.4.0 → 2.4.2

package/src/tools/redis/RedisTransport.js

@@ -2,7 +2,6 @@ import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { parseCustomHeadersFromEnv } from '../../orm/adapters/SqlProxyAdapterUtils.js';
-import { resolveProxyRpcService, } from '../../proxy/CloudflareProxyShared.js';
 import { SignedRequest } from '../../security/SignedRequest.js';
 const loggedSelections = new Set();
 const readEnvString = (key, fallback = '') => {
@@ -19,6 +18,20 @@ const readEnvBool = (key, fallback = false) => {
     const value = Env[key];
     return typeof value === 'boolean' ? value : fallback;
 };
+const readEnvInt = (key, fallback) => {
+    if (typeof Env.getInt === 'function') {
+        return Env.getInt(key, fallback);
+    }
+    const value = Env[key];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isNaN(parsed) ? fallback : parsed;
+    }
+    return fallback;
+};
 const resolveSigningPrefix = (baseUrl) => {
     try {
         const parsed = new URL(baseUrl);
@@ -56,20 +69,19 @@ const resolveProxyBaseUrl = () => {
         return explicit;
     return `http://${Env.REDIS_PROXY_HOST}:${Env.REDIS_PROXY_PORT}`;
 };
-const createRequestId = () => {
-    const crypto = globalThis.crypto;
-    if (typeof crypto?.randomUUID === 'function')
-        return crypto.randomUUID();
-    return `req_${Date.now()}_${Math.random().toString(16).slice(2)}`;
-};
-const resolveProxySettings = (_options) => ({
+const resolveProxySettings = () => ({
     baseUrl: resolveProxyBaseUrl(),
-    keyId: Env.get('REDIS_PROXY_KEY_ID').trim() === '' ? undefined : Env.get('REDIS_PROXY_KEY_ID'),
-    secret: Env.REDIS_PROXY_SECRET.trim() === '' ? undefined : Env.get('REDIS_PROXY_SECRET'),
+    keyId: Env.REDIS_PROXY_KEY_ID.trim() === '' ? undefined : Env.REDIS_PROXY_KEY_ID,
+    secret: Env.REDIS_PROXY_SECRET.trim() === '' ? undefined : Env.REDIS_PROXY_SECRET,
     timeoutMs: Env.REDIS_PROXY_TIMEOUT_MS,
-    service: resolveProxyRpcService('redis'),
     customHeaders: parseCustomHeadersFromEnv('REDIS'),
 });
+const isRedisRpcEnabled = () => readEnvBool('USE_REDIS_PROXY', false) && readEnvString('REDIS_RPC_URL', '').trim() !== '';
+const resolveRpcSettings = () => ({
+    baseUrl: readEnvString('REDIS_RPC_URL', '').trim(),
+    secret: readEnvString('REDIS_RPC_SECRET', readEnvString('REDIS_PROXY_SECRET', readEnvString('APP_KEY', ''))),
+    timeoutMs: readEnvInt('REDIS_RPC_TIMEOUT_MS', 30000),
+});
 const buildHeaders = async (settings, requestUrl, body) => {
     const headers = {
         'Content-Type': 'application/json',
@@ -90,17 +102,11 @@ const buildHeaders = async (settings, requestUrl, body) => {
     }
     return headers;
 };
-const requestProxyCommand = async (settings, action, payload) => {
+const requestProxyCommand = async (settings, command, args) => {
     if (settings.baseUrl.trim() === '') {
         throw ErrorFactory.createConfigError('Redis proxy URL is missing (REDIS_PROXY_URL)');
     }
-    const envelope = {
-        service: settings.service,
-        action,
-        requestId: createRequestId(),
-        payload,
-    };
-    const body = JSON.stringify(envelope);
+    const body = JSON.stringify({ command, args });
     const requestUrl = buildRequestUrl(settings.baseUrl, '/zin/redis/command');
     const headers = await buildHeaders(settings, requestUrl, body);
     const signal = typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal
@@ -114,33 +120,56 @@ const requestProxyCommand = async (settings, action, payload) => {
     });
     if (!response.ok) {
         const text = await response.text();
-        // Don't log HTML responses (e.g., 502 Bad Gateway pages)
-        const isHtml = text.trim().toLowerCase().startsWith('<!doctype html') ||
-            text.trim().toLowerCase().startsWith('<html');
-        const errorMessage = isHtml ? 'Non-JSON response from proxy (proxy may be unavailable)' : text;
-        throw ErrorFactory.createTryCatchError(`Redis proxy request failed (${response.status})`, errorMessage);
+        throw ErrorFactory.createTryCatchError(`Redis proxy request failed (${response.status})`, text);
     }
     const parsed = (await response.json());
     return parsed.result;
 };
-const loadScriptDefinition = async (settings, definition) => {
-    const loaded = await requestProxyCommand(settings, 'SCRIPT', {
-        args: ['LOAD', definition.lua],
-    });
-    return loaded;
-};
-const getDefinedScriptSha = async (settings, registry, command) => {
-    const cached = registry.shaByCommand.get(command);
-    if (cached !== undefined) {
-        return cached;
+const requestRpcMethod = async (settings, method, payload) => {
+    if (settings.baseUrl.trim() === '') {
+        throw ErrorFactory.createConfigError('Redis RPC URL is missing. Set USE_REDIS_PROXY=true and REDIS_RPC_URL.');
     }
-    const definition = registry.definitions.get(command);
-    if (definition === undefined) {
-        return undefined;
+    const url = new URL('/rpc', settings.baseUrl);
+    const body = JSON.stringify({
+        service: 'redis',
+        method,
+        payload,
+    });
+    const signal = typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal
+        ? AbortSignal.timeout(settings.timeoutMs)
+        : undefined;
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(settings.secret !== undefined && settings.secret.trim() !== ''
+                ? { 'x-redis-rpc-secret': settings.secret }
+                : {}),
+        },
+        body,
+        signal,
+    });
+    const parsed = (await response.json());
+    if (!response.ok || parsed.ok !== true) {
+        const errorMessage = parsed.error?.message;
+        throw ErrorFactory.createTryCatchError(typeof errorMessage === 'string' && errorMessage.trim() !== ''
+            ? errorMessage
+            : `Redis RPC request failed (${response.status})`, parsed.error?.details);
     }
-    const sha = await loadScriptDefinition(settings, definition);
-    registry.shaByCommand.set(command, sha);
-    return sha;
+    return parsed.result;
+};
+const requestRpcCommand = async (settings, command, args) => requestRpcMethod(settings, 'call', { args: [command, ...args] });
+const requestRpcPipeline = async (settings, commands, transaction) => {
+    const results = await requestRpcMethod(settings, transaction ? 'multi' : 'pipeline', { commands, transaction });
+    return results.map(([error, result]) => [
+        error === null ? null : ErrorFactory.createTryCatchError(error),
+        result,
+    ]);
+};
+const requestRedisCommand = async (mode, settings, command, args) => {
+    return mode === 'rpc'
+        ? requestRpcCommand(settings, command, args)
+        : requestProxyCommand(settings, command, args);
 };
 const logTransportSelection = (mode, config, options) => {
     const rawSubsystem = options?.subsystem?.trim();
@@ -157,6 +186,7 @@ const logTransportSelection = (mode, config, options) => {
         host: mode === 'direct' ? config.host : undefined,
         port: mode === 'direct' ? config.port : undefined,
         proxyUrl: mode === 'proxy' ? resolveProxyBaseUrl() : undefined,
+        rpcUrl: mode === 'rpc' ? readEnvString('REDIS_RPC_URL', '') : undefined,
     });
 };
 const normalizeScanResponse = (value) => {
@@ -169,7 +199,7 @@ const normalizeScanResponse = (value) => {
         : [];
     return [cursor, batch];
 };
-const createScanStream = (settings, options) => {
+const createScanStream = (settings, mode, options) => {
     const handlers = new Map();
     const stream = {
         on(event, handler) {
@@ -201,9 +231,13 @@ const createScanStream = (settings, options) => {
                 let cursor = '0';
                 do {
                     // eslint-disable-next-line no-await-in-loop
-                    const result = await requestProxyCommand(settings, 'SCAN', {
-                        args: [cursor, 'MATCH', options?.match ?? '*', 'COUNT', String(options?.count ?? 200)],
-                    });
+                    const result = await requestRedisCommand(mode, settings, 'SCAN', [
+                        cursor,
+                        'MATCH',
+                        options?.match ?? '*',
+                        'COUNT',
+                        String(options?.count ?? 200),
+                    ]);
                     const [nextCursor, batch] = normalizeScanResponse(result);
                     cursor = nextCursor;
                     if (batch.length > 0) {
@@ -219,19 +253,18 @@ const createScanStream = (settings, options) => {
     });
     return stream;
 };
-const createPipeline = (settings) => {
+const createPipeline = (settings, mode, transaction = false) => {
     const commands = [];
     const target = {
         async exec() {
-            Logger.debug('[redis][proxy][pipeline] Executing pipeline', {
-                commandCount: commands.length,
-                commands: commands.map((c) => ({ command: c.command, argsCount: c.args.length })),
-            });
+            if (mode === 'rpc') {
+                return requestRpcPipeline(settings, commands, transaction);
+            }
             const results = [];
             for (const entry of commands) {
                 try {
                     // eslint-disable-next-line no-await-in-loop
-                    const result = await requestProxyCommand(settings, entry.command, { args: entry.args });
+                    const result = await requestRedisCommand(mode, settings, entry.command, entry.args);
                     results.push([null, result]);
                 }
                 catch (error) {
@@ -245,14 +278,6 @@ const createPipeline = (settings) => {
             }
             return results;
         },
-        runCommand(name, args) {
-            Logger.debug('[redis][proxy][pipeline] runCommand called in pipeline', {
-                commandName: name,
-                argsCount: args.length,
-            });
-            commands.push({ command: name, args });
-            return pipeline;
-        },
     };
     const pipeline = new Proxy(target, {
         get(obj, prop) {
@@ -261,7 +286,7 @@ const createPipeline = (settings) => {
             if (prop in obj)
                 return Reflect.get(obj, prop);
             return (...args) => {
-                commands.push({ command: prop, args });
+                commands.push({ command: prop.toUpperCase(), args });
                 return pipeline;
             };
         },
@@ -269,120 +294,63 @@ const createPipeline = (settings) => {
     return pipeline;
 };
 export const resolveRedisTransportMode = () => {
-    return readEnvBool('USE_REDIS_PROXY', false) || readEnvString('REDIS_PROXY_URL', '').trim() !== ''
-        ? 'proxy'
-        : 'direct';
+    if (isRedisRpcEnabled())
+        return 'rpc';
+    return readEnvBool('USE_REDIS_PROXY', false) ? 'proxy' : 'direct';
 };
-const createCommandFunction = (settings, command) => {
-    return async (...args) => requestProxyCommand(settings, command, { args });
-};
-const createDefinedScriptFunction = (settings, command, registry) => {
-    return async (...args) => {
-        const sha = await getDefinedScriptSha(settings, registry, command);
-        if (sha === undefined) {
-            return requestProxyCommand(settings, command, { args });
-        }
-        const definition = registry.definitions.get(command);
-        const numberOfKeys = definition?.numberOfKeys ?? 0;
-        return requestProxyCommand(settings, 'EVALSHA', {
-            args: [sha, numberOfKeys, ...args],
-        });
-    };
-};
-const createScriptsHandler = (settings) => {
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop !== 'string')
-                return undefined;
-            return async (...args) => requestProxyCommand(settings, prop, { args });
-        },
-    });
-};
-const handlePropertyAccess = (obj, prop, client, settings, registry) => {
-    if (typeof prop !== 'string')
-        return Reflect.get(obj, prop);
-    if (prop === 'then')
-        return undefined;
-    if (prop === 'setMaxListeners') {
-        return function (_count) {
-            return client;
-        };
-    }
-    if (prop === 'getMaxListeners') {
-        return function () {
-            return Infinity;
-        };
-    }
-    if (registry.definitions.has(prop)) {
-        return createDefinedScriptFunction(settings, prop, registry);
-    }
-    if (prop in obj) {
-        return Reflect.get(obj, prop);
+export const createRedisProxyConnection = (config, options) => {
+    const mode = resolveRedisTransportMode();
+    const settings = mode === 'rpc' ? resolveRpcSettings() : resolveProxySettings();
+    if (mode === 'direct') {
+        throw ErrorFactory.createConfigError('Redis proxy connection requested while direct mode is active.');
     }
-    return createCommandFunction(settings, prop);
-};
-const createProxyTarget = (config, options, settings, client, registry) => {
+    logTransportSelection(mode, config, options);
     const target = {
-        __bullmq_iredis: true,
-        isCluster: false,
-        options: Object.freeze({}),
         status: 'ready',
         connect: async () => { },
         // eslint-disable-next-line @typescript-eslint/require-await
         quit: async () => 'OK',
         disconnect: () => undefined,
-        duplicate: () => createRedisProxyConnection(config, options, registry),
-        defineCommand: (name, definition) => {
-            registry.definitions.set(name, definition);
-            registry.shaByCommand.delete(name);
-            Logger.debug('[redis][proxy][bullmq] registered defined command', {
-                commandName: name,
-                numberOfKeys: definition.numberOfKeys,
-                luaLength: definition.lua.length,
-            });
-        },
-        runCommand: async (name, args) => requestProxyCommand(settings, name, { args }),
-        on: (_event, _handler) => client ?? target,
-        once: (_event, _handler) => client ?? target,
-        off: (_event, _handler) => client ?? target,
-        removeListener: (_event, _handler) => client ?? target,
-        setMaxListeners: (_count) => client ?? target,
+        on: (_event, _handler) => client,
+        once: (_event, _handler) => client,
+        off: (_event, _handler) => client,
+        removeListener: (_event, _handler) => client,
+        setMaxListeners: (_count) => client,
         getMaxListeners: () => Infinity,
-        call: async (command, ...args) => requestProxyCommand(settings, command, { args }),
-        scripts: createScriptsHandler(settings),
-        pipeline: () => createPipeline(settings),
-        multi: () => createPipeline(settings),
-        scanStream: (scanOptions) => createScanStream(settings, scanOptions),
-    };
-    return target;
-};
-export const createRedisProxyConnection = (config, options, registry) => {
-    const settings = resolveProxySettings(options);
-    const scriptRegistry = registry ?? {
-        definitions: new Map(),
-        shaByCommand: new Map(),
+        call: async (command, ...args) => {
+            return requestRedisCommand(mode, settings, command, args);
+        },
+        pipeline: () => createPipeline(settings, mode),
+        multi: () => createPipeline(settings, mode, true),
+        scanStream: (scanOptions) => createScanStream(settings, mode, scanOptions),
     };
-    logTransportSelection('proxy', config, options);
-    Logger.info('[redis][proxy] Creating opaque proxy connection', {
-        transport: 'BullMQ',
-    });
-    const proxyTarget = createProxyTarget(config, options, settings, null, scriptRegistry);
-    const client = new Proxy(proxyTarget, {
+    const client = new Proxy(target, {
         get(obj, prop) {
-            return handlePropertyAccess(obj, prop, client, settings, scriptRegistry);
+            if (typeof prop !== 'string')
+                return Reflect.get(obj, prop);
+            if (prop === 'then')
+                return undefined;
+            if (prop === 'setMaxListeners') {
+                return function (_count) {
+                    return client;
+                };
+            }
+            if (prop === 'getMaxListeners') {
+                return function () {
+                    return Infinity;
+                };
+            }
+            if (prop in obj)
+                return Reflect.get(obj, prop);
+            return async (...args) => requestRedisCommand(mode, settings, prop.toUpperCase(), args);
         },
     });
     return client;
 };
 export const ensureRedisTransportMode = (config, options) => {
     const mode = resolveRedisTransportMode();
-    const subsystem = options?.subsystem ?? 'redis';
-    const requireDirectForScripts = options?.requireDirectForScripts ?? Env.REDIS_REQUIRE_DIRECT_FOR_SCRIPTS;
     if (mode === 'proxy' && options?.requireDirect === true) {
-        throw ErrorFactory.createConfigError(`Redis subsystem '${subsystem}' requires a direct Redis connection, but proxy mode is enabled.`);
-    }
-    if (mode === 'proxy' && requireDirectForScripts) {
-        throw ErrorFactory.createConfigError(`Redis subsystem '${subsystem}' requires a direct Redis connection for scripts, but proxy mode is enabled.`);
+        throw ErrorFactory.createConfigError(`Redis subsystem '${options.subsystem ?? 'redis'}' requires a direct Redis connection, but proxy mode is enabled.`);
     }
     if (mode === 'direct') {
         logTransportSelection(mode, config, options);

package/src/zintrust.plugins.d.ts

@@ -1,7 +1,10 @@
 /**
- * Auto-generated fallback module.
- * This file is created by scripts/ensure-worker-plugins.mjs when missing.
- * It allows optional runtime plugin imports to resolve in CI/scaffolded setups.
+ * ZinTrust plugin auto-imports
+ *
+ * In real projects, this file is managed by `zin plugin install` and contains
+ * side-effect imports (e.g. `@zintrust/db-sqlite/register`) that register
+ * optional adapters/drivers into core registries.
+ *
  */
 export type {};
 export declare const __zintrustGeneratedPluginStub = "zintrust.plugins.ts";

package/src/zintrust.plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zintrust.plugins.d.ts","sourceRoot":"","sources":["../../src/zintrust.plugins.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,YAAY,EAAE,CAAC;AAgBf,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;;AACnE,wBAAkB"}
+{"version":3,"file":"zintrust.plugins.d.ts","sourceRoot":"","sources":["../../src/zintrust.plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,YAAY,EAAE,CAAC;AAgBf,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;;AACnE,wBAAkB"}

package/src/zintrust.plugins.js

@@ -1,7 +1,10 @@
 /**
- * Auto-generated fallback module.
- * This file is created by scripts/ensure-worker-plugins.mjs when missing.
- * It allows optional runtime plugin imports to resolve in CI/scaffolded setups.
+ * ZinTrust plugin auto-imports
+ *
+ * In real projects, this file is managed by `zin plugin install` and contains
+ * side-effect imports (e.g. `@zintrust/db-sqlite/register`) that register
+ * optional adapters/drivers into core registries.
+ *
  */
 import * as TraceRuntime from './runtime/plugins/trace-runtime.js';
 globalThis.__zintrust_system_trace_plugin_requested__ = true;

package/src/proxy/redis/RedisProxyActions.d.ts

@@ -1,15 +0,0 @@
-import type { QueueDriver } from '@zintrust/queue-monitor/driver';
-import type { Metrics } from '@zintrust/queue-monitor/metrics';
-export type QueueMonitorContext = Readonly<{
-    driver: QueueDriver;
-    metrics: Metrics;
-}>;
-export type RedisProxyRedisConfig = Readonly<{
-    host: string;
-    port: number;
-    password: string;
-    db: number;
-}>;
-export declare const createQueueMonitorContext: (redis: RedisProxyRedisConfig) => Promise<QueueMonitorContext>;
-export declare const dispatchServiceCommand: (service: string, action: string, payload: Record<string, unknown>, queueMonitor: QueueMonitorContext) => Promise<unknown>;
-//# sourceMappingURL=RedisProxyActions.d.ts.map

package/src/proxy/redis/RedisProxyActions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RedisProxyActions.d.ts","sourceRoot":"","sources":["../../../../src/proxy/redis/RedisProxyActions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAG/D,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC,CAAC;AA4BH,eAAO,MAAM,yBAAyB,GACpC,OAAO,qBAAqB,KAC3B,OAAO,CAAC,mBAAmB,CAU7B,CAAC;AAuIF,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,cAAc,mBAAmB,KAChC,OAAO,CAAC,OAAO,CAUjB,CAAC"}

package/src/proxy/redis/RedisProxyActions.js

@@ -1,124 +0,0 @@
-import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-const loadQueueMonitorDriverModule = async () => {
-    return import('@zintrust/queue-monitor/driver');
-};
-const loadQueueMonitorMetricsModule = async () => {
-    return import('@zintrust/queue-monitor/metrics');
-};
-const loadQueueMonitoringServiceModule = async () => {
-    return import('../../../packages/queue-monitor/src/QueueMonitoringService.js');
-};
-const loadWorkersApiModule = async () => {
-    return import('../../../packages/workers/src/dashboard/workers-api.js');
-};
-const loadWorkerFactoryModule = async () => {
-    return import('../../../packages/workers/src/WorkerFactory.js');
-};
-export const createQueueMonitorContext = async (redis) => {
-    const [driverModule, metricsModule] = await Promise.all([
-        loadQueueMonitorDriverModule(),
-        loadQueueMonitorMetricsModule(),
-    ]);
-    return {
-        driver: driverModule.createBullMQDriver(redis),
-        metrics: metricsModule.createMetrics(redis),
-    };
-};
-const readString = (value) => {
-    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
-};
-const readBoolean = (value) => value === true;
-const readNumber = (value) => {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-};
-const readQueueNames = (value) => {
-    if (!Array.isArray(value))
-        return undefined;
-    const names = value
-        .filter((entry) => typeof entry === 'string')
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-    return names.length > 0 ? names : undefined;
-};
-const resolveWorkerPersistenceOverride = (payload) => {
-    const driver = readString(payload['driver']);
-    if (driver === 'redis')
-        return { driver: 'redis' };
-    if (driver === 'database')
-        return { driver: 'database' };
-    if (driver === 'memory')
-        return { driver: 'memory' };
-    return undefined;
-};
-const workerActionHandlers = {
-    getWorkers: async (payload) => {
-        const module = await loadWorkersApiModule();
-        return module.getWorkers(payload);
-    },
-    getWorkerDetails: async (payload) => {
-        const module = await loadWorkersApiModule();
-        return module.getWorkerDetails(readString(payload['name'] ?? payload['workerName']) ?? '', readString(payload['driver']));
-    },
-    toggleAutoStart: async (payload) => {
-        const module = await loadWorkersApiModule();
-        return module.toggleAutoStart(readString(payload['name'] ?? payload['workerName']) ?? '', readBoolean(payload['enabled']));
-    },
-    listPersistedRecords: async (payload) => {
-        const module = await loadWorkerFactoryModule();
-        return module.WorkerFactory.listPersistedRecords(resolveWorkerPersistenceOverride(payload), {
-            offset: readNumber(payload['offset']),
-            limit: readNumber(payload['limit']),
-            search: readString(payload['search']),
-            includeInactive: readBoolean(payload['includeInactive']),
-        });
-    },
-    listFileBackedRecords: async () => {
-        const module = await loadWorkerFactoryModule();
-        return module.WorkerFactory.listFileBackedRecords();
-    },
-    getPersisted: async (payload) => {
-        const module = await loadWorkerFactoryModule();
-        return module.WorkerFactory.getPersisted(readString(payload['name'] ?? payload['workerName']) ?? '', resolveWorkerPersistenceOverride(payload));
-    },
-    getHealth: async (payload) => {
-        const module = await loadWorkerFactoryModule();
-        return module.WorkerFactory.getHealth(readString(payload['name'] ?? payload['workerName']) ?? '');
-    },
-    getMetrics: async (payload) => {
-        const module = await loadWorkerFactoryModule();
-        return module.WorkerFactory.getMetrics(readString(payload['name'] ?? payload['workerName']) ?? '');
-    },
-};
-const queueMonitorActionHandlers = {
-    getRecentJobsForQueue: async (payload, queueMonitor) => {
-        const module = await loadQueueMonitoringServiceModule();
-        return module.getRecentJobsForQueue(readString(payload['queue'] ?? payload['queueName']) ?? '', queueMonitor.metrics, queueMonitor.driver);
-    },
-    getRecentJobsForSelection: async (payload, queueMonitor) => {
-        const module = await loadQueueMonitoringServiceModule();
-        return module.getRecentJobsForSelection(readString(payload['queue'] ?? payload['queueName']) ?? '', queueMonitor.metrics, queueMonitor.driver, readQueueNames(payload['queueNames']));
-    },
-};
-const dispatchWorkerAction = async (action, payload) => {
-    const handler = workerActionHandlers[action];
-    if (handler === undefined) {
-        throw ErrorFactory.createValidationError(`Unsupported worker action: ${action}`);
-    }
-    return handler(payload);
-};
-const dispatchQueueMonitorAction = async (action, payload, queueMonitor) => {
-    const handler = queueMonitorActionHandlers[action];
-    if (handler === undefined) {
-        throw ErrorFactory.createValidationError(`Unsupported queue-monitor action: ${action}`);
-    }
-    return handler(payload, queueMonitor);
-};
-export const dispatchServiceCommand = async (service, action, payload, queueMonitor) => {
-    if (service === 'worker') {
-        return dispatchWorkerAction(action, payload);
-    }
-    if (service === 'queue-monitor') {
-        return dispatchQueueMonitorAction(action, payload, queueMonitor);
-    }
-    throw ErrorFactory.createValidationError(`Unsupported RPC service: ${service}`);
-};