@nest-batch/core 0.2.0

package/dist/src/execution/job-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/execution/job-executor.ts"],"sourcesContent":["import { Injectable, Inject, Optional, forwardRef, Logger } from '@nestjs/common';\nimport type { JobDefinition, ListenerDefinition } from '../core/ir';\nimport { RefKind, type ListenerRef } from '../core/ir';\nimport { JobRepository, type JobParameters, type JobExecution } from '../core/repository';\nimport { TransactionManager } from '../core/transaction';\nimport { StepStatus, JobStatus, FlowExecutionStatus } from '../core/status';\nimport { JobNotRestartableError } from '../core/errors';\nimport { TaskletStepExecutor, type StepExecutionResult } from './tasklet-step-executor';\nimport { ChunkStepExecutor, type ChunkExecutionResult } from './chunk-step-executor';\nimport {\n  ListenerInvoker,\n  type ResolverMap,\n  type ListenerResolver,\n} from './listener-invoker';\nimport { FlowEvaluator } from '../flow/flow-evaluator';\nimport {\n  BATCH_EVENT,\n  NoopBatchObserver,\n  type BatchEvent,\n  type BatchObserver,\n} from '../observability';\n\n/**\n * Result type that covers both tasklet and chunk step outcomes.\n * Structurally compatible with `StepExecutionPatch` so the executor\n * can forward it directly to `updateStepExecution`.\n *\n * The only field chunk has but tasklet doesn't is `commitCount`; for\n * tasklet results it stays `undefined` and `updateStepExecution`\n * happily ignores undefined fields (merge semantics, see repository).\n */\ntype StepResult = StepExecutionResult | ChunkExecutionResult;\n\n/**\n * JobExecutor — drives a single JobExecution to completion.\n *\n * Flow (per ORACLE verdict 3c):\n *   1. Mark execution as STARTED.\n *   2. `before:job:*` listeners.\n *   3. Loop:\n *      a. Look up the current step (jobDef.steps[currentStepId]). If the\n *         step is missing, mark the job FAILED with exit code\n *         `NO_SUCH_STEP` and break.\n *      b. Create a StepExecution, run it (tasklet or chunk), and persist\n *         the result via `updateStepExecution`. During the run, the\n *         step's own `after-step:*` listeners fire (see\n *         `TaskletStepExecutor.execute` step 4 / `ChunkStepExecutor`).\n *         Those listeners run BEFORE we evaluate transitions so they get\n *         a chance to mutate the result (e.g. flip COMPLETED → FAILED)\n *         and the resulting flow routing sees the override.\n *      c. Map the (possibly overridden) step status to a\n *         `FlowExecutionStatus` and ask the `FlowEvaluator` for the next\n *         step. `null` means END.\n *      d. If the step FAILED and the evaluator returned `null`\n *         (no recovery transition matches), short-circuit the job to\n *         FAILED — we must not continue running subsequent steps\n *         declared in the graph, because none are reachable.\n *   4. `after:job:*` listeners (with the final status).\n *\n * Out of scope (future tasks):\n *   - Concurrency control (Task 38).\n *   - `on-error:job:*` listener invocation when the executor itself\n *     throws (the catch block can be wired to it in a follow-up).\n */\n@Injectable()\nexport class JobExecutor {\n  private readonly logger = new Logger(JobExecutor.name);\n\n  constructor(\n    private readonly repository: JobRepository,\n    @Inject(forwardRef(() => TransactionManager))\n    private readonly transactionManager: TransactionManager,\n    private readonly taskletExecutor: TaskletStepExecutor,\n    private readonly chunkExecutor: ChunkStepExecutor,\n    private readonly listenerInvoker: ListenerInvoker,\n    private readonly flowEvaluator: FlowEvaluator,\n    @Optional()\n    private readonly observer: BatchObserver = new NoopBatchObserver(),\n  ) {}\n\n  /**\n   * Execute a JobExecution against its `JobDefinition`. Returns the\n   * final, persisted `JobExecution` (status = COMPLETED | FAILED).\n   *\n   * Restart behavior (per Metis verdict 3b — restartable opt-in, per\n   * ORACLE 3b — default-on for persisted repositories):\n   *   - If `execution.status` is `FAILED` on entry, this is a restart\n   *     attempt. We require `jobDef.restartable === true`; otherwise we\n   *     throw `JobNotRestartableError` and leave the execution alone.\n   *   - For each chunk step, we look up the latest FAILED StepExecution\n   *     for that step in this job execution. If one exists, we read its\n   *     ExecutionContext's `lastChunkIndex` checkpoint and pass it to the\n   *     `ChunkStepExecutor` as `resumeFromChunkIndex`, which then skips\n   *     chunks ≤ that index. Tasklet steps always re-run from scratch\n   *     (they have no chunk-level resume granularity in this MVP).\n   *\n   * Partition routing (T8): the optional third argument carries the\n   * `partitionIndex` / `partitionCount` pair the transport attached\n   * to the job. When set, the chunk executor bounds the read loop\n   * to the partition's range (see `packages/core/src/partition-helpers.ts`).\n   */\n  async execute(\n    execution: JobExecution,\n    jobDef: JobDefinition,\n    partition?: { partitionIndex?: number; partitionCount?: number },\n  ): Promise<JobExecution> {\n    // Capture the pre-execute status. For a fresh launch, the launcher\n    // created the execution with status STARTING; for a restart, the\n    // caller (JobLauncher.run) hands us a terminal execution that can\n    // be resumed.\n    const isRestart =\n      execution.status === JobStatus.FAILED || execution.status === JobStatus.STOPPED;\n    if (isRestart && !jobDef.restartable) {\n      throw new JobNotRestartableError(jobDef.id);\n    }\n\n    await this.repository.updateJobExecution(execution.id, {\n      status: JobStatus.STARTED,\n      startTime: new Date(),\n    });\n\n    await this.emit({\n      type: BATCH_EVENT.JOB_STARTED,\n      timestamp: new Date(),\n      jobExecutionId: execution.id,\n      data: { jobName: jobDef.id },\n    });\n\n    // Build the full resolver map once. The same map powers both the\n    // job-level `invokeBefore` / `invokeAfter` calls below and the\n    // step-level resolvers handed to the TaskletStepExecutor (derived\n    // by `buildLegacyStepResolvers` into the legacy key shape). Building\n    // it once per execution avoids re-walking the IR on every step.\n    const jobResolvers = this.buildResolverMap(jobDef);\n    const stepResolvers = this.buildLegacyStepResolvers(jobResolvers);\n\n    await this.listenerInvoker.invokeBefore(jobResolvers, 'job', {\n      jobExecutionId: execution.id,\n      stepExecutionId: '<job>',\n    });\n\n    // Cache the step order once. `Object.keys` returns insertion order\n    // for string keys (per ES2015+), so this is the canonical\n    // declaration order — used for the linear fallback below.\n    const stepOrder = Object.keys(jobDef.steps);\n\n    let currentStepId: string | null = jobDef.startStepId;\n    let finalStatus: JobStatus = JobStatus.COMPLETED;\n    let currentStepExecutionId: string | null = null;\n\n    try {\n      while (currentStepId !== null) {\n        const step = jobDef.steps[currentStepId];\n        if (!step) {\n          await this.repository.updateJobExecution(execution.id, {\n            status: JobStatus.FAILED,\n            endTime: new Date(),\n            exitCode: 'NO_SUCH_STEP',\n            exitMessage: `Step \"${currentStepId}\" not found`,\n          });\n          finalStatus = JobStatus.FAILED;\n          break;\n        }\n\n        // Restart path: if this is a restart and the current step is a\n        // chunk step, locate the latest FAILED step execution for the\n        // same step name and load its `lastChunkIndex` checkpoint. That\n        // value is passed to the chunk executor as `resumeFromChunkIndex`.\n        // For tasklet steps (and chunk steps with no prior failure) we\n        // leave `resumeFromChunkIndex` undefined — the chunk executor\n        // treats undefined as \"start from the beginning\".\n        //\n        // Look this up BEFORE createStepExecution so the just-created\n        // STARTING step isn't returned as the \"latest\" entry.\n        let resumeFromChunkIndex: number | undefined;\n        if (isRestart && step.kind === 'chunk') {\n          const priorFailed = await this.repository.findLatestStepExecution(execution.id, step.id);\n          if (priorFailed && priorFailed.status === StepStatus.FAILED) {\n            resumeFromChunkIndex = await this.getLastCheckpoint(priorFailed.id);\n          }\n        }\n\n        const stepExecution = await this.repository.createStepExecution(execution.id, step.id);\n        currentStepExecutionId = stepExecution.id;\n\n        await this.emit({\n          type: BATCH_EVENT.STEP_STARTED,\n          timestamp: new Date(),\n          jobExecutionId: execution.id,\n          stepExecutionId: stepExecution.id,\n          data: { stepId: step.id, kind: step.kind },\n        });\n\n        let result: StepResult;\n        try {\n          if (step.kind === 'tasklet') {\n            result = await this.taskletExecutor.execute(step, {\n              jobExecutionId: execution.id,\n              jobRepository: this.repository,\n              transactionManager: this.transactionManager,\n              listenerInvoker: this.listenerInvoker,\n              listenerResolvers: stepResolvers,\n            });\n          } else {\n            // Forward the partition routing (T8) when the transport\n            // supplied one. The chunk executor uses the partition\n            // index + count + the step's `partitions.range` to bound\n            // its read loop. Absent partition args fall through to\n            // the 0.1.0 non-partitioned chunk pipeline.\n            const partitionArgs =\n              partition?.partitionIndex !== undefined && partition?.partitionCount !== undefined\n                ? {\n                    partitionIndex: partition.partitionIndex,\n                    partitionCount: partition.partitionCount,\n                  }\n                : {};\n            result = await this.chunkExecutor.execute(step, {\n              jobExecutionId: execution.id,\n              stepExecutionId: stepExecution.id,\n              jobRepository: this.repository,\n              transactionManager: this.transactionManager,\n              listenerInvoker: this.listenerInvoker,\n              jobExecutionId2: execution.id,\n              resolvers: new Map(),\n              ...(resumeFromChunkIndex !== undefined ? { resumeFromChunkIndex } : {}),\n              ...partitionArgs,\n            });\n          }\n        } catch (stepErr) {\n          // The executor itself threw (e.g. resolveReader threw in a\n          // chunk step before the executor's own try-catch could catch\n          // it). Persist the step as FAILED with the error message and\n          // re-raise so the outer handler marks the job FAILED.\n          await this.repository.updateStepExecution(stepExecution.id, {\n            status: StepStatus.FAILED,\n            exitCode: 'FAILED',\n            exitMessage: stepErr instanceof Error ? stepErr.message : String(stepErr),\n            endTime: new Date(),\n          });\n          currentStepExecutionId = null;\n          throw stepErr;\n        }\n        currentStepExecutionId = null;\n\n        await this.repository.updateStepExecution(stepExecution.id, {\n          status: result.status,\n          ...(result.readCount !== undefined ? { readCount: result.readCount } : {}),\n          ...(result.writeCount !== undefined ? { writeCount: result.writeCount } : {}),\n          ...(result.skipCount !== undefined ? { skipCount: result.skipCount } : {}),\n          ...('commitCount' in result && result.commitCount !== undefined\n            ? { commitCount: result.commitCount }\n            : {}),\n          exitCode: result.exitCode,\n          exitMessage: result.exitMessage,\n          endTime: new Date(),\n        });\n\n        await this.emit({\n          type:\n            result.status === StepStatus.COMPLETED\n              ? BATCH_EVENT.STEP_COMPLETED\n              : result.status === StepStatus.FAILED\n                ? BATCH_EVENT.STEP_FAILED\n                : BATCH_EVENT.STEP_COMPLETED,\n          timestamp: new Date(),\n          jobExecutionId: execution.id,\n          stepExecutionId: stepExecution.id,\n          data: {\n            stepId: step.id,\n            status: result.status,\n            ...(result.exitCode !== undefined ? { exitCode: result.exitCode } : {}),\n          },\n        });\n\n        // Map StepStatus -> FlowExecutionStatus. Anything other than\n        // COMPLETED/FAILED collapses to UNKNOWN → evaluator returns\n        // null → flow ends.\n        const flowStatus: FlowExecutionStatus =\n          result.status === StepStatus.COMPLETED\n            ? FlowExecutionStatus.COMPLETED\n            : result.status === StepStatus.FAILED\n              ? FlowExecutionStatus.FAILED\n              : FlowExecutionStatus.UNKNOWN;\n        const deciderExitStatus = await this.resolveDeciderExitStatus(\n          jobDef,\n          currentStepId,\n          {\n            jobExecution: execution,\n            stepId: step.id,\n            stepExecutionId: stepExecution.id,\n            stepStatus: result.status,\n            exitCode: result.exitCode,\n            exitMessage: result.exitMessage,\n          },\n        );\n        const flowExitStatus = deciderExitStatus ?? (result.exitCode || flowStatus);\n\n        let evaluatorResult = await this.flowEvaluator.evaluate(\n          jobDef.transitions,\n          currentStepId,\n          flowExitStatus,\n        );\n\n        // Distinguish \"no transition declared\" (linear fallback) from\n        // \"transition declared with toStepId: null\" (explicit END).\n        // FlowEvaluator returns null for both, so we inspect the\n        // transition list directly.\n        let hasMatchingTransition = jobDef.transitions.some((t) =>\n          this.flowEvaluator.matches(t, currentStepId!, flowExitStatus),\n        );\n        if (!hasMatchingTransition && flowExitStatus !== flowStatus) {\n          evaluatorResult = await this.flowEvaluator.evaluate(\n            jobDef.transitions,\n            currentStepId,\n            flowStatus,\n          );\n          hasMatchingTransition = jobDef.transitions.some((t) =>\n            this.flowEvaluator.matches(t, currentStepId!, flowStatus),\n          );\n        }\n\n        let nextStepId: string | null;\n        if (hasMatchingTransition) {\n          // Explicit transition: respect its target, including null\n          // (END). Do not fall through to linear order.\n          nextStepId = evaluatorResult;\n        } else if (result.status === StepStatus.FAILED) {\n          // FAILED with no matching transition → short-circuit. The\n          // graph declares no path forward, so the job is FAILED — we\n          // must not invent a \"next\" step.\n          await this.repository.updateJobExecution(execution.id, {\n            status: JobStatus.FAILED,\n            endTime: new Date(),\n            exitCode: result.exitCode,\n            exitMessage: result.exitMessage,\n          });\n          finalStatus = JobStatus.FAILED;\n          break;\n        } else {\n          // COMPLETED with no transition → linear fallback to the next\n          // step in declaration order. If we're already on the last\n          // step, the job ends.\n          const currentIdx = stepOrder.indexOf(currentStepId);\n          const nextIdx = currentIdx + 1;\n          nextStepId = nextIdx < stepOrder.length ? stepOrder[nextIdx]! : null;\n        }\n\n        currentStepId = nextStepId;\n      }\n\n      if (finalStatus === JobStatus.COMPLETED) {\n        await this.repository.updateJobExecution(execution.id, {\n          status: JobStatus.COMPLETED,\n          endTime: new Date(),\n          exitCode: 'COMPLETED',\n        });\n      }\n    } catch (err) {\n      // Defensive: leave the job FAILED rather than crash the host.\n      await this.repository.updateJobExecution(execution.id, {\n        status: JobStatus.FAILED,\n        endTime: new Date(),\n        exitMessage: err instanceof Error ? err.message : String(err),\n      });\n      finalStatus = JobStatus.FAILED;\n    }\n\n    // `after:job:*` listeners run once the job is in a terminal state.\n    // They receive the final status as the second positional argument\n    // (the `args` slot in the current API; the legacy builder path used\n    // the same shape). The resolver map is the same one built above;\n    // we re-use it to avoid a second IR walk.\n    await this.listenerInvoker.invokeAfter(\n      jobResolvers,\n      'job',\n      { jobExecutionId: execution.id, stepExecutionId: '<job>' },\n      [{ status: finalStatus }],\n    );\n\n    await this.emit({\n      type:\n        finalStatus === JobStatus.COMPLETED ? BATCH_EVENT.JOB_COMPLETED : BATCH_EVENT.JOB_FAILED,\n      timestamp: new Date(),\n      jobExecutionId: execution.id,\n      data: { status: finalStatus },\n    });\n\n    return (await this.repository.getJobExecution(execution.id))!;\n  }\n\n  /**\n   * Build a listener resolver map for the given job. Walks every\n   * `ListenerDefinition` in `jobDef.listeners` (job-level + step-level +\n   * chunk-level + item-level + skip-level) and resolves each ref into a\n   * callable `ListenerEntry` keyed by `${phase}:${kind}:${name}`.\n   *\n   * The returned map is consumed by `ListenerInvoker.invokeBefore /\n   * invokeAfter / invokeOnError / invokeOnSkip*` (Task 20 API). The legacy\n   * step-level methods (`invokeBeforeStep` etc.) consume a derived\n   * legacy-shaped map produced by `buildLegacyStepResolvers` — that\n   * conversion happens at the call site, not here, so this method stays\n   * the single source of truth for the new shape.\n   *\n   * Ref resolution rules:\n   *   - `RefKind.BuilderLambda`  → use `ref.fn` directly (the compiler\n   *                                pre-binds decorator-discovered methods\n   *                                and the builder API ships bare fns).\n   *   - `RefKind.Method`         → requires the Jobable instance. Until\n   *                                a `ModuleRef` is wired (Task 9+), this\n   *                                branch logs a warning and is skipped.\n   *   - `RefKind.ProviderToken`  → resolved in Task 9 against a\n   *                                pre-built provider map. Skipped here\n   *                                with a warning.\n   */\n  private buildResolverMap(jobDef: JobDefinition): ResolverMap {\n    const resolvers: ResolverMap = new Map();\n    let lambdaCounter = 0;\n\n    for (const def of jobDef.listeners) {\n      const fn = this.resolveListenerRef(def);\n      if (fn === null) continue;\n\n      const name = this.resolveListenerName(def.ref, lambdaCounter);\n      if (def.ref.kind === RefKind.BuilderLambda) lambdaCounter += 1;\n\n      const key = `${def.phase}:${def.kind}:${name}`;\n      resolvers.set(key, {\n        fn,\n        ...(def.nonCritical !== undefined ? { nonCritical: def.nonCritical } : {}),\n      });\n    }\n\n    return resolvers;\n  }\n\n  /**\n   * Resolve a single `ListenerDefinition` to its callable function, or\n   * `null` if the ref kind is not yet supported. See `buildResolverMap`\n   * for the per-kind resolution contract.\n   */\n  private resolveListenerRef(def: ListenerDefinition): ((...args: any[]) => any) | null {\n    const ref = def.ref;\n    switch (ref.kind) {\n      case RefKind.BuilderLambda:\n        return ref.fn ?? null;\n      case RefKind.Method:\n        this.logger.warn(\n          `JobExecutor: Method-ref listener (classToken=${ref.classToken ?? '<unknown>'}, ` +\n            `methodName=${ref.methodName ?? '<unknown>'}) requires a Jobable instance; ` +\n            'this resolution path lands in a follow-up task. Listener skipped.',\n        );\n        return null;\n      case RefKind.ProviderToken:\n        this.logger.warn(\n          `JobExecutor: ProviderToken-ref listener (token=${ref.token ?? '<empty>'}) ` +\n            'is resolved in Task 9. Listener skipped.',\n        );\n        return null;\n      default: {\n        const _exhaustive: never = ref.kind;\n        void _exhaustive;\n        return null;\n      }\n    }\n  }\n\n  /**\n   * Derive the `name` segment of the resolver key. Method refs carry a\n   * `classToken` + `methodName` pair that uniquely identifies the bound\n   * method; BuilderLambda refs do not carry a name (the compiler drops\n   * the method name when it pre-binds), so we mint a `lambda-N` name\n   * from a per-job counter to guarantee uniqueness.\n   */\n  private resolveListenerName(ref: ListenerRef, lambdaCounter: number): string {\n    if (ref.kind === RefKind.Method) {\n      return `${ref.classToken ?? '<unknown>'}.${ref.methodName ?? '<unknown>'}`;\n    }\n    return `lambda-${lambdaCounter}`;\n  }\n\n  /**\n   * Derive a legacy `Map<string, ListenerResolver>` from a new\n   * `ResolverMap`, containing only the step-level entries with their\n   * keys translated from `${phase}:step:${name}` back to the legacy\n   * `${phase}-step:${name}` shape. The `nonCritical` flag is dropped\n   * (legacy `ListenerResolver` is a bare function with no metadata).\n   *\n   * This is the bridge the `TaskletStepExecutor` (which still consumes\n   * the legacy shape) needs until it migrates to the new API. Kept as\n   * a private helper so the conversion logic is in one place.\n   */\n  private buildLegacyStepResolvers(resolvers: ResolverMap): Map<string, ListenerResolver> {\n    const legacy: Map<string, ListenerResolver> = new Map();\n    for (const [key, entry] of resolvers.entries()) {\n      if (key.startsWith('before:step:')) {\n        legacy.set(`before-step:${key.slice('before:step:'.length)}`, entry.fn as ListenerResolver);\n      } else if (key.startsWith('after:step:')) {\n        legacy.set(`after-step:${key.slice('after:step:'.length)}`, entry.fn as ListenerResolver);\n      } else if (key.startsWith('on-error:step:')) {\n        legacy.set(`on-step-error:${key.slice('on-error:step:'.length)}`, entry.fn as ListenerResolver);\n      }\n    }\n    return legacy;\n  }\n\n  /**\n   * Read the `lastChunkIndex` checkpoint from the step-scoped\n   * ExecutionContext for `stepExecutionId`. Returns `undefined` when the\n   * step has no recorded checkpoint (e.g., the prior run failed on the\n   * very first chunk and never got a chance to write one). The chunk\n   * executor treats `undefined` as \"no resume; start from the beginning\".\n   */\n  private async getLastCheckpoint(stepExecutionId: string): Promise<number | undefined> {\n    const ctx = await this.repository.getExecutionContext({ stepExecutionId });\n    if (ctx.data === null || typeof ctx.data !== 'object' || Array.isArray(ctx.data)) {\n      return undefined;\n    }\n    const value = (ctx.data as { lastChunkIndex?: unknown }).lastChunkIndex;\n    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n  }\n\n  private async resolveDeciderExitStatus(\n    jobDef: JobDefinition,\n    afterStepId: string,\n    context: Parameters<NonNullable<JobDefinition['deciders']>[number]['decide']>[0],\n  ): Promise<string | undefined> {\n    const decider = (jobDef.deciders ?? []).find((d) => d.afterStepId === afterStepId);\n    if (decider === undefined) return undefined;\n    const status = await decider.decide(context);\n    const trimmed = status.trim();\n    return trimmed.length > 0 ? trimmed : undefined;\n  }\n\n  /**\n   * Dispatch a BatchEvent to the configured observer. Errors thrown by\n   * the observer are swallowed: a failing logger/queue must not crash\n   * the executor (the job's persisted state is the source of truth).\n   */\n  private async emit(event: BatchEvent): Promise<void> {\n    try {\n      await this.observer.onEvent(event);\n    } catch {\n      // intentional: observer failures are best-effort and must not\n      // affect the executor's own state transitions.\n    }\n  }\n}\n\n// Re-export common types for convenience so callers that import\n// `JobExecutor` don't need a second import for `StepExecutionResult` etc.\nexport type { StepExecutionResult } from './tasklet-step-executor';\nexport type { ChunkExecutionResult } from './chunk-step-executor';\nexport type { JobParameters, JobExecution };\n"],"names":["JobExecutor","logger","Logger","name","repository","transactionManager","taskletExecutor","chunkExecutor","listenerInvoker","flowEvaluator","observer","NoopBatchObserver","execute","execution","jobDef","partition","isRestart","status","JobStatus","FAILED","STOPPED","restartable","JobNotRestartableError","id","updateJobExecution","STARTED","startTime","Date","emit","type","BATCH_EVENT","JOB_STARTED","timestamp","jobExecutionId","data","jobName","jobResolvers","buildResolverMap","stepResolvers","buildLegacyStepResolvers","invokeBefore","stepExecutionId","stepOrder","Object","keys","steps","currentStepId","startStepId","finalStatus","COMPLETED","currentStepExecutionId","step","endTime","exitCode","exitMessage","resumeFromChunkIndex","kind","priorFailed","findLatestStepExecution","StepStatus","getLastCheckpoint","stepExecution","createStepExecution","STEP_STARTED","stepId","result","jobRepository","listenerResolvers","partitionArgs","partitionIndex","undefined","partitionCount","jobExecutionId2","resolvers","Map","stepErr","updateStepExecution","Error","message","String","readCount","writeCount","skipCount","commitCount","STEP_COMPLETED","STEP_FAILED","flowStatus","FlowExecutionStatus","UNKNOWN","deciderExitStatus","resolveDeciderExitStatus","jobExecution","stepStatus","flowExitStatus","evaluatorResult","evaluate","transitions","hasMatchingTransition","some","t","matches","nextStepId","currentIdx","indexOf","nextIdx","length","err","invokeAfter","JOB_COMPLETED","JOB_FAILED","getJobExecution","lambdaCounter","def","listeners","fn","resolveListenerRef","resolveListenerName","ref","RefKind","BuilderLambda","key","phase","set","nonCritical","Method","warn","classToken","methodName","ProviderToken","token","_exhaustive","legacy","entry","entries","startsWith","slice","ctx","getExecutionContext","Array","isArray","value","lastChunkIndex","Number","isFinite","afterStepId","context","decider","deciders","find","d","decide","trimmed","trim","event","onEvent","TransactionManager"],"mappings":"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"}

package/dist/src/execution/job-explorer.d.ts

@@ -0,0 +1,15 @@
+import type { JobDefinition } from '../core/ir';
+import { JobExecutionDetails, JobExecutionFilter, JobInstance, JobInstanceFilter, JobExecution } from '../core/repository';
+import { JobRepository } from '../core/repository';
+import { JobRegistry } from '../registry/job-registry';
+export declare class JobExplorer {
+    private readonly registry;
+    private readonly repository;
+    constructor(registry: JobRegistry, repository: JobRepository);
+    listJobs(): JobDefinition[];
+    getJobInstance(jobInstanceId: string): Promise<JobInstance>;
+    listJobInstances(filter?: JobInstanceFilter): Promise<JobInstance[]>;
+    listJobExecutions(filter?: JobExecutionFilter): Promise<JobExecution[]>;
+    getJobExecutionDetails(executionId: string): Promise<JobExecutionDetails>;
+}
+//# sourceMappingURL=job-explorer.d.ts.map

package/dist/src/execution/job-explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-explorer.d.ts","sourceRoot":"","sources":["../../../src/execution/job-explorer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,iBAAiB,EACjB,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAKnD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,qBACa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBADV,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,aAAa;IAG5C,QAAQ,IAAI,aAAa,EAAE;IAIrB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ3D,gBAAgB,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAIxE,iBAAiB,CAAC,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAI3E,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA4BhF"}

package/dist/src/execution/job-explorer.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "JobExplorer", {
+    enumerable: true,
+    get: function() {
+        return JobExplorer;
+    }
+});
+const _common = require("@nestjs/common");
+const _repository = require("../core/repository");
+const _errors = require("../core/errors");
+const _jobregistry = require("../registry/job-registry");
+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 JobExplorer = class JobExplorer {
+    registry;
+    repository;
+    constructor(registry, repository){
+        this.registry = registry;
+        this.repository = repository;
+    }
+    listJobs() {
+        return this.registry.getAll();
+    }
+    async getJobInstance(jobInstanceId) {
+        const instance = await this.repository.getJobInstance(jobInstanceId);
+        if (instance === null) {
+            throw new _errors.JobInstanceNotFoundError(jobInstanceId);
+        }
+        return instance;
+    }
+    async listJobInstances(filter = {}) {
+        return this.repository.findJobInstances(filter);
+    }
+    async listJobExecutions(filter = {}) {
+        return this.repository.findJobExecutions(filter);
+    }
+    async getJobExecutionDetails(executionId) {
+        const jobExecution = await this.repository.getJobExecution(executionId);
+        if (jobExecution === null) {
+            throw new _errors.JobExecutionNotFoundError(executionId);
+        }
+        const jobInstance = await this.repository.getJobInstance(jobExecution.jobInstanceId);
+        if (jobInstance === null) {
+            throw new _errors.JobInstanceNotFoundError(jobExecution.jobInstanceId);
+        }
+        const stepExecutions = await this.repository.findStepExecutions(executionId);
+        const jobContext = await this.repository.getExecutionContext({
+            jobExecutionId: executionId
+        });
+        const stepContexts = await Promise.all(stepExecutions.map(async (step)=>({
+                stepExecutionId: step.id,
+                context: await this.repository.getExecutionContext({
+                    stepExecutionId: step.id
+                })
+            })));
+        return {
+            jobInstance,
+            jobExecution,
+            stepExecutions,
+            jobContext,
+            stepContexts
+        };
+    }
+};
+JobExplorer = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _jobregistry.JobRegistry === "undefined" ? Object : _jobregistry.JobRegistry,
+        typeof _repository.JobRepository === "undefined" ? Object : _repository.JobRepository
+    ])
+], JobExplorer);
+
+//# sourceMappingURL=job-explorer.js.map

