@nest-batch/bullmq 0.2.0

package/dist/src/adapters/bullmq.adapter.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BullmqAdapter () {
+        return BullmqAdapter;
+    },
+    get BullmqModule () {
+        return BullmqModule;
+    }
+});
+const _common = require("@nestjs/common");
+const _core = require("@nest-batch/core");
+const _bullmqexecutionstrategy = require("../bullmq-execution-strategy");
+const _bullmqruntimeservice = require("../bullmq-runtime.service");
+const _bullmqscheduleservice = require("../bullmq-schedule.service");
+const _connection = require("../connection");
+const _moduleoptions = require("../module-options");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let BullmqModule = class BullmqModule {
+};
+BullmqModule = _ts_decorate([
+    (0, _common.Module)({})
+], BullmqModule);
+/**
+ * Sentinel token for the async-options factory chain.
+ *
+ * `forRootAsync` registers a `useFactory` provider under this token
+ * that runs the user's factory, then a second provider
+ * (`BULLMQ_MODULE_OPTIONS`) that depends on it and freezes the
+ * resolved options. A duplicate `provide` for
+ * `BULLMQ_MODULE_OPTIONS` would crash Nest's container, so the
+ * chain uses this private symbol as the intermediate step.
+ *
+ * Mirrors the `Symbol.for('@nest-batch/bullmq/OPTIONS_FACTORY')`
+ * used by the legacy `BullmqBatchModule.forRootAsync()` — the
+ * `Symbol.for` key is process-scoped and stable across module
+ * versions, so any host still wiring up the legacy class is not
+ * affected.
+ */ const OPTIONS_FACTORY = Symbol.for('@nest-batch/bullmq/OPTIONS_FACTORY');
+/**
+ * The list of exports the BullMQ adapter's `DynamicModule` exposes
+ * to the host application.
+ *
+ * Centralised so the sync and async paths stay in lockstep — any
+ * future addition (e.g. a `BullmqScheduler` controller) only needs
+ * to be added here.
+ *
+ * The set mirrors the legacy `BullmqBatchModule.forRoot()` exports
+ * (the `forRootAsync()` legacy path was missing
+ * `BullmqRuntimeService` 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
+ *     `/healthz` endpoint) can resolve the strategy class via
+ *     `moduleRef.get(EXECUTION_STRATEGY)`.
+ *   - `BULLMQ_MODULE_OPTIONS` — the resolved connection / worker
+ *     config bag, for inspection and (future) for per-role client
+ *     builders.
+ *   - `BullMqExecutionStrategy` — the concrete class, for type-
+ *     strict consumers that prefer class injection.
+ *   - `BullmqRuntimeService` — the runtime that owns the
+ *     `Queue` / `Worker` / `QueueEvents` lifecycle.
+ *   - `BullmqScheduleService` — the runtime that owns the
+ *     `@BatchScheduled` cron-to-BullMQ translation.
+ */ const ADAPTER_EXPORTS = [
+    _core.EXECUTION_STRATEGY,
+    _moduleoptions.BULLMQ_MODULE_OPTIONS,
+    _bullmqexecutionstrategy.BullMqExecutionStrategy,
+    _bullmqruntimeservice.BullmqRuntimeService,
+    _bullmqscheduleservice.BullmqScheduleService
+];
+let BullmqAdapter = class BullmqAdapter {
+    /**
+   * Synchronous configuration.
+   *
+   * Resolves the connection options up-front (`resolveBullMqConnection`
+   * fills in defaults + freezes the bag) and emits a
+   * `BatchAdapter` whose `module` is a `global: true`
+   * `DynamicModule` registering the strategy class, the runtime
+   * services, the `EXECUTION_STRATEGY` binding, and the resolved
+   * options as a value provider under `BULLMQ_MODULE_OPTIONS`.
+   *
+   * No options object is required: the module accepts an empty
+   * `{}` and applies all defaults (host `127.0.0.1`, port `6379`,
+   * keyPrefix `nest-batch:`, no auth, no TLS, `autoStartWorker:
+   * false`).
+   *
+   * @param options - Connection + worker config. All fields optional.
+   * @returns A `BatchAdapter` with `name: 'bullmq'` and the
+   *   `BullmqModule` dynamic module.
+   */ static forRoot(options = {}) {
+        const resolved = Object.freeze({
+            connection: (0, _connection.resolveBullMqConnection)(options.connection),
+            autoStartWorker: options.autoStartWorker ?? false
+        });
+        return {
+            name: 'bullmq',
+            module: buildBullmqDynamicModule({
+                providers: buildStaticProviders(resolved)
+            })
+        };
+    }
+    /**
+   * Async configuration — useful when the Redis connection comes
+   * from a config service or another async provider.
+   *
+   * The shape mirrors `NestBatchModule.forRootAsync`:
+   *   - `imports` is forwarded to the resulting
+   *     `DynamicModule.imports` (so `ConfigModule` is available
+   *     when the factory runs).
+   *   - `inject` lists the providers the factory needs in its
+   *     argument list.
+   *   - `useFactory` resolves the options bag at module-build
+   *     time. The factory's return value is treated as
+   *     `BullMqModuleOptions` and is fed through
+   *     `resolveBullMqConnection` by the `BULLMQ_MODULE_OPTIONS`
+   *     factory provider (defaults applied, bag frozen).
+   *
+   * Implementation note: the factory is registered under the
+   * package-private `OPTIONS_FACTORY` sentinel token; the
+   * `BULLMQ_MODULE_OPTIONS` provider depends on it. This is the
+   * same chain the legacy `BullmqBatchModule.forRootAsync` used
+   * — the dynamic module is built off the static provider list,
+   * with the static `BULLMQ_MODULE_OPTIONS` value provider
+   * replaced by the async factory pair.
+   *
+   * @param asyncOptions - `{ imports, inject, useFactory }` bag.
+   *   `useFactory` is required; `imports` and `inject` are
+   *   optional and default to `[]`.
+   * @returns A `BatchAdapter` with `name: 'bullmq'` and the
+   *   `BullmqModule` dynamic module (with `imports` wired).
+   */ static forRootAsync(asyncOptions) {
+        const factoryProvider = {
+            provide: OPTIONS_FACTORY,
+            useFactory: asyncOptions.useFactory,
+            inject: [
+                ...asyncOptions.inject ?? []
+            ]
+        };
+        const mergedOptionsProvider = {
+            provide: _moduleoptions.BULLMQ_MODULE_OPTIONS,
+            useFactory: (fromFactory)=>{
+                return Object.freeze({
+                    connection: (0, _connection.resolveBullMqConnection)(fromFactory?.connection),
+                    autoStartWorker: fromFactory?.autoStartWorker ?? false
+                });
+            },
+            inject: [
+                OPTIONS_FACTORY
+            ]
+        };
+        // The static provider list is the same as `forRoot` except
+        // the value provider for `BULLMQ_MODULE_OPTIONS` is replaced
+        // with the async factory above (a duplicate `provide` would
+        // crash Nest's container). We seed `buildStaticProviders`
+        // with a placeholder resolved bag (its value is discarded
+        // — the async provider overrides the slot) so the function
+        // can be the single source of truth for the rest of the
+        // provider list.
+        const baseProviders = buildStaticProviders(Object.freeze({
+            connection: (0, _connection.resolveBullMqConnection)(undefined),
+            autoStartWorker: false
+        }));
+        const filtered = baseProviders.filter((p)=>!(typeof p === 'object' && p !== null && 'provide' in p && p.provide === _moduleoptions.BULLMQ_MODULE_OPTIONS));
+        return {
+            name: 'bullmq',
+            module: buildBullmqDynamicModule({
+                providers: [
+                    factoryProvider,
+                    mergedOptionsProvider,
+                    ...filtered
+                ],
+                imports: asyncOptions.imports
+            })
+        };
+    }
+};
+/**
+ * Build the static provider list shared by `forRoot()` and
+ * `forRootAsync()`.
+ *
+ * Centralised so the sync and async paths declare the same set of
+ * providers (and any future addition — e.g. a per-role client
+ * builder — only needs to be added here).
+ *
+ * The async path then filters the `BULLMQ_MODULE_OPTIONS` entry
+ * out of the returned array and replaces it with the factory
+ * pair. Everything else is shared.
+ */ function buildStaticProviders(resolved) {
+    return [
+        _bullmqexecutionstrategy.BullMqExecutionStrategy,
+        _bullmqruntimeservice.BullmqRuntimeService,
+        _bullmqscheduleservice.BullmqScheduleService,
+        {
+            provide: _core.EXECUTION_STRATEGY,
+            useExisting: _bullmqexecutionstrategy.BullMqExecutionStrategy
+        },
+        {
+            provide: _moduleoptions.BULLMQ_MODULE_OPTIONS,
+            useValue: resolved
+        }
+    ];
+}
+/**
+ * Build the `DynamicModule` payload for the BullMQ adapter.
+ *
+ * Extracted from the two factory methods so the provider /
+ * export / global-true shape lives in one place. NestJS's
+ * `validateExportedProvider` check rejects an `exports` entry
+ * that is not in `providers` (or imported), so adding to one
+ * without the other is a silent runtime failure — keeping the
+ * two arrays synchronised by construction is the safest
+ * pattern.
+ *
+ * `imports` is optional: `forRoot` does not need any (it has no
+ * async providers), `forRootAsync` forwards the user's
+ * `imports` (typically `ConfigModule`) so the factory's
+ * `inject` targets resolve.
+ */ function buildBullmqDynamicModule(args) {
+    const module = {
+        module: BullmqModule,
+        global: true,
+        providers: args.providers,
+        exports: [
+            ...ADAPTER_EXPORTS
+        ]
+    };
+    if (args.imports !== undefined) {
+        return {
+            ...module,
+            imports: [
+                ...args.imports
+            ]
+        };
+    }
+    return module;
+}
+
+//# sourceMappingURL=bullmq.adapter.js.map

