scrapme-flow 0.0.0-stage → 0.2.0

package/dist/src/flow/command-executor.js

@@ -0,0 +1,87 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { TYPES } from '../di/types.js';
+import { Timing } from '../util/timing.js';
+import { CommandTimeoutError, FlowCancelledError, FlowErrors } from './flow-errors.js';
+import { ATTEMPT_OUTCOME, } from './flow.models.js';
+import { RetryPolicy } from './retry-policy.js';
+/**
+ * Runs one step inside a flow attempt: attempts with a timeout each, retried with backoff while the error is
+ * retryable. Never throws. (The whole flow is retried by pg-boss; this is the per-command retry inside it.)
+ */
+let CommandExecutor = class CommandExecutor {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /** step settings > command.options > defaults (Scrapme.create({ defaults })). */
+    policy(step, command) {
+        const d = this.config.flow;
+        const c = command.options ?? {};
+        const s = step.options;
+        return {
+            maxAttempts: 1 + (s.retries ?? c.retries ?? d.retries),
+            timeoutMs: s.timeoutMs ?? c.timeoutMs ?? d.timeoutMs,
+            retryDelayMs: s.retryDelayMs ?? c.retryDelayMs ?? d.retryDelayMs,
+            maxRetryDelayMs: s.maxRetryDelayMs ?? c.maxRetryDelayMs ?? d.maxRetryDelayMs,
+        };
+    }
+    async execute(step, command, input, base, runSignal, listeners) {
+        const policy = this.policy(step, command);
+        const retry = new RetryPolicy(policy);
+        const attempts = [];
+        const started = Date.now();
+        for (let attempt = 1;; attempt++) {
+            const startedAt = new Date();
+            await listeners.started?.(attempt);
+            try {
+                if (runSignal?.aborted)
+                    throw new FlowCancelledError(runSignal.reason);
+                const value = await Timing.withTimeout((signal) => command.execute(input, { ...base, attempt, maxAttempts: policy.maxAttempts, signal, logger: base.logger.child({ attempt }) }), policy.timeoutMs, () => new CommandTimeoutError(step.key, policy.timeoutMs), runSignal);
+                attempts.push(this.report(attempt, base.flowAttempt, startedAt, ATTEMPT_OUTCOME.SUCCEEDED));
+                return { ok: true, value, attempts, durationMs: Date.now() - started };
+            }
+            catch (caught) {
+                const error = runSignal?.aborted && !(caught instanceof FlowCancelledError) ? new FlowCancelledError(runSignal.reason) : caught;
+                const final = !this.shouldRetry(command, error) || attempt >= policy.maxAttempts;
+                const report = {
+                    ...this.report(attempt, base.flowAttempt, startedAt, error instanceof CommandTimeoutError ? ATTEMPT_OUTCOME.TIMEOUT : ATTEMPT_OUTCOME.FAILED),
+                    error: FlowErrors.serialize(error),
+                    ...(final ? {} : { retryInMs: retry.delayAfter(attempt) }),
+                };
+                attempts.push(report);
+                await listeners.failed(report, error, final);
+                if (final)
+                    return { ok: false, error, attempts, durationMs: Date.now() - started };
+                try {
+                    await Timing.sleep(report.retryInMs ?? 0, runSignal);
+                }
+                catch (reason) {
+                    return { ok: false, error: new FlowCancelledError(reason), attempts, durationMs: Date.now() - started };
+                }
+            }
+        }
+    }
+    report(attempt, flowAttempt, startedAt, outcome) {
+        return { attempt, flowAttempt, startedAt: startedAt.toISOString(), durationMs: Date.now() - startedAt.getTime(), outcome };
+    }
+    shouldRetry(command, error) {
+        if (error instanceof FlowCancelledError)
+            return false;
+        return command.isRetryable ? command.isRetryable(error) : FlowErrors.isRetryable(error);
+    }
+};
+CommandExecutor = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.Config))
+], CommandExecutor);
+export { CommandExecutor };
+//# sourceMappingURL=command-executor.js.map

