@nest-batch/core 0.2.0

package/dist/src/module/nest-batch.module.js

@@ -0,0 +1,475 @@
+"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 BatchBootstrapper () {
+        return BatchBootstrapper;
+    },
+    get IN_PROCESS_EXECUTION_STRATEGY_PROVIDER () {
+        return _inprocessexecutionstrategy.IN_PROCESS_EXECUTION_STRATEGY_PROVIDER;
+    },
+    get InProcessExecutionStrategy () {
+        return _inprocessexecutionstrategy.InProcessExecutionStrategy;
+    },
+    get NestBatchModule () {
+        return NestBatchModule;
+    }
+});
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _definitioncompiler = require("../compiler/definition-compiler");
+const _batchexplorer = require("../explorer/batch-explorer");
+const _jobregistry = require("../registry/job-registry");
+const _jobexecutor = require("../execution/job-executor");
+const _chunkstepexecutor = require("../execution/chunk-step-executor");
+const _taskletstepexecutor = require("../execution/tasklet-step-executor");
+const _listenerinvoker = require("../execution/listener-invoker");
+const _joblauncher = require("../execution/job-launcher");
+const _jobexplorer = require("../execution/job-explorer");
+const _joboperator = require("../execution/job-operator");
+const _batchworkerrunner = require("../execution/batch-worker-runner");
+const _inprocessexecutionstrategy = require("../execution/in-process-execution-strategy");
+const _flowevaluator = require("../flow/flow-evaluator");
+const _constants = require("../decorators/constants");
+const _batchscheduleregistry = require("./batch-schedule-registry");
+const _tokens = require("./tokens");
+const _jobrepository = require("../core/repository/job-repository");
+const _transactionmanager = require("../core/transaction/transaction-manager");
+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);
+}
+/**
+ * Sentinel provider token used by `forRootAsync` to plumb the user's
+ * `useFactory` through DI. The factory is registered under this
+ * token, and `MODULE_OPTIONS_TOKEN` resolves to its output via a
+ * follow-up `useFactory` provider.
+ *
+ * `Symbol.for(...)` makes the token stable across module boundaries:
+ * tooling or sibling packages that know the description string can
+ * resolve the same symbol without importing this file. Matches the
+ * convention used by `BATCH_SCHEDULE_REGISTRY`, `MODULE_OPTIONS_TOKEN`,
+ * `JOB_REPOSITORY_TOKEN`, etc. in `./tokens.ts`.
+ */ const OPTIONS_FACTORY = Symbol.for('@nest-batch/core/OPTIONS_FACTORY');
+let BatchBootstrapper = class BatchBootstrapper {
+    explorer;
+    compiler;
+    registry;
+    scheduleRegistry;
+    logger = new _common.Logger(BatchBootstrapper.name);
+    constructor(explorer, compiler, registry, scheduleRegistry){
+        this.explorer = explorer;
+        this.compiler = compiler;
+        this.registry = registry;
+        this.scheduleRegistry = scheduleRegistry;
+    }
+    onApplicationBootstrap() {
+        // 1. Compile + register every discovered job.
+        for (const discovered of this.explorer.getDiscovered()){
+            const jobId = discovered.jobOptions.id;
+            try {
+                const def = this.compiler.compileFromDiscovered(discovered);
+                this.registry.register(def);
+                this.logger.log(`Registered job "${jobId}"`);
+            } catch (err) {
+                this.logger.error(`Failed to register job "${jobId}": ${err.message}`);
+                throw err;
+            }
+        }
+        // 2. Walk the same discovered set for @BatchScheduled metadata
+        //    and populate BatchScheduleRegistry. The metadata is stamped
+        //    by the decorator via `SetMetadata(KEY, value)`, which Nest
+        //    writes to the *function reference* of the decorated method
+        //    (not to the prototype+name slot). We therefore read it from
+        //    `prototype[name]` (the function), not from the (proto, name)
+        //    tuple.
+        for (const discovered of this.explorer.getDiscovered()){
+            const jobId = discovered.jobOptions.id;
+            const prototype = discovered.classRef.prototype;
+            for (const name of this.allMethodNames(prototype)){
+                const fn = prototype[name];
+                if (typeof fn !== 'function') continue;
+                const meta = Reflect.getMetadata(_constants.BATCH_SCHEDULED_OPTIONS, fn);
+                if (!meta) continue;
+                const entry = {
+                    jobId,
+                    methodName: name,
+                    cron: meta.cron,
+                    timezone: meta.options.timezone,
+                    overlap: meta.options.overlap,
+                    startAt: meta.options.startAt,
+                    endAt: meta.options.endAt,
+                    inert: meta.inert
+                };
+                try {
+                    this.scheduleRegistry.register(entry);
+                    this.logger.log(`Registered schedule for job "${jobId}"::${name} (cron="${meta.cron}", tz="${meta.options.timezone}")`);
+                } catch (err) {
+                    this.logger.error(`Failed to register schedule for job "${jobId}"::${name}: ${err.message}`);
+                    throw err;
+                }
+            }
+        }
+    }
+    /**
+   * Walk the prototype chain and return every own method name
+   * (excluding `constructor`) up to (but not including)
+   * `Object.prototype`. Same shape as `BatchExplorer.allMethodNames` —
+   * we duplicate the walker here so the bootstrapper remains
+   * independent of the explorer's internals.
+   */ allMethodNames(prototype) {
+        const names = new Set();
+        let proto = prototype;
+        while(proto && proto !== Object.prototype){
+            for (const name of Object.getOwnPropertyNames(proto)){
+                if (name === 'constructor') continue;
+                names.add(name);
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return names;
+    }
+};
+BatchBootstrapper = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _batchexplorer.BatchExplorer === "undefined" ? Object : _batchexplorer.BatchExplorer,
+        typeof _definitioncompiler.DefinitionCompiler === "undefined" ? Object : _definitioncompiler.DefinitionCompiler,
+        typeof _jobregistry.JobRegistry === "undefined" ? Object : _jobregistry.JobRegistry,
+        typeof _batchscheduleregistry.BatchScheduleRegistry === "undefined" ? Object : _batchscheduleregistry.BatchScheduleRegistry
+    ])
+], BatchBootstrapper);
+let NestBatchModule = class NestBatchModule {
+    /**
+   * Build a provider list from an adapter's `globalProviders`,
+   * automatically aliasing the abstract `JobRepository` class to
+   * `JOB_REPOSITORY_TOKEN` when the symbol is present but the class
+   * itself is not directly provided.
+   *
+   * This fixes the NestJS DI resolution gap: `JobExecutor`,
+   * `JobLauncher`, and `InProcessExecutionStrategy` all inject the
+   * abstract `JobRepository`, but adapters typically bind their
+   * concrete implementation to `JOB_REPOSITORY_TOKEN`. NestJS cannot
+   * resolve abstract class → concrete subclass automatically, so we
+   * inject the alias here.
+   *
+   * Idempotent: if `JobRepository` is already directly provided (e.g.
+   * `{ provide: JobRepository, useClass: MyRepo }`), no extra alias is
+   * added.
+   */ static buildProviders(adapterGlobalProviders) {
+        const providers = [
+            ...adapterGlobalProviders
+        ];
+        const hasJobRepositoryToken = providers.some((p)=>typeof p === 'object' && p !== null && 'provide' in p && p.provide === _tokens.JOB_REPOSITORY_TOKEN);
+        const hasJobRepositoryClass = providers.some((p)=>p === _jobrepository.JobRepository || typeof p === 'object' && p !== null && 'provide' in p && p.provide === _jobrepository.JobRepository);
+        if (hasJobRepositoryToken && !hasJobRepositoryClass) {
+            providers.push({
+                provide: _jobrepository.JobRepository,
+                useExisting: _tokens.JOB_REPOSITORY_TOKEN
+            });
+        }
+        const hasTransactionManagerToken = providers.some((p)=>typeof p === 'object' && p !== null && 'provide' in p && p.provide === _tokens.TRANSACTION_MANAGER_TOKEN);
+        const hasTransactionManagerClass = providers.some((p)=>p === _transactionmanager.TransactionManager || typeof p === 'object' && p !== null && 'provide' in p && p.provide === _transactionmanager.TransactionManager);
+        if (hasTransactionManagerToken && !hasTransactionManagerClass) {
+            providers.push({
+                provide: _transactionmanager.TransactionManager,
+                useExisting: _tokens.TRANSACTION_MANAGER_TOKEN
+            });
+        }
+        return providers;
+    }
+    /**
+   * Best-effort resolution of `inject` tokens by reading the
+   * `providers` metadata of modules listed in `imports`. This lets
+   * `forRootAsync` evaluate a synchronous `useFactory` even when it
+   * declares `inject` deps, provided those deps are `useValue`
+   * providers exported by an imported module.
+   *
+   * Only `useValue` providers can be resolved this way — `useClass`
+   * and `useFactory` providers need Nest's DI container and are
+   * skipped.
+   */ static resolveInjectValues(imports, inject) {
+        if (!inject || inject.length === 0) return [];
+        const values = [];
+        for (const token of inject){
+            let resolved = undefined;
+            for (const mod of imports ?? []){
+                if (!mod) continue;
+                let providers;
+                if (typeof mod === 'object' && 'module' in mod) {
+                    const dynamicMod = mod;
+                    providers = dynamicMod.providers;
+                    if (!providers && dynamicMod.module) {
+                        try {
+                            providers = Reflect.getMetadata('providers', dynamicMod.module);
+                        } catch  {
+                        /* ignore metadata read failures */ }
+                    }
+                } else if (typeof mod === 'function') {
+                    try {
+                        providers = Reflect.getMetadata('providers', mod);
+                    } catch  {
+                    /* ignore metadata read failures */ }
+                }
+                for (const p of providers ?? []){
+                    if (typeof p === 'object' && p !== null && 'provide' in p && p.provide === token && 'useValue' in p) {
+                        resolved = p.useValue;
+                        break;
+                    }
+                }
+                if (resolved !== undefined) break;
+            }
+            values.push(resolved);
+        }
+        return values;
+    }
+    /**
+   * Static (synchronous) configuration.
+   *
+   * Takes the resolved `BatchAdaptersConfig` and builds a
+   * `global: true` `DynamicModule` that:
+   *
+   *   1. imports each adapter's `DynamicModule`
+   *      (`adapters.persistence.module` and `adapters.transport.module`);
+   *   2. imports `DiscoveryModule` from `@nestjs/core` so the explorer
+   *      can use Nest's `DiscoveryService`;
+   *   3. registers core's own providers — `JobRegistry`,
+   *      `DefinitionCompiler`, `BatchExplorer`, `FlowEvaluator`,
+   *      `BatchScheduleRegistry`, `BatchBootstrapper` — and the
+   *      executor subgraph (`JobExecutor`, `ChunkStepExecutor`,
+   *      `TaskletStepExecutor`, `ListenerInvoker`) so the host
+   *      does not have to wire them by hand;
+   *   4. registers each adapter's `globalProviders` (e.g. the
+   *      `JobRepository` / `TransactionManager` implementations
+   *      from a persistence adapter) so the host can inject them
+   *      too;
+   *   5. binds the `BatchAdaptersConfig` to `MODULE_OPTIONS_TOKEN`
+   *      via a value provider for adapter introspection.
+   */ static forRoot(options) {
+        const { adapters } = options;
+        const persistenceProviders = NestBatchModule.buildProviders(adapters.persistence.globalProviders ?? []);
+        const transportProviders = NestBatchModule.buildProviders(adapters.transport.globalProviders ?? []);
+        return {
+            module: NestBatchModule,
+            global: true,
+            imports: [
+                adapters.persistence.module,
+                adapters.transport.module,
+                _core.DiscoveryModule
+            ],
+            providers: [
+                // Core classes (discovery + compile + register).
+                _jobregistry.JobRegistry,
+                _definitioncompiler.DefinitionCompiler,
+                _batchexplorer.BatchExplorer,
+                _flowevaluator.FlowEvaluator,
+                _batchscheduleregistry.BatchScheduleRegistry,
+                BatchBootstrapper,
+                // Executor subgraph (JobExecutor → Chunk/Tasklet/Listener).
+                _jobexecutor.JobExecutor,
+                _chunkstepexecutor.ChunkStepExecutor,
+                _taskletstepexecutor.TaskletStepExecutor,
+                _listenerinvoker.ListenerInvoker,
+                _joblauncher.JobLauncher,
+                _jobexplorer.JobExplorer,
+                _joboperator.JobOperator,
+                _batchworkerrunner.BatchWorkerRunner,
+                // Resolved options bag for adapter introspection.
+                {
+                    provide: _tokens.MODULE_OPTIONS_TOKEN,
+                    useValue: adapters
+                },
+                // Schedule registry symbol alias — the symbol itself
+                // must be a provider (not just a class export) so the
+                // `exports` entry below resolves through Nest's DI
+                // validation.
+                {
+                    provide: _tokens.BATCH_SCHEDULE_REGISTRY,
+                    useExisting: _batchscheduleregistry.BatchScheduleRegistry
+                },
+                // Adapter-supplied global providers (e.g. JobRepository
+                // / TransactionManager implementations).
+                ...persistenceProviders,
+                ...transportProviders
+            ],
+            exports: [
+                // Core classes — exported so sibling packages and the
+                // host app can resolve them from the global module chain.
+                _jobregistry.JobRegistry,
+                _definitioncompiler.DefinitionCompiler,
+                _batchexplorer.BatchExplorer,
+                _flowevaluator.FlowEvaluator,
+                _batchscheduleregistry.BatchScheduleRegistry,
+                BatchBootstrapper,
+                // Tokens — exported so adapters can bind to them via
+                // `@Inject(MODULE_OPTIONS_TOKEN)` and host code can read
+                // the schedule registry by its stable symbol.
+                _tokens.BATCH_SCHEDULE_REGISTRY,
+                _tokens.MODULE_OPTIONS_TOKEN,
+                // Executor subgraph — exported so adapters (e.g. the
+                // `InProcessExecutionStrategy`) and host code can inject
+                // them.
+                _jobexecutor.JobExecutor,
+                _chunkstepexecutor.ChunkStepExecutor,
+                _taskletstepexecutor.TaskletStepExecutor,
+                _listenerinvoker.ListenerInvoker,
+                _joblauncher.JobLauncher,
+                _jobexplorer.JobExplorer,
+                _joboperator.JobOperator,
+                _batchworkerrunner.BatchWorkerRunner,
+                // Adapter-supplied global providers — re-exported so the
+                // host can resolve the persistence + transport bindings
+                // from the global module chain.
+                ...persistenceProviders,
+                ...transportProviders
+            ]
+        };
+    }
+    /**
+   * Async configuration — useful when the adapter set comes from a
+   * config service or another async source.
+   *
+   * Mirrors the `BullmqBatchModule.forRootAsync` pattern: the user's
+   * `useFactory` is registered as a sentinel provider under
+   * `OPTIONS_FACTORY`, and `MODULE_OPTIONS_TOKEN` is bound to its
+   * resolved `BatchAdaptersConfig` via a follow-up `useFactory`
+   * provider. The user's `imports` + `inject` are forwarded as-is
+   * so the factory can pull from `ConfigService` or any other
+   * DI-bound dependency.
+   *
+   * See the `NestBatchModuleAsyncOptions` JSDoc for the adapter
+   * module merging caveat — the async path does not auto-merge
+   * the adapter modules' `globalProviders`. The adapter
+   * `DynamicModule`s must be passed in the caller's `imports`
+   * array so Nest sees them in the module graph; the factory's
+   * return value is used only for `MODULE_OPTIONS_TOKEN`.
+   */ static forRootAsync(options) {
+        const { imports = [], inject = [], useFactory } = options;
+        // Try to evaluate the factory synchronously so we can merge
+        // adapter `globalProviders` at module-build time (mirroring
+        // what `forRoot` does). If the factory is async or needs
+        // injected deps we can't resolve, fall back to the pure
+        // sentinel-factory path.
+        const injectValues = NestBatchModule.resolveInjectValues(imports, inject);
+        const factoryResult = useFactory(...injectValues);
+        if (factoryResult instanceof Promise) {
+            return factoryResult.then((adapters)=>NestBatchModule.buildAsyncModule(options, adapters));
+        }
+        return NestBatchModule.buildAsyncModule(options, factoryResult);
+    }
+    /**
+   * Shared module builder used by both the sync and async branches
+   * of `forRootAsync`. When the factory result is available
+   * synchronously we merge adapter `globalProviders` (plus the
+   * `JobRepository` alias) into core's own provider list, exactly
+   * like `forRoot` does.
+   */ static buildAsyncModule(options, adapters) {
+        const { imports = [], inject = [], useFactory } = options;
+        const persistenceProviders = NestBatchModule.buildProviders(adapters.persistence.globalProviders ?? []);
+        const transportProviders = NestBatchModule.buildProviders(adapters.transport.globalProviders ?? []);
+        // Sentinel factory provider: holds the user's `useFactory` and
+        // any `inject` deps. Other providers can pull the resolved
+        // `BatchAdaptersConfig` via `@Inject(OPTIONS_FACTORY)` if they
+        // need to.
+        const factoryProvider = {
+            provide: OPTIONS_FACTORY,
+            useFactory: useFactory,
+            inject: [
+                ...inject
+            ]
+        };
+        // Options provider: bridges the sentinel factory to the
+        // canonical `MODULE_OPTIONS_TOKEN` so adapters + host code can
+        // read the resolved config by its stable symbol.
+        const optionsProvider = {
+            provide: _tokens.MODULE_OPTIONS_TOKEN,
+            useFactory: (fromFactory)=>fromFactory,
+            inject: [
+                OPTIONS_FACTORY
+            ]
+        };
+        return {
+            module: NestBatchModule,
+            global: true,
+            imports: [
+                ...imports,
+                adapters.persistence.module,
+                adapters.transport.module,
+                _core.DiscoveryModule
+            ],
+            providers: [
+                // Core classes (discovery + compile + register).
+                _jobregistry.JobRegistry,
+                _definitioncompiler.DefinitionCompiler,
+                _batchexplorer.BatchExplorer,
+                _flowevaluator.FlowEvaluator,
+                _batchscheduleregistry.BatchScheduleRegistry,
+                BatchBootstrapper,
+                // Executor subgraph (JobExecutor → Chunk/Tasklet/Listener).
+                _jobexecutor.JobExecutor,
+                _chunkstepexecutor.ChunkStepExecutor,
+                _taskletstepexecutor.TaskletStepExecutor,
+                _listenerinvoker.ListenerInvoker,
+                _joblauncher.JobLauncher,
+                _jobexplorer.JobExplorer,
+                _joboperator.JobOperator,
+                _batchworkerrunner.BatchWorkerRunner,
+                {
+                    provide: _tokens.BATCH_SCHEDULE_REGISTRY,
+                    useExisting: _batchscheduleregistry.BatchScheduleRegistry
+                },
+                // Adapter-supplied global providers (e.g. JobRepository
+                // / TransactionManager implementations).
+                ...persistenceProviders,
+                ...transportProviders,
+                // Sentinel factory + options provider (the async path).
+                factoryProvider,
+                optionsProvider
+            ],
+            exports: [
+                // Core classes.
+                _jobregistry.JobRegistry,
+                _definitioncompiler.DefinitionCompiler,
+                _batchexplorer.BatchExplorer,
+                _flowevaluator.FlowEvaluator,
+                _batchscheduleregistry.BatchScheduleRegistry,
+                BatchBootstrapper,
+                // Tokens.
+                _tokens.BATCH_SCHEDULE_REGISTRY,
+                _tokens.MODULE_OPTIONS_TOKEN,
+                // Executor subgraph.
+                _jobexecutor.JobExecutor,
+                _chunkstepexecutor.ChunkStepExecutor,
+                _taskletstepexecutor.TaskletStepExecutor,
+                _listenerinvoker.ListenerInvoker,
+                _joblauncher.JobLauncher,
+                _jobexplorer.JobExplorer,
+                _joboperator.JobOperator,
+                _batchworkerrunner.BatchWorkerRunner,
+                // Adapter-supplied global providers — re-exported so the
+                // host can resolve the persistence + transport bindings
+                // from the global module chain.
+                ...persistenceProviders,
+                ...transportProviders
+            ]
+        };
+    }
+};
+NestBatchModule = _ts_decorate([
+    (0, _common.Module)({})
+], NestBatchModule);
+
+//# sourceMappingURL=nest-batch.module.js.map