package/dist/src/execution/job-explorer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/execution/job-explorer.ts"],"sourcesContent":["import { Injectable } from '@nestjs/common';\n\nimport type { JobDefinition } from '../core/ir';\nimport {\n  JobExecutionDetails,\n  JobExecutionFilter,\n  JobInstance,\n  JobInstanceFilter,\n  JobExecution,\n} from '../core/repository';\nimport { JobRepository } from '../core/repository';\nimport {\n  JobExecutionNotFoundError,\n  JobInstanceNotFoundError,\n} from '../core/errors';\nimport { JobRegistry } from '../registry/job-registry';\n\n@Injectable()\nexport class JobExplorer {\n  constructor(\n    private readonly registry: JobRegistry,\n    private readonly repository: JobRepository,\n  ) {}\n\n  listJobs(): JobDefinition[] {\n    return this.registry.getAll();\n  }\n\n  async getJobInstance(jobInstanceId: string): Promise<JobInstance> {\n    const instance = await this.repository.getJobInstance(jobInstanceId);\n    if (instance === null) {\n      throw new JobInstanceNotFoundError(jobInstanceId);\n    }\n    return instance;\n  }\n\n  async listJobInstances(filter: JobInstanceFilter = {}): Promise<JobInstance[]> {\n    return this.repository.findJobInstances(filter);\n  }\n\n  async listJobExecutions(filter: JobExecutionFilter = {}): Promise<JobExecution[]> {\n    return this.repository.findJobExecutions(filter);\n  }\n\n  async getJobExecutionDetails(executionId: string): Promise<JobExecutionDetails> {\n    const jobExecution = await this.repository.getJobExecution(executionId);\n    if (jobExecution === null) {\n      throw new JobExecutionNotFoundError(executionId);\n    }\n\n    const jobInstance = await this.repository.getJobInstance(jobExecution.jobInstanceId);\n    if (jobInstance === null) {\n      throw new JobInstanceNotFoundError(jobExecution.jobInstanceId);\n    }\n\n    const stepExecutions = await this.repository.findStepExecutions(executionId);\n    const jobContext = await this.repository.getExecutionContext({ jobExecutionId: executionId });\n    const stepContexts = await Promise.all(\n      stepExecutions.map(async (step) => ({\n        stepExecutionId: step.id,\n        context: await this.repository.getExecutionContext({ stepExecutionId: step.id }),\n      })),\n    );\n\n    return {\n      jobInstance,\n      jobExecution,\n      stepExecutions,\n      jobContext,\n      stepContexts,\n    };\n  }\n}\n"],"names":["JobExplorer","registry","repository","listJobs","getAll","getJobInstance","jobInstanceId","instance","JobInstanceNotFoundError","listJobInstances","filter","findJobInstances","listJobExecutions","findJobExecutions","getJobExecutionDetails","executionId","jobExecution","getJobExecution","JobExecutionNotFoundError","jobInstance","stepExecutions","findStepExecutions","jobContext","getExecutionContext","jobExecutionId","stepContexts","Promise","all","map","step","stepExecutionId","id","context"],"mappings":";;;;+BAkBaA;;;eAAAA;;;wBAlBc;4BAUG;wBAIvB;6BACqB;;;;;;;;;;AAGrB,IAAA,AAAMA,cAAN,MAAMA;;;IACX,YACE,AAAiBC,QAAqB,EACtC,AAAiBC,UAAyB,CAC1C;aAFiBD,WAAAA;aACAC,aAAAA;IAChB;IAEHC,WAA4B;QAC1B,OAAO,IAAI,CAACF,QAAQ,CAACG,MAAM;IAC7B;IAEA,MAAMC,eAAeC,aAAqB,EAAwB;QAChE,MAAMC,WAAW,MAAM,IAAI,CAACL,UAAU,CAACG,cAAc,CAACC;QACtD,IAAIC,aAAa,MAAM;YACrB,MAAM,IAAIC,gCAAwB,CAACF;QACrC;QACA,OAAOC;IACT;IAEA,MAAME,iBAAiBC,SAA4B,CAAC,CAAC,EAA0B;QAC7E,OAAO,IAAI,CAACR,UAAU,CAACS,gBAAgB,CAACD;IAC1C;IAEA,MAAME,kBAAkBF,SAA6B,CAAC,CAAC,EAA2B;QAChF,OAAO,IAAI,CAACR,UAAU,CAACW,iBAAiB,CAACH;IAC3C;IAEA,MAAMI,uBAAuBC,WAAmB,EAAgC;QAC9E,MAAMC,eAAe,MAAM,IAAI,CAACd,UAAU,CAACe,eAAe,CAACF;QAC3D,IAAIC,iBAAiB,MAAM;YACzB,MAAM,IAAIE,iCAAyB,CAACH;QACtC;QAEA,MAAMI,cAAc,MAAM,IAAI,CAACjB,UAAU,CAACG,cAAc,CAACW,aAAaV,aAAa;QACnF,IAAIa,gBAAgB,MAAM;YACxB,MAAM,IAAIX,gCAAwB,CAACQ,aAAaV,aAAa;QAC/D;QAEA,MAAMc,iBAAiB,MAAM,IAAI,CAAClB,UAAU,CAACmB,kBAAkB,CAACN;QAChE,MAAMO,aAAa,MAAM,IAAI,CAACpB,UAAU,CAACqB,mBAAmB,CAAC;YAAEC,gBAAgBT;QAAY;QAC3F,MAAMU,eAAe,MAAMC,QAAQC,GAAG,CACpCP,eAAeQ,GAAG,CAAC,OAAOC,OAAU,CAAA;gBAClCC,iBAAiBD,KAAKE,EAAE;gBACxBC,SAAS,MAAM,IAAI,CAAC9B,UAAU,CAACqB,mBAAmB,CAAC;oBAAEO,iBAAiBD,KAAKE,EAAE;gBAAC;YAChF,CAAA;QAGF,OAAO;YACLZ;YACAH;YACAI;YACAE;YACAG;QACF;IACF;AACF"}