package/dist/src/flow/command-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-executor.js","sourceRoot":"","sources":["../../../src/flow/command-executor.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACvF,OAAO,EACL,eAAe,GAShB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;GAGG;AAEI,IAAM,eAAe,GAArB,MAAM,eAAe;IACgC;IAA1D,YAA0D,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAEnF,iFAAiF;IAC1E,MAAM,CAAC,IAAoB,EAAE,OAAgB;QAClD,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;QAC3B,MAAM,CAAC,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;QAChC,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QACvB,OAAO;YACL,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC;YACtD,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS;YACpD,YAAY,EAAE,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,YAAY;YAChE,eAAe,EAAE,CAAC,CAAC,eAAe,IAAI,CAAC,CAAC,eAAe,IAAI,CAAC,CAAC,eAAe;SAC7E,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,IAAoB,EACpB,OAAgB,EAChB,KAAc,EACd,IAAgE,EAChE,SAAkC,EAClC,SAA8E;QAE9E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC1C,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,QAAQ,GAAoB,EAAE,CAAC;QACrC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE3B,KAAK,IAAI,OAAO,GAAG,CAAC,GAAI,OAAO,EAAE,EAAE,CAAC;YAClC,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;YAC7B,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;YACnC,IAAI,CAAC;gBACH,IAAI,SAAS,EAAE,OAAO;oBAAE,MAAM,IAAI,kBAAkB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBACvE,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,WAAW,CACpC,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EACzI,MAAM,CAAC,SAAS,EAChB,GAAG,EAAE,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,SAAS,CAAC,EACzD,SAAS,CACV,CAAC;gBACF,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC5F,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;YACzE,CAAC;YAAC,OAAO,MAAM,EAAE,CAAC;gBAChB,MAAM,KAAK,GAAG,SAAS,EAAE,OAAO,IAAI,CAAC,CAAC,MAAM,YAAY,kBAAkB,CAAC,CAAC,CAAC,CAAC,IAAI,kBAAkB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;gBAChI,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,OAAO,IAAI,MAAM,CAAC,WAAW,CAAC;gBACjF,MAAM,MAAM,GAAkB;oBAC5B,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,EAAE,KAAK,YAAY,mBAAmB,CAAC,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC;oBAC7I,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC;oBAClC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;iBAC3D,CAAC;gBACF,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACtB,MAAM,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;gBAC7C,IAAI,KAAK;oBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;gBACnF,IAAI,CAAC;oBACH,MAAM,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;gBACvD,CAAC;gBAAC,OAAO,MAAM,EAAE,CAAC;oBAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,kBAAkB,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;gBAC1G,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,OAAe,EAAE,WAAmB,EAAE,SAAe,EAAE,OAAiC;QACrG,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC;IAC7H,CAAC;IAEO,WAAW,CAAC,OAAgB,EAAE,KAAc;QAClD,IAAI,KAAK,YAAY,kBAAkB;YAAE,OAAO,KAAK,CAAC;QACtD,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC1F,CAAC;CACF,CAAA;AAtEY,eAAe;IAD3B,UAAU,EAAE;IAES,WAAA,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;GAD7B,eAAe,CAsE3B"}

package/dist/src/flow/command-resolver.d.ts

@@ -0,0 +1,11 @@
+import { type Container } from 'inversify';
+import type { Command, CommandRef } from './flow.models.js';
+/**
+ * Turns a step's command into an instance: classes come from scrapme's container (autobind; its parent is your
+ * app's container, so a command's `@inject(...)` gets your services), instances are used as they are.
+ */
+export declare class CommandResolver {
+    private readonly container;
+    constructor(container: Container);
+    resolve(ref: CommandRef): Command;
+}

package/dist/src/flow/command-resolver.js