package/dist/src/module/nest-batch.module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/module/nest-batch.module.ts"],"sourcesContent":["import {\n  DynamicModule,\n  Injectable,\n  Logger,\n  Module,\n  OnApplicationBootstrap,\n  Provider,\n} from '@nestjs/common';\nimport { DiscoveryModule } from '@nestjs/core';\n\nimport type { BatchAdaptersConfig } from './adapter';\nimport { DefinitionCompiler } from '../compiler/definition-compiler';\nimport { BatchExplorer } from '../explorer/batch-explorer';\nimport { JobRegistry } from '../registry/job-registry';\nimport { JobExecutor } from '../execution/job-executor';\nimport { ChunkStepExecutor } from '../execution/chunk-step-executor';\nimport { TaskletStepExecutor } from '../execution/tasklet-step-executor';\nimport { ListenerInvoker } from '../execution/listener-invoker';\nimport { JobLauncher } from '../execution/job-launcher';\nimport { JobExplorer } from '../execution/job-explorer';\nimport { JobOperator } from '../execution/job-operator';\nimport { BatchWorkerRunner } from '../execution/batch-worker-runner';\nimport {\n  InProcessExecutionStrategy,\n  IN_PROCESS_EXECUTION_STRATEGY_PROVIDER,\n} from '../execution/in-process-execution-strategy';\nimport { FlowEvaluator } from '../flow/flow-evaluator';\nimport { BATCH_SCHEDULED_OPTIONS } from '../decorators/constants';\nimport type { BatchScheduledMetadata } from '../scheduling/batch-scheduled';\nimport {\n  BatchScheduleRegistry,\n  type BatchScheduleEntry,\n} from './batch-schedule-registry';\nimport {\n  BATCH_SCHEDULE_REGISTRY,\n  JOB_REPOSITORY_TOKEN,\n  MODULE_OPTIONS_TOKEN,\n  TRANSACTION_MANAGER_TOKEN,\n} from './tokens';\nimport { JobRepository } from '../core/repository/job-repository';\nimport { TransactionManager } from '../core/transaction/transaction-manager';\n\n/**\n * Re-export the default in-process strategy and its token binding so\n * the host app can wire them up alongside the rest of the batch\n * engine. The strategy is *not* auto-registered by\n * `NestBatchModule.forRoot()` because its constructor requires\n * `JobRepository` and `JobExecutor` — runtime deps the host\n * supplies. The T4 `InProcessAdapter` factory does the wiring through\n * the adapter's own `DynamicModule.exports` so the runtime\n * resolution chain works without the core module having to know which\n * adapter is active.\n *\n * ```ts\n * import { InProcessAdapter, MikroOrmAdapter, NestBatchModule } from '@nest-batch/core';\n *\n * @Module({\n *   imports: [\n *     NestBatchModule.forRoot({\n *       adapters: {\n *         persistence: MikroOrmAdapter,\n *         transport: InProcessAdapter,\n *       },\n *     }),\n *   ],\n * })\n * class AppModule {}\n * ```\n */\nexport { InProcessExecutionStrategy, IN_PROCESS_EXECUTION_STRATEGY_PROVIDER };\n\n/**\n * Options for `NestBatchModule.forRoot()`.\n *\n * The whole configuration is the pair of adapters (persistence +\n * transport) the host picked. Both are required — the compiler\n * will reject an `adapters` bag that is missing one — and each\n * adapter is a self-contained `DynamicModule` core will import.\n * Sibling packages can no longer extend the options shape via\n * interface merging: the old `AdapterOptions` extension point is\n * gone because every adapter now owns its own `DynamicModule`\n * (and therefore its own config). Adapter authors that want\n * type-safe factory arguments should expose them on their own\n * adapter factory (e.g. `MikroOrmAdapter.forRoot({ ... })`).\n *\n *   - `adapters.persistence` — the adapter that owns the\n *     `JobRepository` + `TransactionManager` bindings (e.g.\n *     `MikroOrmAdapter`, `TypeOrmAdapter`).\n *   - `adapters.transport`   — the adapter that owns the\n *     `IExecutionStrategy` binding (e.g. `InProcessAdapter`,\n *     `BullmqAdapter`).\n */\nexport interface NestBatchModuleOptions {\n  readonly adapters: BatchAdaptersConfig;\n}\n\n/**\n * Options for `NestBatchModule.forRootAsync()`.\n *\n * `imports` + `inject` + `useFactory` mirror the standard\n * `ConfigurableModuleBuilder` shape. The factory is registered as a\n * sentinel provider under `OPTIONS_FACTORY` (a `Symbol.for` token\n * stable across module boundaries), and `MODULE_OPTIONS_TOKEN` is\n * bound to its resolved `BatchAdaptersConfig` via a follow-up\n * `useFactory` provider.\n *\n * **Note on adapter module merging.** NestJS cannot dynamically\n * import a `DynamicModule` at module-build time, so the\n * `forRootAsync` path does NOT auto-merge the adapter modules'\n * `globalProviders` into the core module's `providers` list the way\n * `forRoot` does. Two consequences for the async path:\n *\n *   1. The adapter `DynamicModule`s must be passed in the caller's\n *      `imports` array directly (e.g.\n *      `imports: [MikroOrmAdapter.module, InProcessAdapter.module]`)\n *      so Nest sees them in the module graph.\n *   2. The factory's return value is used only for the\n *      `MODULE_OPTIONS_TOKEN` binding (adapters introspection);\n *      sibling packages and the host can read the resolved config\n *      via `@Inject(MODULE_OPTIONS_TOKEN)`.\n *\n * For the full auto-merge (adapter modules + `globalProviders`\n * registered into core's own DI scope), prefer `forRoot` with a\n * pre-resolved `BatchAdaptersConfig`. The async path is for\n * adapters whose factory needs to consult a config service or\n * another async provider to decide which adapter to plug in.\n */\nexport interface NestBatchModuleAsyncOptions {\n  imports?: DynamicModule['imports'];\n  useFactory: (\n    ...args: unknown[]\n  ) => Promise<BatchAdaptersConfig> | BatchAdaptersConfig;\n  inject?: readonly unknown[];\n}\n\n/**\n * Sentinel provider token used by `forRootAsync` to plumb the user's\n * `useFactory` through DI. The factory is registered under this\n * token, and `MODULE_OPTIONS_TOKEN` resolves to its output via a\n * follow-up `useFactory` provider.\n *\n * `Symbol.for(...)` makes the token stable across module boundaries:\n * tooling or sibling packages that know the description string can\n * resolve the same symbol without importing this file. Matches the\n * convention used by `BATCH_SCHEDULE_REGISTRY`, `MODULE_OPTIONS_TOKEN`,\n * `JOB_REPOSITORY_TOKEN`, etc. in `./tokens.ts`.\n */\nconst OPTIONS_FACTORY: symbol = Symbol.for('@nest-batch/core/OPTIONS_FACTORY');\n\n/**\n * Hook that runs on `OnApplicationBootstrap` to wire together the\n * discovery → compile → register pipeline.\n *\n * Why a separate provider and not a method on `JobRegistry` or\n * `DefinitionCompiler`?\n *   - `BatchExplorer.onModuleInit` populates the discovered\n *     list once the DI container is ready. Compilation needs every\n *     `@Jobable` provider to be instantiated, so it must run *after*\n *     `onModuleInit`.\n *   - `OnApplicationBootstrap` is the latest point in Nest's lifecycle\n *     before the app actually starts handling requests, so all of:\n *     `forRoot` / `forRootAsync` providers, custom `useFactory` results,\n *     and user-supplied job classes, are guaranteed to be live.\n *   - Keeping the wire-up in a dedicated `BatchBootstrapper` means the\n *     explorer/compiler/registry stay pure (no `onApplicationBootstrap`\n *     coupling) and are independently testable.\n *\n * The bootstrapper also walks every discovered job for\n * `@BatchScheduled` metadata and registers the corresponding entries\n * into the `BatchScheduleRegistry` so the (future) runtime scheduler\n * has a single, stable place to read them from. Today, the registry is\n * metadata-only — no timers are installed.\n */\n@Injectable()\nexport class BatchBootstrapper implements OnApplicationBootstrap {\n  private readonly logger = new Logger(BatchBootstrapper.name);\n\n  constructor(\n    private readonly explorer: BatchExplorer,\n    private readonly compiler: DefinitionCompiler,\n    private readonly registry: JobRegistry,\n    private readonly scheduleRegistry: BatchScheduleRegistry,\n  ) {}\n\n  onApplicationBootstrap(): void {\n    // 1. Compile + register every discovered job.\n    for (const discovered of this.explorer.getDiscovered()) {\n      const jobId = discovered.jobOptions.id;\n      try {\n        const def = this.compiler.compileFromDiscovered(discovered);\n        this.registry.register(def);\n        this.logger.log(`Registered job \"${jobId}\"`);\n      } catch (err) {\n        this.logger.error(\n          `Failed to register job \"${jobId}\": ${(err as Error).message}`,\n        );\n        throw err;\n      }\n    }\n\n    // 2. Walk the same discovered set for @BatchScheduled metadata\n    //    and populate BatchScheduleRegistry. The metadata is stamped\n    //    by the decorator via `SetMetadata(KEY, value)`, which Nest\n    //    writes to the *function reference* of the decorated method\n    //    (not to the prototype+name slot). We therefore read it from\n    //    `prototype[name]` (the function), not from the (proto, name)\n    //    tuple.\n    for (const discovered of this.explorer.getDiscovered()) {\n      const jobId = discovered.jobOptions.id;\n      const prototype = discovered.classRef.prototype as Record<string, unknown>;\n      for (const name of this.allMethodNames(prototype)) {\n        const fn = prototype[name];\n        if (typeof fn !== 'function') continue;\n        const meta = Reflect.getMetadata(\n          BATCH_SCHEDULED_OPTIONS,\n          fn,\n        ) as BatchScheduledMetadata | undefined;\n        if (!meta) continue;\n        const entry: BatchScheduleEntry = {\n          jobId,\n          methodName: name,\n          cron: meta.cron,\n          timezone: meta.options.timezone,\n          overlap: meta.options.overlap,\n          startAt: meta.options.startAt,\n          endAt: meta.options.endAt,\n          inert: meta.inert,\n        };\n        try {\n          this.scheduleRegistry.register(entry);\n          this.logger.log(\n            `Registered schedule for job \"${jobId}\"::${name} (cron=\"${meta.cron}\", tz=\"${meta.options.timezone}\")`,\n          );\n        } catch (err) {\n          this.logger.error(\n            `Failed to register schedule for job \"${jobId}\"::${name}: ${\n              (err as Error).message\n            }`,\n          );\n          throw err;\n        }\n      }\n    }\n  }\n\n  /**\n   * Walk the prototype chain and return every own method name\n   * (excluding `constructor`) up to (but not including)\n   * `Object.prototype`. Same shape as `BatchExplorer.allMethodNames` —\n   * we duplicate the walker here so the bootstrapper remains\n   * independent of the explorer's internals.\n   */\n  private allMethodNames(prototype: object): Set<string> {\n    const names = new Set<string>();\n    let proto: object | null = prototype;\n    while (proto && proto !== Object.prototype) {\n      for (const name of Object.getOwnPropertyNames(proto)) {\n        if (name === 'constructor') continue;\n        names.add(name);\n      }\n      proto = Object.getPrototypeOf(proto);\n    }\n    return names;\n  }\n}\n\n/**\n * Public Nest module that wires up the @nest-batch/core library.\n *\n * The module is a `global: true` `DynamicModule` whose `imports`,\n * `providers`, and `exports` are assembled at the call site by\n * `forRoot` (synchronous) or `forRootAsync` (sentinel-factory\n * pattern). In both paths the core providers and the executor\n * subgraph are auto-registered so the host does not have to wire\n * them by hand; adapter modules are imported as part of the same\n * `DynamicModule` so Nest's discovery phase sees every job class.\n *\n * @see {@link NestBatchModuleOptions} for the synchronous options shape\n * @see {@link NestBatchModuleAsyncOptions} for the async options shape\n * @see {@link BatchAdaptersConfig} for the adapter contract\n */\n@Module({})\nexport class NestBatchModule {\n  /**\n   * Build a provider list from an adapter's `globalProviders`,\n   * automatically aliasing the abstract `JobRepository` class to\n   * `JOB_REPOSITORY_TOKEN` when the symbol is present but the class\n   * itself is not directly provided.\n   *\n   * This fixes the NestJS DI resolution gap: `JobExecutor`,\n   * `JobLauncher`, and `InProcessExecutionStrategy` all inject the\n   * abstract `JobRepository`, but adapters typically bind their\n   * concrete implementation to `JOB_REPOSITORY_TOKEN`. NestJS cannot\n   * resolve abstract class → concrete subclass automatically, so we\n   * inject the alias here.\n   *\n   * Idempotent: if `JobRepository` is already directly provided (e.g.\n   * `{ provide: JobRepository, useClass: MyRepo }`), no extra alias is\n   * added.\n   */\n  private static buildProviders(adapterGlobalProviders: readonly Provider[]): Provider[] {\n    const providers = [...adapterGlobalProviders];\n\n    const hasJobRepositoryToken = providers.some(\n      (p) =>\n        typeof p === 'object' &&\n        p !== null &&\n        'provide' in p &&\n        p.provide === JOB_REPOSITORY_TOKEN,\n    );\n\n    const hasJobRepositoryClass = providers.some(\n      (p) =>\n        p === JobRepository ||\n        (typeof p === 'object' &&\n          p !== null &&\n          'provide' in p &&\n          p.provide === JobRepository),\n    );\n\n    if (hasJobRepositoryToken && !hasJobRepositoryClass) {\n      providers.push({\n        provide: JobRepository,\n        useExisting: JOB_REPOSITORY_TOKEN,\n      });\n    }\n\n    const hasTransactionManagerToken = providers.some(\n      (p) =>\n        typeof p === 'object' &&\n        p !== null &&\n        'provide' in p &&\n        p.provide === TRANSACTION_MANAGER_TOKEN,\n    );\n\n    const hasTransactionManagerClass = providers.some(\n      (p) =>\n        p === TransactionManager ||\n        (typeof p === 'object' &&\n          p !== null &&\n          'provide' in p &&\n          p.provide === TransactionManager),\n    );\n\n    if (hasTransactionManagerToken && !hasTransactionManagerClass) {\n      providers.push({\n        provide: TransactionManager,\n        useExisting: TRANSACTION_MANAGER_TOKEN,\n      });\n    }\n\n    return providers;\n  }\n\n  /**\n   * Best-effort resolution of `inject` tokens by reading the\n   * `providers` metadata of modules listed in `imports`. This lets\n   * `forRootAsync` evaluate a synchronous `useFactory` even when it\n   * declares `inject` deps, provided those deps are `useValue`\n   * providers exported by an imported module.\n   *\n   * Only `useValue` providers can be resolved this way — `useClass`\n   * and `useFactory` providers need Nest's DI container and are\n   * skipped.\n   */\n  private static resolveInjectValues(\n    imports: NestBatchModuleAsyncOptions['imports'],\n    inject: readonly unknown[],\n  ): unknown[] {\n    if (!inject || inject.length === 0) return [];\n\n    const values: unknown[] = [];\n    for (const token of inject) {\n      let resolved: unknown = undefined;\n      for (const mod of imports ?? []) {\n        if (!mod) continue;\n\n        let providers: Provider[] | undefined;\n\n        if (typeof mod === 'object' && 'module' in mod) {\n          const dynamicMod = mod as DynamicModule;\n          providers = dynamicMod.providers;\n          if (!providers && dynamicMod.module) {\n            try {\n              providers = Reflect.getMetadata('providers', dynamicMod.module);\n            } catch {\n              /* ignore metadata read failures */\n            }\n          }\n        } else if (typeof mod === 'function') {\n          try {\n            providers = Reflect.getMetadata('providers', mod);\n          } catch {\n            /* ignore metadata read failures */\n          }\n        }\n\n        for (const p of providers ?? []) {\n          if (\n            typeof p === 'object' &&\n            p !== null &&\n            'provide' in p &&\n            p.provide === token &&\n            'useValue' in p\n          ) {\n            resolved = p.useValue;\n            break;\n          }\n        }\n        if (resolved !== undefined) break;\n      }\n      values.push(resolved);\n    }\n    return values;\n  }\n\n  /**\n   * Static (synchronous) configuration.\n   *\n   * Takes the resolved `BatchAdaptersConfig` and builds a\n   * `global: true` `DynamicModule` that:\n   *\n   *   1. imports each adapter's `DynamicModule`\n   *      (`adapters.persistence.module` and `adapters.transport.module`);\n   *   2. imports `DiscoveryModule` from `@nestjs/core` so the explorer\n   *      can use Nest's `DiscoveryService`;\n   *   3. registers core's own providers — `JobRegistry`,\n   *      `DefinitionCompiler`, `BatchExplorer`, `FlowEvaluator`,\n   *      `BatchScheduleRegistry`, `BatchBootstrapper` — and the\n   *      executor subgraph (`JobExecutor`, `ChunkStepExecutor`,\n   *      `TaskletStepExecutor`, `ListenerInvoker`) so the host\n   *      does not have to wire them by hand;\n   *   4. registers each adapter's `globalProviders` (e.g. the\n   *      `JobRepository` / `TransactionManager` implementations\n   *      from a persistence adapter) so the host can inject them\n   *      too;\n   *   5. binds the `BatchAdaptersConfig` to `MODULE_OPTIONS_TOKEN`\n   *      via a value provider for adapter introspection.\n   */\n  static forRoot(options: NestBatchModuleOptions): DynamicModule {\n    const { adapters } = options;\n    const persistenceProviders = NestBatchModule.buildProviders(\n      adapters.persistence.globalProviders ?? [],\n    );\n    const transportProviders = NestBatchModule.buildProviders(\n      adapters.transport.globalProviders ?? [],\n    );\n\n    return {\n      module: NestBatchModule,\n      global: true,\n      imports: [\n        adapters.persistence.module,\n        adapters.transport.module,\n        DiscoveryModule,\n      ],\n      providers: [\n        // Core classes (discovery + compile + register).\n        JobRegistry,\n        DefinitionCompiler,\n        BatchExplorer,\n        FlowEvaluator,\n        BatchScheduleRegistry,\n        BatchBootstrapper,\n        // Executor subgraph (JobExecutor → Chunk/Tasklet/Listener).\n        JobExecutor,\n        ChunkStepExecutor,\n        TaskletStepExecutor,\n        ListenerInvoker,\n        JobLauncher,\n        JobExplorer,\n        JobOperator,\n        BatchWorkerRunner,\n        // Resolved options bag for adapter introspection.\n        {\n          provide: MODULE_OPTIONS_TOKEN,\n          useValue: adapters,\n        },\n        // Schedule registry symbol alias — the symbol itself\n        // must be a provider (not just a class export) so the\n        // `exports` entry below resolves through Nest's DI\n        // validation.\n        {\n          provide: BATCH_SCHEDULE_REGISTRY,\n          useExisting: BatchScheduleRegistry,\n        },\n        // Adapter-supplied global providers (e.g. JobRepository\n        // / TransactionManager implementations).\n        ...persistenceProviders,\n        ...transportProviders,\n      ],\n      exports: [\n        // Core classes — exported so sibling packages and the\n        // host app can resolve them from the global module chain.\n        JobRegistry,\n        DefinitionCompiler,\n        BatchExplorer,\n        FlowEvaluator,\n        BatchScheduleRegistry,\n        BatchBootstrapper,\n        // Tokens — exported so adapters can bind to them via\n        // `@Inject(MODULE_OPTIONS_TOKEN)` and host code can read\n        // the schedule registry by its stable symbol.\n        BATCH_SCHEDULE_REGISTRY,\n        MODULE_OPTIONS_TOKEN,\n        // Executor subgraph — exported so adapters (e.g. the\n        // `InProcessExecutionStrategy`) and host code can inject\n        // them.\n        JobExecutor,\n        ChunkStepExecutor,\n        TaskletStepExecutor,\n        ListenerInvoker,\n        JobLauncher,\n        JobExplorer,\n        JobOperator,\n        BatchWorkerRunner,\n        // Adapter-supplied global providers — re-exported so the\n        // host can resolve the persistence + transport bindings\n        // from the global module chain.\n        ...persistenceProviders,\n        ...transportProviders,\n      ],\n    };\n  }\n\n  /**\n   * Async configuration — useful when the adapter set comes from a\n   * config service or another async source.\n   *\n   * Mirrors the `BullmqBatchModule.forRootAsync` pattern: the user's\n   * `useFactory` is registered as a sentinel provider under\n   * `OPTIONS_FACTORY`, and `MODULE_OPTIONS_TOKEN` is bound to its\n   * resolved `BatchAdaptersConfig` via a follow-up `useFactory`\n   * provider. The user's `imports` + `inject` are forwarded as-is\n   * so the factory can pull from `ConfigService` or any other\n   * DI-bound dependency.\n   *\n   * See the `NestBatchModuleAsyncOptions` JSDoc for the adapter\n   * module merging caveat — the async path does not auto-merge\n   * the adapter modules' `globalProviders`. The adapter\n   * `DynamicModule`s must be passed in the caller's `imports`\n   * array so Nest sees them in the module graph; the factory's\n   * return value is used only for `MODULE_OPTIONS_TOKEN`.\n   */\n  static forRootAsync(\n    options: NestBatchModuleAsyncOptions,\n  ): DynamicModule | Promise<DynamicModule> {\n    const { imports = [], inject = [], useFactory } = options;\n\n    // Try to evaluate the factory synchronously so we can merge\n    // adapter `globalProviders` at module-build time (mirroring\n    // what `forRoot` does). If the factory is async or needs\n    // injected deps we can't resolve, fall back to the pure\n    // sentinel-factory path.\n    const injectValues = NestBatchModule.resolveInjectValues(imports, inject);\n    const factoryResult = useFactory(...injectValues);\n\n    if (factoryResult instanceof Promise) {\n      return factoryResult.then((adapters) =>\n        NestBatchModule.buildAsyncModule(options, adapters),\n      );\n    }\n\n    return NestBatchModule.buildAsyncModule(options, factoryResult);\n  }\n\n  /**\n   * Shared module builder used by both the sync and async branches\n   * of `forRootAsync`. When the factory result is available\n   * synchronously we merge adapter `globalProviders` (plus the\n   * `JobRepository` alias) into core's own provider list, exactly\n   * like `forRoot` does.\n   */\n  private static buildAsyncModule(\n    options: NestBatchModuleAsyncOptions,\n    adapters: BatchAdaptersConfig,\n  ): DynamicModule {\n    const { imports = [], inject = [], useFactory } = options;\n\n    const persistenceProviders = NestBatchModule.buildProviders(\n      adapters.persistence.globalProviders ?? [],\n    );\n    const transportProviders = NestBatchModule.buildProviders(\n      adapters.transport.globalProviders ?? [],\n    );\n\n    // Sentinel factory provider: holds the user's `useFactory` and\n    // any `inject` deps. Other providers can pull the resolved\n    // `BatchAdaptersConfig` via `@Inject(OPTIONS_FACTORY)` if they\n    // need to.\n    const factoryProvider: Provider = {\n      provide: OPTIONS_FACTORY,\n      useFactory: useFactory as (...args: unknown[]) => unknown,\n      inject: [...inject] as Array<string | symbol | Function>,\n    };\n\n    // Options provider: bridges the sentinel factory to the\n    // canonical `MODULE_OPTIONS_TOKEN` so adapters + host code can\n    // read the resolved config by its stable symbol.\n    const optionsProvider: Provider = {\n      provide: MODULE_OPTIONS_TOKEN,\n      useFactory: (\n        fromFactory: BatchAdaptersConfig | undefined,\n      ): BatchAdaptersConfig | undefined => fromFactory,\n      inject: [OPTIONS_FACTORY],\n    };\n\n    return {\n      module: NestBatchModule,\n      global: true,\n      imports: [\n        ...imports,\n        adapters.persistence.module,\n        adapters.transport.module,\n        DiscoveryModule,\n      ],\n      providers: [\n        // Core classes (discovery + compile + register).\n        JobRegistry,\n        DefinitionCompiler,\n        BatchExplorer,\n        FlowEvaluator,\n        BatchScheduleRegistry,\n        BatchBootstrapper,\n        // Executor subgraph (JobExecutor → Chunk/Tasklet/Listener).\n        JobExecutor,\n        ChunkStepExecutor,\n        TaskletStepExecutor,\n        ListenerInvoker,\n        JobLauncher,\n        JobExplorer,\n        JobOperator,\n        BatchWorkerRunner,\n        {\n          provide: BATCH_SCHEDULE_REGISTRY,\n          useExisting: BatchScheduleRegistry,\n        },\n        // Adapter-supplied global providers (e.g. JobRepository\n        // / TransactionManager implementations).\n        ...persistenceProviders,\n        ...transportProviders,\n        // Sentinel factory + options provider (the async path).\n        factoryProvider,\n        optionsProvider,\n      ],\n      exports: [\n        // Core classes.\n        JobRegistry,\n        DefinitionCompiler,\n        BatchExplorer,\n        FlowEvaluator,\n        BatchScheduleRegistry,\n        BatchBootstrapper,\n        // Tokens.\n        BATCH_SCHEDULE_REGISTRY,\n        MODULE_OPTIONS_TOKEN,\n        // Executor subgraph.\n        JobExecutor,\n        ChunkStepExecutor,\n        TaskletStepExecutor,\n        ListenerInvoker,\n        JobLauncher,\n        JobExplorer,\n        JobOperator,\n        BatchWorkerRunner,\n        // Adapter-supplied global providers — re-exported so the\n        // host can resolve the persistence + transport bindings\n        // from the global module chain.\n        ...persistenceProviders,\n        ...transportProviders,\n      ],\n    };\n  }\n}\n"],"names":["BatchBootstrapper","IN_PROCESS_EXECUTION_STRATEGY_PROVIDER","InProcessExecutionStrategy","NestBatchModule","OPTIONS_FACTORY","Symbol","for","logger","Logger","name","explorer","compiler","registry","scheduleRegistry","onApplicationBootstrap","discovered","getDiscovered","jobId","jobOptions","id","def","compileFromDiscovered","register","log","err","error","message","prototype","classRef","allMethodNames","fn","meta","Reflect","getMetadata","BATCH_SCHEDULED_OPTIONS","entry","methodName","cron","timezone","options","overlap","startAt","endAt","inert","names","Set","proto","Object","getOwnPropertyNames","add","getPrototypeOf","buildProviders","adapterGlobalProviders","providers","hasJobRepositoryToken","some","p","provide","JOB_REPOSITORY_TOKEN","hasJobRepositoryClass","JobRepository","push","useExisting","hasTransactionManagerToken","TRANSACTION_MANAGER_TOKEN","hasTransactionManagerClass","TransactionManager","resolveInjectValues","imports","inject","length","values","token","resolved","undefined","mod","dynamicMod","module","useValue","forRoot","adapters","persistenceProviders","persistence","globalProviders","transportProviders","transport","global","DiscoveryModule","JobRegistry","DefinitionCompiler","BatchExplorer","FlowEvaluator","BatchScheduleRegistry","JobExecutor","ChunkStepExecutor","TaskletStepExecutor","ListenerInvoker","JobLauncher","JobExplorer","JobOperator","BatchWorkerRunner","MODULE_OPTIONS_TOKEN","BATCH_SCHEDULE_REGISTRY","exports","forRootAsync","useFactory","injectValues","factoryResult","Promise","then","buildAsyncModule","factoryProvider","optionsProvider","fromFactory"],"mappings":"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"}

package/dist/src/module/tokens.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Public injection tokens for the `@nest-batch/core` module surface.
+ *
+ * These tokens are the stable, package-scoped identifiers sibling packages
+ * (e.g. `@nest-batch/mikro-orm`, `@nest-batch/typeorm`, `@nest-batch/bullmq`)
+ * use to bind their own providers into the core DI graph. They are
+ * registered in the global `Symbol.for` registry under stable, package-
+ * scoped keys so they are unique across the host process even if the
+ * package is loaded multiple times.
+ *
+ * Why symbols and not string tokens?
+ *   - Symbols cannot collide with a user string by accident.
+ *   - `Symbol.for(key)` gives us cross-realm uniqueness without the
+ *     caller having to thread the token through `import` chains — a
+ *     host can resolve any of these tokens by reaching into
+ *     `Symbol.for('...description...')` and getting the same value.
+ *   - Symbols are erased from emitted JavaScript, so they do not
+ *     pollute production bundles with debug strings.
+ *
+ * Why a stable description (not `Symbol(description)`)?
+ *   - `Symbol.for('k')` only works if the *same* string is passed both
+ *     times. Hard-coding a `description` lets future sibling packages
+ *     resolve the token without importing this file (useful for tooling
+ *     and for ad-hoc cross-package debugging).
+ */
+import { EXECUTION_STRATEGY } from '../execution/execution-strategy';
+/**
+ * Injection token for the `JobRepository` implementation.
+ *
+ * Adapter packages (`@nest-batch/mikro-orm`, `@nest-batch/typeorm`, ...)
+ * bind their `JobRepository` subclass to this token. By default the host
+ * app is expected to register its own `JobRepository` provider — core
+ * does NOT ship a default binding because the choice of persistence
+ * backend is the host's decision.
+ */
+export declare const JOB_REPOSITORY_TOKEN: symbol;
+/**
+ * Injection token for the `TransactionManager` implementation.
+ *
+ * Adapter packages bind their transaction manager to this token. The
+ * `JobRepository` implementation is expected to participate in the same
+ * transaction (e.g. share the same `EntityManager` / `DataSource`).
+ */
+export declare const TRANSACTION_MANAGER_TOKEN: symbol;
+/**
+ * Injection token for the `BatchScheduleRegistry` provider.
+ *
+ * The `BatchExplorer` populates this registry with `@BatchScheduled`
+ * metadata it discovers on `@Jobable` classes. The future runtime
+ * scheduler (the `@nest-batch/bullmq` cron strategy, or a sibling
+ * scheduling package) reads from this registry to install the actual
+ * timers. Keeping the registry as a stable token means adapters can
+ * inject it (for introspection / health checks) without depending on
+ * the explorer's internal state.
+ */
+export declare const BATCH_SCHEDULE_REGISTRY: symbol;
+/**
+ * Injection token for the module's resolved options bag.
+ *
+ * Backs the post-`useFactory` options read (T2 will wire the async
+ * factory provider to write into this slot). Sibling packages and the
+ * host app can read the resolved options by injecting this token. The
+ * shape is the union of `NestBatchModuleOptions` plus whatever an
+ * adapter's own config contributed, so the value is a
+ * `Record<string, unknown>` at runtime.
+ *
+ * The previous `'BATCH_OPTIONS'` string alias was removed in the
+ * T1 type-contract refactor — hosts that need the options bag should
+ * inject `MODULE_OPTIONS_TOKEN` instead.
+ */
+export declare const MODULE_OPTIONS_TOKEN: symbol;
+/**
+ * Polymorphic execution strategy token.
+ *
+ * Re-exported here from `execution/execution-strategy.ts` so that the
+ * module surface is the single import path for downstream packages.
+ * Apps that want the default in-process strategy wire up
+ * `IN_PROCESS_EXECUTION_STRATEGY_PROVIDER`; sibling packages (e.g.
+ * `@nest-batch/bullmq`) provide a custom binding under this same
+ * token.
+ */
+export { EXECUTION_STRATEGY };
+//# sourceMappingURL=tokens.d.ts.map

package/dist/src/module/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/module/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAElC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAEvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAErC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAElC,CAAC;AAEF;;;;;;;;;GASG;AACH,OAAO,EAAE,kBAAkB,EAAE,CAAC"}