@forestadmin/workflow-executor 1.35.8 → 1.37.0

package/dist/executors/per-record-step-executor.js

@@ -0,0 +1,369 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const errors_1 = require("../errors");
+const base_step_executor_1 = require("./base-step-executor");
+const iteration_run_store_1 = __importStar(require("./iteration-run-store"));
+const record_step_executor_1 = require("./record-step-executor");
+const record_id_1 = require("../record-id");
+const step_execution_data_1 = require("../types/step-execution-data");
+const step_definition_1 = require("../types/validated/step-definition");
+// Read before any type-specific confirmation: Get Data has none, and a failed record of any step
+// can be retried or skipped.
+const FailedRecordsRequestSchema = zod_1.z
+    .object({
+    failedRecords: zod_1.z.enum(['retry', 'skip']),
+    sourceRecordId: zod_1.z.string().min(1).optional(),
+})
+    .strict();
+// Handle the rest manually: every record not finished, the paused one included, is handed over at
+// once, as if each had been handled by hand, so a record that failed before them still ends the
+// step in error and comes back as Retry failed and Skip failed.
+const HandRestRequestSchema = zod_1.z
+    .object({
+    unfinishedRecords: zod_1.z.literal('handle-manually'),
+    sourceRecordId: zod_1.z.string().min(1),
+})
+    .strict();
+// Runs a record step once per record its Multiple source loaded, in order, each record
+// independently, through the single-record executor of its type.
+class PerRecordStepExecutor {
+    constructor(context, source, createInner) {
+        this.context = context;
+        this.source = source;
+        this.createInner = createInner;
+    }
+    async execute() {
+        try {
+            return await this.run();
+        }
+        catch (error) {
+            this.context.logger('Error', 'Per-record step failed', {
+                ...this.logCtx,
+                error: (0, errors_1.extractErrorMessage)(error),
+            });
+            if (error instanceof errors_1.WorkflowExecutorError) {
+                return this.outcome('error', (0, errors_1.toErrorOutcome)(error));
+            }
+            return this.outcome('error', { error: 'Unexpected error during step execution' });
+        }
+    }
+    async run() {
+        const { stepDefinition } = this.context;
+        if (stepDefinition.type === step_definition_1.StepType.LoadRelatedRecord &&
+            stepDefinition.preRecordedArgs?.multiple === true) {
+            throw new errors_1.MultipleOnPerRecordSourceError(stepDefinition.title);
+        }
+        const executions = await this.context.runStore.getStepExecutions(this.context.runId);
+        const stored = executions.find(e => e.stepIndex === this.context.stepIndex);
+        const row = (0, step_execution_data_1.isPerRecordExecution)(stored) ? stored : this.listRecords(executions);
+        const answered = this.readRequest(row);
+        await this.persist(row);
+        for (let index = 0; index < row.iterations.length; index += 1) {
+            if (row.iterations[index].finishedAt === undefined) {
+                // Records run one after the other: each one renews the lock the next one relies on.
+                // eslint-disable-next-line no-await-in-loop
+                const run = await this.runRecord(row, index, answered === index, executions);
+                if ('interrupted' in run) {
+                    return { ...this.outcome('awaiting-input'), interrupted: run.interrupted };
+                }
+                if (run.status === 'awaiting-input')
+                    return this.outcome('awaiting-input');
+            }
+        }
+        const failed = row.iterations.filter(iteration => iteration.error !== undefined);
+        if (failed.length === 0)
+            return this.outcome('success');
+        // Records failing for one kind of reason make the step fail for it: an edit, not a retry, fixes
+        // a configuration error on every record.
+        const kinds = new Set(failed.map(iteration => iteration.errorKind));
+        const [errorKind] = kinds.size === 1 ? [...kinds] : [];
+        return this.outcome('error', {
+            error: `${failed.length} of ${row.iterations.length} records failed.`,
+            ...(errorKind !== undefined && { errorKind }),
+        });
+    }
+    // Every record is listed when the step starts, so the run view shows the ones still to come.
+    listRecords(executions) {
+        const { root } = this.source;
+        const rootExecution = (0, base_step_executor_1.findStepExecution)(root, executions);
+        const result = rootExecution?.type === 'load-related-record' && rootExecution.executionResult;
+        const records = result && 'records' in result ? result.records : [];
+        if (records.length === 0) {
+            throw new errors_1.SourceRecordMissingError(root.stepDefinition.title, {
+                errorKind: (0, record_step_executor_1.classifyMissingSourceRecord)(rootExecution),
+                errorSourceStepIndex: root.stepOutcome.stepIndex,
+            });
+        }
+        return {
+            type: this.context.stepDefinition.type,
+            stepIndex: this.context.stepIndex,
+            iterations: records.map(record => ({ sourceRecordRef: record, attempt: 1 })),
+        };
+    }
+    // Applies a retry, skip or hand-the-rest request, or returns the index of the paused record an
+    // answer is for.
+    // An answer for any other record is dropped: the run view sent it for a pause that has moved on.
+    readRequest(row) {
+        const incoming = this.context.incomingPendingData;
+        if (incoming === undefined)
+            return undefined;
+        const request = FailedRecordsRequestSchema.safeParse(incoming);
+        if (request.success) {
+            const { failedRecords, sourceRecordId } = request.data;
+            row.iterations = row.iterations.map(iteration => {
+                if (iteration.error === undefined)
+                    return iteration;
+                if (sourceRecordId !== undefined && sourceRecordId !== this.idOf(iteration)) {
+                    return iteration;
+                }
+                return failedRecords === 'retry'
+                    ? { sourceRecordRef: iteration.sourceRecordRef, attempt: iteration.attempt + 1 }
+                    : {
+                        sourceRecordRef: iteration.sourceRecordRef,
+                        ...(iteration.selectedRecordRef && {
+                            selectedRecordRef: iteration.selectedRecordRef,
+                        }),
+                        attempt: iteration.attempt,
+                        executionResult: { skipped: true },
+                        finishedAt: new Date().toISOString(),
+                    };
+            });
+            return undefined;
+        }
+        const paused = row.iterations.findIndex(iteration => iteration.finishedAt === undefined);
+        const { sourceRecordId } = (incoming ?? {});
+        const isForPaused = paused >= 0 &&
+            row.iterations[paused].pendingData !== undefined &&
+            sourceRecordId === this.idOf(row.iterations[paused]);
+        if (isForPaused && HandRestRequestSchema.safeParse(incoming).success) {
+            const finishedAt = new Date().toISOString();
+            row.iterations = row.iterations.map(iteration => iteration.finishedAt !== undefined
+                ? iteration
+                : {
+                    sourceRecordRef: iteration.sourceRecordRef,
+                    ...(iteration.selectedRecordRef && {
+                        selectedRecordRef: iteration.selectedRecordRef,
+                    }),
+                    attempt: iteration.attempt,
+                    userConfirmation: { userConfirmed: false },
+                    executionResult: { skipped: true },
+                    finishedAt,
+                });
+            return undefined;
+        }
+        if (isForPaused)
+            return paused;
+        this.context.logger('Info', 'Dropped an answer for a record that is not the one paused', {
+            ...this.logCtx,
+            sourceRecordId: typeof sourceRecordId === 'string' ? sourceRecordId : null,
+        });
+        return undefined;
+    }
+    async runRecord(row, index, answered, executions) {
+        // An answered record runs before any hand-back: its answer lives only in this dispatch, and
+        // the claim that brought it is fresh.
+        const decision = answered
+            ? 'continue'
+            : (await this.context.runControl?.beforeRecord()) ?? 'continue';
+        if (decision === 'stop')
+            return { interrupted: 'stopped' };
+        if (decision === 'yield')
+            return { interrupted: 'yielded' };
+        const { sourceRecordRef } = row.iterations[index];
+        if (!this.reachesRecord(sourceRecordRef, executions)) {
+            row.iterations[index] = {
+                ...row.iterations[index],
+                executionResult: { skipped: true },
+                finishedAt: new Date().toISOString(),
+            };
+            await this.persist(row);
+            return { status: 'success' };
+        }
+        // A restart cut this record's change off after it started: it may have landed, so the record
+        // fails saying so, and only a retry, which drops the marker, runs it again.
+        if (row.iterations[index].idempotencyPhase === 'executing') {
+            return this.failRecord(row, index, new errors_1.RecordChangeInterruptedError().userMessage);
+        }
+        const store = new iteration_run_store_1.default(this.context.runStore, this.context.stepIndex, sourceRecordRef, {
+            get: () => row.iterations[index],
+            set: async (iteration) => {
+                row.iterations[index] = iteration;
+                await this.persist(row);
+            },
+        });
+        const { incomingPendingData } = this.context;
+        const answer = answered ? this.withoutRecordId(incomingPendingData) : undefined;
+        const inner = this.createInner({
+            ...this.context,
+            runStore: store,
+            incomingPendingData: answer,
+            stepTimeoutS: undefined,
+            perRecordLabel: await this.labelOf(sourceRecordRef),
+        });
+        const { stepOutcome } = await this.withTimeout(inner.execute(), store, () => row.iterations[index]);
+        if (stepOutcome.status === 'awaiting-input') {
+            await this.persist(row);
+            return { status: 'awaiting-input' };
+        }
+        if (stepOutcome.status === 'error') {
+            return this.failRecord(row, index, stepOutcome.error ?? 'Unexpected error during step execution', stepOutcome.errorKind);
+        }
+        row.iterations[index] = { ...row.iterations[index], finishedAt: new Date().toISOString() };
+        await this.persist(row);
+        return { status: stepOutcome.status };
+    }
+    async failRecord(row, index, error, errorKind) {
+        row.iterations[index] = {
+            ...row.iterations[index],
+            error,
+            ...(errorKind !== undefined && { errorKind }),
+            finishedAt: new Date().toISOString(),
+        };
+        await this.persist(row);
+        return { status: 'error' };
+    }
+    // A record whose per-record source found nothing for it is skipped by the steps after it.
+    reachesRecord(sourceRecordRef, executions) {
+        const { root, direct } = this.source;
+        if (direct === root)
+            return true;
+        const execution = (0, base_step_executor_1.findStepExecution)(direct, executions);
+        if (!(0, step_execution_data_1.isPerRecordExecution)(execution))
+            return false;
+        const result = execution.iterations.find(iteration => (0, iteration_run_store_1.isSameRecord)(iteration.sourceRecordRef, sourceRecordRef))?.executionResult;
+        return Boolean(result && 'record' in result);
+    }
+    // The step timeout applies to each record. The race does not abort the call it gives up on, so
+    // the store it writes through is abandoned and its late result is never saved.
+    async withTimeout(execution, store, iteration) {
+        const timeoutS = this.context.stepTimeoutS;
+        if (!timeoutS || timeoutS <= 0)
+            return execution;
+        let timer;
+        let timedOut = false;
+        // The abandoned call still ends, and only this log says how: a change it had started may land.
+        execution.then(result => {
+            if (!timedOut)
+                return;
+            this.context.logger('Warn', 'A record past its step timeout finished late', {
+                ...this.logCtx,
+                sourceRecordId: this.idOf(iteration()),
+                stepStatus: result.stepOutcome.status,
+                error: result.stepOutcome.error,
+            });
+        }, error => {
+            if (!timedOut)
+                return;
+            this.context.logger('Warn', 'A record past its step timeout failed late', {
+                ...this.logCtx,
+                sourceRecordId: this.idOf(iteration()),
+                error: (0, errors_1.extractErrorMessage)(error),
+            });
+        });
+        try {
+            return await Promise.race([
+                execution,
+                new Promise(resolve => {
+                    timer = setTimeout(() => {
+                        timedOut = true;
+                        store.abandon();
+                        // Past its write-ahead marker, the change has started and may still land.
+                        const changeStarted = iteration().idempotencyPhase === 'executing';
+                        this.context.logger('Error', `Step execution exceeded timeout of ${timeoutS}s`, {
+                            ...this.logCtx,
+                            sourceRecordId: this.idOf(iteration()),
+                            timeoutS,
+                            changeStarted,
+                        });
+                        const error = changeStarted
+                            ? new errors_1.RecordChangeInterruptedError()
+                            : new errors_1.StepTimeoutError(timeoutS);
+                        resolve(this.outcome('error', { error: error.userMessage }));
+                    }, timeoutS * 1000);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    withoutRecordId(pendingData) {
+        const { sourceRecordId, ...answer } = pendingData;
+        return answer;
+    }
+    idOf(iteration) {
+        return (0, record_id_1.serializeRecordId)(iteration.sourceRecordRef.recordId);
+    }
+    // The label only names the record to the AI, so a schema that cannot be read falls back to the
+    // technical name: the record's own run reads it again and reports the failure on that record.
+    async labelOf(record) {
+        const id = record.recordId.join(', ');
+        try {
+            const schema = await this.context.schemaResolver.resolve(record.collectionName);
+            return `${schema.collectionDisplayName} #${id}`;
+        }
+        catch (error) {
+            this.context.logger('Warn', 'Could not read the schema naming a record for the AI', {
+                ...this.logCtx,
+                collectionName: record.collectionName,
+                error: (0, errors_1.extractErrorMessage)(error),
+            });
+            return `${record.collectionName} #${id}`;
+        }
+    }
+    persist(row) {
+        return this.context.runStore.saveStepExecution(this.context.runId, row);
+    }
+    outcome(status, extra = {}) {
+        return {
+            stepOutcome: {
+                type: 'record',
+                stepId: this.context.stepId,
+                stepIndex: this.context.stepIndex,
+                status,
+                ...extra,
+            },
+        };
+    }
+    get logCtx() {
+        const { runId, stepId, stepIndex, stepDefinition } = this.context;
+        return { runId, stepId, stepIndex, stepType: stepDefinition.type };
+    }
+}
+exports.default = PerRecordStepExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"per-record-step-executor.js","sourceRoot":"","sources":["../../src/executors/per-record-step-executor.ts"],"names":[],"mappings":"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"}

package/dist/executors/record-step-executor.d.ts

@@ -1,8 +1,12 @@
 import type { StepExecutionResult } from '../types/execution-context';
+import type { StepExecutionData } from '../types/step-execution-data';
 import type { CollectionSchema, FieldSchema, RecordRef } from '../types/validated/collection';
+import type { Step } from '../types/validated/execution';
 import type { StepDefinition } from '../types/validated/step-definition';
 import type { ErrorKind, RecordStepStatus } from '../types/validated/step-outcome';
 import BaseStepExecutor from './base-step-executor';
+export declare function classifyMissingSourceRecord(execution?: StepExecutionData): ErrorKind | undefined;
+export declare function findPinnedLoadStep(previousSteps: readonly Step[], stepId: string, frameStepIndexes?: number[]): Step | undefined;
 export default abstract class RecordStepExecutor<TStep extends StepDefinition = StepDefinition> extends BaseStepExecutor<TStep> {
     protected buildOutcomeResult(outcome: {
         status: RecordStepStatus;

package/dist/executors/record-step-executor.js

@@ -3,10 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyMissingSourceRecord = classifyMissingSourceRecord;
+exports.findPinnedLoadStep = findPinnedLoadStep;
 const ai_proxy_1 = require("@forestadmin/ai-proxy");
 const zod_1 = require("zod");
 const errors_1 = require("../errors");
 const base_step_executor_1 = __importDefault(require("./base-step-executor"));
+const step_execution_data_1 = require("../types/step-execution-data");
 const step_definition_1 = require("../types/validated/step-definition");
 // Candidates passed over are the operator's call, and none at all is a source the operator can go
 // back to. Neither is a configuration fault, so neither is classified as one.
@@ -23,6 +26,31 @@ function classifyMissingSourceRecord(execution) {
     // Whether it paused or recorded a decline, the candidate list says whether there was a choice.
     return pendingData.availableRecordIds.length > 0 ? 'operator' : 'empty-source';
 }
+// The step a pin names: the latest Load Related Record with that id, because a loop repeats ids,
+// and only inside the frame when one is given, since step ids are unique only per workflow.
+function findPinnedLoadStep(previousSteps, stepId, frameStepIndexes) {
+    return previousSteps
+        .filter(step => step.stepDefinition.type === step_definition_1.StepType.LoadRelatedRecord &&
+        step.stepOutcome.stepId === stepId &&
+        (frameStepIndexes === undefined || frameStepIndexes.includes(step.stepOutcome.stepIndex)))
+        .at(-1);
+}
+// Every record a load-related-record execution loaded: one, several, or one per record it ran for.
+function loadedRecordsOf(execution) {
+    if ((0, step_execution_data_1.isPerRecordExecution)(execution)) {
+        return execution.iterations.flatMap(iteration => {
+            const result = iteration.executionResult;
+            return result && 'record' in result ? [result.record] : [];
+        });
+    }
+    if (execution?.type !== 'load-related-record' || execution.executionResult === undefined) {
+        return [];
+    }
+    const result = execution.executionResult;
+    if ('records' in result)
+        return result.records;
+    return 'record' in result ? [result.record] : [];
+}
 class RecordStepExecutor extends base_step_executor_1.default {
     buildOutcomeResult(outcome) {
         return {
@@ -81,20 +109,22 @@ class RecordStepExecutor extends base_step_executor_1.default {
         }
         return record;
     }
-    // Undefined on a miss so each caller names its own error, and the latest match because a loop
-    // repeats ids. A call's pin passes its frame, since step ids are unique only per workflow.
+    // Undefined on a miss so each caller names its own error. A call's pin passes its frame.
     async resolveStepRecordRef(stepId, frameStepIndexes) {
-        const matches = this.context.previousSteps.filter(step => step.stepDefinition.type === step_definition_1.StepType.LoadRelatedRecord &&
-            step.stepOutcome.stepId === stepId &&
-            (frameStepIndexes === undefined || frameStepIndexes.includes(step.stepOutcome.stepIndex)));
-        const sourceStep = matches[matches.length - 1];
+        const sourceStep = findPinnedLoadStep(this.context.previousSteps, stepId, frameStepIndexes);
         if (sourceStep) {
             const stepExecutions = await this.context.runStore.getStepExecutions(this.context.runId);
             const execution = this.resolveStepExecution(sourceStep, stepExecutions);
-            if (execution?.type === 'load-related-record' &&
-                execution.executionResult !== undefined &&
-                'record' in execution.executionResult) {
-                return execution.executionResult.record;
+            // A step that ran once per record keeps what it loaded in its iterations, not in a result.
+            if ((0, step_execution_data_1.isPerRecordExecution)(execution)) {
+                throw new errors_1.SourceLoadsSeveralRecordsError(sourceStep.stepDefinition.title);
+            }
+            const result = execution?.type === 'load-related-record' && execution.executionResult;
+            if (result && 'record' in result)
+                return result.record;
+            // A step's own pin on a Multiple step runs once per record, so only a call's pin gets here.
+            if (result && 'records' in result) {
+                throw new errors_1.SourceLoadsSeveralRecordsError(sourceStep.stepDefinition.title);
             }
             // The source step exists but loaded nothing → clear "no source record" message,
             // distinct from a config pointing at a non-existent step.
@@ -110,17 +140,9 @@ class RecordStepExecutor extends base_step_executor_1.default {
     // originalStepIndex.
     async getAvailableRecordRefs() {
         const stepExecutions = await this.context.runStore.getStepExecutions(this.context.runId);
-        const relatedRecords = this.context.previousSteps.flatMap(step => {
-            if (step.stepDefinition.type !== step_definition_1.StepType.LoadRelatedRecord)
-                return [];
-            const execution = this.resolveStepExecution(step, stepExecutions);
-            if (execution?.type === 'load-related-record' &&
-                execution.executionResult !== undefined &&
-                'record' in execution.executionResult) {
-                return [execution.executionResult.record];
-            }
-            return [];
-        });
+        const relatedRecords = this.context.previousSteps.flatMap(step => step.stepDefinition.type === step_definition_1.StepType.LoadRelatedRecord
+            ? loadedRecordsOf(this.resolveStepExecution(step, stepExecutions))
+            : []);
         return [this.context.baseRecordRef, ...relatedRecords];
     }
     getCollectionSchema(collectionName) {
@@ -181,4 +203,4 @@ class RecordStepExecutor extends base_step_executor_1.default {
     }
 }
 exports.default = RecordStepExecutor;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-step-executor.js","sourceRoot":"","sources":["../../src/executors/record-step-executor.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-step-executor.js","sourceRoot":"","sources":["../../src/executors/record-step-executor.ts"],"names":[],"mappings":"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"}

package/dist/executors/related-record-picker.d.ts

@@ -0,0 +1,21 @@
+import type { CollectionSchema, RecordData } from '../types/validated/collection';
+import type { BaseMessage } from '@forestadmin/ai-proxy';
+import { DynamicStructuredTool, SystemMessage } from '@forestadmin/ai-proxy';
+export interface PickerAi {
+    invoke<T>(messages: BaseMessage[], tool: DynamicStructuredTool): Promise<T>;
+    contextMessage: SystemMessage;
+    warn(message: string, context: Record<string, unknown>): void;
+}
+/** AI call 1 for HasMany: selects the most relevant fields to compare candidates. */
+export declare function selectRelevantFields(ai: PickerAi, schema: CollectionSchema, prompt: string | undefined): Promise<string[]>;
+/** AI call 2 for a Multiple step: picks every candidate relevant to the request. */
+export declare function selectRelevantRecordIndexes(ai: PickerAi, candidates: RecordData[], fieldNames: string[], prompt: string | undefined, collectionDisplayName: string): Promise<{
+    indexes: number[];
+    confident: boolean;
+    sawAll: boolean;
+}>;
+export declare function selectBestRecordIndex(ai: PickerAi, candidates: RecordData[], fieldNames: string[], prompt: string | undefined, allowNone?: boolean): Promise<{
+    index: number;
+    confident: boolean;
+}>;
+//# sourceMappingURL=related-record-picker.d.ts.map