package/dist/src/adapters/bullmq.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/bullmq.adapter.ts"],"sourcesContent":["import { Module, type DynamicModule, type Provider } from '@nestjs/common';\nimport { EXECUTION_STRATEGY, type BatchAdapter } from '@nest-batch/core';\n\nimport { BullMqExecutionStrategy } from '../bullmq-execution-strategy';\nimport { BullmqRuntimeService } from '../bullmq-runtime.service';\nimport { BullmqScheduleService } from '../bullmq-schedule.service';\nimport { resolveBullMqConnection } from '../connection';\nimport {\n  BULLMQ_MODULE_OPTIONS,\n  type BullMqModuleOptions,\n  type ResolvedBullMqModuleOptions,\n} from '../module-options';\n\n/**\n * Empty Nest module class that owns the BullMQ transport's\n * provider graph.\n *\n * Mirrors `InProcessModule` in `@nest-batch/core/src/adapters/\n * in-process.adapter.ts`: the class has no body on purpose. It is\n * purely a `DynamicModule` carrier — Nest's module system requires\n * *some* class to identify the module, and the empty class is the\n * minimum possible surface (no decorators, no lifecycle hooks, no\n * metadata). All real behaviour lives on the providers.\n */\n@Module({})\nexport class BullmqModule {}\n\n/**\n * Sentinel token for the async-options factory chain.\n *\n * `forRootAsync` registers a `useFactory` provider under this token\n * that runs the user's factory, then a second provider\n * (`BULLMQ_MODULE_OPTIONS`) that depends on it and freezes the\n * resolved options. A duplicate `provide` for\n * `BULLMQ_MODULE_OPTIONS` would crash Nest's container, so the\n * chain uses this private symbol as the intermediate step.\n *\n * Mirrors the `Symbol.for('@nest-batch/bullmq/OPTIONS_FACTORY')`\n * used by the legacy `BullmqBatchModule.forRootAsync()` — the\n * `Symbol.for` key is process-scoped and stable across module\n * versions, so any host still wiring up the legacy class is not\n * affected.\n */\nconst OPTIONS_FACTORY: symbol = Symbol.for('@nest-batch/bullmq/OPTIONS_FACTORY');\n\n/**\n * The list of exports the BullMQ adapter's `DynamicModule` exposes\n * to the host application.\n *\n * Centralised so the sync and async paths stay in lockstep — any\n * future addition (e.g. a `BullmqScheduler` controller) only needs\n * to be added here.\n *\n * The set mirrors the legacy `BullmqBatchModule.forRoot()` exports\n * (the `forRootAsync()` legacy path was missing\n * `BullmqRuntimeService` from `exports` — that omission is fixed\n * here, both paths now export the same five entries).\n *\n *   - `EXECUTION_STRATEGY` — the DI token, so host code (e.g. a\n *     `/healthz` endpoint) can resolve the strategy class via\n *     `moduleRef.get(EXECUTION_STRATEGY)`.\n *   - `BULLMQ_MODULE_OPTIONS` — the resolved connection / worker\n *     config bag, for inspection and (future) for per-role client\n *     builders.\n *   - `BullMqExecutionStrategy` — the concrete class, for type-\n *     strict consumers that prefer class injection.\n *   - `BullmqRuntimeService` — the runtime that owns the\n *     `Queue` / `Worker` / `QueueEvents` lifecycle.\n *   - `BullmqScheduleService` — the runtime that owns the\n *     `@BatchScheduled` cron-to-BullMQ translation.\n */\nconst ADAPTER_EXPORTS: ReadonlyArray<symbol | typeof BullMqExecutionStrategy | typeof BullmqRuntimeService | typeof BullmqScheduleService> = [\n  EXECUTION_STRATEGY,\n  BULLMQ_MODULE_OPTIONS,\n  BullMqExecutionStrategy,\n  BullmqRuntimeService,\n  BullmqScheduleService,\n];\n\n/**\n * `BullmqAdapter` — the transport adapter for `@nest-batch/bullmq`\n * used by the new factory-pattern\n * `NestBatchModule.forRoot({ adapters: { transport, ... } })` API.\n *\n * Overrides the default `EXECUTION_STRATEGY` token with a BullMQ-\n * backed `IExecutionStrategy` (`BullMqExecutionStrategy`) and wires\n * the runtime services that own the BullMQ client lifecycle\n * (`BullmqRuntimeService` for step enqueue + worker, plus\n * `BullmqScheduleService` for `@BatchScheduled` cron entries).\n *\n * Two static methods:\n *\n *   - `forRoot(options)` — synchronous configuration. The\n *     connection options are resolved up-front and frozen under\n *     the `BULLMQ_MODULE_OPTIONS` token. Use this when the Redis\n *     host is known at module composition time.\n *\n *   - `forRootAsync({ imports, inject, useFactory })` — async\n *     configuration. The factory is registered as a sentinel\n *     provider; the `BULLMQ_MODULE_OPTIONS` provider depends on\n *     it. Use this when the connection comes from a config\n *     service or another async source.\n *\n * The two methods share the same provider list via the\n * `buildStaticProviders` helper — the only difference is whether\n * `BULLMQ_MODULE_OPTIONS` is a value provider (sync) or a factory\n * provider that resolves the user's `useFactory` result (async).\n *\n * `globalProviders` is intentionally omitted. The recommended path\n * is to expose host-visible providers via the module's own\n * `exports` (see `ADAPTER_EXPORTS` above) — the `BatchAdapter`\n * interface's `globalProviders` field is for runtime classes the\n * adapter's own module needs but that core itself would also\n * re-export. `JobLauncher` (registered by `NestBatchModule`, not\n * by this adapter) injects the strategy by the `EXECUTION_STRATEGY`\n * token, which is already in `exports`, so the resolution chain\n * works without core having to know which adapter is active.\n *\n * @example\n * ```ts\n * // Synchronous wiring (connection known at module-build time)\n * import { Module } from '@nestjs/common';\n * import { NestBatchModule, InProcessAdapter } from '@nest-batch/core';\n * import { MikroOrmAdapter } from '@nest-batch/mikro-orm';\n * import { BullmqAdapter } from '@nest-batch/bullmq';\n *\n * @Module({\n *   imports: [\n *     NestBatchModule.forRoot({\n *       adapters: {\n *         persistence: MikroOrmAdapter,\n *         transport: BullmqAdapter.forRoot({\n *           connection: {\n *             host: process.env.REDIS_HOST,\n *             port: Number(process.env.REDIS_PORT),\n *             keyPrefix: 'nest-batch:',\n *           },\n *           autoStartWorker: true,\n *         }),\n *       },\n *     }),\n *   ],\n * })\n * class AppModule {}\n * ```\n *\n * @example\n * ```ts\n * // Async wiring (connection sourced from ConfigService)\n * BullmqAdapter.forRootAsync({\n *   imports: [ConfigModule],\n *   inject: [ConfigService],\n *   useFactory: (cfg: ConfigService) => ({\n *     connection: {\n *       host: cfg.get<string>('redis.host'),\n *       port: cfg.get<number>('redis.port'),\n *       password: cfg.get<string>('redis.password'),\n *     },\n *   }),\n * });\n * ```\n */\nexport class BullmqAdapter {\n  /**\n   * Synchronous configuration.\n   *\n   * Resolves the connection options up-front (`resolveBullMqConnection`\n   * fills in defaults + freezes the bag) and emits a\n   * `BatchAdapter` whose `module` is a `global: true`\n   * `DynamicModule` registering the strategy class, the runtime\n   * services, the `EXECUTION_STRATEGY` binding, and the resolved\n   * options as a value provider under `BULLMQ_MODULE_OPTIONS`.\n   *\n   * No options object is required: the module accepts an empty\n   * `{}` and applies all defaults (host `127.0.0.1`, port `6379`,\n   * keyPrefix `nest-batch:`, no auth, no TLS, `autoStartWorker:\n   * false`).\n   *\n   * @param options - Connection + worker config. All fields optional.\n   * @returns A `BatchAdapter` with `name: 'bullmq'` and the\n   *   `BullmqModule` dynamic module.\n   */\n  static forRoot(options: BullMqModuleOptions = {}): BatchAdapter {\n    const resolved: ResolvedBullMqModuleOptions = Object.freeze({\n      connection: resolveBullMqConnection(options.connection),\n      autoStartWorker: options.autoStartWorker ?? false,\n    });\n    return {\n      name: 'bullmq',\n      module: buildBullmqDynamicModule({\n        providers: buildStaticProviders(resolved),\n      }),\n    };\n  }\n\n  /**\n   * Async configuration — useful when the Redis connection comes\n   * from a config service or another async provider.\n   *\n   * The shape mirrors `NestBatchModule.forRootAsync`:\n   *   - `imports` is forwarded to the resulting\n   *     `DynamicModule.imports` (so `ConfigModule` is available\n   *     when the factory runs).\n   *   - `inject` lists the providers the factory needs in its\n   *     argument list.\n   *   - `useFactory` resolves the options bag at module-build\n   *     time. The factory's return value is treated as\n   *     `BullMqModuleOptions` and is fed through\n   *     `resolveBullMqConnection` by the `BULLMQ_MODULE_OPTIONS`\n   *     factory provider (defaults applied, bag frozen).\n   *\n   * Implementation note: the factory is registered under the\n   * package-private `OPTIONS_FACTORY` sentinel token; the\n   * `BULLMQ_MODULE_OPTIONS` provider depends on it. This is the\n   * same chain the legacy `BullmqBatchModule.forRootAsync` used\n   * — the dynamic module is built off the static provider list,\n   * with the static `BULLMQ_MODULE_OPTIONS` value provider\n   * replaced by the async factory pair.\n   *\n   * @param asyncOptions - `{ imports, inject, useFactory }` bag.\n   *   `useFactory` is required; `imports` and `inject` are\n   *   optional and default to `[]`.\n   * @returns A `BatchAdapter` with `name: 'bullmq'` and the\n   *   `BullmqModule` dynamic module (with `imports` wired).\n   */\n  static forRootAsync(asyncOptions: {\n    imports?: DynamicModule['imports'];\n    inject?: readonly unknown[];\n    useFactory: (\n      ...args: unknown[]\n    ) => Promise<BullMqModuleOptions> | BullMqModuleOptions;\n  }): BatchAdapter {\n    const factoryProvider: Provider = {\n      provide: OPTIONS_FACTORY,\n      useFactory: asyncOptions.useFactory as (...args: unknown[]) => unknown,\n      inject: [...(asyncOptions.inject ?? [])] as Array<string | symbol | Function>,\n    };\n\n    const mergedOptionsProvider: Provider = {\n      provide: BULLMQ_MODULE_OPTIONS,\n      useFactory: (\n        fromFactory: BullMqModuleOptions | undefined,\n      ): ResolvedBullMqModuleOptions => {\n        return Object.freeze({\n          connection: resolveBullMqConnection(fromFactory?.connection),\n          autoStartWorker: fromFactory?.autoStartWorker ?? false,\n        });\n      },\n      inject: [OPTIONS_FACTORY],\n    };\n\n    // The static provider list is the same as `forRoot` except\n    // the value provider for `BULLMQ_MODULE_OPTIONS` is replaced\n    // with the async factory above (a duplicate `provide` would\n    // crash Nest's container). We seed `buildStaticProviders`\n    // with a placeholder resolved bag (its value is discarded\n    // — the async provider overrides the slot) so the function\n    // can be the single source of truth for the rest of the\n    // provider list.\n    const baseProviders = buildStaticProviders(\n      Object.freeze({\n        connection: resolveBullMqConnection(undefined),\n        autoStartWorker: false,\n      }),\n    );\n    const filtered = baseProviders.filter(\n      (p) =>\n        !(\n          typeof p === 'object' &&\n          p !== null &&\n          'provide' in p &&\n          (p as { provide: unknown }).provide === BULLMQ_MODULE_OPTIONS\n        ),\n    );\n\n    return {\n      name: 'bullmq',\n      module: buildBullmqDynamicModule({\n        providers: [factoryProvider, mergedOptionsProvider, ...filtered],\n        imports: asyncOptions.imports,\n      }),\n    };\n  }\n}\n\n/**\n * Build the static provider list shared by `forRoot()` and\n * `forRootAsync()`.\n *\n * Centralised so the sync and async paths declare the same set of\n * providers (and any future addition — e.g. a per-role client\n * builder — only needs to be added here).\n *\n * The async path then filters the `BULLMQ_MODULE_OPTIONS` entry\n * out of the returned array and replaces it with the factory\n * pair. Everything else is shared.\n */\nfunction buildStaticProviders(\n  resolved: ResolvedBullMqModuleOptions,\n): Provider[] {\n  return [\n    BullMqExecutionStrategy,\n    BullmqRuntimeService,\n    BullmqScheduleService,\n    {\n      provide: EXECUTION_STRATEGY,\n      useExisting: BullMqExecutionStrategy,\n    },\n    {\n      provide: BULLMQ_MODULE_OPTIONS,\n      useValue: resolved,\n    },\n  ];\n}\n\n/**\n * Build the `DynamicModule` payload for the BullMQ adapter.\n *\n * Extracted from the two factory methods so the provider /\n * export / global-true shape lives in one place. NestJS's\n * `validateExportedProvider` check rejects an `exports` entry\n * that is not in `providers` (or imported), so adding to one\n * without the other is a silent runtime failure — keeping the\n * two arrays synchronised by construction is the safest\n * pattern.\n *\n * `imports` is optional: `forRoot` does not need any (it has no\n * async providers), `forRootAsync` forwards the user's\n * `imports` (typically `ConfigModule`) so the factory's\n * `inject` targets resolve.\n */\nfunction buildBullmqDynamicModule(args: {\n  providers: Provider[];\n  imports?: DynamicModule['imports'];\n}): DynamicModule {\n  const module: DynamicModule = {\n    module: BullmqModule,\n    global: true,\n    providers: args.providers,\n    exports: [...ADAPTER_EXPORTS],\n  };\n  if (args.imports !== undefined) {\n    return { ...module, imports: [...args.imports] };\n  }\n  return module;\n}\n"],"names":["BullmqAdapter","BullmqModule","OPTIONS_FACTORY","Symbol","for","ADAPTER_EXPORTS","EXECUTION_STRATEGY","BULLMQ_MODULE_OPTIONS","BullMqExecutionStrategy","BullmqRuntimeService","BullmqScheduleService","forRoot","options","resolved","Object","freeze","connection","resolveBullMqConnection","autoStartWorker","name","module","buildBullmqDynamicModule","providers","buildStaticProviders","forRootAsync","asyncOptions","factoryProvider","provide","useFactory","inject","mergedOptionsProvider","fromFactory","baseProviders","undefined","filtered","filter","p","imports","useExisting","useValue","args","global","exports"],"mappings":";;;;;;;;;;;QAkKaA;eAAAA;;QAzIAC;eAAAA;;;wBAzB6C;sBACJ;yCAEd;sCACH;uCACC;4BACE;+BAKjC;;;;;;;AAcA,IAAA,AAAMA,eAAN,MAAMA;AAAc;;;;AAE3B;;;;;;;;;;;;;;;CAeC,GACD,MAAMC,kBAA0BC,OAAOC,GAAG,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,MAAMC,kBAAuI;IAC3IC,wBAAkB;IAClBC,oCAAqB;IACrBC,gDAAuB;IACvBC,0CAAoB;IACpBC,4CAAqB;CACtB;AAqFM,IAAA,AAAMV,gBAAN,MAAMA;IACX;;;;;;;;;;;;;;;;;;GAkBC,GACD,OAAOW,QAAQC,UAA+B,CAAC,CAAC,EAAgB;QAC9D,MAAMC,WAAwCC,OAAOC,MAAM,CAAC;YAC1DC,YAAYC,IAAAA,mCAAuB,EAACL,QAAQI,UAAU;YACtDE,iBAAiBN,QAAQM,eAAe,IAAI;QAC9C;QACA,OAAO;YACLC,MAAM;YACNC,QAAQC,yBAAyB;gBAC/BC,WAAWC,qBAAqBV;YAClC;QACF;IACF;IAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BC,GACD,OAAOW,aAAaC,YAMnB,EAAgB;QACf,MAAMC,kBAA4B;YAChCC,SAASzB;YACT0B,YAAYH,aAAaG,UAAU;YACnCC,QAAQ;mBAAKJ,aAAaI,MAAM,IAAI,EAAE;aAAE;QAC1C;QAEA,MAAMC,wBAAkC;YACtCH,SAASpB,oCAAqB;YAC9BqB,YAAY,CACVG;gBAEA,OAAOjB,OAAOC,MAAM,CAAC;oBACnBC,YAAYC,IAAAA,mCAAuB,EAACc,aAAaf;oBACjDE,iBAAiBa,aAAab,mBAAmB;gBACnD;YACF;YACAW,QAAQ;gBAAC3B;aAAgB;QAC3B;QAEA,2DAA2D;QAC3D,6DAA6D;QAC7D,4DAA4D;QAC5D,0DAA0D;QAC1D,0DAA0D;QAC1D,2DAA2D;QAC3D,wDAAwD;QACxD,iBAAiB;QACjB,MAAM8B,gBAAgBT,qBACpBT,OAAOC,MAAM,CAAC;YACZC,YAAYC,IAAAA,mCAAuB,EAACgB;YACpCf,iBAAiB;QACnB;QAEF,MAAMgB,WAAWF,cAAcG,MAAM,CACnC,CAACC,IACC,CACE,CAAA,OAAOA,MAAM,YACbA,MAAM,QACN,aAAaA,KACb,AAACA,EAA2BT,OAAO,KAAKpB,oCAAqB,AAAD;QAIlE,OAAO;YACLY,MAAM;YACNC,QAAQC,yBAAyB;gBAC/BC,WAAW;oBAACI;oBAAiBI;uBAA0BI;iBAAS;gBAChEG,SAASZ,aAAaY,OAAO;YAC/B;QACF;IACF;AACF;AAEA;;;;;;;;;;;CAWC,GACD,SAASd,qBACPV,QAAqC;IAErC,OAAO;QACLL,gDAAuB;QACvBC,0CAAoB;QACpBC,4CAAqB;QACrB;YACEiB,SAASrB,wBAAkB;YAC3BgC,aAAa9B,gDAAuB;QACtC;QACA;YACEmB,SAASpB,oCAAqB;YAC9BgC,UAAU1B;QACZ;KACD;AACH;AAEA;;;;;;;;;;;;;;;CAeC,GACD,SAASQ,yBAAyBmB,IAGjC;IACC,MAAMpB,SAAwB;QAC5BA,QAAQnB;QACRwC,QAAQ;QACRnB,WAAWkB,KAAKlB,SAAS;QACzBoB,SAAS;eAAIrC;SAAgB;IAC/B;IACA,IAAImC,KAAKH,OAAO,KAAKJ,WAAW;QAC9B,OAAO;YAAE,GAAGb,MAAM;YAAEiB,SAAS;mBAAIG,KAAKH,OAAO;aAAC;QAAC;IACjD;IACA,OAAOjB;AACT"}

package/dist/src/adapters/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public surface for the BullMQ adapter factory.
+ *
+ * The `BullmqAdapter` is the only entry point the host should
+ * depend on for the new factory-pattern API. The internal module
+ * class (`BullmqModule`) is exported alongside it as a NestJS
+ * identifier — it is safe to reference from test code that needs
+ * to assert on the `module` field of the adapter value, but it
+ * has no runtime surface beyond the empty class body.
+ */
+export * from './bullmq.adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,kBAAkB,CAAC"}

package/dist/src/adapters/index.js

@@ -0,0 +1,29 @@
+/**
+ * Public surface for the BullMQ adapter factory.
+ *
+ * The `BullmqAdapter` is the only entry point the host should
+ * depend on for the new factory-pattern API. The internal module
+ * class (`BullmqModule`) is exported alongside it as a NestJS
+ * identifier — it is safe to reference from test code that needs
+ * to assert on the `module` field of the adapter value, but it
+ * has no runtime surface beyond the empty class body.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./bullmq.adapter"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/src/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/index.ts"],"sourcesContent":["/**\n * Public surface for the BullMQ adapter factory.\n *\n * The `BullmqAdapter` is the only entry point the host should\n * depend on for the new factory-pattern API. The internal module\n * class (`BullmqModule`) is exported alongside it as a NestJS\n * identifier — it is safe to reference from test code that needs\n * to assert on the `module` field of the adapter value, but it\n * has no runtime surface beyond the empty class body.\n */\nexport * from './bullmq.adapter';\n"],"names":[],"mappings":"AAAA;;;;;;;;;CASC;;;;qBACa"}

package/dist/src/bullmq-execution-strategy.d.ts

@@ -0,0 +1,59 @@
+import { type ExecutionStrategyContext, type IExecutionStrategy, type JobDefinition, type JobParameters, type LaunchResult } from '@nest-batch/core';
+import { BullmqRuntimeService, BULLMQ_STRATEGY_NAME } from './bullmq-runtime.service';
+/**
+ * BullMQ execution strategy — the `@nest-batch/core`-facing
+ * transport that hands a `JobExecution` off to a BullMQ `Queue`
+ * and lets a `Worker` process the work.
+ *
+ * Design (T18):
+ *   - The actual BullMQ resource ownership (queue / worker /
+ *     queue-events lifecycle, connection tuning, event bridge)
+ *     lives in `BullmqRuntimeService`. 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
+ *     independently testable (e.g. a test that wants to drive
+ *     the worker without going through the launcher can
+ *     instantiate the runtime service alone), and lets the
+ *     strategy class stay as a stable public surface for
+ *     `EXECUTION_STRATEGY` consumers.
+ *   - The strategy inherits the runtime service's
+ *     `name` (`'bullmq'`) — the runtime service is the
+ *     single source of truth for the strategy name.
+ *
+ * `name` and `launch()` together comprise the T18 contract:
+ *   - `name = 'bullmq'` — replaces the T17 stub's
+ *     `'bullmq-stub'` so log lines and boundary reports can
+ *     tell the real implementation from the skeleton.
+ *   - `launch()` enqueues exactly one BullMQ job per step
+ *     (one job per step, NEVER one job per row/chunk) and
+ *     returns `{ kind: 'enqueued', queueJobId }`. The launch
+ *     is fire-and-forget; the launcher re-resolves the
+ *     canonical `JobExecution` from the repository.
+ */
+export declare class BullMqExecutionStrategy implements IExecutionStrategy {
+    private readonly runtime;
+    /** Strategy name. Mirrors the runtime service's name. */
+    readonly name = "bullmq";
+    private readonly logger;
+    constructor(runtime: BullmqRuntimeService);
+    /**
+     * Enqueue the work and return the BullMQ job id. The DB
+     * execution row was created by the launcher BEFORE this
+     * method was called — this method MUST NOT re-create it
+     * (the launcher's atomic create-or-lock would race with us).
+     *
+     * Throws on producer failure. The launcher propagates the
+     * error to its caller; the canonical `JobExecution` row
+     * stays in `STARTING` and the host's recovery path is
+     * responsible for transitioning it (a future task will
+     * wire a "dead letter" cleanup).
+     */
+    launch(job: JobDefinition, params: JobParameters, ctx: ExecutionStrategyContext): Promise<LaunchResult>;
+}
+/**
+ * Re-export the canonical `name` for tests that want to assert
+ * on it without importing the runtime service directly.
+ */
+export { BULLMQ_STRATEGY_NAME };
+//# sourceMappingURL=bullmq-execution-strategy.d.ts.map

package/dist/src/bullmq-execution-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullmq-execution-strategy.d.ts","sourceRoot":"","sources":["../../src/bullmq-execution-strategy.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBACa,uBAAwB,YAAW,kBAAkB;IAMpD,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,yDAAyD;IACzD,QAAQ,CAAC,IAAI,YAAwB;IAErC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;gBAEtC,OAAO,EAAE,oBAAoB;IAE1D;;;;;;;;;;;OAWG;IACG,MAAM,CACV,GAAG,EAAE,aAAa,EAClB,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,wBAAwB,GAC5B,OAAO,CAAC,YAAY,CAAC;CAGzB;AAED;;;GAGG;AACH,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/src/bullmq-execution-strategy.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BULLMQ_STRATEGY_NAME () {
+        return _bullmqruntimeservice.BULLMQ_STRATEGY_NAME;
+    },
+    get BullMqExecutionStrategy () {
+        return BullMqExecutionStrategy;
+    }
+});
+const _common = require("@nestjs/common");
+const _bullmqruntimeservice = require("./bullmq-runtime.service");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let BullMqExecutionStrategy = class BullMqExecutionStrategy {
+    runtime;
+    /** Strategy name. Mirrors the runtime service's name. */ name = _bullmqruntimeservice.BULLMQ_STRATEGY_NAME;
+    logger = new _common.Logger(BullMqExecutionStrategy.name);
+    constructor(runtime){
+        this.runtime = runtime;
+    }
+    /**
+   * Enqueue the work and return the BullMQ job id. The DB
+   * execution row was created by the launcher BEFORE this
+   * method was called — this method MUST NOT re-create it
+   * (the launcher's atomic create-or-lock would race with us).
+   *
+   * Throws on producer failure. The launcher propagates the
+   * error to its caller; the canonical `JobExecution` row
+   * stays in `STARTING` and the host's recovery path is
+   * responsible for transitioning it (a future task will
+   * wire a "dead letter" cleanup).
+   */ async launch(job, params, ctx) {
+        return this.runtime.launch(job, params, ctx);
+    }
+};
+BullMqExecutionStrategy = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _bullmqruntimeservice.BullmqRuntimeService === "undefined" ? Object : _bullmqruntimeservice.BullmqRuntimeService
+    ])
+], BullMqExecutionStrategy);
+
+//# sourceMappingURL=bullmq-execution-strategy.js.map

