@nest-batch/core 0.2.0

package/dist/src/builder/step-builder.d.ts

@@ -0,0 +1,74 @@
+import type { StepDefinition, ReaderRef, ProcessorRef, WriterRef, TaskletRef, ListenerRef, SkipPolicyConfig, RetryPolicyConfig, ListenerKind, ListenerPhase } from '../core/ir';
+/**
+ * Fluent builder for a single step (`chunk` or `tasklet`).
+ *
+ * Typical usage via `JobBuilder.addStep` callback:
+ *
+ *   .addStep((b) => b
+ *     .chunk('read-csv', 100, {
+ *       reader: { kind: BuilderLambda, fn: readCsv },
+ *       processor: { kind: BuilderLambda, fn: transform },
+ *       writer: { kind: BuilderLambda, fn: writeRows },
+ *     }))
+ *
+ *   .addStep((b) => b
+ *     .tasklet('cleanup', { kind: BuilderLambda, fn: cleanup }))
+ *
+ * The builder is single-use: call `.build()` once to produce the
+ * `StepDefinition` IR.
+ */
+export declare class StepBuilder {
+    private _chunkSize?;
+    private _reader?;
+    private _processor?;
+    private _writer?;
+    private _tasklet?;
+    private _id?;
+    private _skipPolicy?;
+    private _retryPolicy?;
+    private readonly itemListeners;
+    private readonly listenerDefs;
+    /**
+     * Start a chunk step. Sets the step id and chunk size; optionally
+     * accepts reader/processor/writer/policies in a single call.
+     *
+     *   .chunk('s1', 100, { reader, processor, writer })
+     *   .chunk('s2', 50,  { reader, writer, skipPolicy })
+     *
+     * Throws if `size` is not a positive integer.
+     */
+    chunk(id: string, size: number, config?: {
+        reader: ReaderRef;
+        processor?: ProcessorRef;
+        writer: WriterRef;
+        skipPolicy?: SkipPolicyConfig;
+        retryPolicy?: RetryPolicyConfig;
+    }): this;
+    /**
+     * Start a tasklet step. Sets the step id and the tasklet ref.
+     *
+     *   .tasklet('cleanup', { kind: BuilderLambda, fn: cleanup })
+     */
+    tasklet(id: string, ref: TaskletRef): this;
+    reader(ref: ReaderRef): this;
+    processor(ref: ProcessorRef): this;
+    writer(ref: WriterRef): this;
+    skipPolicy(p: SkipPolicyConfig): this;
+    retryPolicy(p: RetryPolicyConfig): this;
+    /**
+     * Attach an item-level listener ref to this step. Listener metadata
+     * is also recorded internally so it can be re-emitted via `.build()`.
+     *
+     * (The step IR's `listeners: ItemListenerRef[]` field is the source of
+     * truth at runtime; the `ListenerDefinition[]` aggregate lives on the
+     * job. We keep both in sync here for downstream consumer convenience.)
+     */
+    addListener(ref: ListenerRef, kind: ListenerKind, phase: ListenerPhase, nonCritical?: boolean): this;
+    /**
+     * Produce the `StepDefinition` IR. Throws if the step is missing an
+     * id, or is neither a configured tasklet nor a configured chunk
+     * (chunk requires both `reader` and `writer`).
+     */
+    build(): StepDefinition;
+}
+//# sourceMappingURL=step-builder.d.ts.map

