@nest-batch/core 0.2.0

package/src/compiler/definition-compiler.ts

@@ -0,0 +1,325 @@
+import 'reflect-metadata';
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  RefKind,
+  type JobDefinition,
+  type StepDefinition,
+  type ChunkStepDefinition,
+  type TaskletStepDefinition,
+  type ReaderRef,
+  type ProcessorRef,
+  type WriterRef,
+  type TaskletRef,
+  type ListenerRef,
+  type ListenerDefinition,
+  type TransitionDefinition,
+} from '../core/ir';
+import { FlowExecutionStatus } from '../core/status';
+import { BatchError, InvalidFlowGraphError } from '../core/errors';
+import { DefinitionValidator } from '../core/validation/definition-validator';
+import { validatePartitions, InvalidPartitionsError } from '../partition-helpers';
+import type { DiscoveredJob } from '../explorer/batch-explorer';
+import {
+  BATCH_ITEM_READER_METADATA,
+  BATCH_ITEM_PROCESSOR_METADATA,
+  BATCH_ITEM_WRITER_METADATA,
+} from '../decorators/constants';
+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 class ProviderNotFoundError extends BatchError {
+  readonly code = 'PROVIDER_NOT_FOUND';
+  constructor(token: string) {
+    super(`Provider not found: ${token}`, { token });
+  }
+}
+
+/**
+ * `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.
+ */
+@Injectable()
+export class DefinitionCompiler {
+  private readonly logger = new Logger(DefinitionCompiler.name);
+  private readonly validator = new DefinitionValidator();
+
+  /**
+   * Compile from a discovered class. Resolves reader/processor/writer methods
+   * on the class prototype and assembles StepDefinitions. Validates before returning.
+   */
+  compileFromDiscovered(discovered: DiscoveredJob): JobDefinition {
+    const steps: Record<string, StepDefinition> = {};
+    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: ListenerDefinition[] = discovered.listenerMethods.map((l) => ({
+      kind: l.kind,
+      phase: l.phase,
+      nonCritical: l.nonCritical,
+      ref: this.buildListenerRef(discovered, classToken, l.methodName),
+    }));
+
+    const transitions: TransitionDefinition[] = discovered.transitionMethods.map((t) => ({
+      fromStepId: t.fromStep,
+      onStatus:
+        (FlowExecutionStatus as Record<string, FlowExecutionStatus>)[t.onStatus] ??
+        FlowExecutionStatus.UNKNOWN,
+      toStepId: t.toStep,
+    }));
+
+    const job: JobDefinition = {
+      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: JobBuilderConfig): JobDefinition {
+    const steps: Record<string, StepDefinition> = {};
+    for (const s of config.steps) {
+      steps[s.id] = s;
+    }
+    const job: JobDefinition = {
+      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.
+   */
+  private buildListenerRef(
+    discovered: DiscoveredJob,
+    classToken: string,
+    methodName: string,
+  ): ListenerRef {
+    const instance = discovered.instance as
+      | Record<string, (...args: unknown[]) => unknown>
+      | undefined;
+    const method = instance?.[methodName];
+    if (method) {
+      return {
+        kind: RefKind.BuilderLambda,
+        fn: method.bind(discovered.instance) as (...args: any[]) => unknown,
+      };
+    }
+    return { kind: 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.
+   */
+  private buildTaskletStep(
+    discovered: DiscoveredJob,
+    classToken: string,
+    step: DiscoveredJob['stepMethods'][number],
+  ): TaskletStepDefinition {
+    const instance = discovered.instance as
+      | Record<string, (...args: unknown[]) => unknown>
+      | undefined;
+    const method = instance?.[step.methodName];
+    const taskletRef: TaskletRef = method
+      ? { kind: RefKind.BuilderLambda, fn: () => method.bind(discovered.instance) }
+      : { kind: 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.
+   */
+  private buildChunkStep(
+    discovered: DiscoveredJob,
+    classToken: string,
+    step: DiscoveredJob['stepMethods'][number],
+  ): ChunkStepDefinition {
+    const reader = this.findItemMethod(discovered, BATCH_ITEM_READER_METADATA);
+    const processor = this.findItemMethod(discovered, BATCH_ITEM_PROCESSOR_METADATA);
+    const writer = this.findItemMethod(discovered, 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: ReaderRef = this.buildItemMethodRef(discovered, classToken, reader);
+    const writerRef: 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 {
+      validatePartitions(step.options.partitions);
+    } catch (err) {
+      if (err instanceof InvalidPartitionsError) {
+        throw new 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) satisfies ProcessorRef,
+          }
+        : {}),
+    };
+  }
+
+  private buildItemMethodRef(
+    discovered: DiscoveredJob,
+    classToken: string,
+    methodName: string,
+  ): ReaderRef | ProcessorRef | WriterRef {
+    const instance = discovered.instance as
+      | Record<string, (...args: unknown[]) => unknown>
+      | undefined;
+    const method = instance?.[methodName];
+    if (method) {
+      return {
+        kind: RefKind.BuilderLambda,
+        fn: () => method.bind(discovered.instance),
+      };
+    }
+    return {
+      kind: 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.
+   */
+  private findItemMethod(discovered: DiscoveredJob, metadataKey: string): string | undefined {
+    const proto = discovered.classRef.prototype as object | undefined;
+    if (!proto) return undefined;
+    let p: object | null = 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;
+  }
+}

package/src/compiler/index.ts

@@ -0,0 +1,2 @@
+export * from './builder-types';
+export * from './definition-compiler';

package/src/core/errors.ts

@@ -0,0 +1,125 @@
+export abstract class BatchError extends Error {
+  abstract readonly code: string;
+  readonly details?: unknown;
+  constructor(message: string, details?: unknown) {
+    super(message);
+    this.name = this.constructor.name;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+export class JobNotFoundError extends BatchError {
+  readonly code = 'JOB_NOT_FOUND';
+  constructor(jobId: string) {
+    super(`Job not found: ${jobId}`, { jobId });
+  }
+}
+
+export class DuplicateJobDefinitionError extends BatchError {
+  readonly code = 'DUPLICATE_JOB';
+  constructor(jobId: string) {
+    super(`Job already registered: ${jobId}`, { jobId });
+  }
+}
+
+export class InvalidFlowGraphError extends BatchError {
+  readonly code: string;
+  constructor(code: string, message: string, details?: unknown) {
+    super(message, details);
+    this.code = code;
+  }
+}
+
+export class SkipLimitExceededError extends BatchError {
+  readonly code = 'SKIP_LIMIT_EXCEEDED';
+  constructor(limit: number, message?: string) {
+    super(message ?? `Skip limit exceeded: ${limit}`, { limit });
+  }
+}
+
+export class RetryLimitExceededError extends BatchError {
+  readonly code = 'RETRY_LIMIT_EXCEEDED';
+  constructor(limit: number, message?: string) {
+    super(message ?? `Retry limit exceeded: ${limit}`, { limit });
+  }
+}
+
+export class JobExecutionAlreadyRunningError extends BatchError {
+  readonly code = 'JOB_EXECUTION_ALREADY_RUNNING';
+  constructor(jobInstanceId: string) {
+    super(`Job instance already running: ${jobInstanceId}`, { jobInstanceId });
+  }
+}
+
+export class JobExecutionNotFoundError extends BatchError {
+  readonly code = 'JOB_EXECUTION_NOT_FOUND';
+  constructor(executionId: string) {
+    super(`Job execution not found: ${executionId}`, { executionId });
+  }
+}
+
+export class JobInstanceNotFoundError extends BatchError {
+  readonly code = 'JOB_INSTANCE_NOT_FOUND';
+  constructor(jobInstanceId: string) {
+    super(`Job instance not found: ${jobInstanceId}`, { jobInstanceId });
+  }
+}
+
+export class InvalidJobOperationError extends BatchError {
+  readonly code = 'INVALID_JOB_OPERATION';
+  constructor(operation: string, message: string, details?: unknown) {
+    super(message, { operation, ...(typeof details === 'object' && details !== null ? details : {}) });
+  }
+}
+
+export class UnsupportedJobRepositoryOperationError extends BatchError {
+  readonly code = 'UNSUPPORTED_JOB_REPOSITORY_OPERATION';
+  constructor(operation: string) {
+    super(`JobRepository operation is not supported by this adapter: ${operation}`, {
+      operation,
+    });
+  }
+}
+
+/**
+ * Thrown when a restart is attempted against a JobDefinition that was
+ * declared with `restartable: false`. Restarting a FAILED execution is
+ * opt-in — by default the in-memory repository and most adapters are
+ * non-restartable because their contexts are process-local and lost on
+ * crash. (Per Metis: in-memory is `restartable: false` by default.)
+ */
+export class JobNotRestartableError extends BatchError {
+  readonly code = 'JOB_NOT_RESTARTABLE';
+  constructor(jobId: string) {
+    super(`Job is not restartable: ${jobId}`, { jobId });
+  }
+}
+
+export class InvalidExecutionContextError extends BatchError {
+  readonly code = 'INVALID_EXECUTION_CONTEXT';
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+/**
+ * Thrown when a `RefKind.ProviderToken` ref cannot be resolved against
+ * the executor's `providerResolvers` map (Task 9). The message always
+ * carries the unresolved token id and the role (`reader` / `processor`
+ * / `writer` / `tasklet` / `listener`) so log lines and test failures
+ * identify the missing provider deterministically.
+ *
+ * Distinct from `ProviderNotFoundError` in the compiler, which fires
+ * during IR compilation when a chunk step is missing a required item
+ * handler method. This error fires at runtime when the DI binding for
+ * an already-shaped ref cannot be located.
+ */
+export class ProviderTokenNotFoundError extends BatchError {
+  readonly code = 'PROVIDER_TOKEN_NOT_FOUND';
+  constructor(token: string, role: string) {
+    super(`No provider bound for ${role} token: ${token}`, { token, role });
+  }
+}

package/src/core/execution-context/index.ts

@@ -0,0 +1,3 @@
+export * from './json-value';
+export * from './validator';
+export * from './serializer';

package/src/core/execution-context/json-value.ts

@@ -0,0 +1,3 @@
+export type JsonPrimitive = string | number | boolean | null;
+
+export type JsonValue = JsonPrimitive | JsonValue[] | { [k: string]: JsonValue };

package/src/core/execution-context/serializer.ts

@@ -0,0 +1,21 @@
+import { InvalidExecutionContextError } from '../errors';
+import type { JsonValue } from './json-value';
+
+export function serializeContext(ctx: unknown): string {
+  return JSON.stringify(
+    ctx,
+    function (this: unknown, key: string, value: unknown): unknown {
+      if (typeof value === 'bigint') {
+        throw new InvalidExecutionContextError(
+          `Cannot serialize BigInt at key "${key}"`,
+          { key },
+        );
+      }
+      return value;
+    },
+  );
+}
+
+export function deserializeContext<T extends JsonValue>(raw: string): T {
+  return JSON.parse(raw) as T;
+}

package/src/core/execution-context/validator.ts

@@ -0,0 +1,103 @@
+import { InvalidExecutionContextError } from '../errors';
+import type { JsonValue } from './json-value';
+
+const MAX_DEPTH = 100;
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  if (v === null || typeof v !== 'object') return false;
+  if (Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+/**
+ * Asserts that `value` is JSON-serializable. Throws InvalidExecutionContextError
+ * with `details.path` on the first non-serializable value encountered.
+ *
+ * Rejection rules:
+ *   - undefined (top level only; inside objects/arrays: silently omitted)
+ *   - function, bigint, symbol
+ *   - non-finite numbers (NaN, Infinity, -Infinity)
+ *   - class instances (anything with a non-Object prototype that is not Date/RegExp)
+ *   - circular references
+ *   - nesting depth > 100
+ *
+ * `seen` and `depth` are threaded through recursive calls so cycles and depth
+ * are tracked across the whole object graph, not per call.
+ */
+export function assertJsonSerializable(
+  value: unknown,
+  path = '$',
+  seen: WeakSet<object> = new WeakSet(),
+  depth = 0,
+): void {
+  if (value === null) return;
+
+  const t = typeof value;
+  if (t === 'undefined') {
+    throw new InvalidExecutionContextError(
+      `Value at ${path} is undefined (must be omitted or null)`,
+      { path },
+    );
+  }
+  if (t === 'string' || t === 'boolean') return;
+  if (t === 'number') {
+    if (!Number.isFinite(value as number)) {
+      throw new InvalidExecutionContextError(
+        `Value at ${path} is not a finite number`,
+        { path, value },
+      );
+    }
+    return;
+  }
+  if (t === 'bigint') {
+    throw new InvalidExecutionContextError(`Value at ${path} is a BigInt`, { path });
+  }
+  if (t === 'symbol') {
+    throw new InvalidExecutionContextError(`Value at ${path} is a Symbol`, { path });
+  }
+  if (t === 'function') {
+    throw new InvalidExecutionContextError(`Value at ${path} is a function`, { path });
+  }
+
+  // object types
+  if (value instanceof Date) return;
+  if (value instanceof RegExp) return;
+
+  if (depth > MAX_DEPTH) {
+    throw new InvalidExecutionContextError(`Max depth exceeded at ${path}`, { path });
+  }
+  const objRef = value as object;
+  if (seen.has(objRef)) {
+    throw new InvalidExecutionContextError(
+      `Circular reference detected at ${path}`,
+      { path },
+    );
+  }
+  seen.add(objRef);
+
+  if (Array.isArray(value)) {
+    const arr = value as unknown[];
+    for (let i = 0; i < arr.length; i++) {
+      assertJsonSerializable(arr[i], `${path}[${i}]`, seen, depth + 1);
+    }
+    return;
+  }
+  if (isPlainObject(value)) {
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+      const v = obj[key];
+      if (v === undefined) continue; // undefined values in objects are silently omitted
+      assertJsonSerializable(v, `${path}.${key}`, seen, depth + 1);
+    }
+    return;
+  }
+  // class instance
+  throw new InvalidExecutionContextError(
+    `Value at ${path} is a class instance (not plain object)`,
+    { path, ctor: (value as object).constructor?.name },
+  );
+}
+
+// Re-export JsonValue for downstream convenience.
+export type { JsonValue } from './json-value';

package/src/core/index.ts

@@ -0,0 +1,7 @@
+export * from './status';
+export * from './errors';
+export * from './ir';
+export * from './execution-context';
+export * from './item';
+export * from './repository';
+export * from './transaction';

package/src/core/ir/decider-definition.ts

@@ -0,0 +1,25 @@
+import type { JobExecution } from '../repository/types';
+import type { StepStatus } from '../status';
+
+export interface JobExecutionDeciderContext {
+  readonly jobExecution: JobExecution;
+  readonly stepId: string;
+  readonly stepExecutionId: string;
+  readonly stepStatus: StepStatus;
+  readonly exitCode: string;
+  readonly exitMessage: string;
+}
+
+export type JobExecutionDecider = (
+  context: JobExecutionDeciderContext,
+) => string | Promise<string>;
+
+export interface DeciderDefinition {
+  readonly afterStepId: string;
+  readonly decide: JobExecutionDecider;
+}
+
+export interface ReusableFlowDefinition {
+  readonly transitions: readonly import('./transition-definition').TransitionDefinition[];
+  readonly deciders?: readonly DeciderDefinition[];
+}

package/src/core/ir/index.ts

@@ -0,0 +1,7 @@
+export * from './job-definition';
+export * from './step-definition';
+export * from './transition-definition';
+export * from './decider-definition';
+export * from './listener-definition';
+export * from './policy-config';
+export * from './refs';

package/src/core/ir/job-definition.ts

@@ -0,0 +1,15 @@
+import type { StepDefinition } from './step-definition';
+import type { TransitionDefinition } from './transition-definition';
+import type { ListenerDefinition } from './listener-definition';
+import type { DeciderDefinition } from './decider-definition';
+
+export interface JobDefinition {
+  id: string;
+  steps: Record<string, StepDefinition>;
+  startStepId: string;
+  transitions: TransitionDefinition[];
+  deciders?: DeciderDefinition[];
+  listeners: ListenerDefinition[];
+  restartable: boolean;
+  allowDuplicateInstances: boolean;
+}

package/src/core/ir/listener-definition.ts

@@ -0,0 +1,19 @@
+import type { ListenerRef } from './refs';
+
+export type ListenerKind =
+  | 'job'
+  | 'step'
+  | 'chunk'
+  | 'item-read'
+  | 'item-process'
+  | 'item-write'
+  | 'skip'
+  | 'transition';
+export type ListenerPhase = 'before' | 'after' | 'on-error';
+
+export interface ListenerDefinition {
+  kind: ListenerKind;
+  ref: ListenerRef;
+  phase: ListenerPhase;
+  nonCritical?: boolean;
+}

package/src/core/ir/policy-config.ts

@@ -0,0 +1,19 @@
+export type ErrorClass = new (...args: any[]) => Error;
+export type ErrorPredicate = (err: unknown) => boolean;
+export type Skippable = ErrorClass | ErrorPredicate;
+
+export interface SkipPolicyConfig {
+  limit: number;
+  skippable: Skippable[];
+}
+
+export type BackoffConfig =
+  | { type: 'fixed'; ms: number }
+  | { type: 'exponential'; initialMs: number; maxMs?: number; factor?: number }
+  | { type: 'none' };
+
+export interface RetryPolicyConfig {
+  limit: number;
+  retryable: Skippable[];
+  backoff: BackoffConfig;
+}