@bymax-one/nest-queue 1.2.14 → 1.2.16

package/dist/server/index.mjs

@@ -88,6 +88,11 @@ function invalid(reason) {
     reason
   });
 }
+function checkTimerDelay(name, value) {
+  if (value !== void 0 && !isTimerDelayMs(value)) {
+    invalid(`${name} must be a whole number from 1 to ${String(MAX_TIMER_DELAY_MS)}`);
+  }
+}
 function isParseableUrl(url) {
   const candidate = /^rediss?:\/\//i.test(url) ? url : url.startsWith("//") ? `redis:${url}` : `redis://${url}`;
   if (!URL.canParse(candidate)) return false;
@@ -128,15 +133,13 @@ function validateOptions(opts) {
   if (drainTimeoutMs !== void 0 && drainTimeoutMs <= 0) {
     invalid("shutdown.drainTimeoutMs must be > 0");
   }
+  checkTimerDelay("shutdown.drainTimeoutMs", drainTimeoutMs);
   const cacheTtlMs = opts.metrics?.cacheTtlMs;
   if (cacheTtlMs !== void 0 && cacheTtlMs < 0) {
     invalid("metrics.cacheTtlMs must be >= 0");
   }
-  for (const key of ["commandTimeoutMs", "enqueueTimeoutMs"]) {
-    const value = opts[key];
-    if (value !== void 0 && !isTimerDelayMs(value)) {
-      invalid(`${key} must be a whole number from 1 to ${String(MAX_TIMER_DELAY_MS)}`);
-    }
+  for (const key of ["commandTimeoutMs", "enqueueTimeoutMs", "connectionReadyTimeoutMs"]) {
+    checkTimerDelay(key, opts[key]);
   }
 }
 
@@ -155,6 +158,7 @@ var DEFAULT_ENQUEUE_TIMEOUT_MS = 1e4;
 var MAX_JOBS_PAGE_SIZE = 1e3;
 var DEFAULT_METRICS_CACHE_TTL_MS = 5e3;
 var DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS = 3e4;
+var MAX_BULK_SIZE = 1e3;
 
 // src/server/config/resolved-options.ts
 function applyDefaults(opts) {
@@ -248,13 +252,14 @@ function duplicateConnection(client) {
 }
 
 // src/server/services/connection-resolver.service.ts
-var _logger, _client, _options;
+var _logger, _client, _options, _pendingReady;
 var ConnectionResolver = class {
   constructor(options) {
     __privateAdd(this, _logger, new Logger(ConnectionResolver.name));
     __privateAdd(this, _client);
     __privateAdd(this, _options);
     __publicField(this, "mode");
+    __privateAdd(this, _pendingReady);
     __privateSet(this, _options, options);
   }
   async init() {
@@ -310,6 +315,21 @@ var ConnectionResolver = class {
   isOwned() {
     return this.mode === "mode-b-owned";
   }
+  awaitReady() {
+    const client = this.getClient();
+    if (!WAITING_STATUSES.has(client.status)) return Promise.resolve();
+    __privateGet(this, _pendingReady) ?? __privateSet(this, _pendingReady, new Promise((resolve) => {
+      const release = () => {
+        client.off("ready", release);
+        client.off("end", release);
+        __privateSet(this, _pendingReady, void 0);
+        resolve();
+      };
+      client.on("ready", release);
+      client.on("end", release);
+    }));
+    return __privateGet(this, _pendingReady);
+  }
   async teardown() {
     if (this.isOwned() && __privateGet(this, _client)) {
       const client = __privateGet(this, _client);
@@ -330,7 +350,7 @@ var ConnectionResolver = class {
     }
     if (client.options.maxRetriesPerRequest === null) {
       __privateGet(this, _logger).warn(
-        "The shared client has maxRetriesPerRequest: null, so a producer call made while Redis is unreachable waits for as long as the outage lasts; enqueue is bounded by enqueueTimeoutMs, other QueueService calls are not. Give the client a finite limit to fail fast."
+        "The shared client has maxRetriesPerRequest: null, so a command issued while Redis is unreachable stays queued in the client for as long as the outage lasts. QueueService calls are bounded by enqueueTimeoutMs and the caller is released, but the command is not cancelled. Give the client a finite limit to fail fast."
       );
     }
     const probe = duplicateConnection(client);
@@ -380,10 +400,17 @@ var ConnectionResolver = class {
 _logger = new WeakMap();
 _client = new WeakMap();
 _options = new WeakMap();
+_pendingReady = new WeakMap();
 ConnectionResolver = __decorateClass([
   Injectable(),
   __decorateParam(0, Inject(BYMAX_QUEUE_OPTIONS))
 ], ConnectionResolver);
+var WAITING_STATUSES = /* @__PURE__ */ new Set([
+  "connecting",
+  "connect",
+  "reconnecting",
+  "close"
+]);
 function isReplyError(err) {
   return typeof err === "object" && err !== null && err.name === "ReplyError";
 }
@@ -432,6 +459,13 @@ function attachDefaultErrorListener(emitter, logger, kind, queueName) {
     logger.error(`${kind} for queue "${queueName}" emitted an error: ${describeError(err)}`);
   });
 }
+function assertPageWindow(operation, start, end) {
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end - start >= MAX_JOBS_PAGE_SIZE) {
+    throw new QueueException(QUEUE_ERROR_CODES.INVALID_OPTIONS, HttpStatus.BAD_REQUEST, {
+      reason: `${operation} needs integers with 0 <= start <= end and at most ${String(MAX_JOBS_PAGE_SIZE)} jobs per call`
+    });
+  }
+}
 
 // src/server/utils/with-deadline.ts
 function withDeadline(work, timeoutMs, onTimeout) {
@@ -454,6 +488,18 @@ function timeoutException(operation, timeoutMs, cause) {
   if (cause !== void 0) exception.cause = cause;
   return exception;
 }
+function unavailableException(operation, cause) {
+  const exception = new QueueException(
+    QUEUE_ERROR_CODES.CONNECTION_TIMEOUT,
+    HttpStatus.INTERNAL_SERVER_ERROR,
+    { operation, reason: "offline" }
+  );
+  exception.cause = cause;
+  return exception;
+}
+function isOfflineRejection(err) {
+  return err instanceof Error && err.message === "Stream isn't writeable and enableOfflineQueue options is false";
+}
 function isCommandTimeout(err) {
   return err instanceof Error && err.message === "Command timed out";
 }
@@ -461,12 +507,12 @@ async function withCommandTimeoutCode(operation, commandTimeoutMs, work) {
   try {
     return await work;
   } catch (err) {
-    throw isCommandTimeout(err) ? timeoutException(operation, commandTimeoutMs(), err) : err;
+    if (isCommandTimeout(err)) throw timeoutException(operation, commandTimeoutMs(), err);
+    throw isOfflineRejection(err) ? unavailableException(operation, err) : err;
   }
 }
 
 // src/server/services/queue.service.ts
-var MAX_BULK_SIZE = 1e3;
 function assertValidCron(repeat, queueOptions) {
   if (queueOptions.settings?.repeatStrategy !== void 0) return;
   try {
@@ -477,13 +523,14 @@ function assertValidCron(repeat, queueOptions) {
     });
   }
 }
-var _queues;
+var _queues, _warm;
 var QueueService = class {
   constructor(connection, options) {
     this.connection = connection;
     this.options = options;
     __publicField(this, "logger", new Logger(QueueService.name));
     __privateAdd(this, _queues, /* @__PURE__ */ new Map());
+    __privateAdd(this, _warm, /* @__PURE__ */ new Set());
   }
   connection;
   options;
@@ -502,27 +549,38 @@ var QueueService = class {
     __privateGet(this, _queues).set(queueName, queue);
     return queue;
   }
-  enqueueTimeout(operation) {
-    return timeoutException(operation, this.options.enqueueTimeoutMs);
-  }
-  call(operation, work) {
+  call(operation, queueName, run) {
+    let expired = false;
+    const guarded = withDeadline(
+      this.afterReady(queueName).then(() => {
+        if (expired) throw new Error("the call had already timed out");
+        return run();
+      }),
+      this.options.enqueueTimeoutMs,
+      () => {
+        expired = true;
+        return timeoutException(operation, this.options.enqueueTimeoutMs);
+      }
+    );
     return withCommandTimeoutCode(
       operation,
       () => this.connection.getClient().options.commandTimeout ?? this.options.commandTimeoutMs,
-      work
+      guarded
     );
   }
+  async afterReady(queueName) {
+    if (__privateGet(this, _warm).has(queueName)) return;
+    await this.connection.awaitReady();
+    __privateGet(this, _warm).add(queueName);
+  }
   queueFor(queueName) {
     return this.getOrCreateQueue(queueName);
   }
   async enqueue(queueName, jobName, data, options) {
     const job = await this.call(
       "enqueue",
-      withDeadline(
-        this.queueFor(queueName).add(jobName, data, options),
-        this.options.enqueueTimeoutMs,
-        () => this.enqueueTimeout("enqueue")
-      )
+      queueName,
+      () => this.queueFor(queueName).add(jobName, data, options)
     );
     return job;
   }
@@ -541,16 +599,13 @@ var QueueService = class {
     try {
       const created = await this.call(
         "enqueueBulk",
-        withDeadline(
-          this.queueFor(queueName).addBulk(
-            jobs.map((job) => ({
-              name: job.name,
-              data: job.data,
-              ...job.options === void 0 ? {} : { opts: job.options }
-            }))
-          ),
-          this.options.enqueueTimeoutMs,
-          () => this.enqueueTimeout("enqueueBulk")
+        queueName,
+        () => this.queueFor(queueName).addBulk(
+          jobs.map((job) => ({
+            name: job.name,
+            data: job.data,
+            ...job.options === void 0 ? {} : { opts: job.options }
+          }))
         )
       );
       return created;
@@ -568,22 +623,23 @@ var QueueService = class {
     }
   }
   async getJob(queueName, jobId) {
-    const job = await this.call("getJob", this.queueFor(queueName).getJob(jobId));
+    const job = await this.call("getJob", queueName, () => this.queueFor(queueName).getJob(jobId));
     return job ?? null;
   }
   async getJobs(queueName, status, start = 0, end = 50) {
-    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end - start >= MAX_JOBS_PAGE_SIZE) {
-      throw new QueueException(QUEUE_ERROR_CODES.INVALID_OPTIONS, HttpStatus.BAD_REQUEST, {
-        reason: `getJobs needs integers with 0 <= start <= end and at most ${String(MAX_JOBS_PAGE_SIZE)} jobs per call`
-      });
-    }
-    const jobs = await this.call("getJobs", this.queueFor(queueName).getJobs([status], start, end));
+    assertPageWindow("getJobs", start, end);
+    const jobs = await this.call(
+      "getJobs",
+      queueName,
+      () => this.queueFor(queueName).getJobs([status], start, end)
+    );
     return jobs;
   }
   async getMetrics(queueName) {
     const counts = await this.call(
       "getMetrics",
-      this.queueFor(queueName).getJobCounts("waiting", "active", "completed", "failed", "delayed")
+      queueName,
+      () => this.queueFor(queueName).getJobCounts("waiting", "active", "completed", "failed", "delayed")
     );
     return {
       queue: queueName,
@@ -602,24 +658,38 @@ var QueueService = class {
     if ("pattern" in repeat) assertValidCron(repeat, this.options.queueOptions);
     const job = await this.call(
       "upsertJobScheduler",
-      queue.upsertJobScheduler(schedulerId, repeat, jobTemplate)
+      queueName,
+      () => queue.upsertJobScheduler(schedulerId, repeat, jobTemplate)
     );
     return job;
   }
   async removeJobScheduler(queueName, schedulerId) {
-    return this.call("removeJobScheduler", this.queueFor(queueName).removeJobScheduler(schedulerId));
+    return this.call(
+      "removeJobScheduler",
+      queueName,
+      () => this.queueFor(queueName).removeJobScheduler(schedulerId)
+    );
   }
   async getJobSchedulers(queueName, start = 0, end = 50, asc = true) {
-    return this.call("getJobSchedulers", this.queueFor(queueName).getJobSchedulers(start, end, asc));
+    assertPageWindow("getJobSchedulers", start, end);
+    return this.call(
+      "getJobSchedulers",
+      queueName,
+      () => this.queueFor(queueName).getJobSchedulers(start, end, asc)
+    );
   }
   async pauseQueue(queueName) {
-    await this.call("pauseQueue", this.queueFor(queueName).pause());
+    await this.call("pauseQueue", queueName, () => this.queueFor(queueName).pause());
   }
   async resumeQueue(queueName) {
-    await this.call("resumeQueue", this.queueFor(queueName).resume());
+    await this.call("resumeQueue", queueName, () => this.queueFor(queueName).resume());
   }
   async cleanQueue(queueName, gracePeriodMs, limit, status) {
-    return this.call("cleanQueue", this.queueFor(queueName).clean(gracePeriodMs, limit, status));
+    return this.call(
+      "cleanQueue",
+      queueName,
+      () => this.queueFor(queueName).clean(gracePeriodMs, limit, status)
+    );
   }
   getCachedQueues() {
     return __privateGet(this, _queues);
@@ -629,9 +699,11 @@ var QueueService = class {
       await queue.close().catch(() => void 0);
     }
     __privateGet(this, _queues).clear();
+    __privateGet(this, _warm).clear();
   }
 };
 _queues = new WeakMap();
+_warm = new WeakMap();
 QueueService = __decorateClass([
   Injectable(),
   __decorateParam(0, Inject(ConnectionResolver)),
@@ -640,13 +712,15 @@ QueueService = __decorateClass([
 function errorCodeOf(err) {
   return err.getResponse().error.code;
 }
-var _connection;
+var _connection, _deadlineMs;
 var FlowService = class {
-  constructor(connection, enabled, prefix, telemetry) {
+  constructor(connection, enabled, prefix, telemetry, enqueueTimeoutMs = DEFAULT_ENQUEUE_TIMEOUT_MS) {
     __publicField(this, "logger", new Logger(FlowService.name));
     __publicField(this, "producer");
     __privateAdd(this, _connection);
+    __privateAdd(this, _deadlineMs);
     __privateSet(this, _connection, connection);
+    __privateSet(this, _deadlineMs, enqueueTimeoutMs);
     if (enabled) {
       this.producer = new FlowProducer({
         connection: connection.getClient(),
@@ -657,17 +731,24 @@ var FlowService = class {
     }
   }
   async add(flow) {
-    return withCommandTimeoutCode(
-      "addFlow",
-      () => this.commandTimeout(),
-      this.requireProducer().add(flow)
-    );
+    return this.bounded("addFlow", this.requireProducer().add(flow));
   }
   async addBulk(flows) {
+    const producer = this.requireProducer();
+    if (flows.length > MAX_BULK_SIZE) {
+      throw new QueueException(
+        QUEUE_ERROR_CODES.BULK_ENQUEUE_FAILED,
+        HttpStatus.INTERNAL_SERVER_ERROR,
+        { reason: "batch size exceeds limit", limit: MAX_BULK_SIZE, received: flows.length }
+      );
+    }
+    return this.bounded("addFlowBulk", producer.addBulk([...flows]));
+  }
+  bounded(operation, work) {
     return withCommandTimeoutCode(
-      "addFlowBulk",
+      operation,
       () => this.commandTimeout(),
-      this.requireProducer().addBulk([...flows])
+      withDeadline(work, __privateGet(this, _deadlineMs), () => timeoutException(operation, __privateGet(this, _deadlineMs)))
     );
   }
   commandTimeout() {
@@ -689,6 +770,7 @@ var FlowService = class {
   }
 };
 _connection = new WeakMap();
+_deadlineMs = new WeakMap();
 FlowService = __decorateClass([
   Injectable()
 ], FlowService);
@@ -734,6 +816,41 @@ var MetricsService = class {
 MetricsService = __decorateClass([
   Injectable()
 ], MetricsService);
+
+// src/server/utils/worker-option-problem.ts
+var WORKER_TIMER_MIN_MS = 1e3;
+function countProblem(name, value, min, max) {
+  if (!Number.isInteger(value)) return { reason: `${name} must be a whole number`, actual: value };
+  if (value < min) return { reason: `${name} must be >= ${String(min)}`, actual: value };
+  if (value > max) return { reason: `${name} must be <= ${String(max)}`, actual: value };
+  return void 0;
+}
+function timerProblem(name, value) {
+  if (value === void 0) return void 0;
+  if (Number.isInteger(value) && value >= WORKER_TIMER_MIN_MS && value <= MAX_TIMER_DELAY_MS) {
+    return void 0;
+  }
+  return {
+    reason: `${name} must be a whole number from ${String(WORKER_TIMER_MIN_MS)} to ${String(MAX_TIMER_DELAY_MS)}`,
+    actual: value
+  };
+}
+function workerOptionProblem(opts) {
+  if (opts === void 0) return void 0;
+  const { concurrency, limiter, lockDuration, stalledInterval } = opts;
+  return (concurrency === void 0 ? void 0 : countProblem("concurrency", concurrency, 1, MAX_WORKER_CONCURRENCY)) ?? (limiter === void 0 ? void 0 : countProblem("limiter.max", limiter.max, 1, Number.POSITIVE_INFINITY) ?? countProblem("limiter.duration", limiter.duration, 1, Number.POSITIVE_INFINITY)) ?? timerProblem("lockDuration", lockDuration) ?? timerProblem("stalledInterval", stalledInterval);
+}
+
+// src/server/utils/abandoned-workers.ts
+var abandoned = /* @__PURE__ */ new WeakSet();
+function abandonWorker(worker) {
+  abandoned.add(worker);
+}
+function isAbandoned(worker) {
+  return abandoned.has(worker);
+}
+
+// src/server/services/worker-registry.service.ts
 var _entries;
 var WorkerRegistry = class {
   constructor(connection, options) {
@@ -754,7 +871,7 @@ var WorkerRegistry = class {
     try {
       worker = new Worker(
         queueName,
-        toProcessor(handler, options?.jobTimeoutMs),
+        toProcessor(handler, options?.jobTimeoutMs, () => isAbandoned(worker)),
         bullOpts
       );
     } catch (cause) {
@@ -847,51 +964,15 @@ var WorkerRegistry = class {
     }
   }
   validateOptions(opts) {
-    if (opts?.concurrency !== void 0) {
-      if (opts.concurrency < 1) {
-        throw new QueueException(
-          QUEUE_ERROR_CODES.WORKER_REGISTRATION_FAILED,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-          {
-            reason: "concurrency must be >= 1",
-            actual: opts.concurrency
-          }
-        );
-      }
-      if (opts.concurrency > MAX_WORKER_CONCURRENCY) {
-        throw new QueueException(
-          QUEUE_ERROR_CODES.WORKER_REGISTRATION_FAILED,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-          {
-            reason: `concurrency must be <= ${MAX_WORKER_CONCURRENCY.toString()}`,
-            actual: opts.concurrency
-          }
-        );
-      }
+    const problem = workerOptionProblem(opts);
+    if (problem !== void 0) {
+      throw new QueueException(
+        QUEUE_ERROR_CODES.WORKER_REGISTRATION_FAILED,
+        HttpStatus.INTERNAL_SERVER_ERROR,
+        problem
+      );
     }
     this.validateJobTimeout(opts);
-    if (opts?.limiter !== void 0) {
-      if (opts.limiter.max < 1) {
-        throw new QueueException(
-          QUEUE_ERROR_CODES.WORKER_REGISTRATION_FAILED,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-          {
-            reason: "limiter.max must be >= 1",
-            actual: opts.limiter.max
-          }
-        );
-      }
-      if (opts.limiter.duration < 1) {
-        throw new QueueException(
-          QUEUE_ERROR_CODES.WORKER_REGISTRATION_FAILED,
-          HttpStatus.INTERNAL_SERVER_ERROR,
-          {
-            reason: "limiter.duration must be >= 1",
-            actual: opts.limiter.duration
-          }
-        );
-      }
-    }
   }
   validateJobTimeout(opts) {
     if (opts?.jobTimeoutMs !== void 0 && !isTimerDelayMs(opts.jobTimeoutMs)) {
@@ -968,7 +1049,7 @@ var JobTimeoutError = class extends Error {
     this.name = "JobTimeoutError";
   }
 };
-function toProcessor(handler, timeoutMs) {
+function adaptHandler(handler, timeoutMs) {
   if (timeoutMs === void 0) return (job, _token, signal) => handler(job, signal);
   return (job, _token, signal) => {
     const own = new AbortController();
@@ -990,6 +1071,16 @@ function toProcessor(handler, timeoutMs) {
     });
   };
 }
+function toProcessor(handler, timeoutMs, abandoned2) {
+  const run = adaptHandler(handler, timeoutMs);
+  return (job, token, signal) => run(job, token, signal).then(
+    (value) => abandoned2() ? new Promise(() => void 0) : value,
+    (error) => {
+      if (abandoned2()) return new Promise(() => void 0);
+      throw error;
+    }
+  );
+}
 var _events, _connections;
 var QueueEventsRegistry = class {
   constructor(connection, options) {
@@ -1168,6 +1259,7 @@ ProcessorDiscoveryService = __decorateClass([
   __decorateParam(1, Inject(WorkerRegistry)),
   __decorateParam(2, Inject(QueueEventsRegistry))
 ], ProcessorDiscoveryService);
+var FORCE_CLOSE_GRACE_MS = 1e3;
 var DrainTimeoutError = class extends Error {
 };
 var QueueLifecycle = class {
@@ -1201,25 +1293,33 @@ var QueueLifecycle = class {
     await this.closeQueues();
     await this.teardownConnection();
     this.logger.log(
-      `Queue shutdown complete in ${String(Date.now() - (this.startedAt ?? Date.now()))}ms (forced ${String(this.forcedWorkers)} worker(s))`
+      `Queue shutdown complete in ${String(Date.now() - (this.startedAt ?? Date.now()))}ms (${String(this.forcedWorkers)} worker(s) stopped without draining)`
     );
   }
   async closeWorkers(deadline) {
-    let forced = 0;
+    let undrained = 0;
     await Promise.all(
       Array.from(this.workers.getAll(), async ([name, worker]) => {
         try {
-          await bounded(worker.close(), deadline);
+          await bounded(
+            worker.pause().then(() => worker.close()),
+            deadline
+          );
         } catch (cause) {
-          forced++;
+          undrained++;
+          abandonWorker(worker);
+          const stopped = "it is stopped without waiting for its in-flight job, which becomes stalled and is retried";
           this.logger.warn(
-            cause instanceof DrainTimeoutError ? `Worker "${name}" exceeded the ${String(this.resolved.shutdown.drainTimeoutMs)}ms drain budget \u2014 forcing close (${QUEUE_ERROR_CODES.SHUTDOWN_TIMEOUT_EXCEEDED}); the in-flight job becomes stalled and is retried` : `Worker "${name}" failed to close gracefully (${describeError(cause)}) \u2014 forcing close; the in-flight job becomes stalled and is retried`
+            cause instanceof DrainTimeoutError ? `Worker "${name}" exceeded the ${String(this.resolved.shutdown.drainTimeoutMs)}ms drain budget (${QUEUE_ERROR_CODES.SHUTDOWN_TIMEOUT_EXCEEDED}); ${stopped}` : `Worker "${name}" failed to close gracefully (${describeError(cause)}); ${stopped}`
+          );
+          const deadlineError = () => new DrainTimeoutError();
+          await withDeadline(worker.close(true), FORCE_CLOSE_GRACE_MS, deadlineError).catch(
+            () => void 0
           );
-          void worker.close(true).catch(() => void 0);
         }
       })
     );
-    return forced;
+    return undrained;
   }
   async closeQueueEvents(deadline) {
     await Promise.all(
@@ -1294,7 +1394,13 @@ var BymaxQueueModule = class extends ConfigurableModuleClass {
         { provide: BYMAX_QUEUE_RESOLVED_OPTIONS, useValue: resolved },
         {
           provide: FlowService,
-          useFactory: (conn) => new FlowService(conn, resolved.flows.enabled, resolved.prefix, resolved.telemetry),
+          useFactory: (conn) => new FlowService(
+            conn,
+            resolved.flows.enabled,
+            resolved.prefix,
+            resolved.telemetry,
+            resolved.enqueueTimeoutMs
+          ),
           inject: [ConnectionResolver]
         },
         {
@@ -1324,7 +1430,13 @@ var BymaxQueueModule = class extends ConfigurableModuleClass {
         },
         {
           provide: FlowService,
-          useFactory: (conn, resolved) => new FlowService(conn, resolved.flows.enabled, resolved.prefix, resolved.telemetry),
+          useFactory: (conn, resolved) => new FlowService(
+            conn,
+            resolved.flows.enabled,
+            resolved.prefix,
+            resolved.telemetry,
+            resolved.enqueueTimeoutMs
+          ),
           inject: [ConnectionResolver, BYMAX_QUEUE_RESOLVED_OPTIONS]
         },
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bymax-one/nest-queue",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "NestJS dynamic module wrapping BullMQ — typed jobs, flows, job schedulers, deduplication, OpenTelemetry, graceful shutdown",
   "author": "Bymax One <support@bymax.one>",
   "license": "MIT",