package/dist/src/builder/step-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-builder.d.ts","sourceRoot":"","sources":["../../../src/builder/step-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAGd,SAAS,EACT,YAAY,EACZ,SAAS,EACT,UAAU,EACV,WAAW,EAEX,gBAAgB,EAChB,iBAAiB,EAEjB,YAAY,EACZ,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,WAAW;IAQtB,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAC,CAAY;IAC5B,OAAO,CAAC,UAAU,CAAC,CAAe;IAClC,OAAO,CAAC,OAAO,CAAC,CAAY;IAC5B,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,GAAG,CAAC,CAAS;IACrB,OAAO,CAAC,WAAW,CAAC,CAAmB;IACvC,OAAO,CAAC,YAAY,CAAC,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;IACvD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;IAIzD;;;;;;;;OAQG;IACH,KAAK,CACH,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE;QACP,MAAM,EAAE,SAAS,CAAC;QAClB,SAAS,CAAC,EAAE,YAAY,CAAC;QACzB,MAAM,EAAE,SAAS,CAAC;QAClB,UAAU,CAAC,EAAE,gBAAgB,CAAC;QAC9B,WAAW,CAAC,EAAE,iBAAiB,CAAC;KACjC,GACA,IAAI;IAgBP;;;;OAIG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,IAAI;IAQ1C,MAAM,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI;IAK5B,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAKlC,MAAM,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI;IAK5B,UAAU,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAKrC,WAAW,CAAC,CAAC,EAAE,iBAAiB,GAAG,IAAI;IAKvC;;;;;;;OAOG;IACH,WAAW,CACT,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,aAAa,EACpB,WAAW,CAAC,EAAE,OAAO,GACpB,IAAI;IAaP;;;;OAIG;IACH,KAAK,IAAI,cAAc;CA6BxB"}

package/dist/src/builder/step-builder.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "StepBuilder", {
+    enumerable: true,
+    get: function() {
+        return StepBuilder;
+    }
+});
+let StepBuilder = class StepBuilder {
+    // Field names use a `_` prefix to avoid colliding with the same-named
+    // setter methods (`reader` / `processor` / `writer` / `tasklet` /
+    // `skipPolicy` / `retryPolicy`). With `useDefineForClassFields: false`
+    // (project tsconfig), a class field shadows any prototype method of
+    // the same name — which would make the fluent setters unreachable and
+    // (more subtly) make `if (this.tasklet)` in `build()` accidentally
+    // find the method via the prototype chain.
+    _chunkSize;
+    _reader;
+    _processor;
+    _writer;
+    _tasklet;
+    _id;
+    _skipPolicy;
+    _retryPolicy;
+    itemListeners = [];
+    listenerDefs = [];
+    // --- step-kind entry points ------------------------------------------
+    /**
+   * Start a chunk step. Sets the step id and chunk size; optionally
+   * accepts reader/processor/writer/policies in a single call.
+   *
+   *   .chunk('s1', 100, { reader, processor, writer })
+   *   .chunk('s2', 50,  { reader, writer, skipPolicy })
+   *
+   * Throws if `size` is not a positive integer.
+   */ chunk(id, size, config) {
+        if (!Number.isInteger(size) || size <= 0) {
+            throw new Error('chunkSize must be a positive integer');
+        }
+        this._id = id;
+        this._chunkSize = size;
+        if (config) {
+            this._reader = config.reader;
+            this._processor = config.processor;
+            this._writer = config.writer;
+            this._skipPolicy = config.skipPolicy;
+            this._retryPolicy = config.retryPolicy;
+        }
+        return this;
+    }
+    /**
+   * Start a tasklet step. Sets the step id and the tasklet ref.
+   *
+   *   .tasklet('cleanup', { kind: BuilderLambda, fn: cleanup })
+   */ tasklet(id, ref) {
+        this._id = id;
+        this._tasklet = ref;
+        return this;
+    }
+    // --- fine-grained setters (used after `.chunk(id, size)`) -----------
+    reader(ref) {
+        this._reader = ref;
+        return this;
+    }
+    processor(ref) {
+        this._processor = ref;
+        return this;
+    }
+    writer(ref) {
+        this._writer = ref;
+        return this;
+    }
+    skipPolicy(p) {
+        this._skipPolicy = p;
+        return this;
+    }
+    retryPolicy(p) {
+        this._retryPolicy = p;
+        return this;
+    }
+    /**
+   * Attach an item-level listener ref to this step. Listener metadata
+   * is also recorded internally so it can be re-emitted via `.build()`.
+   *
+   * (The step IR's `listeners: ItemListenerRef[]` field is the source of
+   * truth at runtime; the `ListenerDefinition[]` aggregate lives on the
+   * job. We keep both in sync here for downstream consumer convenience.)
+   */ addListener(ref, kind, phase, nonCritical) {
+        this.itemListeners.push(ref);
+        this.listenerDefs.push({
+            ref,
+            kind,
+            phase,
+            ...nonCritical !== undefined ? {
+                nonCritical
+            } : {}
+        });
+        return this;
+    }
+    // --- build -----------------------------------------------------------
+    /**
+   * Produce the `StepDefinition` IR. Throws if the step is missing an
+   * id, or is neither a configured tasklet nor a configured chunk
+   * (chunk requires both `reader` and `writer`).
+   */ build() {
+        if (!this._id) {
+            throw new Error('Step must have an id (call .chunk() or .tasklet() first)');
+        }
+        if (this._tasklet) {
+            const def = {
+                kind: 'tasklet',
+                id: this._id,
+                tasklet: this._tasklet,
+                listeners: this.itemListeners
+            };
+            return def;
+        }
+        if (this._chunkSize !== undefined && this._reader && this._writer) {
+            const def = {
+                kind: 'chunk',
+                id: this._id,
+                chunkSize: this._chunkSize,
+                reader: this._reader,
+                writer: this._writer,
+                listeners: this.itemListeners,
+                ...this._processor ? {
+                    processor: this._processor
+                } : {},
+                ...this._skipPolicy ? {
+                    skipPolicy: this._skipPolicy
+                } : {},
+                ...this._retryPolicy ? {
+                    retryPolicy: this._retryPolicy
+                } : {}
+            };
+            return def;
+        }
+        throw new Error('Step must be either tasklet or chunk with reader+writer');
+    }
+};
+
+//# sourceMappingURL=step-builder.js.map