@@ -0,0 +1,35 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { TYPES } from '../di/types.js';
+/**
+ * Turns a step's command into an instance: classes come from scrapme's container (autobind; its parent is your
+ * app's container, so a command's `@inject(...)` gets your services), instances are used as they are.
+ */
+let CommandResolver = class CommandResolver {
+    container;
+    constructor(container) {
+        this.container = container;
+    }
+    resolve(ref) {
+        if (typeof ref !== 'function')
+            return ref;
+        const command = this.container.get(ref);
+        if (!command || typeof command.execute !== 'function')
+            throw new TypeError(`${ref.name} has no execute method`);
+        return command;
+    }
+};
+CommandResolver = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.Container))
+], CommandResolver);
+export { CommandResolver };
+//# sourceMappingURL=command-resolver.js.map

package/dist/src/flow/command-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-resolver.js","sourceRoot":"","sources":["../../../src/flow/command-resolver.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAkB,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC;;;GAGG;AAEI,IAAM,eAAe,GAArB,MAAM,eAAe;IACmC;IAA7D,YAA6D,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IAAG,CAAC;IAE9E,OAAO,CAAC,GAAe;QAC5B,IAAI,OAAO,GAAG,KAAK,UAAU;YAAE,OAAO,GAAG,CAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAU,GAAmC,CAAC,CAAC;QACjF,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,UAAU;YAAE,MAAM,IAAI,SAAS,CAAC,GAAG,GAAG,CAAC,IAAI,wBAAwB,CAAC,CAAC;QAChH,OAAO,OAAO,CAAC;IACjB,CAAC;CACF,CAAA;AATY,eAAe;IAD3B,UAAU,EAAE;IAES,WAAA,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;GADhC,eAAe,CAS3B"}

package/dist/src/flow/flow-catalog.d.ts

@@ -0,0 +1,12 @@
+import { Flow } from './flow.js';
+import type { FlowConfig } from './flow.models.js';
+/** The flows this app runs, by name — a queued job only carries the name. Names must be unique. */
+export declare class FlowCatalog {
+    private readonly flows;
+    constructor(flows: readonly (Flow | FlowConfig)[]);
+    has(name: string): boolean;
+    /** Throws FlowDefinitionError for a flow that wasn't given to Scrapme.create. */
+    get(name: string): Flow;
+    names(): string[];
+    all(): Flow[];
+}

package/dist/src/flow/flow-catalog.js

@@ -0,0 +1,31 @@
+import { FlowDefinitionError } from './flow-errors.js';
+import { Flow } from './flow.js';
+/** The flows this app runs, by name — a queued job only carries the name. Names must be unique. */
+export class FlowCatalog {
+    flows = new Map();
+    constructor(flows) {
+        for (const given of flows) {
+            const flow = given instanceof Flow ? given : new Flow(given);
+            if (this.flows.has(flow.name))
+                throw new FlowDefinitionError('two flows have this name (names must be unique)', flow.name);
+            this.flows.set(flow.name, flow);
+        }
+    }
+    has(name) {
+        return this.flows.has(name);
+    }
+    /** Throws FlowDefinitionError for a flow that wasn't given to Scrapme.create. */
+    get(name) {
+        const flow = this.flows.get(name);
+        if (!flow)
+            throw new FlowDefinitionError(`not registered - add it to Scrapme.create({ flows: [...] }) (registered: ${this.names().join(', ') || 'none'})`, name);
+        return flow;
+    }
+    names() {
+        return [...this.flows.keys()].sort();
+    }
+    all() {
+        return [...this.flows.values()];
+    }
+}
+//# sourceMappingURL=flow-catalog.js.map

package/dist/src/flow/flow-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-catalog.js","sourceRoot":"","sources":["../../../src/flow/flow-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,mGAAmG;AACnG,MAAM,OAAO,WAAW;IACL,KAAK,GAAG,IAAI,GAAG,EAAgB,CAAC;IAEjD,YAAmB,KAAqC;QACtD,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;YAC1B,MAAM,IAAI,GAAG,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7D,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,MAAM,IAAI,mBAAmB,CAAC,iDAAiD,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3H,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAEM,GAAG,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,iFAAiF;IAC1E,GAAG,CAAC,IAAY;QACrB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,mBAAmB,CAAC,4EAA4E,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,GAAG,EAAE,IAAI,CAAC,CAAC;QACjK,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,KAAK;QACV,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACvC,CAAC;IAEM,GAAG;QACR,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAClC,CAAC;CACF"}