package/dist/src/execution/job-key.d.ts

@@ -0,0 +1,3 @@
+import type { JobParameters } from '../core/repository/types';
+export declare function canonicalJobKey(params: JobParameters): string;
+//# sourceMappingURL=job-key.d.ts.map

package/dist/src/execution/job-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-key.d.ts","sourceRoot":"","sources":["../../../src/execution/job-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AA6B9D,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAI7D"}

package/dist/src/execution/job-key.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "canonicalJobKey", {
+    enumerable: true,
+    get: function() {
+        return canonicalJobKey;
+    }
+});
+const _crypto = require("crypto");
+/**
+ * Canonicalize JobParameters into a stable string.
+ * - Object keys sorted alphabetically (recursive)
+ * - Arrays preserve order (different order = different key)
+ * - Date → ISO string
+ * - null/undefined → omitted
+ * - Number: keep as-is (1 vs 1.0 same via String())
+ * - String: as-is (no whitespace trim — callers must normalize)
+ */ function canonicalize(value) {
+    if (value === null || value === undefined) return undefined;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+    if (typeof value === 'bigint') throw new Error('BigInt not supported in job key');
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) return value.map(canonicalize);
+    if (typeof value === 'object') {
+        const obj = value;
+        const sorted = {};
+        for (const k of Object.keys(obj).sort()){
+            const v = canonicalize(obj[k]);
+            if (v !== undefined) sorted[k] = v;
+        }
+        return sorted;
+    }
+    return value;
+}
+function canonicalJobKey(params) {
+    const canonical = canonicalize(params);
+    const json = JSON.stringify(canonical);
+    return (0, _crypto.createHash)('sha256').update(json).digest('hex');
+}
+
+//# sourceMappingURL=job-key.js.map