package/dist/src/bullmq-execution-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bullmq-execution-strategy.ts"],"sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\n\nimport {\n  type ExecutionStrategyContext,\n  type IExecutionStrategy,\n  type JobDefinition,\n  type JobParameters,\n  type LaunchResult,\n} from '@nest-batch/core';\n\nimport {\n  BullmqRuntimeService,\n  BULLMQ_STRATEGY_NAME,\n} from './bullmq-runtime.service';\n\n/**\n * BullMQ execution strategy — the `@nest-batch/core`-facing\n * transport that hands a `JobExecution` off to a BullMQ `Queue`\n * and lets a `Worker` process the work.\n *\n * Design (T18):\n *   - The actual BullMQ resource ownership (queue / worker /\n *     queue-events lifecycle, connection tuning, event bridge)\n *     lives in `BullmqRuntimeService`. This class is a thin\n *     adapter that maps the `IExecutionStrategy` contract to\n *     the runtime service's `launch()` shape.\n *   - Splitting the two lets the runtime service be\n *     independently testable (e.g. a test that wants to drive\n *     the worker without going through the launcher can\n *     instantiate the runtime service alone), and lets the\n *     strategy class stay as a stable public surface for\n *     `EXECUTION_STRATEGY` consumers.\n *   - The strategy inherits the runtime service's\n *     `name` (`'bullmq'`) — the runtime service is the\n *     single source of truth for the strategy name.\n *\n * `name` and `launch()` together comprise the T18 contract:\n *   - `name = 'bullmq'` — replaces the T17 stub's\n *     `'bullmq-stub'` so log lines and boundary reports can\n *     tell the real implementation from the skeleton.\n *   - `launch()` enqueues exactly one BullMQ job per step\n *     (one job per step, NEVER one job per row/chunk) and\n *     returns `{ kind: 'enqueued', queueJobId }`. The launch\n *     is fire-and-forget; the launcher re-resolves the\n *     canonical `JobExecution` from the repository.\n */\n@Injectable()\nexport class BullMqExecutionStrategy implements IExecutionStrategy {\n  /** Strategy name. Mirrors the runtime service's name. */\n  readonly name = BULLMQ_STRATEGY_NAME;\n\n  private readonly logger = new Logger(BullMqExecutionStrategy.name);\n\n  constructor(private readonly runtime: BullmqRuntimeService) {}\n\n  /**\n   * Enqueue the work and return the BullMQ job id. The DB\n   * execution row was created by the launcher BEFORE this\n   * method was called — this method MUST NOT re-create it\n   * (the launcher's atomic create-or-lock would race with us).\n   *\n   * Throws on producer failure. The launcher propagates the\n   * error to its caller; the canonical `JobExecution` row\n   * stays in `STARTING` and the host's recovery path is\n   * responsible for transitioning it (a future task will\n   * wire a \"dead letter\" cleanup).\n   */\n  async launch(\n    job: JobDefinition,\n    params: JobParameters,\n    ctx: ExecutionStrategyContext,\n  ): Promise<LaunchResult> {\n    return this.runtime.launch(job, params, ctx);\n  }\n}\n\n/**\n * Re-export the canonical `name` for tests that want to assert\n * on it without importing the runtime service directly.\n */\nexport { BULLMQ_STRATEGY_NAME };\n"],"names":["BULLMQ_STRATEGY_NAME","BullMqExecutionStrategy","name","logger","Logger","runtime","launch","job","params","ctx"],"mappings":";;;;;;;;;;;QAgFSA;eAAAA,0CAAoB;;QAjChBC;eAAAA;;;wBA/CsB;sCAa5B;;;;;;;;;;AAkCA,IAAA,AAAMA,0BAAN,MAAMA;;IACX,uDAAuD,GACvD,AAASC,OAAOF,0CAAoB,CAAC;IAEpBG,SAAS,IAAIC,cAAM,CAACH,wBAAwBC,IAAI,EAAE;IAEnE,YAAY,AAAiBG,OAA6B,CAAE;aAA/BA,UAAAA;IAAgC;IAE7D;;;;;;;;;;;GAWC,GACD,MAAMC,OACJC,GAAkB,EAClBC,MAAqB,EACrBC,GAA6B,EACN;QACvB,OAAO,IAAI,CAACJ,OAAO,CAACC,MAAM,CAACC,KAAKC,QAAQC;IAC1C;AACF"}