package/dist/src/flow/flow-errors.d.ts

@@ -0,0 +1,66 @@
+import { type SerializedError } from './flow.models.js';
+/** An error retrying cannot fix (bad input, page without the expected data, rejected e-mail address…). */
+export declare class PermanentError extends Error {
+    readonly retryable = false;
+    readonly code: string;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+    });
+}
+/** A command needs a service that wasn't given to Scrapme.create — fix the options, a retry won't help. */
+export declare class NotConfiguredError extends PermanentError {
+    constructor(service: string, neededBy: string);
+}
+/** One attempt took longer than its timeoutMs (retryable). */
+export declare class CommandTimeoutError extends Error {
+    readonly step: string;
+    readonly timeoutMs: number;
+    readonly retryable = true;
+    readonly code: "COMMAND_TIMEOUT";
+    constructor(step: string, timeoutMs: number);
+}
+/** The run was cancelled through RunOptions.signal (never retried). */
+export declare class FlowCancelledError extends Error {
+    readonly retryable = false;
+    readonly code: "FLOW_CANCELLED";
+    constructor(reason?: unknown);
+    private static describe;
+}
+/** A run that failed for good; `cause` is the step's last error (for apps that want to throw after waitFor). */
+export declare class FlowFailedError extends Error {
+    readonly flow: string;
+    readonly step: string;
+    readonly runId: string;
+    readonly code: "FLOW_FAILED";
+    constructor(flow: string, step: string, runId: string, cause: unknown);
+}
+/**
+ * A flow can't be used as written: wrong shape, bad reference, duplicate key, not a command. Thrown by
+ * new Flow (so at import time of the `*.flow.ts` file) or Scrapme.create — never in the middle of a run.
+ */
+export declare class FlowDefinitionError extends Error {
+    readonly flow: string;
+    readonly retryable = false;
+    readonly code: "FLOW_DEFINITION";
+    constructor(message: string, flow: string);
+}
+/** The run input doesn't fit the flow's `<param>`s (missing required, wrong type). Thrown before the run starts. */
+export declare class FlowInputError extends Error {
+    readonly flow: string;
+    readonly problems: readonly string[];
+    readonly retryable = false;
+    readonly code: "FLOW_INPUT";
+    constructor(flow: string, problems: readonly string[]);
+}
+/** What scrapme needs to know about any error: retry it? how to store it? */
+export declare class FlowErrors {
+    private static readonly MAX_CAUSE_DEPTH;
+    /**
+     * Default retry decision: PermanentError and anything with `retryable === false` (e.g. client errors of
+     * scrap-anything-client) are final, cancellations are final, everything else is retried.
+     */
+    static isRetryable(error: unknown): boolean;
+    /** JSON-safe form for storage and reports (follows `cause` 3 levels deep). */
+    static serialize(error: unknown, depth?: number): SerializedError;
+}

package/dist/src/flow/flow-errors.js