package/dist/src/execution/job-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/execution/job-key.ts"],"sourcesContent":["import { createHash } from 'crypto';\nimport type { JobParameters } from '../core/repository/types';\n\n/**\n * Canonicalize JobParameters into a stable string.\n * - Object keys sorted alphabetically (recursive)\n * - Arrays preserve order (different order = different key)\n * - Date → ISO string\n * - null/undefined → omitted\n * - Number: keep as-is (1 vs 1.0 same via String())\n * - String: as-is (no whitespace trim — callers must normalize)\n */\nfunction canonicalize(value: unknown): unknown {\n  if (value === null || value === undefined) return undefined;\n  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;\n  if (typeof value === 'bigint') throw new Error('BigInt not supported in job key');\n  if (value instanceof Date) return value.toISOString();\n  if (Array.isArray(value)) return value.map(canonicalize);\n  if (typeof value === 'object') {\n    const obj = value as Record<string, unknown>;\n    const sorted: Record<string, unknown> = {};\n    for (const k of Object.keys(obj).sort()) {\n      const v = canonicalize(obj[k]);\n      if (v !== undefined) sorted[k] = v;\n    }\n    return sorted;\n  }\n  return value;\n}\n\nexport function canonicalJobKey(params: JobParameters): string {\n  const canonical = canonicalize(params);\n  const json = JSON.stringify(canonical);\n  return createHash('sha256').update(json).digest('hex');\n}\n"],"names":["canonicalJobKey","canonicalize","value","undefined","Error","Date","toISOString","Array","isArray","map","obj","sorted","k","Object","keys","sort","v","params","canonical","json","JSON","stringify","createHash","update","digest"],"mappings":";;;;+BA8BgBA;;;eAAAA;;;wBA9BW;AAG3B;;;;;;;;CAQC,GACD,SAASC,aAAaC,KAAc;IAClC,IAAIA,UAAU,QAAQA,UAAUC,WAAW,OAAOA;IAClD,IAAI,OAAOD,UAAU,YAAY,OAAOA,UAAU,YAAY,OAAOA,UAAU,WAAW,OAAOA;IACjG,IAAI,OAAOA,UAAU,UAAU,MAAM,IAAIE,MAAM;IAC/C,IAAIF,iBAAiBG,MAAM,OAAOH,MAAMI,WAAW;IACnD,IAAIC,MAAMC,OAAO,CAACN,QAAQ,OAAOA,MAAMO,GAAG,CAACR;IAC3C,IAAI,OAAOC,UAAU,UAAU;QAC7B,MAAMQ,MAAMR;QACZ,MAAMS,SAAkC,CAAC;QACzC,KAAK,MAAMC,KAAKC,OAAOC,IAAI,CAACJ,KAAKK,IAAI,GAAI;YACvC,MAAMC,IAAIf,aAAaS,GAAG,CAACE,EAAE;YAC7B,IAAII,MAAMb,WAAWQ,MAAM,CAACC,EAAE,GAAGI;QACnC;QACA,OAAOL;IACT;IACA,OAAOT;AACT;AAEO,SAASF,gBAAgBiB,MAAqB;IACnD,MAAMC,YAAYjB,aAAagB;IAC/B,MAAME,OAAOC,KAAKC,SAAS,CAACH;IAC5B,OAAOI,IAAAA,kBAAU,EAAC,UAAUC,MAAM,CAACJ,MAAMK,MAAM,CAAC;AAClD"}

