@nest-batch/core 0.2.0 → 0.2.1

package/src/execution/in-process-schedule.ts

@@ -0,0 +1,143 @@
+import { Injectable, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { CronJob } from 'cron';
+
+import { type BatchScheduleEntry, BatchScheduleRegistry } from '../module/batch-schedule-registry';
+import { JobLauncher } from './job-launcher';
+
+interface ScheduleState {
+  readonly entry: BatchScheduleEntry;
+  readonly job: CronJob;
+  runningCount: number;
+  queued: boolean;
+  queuedAt: Date | null;
+}
+
+function scheduleKey(entry: BatchScheduleEntry): string {
+  return `${entry.jobId}::${entry.scheduleName}`;
+}
+
+/**
+ * In-process scheduler for `@BatchScheduled` jobs.
+ *
+ * This is deliberately part of the in-process transport, not the
+ * `@BatchScheduled` decorator. The decorator remains metadata-only;
+ * this provider consumes the `BatchScheduleRegistry` and turns matching
+ * cron ticks into `JobLauncher.launch(...)` calls inside the same server
+ * process.
+ */
+@Injectable()
+export class InProcessSchedule implements OnApplicationBootstrap, OnApplicationShutdown {
+  private readonly logger = new Logger(InProcessSchedule.name);
+  private readonly states = new Map<string, ScheduleState>();
+  private stopped = true;
+
+  constructor(
+    private readonly scheduleRegistry: BatchScheduleRegistry,
+    private readonly launcher: JobLauncher,
+  ) {}
+
+  onApplicationBootstrap(): void {
+    this.stopped = false;
+    for (const entry of this.scheduleRegistry.getAll()) {
+      if (entry.inert) {
+        this.logger.log(`Skipping inert schedule: ${entry.jobId}::${entry.scheduleName}`);
+        continue;
+      }
+
+      try {
+        let state!: ScheduleState;
+        const job = CronJob.from({
+          cronTime: entry.cron,
+          timeZone: entry.timezone,
+          start: false,
+          unrefTimeout: true,
+          name: scheduleKey(entry),
+          errorHandler: (err) => {
+            this.logger.warn(
+              `In-process schedule ${scheduleKey(entry)} callback failed: ${
+                err instanceof Error ? err.message : String(err)
+              }`,
+            );
+          },
+          onTick: () => {
+            if (this.stopped) return;
+            this.dispatch(state, state.job.lastDate() ?? new Date());
+          },
+        });
+        state = {
+          entry,
+          job,
+          runningCount: 0,
+          queued: false,
+          queuedAt: null,
+        };
+        this.states.set(scheduleKey(entry), state);
+        job.start();
+      } catch (err) {
+        this.logger.warn(
+          `Failed to install in-process schedule ${entry.jobId}::${entry.scheduleName}: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
+    }
+
+    if (this.states.size === 0) return;
+
+    this.logger.log(`InProcessSchedule started: schedules=${this.states.size}`);
+  }
+
+  onApplicationShutdown(): void {
+    this.stopped = true;
+    for (const state of this.states.values()) {
+      void state.job.stop();
+    }
+    this.states.clear();
+  }
+
+  private dispatch(state: ScheduleState, scheduledAt: Date): void {
+    if (this.stopped) return;
+    const overlap = state.entry.overlap ?? 'skip';
+    if (state.runningCount > 0) {
+      if (overlap === 'skip') return;
+      if (overlap === 'queue') {
+        state.queued = true;
+        state.queuedAt ??= scheduledAt;
+        return;
+      }
+    }
+
+    state.runningCount += 1;
+    void this.launch(state, scheduledAt).finally(() => {
+      state.runningCount -= 1;
+      if (this.stopped) return;
+      if (state.runningCount === 0 && state.queued) {
+        state.queued = false;
+        const queuedAt = state.queuedAt ?? new Date();
+        state.queuedAt = null;
+        this.dispatch(state, queuedAt);
+      }
+    });
+  }
+
+  private async launch(state: ScheduleState, scheduledAt: Date): Promise<void> {
+    const { entry } = state;
+    try {
+      const execution = await this.launcher.launch(entry.jobId, {
+        scheduled: true,
+        scheduleName: entry.scheduleName,
+        scheduledAt: scheduledAt.toISOString(),
+      });
+      this.logger.log(
+        `Fired schedule ${entry.jobId}::${entry.scheduleName} -> ` +
+          `execution=${execution.id} status=${execution.status}`,
+      );
+    } catch (err) {
+      this.logger.warn(
+        `Failed to fire schedule ${entry.jobId}::${entry.scheduleName}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+}

package/src/execution/index.ts

@@ -11,3 +11,4 @@ export * from './job-key';
 export * from './execution-strategy';
 export * from './ref-resolver';
 export * from './in-process-execution-strategy';
+export * from './in-process-schedule';

package/src/execution/job-executor.ts

@@ -7,11 +7,7 @@ import { StepStatus, JobStatus, FlowExecutionStatus } from '../core/status';
 import { JobNotRestartableError } from '../core/errors';
 import { TaskletStepExecutor, type StepExecutionResult } from './tasklet-step-executor';
 import { ChunkStepExecutor, type ChunkExecutionResult } from './chunk-step-executor';
-import {
-  ListenerInvoker,
-  type ResolverMap,
-  type ListenerResolver,
-} from './listener-invoker';
+import { ListenerInvoker, type ResolverMap, type ListenerResolver } from './listener-invoker';
 import { FlowEvaluator } from '../flow/flow-evaluator';
 import {
   BATCH_EVENT,
@@ -137,6 +133,7 @@ export class JobExecutor {
     await this.listenerInvoker.invokeBefore(jobResolvers, 'job', {
       jobExecutionId: execution.id,
       stepExecutionId: '<job>',
+      jobParameters: execution.params,
     });
 
     // Cache the step order once. `Object.keys` returns insertion order
@@ -196,6 +193,9 @@ export class JobExecutor {
           if (step.kind === 'tasklet') {
             result = await this.taskletExecutor.execute(step, {
               jobExecutionId: execution.id,
+              stepExecutionId: stepExecution.id,
+              stepName: step.id,
+              jobParameters: execution.params,
               jobRepository: this.repository,
               transactionManager: this.transactionManager,
               listenerInvoker: this.listenerInvoker,
@@ -217,9 +217,12 @@ export class JobExecutor {
             result = await this.chunkExecutor.execute(step, {
               jobExecutionId: execution.id,
               stepExecutionId: stepExecution.id,
+              stepName: step.id,
+              jobParameters: execution.params,
               jobRepository: this.repository,
               transactionManager: this.transactionManager,
               listenerInvoker: this.listenerInvoker,
+              listenerResolvers: jobResolvers,
               jobExecutionId2: execution.id,
               resolvers: new Map(),
               ...(resumeFromChunkIndex !== undefined ? { resumeFromChunkIndex } : {}),
@@ -281,18 +284,14 @@ export class JobExecutor {
             : result.status === StepStatus.FAILED
               ? FlowExecutionStatus.FAILED
               : FlowExecutionStatus.UNKNOWN;
-        const deciderExitStatus = await this.resolveDeciderExitStatus(
-          jobDef,
-          currentStepId,
-          {
-            jobExecution: execution,
-            stepId: step.id,
-            stepExecutionId: stepExecution.id,
-            stepStatus: result.status,
-            exitCode: result.exitCode,
-            exitMessage: result.exitMessage,
-          },
-        );
+        const deciderExitStatus = await this.resolveDeciderExitStatus(jobDef, currentStepId, {
+          jobExecution: execution,
+          stepId: step.id,
+          stepExecutionId: stepExecution.id,
+          stepStatus: result.status,
+          exitCode: result.exitCode,
+          exitMessage: result.exitMessage,
+        });
         const flowExitStatus = deciderExitStatus ?? (result.exitCode || flowStatus);
 
         let evaluatorResult = await this.flowEvaluator.evaluate(
@@ -373,8 +372,12 @@ export class JobExecutor {
     await this.listenerInvoker.invokeAfter(
       jobResolvers,
       'job',
-      { jobExecutionId: execution.id, stepExecutionId: '<job>' },
-      [{ status: finalStatus }],
+      {
+        jobExecutionId: execution.id,
+        stepExecutionId: '<job>',
+        jobParameters: execution.params,
+      },
+      { status: finalStatus },
     );
 
     await this.emit({
@@ -423,7 +426,10 @@ export class JobExecutor {
       const name = this.resolveListenerName(def.ref, lambdaCounter);
       if (def.ref.kind === RefKind.BuilderLambda) lambdaCounter += 1;
 
-      const key = `${def.phase}:${def.kind}:${name}`;
+      const key =
+        def.kind === 'skip' && def.skipKind !== undefined
+          ? `on-skip:${def.skipKind}:${name}`
+          : `${def.phase}:${def.kind}:${name}`;
       resolvers.set(key, {
         fn,
         ...(def.nonCritical !== undefined ? { nonCritical: def.nonCritical } : {}),
@@ -497,7 +503,10 @@ export class JobExecutor {
       } else if (key.startsWith('after:step:')) {
         legacy.set(`after-step:${key.slice('after:step:'.length)}`, entry.fn as ListenerResolver);
       } else if (key.startsWith('on-error:step:')) {
-        legacy.set(`on-step-error:${key.slice('on-error:step:'.length)}`, entry.fn as ListenerResolver);
+        legacy.set(
+          `on-step-error:${key.slice('on-error:step:'.length)}`,
+          entry.fn as ListenerResolver,
+        );
       }
     }
     return legacy;

package/src/execution/listener-invoker.ts

@@ -26,7 +26,8 @@
  * Registration order is preserved (Map iteration is insertion-ordered in JS).
  */
 import { Injectable, Logger } from '@nestjs/common';
-import type { ExecutionContext } from '../core/repository';
+import type { ExecutionContext, JobParameters } from '../core/repository';
+import type { SkipSubKind } from '../core/ir/listener-definition';
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -122,8 +123,6 @@ export type OnErrorKind = 'job' | 'step' | 'chunk';
  * Sub-kinds for the `on-skip` phase. The resolver key looks like
  * `on-skip:${SkipSubKind}:${name}` — for example `on-skip:read:MySkipListener`.
  */
-export type SkipSubKind = 'read' | 'process' | 'write';
-
 // ---------------------------------------------------------------------------
 // Implementation
 // ---------------------------------------------------------------------------
@@ -140,11 +139,10 @@ export class ListenerInvoker {
    * Invoke every `before:<kind>:<name>` resolver, in registration order.
    *
    * Listener signature depends on `<kind>`:
-   *   - `job` / `chunk`   — `fn(ctx)`
-   *   - `step`            — `fn(ctx, result)` (the optional `args` is the result)
-   *   - `item-read` / `item-process` / `item-write` — `fn(item, ctx)` (the
-   *     optional `args` is the item, placed in the first position by
-   *     convention)
+   *   - `job` / `step` / `chunk` — `fn(ctx, result?)`
+   *   - `item-read` / `item-process` / `item-write` — `fn(item, ctx)` for the
+   *     legacy generic path. Prefer the explicit item helpers below for exact
+   *     read/process/write signatures.
    */
   async invokeBefore(
     resolvers: ResolverMap,
@@ -183,30 +181,115 @@ export class ListenerInvoker {
     await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnError}:${kind}:`, [ctx, err]);
   }
 
-  /** Invoke every `on-skip:read:<name>` resolver. Listener signature: `fn(err, item)`. */
-  async invokeOnSkipRead(
+  /** Invoke every `before:item-read:<name>` resolver. Listener signature: `fn(ctx)`. */
+  async invokeBeforeRead(resolvers: ResolverMap, ctx: ListenerContext): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.Before}:item-read:`, [ctx]);
+  }
+
+  /** Invoke every `after:item-read:<name>` resolver. Listener signature: `fn(item, ctx)`. */
+  async invokeAfterRead(
+    resolvers: ResolverMap,
+    item: unknown,
+    ctx: ListenerContext,
+  ): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.After}:item-read:`, [item, ctx]);
+  }
+
+  /** Invoke every `on-error:item-read:<name>` resolver. Listener signature: `fn(err, ctx)`. */
+  async invokeOnReadError(
     resolvers: ResolverMap,
     err: unknown,
+    ctx: ListenerContext,
+  ): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnError}:item-read:`, [err, ctx]);
+  }
+
+  /** Invoke every `before:item-process:<name>` resolver. Listener signature: `fn(item, ctx)`. */
+  async invokeBeforeProcess(
+    resolvers: ResolverMap,
     item: unknown,
+    ctx: ListenerContext,
   ): Promise<void> {
-    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnSkip}:read:`, [err, item]);
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.Before}:item-process:`, [item, ctx]);
   }
 
-  /** Invoke every `on-skip:process:<name>` resolver. Listener signature: `fn(item, err)`. */
-  async invokeOnSkipProcess(
+  /** Invoke every `after:item-process:<name>` resolver. Listener signature: `fn(item, result, ctx)`. */
+  async invokeAfterProcess(
+    resolvers: ResolverMap,
+    item: unknown,
+    result: unknown,
+    ctx: ListenerContext,
+  ): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.After}:item-process:`, [
+      item,
+      result,
+      ctx,
+    ]);
+  }
+
+  /** Invoke every `on-error:item-process:<name>` resolver. Listener signature: `fn(item, err, ctx)`. */
+  async invokeOnProcessError(
     resolvers: ResolverMap,
     item: unknown,
     err: unknown,
+    ctx: ListenerContext,
   ): Promise<void> {
-    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnSkip}:process:`, [item, err]);
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnError}:item-process:`, [
+      item,
+      err,
+      ctx,
+    ]);
   }
 
-  /** Invoke every `on-skip:write:<name>` resolver. Listener signature: `fn(items, err)`. */
-  async invokeOnSkipWrite(
+  /** Invoke every `before:item-write:<name>` resolver. Listener signature: `fn(items, ctx)`. */
+  async invokeBeforeWrite(
+    resolvers: ResolverMap,
+    items: unknown[],
+    ctx: ListenerContext,
+  ): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.Before}:item-write:`, [items, ctx]);
+  }
+
+  /** Invoke every `after:item-write:<name>` resolver. Listener signature: `fn(items, result, ctx)`. */
+  async invokeAfterWrite(
+    resolvers: ResolverMap,
+    items: unknown[],
+    result: unknown,
+    ctx: ListenerContext,
+  ): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.After}:item-write:`, [
+      items,
+      result,
+      ctx,
+    ]);
+  }
+
+  /** Invoke every `on-error:item-write:<name>` resolver. Listener signature: `fn(items, err, ctx)`. */
+  async invokeOnWriteError(
     resolvers: ResolverMap,
     items: unknown[],
     err: unknown,
+    ctx: ListenerContext,
   ): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnError}:item-write:`, [
+      items,
+      err,
+      ctx,
+    ]);
+  }
+
+  /** Invoke every `on-skip:read:<name>` resolver. Listener signature: `fn(err, item)`. */
+  async invokeOnSkipRead(resolvers: ResolverMap, err: unknown, item: unknown): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnSkip}:read:`, [err, item]);
+  }
+
+  /** Invoke every `on-skip:process:<name>` resolver. Listener signature: `fn(item, err)`. */
+  async invokeOnSkipProcess(resolvers: ResolverMap, item: unknown, err: unknown): Promise<void> {
+    await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnSkip}:process:`, [item, err]);
+  }
+
+  /** Invoke every `on-skip:write:<name>` resolver. Listener signature: `fn(items, err)`. */
+  async invokeOnSkipWrite(resolvers: ResolverMap, items: unknown[], err: unknown): Promise<void> {
     await this.invokeMatching(resolvers, `${LISTENER_PHASE.OnSkip}:write:`, [items, err]);
   }
 
@@ -309,27 +392,21 @@ export class ListenerInvoker {
    * Compute the positional argument list to forward to a before/after
    * listener, based on the listener's kind.
    *
-   * - `job` / `chunk`   → `[ctx]`
-   * - `step`            → `[ctx, args]`   (args is the result)
+   * - `job` / `step` / `chunk` → `[ctx]` or `[ctx, args]`
    * - `item-read` /
    *   `item-process` /
    *   `item-write`      → `[args, ctx]`   (args is the item, leading position)
    */
-  private buildCallArgs(
-    kind: LifecyclePhaseKind,
-    ctx: ListenerContext,
-    args: unknown,
-  ): unknown[] {
+  private buildCallArgs(kind: LifecyclePhaseKind, ctx: ListenerContext, args: unknown): unknown[] {
     switch (kind) {
       case 'item-read':
       case 'item-process':
       case 'item-write':
-        return [args, ctx];
-      case 'step':
-        return [ctx, args];
+        return args === undefined ? [ctx] : [args, ctx];
       case 'job':
+      case 'step':
       case 'chunk':
-        return [ctx];
+        return args === undefined ? [ctx] : [ctx, args];
       default: {
         // exhaustive guard
         const _exhaustive: never = kind;
@@ -380,6 +457,7 @@ export interface ListenerContext {
   jobExecutionId: string;
   stepExecutionId?: string;
   stepName?: string;
+  jobParameters?: JobParameters;
   /** Arbitrary, executor-supplied metadata (transaction context, etc.). */
   [extra: string]: unknown;
 }

package/src/execution/tasklet-step-executor.ts

@@ -7,6 +7,7 @@ import type {
   ExecutionContext,
   StepExecution,
   ExecutionScope,
+  JobParameters,
 } from '../core/repository';
 import type { TransactionManager } from '../core/transaction';
 import { StepStatus, JobStatus } from '../core/status';
@@ -19,6 +20,9 @@ import { resolveProviderToken, type ProviderResolvers } from './ref-resolver';
  */
 export interface TaskletExecutionContext {
   jobExecutionId: string;
+  stepExecutionId?: string;
+  stepName?: string;
+  jobParameters?: JobParameters;
   jobRepository: JobRepository;
   transactionManager: TransactionManager;
   listenerInvoker: ListenerInvoker;
@@ -76,26 +80,26 @@ export class TaskletStepExecutor {
   ): Promise<StepExecutionResult> {
     // Build the TaskletContext the tasklet will see.
     //
-    // `stepExecutionId` is a placeholder here — the JobExecutor knows the real
-    // ID (it created the StepExecution) and will patch this object before the
-    // tasklet uses it. The placeholder keeps the contract explicit.
-    //
-    // `getExecutionContext` / `saveExecutionContext` are also stubbed here;
-    // they become real once the JobExecutor wires the stepExecutionId in.
-    // (For Wave 3 tests we do not exercise these methods.)
+    const stepExecutionId = context.stepExecutionId ?? '<pending>';
+    const stepName = context.stepName ?? step.id;
+    const jobParameters = context.jobParameters ?? {};
     const taskletCtx: TaskletContext = {
       jobExecutionId: context.jobExecutionId,
-      stepExecutionId: '<pending>',
-      getExecutionContext: async () => ({ data: null, version: 0 }),
-      saveExecutionContext: async (_ctx: ExecutionContext) => {
-        // wired by JobExecutor (Task 20) once stepExecutionId is known
+      stepExecutionId,
+      jobParameters,
+      getExecutionContext: async () =>
+        context.jobRepository.getExecutionContext({ stepExecutionId }),
+      saveExecutionContext: async (ctx: ExecutionContext) => {
+        await context.jobRepository.saveExecutionContext({ stepExecutionId }, ctx);
       },
     };
 
     // 1. before-step listeners
     await context.listenerInvoker.invokeBeforeStep(context.listenerResolvers, {
       jobExecutionId: context.jobExecutionId,
-      stepExecutionId: taskletCtx.stepExecutionId,
+      stepExecutionId,
+      stepName,
+      jobParameters,
     });
 
     let result: StepExecutionResult;
@@ -117,7 +121,12 @@ export class TaskletStepExecutor {
       // 3. on-step-error listeners (best-effort: rethrow their failures too)
       await context.listenerInvoker.invokeOnErrorStep(
         context.listenerResolvers,
-        { jobExecutionId: context.jobExecutionId, stepExecutionId: taskletCtx.stepExecutionId },
+        {
+          jobExecutionId: context.jobExecutionId,
+          stepExecutionId,
+          stepName,
+          jobParameters,
+        },
         err,
       );
       result = {
@@ -136,7 +145,12 @@ export class TaskletStepExecutor {
     // different branch — transition evaluation runs AFTER this call.
     await context.listenerInvoker.invokeAfterStep(
       context.listenerResolvers,
-      { jobExecutionId: context.jobExecutionId, stepExecutionId: taskletCtx.stepExecutionId },
+      {
+        jobExecutionId: context.jobExecutionId,
+        stepExecutionId,
+        stepName,
+        jobParameters,
+      },
       result,
     );
 
@@ -156,7 +170,13 @@ export class TaskletStepExecutor {
    * `builder-lambda` ref before reaching this executor.
    */
   private resolveTasklet(
-    taskletRef: { kind: string; token?: string; fn?: ListenerResolver; classToken?: string; methodName?: string },
+    taskletRef: {
+      kind: string;
+      token?: string;
+      fn?: ListenerResolver;
+      classToken?: string;
+      methodName?: string;
+    },
     context: TaskletExecutionContext,
   ): Tasklet {
     if (taskletRef.kind === RefKind.BuilderLambda && taskletRef.fn) {
@@ -164,7 +184,11 @@ export class TaskletStepExecutor {
       if (typeof result === 'function') {
         return { execute: result as Tasklet['execute'] };
       }
-      if (result !== null && typeof result === 'object' && typeof (result as Tasklet).execute === 'function') {
+      if (
+        result !== null &&
+        typeof result === 'object' &&
+        typeof (result as Tasklet).execute === 'function'
+      ) {
         return result as Tasklet;
       }
       return { execute: taskletRef.fn as Tasklet['execute'] };

package/src/explorer/batch-explorer.ts

@@ -10,7 +10,7 @@ import {
   BATCH_TRANSITION_METADATA,
 } from '../decorators/constants';
 import type { JobableOptions, StepableOptions } from '../decorators';
-import type { ListenerKind, ListenerPhase } from '../core/ir/listener-definition';
+import type { ListenerKind, ListenerPhase, SkipSubKind } from '../core/ir/listener-definition';
 
 /**
  * Raw shape of a discovered batch job, as it appears immediately after the
@@ -50,6 +50,7 @@ export interface DiscoveredListener {
   methodName: string;
   kind: ListenerKind;
   phase: ListenerPhase;
+  skipKind?: SkipSubKind;
   nonCritical?: boolean;
 }
 
@@ -164,8 +165,7 @@ export class BatchExplorer implements OnModuleInit {
         | StepableOptions
         | undefined;
       if (!opts) continue;
-      const isTasklet =
-        Reflect.getMetadata(BATCH_TASKLET_METADATA, prototype, name) === true;
+      const isTasklet = Reflect.getMetadata(BATCH_TASKLET_METADATA, prototype, name) === true;
       result.push({ methodName: name, options: opts, isTasklet });
     }
     return result;
@@ -186,13 +186,19 @@ export class BatchExplorer implements OnModuleInit {
     const result: DiscoveredListener[] = [];
     for (const name of this.allMethodNames(prototype)) {
       const opts = Reflect.getMetadata(BATCH_LISTENER_METADATA, prototype, name) as
-        | { kind: ListenerKind; phase: ListenerPhase; nonCritical?: boolean }
+        | {
+            kind: ListenerKind;
+            phase: ListenerPhase;
+            skipKind?: SkipSubKind;
+            nonCritical?: boolean;
+          }
         | undefined;
       if (!opts) continue;
       result.push({
         methodName: name,
         kind: opts.kind,
         phase: opts.phase,
+        ...(opts.skipKind !== undefined ? { skipKind: opts.skipKind } : {}),
         nonCritical: opts.nonCritical,
       });
     }

package/src/index.ts

@@ -14,6 +14,7 @@ export * from './transaction';
 export * from './repository';
 export * as BatchDecorators from './decorators';
 export * from './module';
+export * from './scheduling/batch-scheduled';
 export * from './builder';
 export * from './explorer';
 export * from './listeners';