@@ -0,0 +1,119 @@
+import { ERROR_CODE } from './flow.models.js';
+/** An error retrying cannot fix (bad input, page without the expected data, rejected e-mail address…). */
+export class PermanentError extends Error {
+    retryable = false;
+    code;
+    constructor(message, options = {}) {
+        super(message, { cause: options.cause });
+        this.name = 'PermanentError';
+        this.code = options.code ?? ERROR_CODE.PERMANENT;
+    }
+}
+/** A command needs a service that wasn't given to Scrapme.create — fix the options, a retry won't help. */
+export class NotConfiguredError extends PermanentError {
+    constructor(service, neededBy) {
+        super(`${neededBy} needs "${service}" in Scrapme.create({ ${service}: { … } })`, { code: ERROR_CODE.NOT_CONFIGURED });
+        this.name = 'NotConfiguredError';
+    }
+}
+/** One attempt took longer than its timeoutMs (retryable). */
+export class CommandTimeoutError extends Error {
+    step;
+    timeoutMs;
+    retryable = true;
+    code = ERROR_CODE.COMMAND_TIMEOUT;
+    constructor(step, timeoutMs) {
+        super(`step "${step}" timed out after ${timeoutMs} ms`);
+        this.step = step;
+        this.timeoutMs = timeoutMs;
+        this.name = 'CommandTimeoutError';
+    }
+}
+/** The run was cancelled through RunOptions.signal (never retried). */
+export class FlowCancelledError extends Error {
+    retryable = false;
+    code = ERROR_CODE.FLOW_CANCELLED;
+    constructor(reason) {
+        super(`flow cancelled${FlowCancelledError.describe(reason)}`, { cause: reason });
+        this.name = 'FlowCancelledError';
+    }
+    static describe(reason) {
+        if (reason instanceof Error)
+            return `: ${reason.message}`;
+        return reason ? `: ${String(reason)}` : '';
+    }
+}
+/** A run that failed for good; `cause` is the step's last error (for apps that want to throw after waitFor). */
+export class FlowFailedError extends Error {
+    flow;
+    step;
+    runId;
+    code = ERROR_CODE.FLOW_FAILED;
+    constructor(flow, step, runId, cause) {
+        super(`flow "${flow}" failed at step "${step}" (run ${runId}): ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        this.flow = flow;
+        this.step = step;
+        this.runId = runId;
+        this.name = 'FlowFailedError';
+    }
+}
+/**
+ * A flow can't be used as written: wrong shape, bad reference, duplicate key, not a command. Thrown by
+ * new Flow (so at import time of the `*.flow.ts` file) or Scrapme.create — never in the middle of a run.
+ */
+export class FlowDefinitionError extends Error {
+    flow;
+    retryable = false;
+    code = ERROR_CODE.FLOW_DEFINITION;
+    constructor(message, flow) {
+        super(`flow "${flow}": ${message}`);
+        this.flow = flow;
+        this.name = 'FlowDefinitionError';
+    }
+}
+/** The run input doesn't fit the flow's `<param>`s (missing required, wrong type). Thrown before the run starts. */
+export class FlowInputError extends Error {
+    flow;
+    problems;
+    retryable = false;
+    code = ERROR_CODE.FLOW_INPUT;
+    constructor(flow, problems) {
+        super(`flow "${flow}": ${problems.join('; ')}`);
+        this.flow = flow;
+        this.problems = problems;
+        this.name = 'FlowInputError';
+    }
+}
+/** What scrapme needs to know about any error: retry it? how to store it? */
+export class FlowErrors {
+    static MAX_CAUSE_DEPTH = 3;
+    /**
+     * Default retry decision: PermanentError and anything with `retryable === false` (e.g. client errors of
+     * scrap-anything-client) are final, cancellations are final, everything else is retried.
+     */
+    static isRetryable(error) {
+        if (error instanceof FlowCancelledError || error instanceof PermanentError)
+            return false;
+        if (error && typeof error === 'object' && 'retryable' in error && typeof error.retryable === 'boolean')
+            return error.retryable;
+        if (error instanceof Error && error.name === 'AbortError')
+            return false;
+        return true;
+    }
+    /** JSON-safe form for storage and reports (follows `cause` 3 levels deep). */
+    static serialize(error, depth = 0) {
+        if (!(error instanceof Error)) {
+            return { name: 'NonError', message: typeof error === 'string' ? error : (JSON.stringify(error) ?? String(error)), retryable: true };
+        }
+        const code = error.code;
+        return {
+            name: error.name,
+            message: error.message,
+            ...(typeof code === 'string' || typeof code === 'number' ? { code: String(code) } : {}),
+            retryable: FlowErrors.isRetryable(error),
+            ...(error.stack ? { stack: error.stack } : {}),
+            ...(error.cause !== undefined && depth < FlowErrors.MAX_CAUSE_DEPTH ? { cause: FlowErrors.serialize(error.cause, depth + 1) } : {}),
+        };
+    }
+}
+//# sourceMappingURL=flow-errors.js.map

package/dist/src/flow/flow-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-errors.js","sourceRoot":"","sources":["../../../src/flow/flow-errors.ts"],"names":[],"mappings":"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"}

package/dist/src/flow/flow-job-processor.d.ts

@@ -0,0 +1,33 @@
+import type { ScrapmeConfig } from '../config/config.models.js';
+import type { Logger } from '../logging/logger.js';
+import type { FlowJob } from '../queue/queue.models.js';
+import type { ErrorReporter } from '../reporting/reporting.models.js';
+import type { RunStore } from '../storage/storage.models.js';
+import type { CommandExecutor } from './command-executor.js';
+import type { CommandResolver } from './command-resolver.js';
+import type { Flow } from './flow.js';
+import type { StepInputBuilder } from './step-input-builder.js';
+/**
+ * Runs one attempt of a flow job: every step from the first one, each command with its own retries and timeout
+ * (CommandExecutor). A command that fails for good fails the attempt:
+ *   - retryable error, flow attempts left → run "retrying", throw → pg-boss runs the whole flow again later;
+ *   - last flow attempt, or a permanent error (PermanentError, retryable: false) → run "failed", reported once.
+ * Every change is written to the run document right away — that is what the monitor shows.
+ */
+export declare class FlowJobProcessor {
+    private readonly config;
+    private readonly store;
+    private readonly resolver;
+    private readonly executor;
+    private readonly inputs;
+    private readonly reporter;
+    private readonly logger;
+    constructor(config: ScrapmeConfig, logger: Logger, store: RunStore, resolver: CommandResolver, executor: CommandExecutor, inputs: StepInputBuilder, reporter: ErrorReporter);
+    process(flow: Flow, job: FlowJob): Promise<void>;
+    private runStep;
+    private stepFailed;
+    /** The run failed for good: record it and report it once. */
+    private finishFailed;
+    private static endAttempt;
+    private static stepOf;
+}

package/dist/src/flow/flow-job-processor.js

@@ -0,0 +1,208 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var FlowJobProcessor_1;
+import { inject, injectable } from 'inversify';
+import { TYPES } from '../di/types.js';
+import { LINE_LEVEL } from '../logging/logger.models.js';
+import { Preview } from '../util/preview.js';
+import { FlowErrors } from './flow-errors.js';
+import { ATTEMPT_OUTCOME, FINAL_RUN_STATUSES, RUN_STATUS, STEP_STATUS } from './flow.models.js';
+/**
+ * Runs one attempt of a flow job: every step from the first one, each command with its own retries and timeout
+ * (CommandExecutor). A command that fails for good fails the attempt:
+ *   - retryable error, flow attempts left → run "retrying", throw → pg-boss runs the whole flow again later;
+ *   - last flow attempt, or a permanent error (PermanentError, retryable: false) → run "failed", reported once.
+ * Every change is written to the run document right away — that is what the monitor shows.
+ */
+let FlowJobProcessor = FlowJobProcessor_1 = class FlowJobProcessor {
+    config;
+    store;
+    resolver;
+    executor;
+    inputs;
+    reporter;
+    logger;
+    constructor(config, logger, store, resolver, executor, inputs, reporter) {
+        this.config = config;
+        this.store = store;
+        this.resolver = resolver;
+        this.executor = executor;
+        this.inputs = inputs;
+        this.reporter = reporter;
+        this.logger = logger.child({ component: 'flow' });
+    }
+    async process(flow, job) {
+        const { runId } = job.data;
+        const run = await this.store.get(runId);
+        if (!run) {
+            this.logger.error('flow job without a run document - dropped', { runId, jobId: job.id });
+            return;
+        }
+        if (FINAL_RUN_STATUSES.includes(run.status)) {
+            this.logger.warn('run is finished already - job ignored', { runId, status: run.status });
+            return;
+        }
+        const flowAttempt = job.retryCount + 1;
+        const maxFlowAttempts = job.retryLimit + 1;
+        const log = this.logger.child({ flow: flow.name, runId, flowAttempt });
+        const startedAt = new Date().toISOString();
+        await this.store.update(runId, (d) => {
+            d.status = RUN_STATUS.RUNNING;
+            d.maxFlowAttempts = maxFlowAttempts;
+            d.startedAt ??= startedAt;
+            d.currentStep = null;
+            d.flowAttempts.push({ attempt: flowAttempt, jobId: job.id, startedAt });
+            d.steps = flow.steps.map((step) => ({ key: step.key, command: step.commandName, status: STEP_STATUS.PENDING, attempts: d.steps.find((s) => s.key === step.key)?.attempts ?? [] }));
+        });
+        log.info('flow started', { attempt: flowAttempt + '/' + maxFlowAttempts });
+        this.reporter.log('flow ' + flow.name + ' attempt ' + flowAttempt + '/' + maxFlowAttempts, { runId });
+        let state = { ...run.input };
+        for (const step of flow.steps) {
+            const outcome = await this.runStep(flow, step, runId, state, job, flowAttempt, log);
+            if (!outcome.ok) {
+                const permanent = !job.signal.aborted && !FlowErrors.isRetryable(outcome.error);
+                if (permanent || flowAttempt >= maxFlowAttempts) {
+                    await this.finishFailed(run, job, step.key, outcome.error);
+                    if (permanent)
+                        return; // the job completes: running it again can't help
+                    throw outcome.error; // pg-boss marks the job failed (no attempts left)
+                }
+                await this.store.update(runId, (d) => {
+                    d.status = RUN_STATUS.RETRYING;
+                    FlowJobProcessor_1.endAttempt(d, ATTEMPT_OUTCOME.FAILED, outcome.error);
+                });
+                log.warn('flow attempt failed, pg-boss will run the flow again', { step: step.key, error: outcome.error });
+                throw outcome.error;
+            }
+            state = { ...state, [step.key]: outcome.value };
+        }
+        const finished = new Date();
+        await this.store.update(runId, (d) => {
+            d.status = RUN_STATUS.SUCCEEDED;
+            d.currentStep = null;
+            d.finishedAt = finished.toISOString();
+            d.durationMs = finished.getTime() - Date.parse(d.startedAt ?? d.createdAt);
+            delete d.error;
+            FlowJobProcessor_1.endAttempt(d, ATTEMPT_OUTCOME.SUCCEEDED);
+        });
+        log.info('flow succeeded');
+    }
+    async runStep(flow, step, runId, state, job, flowAttempt, log) {
+        const stepLog = log.child({ step: step.key, command: step.commandName });
+        let command;
+        let input;
+        try {
+            command = this.resolver.resolve(step.command);
+            input = this.inputs.build(step.input, state, step.key);
+        }
+        catch (error) {
+            // a missing value, a throwing field function, an unresolvable command: the same state gives the same error
+            stepLog.error('step failed before it ran', { error });
+            const report = { attempt: 1, flowAttempt, startedAt: new Date().toISOString(), durationMs: 0, outcome: ATTEMPT_OUTCOME.FAILED, error: FlowErrors.serialize(error) };
+            await this.stepFailed(runId, step, report, error, true);
+            return { ok: false, error };
+        }
+        const maxAttempts = this.executor.policy(step, command).maxAttempts;
+        const execution = await this.executor.execute(step, command, input, { runId, flow: flow.name, step: step.key, flowAttempt, logger: stepLog, state: Object.freeze({ ...state }) }, job.signal, {
+            started: async (attempt) => {
+                stepLog.info(attempt === 1 ? 'step started' : 'step attempt started', { attempt, maxAttempts });
+                await this.store.update(runId, (d) => {
+                    const s = FlowJobProcessor_1.stepOf(d, step);
+                    s.status = STEP_STATUS.RUNNING;
+                    s.startedAt ??= new Date().toISOString();
+                    d.currentStep = step.key;
+                });
+            },
+            failed: async (report, error, final) => {
+                stepLog[final ? LINE_LEVEL.ERROR : LINE_LEVEL.WARN](final ? 'step failed' : 'step attempt failed, retrying in ' + report.retryInMs + ' ms', { attempt: report.attempt, maxAttempts, error });
+                this.reporter.log('step ' + step.key + ' attempt ' + report.attempt + '/' + maxAttempts + ' failed', { error: report.error?.message }, final ? LINE_LEVEL.ERROR : LINE_LEVEL.WARN);
+                await this.stepFailed(runId, step, report, error, final);
+            },
+        });
+        if (!execution.ok)
+            return { ok: false, error: execution.error };
+        const finished = new Date();
+        await this.store.update(runId, (d) => {
+            const s = FlowJobProcessor_1.stepOf(d, step);
+            s.status = STEP_STATUS.SUCCEEDED;
+            s.attempts.push(execution.attempts.at(-1));
+            s.finishedAt = finished.toISOString();
+            s.durationMs = finished.getTime() - Date.parse(s.startedAt ?? finished.toISOString());
+            s.output = Preview.of(execution.value, this.config.flow.maxStoredChars);
+        });
+        stepLog.info('step succeeded', { attempts: execution.attempts.length, ms: execution.durationMs });
+        return { ok: true, value: execution.value };
+    }
+    async stepFailed(runId, step, report, error, final) {
+        await this.store.update(runId, (d) => {
+            const s = FlowJobProcessor_1.stepOf(d, step);
+            s.attempts.push(report);
+            if (final) {
+                s.status = STEP_STATUS.FAILED;
+                s.error = report.error ?? FlowErrors.serialize(error);
+                s.finishedAt = new Date().toISOString();
+            }
+        });
+    }
+    /** The run failed for good: record it and report it once. */
+    async finishFailed(run, job, stepKey, error) {
+        const eventId = this.reporter.report(error, {
+            flow: run.flow,
+            step: stepKey,
+            command: run.steps.find((s) => s.key === stepKey)?.command ?? '',
+            runId: run.runId,
+            attempt: job.retryCount + 1,
+            maxAttempts: job.retryLimit + 1,
+            tags: { ...run.tags },
+            extra: { flowAttempt: job.retryCount + 1 },
+        });
+        const finished = new Date();
+        await this.store.update(run.runId, (d) => {
+            d.status = RUN_STATUS.FAILED;
+            d.finishedAt = finished.toISOString();
+            d.durationMs = finished.getTime() - Date.parse(d.startedAt ?? d.createdAt);
+            d.error = { ...FlowErrors.serialize(error), step: stepKey };
+            if (eventId)
+                d.reportEventId = eventId;
+            FlowJobProcessor_1.endAttempt(d, ATTEMPT_OUTCOME.FAILED, error);
+        });
+        await this.reporter.flush();
+        this.logger.error('flow failed', { flow: run.flow, runId: run.runId, step: stepKey, eventId: eventId || undefined });
+    }
+    static endAttempt(d, outcome, error) {
+        const attempt = d.flowAttempts.at(-1);
+        if (!attempt || attempt.finishedAt)
+            return;
+        attempt.finishedAt = new Date().toISOString();
+        attempt.outcome = outcome;
+        if (error !== undefined)
+            attempt.error = FlowErrors.serialize(error);
+    }
+    static stepOf(d, step) {
+        let report = d.steps.find((s) => s.key === step.key);
+        if (!report) {
+            report = { key: step.key, command: step.commandName, status: STEP_STATUS.PENDING, attempts: [] };
+            d.steps.push(report);
+        }
+        return report;
+    }
+};
+FlowJobProcessor = FlowJobProcessor_1 = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.Config)),
+    __param(1, inject(TYPES.Logger)),
+    __param(2, inject(TYPES.RunStore)),
+    __param(3, inject(TYPES.CommandResolver)),
+    __param(4, inject(TYPES.CommandExecutor)),
+    __param(5, inject(TYPES.StepInputBuilder)),
+    __param(6, inject(TYPES.ErrorReporter))
+], FlowJobProcessor);
+export { FlowJobProcessor };
+//# sourceMappingURL=flow-job-processor.js.map