package/dist/src/execution/job-launcher.d.ts

@@ -0,0 +1,75 @@
+import { JobRepository, type JobParameters, type JobExecution } from '../core/repository';
+import { JobRegistry } from '../registry/job-registry';
+import { type IExecutionStrategy } from './execution-strategy';
+import { JobExecutor } from './job-executor';
+import type { JobDefinition } from '../core/ir';
+/**
+ * JobLauncher — public entry point for starting a new JobExecution.
+ *
+ * Flow (pre-strategy, kept unchanged for backwards compat):
+ *   1. Look up the `JobDefinition` from the registry. Missing → `JobNotFoundError`.
+ *   2. Canonicalize `params` into a stable `jobKey` hash. Object key order,
+ *      `null/undefined` omission, `Date → ISO` are all normalized so that
+ *      semantically-identical params yield the same key.
+ *   3. `createExecutionAtomic(jobId, jobKey, params)` — idempotent
+ *      instance get-or-create + `SELECT ... FOR UPDATE SKIP LOCKED` to
+ *      serialize concurrent launches + running-execution check + insert,
+ *      all in a single transaction. Throws
+ *      `JobExecutionAlreadyRunningError` if another launch is in flight
+ *      or an execution is already STARTING/STARTED for the same instance.
+ *   4. Delegate to the injected `IExecutionStrategy` (default:
+ *      `InProcessExecutionStrategy`, which wraps `JobExecutor.execute`).
+ *      The lock is released when the createExecutionAtomic transaction
+ *      commits; the executor itself runs outside the lock (it can be
+ *      long-running).
+ *
+ * `allowDuplicateInstances: true` bypasses step 2's dedup by appending a
+ * fresh UUID nonce to the canonical key on every call, forcing a new
+ * `JobInstance` each time.
+ *
+ * Polymorphic strategy (Task 11):
+ *   The launcher is a thin facade — it owns the registry lookup, the
+ *   canonical `jobKey` derivation, the atomic instance + concurrency
+ *   lock, and the post-strategy `JobExecution` re-resolution. The
+ *   actual *how* of running the job (in-process vs. transport) lives
+ *   behind the `EXECUTION_STRATEGY` token. Sibling packages (e.g.
+ *   `@nest-batch/bullmq`) override the token with a transport
+ *   strategy that enqueues work; the launcher never learns about the
+ *   transport.
+ *
+ *   When no strategy is bound (e.g. direct manual construction in
+ *   unit tests), the launcher falls back to the original direct
+ *   `JobExecutor.execute` path. This keeps the legacy
+ *   `tests/execution/job-launcher.test.ts` working without changes.
+ */
+export declare class JobLauncher {
+    private readonly registry;
+    private readonly repository;
+    private readonly jobExecutor;
+    private readonly strategy?;
+    constructor(registry: JobRegistry, repository: JobRepository, jobExecutor: JobExecutor, strategy?: IExecutionStrategy | undefined);
+    /**
+     * Launch a new job execution. Returns the final `JobExecution` after it
+     * has finished (status = COMPLETED | FAILED) — or, for transport
+     * strategies that return `{ kind: 'enqueued' }`, the latest persisted
+     * `JobExecution` (still in `STARTING` / `STARTED`, since the executor
+     * has not run on the launcher process).
+     *
+     * Throws `JobNotFoundError` if `jobId` is not registered.
+     * Throws `JobExecutionAlreadyRunningError` if a previous launch of the
+     * same `jobName + jobKey` is still in flight.
+     */
+    launch(jobId: string, params?: JobParameters): Promise<JobExecution>;
+    /**
+     * Resume an existing `JobExecution` (used by the restart path).
+     * For this MVP it just delegates to the executor — the launcher does
+     * not yet gate on restartable / concurrency / FAILED-prev-exists rules.
+     *
+     * Note: `run` bypasses the strategy on purpose. Restart is a
+     * recovery path on the in-process execution model; transport
+     * strategies that need their own resume semantics can override
+     * this method on a subclass or via a future token.
+     */
+    run(execution: JobExecution, jobDef: JobDefinition): Promise<JobExecution>;
+}
+//# sourceMappingURL=job-launcher.d.ts.map

