@zintrust/queue-monitor 0.5.8 → 0.7.7

package/dist/QueueMonitoringService.js

@@ -259,6 +259,7 @@ export async function getRecentJobsForQueue(queueName, metrics, driver) {
             name: job.name,
             queue: queueName,
             data: job.data,
+            opts: job.opts,
             attempts: job.attemptsMade,
             status,
             failedReason: job.failedReason || undefined,

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/queue-monitor",
-  "version": "0.5.8",
-  "buildDate": "2026-04-14T16:59:05.681Z",
+  "version": "0.7.7",
+  "buildDate": "2026-04-19T14:20:25.049Z",
   "buildEnvironment": {
     "node": "v20.20.2",
     "platform": "linux",
     "arch": "x64"
   },
   "git": {
-    "commit": "8d52a13d",
+    "commit": "3921a3ee",
     "branch": "master"
   },
   "package": {
@@ -37,8 +37,8 @@
       "sha256": "26a91f1b41d8a976a9e8fabaedc3fe6dc955c700499f0afc1a16fb91c9848665"
     },
     "QueueMonitoringService.js": {
-      "size": 8900,
-      "sha256": "0d00a27755a372ce77bb5921ce25fe024d3e57274cd48f963457f76bf5486e4b"
+      "size": 8928,
+      "sha256": "fc408db720d5883821b169eabce66944295068cd6f2338f1884493c299f0a0f1"
     },
     "connection.d.ts": {
       "size": 107,
@@ -53,32 +53,32 @@
       "sha256": "5140191207b5620500ac5e1edacefed65956a1ad88739695d545ea7d2b405243"
     },
     "dashboard-ui.js": {
-      "size": 54386,
-      "sha256": "9b8d8c41cefbb7a153956c0ed3c29b5fa2c7aa10077b4ca81ae5a99621cfbce1"
+      "size": 54576,
+      "sha256": "b3ee7f13f8fa2fee8204316ac5fe4c9ee0d424131565a58de17061296c7c8e1b"
     },
     "driver.d.ts": {
-      "size": 707,
-      "sha256": "b672414002f819d195cd97d7eb35fee1c09324e33e713e443f524323f65bea28"
+      "size": 1102,
+      "sha256": "70b74e7a0489da3a5545dfd8458ab5b4def1f3733c291a782c033fed0afd0bcf"
     },
     "driver.js": {
-      "size": 4105,
-      "sha256": "50229d05df9ca8bf5528b923e2799a4719e5a32ad9fa30bf3e2f36ecc91cf00c"
+      "size": 5165,
+      "sha256": "06a4aa4294ed0694146d184e8b0f1677ebe22a3d90bffa30b7c268657035c760"
     },
     "index.d.ts": {
       "size": 2161,
       "sha256": "2556c136641769f4e7cd81abd6ecae8663433aba74b09bc507b8fba01e3fc6f5"
     },
     "index.js": {
-      "size": 12869,
-      "sha256": "8d0f8ad669b74d5152768e9265cccd4c79320a0046f3d3c26d00bd802077874b"
+      "size": 13905,
+      "sha256": "707429961a88fe448506c3d3ca5c348cfa9305addd10bc081b1191ff141e8218"
     },
     "metrics.d.ts": {
-      "size": 868,
-      "sha256": "cbae21100c770e0960f4ae8c96bfaa2015162042122e04f00812817f04306512"
+      "size": 910,
+      "sha256": "6467795f6de818a1f295c42755005e394f25b145163c7678d6ac9ac1f9477fea"
     },
     "metrics.js": {
-      "size": 3448,
-      "sha256": "022c97865d37933fd7ed92f47b86b0450056caffd629fce6add51c902529bfe5"
+      "size": 3472,
+      "sha256": "fab0e6d62ed694dcf57904a68b683280e4063c2fdcf97c60fdf5d933ae2b8f4f"
     },
     "worker.d.ts": {
       "size": 332,

package/dist/dashboard-ui.js

@@ -983,9 +983,12 @@ const getRetryJobFunction = () => `
                 const res = await fetch(API_BASE + '/api/retry/' + queueName + '/' + jobId, {
                     method: 'POST'
                 });
+                const payload = await res.json().catch(() => null);
 
                 if (res.ok) {
-                    btn.textContent = '✓ Retried';
+                    btn.textContent = payload && payload.status === 'requeued_from_snapshot'
+                        ? '✓ Requeued'
+                        : '✓ Retried';
                     setTimeout(() => {
                         console.log('HTTP jobs polling disabled - using SSE only');
                         // fetchJobs(currentQueue);

package/dist/driver.d.ts

@@ -2,12 +2,32 @@ import type { Job, JobsOptions } from 'bullmq';
 import { type RedisConfig } from './connection';
 export type JobPayload<T = unknown> = T;
 export type JobCounts = Record<string, number>;
+export type RetrySnapshot = {
+    name?: string;
+    data: unknown;
+    opts?: JobsOptions;
+};
+export type RetryJobResult = {
+    ok: true;
+    status: 'retried';
+} | {
+    ok: true;
+    status: 'requeued_from_snapshot';
+    newJobId?: string;
+} | {
+    ok: false;
+    status: 'missing';
+} | {
+    ok: false;
+    status: 'not_retryable';
+    reason?: string;
+};
 export type QueueDriver = {
     enqueue<T>(name: string, payload: T, options?: JobsOptions): Promise<string>;
     getJob(queueName: string, jobId: string): Promise<Job | undefined>;
     getJobCounts(queueName: string): Promise<JobCounts>;
     getRecentJobs(queueName: string, limit?: number): Promise<Job[]>;
-    retryJob(queueName: string, jobId: string): Promise<boolean>;
+    retryJob(queueName: string, jobId: string, snapshot?: RetrySnapshot): Promise<RetryJobResult>;
     getQueues(): Promise<string[]>;
     close(): Promise<void>;
 };

package/dist/driver.js

@@ -41,6 +41,7 @@ async function discoverQueuesFromRedis(redis, inMemoryQueues) {
     }
     return Array.from(found.values());
 }
+// eslint-disable-next-line max-lines-per-function
 export const createBullMQDriver = (config) => {
     const queues = new Map();
     const redis = createRedisConnection(config, 3, { subsystem: 'queue-monitor' });
@@ -77,6 +78,23 @@ export const createBullMQDriver = (config) => {
         const queue = getQueue(queueName);
         return queue.getJobCounts();
     };
+    const requeueFromSnapshot = async (queue, snapshot) => {
+        try {
+            const requeued = await queue.add(snapshot.name ?? 'default', snapshot.data, snapshot.opts);
+            return {
+                ok: true,
+                status: 'requeued_from_snapshot',
+                newJobId: requeued.id === undefined || requeued.id === null ? undefined : String(requeued.id),
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                status: 'not_retryable',
+                reason: error instanceof Error ? error.message : String(error),
+            };
+        }
+    };
     const getRecentJobs = async (queueName, limit = 100) => {
         const queue = getQueue(queueName);
         const jobs = await queue.getJobs(['completed', 'failed', 'active', 'waiting', 'delayed', 'paused'], 0, Math.max(0, limit - 1), true);
@@ -84,16 +102,24 @@ export const createBullMQDriver = (config) => {
         await enrichJobsWithState(jobs);
         return jobs;
     };
-    const retryJob = async (queueName, jobId) => {
+    const retryJob = async (queueName, jobId, snapshot) => {
+        const queue = getQueue(queueName);
         const job = await getJob(queueName, jobId);
-        if (!job)
-            return false;
+        if (!job) {
+            if (snapshot)
+                return requeueFromSnapshot(queue, snapshot);
+            return { ok: false, status: 'missing' };
+        }
         try {
             await job.retry();
-            return true;
+            return { ok: true, status: 'retried' };
         }
-        catch {
-            return false;
+        catch (error) {
+            return {
+                ok: false,
+                status: 'not_retryable',
+                reason: error instanceof Error ? error.message : String(error),
+            };
         }
     };
     const getQueues = async () => {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Env, isArray, isNonEmptyString, Logger, queueConfig, resolveLockPrefix, Router, } from '@zintrust/core';
+import { Env, isNonEmptyString, Logger, queueConfig, resolveLockPrefix, Router, } from '@zintrust/core';
 import { createRedisConnection } from './connection';
 import { getDashboardHtml } from './dashboard-ui';
 import { createBullMQDriver } from './driver';
@@ -37,8 +37,7 @@ const HISTOGRAM_BUCKETS = [
 const MAX_LOCK_KEYS = 10_000;
 function normalizeQueueNames(queueNames) {
     return Array.from(new Set(queueNames
-        .map((queueName) => queueName)
-        .filter(isNonEmptyString)
+        .filter((queueName) => typeof queueName === 'string' && isNonEmptyString(queueName))
         .map((name) => name.trim())))
         .filter((name) => name.length > 0)
         .sort((left, right) => left.localeCompare(right));
@@ -47,7 +46,7 @@ async function resolveKnownQueues(knownQueues) {
     if (typeof knownQueues === 'function') {
         return normalizeQueueNames(await knownQueues());
     }
-    if (isArray(knownQueues)) {
+    if (Array.isArray(knownQueues)) {
         return normalizeQueueNames(knownQueues);
     }
     return [];
@@ -169,20 +168,44 @@ async function handleJobsEndpoint(req, res, metrics, driver) {
     const jobs = await getRecentJobsForSelection(queueName, metrics, driver);
     res.json(jobs);
 }
-async function handleRetryEndpoint(req, res, driver) {
+async function handleRetryEndpoint(req, res, driver, metrics) {
     const queueName = extractQueueParam(req);
     const jobId = typeof req.getParam === 'function' ? req.getParam?.('jobId') : req.params?.['jobId'];
     if (!queueName || !jobId) {
         res.status(400).json(fieldError('queue_name,job_id', 'Queue name and job ID must be provided'));
         return;
     }
-    const success = await driver.retryJob(queueName, jobId);
-    if (success) {
-        res.json({ ok: true, message: `Job ${jobId} queued for retry` });
+    const recentJobs = await getRecentJobsForSelection(queueName, metrics, driver);
+    const snapshotCandidate = recentJobs.find((job) => String(job.id) === jobId);
+    const retrySnapshot = snapshotCandidate === undefined
+        ? undefined
+        : {
+            name: snapshotCandidate.name,
+            data: snapshotCandidate.data,
+            opts: snapshotCandidate.opts,
+        };
+    const result = await driver.retryJob(queueName, jobId, retrySnapshot);
+    if (result.ok) {
+        res.json({
+            ok: true,
+            status: result.status,
+            message: result.status === 'requeued_from_snapshot'
+                ? `Job ${jobId} re-queued from monitor snapshot`
+                : `Job ${jobId} queued for retry`,
+            ...(result.status === 'requeued_from_snapshot' && result.newJobId
+                ? { newJobId: result.newJobId }
+                : {}),
+        });
+        return;
     }
-    else {
-        res.status(404).json({ error: 'Job not found or cannot be retried' });
+    if (result.status === 'missing') {
+        res.status(404).json({ error: `Job ${jobId} no longer exists`, status: result.status });
+        return;
     }
+    res.status(409).json({
+        error: result.reason ?? `Job ${jobId} cannot be retried in its current state`,
+        status: result.status,
+    });
 }
 function buildSettings(config) {
     return {
@@ -241,7 +264,7 @@ function registerApiRoutes(router, settings, routeOptions, metrics, driver, getS
     registerSnapshotApi(router, settings, routeOptions, getSnapshot);
     registerJobsApi(router, settings, routeOptions, metrics, driver);
     registerLocksApi(router, settings, routeOptions, getLocks);
-    registerRetryApi(router, settings, routeOptions, driver);
+    registerRetryApi(router, settings, routeOptions, driver, metrics);
     registerEventsApi(router, settings, routeOptions, getSnapshot, getLocks, metrics, driver);
 }
 function registerSnapshotApi(router, settings, routeOptions, getSnapshot) {
@@ -265,9 +288,9 @@ function registerLocksApi(router, settings, routeOptions, getLocks) {
         res.json(locks);
     }, routeOptions);
 }
-function registerRetryApi(router, settings, routeOptions, driver) {
+function registerRetryApi(router, settings, routeOptions, driver, metrics) {
     Router.post(router, `${settings.basePath}/api/retry/:queue/:jobId`, async (req, res) => {
-        await handleRetryEndpoint(req, res, driver);
+        await handleRetryEndpoint(req, res, driver, metrics);
     }, routeOptions);
 }
 function registerEventsApi(router, settings, routeOptions, getSnapshot, getLocks, metrics, driver) {

package/dist/metrics.d.ts

@@ -1,4 +1,4 @@
-import { type Job } from 'bullmq';
+import { type Job, type JobsOptions } from 'bullmq';
 import { type RedisConfig } from './connection';
 export type JobStatus = 'completed' | 'failed';
 export type JobSummary = {
@@ -6,6 +6,7 @@ export type JobSummary = {
     name: string;
     queue?: string;
     data: unknown;
+    opts?: JobsOptions;
     attempts: number;
     status?: string;
     failedReason?: string;

package/dist/metrics.js

@@ -19,6 +19,7 @@ const recordJobImpl = async (redis, queue, status, job, error) => {
         id: job.id,
         name: job.name,
         data: job.data,
+        opts: job.opts,
         attempts: job.attemptsMade,
         failedReason: job.failedReason || error?.message,
         timestamp: Date.now(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/queue-monitor",
-  "version": "0.5.8",
+  "version": "0.7.7",
   "description": "Queue monitoring package for ZinTrust with BullMQ and Redis.",
   "private": false,
   "type": "module",
@@ -20,7 +20,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.5.7"
+    "@zintrust/core": "^0.7.7"
   },
   "publishConfig": {
     "access": "public"