@nest-batch/bullmq 0.2.0 → 0.2.1

package/dist/src/index.js

@@ -27,7 +27,7 @@ Object.defineProperty(exports, "__esModule", {
 _export_star(require("./connection"), exports);
 _export_star(require("./module-options"), exports);
 _export_star(require("./bullmq-execution-strategy"), exports);
-_export_star(require("./bullmq-schedule.service"), exports);
+_export_star(require("./bullmq-schedule"), exports);
 _export_star(require("./adapters"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Public API barrel for `@nest-batch/bullmq`.\n *\n * The host application should depend exclusively on this barrel:\n *   - `BullmqAdapter` is the new factory-pattern transport\n *     adapter (use with `NestBatchModule.forRoot({ adapters:\n *     { transport: BullmqAdapter.forRoot(...) } })`).\n *   - `BullMqExecutionStrategy` is the strategy class (also\n *     exported individually so callers can inject it directly for\n *     inspection / health checks).\n *   - `BULLMQ_MODULE_OPTIONS` is the DI token for the resolved\n *     module options bag.\n *   - the connection helpers are re-exported so callers can build\n *     a fully-resolved `BullMqResolvedConnection` from a partial\n *     `BullMqConnectionOptions` without importing the internal\n *     `connection.ts` file.\n *\n * The legacy `BullmqBatchModule` (with `forRoot` / `forRootAsync`\n * static methods) has been replaced by `BullmqAdapter`. Internal\n * modules (`./bullmq-execution-strategy`, `./module-options`,\n * `./connection`, `./adapters/bullmq.module`) are implementation\n * details and may move between releases.\n */\nexport * from './connection';\nexport * from './module-options';\nexport * from './bullmq-execution-strategy';\nexport * from './bullmq-schedule.service';\nexport * from './adapters';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC;;;;qBACa;qBACA;qBACA;qBACA;qBACA"}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/**\n * Public API barrel for `@nest-batch/bullmq`.\n *\n * The host application should depend exclusively on this barrel:\n *   - `BullmqAdapter` is the new factory-pattern transport\n *     adapter (use with `NestBatchModule.forRoot({ adapters:\n *     { transport: BullmqAdapter.forRoot(...) } })`).\n *   - `BullMqExecutionStrategy` is the strategy class (also\n *     exported individually so callers can inject it directly for\n *     inspection / health checks).\n *   - `BULLMQ_MODULE_OPTIONS` is the DI token for the resolved\n *     module options bag.\n *   - the connection helpers are re-exported so callers can build\n *     a fully-resolved `BullMqResolvedConnection` from a partial\n *     `BullMqConnectionOptions` without importing the internal\n *     `connection.ts` file.\n *\n * The legacy `BullmqBatchModule` (with `forRoot` / `forRootAsync`\n * static methods) has been replaced by `BullmqAdapter`. Internal\n * modules (`./bullmq-execution-strategy`, `./module-options`,\n * `./connection`, `./adapters/bullmq.module`) are implementation\n * details and may move between releases.\n */\nexport * from './connection';\nexport * from './module-options';\nexport * from './bullmq-execution-strategy';\nexport * from './bullmq-schedule';\nexport * from './adapters';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC;;;;qBACa;qBACA;qBACA;qBACA;qBACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-batch/bullmq",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "BullMQ runtime adapter for @nest-batch/core — runs batch jobs and partitioned steps as BullMQ queues and workers.",
   "license": "MIT",
   "author": "easdkr",
@@ -34,7 +34,7 @@
     "@nestjs/common": "^10 || ^11",
     "@nestjs/core": "^10 || ^11",
     "bullmq": "^5.0.0",
-    "@nest-batch/core": "^0.2.0"
+    "@nest-batch/core": "^0.2.1"
   },
   "peerDependenciesMeta": {
     "@nest-batch/core": {
@@ -60,7 +60,7 @@
     "reflect-metadata": "^0.2.2",
     "typescript": "^5.5.0",
     "vitest": "^2.0.0",
-    "@nest-batch/core": "0.2.0"
+    "@nest-batch/core": "0.2.1"
   },
   "scripts": {
     "build": "swc src -d dist --config-file ../../.swcrc && tsc --emitDeclarationOnly -p tsconfig.build.json",

package/src/adapters/bullmq.adapter.ts

@@ -2,8 +2,8 @@ import { Module, type DynamicModule, type Provider } from '@nestjs/common';
 import { EXECUTION_STRATEGY, type BatchAdapter } from '@nest-batch/core';
 
 import { BullMqExecutionStrategy } from '../bullmq-execution-strategy';
-import { BullmqRuntimeService } from '../bullmq-runtime.service';
-import { BullmqScheduleService } from '../bullmq-schedule.service';
+import { BullmqRuntime } from '../bullmq-runtime';
+import { BullmqSchedule } from '../bullmq-schedule';
 import { resolveBullMqConnection } from '../connection';
 import {
   BULLMQ_MODULE_OPTIONS,
@@ -53,7 +53,7 @@ const OPTIONS_FACTORY: symbol = Symbol.for('@nest-batch/bullmq/OPTIONS_FACTORY')
  *
  * The set mirrors the legacy `BullmqBatchModule.forRoot()` exports
  * (the `forRootAsync()` legacy path was missing
- * `BullmqRuntimeService` from `exports` — that omission is fixed
+ * `BullmqRuntime` from `exports` — that omission is fixed
  * here, both paths now export the same five entries).
  *
  *   - `EXECUTION_STRATEGY` — the DI token, so host code (e.g. a
@@ -64,17 +64,19 @@ const OPTIONS_FACTORY: symbol = Symbol.for('@nest-batch/bullmq/OPTIONS_FACTORY')
  *     builders.
  *   - `BullMqExecutionStrategy` — the concrete class, for type-
  *     strict consumers that prefer class injection.
- *   - `BullmqRuntimeService` — the runtime that owns the
+ *   - `BullmqRuntime` — the runtime that owns the
  *     `Queue` / `Worker` / `QueueEvents` lifecycle.
- *   - `BullmqScheduleService` — the runtime that owns the
+ *   - `BullmqSchedule` — the runtime that owns the
  *     `@BatchScheduled` cron-to-BullMQ translation.
  */
-const ADAPTER_EXPORTS: ReadonlyArray<symbol | typeof BullMqExecutionStrategy | typeof BullmqRuntimeService | typeof BullmqScheduleService> = [
+const ADAPTER_EXPORTS: ReadonlyArray<
+  symbol | typeof BullMqExecutionStrategy | typeof BullmqRuntime | typeof BullmqSchedule
+> = [
   EXECUTION_STRATEGY,
   BULLMQ_MODULE_OPTIONS,
   BullMqExecutionStrategy,
-  BullmqRuntimeService,
-  BullmqScheduleService,
+  BullmqRuntime,
+  BullmqSchedule,
 ];
 
 /**
@@ -85,8 +87,8 @@ const ADAPTER_EXPORTS: ReadonlyArray<symbol | typeof BullMqExecutionStrategy | t
  * Overrides the default `EXECUTION_STRATEGY` token with a BullMQ-
  * backed `IExecutionStrategy` (`BullMqExecutionStrategy`) and wires
  * the runtime services that own the BullMQ client lifecycle
- * (`BullmqRuntimeService` for step enqueue + worker, plus
- * `BullmqScheduleService` for `@BatchScheduled` cron entries).
+ * (`BullmqRuntime` for step enqueue + worker, plus
+ * `BullmqSchedule` for `@BatchScheduled` cron entries).
  *
  * Two static methods:
  *
@@ -226,9 +228,7 @@ export class BullmqAdapter {
   static forRootAsync(asyncOptions: {
     imports?: DynamicModule['imports'];
     inject?: readonly unknown[];
-    useFactory: (
-      ...args: unknown[]
-    ) => Promise<BullMqModuleOptions> | BullMqModuleOptions;
+    useFactory: (...args: unknown[]) => Promise<BullMqModuleOptions> | BullMqModuleOptions;
   }): BatchAdapter {
     const factoryProvider: Provider = {
       provide: OPTIONS_FACTORY,
@@ -238,9 +238,7 @@ export class BullmqAdapter {
 
     const mergedOptionsProvider: Provider = {
       provide: BULLMQ_MODULE_OPTIONS,
-      useFactory: (
-        fromFactory: BullMqModuleOptions | undefined,
-      ): ResolvedBullMqModuleOptions => {
+      useFactory: (fromFactory: BullMqModuleOptions | undefined): ResolvedBullMqModuleOptions => {
         return Object.freeze({
           connection: resolveBullMqConnection(fromFactory?.connection),
           autoStartWorker: fromFactory?.autoStartWorker ?? false,
@@ -295,13 +293,11 @@ export class BullmqAdapter {
  * out of the returned array and replaces it with the factory
  * pair. Everything else is shared.
  */
-function buildStaticProviders(
-  resolved: ResolvedBullMqModuleOptions,
-): Provider[] {
+function buildStaticProviders(resolved: ResolvedBullMqModuleOptions): Provider[] {
   return [
     BullMqExecutionStrategy,
-    BullmqRuntimeService,
-    BullmqScheduleService,
+    BullmqRuntime,
+    BullmqSchedule,
     {
       provide: EXECUTION_STRATEGY,
       useExisting: BullMqExecutionStrategy,

package/src/bullmq-execution-strategy.ts

@@ -8,10 +8,7 @@ import {
   type LaunchResult,
 } from '@nest-batch/core';
 
-import {
-  BullmqRuntimeService,
-  BULLMQ_STRATEGY_NAME,
-} from './bullmq-runtime.service';
+import { BullmqRuntime, BULLMQ_STRATEGY_NAME } from './bullmq-runtime';
 
 /**
  * BullMQ execution strategy — the `@nest-batch/core`-facing
@@ -21,7 +18,7 @@ import {
  * Design (T18):
  *   - The actual BullMQ resource ownership (queue / worker /
  *     queue-events lifecycle, connection tuning, event bridge)
- *     lives in `BullmqRuntimeService`. This class is a thin
+ *     lives in `BullmqRuntime`. This class is a thin
  *     adapter that maps the `IExecutionStrategy` contract to
  *     the runtime service's `launch()` shape.
  *   - Splitting the two lets the runtime service be
@@ -51,7 +48,7 @@ export class BullMqExecutionStrategy implements IExecutionStrategy {
 
   private readonly logger = new Logger(BullMqExecutionStrategy.name);
 
-  constructor(private readonly runtime: BullmqRuntimeService) {}
+  constructor(private readonly runtime: BullmqRuntime) {}
 
   /**
    * Enqueue the work and return the BullMQ job id. The DB

package/src/{bullmq-runtime.service.ts → bullmq-runtime.ts}

@@ -20,10 +20,7 @@ import {
 } from '@nest-batch/core';
 import { JobExecutor, JobRegistry, NoopBatchObserver, BATCH_EVENT } from '@nest-batch/core';
 
-import {
-  BULLMQ_MODULE_OPTIONS,
-  type ResolvedBullMqModuleOptions,
-} from './module-options';
+import { BULLMQ_MODULE_OPTIONS, type ResolvedBullMqModuleOptions } from './module-options';
 
 /**
  * Payload shape stored in a BullMQ job's `data` field.
@@ -118,7 +115,7 @@ export const BULLMQ_STRATEGY_NAME = 'bullmq';
  *     of truth and a single method (`close()`).
  */
 @Injectable()
-export class BullmqRuntimeService
+export class BullmqRuntime
   implements IExecutionStrategy, OnApplicationBootstrap, OnApplicationShutdown
 {
   /**
@@ -127,7 +124,7 @@ export class BullmqRuntimeService
    */
   readonly name = BULLMQ_STRATEGY_NAME;
 
-  private readonly logger = new Logger(BullmqRuntimeService.name);
+  private readonly logger = new Logger(BullmqRuntime.name);
 
   /** BullMQ queue (producer side). */
   private queue: Queue | null = null;
@@ -178,12 +175,12 @@ export class BullmqRuntimeService
     if (this.options.autoStartWorker) {
       this.worker = this.buildWorker();
       this.logger.log(
-        `BullmqRuntimeService started: queue="${BULLMQ_QUEUE_NAME}" ` +
+        `BullmqRuntime started: queue="${BULLMQ_QUEUE_NAME}" ` +
           `worker=auto, keyPrefix="${this.options.connection.keyPrefix}"`,
       );
     } else {
       this.logger.log(
-        `BullmqRuntimeService started: queue="${BULLMQ_QUEUE_NAME}" ` +
+        `BullmqRuntime started: queue="${BULLMQ_QUEUE_NAME}" ` +
           `worker=manual (autoStartWorker=false)`,
       );
     }
@@ -241,7 +238,7 @@ export class BullmqRuntimeService
   ): Promise<{ kind: 'enqueued'; queueJobId: string }> {
     if (this.queue === null) {
       throw new Error(
-        `[BullmqRuntimeService] launch() called before onApplicationBootstrap — ` +
+        `[BullmqRuntime] launch() called before onApplicationBootstrap — ` +
           'module is not initialized. Did you forget to import BullmqBatchModule?',
       );
     }
@@ -284,9 +281,7 @@ export class BullmqRuntimeService
         // (which is disabled by `enableOfflineQueue: false`) is
         // not available. Surface this as a hard error so the
         // launcher propagates the failure.
-        throw new Error(
-          `[BullmqRuntimeService] enqueue returned undefined job id (Redis down?)`,
-        );
+        throw new Error(`[BullmqRuntime] enqueue returned undefined job id (Redis down?)`);
       }
       const qid = String(enqueued.id);
       lastQueueJobId = qid;
@@ -301,7 +296,7 @@ export class BullmqRuntimeService
       // (partitionOrdinals has length >= 1), so this branch is
       // unreachable in practice. Keep the explicit throw so a
       // future refactor cannot quietly enqueue zero jobs.
-      throw new Error(`[BullmqRuntimeService] enqueued zero jobs for execution ${ctx.executionId}`);
+      throw new Error(`[BullmqRuntime] enqueued zero jobs for execution ${ctx.executionId}`);
     }
     return { kind: 'enqueued', queueJobId: lastQueueJobId };
   }
@@ -423,7 +418,7 @@ export class BullmqRuntimeService
       // Surface as a BullMQ-level failure so the technical
       // retry / dead-letter path handles it.
       throw new Error(
-        `[BullmqRuntimeService] JobExecution ${payload.executionId} not found in repository`,
+        `[BullmqRuntime] JobExecution ${payload.executionId} not found in repository`,
       );
     }
     const jobDef = this.registry.get(payload.jobId);
@@ -530,9 +525,7 @@ export class BullmqRuntimeService
       try {
         await this.queue.close();
       } catch (err) {
-        this.logger.warn(
-          `Queue close failed: ${err instanceof Error ? err.message : String(err)}`,
-        );
+        this.logger.warn(`Queue close failed: ${err instanceof Error ? err.message : String(err)}`);
       }
       this.queue = null;
     }

package/src/{bullmq-schedule.service.ts → bullmq-schedule.ts}

@@ -5,9 +5,14 @@ import {
   OnApplicationBootstrap,
   OnApplicationShutdown,
 } from '@nestjs/common';
-import { Queue, type JobsOptions } from 'bullmq';
+import { Queue, Worker, type Job, type JobsOptions } from 'bullmq';
 
-import { BATCH_SCHEDULE_REGISTRY, BatchScheduleRegistry, type BatchScheduleEntry } from '@nest-batch/core';
+import {
+  BatchScheduleRegistry,
+  JobLauncher,
+  type BatchScheduleEntry,
+  type JobParameters,
+} from '@nest-batch/core';
 
 import { BULLMQ_MODULE_OPTIONS, type ResolvedBullMqModuleOptions } from './module-options';
 
@@ -26,8 +31,14 @@ import { BULLMQ_MODULE_OPTIONS, type ResolvedBullMqModuleOptions } from './modul
  */
 export const BULLMQ_SCHEDULE_QUEUE_NAME = 'nest-batch-schedule';
 
+export interface BullmqSchedulePayload {
+  readonly jobId: string;
+  readonly scheduleName: string;
+  readonly methodName: string;
+}
+
 /**
- * `BullmqScheduleService` — the runtime scheduler for
+ * `BullmqSchedule` — the runtime scheduler for
  * `@BatchScheduled` entries.
  *
  * Lifecycle:
@@ -39,35 +50,39 @@ export const BULLMQ_SCHEDULE_QUEUE_NAME = 'nest-batch-schedule';
  *   2. BullMQ's `upsertJobScheduler` internally fires the
  *      schedule at the configured cron time. Each fire enqueues a
  *      job into the schedule queue (named after the schedule
- *      entry's method). A separate `Worker` (the one owned by
- *      `BullmqRuntimeService` if `autoStartWorker` is `true`)
- *      processes the jobs.
+ *      entry's method). When `autoStartWorker` is `true`, this
+ *      service also starts a schedule-queue worker that bridges
+ *      `{ jobId, scheduleName, methodName }` into
+ *      `JobLauncher.launch(jobId, params)`.
  *   3. `OnApplicationShutdown` removes every installed scheduler
  *      (via `queue.removeJobScheduler`) and closes the queue.
  *      Removal is best-effort: a partial failure logs a warning
  *      but does not block the rest of the shutdown.
  *
- * Why a dedicated service (not a method on `BullmqRuntimeService`)?
+ * Why a dedicated service (not a method on `BullmqRuntime`)?
  *   - The runtime service is `IExecutionStrategy`-facing; it
  *     knows about `JobExecution`, the in-process launch contract,
  *     and the worker bridge. Mixing scheduler concerns in would
  *     bloat its surface and couple two lifecycles that happen to
  *     share a Redis client but are otherwise independent.
- *   - The scheduler does NOT need a `Worker`; the runtime service
- *     does. A separate service can run with `autoStartWorker:
- *     false` cleanly (a launcher-only deployment that still wants
- *     cron schedules to fire).
+ *   - The schedule queue needs a different worker contract from
+ *     the runtime work queue: schedule payloads identify a job to
+ *     launch, while work payloads identify an already-created
+ *     execution/step. Keeping the bridge here avoids teaching
+ *     `BullmqRuntime` a second payload shape.
  *   - The schedule service owns its own `Queue` (the schedule
  *     queue) so cron jobs are not interleaved with manually-launched
  *     jobs. They share the same `keyPrefix` so the host's Redis
  *     namespace policy still applies.
  */
 @Injectable()
-export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicationShutdown {
-  private readonly logger = new Logger(BullmqScheduleService.name);
+export class BullmqSchedule implements OnApplicationBootstrap, OnApplicationShutdown {
+  private readonly logger = new Logger(BullmqSchedule.name);
 
   /** BullMQ queue for the scheduler (producer side only). */
   private scheduleQueue: Queue | null = null;
+  /** BullMQ worker that turns schedule fires into real batch launches. */
+  private scheduleWorker: Worker<BullmqSchedulePayload> | null = null;
 
   /**
    * Every schedule key installed during `onApplicationBootstrap`.
@@ -84,6 +99,7 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
     private readonly scheduleRegistry: BatchScheduleRegistry,
     @Inject(BULLMQ_MODULE_OPTIONS)
     private readonly options: ResolvedBullMqModuleOptions,
+    private readonly launcher: JobLauncher,
   ) {}
 
   /**
@@ -101,21 +117,25 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
    */
   onApplicationBootstrap(): void {
     this.scheduleQueue = this.buildScheduleQueue();
+    if (this.options.autoStartWorker) {
+      this.scheduleWorker = this.buildScheduleWorker();
+    }
     const entries = this.scheduleRegistry.getAll();
     for (const entry of entries) {
       try {
         this.installSchedule(entry);
       } catch (err) {
         this.logger.warn(
-          `Failed to install schedule for "${entry.jobId}::${entry.methodName}": ` +
+          `Failed to install schedule for "${entry.jobId}::${entry.scheduleName}": ` +
             `${err instanceof Error ? err.message : String(err)}`,
         );
       }
     }
     this.logger.log(
-      `BullmqScheduleService started: queue="${BULLMQ_SCHEDULE_QUEUE_NAME}" ` +
+      `BullmqSchedule started: queue="${BULLMQ_SCHEDULE_QUEUE_NAME}" ` +
         `schedules=${this.installedKeys.size}/${entries.length} ` +
-        `(skipped=${entries.length - this.installedKeys.size} inert)`,
+        `(skipped=${entries.length - this.installedKeys.size} inert) ` +
+        `worker=${this.options.autoStartWorker ? 'auto' : 'manual'}`,
     );
   }
 
@@ -154,7 +174,7 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
   private installSchedule(entry: BatchScheduleEntry): void {
     if (entry.inert) {
       this.logger.log(
-        `Skipping inert schedule: ${entry.jobId}::${entry.methodName} ` +
+        `Skipping inert schedule: ${entry.jobId}::${entry.scheduleName} ` +
           `(cron="${entry.cron}", tz="${entry.timezone}")`,
       );
       return;
@@ -164,16 +184,20 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
       // builds the queue before iterating entries, but a future
       // refactor that calls `installSchedule` from elsewhere
       // should fail loudly.
-      throw new Error('[BullmqScheduleService] scheduleQueue is null');
+      throw new Error('[BullmqSchedule] scheduleQueue is null');
     }
-    const schedulerKey = `${entry.jobId}::${entry.methodName}`;
+    const schedulerKey = `${entry.jobId}::${entry.scheduleName}`;
     const template: {
       name: string;
-      data: Record<string, unknown>;
+      data: BullmqSchedulePayload;
       opts: JobsOptions;
     } = {
-      name: entry.methodName,
-      data: { jobId: entry.jobId, methodName: entry.methodName },
+      name: entry.scheduleName,
+      data: {
+        jobId: entry.jobId,
+        scheduleName: entry.scheduleName,
+        methodName: entry.methodName,
+      },
       opts: {
         attempts: 3,
         backoff: { type: 'exponential', delay: 100, jitter: 0.5 },
@@ -221,6 +245,47 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
     });
   }
 
+  private buildScheduleWorker(): Worker<BullmqSchedulePayload> {
+    return new Worker<BullmqSchedulePayload>(
+      BULLMQ_SCHEDULE_QUEUE_NAME,
+      async (job) => this.processScheduleFire(job),
+      {
+        connection: this.workerConnectionOptions(),
+        prefix: this.options.connection.keyPrefix,
+        concurrency: 1,
+      },
+    );
+  }
+
+  private async processScheduleFire(job: Job<BullmqSchedulePayload>): Promise<void> {
+    const { jobId, scheduleName, methodName } = job.data;
+    if (typeof jobId !== 'string' || jobId.length === 0) {
+      throw new Error('[BullmqSchedule] schedule payload is missing jobId');
+    }
+    if (typeof scheduleName !== 'string' || scheduleName.length === 0) {
+      throw new Error('[BullmqSchedule] schedule payload is missing scheduleName');
+    }
+    if (typeof methodName !== 'string' || methodName.length === 0) {
+      throw new Error('[BullmqSchedule] schedule payload is missing methodName');
+    }
+
+    const scheduledAt =
+      typeof job.timestamp === 'number' && Number.isFinite(job.timestamp)
+        ? new Date(job.timestamp).toISOString()
+        : new Date().toISOString();
+    const params: JobParameters = {
+      scheduled: true,
+      scheduleName,
+      scheduledAt,
+      scheduleQueueJobId: String(job.id ?? ''),
+    };
+    const execution = await this.launcher.launch(jobId, params);
+    this.logger.log(
+      `Fired schedule ${jobId}::${scheduleName} ` +
+        `(method=${methodName}) -> execution=${execution.id} status=${execution.status}`,
+    );
+  }
+
   private producerConnectionOptions(): Record<string, unknown> {
     return {
       host: this.options.connection.host,
@@ -234,6 +299,19 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
     };
   }
 
+  private workerConnectionOptions(): Record<string, unknown> {
+    return {
+      host: this.options.connection.host,
+      port: this.options.connection.port,
+      password: this.options.connection.password,
+      username: this.options.connection.username,
+      db: this.options.connection.db,
+      ...(this.options.connection.tls ? { tls: true } : {}),
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false,
+    };
+  }
+
   // -------------------------------------------------------------------------
   // Close
   // -------------------------------------------------------------------------
@@ -246,6 +324,16 @@ export class BullmqScheduleService implements OnApplicationBootstrap, OnApplicat
    * others from being removed.
    */
   private async close(): Promise<void> {
+    if (this.scheduleWorker !== null) {
+      try {
+        await this.scheduleWorker.close();
+      } catch (err) {
+        this.logger.warn(
+          `Schedule worker close failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+      this.scheduleWorker = null;
+    }
     if (this.scheduleQueue !== null) {
       for (const key of this.installedKeys) {
         try {

package/src/index.ts

@@ -24,5 +24,5 @@
 export * from './connection';
 export * from './module-options';
 export * from './bullmq-execution-strategy';
-export * from './bullmq-schedule.service';
+export * from './bullmq-schedule';
 export * from './adapters';