package/dist/src/execution/job-launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-launcher.d.ts","sourceRoot":"","sources":["../../../src/execution/job-launcher.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBACa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAE3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAG5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBANT,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,aAAa,EAEzB,WAAW,EAAE,WAAW,EAGxB,QAAQ,CAAC,EAAE,kBAAkB,YAAA;IAGhD;;;;;;;;;;OAUG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,aAAkB,GAAG,OAAO,CAAC,YAAY,CAAC;IAqC9E;;;;;;;;;OASG;IACG,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAGjF"}

package/dist/src/execution/job-launcher.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "JobLauncher", {
+    enumerable: true,
+    get: function() {
+        return JobLauncher;
+    }
+});
+const _crypto = require("crypto");
+const _common = require("@nestjs/common");
+const _repository = require("../core/repository");
+const _jobregistry = require("../registry/job-registry");
+const _executionstrategy = require("./execution-strategy");
+const _jobexecutor = require("./job-executor");
+const _jobkey = require("./job-key");
+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);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let JobLauncher = class JobLauncher {
+    registry;
+    repository;
+    jobExecutor;
+    strategy;
+    constructor(registry, repository, jobExecutor, strategy){
+        this.registry = registry;
+        this.repository = repository;
+        this.jobExecutor = jobExecutor;
+        this.strategy = strategy;
+    }
+    /**
+   * Launch a new job execution. Returns the final `JobExecution` after it
+   * has finished (status = COMPLETED | FAILED) — or, for transport
+   * strategies that return `{ kind: 'enqueued' }`, the latest persisted
+   * `JobExecution` (still in `STARTING` / `STARTED`, since the executor
+   * has not run on the launcher process).
+   *
+   * Throws `JobNotFoundError` if `jobId` is not registered.
+   * Throws `JobExecutionAlreadyRunningError` if a previous launch of the
+   * same `jobName + jobKey` is still in flight.
+   */ async launch(jobId, params = {}) {
+        const jobDef = this.registry.get(jobId); // throws JobNotFoundError on miss
+        const canonical = (0, _jobkey.canonicalJobKey)(params);
+        const jobKey = jobDef.allowDuplicateInstances ? `${canonical}::${(0, _crypto.randomUUID)()}` : canonical;
+        // Atomic get-or-create + lock + check + insert. The repository's
+        // implementation uses INSERT ... ON CONFLICT DO NOTHING +
+        // FOR UPDATE SKIP LOCKED to serialize concurrent launches.
+        const execution = await this.repository.createExecutionAtomic(jobId, jobKey, params);
+        // No strategy bound → fall back to the legacy direct-execute path.
+        // This branch preserves `tests/execution/job-launcher.test.ts` (which
+        // wires the launcher by hand, no Nest module) and any other
+        // direct-construction consumer.
+        if (this.strategy === undefined) {
+            return this.jobExecutor.execute(execution, jobDef);
+        }
+        // The strategy's `LaunchResult` is intentionally discarded: the
+        // public `JobLauncher.launch` contract always returns a
+        // `JobExecution` (re-resolved from the repository below), and
+        // `queueJobId` is for the strategy's own bookkeeping only.
+        await this.strategy.launch(jobDef, params, {
+            executionId: execution.id,
+            jobExecutionId: execution.id
+        });
+        // For both `completed` and `enqueued` the public `JobLauncher.launch`
+        // contract returns a `JobExecution`. Re-resolve the latest persisted
+        // row so the caller sees the executor's writes (status, endTime,
+        // exitCode) without us hand-merging patches here. If the lookup
+        // somehow returns null (e.g. a custom repository that drops rows),
+        // fall back to the execution the launcher pre-created.
+        const latest = await this.repository.getJobExecution(execution.id);
+        return latest ?? execution;
+    }
+    /**
+   * Resume an existing `JobExecution` (used by the restart path).
+   * For this MVP it just delegates to the executor — the launcher does
+   * not yet gate on restartable / concurrency / FAILED-prev-exists rules.
+   *
+   * Note: `run` bypasses the strategy on purpose. Restart is a
+   * recovery path on the in-process execution model; transport
+   * strategies that need their own resume semantics can override
+   * this method on a subclass or via a future token.
+   */ async run(execution, jobDef) {
+        return this.jobExecutor.execute(execution, jobDef);
+    }
+};
+JobLauncher = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(2, (0, _common.Inject)((0, _common.forwardRef)(()=>_jobexecutor.JobExecutor))),
+    _ts_param(3, (0, _common.Optional)()),
+    _ts_param(3, (0, _common.Inject)(_executionstrategy.EXECUTION_STRATEGY)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _jobregistry.JobRegistry === "undefined" ? Object : _jobregistry.JobRegistry,
+        typeof _repository.JobRepository === "undefined" ? Object : _repository.JobRepository,
+        typeof _jobexecutor.JobExecutor === "undefined" ? Object : _jobexecutor.JobExecutor,
+        typeof IExecutionStrategy === "undefined" ? Object : IExecutionStrategy
+    ])
+], JobLauncher);
+
+//# sourceMappingURL=job-launcher.js.map