package/dist/src/builder/step-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/builder/step-builder.ts"],"sourcesContent":["import type {\n  StepDefinition,\n  ChunkStepDefinition,\n  TaskletStepDefinition,\n  ReaderRef,\n  ProcessorRef,\n  WriterRef,\n  TaskletRef,\n  ListenerRef,\n  ItemListenerRef,\n  SkipPolicyConfig,\n  RetryPolicyConfig,\n  ListenerDefinition,\n  ListenerKind,\n  ListenerPhase,\n} from '../core/ir';\n\n/**\n * Fluent builder for a single step (`chunk` or `tasklet`).\n *\n * Typical usage via `JobBuilder.addStep` callback:\n *\n *   .addStep((b) => b\n *     .chunk('read-csv', 100, {\n *       reader: { kind: BuilderLambda, fn: readCsv },\n *       processor: { kind: BuilderLambda, fn: transform },\n *       writer: { kind: BuilderLambda, fn: writeRows },\n *     }))\n *\n *   .addStep((b) => b\n *     .tasklet('cleanup', { kind: BuilderLambda, fn: cleanup }))\n *\n * The builder is single-use: call `.build()` once to produce the\n * `StepDefinition` IR.\n */\nexport class StepBuilder {\n  // Field names use a `_` prefix to avoid colliding with the same-named\n  // setter methods (`reader` / `processor` / `writer` / `tasklet` /\n  // `skipPolicy` / `retryPolicy`). With `useDefineForClassFields: false`\n  // (project tsconfig), a class field shadows any prototype method of\n  // the same name — which would make the fluent setters unreachable and\n  // (more subtly) make `if (this.tasklet)` in `build()` accidentally\n  // find the method via the prototype chain.\n  private _chunkSize?: number;\n  private _reader?: ReaderRef;\n  private _processor?: ProcessorRef;\n  private _writer?: WriterRef;\n  private _tasklet?: TaskletRef;\n  private _id?: string;\n  private _skipPolicy?: SkipPolicyConfig;\n  private _retryPolicy?: RetryPolicyConfig;\n  private readonly itemListeners: ItemListenerRef[] = [];\n  private readonly listenerDefs: ListenerDefinition[] = [];\n\n  // --- step-kind entry points ------------------------------------------\n\n  /**\n   * Start a chunk step. Sets the step id and chunk size; optionally\n   * accepts reader/processor/writer/policies in a single call.\n   *\n   *   .chunk('s1', 100, { reader, processor, writer })\n   *   .chunk('s2', 50,  { reader, writer, skipPolicy })\n   *\n   * Throws if `size` is not a positive integer.\n   */\n  chunk(\n    id: string,\n    size: number,\n    config?: {\n      reader: ReaderRef;\n      processor?: ProcessorRef;\n      writer: WriterRef;\n      skipPolicy?: SkipPolicyConfig;\n      retryPolicy?: RetryPolicyConfig;\n    },\n  ): this {\n    if (!Number.isInteger(size) || size <= 0) {\n      throw new Error('chunkSize must be a positive integer');\n    }\n    this._id = id;\n    this._chunkSize = size;\n    if (config) {\n      this._reader = config.reader;\n      this._processor = config.processor;\n      this._writer = config.writer;\n      this._skipPolicy = config.skipPolicy;\n      this._retryPolicy = config.retryPolicy;\n    }\n    return this;\n  }\n\n  /**\n   * Start a tasklet step. Sets the step id and the tasklet ref.\n   *\n   *   .tasklet('cleanup', { kind: BuilderLambda, fn: cleanup })\n   */\n  tasklet(id: string, ref: TaskletRef): this {\n    this._id = id;\n    this._tasklet = ref;\n    return this;\n  }\n\n  // --- fine-grained setters (used after `.chunk(id, size)`) -----------\n\n  reader(ref: ReaderRef): this {\n    this._reader = ref;\n    return this;\n  }\n\n  processor(ref: ProcessorRef): this {\n    this._processor = ref;\n    return this;\n  }\n\n  writer(ref: WriterRef): this {\n    this._writer = ref;\n    return this;\n  }\n\n  skipPolicy(p: SkipPolicyConfig): this {\n    this._skipPolicy = p;\n    return this;\n  }\n\n  retryPolicy(p: RetryPolicyConfig): this {\n    this._retryPolicy = p;\n    return this;\n  }\n\n  /**\n   * Attach an item-level listener ref to this step. Listener metadata\n   * is also recorded internally so it can be re-emitted via `.build()`.\n   *\n   * (The step IR's `listeners: ItemListenerRef[]` field is the source of\n   * truth at runtime; the `ListenerDefinition[]` aggregate lives on the\n   * job. We keep both in sync here for downstream consumer convenience.)\n   */\n  addListener(\n    ref: ListenerRef,\n    kind: ListenerKind,\n    phase: ListenerPhase,\n    nonCritical?: boolean,\n  ): this {\n    this.itemListeners.push(ref);\n    this.listenerDefs.push({\n      ref,\n      kind,\n      phase,\n      ...(nonCritical !== undefined ? { nonCritical } : {}),\n    });\n    return this;\n  }\n\n  // --- build -----------------------------------------------------------\n\n  /**\n   * Produce the `StepDefinition` IR. Throws if the step is missing an\n   * id, or is neither a configured tasklet nor a configured chunk\n   * (chunk requires both `reader` and `writer`).\n   */\n  build(): StepDefinition {\n    if (!this._id) {\n      throw new Error('Step must have an id (call .chunk() or .tasklet() first)');\n    }\n    if (this._tasklet) {\n      const def: TaskletStepDefinition = {\n        kind: 'tasklet',\n        id: this._id,\n        tasklet: this._tasklet,\n        listeners: this.itemListeners,\n      };\n      return def;\n    }\n    if (this._chunkSize !== undefined && this._reader && this._writer) {\n      const def: ChunkStepDefinition = {\n        kind: 'chunk',\n        id: this._id,\n        chunkSize: this._chunkSize,\n        reader: this._reader,\n        writer: this._writer,\n        listeners: this.itemListeners,\n        ...(this._processor ? { processor: this._processor } : {}),\n        ...(this._skipPolicy ? { skipPolicy: this._skipPolicy } : {}),\n        ...(this._retryPolicy ? { retryPolicy: this._retryPolicy } : {}),\n      };\n      return def;\n    }\n    throw new Error('Step must be either tasklet or chunk with reader+writer');\n  }\n}\n"],"names":["StepBuilder","_chunkSize","_reader","_processor","_writer","_tasklet","_id","_skipPolicy","_retryPolicy","itemListeners","listenerDefs","chunk","id","size","config","Number","isInteger","Error","reader","processor","writer","skipPolicy","retryPolicy","tasklet","ref","p","addListener","kind","phase","nonCritical","push","undefined","build","def","listeners","chunkSize"],"mappings":"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"}

package/dist/src/compiler/builder-types.d.ts

@@ -0,0 +1,20 @@
+import type { StepDefinition, ListenerDefinition, TransitionDefinition, DeciderDefinition } from '../core/ir';
+/**
+ * Configuration shape for the Builder API. The builder returns this from `build()`.
+ * `DefinitionCompiler.compileFromBuilderConfig` consumes it and produces a
+ * fully-validated `JobDefinition` IR.
+ *
+ * This is a *plain-data* shape — no methods, no Nest DI references — so a builder
+ * can be assembled in unit tests without booting a Nest container.
+ */
+export interface JobBuilderConfig {
+    id: string;
+    restartable: boolean;
+    allowDuplicateInstances: boolean;
+    steps: StepDefinition[];
+    startStepId: string;
+    transitions: TransitionDefinition[];
+    deciders?: DeciderDefinition[];
+    listeners: ListenerDefinition[];
+}
+//# sourceMappingURL=builder-types.d.ts.map

package/dist/src/compiler/builder-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-types.d.ts","sourceRoot":"","sources":["../../../src/compiler/builder-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAGpB;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,OAAO,CAAC;IACrB,uBAAuB,EAAE,OAAO,CAAC;IACjC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,QAAQ,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC/B,SAAS,EAAE,kBAAkB,EAAE,CAAC;CACjC"}

package/dist/src/compiler/builder-types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=builder-types.js.map

package/dist/src/compiler/builder-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/compiler/builder-types.ts"],"names":[],"mappings":""}

package/dist/src/compiler/definition-compiler.d.ts

@@ -0,0 +1,99 @@
+import 'reflect-metadata';
+import { type JobDefinition } from '../core/ir';
+import { BatchError } from '../core/errors';
+import type { DiscoveredJob } from '../explorer/batch-explorer';
+import type { JobBuilderConfig } from './builder-types';
+/**
+ * Thrown when a chunk step on a discovered class cannot resolve a required
+ * item handler method (`@ItemReader` or `@ItemWriter`) on the class prototype.
+ *
+ * Distinct from `InvalidFlowGraphError` because this is a *static* class-shape
+ * problem (the class is missing a decorator), not a flow-graph problem
+ * (transitions, start, reachability). The `code` is stable for callers
+ * that want to switch on it.
+ */
+export declare class ProviderNotFoundError extends BatchError {
+    readonly code = "PROVIDER_NOT_FOUND";
+    constructor(token: string);
+}
+/**
+ * `DefinitionCompiler` is the bridge between metadata-rich sources
+ * (decorator-discovered classes, fluent builder configs) and the
+ * `JobDefinition` IR consumed by the rest of the runtime.
+ *
+ * Two compilation paths share the same output type:
+ *
+ *   - `compileFromDiscovered(discovered)` walks the class prototype
+ *     (resolved by `BatchExplorer` in Task 7) and binds reader /
+ *     processor / writer / tasklet / listener methods into `Ref`s.
+ *   - `compileFromBuilderConfig(config)` accepts a plain-data config
+ *     from the builder API and copies it into a `JobDefinition`.
+ *
+ * Both paths run the same `DefinitionValidator` before returning, so
+ * downstream consumers can assume the IR is structurally sound.
+ *
+ * The compiler does NOT register the job — that is `JobRegistry`'s job
+ * (Task 9). The compiler is pure: it produces IR, nothing else.
+ */
+export declare class DefinitionCompiler {
+    private readonly logger;
+    private readonly validator;
+    /**
+     * Compile from a discovered class. Resolves reader/processor/writer methods
+     * on the class prototype and assembles StepDefinitions. Validates before returning.
+     */
+    compileFromDiscovered(discovered: DiscoveredJob): JobDefinition;
+    /**
+     * Compile from a builder config. Used by the fluent Builder API.
+     * Same validation as `compileFromDiscovered`.
+     */
+    compileFromBuilderConfig(config: JobBuilderConfig): JobDefinition;
+    /**
+     * Resolve a listener method on a discovered class to a callable
+     * `ListenerRef`. Mirrors the tasklet-ref resolution in
+     * `buildTaskletStep`: if the DI container has already instantiated
+     * the class (which is the case by the time the explorer walks
+     * providers at `onModuleInit`), the method is pre-bound to the
+     * instance and the returned ref is a `BuilderLambda` carrying the
+     * bound function. This lets the runtime resolver map call the
+     * listener directly without holding onto the instance or a
+     * `ModuleRef`.
+     *
+     * When the instance is not yet available (factory providers that
+     * have not been instantiated, late-bound providers, etc.) the ref
+     * stays as a `Method` and the runtime resolver will throw a
+     * deterministic error if it cannot resolve the class. The
+     * pre-binding is a pure optimisation for the common
+     * `providers: [MyClass]` case — the test suite exercises that path.
+     */
+    private buildListenerRef;
+    /**
+     * Build a `TaskletStepDefinition` for a `@Stepable` + `@Tasklet` method.
+     *
+     * If a DI-resolved instance is available on the `DiscoveredJob`, the
+     * tasklet ref is a `BuilderLambda` (bound function) so the executor
+     * can call it directly. Otherwise we fall back to a `Method` ref that
+     * the executor resolves at runtime against the DI container.
+     */
+    private buildTaskletStep;
+    /**
+     * Build a `ChunkStepDefinition` for a `@Stepable` (no `@Tasklet`) method.
+     * Requires `@ItemReader` and `@ItemWriter` on the class; `@ItemProcessor`
+     * is optional.
+     *
+     * Throws `ProviderNotFoundError` if a required handler is missing.
+     */
+    private buildChunkStep;
+    private buildItemMethodRef;
+    /**
+     * Walks the prototype chain (including inherited prototypes, stopping
+     * at `Object.prototype`) looking for a method carrying the given
+     * `BATCH_ITEM_*` metadata key.
+     *
+     * Returns the method name or `undefined`. The explorer only records
+     * `@Stepable` / listener / transition methods; item handlers are
+     * resolved here at compile time.
+     */
+    private findItemMethod;
+}
+//# sourceMappingURL=definition-compiler.d.ts.map

package/dist/src/compiler/definition-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-compiler.d.ts","sourceRoot":"","sources":["../../../src/compiler/definition-compiler.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAEL,KAAK,aAAa,EAWnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAyB,MAAM,gBAAgB,CAAC;AAGnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAMhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACnD,QAAQ,CAAC,IAAI,wBAAwB;gBACzB,KAAK,EAAE,MAAM;CAG1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD;;;OAGG;IACH,qBAAqB,CAAC,UAAU,EAAE,aAAa,GAAG,aAAa;IAiD/D;;;OAGG;IACH,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa;IAqBjE;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IA+DtB,OAAO,CAAC,kBAAkB;IAsB1B;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;CAavB"}

package/dist/src/compiler/definition-compiler.js

@@ -0,0 +1,257 @@
+"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 DefinitionCompiler () {
+        return DefinitionCompiler;
+    },
+    get ProviderNotFoundError () {
+        return ProviderNotFoundError;
+    }
+});
+require("reflect-metadata");
+const _common = require("@nestjs/common");
+const _ir = require("../core/ir");
+const _status = require("../core/status");
+const _errors = require("../core/errors");
+const _definitionvalidator = require("../core/validation/definition-validator");
+const _partitionhelpers = require("../partition-helpers");
+const _constants = require("../decorators/constants");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let ProviderNotFoundError = class ProviderNotFoundError extends _errors.BatchError {
+    code = 'PROVIDER_NOT_FOUND';
+    constructor(token){
+        super(`Provider not found: ${token}`, {
+            token
+        });
+    }
+};
+let DefinitionCompiler = class DefinitionCompiler {
+    logger = new _common.Logger(DefinitionCompiler.name);
+    validator = new _definitionvalidator.DefinitionValidator();
+    /**
+   * Compile from a discovered class. Resolves reader/processor/writer methods
+   * on the class prototype and assembles StepDefinitions. Validates before returning.
+   */ compileFromDiscovered(discovered) {
+        const steps = {};
+        const startStepId = discovered.stepMethods[0]?.options.id ?? '';
+        const classToken = discovered.classRef.name;
+        for (const step of discovered.stepMethods){
+            if (step.isTasklet) {
+                steps[step.options.id] = this.buildTaskletStep(discovered, classToken, step);
+            } else {
+                steps[step.options.id] = this.buildChunkStep(discovered, classToken, step);
+            }
+        }
+        const listenerDefs = discovered.listenerMethods.map((l)=>({
+                kind: l.kind,
+                phase: l.phase,
+                nonCritical: l.nonCritical,
+                ref: this.buildListenerRef(discovered, classToken, l.methodName)
+            }));
+        const transitions = discovered.transitionMethods.map((t)=>({
+                fromStepId: t.fromStep,
+                onStatus: _status.FlowExecutionStatus[t.onStatus] ?? _status.FlowExecutionStatus.UNKNOWN,
+                toStepId: t.toStep
+            }));
+        const job = {
+            id: discovered.jobOptions.id,
+            steps,
+            startStepId,
+            transitions,
+            deciders: [],
+            listeners: listenerDefs,
+            restartable: discovered.jobOptions.restartable ?? false,
+            allowDuplicateInstances: discovered.jobOptions.allowDuplicateInstances ?? false
+        };
+        this.logger.log(`Compiled job "${job.id}" from "${classToken}": ${Object.keys(steps).length} step(s), ${listenerDefs.length} listener(s), ${transitions.length} transition(s)`);
+        this.validator.validate(job);
+        return job;
+    }
+    /**
+   * Compile from a builder config. Used by the fluent Builder API.
+   * Same validation as `compileFromDiscovered`.
+   */ compileFromBuilderConfig(config) {
+        const steps = {};
+        for (const s of config.steps){
+            steps[s.id] = s;
+        }
+        const job = {
+            id: config.id,
+            steps,
+            startStepId: config.startStepId,
+            transitions: config.transitions,
+            deciders: config.deciders ?? [],
+            listeners: config.listeners,
+            restartable: config.restartable,
+            allowDuplicateInstances: config.allowDuplicateInstances
+        };
+        this.validator.validate(job);
+        return job;
+    }
+    // --- private helpers --------------------------------------------------
+    /**
+   * Resolve a listener method on a discovered class to a callable
+   * `ListenerRef`. Mirrors the tasklet-ref resolution in
+   * `buildTaskletStep`: if the DI container has already instantiated
+   * the class (which is the case by the time the explorer walks
+   * providers at `onModuleInit`), the method is pre-bound to the
+   * instance and the returned ref is a `BuilderLambda` carrying the
+   * bound function. This lets the runtime resolver map call the
+   * listener directly without holding onto the instance or a
+   * `ModuleRef`.
+   *
+   * When the instance is not yet available (factory providers that
+   * have not been instantiated, late-bound providers, etc.) the ref
+   * stays as a `Method` and the runtime resolver will throw a
+   * deterministic error if it cannot resolve the class. The
+   * pre-binding is a pure optimisation for the common
+   * `providers: [MyClass]` case — the test suite exercises that path.
+   */ buildListenerRef(discovered, classToken, methodName) {
+        const instance = discovered.instance;
+        const method = instance?.[methodName];
+        if (method) {
+            return {
+                kind: _ir.RefKind.BuilderLambda,
+                fn: method.bind(discovered.instance)
+            };
+        }
+        return {
+            kind: _ir.RefKind.Method,
+            classToken,
+            methodName
+        };
+    }
+    /**
+   * Build a `TaskletStepDefinition` for a `@Stepable` + `@Tasklet` method.
+   *
+   * If a DI-resolved instance is available on the `DiscoveredJob`, the
+   * tasklet ref is a `BuilderLambda` (bound function) so the executor
+   * can call it directly. Otherwise we fall back to a `Method` ref that
+   * the executor resolves at runtime against the DI container.
+   */ buildTaskletStep(discovered, classToken, step) {
+        const instance = discovered.instance;
+        const method = instance?.[step.methodName];
+        const taskletRef = method ? {
+            kind: _ir.RefKind.BuilderLambda,
+            fn: ()=>method.bind(discovered.instance)
+        } : {
+            kind: _ir.RefKind.Method,
+            classToken,
+            methodName: step.methodName
+        };
+        return {
+            kind: 'tasklet',
+            id: step.options.id,
+            tasklet: taskletRef,
+            listeners: []
+        };
+    }
+    /**
+   * Build a `ChunkStepDefinition` for a `@Stepable` (no `@Tasklet`) method.
+   * Requires `@ItemReader` and `@ItemWriter` on the class; `@ItemProcessor`
+   * is optional.
+   *
+   * Throws `ProviderNotFoundError` if a required handler is missing.
+   */ buildChunkStep(discovered, classToken, step) {
+        const reader = this.findItemMethod(discovered, _constants.BATCH_ITEM_READER_METADATA);
+        const processor = this.findItemMethod(discovered, _constants.BATCH_ITEM_PROCESSOR_METADATA);
+        const writer = this.findItemMethod(discovered, _constants.BATCH_ITEM_WRITER_METADATA);
+        if (!reader) {
+            throw new ProviderNotFoundError(`@ItemReader for job ${discovered.jobOptions.id} (step ${step.options.id})`);
+        }
+        if (!writer) {
+            throw new ProviderNotFoundError(`@ItemWriter for job ${discovered.jobOptions.id} (step ${step.options.id})`);
+        }
+        const readerRef = this.buildItemMethodRef(discovered, classToken, reader);
+        const writerRef = this.buildItemMethodRef(discovered, classToken, writer);
+        // Validate the partition config at compile time so a typo
+        // (e.g. `count: 0`) fails at module load rather than at
+        // runtime when the launcher pre-creates the execution.
+        // `DefinitionValidator.validate` does the same check later
+        // (the IR is the source of truth), but the compiler is the
+        // first place we have the value in hand and we want the
+        // earliest possible failure for a decorator-discovered job.
+        try {
+            (0, _partitionhelpers.validatePartitions)(step.options.partitions);
+        } catch (err) {
+            if (err instanceof _partitionhelpers.InvalidPartitionsError) {
+                throw new _errors.InvalidFlowGraphError('INVALID_PARTITIONS', `Step "${step.options.id}" has invalid partitions: ${err.message}`, {
+                    jobId: discovered.jobOptions.id,
+                    stepId: step.options.id,
+                    partitions: step.options.partitions
+                });
+            }
+            throw err;
+        }
+        return {
+            kind: 'chunk',
+            id: step.options.id,
+            chunkSize: step.options.chunkSize ?? 100,
+            reader: readerRef,
+            writer: writerRef,
+            skipPolicy: step.options.skipPolicy,
+            retryPolicy: step.options.retryPolicy,
+            listeners: [],
+            ...step.options.partitions !== undefined ? {
+                partitions: step.options.partitions
+            } : {},
+            ...processor ? {
+                processor: this.buildItemMethodRef(discovered, classToken, processor)
+            } : {}
+        };
+    }
+    buildItemMethodRef(discovered, classToken, methodName) {
+        const instance = discovered.instance;
+        const method = instance?.[methodName];
+        if (method) {
+            return {
+                kind: _ir.RefKind.BuilderLambda,
+                fn: ()=>method.bind(discovered.instance)
+            };
+        }
+        return {
+            kind: _ir.RefKind.Method,
+            classToken,
+            methodName
+        };
+    }
+    /**
+   * Walks the prototype chain (including inherited prototypes, stopping
+   * at `Object.prototype`) looking for a method carrying the given
+   * `BATCH_ITEM_*` metadata key.
+   *
+   * Returns the method name or `undefined`. The explorer only records
+   * `@Stepable` / listener / transition methods; item handlers are
+   * resolved here at compile time.
+   */ findItemMethod(discovered, metadataKey) {
+        const proto = discovered.classRef.prototype;
+        if (!proto) return undefined;
+        let p = proto;
+        while(p && p !== Object.prototype){
+            for (const name of Object.getOwnPropertyNames(p)){
+                if (name === 'constructor') continue;
+                if (Reflect.getMetadata(metadataKey, p, name) === true) return name;
+            }
+            p = Object.getPrototypeOf(p);
+        }
+        return undefined;
+    }
+};
+DefinitionCompiler = _ts_decorate([
+    (0, _common.Injectable)()
+], DefinitionCompiler);
+
+//# sourceMappingURL=definition-compiler.js.map