package/dist/src/execution/job-launcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/execution/job-launcher.ts"],"sourcesContent":["import { randomUUID } from 'crypto';\n\nimport { Inject, Injectable, Optional, forwardRef } from '@nestjs/common';\n\nimport { JobNotFoundError, JobExecutionAlreadyRunningError } from '../core/errors';\nimport { JobRepository, type JobParameters, type JobExecution } from '../core/repository';\nimport { JobRegistry } from '../registry/job-registry';\n\nimport {\n  EXECUTION_STRATEGY,\n  type IExecutionStrategy,\n} from './execution-strategy';\nimport { JobExecutor } from './job-executor';\nimport { canonicalJobKey } from './job-key';\n\nimport type { JobDefinition } from '../core/ir';\n\n\n\n/**\n * JobLauncher — public entry point for starting a new JobExecution.\n *\n * Flow (pre-strategy, kept unchanged for backwards compat):\n *   1. Look up the `JobDefinition` from the registry. Missing → `JobNotFoundError`.\n *   2. Canonicalize `params` into a stable `jobKey` hash. Object key order,\n *      `null/undefined` omission, `Date → ISO` are all normalized so that\n *      semantically-identical params yield the same key.\n *   3. `createExecutionAtomic(jobId, jobKey, params)` — idempotent\n *      instance get-or-create + `SELECT ... FOR UPDATE SKIP LOCKED` to\n *      serialize concurrent launches + running-execution check + insert,\n *      all in a single transaction. Throws\n *      `JobExecutionAlreadyRunningError` if another launch is in flight\n *      or an execution is already STARTING/STARTED for the same instance.\n *   4. Delegate to the injected `IExecutionStrategy` (default:\n *      `InProcessExecutionStrategy`, which wraps `JobExecutor.execute`).\n *      The lock is released when the createExecutionAtomic transaction\n *      commits; the executor itself runs outside the lock (it can be\n *      long-running).\n *\n * `allowDuplicateInstances: true` bypasses step 2's dedup by appending a\n * fresh UUID nonce to the canonical key on every call, forcing a new\n * `JobInstance` each time.\n *\n * Polymorphic strategy (Task 11):\n *   The launcher is a thin facade — it owns the registry lookup, the\n *   canonical `jobKey` derivation, the atomic instance + concurrency\n *   lock, and the post-strategy `JobExecution` re-resolution. The\n *   actual *how* of running the job (in-process vs. transport) lives\n *   behind the `EXECUTION_STRATEGY` token. Sibling packages (e.g.\n *   `@nest-batch/bullmq`) override the token with a transport\n *   strategy that enqueues work; the launcher never learns about the\n *   transport.\n *\n *   When no strategy is bound (e.g. direct manual construction in\n *   unit tests), the launcher falls back to the original direct\n *   `JobExecutor.execute` path. This keeps the legacy\n *   `tests/execution/job-launcher.test.ts` working without changes.\n */\n@Injectable()\nexport class JobLauncher {\n  constructor(\n    private readonly registry: JobRegistry,\n    private readonly repository: JobRepository,\n    @Inject(forwardRef(() => JobExecutor))\n    private readonly jobExecutor: JobExecutor,\n    @Optional()\n    @Inject(EXECUTION_STRATEGY)\n    private readonly strategy?: IExecutionStrategy,\n  ) {}\n\n  /**\n   * Launch a new job execution. Returns the final `JobExecution` after it\n   * has finished (status = COMPLETED | FAILED) — or, for transport\n   * strategies that return `{ kind: 'enqueued' }`, the latest persisted\n   * `JobExecution` (still in `STARTING` / `STARTED`, since the executor\n   * has not run on the launcher process).\n   *\n   * Throws `JobNotFoundError` if `jobId` is not registered.\n   * Throws `JobExecutionAlreadyRunningError` if a previous launch of the\n   * same `jobName + jobKey` is still in flight.\n   */\n  async launch(jobId: string, params: JobParameters = {}): Promise<JobExecution> {\n    const jobDef = this.registry.get(jobId); // throws JobNotFoundError on miss\n    const canonical = canonicalJobKey(params);\n    const jobKey = jobDef.allowDuplicateInstances ? `${canonical}::${randomUUID()}` : canonical;\n\n    // Atomic get-or-create + lock + check + insert. The repository's\n    // implementation uses INSERT ... ON CONFLICT DO NOTHING +\n    // FOR UPDATE SKIP LOCKED to serialize concurrent launches.\n    const execution = await this.repository.createExecutionAtomic(jobId, jobKey, params);\n\n    // No strategy bound → fall back to the legacy direct-execute path.\n    // This branch preserves `tests/execution/job-launcher.test.ts` (which\n    // wires the launcher by hand, no Nest module) and any other\n    // direct-construction consumer.\n    if (this.strategy === undefined) {\n      return this.jobExecutor.execute(execution, jobDef);\n    }\n\n    // The strategy's `LaunchResult` is intentionally discarded: the\n    // public `JobLauncher.launch` contract always returns a\n    // `JobExecution` (re-resolved from the repository below), and\n    // `queueJobId` is for the strategy's own bookkeeping only.\n    await this.strategy.launch(jobDef, params, {\n      executionId: execution.id,\n      jobExecutionId: execution.id,\n    });\n\n    // For both `completed` and `enqueued` the public `JobLauncher.launch`\n    // contract returns a `JobExecution`. Re-resolve the latest persisted\n    // row so the caller sees the executor's writes (status, endTime,\n    // exitCode) without us hand-merging patches here. If the lookup\n    // somehow returns null (e.g. a custom repository that drops rows),\n    // fall back to the execution the launcher pre-created.\n    const latest = await this.repository.getJobExecution(execution.id);\n    return latest ?? execution;\n  }\n\n  /**\n   * Resume an existing `JobExecution` (used by the restart path).\n   * For this MVP it just delegates to the executor — the launcher does\n   * not yet gate on restartable / concurrency / FAILED-prev-exists rules.\n   *\n   * Note: `run` bypasses the strategy on purpose. Restart is a\n   * recovery path on the in-process execution model; transport\n   * strategies that need their own resume semantics can override\n   * this method on a subclass or via a future token.\n   */\n  async run(execution: JobExecution, jobDef: JobDefinition): Promise<JobExecution> {\n    return this.jobExecutor.execute(execution, jobDef);\n  }\n}\n"],"names":["JobLauncher","registry","repository","jobExecutor","strategy","launch","jobId","params","jobDef","get","canonical","canonicalJobKey","jobKey","allowDuplicateInstances","randomUUID","execution","createExecutionAtomic","undefined","execute","executionId","id","jobExecutionId","latest","getJobExecution","run","JobExecutor"],"mappings":";;;;+BA2DaA;;;eAAAA;;;wBA3Dc;wBAE8B;4BAGY;6BACzC;mCAKrB;6BACqB;wBACI;;;;;;;;;;;;;;;AA8CzB,IAAA,AAAMA,cAAN,MAAMA;;;;;IACX,YACE,AAAiBC,QAAqB,EACtC,AAAiBC,UAAyB,EAC1C,AACiBC,WAAwB,EACzC,AAEiBC,QAA6B,CAC9C;aAPiBH,WAAAA;aACAC,aAAAA;aAEAC,cAAAA;aAGAC,WAAAA;IAChB;IAEH;;;;;;;;;;GAUC,GACD,MAAMC,OAAOC,KAAa,EAAEC,SAAwB,CAAC,CAAC,EAAyB;QAC7E,MAAMC,SAAS,IAAI,CAACP,QAAQ,CAACQ,GAAG,CAACH,QAAQ,kCAAkC;QAC3E,MAAMI,YAAYC,IAAAA,uBAAe,EAACJ;QAClC,MAAMK,SAASJ,OAAOK,uBAAuB,GAAG,GAAGH,UAAU,EAAE,EAAEI,IAAAA,kBAAU,KAAI,GAAGJ;QAElF,iEAAiE;QACjE,0DAA0D;QAC1D,2DAA2D;QAC3D,MAAMK,YAAY,MAAM,IAAI,CAACb,UAAU,CAACc,qBAAqB,CAACV,OAAOM,QAAQL;QAE7E,mEAAmE;QACnE,sEAAsE;QACtE,4DAA4D;QAC5D,gCAAgC;QAChC,IAAI,IAAI,CAACH,QAAQ,KAAKa,WAAW;YAC/B,OAAO,IAAI,CAACd,WAAW,CAACe,OAAO,CAACH,WAAWP;QAC7C;QAEA,gEAAgE;QAChE,wDAAwD;QACxD,8DAA8D;QAC9D,2DAA2D;QAC3D,MAAM,IAAI,CAACJ,QAAQ,CAACC,MAAM,CAACG,QAAQD,QAAQ;YACzCY,aAAaJ,UAAUK,EAAE;YACzBC,gBAAgBN,UAAUK,EAAE;QAC9B;QAEA,sEAAsE;QACtE,qEAAqE;QACrE,iEAAiE;QACjE,gEAAgE;QAChE,mEAAmE;QACnE,uDAAuD;QACvD,MAAME,SAAS,MAAM,IAAI,CAACpB,UAAU,CAACqB,eAAe,CAACR,UAAUK,EAAE;QACjE,OAAOE,UAAUP;IACnB;IAEA;;;;;;;;;GASC,GACD,MAAMS,IAAIT,SAAuB,EAAEP,MAAqB,EAAyB;QAC/E,OAAO,IAAI,CAACL,WAAW,CAACe,OAAO,CAACH,WAAWP;IAC7C;AACF;;;iEApE6BiB,wBAAW"}

package/dist/src/execution/job-operator.d.ts

@@ -0,0 +1,22 @@
+import { JobExecution, JobExecutionDetails, JobExecutionFilter, JobInstance, JobInstanceFilter, JobParameters, JobRepository } from '../core/repository';
+import type { JobDefinition } from '../core/ir';
+import { JobRegistry } from '../registry/job-registry';
+import { JobExplorer } from './job-explorer';
+import { JobLauncher } from './job-launcher';
+export declare class JobOperator {
+    private readonly explorer;
+    private readonly registry;
+    private readonly repository;
+    private readonly launcher;
+    constructor(explorer: JobExplorer, registry: JobRegistry, repository: JobRepository, launcher: JobLauncher);
+    listJobs(): JobDefinition[];
+    listJobInstances(filter?: JobInstanceFilter): Promise<JobInstance[]>;
+    listJobExecutions(filter?: JobExecutionFilter): Promise<JobExecution[]>;
+    getJobExecutionDetails(executionId: string): Promise<JobExecutionDetails>;
+    stop(executionId: string): Promise<JobExecutionDetails>;
+    abandon(executionId: string): Promise<JobExecutionDetails>;
+    restart(executionId: string): Promise<JobExecutionDetails>;
+    startNextInstance(jobId: string, params?: JobParameters): Promise<JobExecution>;
+    private isActive;
+}
+//# sourceMappingURL=job-operator.d.ts.map

package/dist/src/execution/job-operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-operator.d.ts","sourceRoot":"","sources":["../../../src/execution/job-operator.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,aAAa,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,qBACa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAHR,QAAQ,EAAE,WAAW,EACrB,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,WAAW;IAGxC,QAAQ,IAAI,aAAa,EAAE;IAI3B,gBAAgB,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAIxE,iBAAiB,CAAC,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAI3E,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAInE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAwBvD,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyB1D,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAiBhE,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,aAAkB,GAAG,OAAO,CAAC,YAAY,CAAC;IAOnF,OAAO,CAAC,QAAQ;CAOjB"}

package/dist/src/execution/job-operator.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "JobOperator", {
+    enumerable: true,
+    get: function() {
+        return JobOperator;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const _common = require("@nestjs/common");
+const _errors = require("../core/errors");
+const _repository = require("../core/repository");
+const _status = require("../core/status");
+const _jobregistry = require("../registry/job-registry");
+const _jobexplorer = require("./job-explorer");
+const _joblauncher = require("./job-launcher");
+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 JobOperator = class JobOperator {
+    explorer;
+    registry;
+    repository;
+    launcher;
+    constructor(explorer, registry, repository, launcher){
+        this.explorer = explorer;
+        this.registry = registry;
+        this.repository = repository;
+        this.launcher = launcher;
+    }
+    listJobs() {
+        return this.explorer.listJobs();
+    }
+    listJobInstances(filter = {}) {
+        return this.explorer.listJobInstances(filter);
+    }
+    listJobExecutions(filter = {}) {
+        return this.explorer.listJobExecutions(filter);
+    }
+    getJobExecutionDetails(executionId) {
+        return this.explorer.getJobExecutionDetails(executionId);
+    }
+    async stop(executionId) {
+        const details = await this.explorer.getJobExecutionDetails(executionId);
+        const status = details.jobExecution.status;
+        if (status === _status.JobStatus.STOPPED) {
+            return details;
+        }
+        if (!this.isActive(status)) {
+            throw new _errors.InvalidJobOperationError('stop', `Cannot stop execution in ${status} state`, {
+                executionId,
+                status
+            });
+        }
+        await this.repository.updateJobExecution(executionId, {
+            status: _status.JobStatus.STOPPED,
+            endTime: new Date(),
+            exitCode: 'STOPPED',
+            exitMessage: 'Stopped by JobOperator'
+        });
+        return this.explorer.getJobExecutionDetails(executionId);
+    }
+    async abandon(executionId) {
+        const details = await this.explorer.getJobExecutionDetails(executionId);
+        const status = details.jobExecution.status;
+        if (status === _status.JobStatus.ABANDONED) {
+            return details;
+        }
+        if (this.isActive(status) || status === _status.JobStatus.COMPLETED) {
+            throw new _errors.InvalidJobOperationError('abandon', `Cannot abandon execution in ${status} state`, {
+                executionId,
+                status
+            });
+        }
+        await this.repository.updateJobExecution(executionId, {
+            status: _status.JobStatus.ABANDONED,
+            endTime: details.jobExecution.endTime ?? new Date(),
+            exitCode: 'ABANDONED',
+            exitMessage: 'Abandoned by JobOperator'
+        });
+        return this.explorer.getJobExecutionDetails(executionId);
+    }
+    async restart(executionId) {
+        const details = await this.explorer.getJobExecutionDetails(executionId);
+        const status = details.jobExecution.status;
+        if (status !== _status.JobStatus.FAILED && status !== _status.JobStatus.STOPPED) {
+            throw new _errors.InvalidJobOperationError('restart', `Cannot restart execution in ${status} state`, {
+                executionId,
+                status
+            });
+        }
+        const jobDef = this.registry.get(details.jobInstance.jobName);
+        const execution = await this.launcher.run(details.jobExecution, jobDef);
+        return this.explorer.getJobExecutionDetails(execution.id);
+    }
+    startNextInstance(jobId, params = {}) {
+        return this.launcher.launch(jobId, {
+            ...params,
+            _nestBatchRunId: (0, _nodecrypto.randomUUID)()
+        });
+    }
+    isActive(status) {
+        return status === _status.JobStatus.STARTING || status === _status.JobStatus.STARTED || status === _status.JobStatus.STOPPING;
+    }
+};
+JobOperator = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _jobexplorer.JobExplorer === "undefined" ? Object : _jobexplorer.JobExplorer,
+        typeof _jobregistry.JobRegistry === "undefined" ? Object : _jobregistry.JobRegistry,
+        typeof _repository.JobRepository === "undefined" ? Object : _repository.JobRepository,
+        typeof _joblauncher.JobLauncher === "undefined" ? Object : _joblauncher.JobLauncher
+    ])
+], JobOperator);
+
+//# sourceMappingURL=job-operator.js.map