@forestadmin/workflow-executor 1.0.0

package/dist/stores/build-run-store.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDatabaseRunStore = buildDatabaseRunStore;
+exports.buildInMemoryRunStore = buildInMemoryRunStore;
+const sequelize_1 = require("sequelize");
+const database_store_1 = __importDefault(require("./database-store"));
+const in_memory_store_1 = __importDefault(require("./in-memory-store"));
+async function buildDatabaseRunStore(options) {
+    const sequelize = new sequelize_1.Sequelize({ logging: false, ...options });
+    const store = new database_store_1.default({ sequelize });
+    try {
+        await store.init();
+    }
+    catch (error) {
+        await sequelize.close();
+        throw error;
+    }
+    return store;
+}
+async function buildInMemoryRunStore() {
+    const store = new in_memory_store_1.default();
+    await store.init();
+    return store;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtcnVuLXN0b3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0b3Jlcy9idWlsZC1ydW4tc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFRQSxzREFhQztBQUVELHNEQUtDO0FBekJELHlDQUFzQztBQUV0QyxzRUFBNkM7QUFDN0Msd0VBQThDO0FBRXZDLEtBQUssVUFBVSxxQkFBcUIsQ0FBQyxPQUFnQjtJQUMxRCxNQUFNLFNBQVMsR0FBRyxJQUFJLHFCQUFTLENBQUMsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUVoRSxNQUFNLEtBQUssR0FBRyxJQUFJLHdCQUFhLENBQUMsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBRS9DLElBQUksQ0FBQztRQUNILE1BQU0sS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsTUFBTSxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDeEIsTUFBTSxLQUFLLENBQUM7SUFDZCxDQUFDO0lBRUQsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBRU0sS0FBSyxVQUFVLHFCQUFxQjtJQUN6QyxNQUFNLEtBQUssR0FBRyxJQUFJLHlCQUFhLEVBQUUsQ0FBQztJQUNsQyxNQUFNLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUVuQixPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMifQ==

package/dist/stores/database-store.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from '../ports/logger-port';
+import type { RunStore } from '../ports/run-store';
+import type { StepExecutionData } from '../types/step-execution-data';
+import type { Sequelize } from 'sequelize';
+export interface DatabaseStoreOptions {
+    sequelize: Sequelize;
+}
+export default class DatabaseStore implements RunStore {
+    private readonly sequelize;
+    constructor(options: DatabaseStoreOptions);
+    init(logger?: Logger): Promise<void>;
+    getStepExecutions(runId: string): Promise<StepExecutionData[]>;
+    saveStepExecution(runId: string, stepExecution: StepExecutionData): Promise<void>;
+    close(logger?: Logger): Promise<void>;
+    private callPort;
+}
+//# sourceMappingURL=database-store.d.ts.map

package/dist/stores/database-store.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const umzug_1 = require("umzug");
+const errors_1 = require("../errors");
+const TABLE_NAME = 'workflow_step_executions';
+class DatabaseStore {
+    constructor(options) {
+        this.sequelize = options.sequelize;
+    }
+    async init(logger) {
+        const umzug = new umzug_1.Umzug({
+            migrations: [
+                {
+                    name: '001_create_workflow_step_executions',
+                    up: async ({ context }) => {
+                        await context.createTable(TABLE_NAME, {
+                            id: {
+                                type: sequelize_1.DataTypes.INTEGER,
+                                primaryKey: true,
+                                autoIncrement: true,
+                            },
+                            runId: {
+                                type: sequelize_1.DataTypes.STRING(255),
+                                allowNull: false,
+                                field: 'run_id',
+                            },
+                            stepIndex: {
+                                type: sequelize_1.DataTypes.INTEGER,
+                                allowNull: false,
+                                field: 'step_index',
+                            },
+                            data: {
+                                type: sequelize_1.DataTypes.JSON,
+                                allowNull: false,
+                            },
+                            createdAt: {
+                                type: sequelize_1.DataTypes.DATE,
+                                allowNull: false,
+                                defaultValue: sequelize_1.DataTypes.NOW,
+                                field: 'created_at',
+                            },
+                            updatedAt: {
+                                type: sequelize_1.DataTypes.DATE,
+                                allowNull: false,
+                                defaultValue: sequelize_1.DataTypes.NOW,
+                                field: 'updated_at',
+                            },
+                        });
+                        await context.addIndex(TABLE_NAME, ['run_id'], { name: 'idx_run_id' });
+                        await context.addIndex(TABLE_NAME, ['run_id', 'step_index'], {
+                            unique: true,
+                            name: 'idx_run_id_step_index',
+                        });
+                    },
+                    down: async ({ context }) => {
+                        await context.dropTable(TABLE_NAME);
+                    },
+                },
+            ],
+            context: this.sequelize.getQueryInterface(),
+            storage: new umzug_1.SequelizeStorage({ sequelize: this.sequelize }),
+            logger: undefined,
+        });
+        return this.callPort('init', async () => {
+            try {
+                await umzug.up();
+            }
+            catch (error) {
+                logger?.error('Database migration failed', {
+                    error: (0, errors_1.extractErrorMessage)(error),
+                });
+                throw error;
+            }
+        });
+    }
+    async getStepExecutions(runId) {
+        return this.callPort('getStepExecutions', async () => {
+            const [rows] = await this.sequelize.query(`SELECT data FROM ${TABLE_NAME} WHERE run_id = :runId ORDER BY step_index ASC`, { replacements: { runId } });
+            return rows.map(row => typeof row.data === 'string' ? JSON.parse(row.data) : row.data);
+        });
+    }
+    async saveStepExecution(runId, stepExecution) {
+        return this.callPort('saveStepExecution', async () => {
+            await this.sequelize.transaction(async (transaction) => {
+                const now = new Date();
+                const data = JSON.stringify(stepExecution);
+                const replacements = { runId, stepIndex: stepExecution.stepIndex, data, now };
+                // Delete + insert in transaction: dialect-agnostic upsert (avoids ON CONFLICT / ON DUPLICATE)
+                await this.sequelize.query(`DELETE FROM ${TABLE_NAME} WHERE run_id = :runId AND step_index = :stepIndex`, { replacements, transaction });
+                await this.sequelize.query(`INSERT INTO ${TABLE_NAME} (run_id, step_index, data, created_at, updated_at) VALUES (:runId, :stepIndex, :data, :now, :now)`, { replacements, transaction });
+            });
+        });
+    }
+    async close(logger) {
+        return this.callPort('close', async () => {
+            try {
+                await this.sequelize.close();
+            }
+            catch (error) {
+                logger?.error('Failed to close database connection', {
+                    error: (0, errors_1.extractErrorMessage)(error),
+                });
+            }
+        });
+    }
+    async callPort(operation, fn) {
+        try {
+            return await fn();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.RunStorePortError(operation, cause);
+        }
+    }
+}
+exports.default = DatabaseStore;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2Utc3RvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RvcmVzL2RhdGFiYXNlLXN0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBS0EseUNBQXNDO0FBQ3RDLGlDQUFnRDtBQUVoRCxzQ0FBMEY7QUFFMUYsTUFBTSxVQUFVLEdBQUcsMEJBQTBCLENBQUM7QUFNOUMsTUFBcUIsYUFBYTtJQUdoQyxZQUFZLE9BQTZCO1FBQ3ZDLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQztJQUNyQyxDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFlO1FBQ3hCLE1BQU0sS0FBSyxHQUFHLElBQUksYUFBSyxDQUFDO1lBQ3RCLFVBQVUsRUFBRTtnQkFDVjtvQkFDRSxJQUFJLEVBQUUscUNBQXFDO29CQUMzQyxFQUFFLEVBQUUsS0FBSyxFQUFFLEVBQUUsT0FBTyxFQUErQixFQUFFLEVBQUU7d0JBQ3JELE1BQU0sT0FBTyxDQUFDLFdBQVcsQ0FBQyxVQUFVLEVBQUU7NEJBQ3BDLEVBQUUsRUFBRTtnQ0FDRixJQUFJLEVBQUUscUJBQVMsQ0FBQyxPQUFPO2dDQUN2QixVQUFVLEVBQUUsSUFBSTtnQ0FDaEIsYUFBYSxFQUFFLElBQUk7NkJBQ3BCOzRCQUNELEtBQUssRUFBRTtnQ0FDTCxJQUFJLEVBQUUscUJBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDO2dDQUMzQixTQUFTLEVBQUUsS0FBSztnQ0FDaEIsS0FBSyxFQUFFLFFBQVE7NkJBQ2hCOzRCQUNELFNBQVMsRUFBRTtnQ0FDVCxJQUFJLEVBQUUscUJBQVMsQ0FBQyxPQUFPO2dDQUN2QixTQUFTLEVBQUUsS0FBSztnQ0FDaEIsS0FBSyxFQUFFLFlBQVk7NkJBQ3BCOzRCQUNELElBQUksRUFBRTtnQ0FDSixJQUFJLEVBQUUscUJBQVMsQ0FBQyxJQUFJO2dDQUNwQixTQUFTLEVBQUUsS0FBSzs2QkFDakI7NEJBQ0QsU0FBUyxFQUFFO2dDQUNULElBQUksRUFBRSxxQkFBUyxDQUFDLElBQUk7Z0NBQ3BCLFNBQVMsRUFBRSxLQUFLO2dDQUNoQixZQUFZLEVBQUUscUJBQVMsQ0FBQyxHQUFHO2dDQUMzQixLQUFLLEVBQUUsWUFBWTs2QkFDcEI7NEJBQ0QsU0FBUyxFQUFFO2dDQUNULElBQUksRUFBRSxxQkFBUyxDQUFDLElBQUk7Z0NBQ3BCLFNBQVMsRUFBRSxLQUFLO2dDQUNoQixZQUFZLEVBQUUscUJBQVMsQ0FBQyxHQUFHO2dDQUMzQixLQUFLLEVBQUUsWUFBWTs2QkFDcEI7eUJBQ0YsQ0FBQyxDQUFDO3dCQUVILE1BQU0sT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxRQUFRLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsQ0FBQyxDQUFDO3dCQUN2RSxNQUFNLE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLENBQUMsUUFBUSxFQUFFLFlBQVksQ0FBQyxFQUFFOzRCQUMzRCxNQUFNLEVBQUUsSUFBSTs0QkFDWixJQUFJLEVBQUUsdUJBQXVCO3lCQUM5QixDQUFDLENBQUM7b0JBQ0wsQ0FBQztvQkFDRCxJQUFJLEVBQUUsS0FBSyxFQUFFLEVBQUUsT0FBTyxFQUErQixFQUFFLEVBQUU7d0JBQ3ZELE1BQU0sT0FBTyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQztvQkFDdEMsQ0FBQztpQkFDRjthQUNGO1lBQ0QsT0FBTyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsaUJBQWlCLEVBQUU7WUFDM0MsT0FBTyxFQUFFLElBQUksd0JBQWdCLENBQUMsRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQzVELE1BQU0sRUFBRSxTQUFTO1NBQ2xCLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDdEMsSUFBSSxDQUFDO2dCQUNILE1BQU0sS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDO1lBQ25CLENBQUM7WUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUNmLE1BQU0sRUFBRSxLQUFLLENBQUMsMkJBQTJCLEVBQUU7b0JBQ3pDLEtBQUssRUFBRSxJQUFBLDRCQUFtQixFQUFDLEtBQUssQ0FBQztpQkFDbEMsQ0FBQyxDQUFDO2dCQUNILE1BQU0sS0FBSyxDQUFDO1lBQ2QsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxLQUFhO1FBQ25DLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsRUFBRSxLQUFLLElBQUksRUFBRTtZQUNuRCxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FDdkMsb0JBQW9CLFVBQVUsZ0RBQWdELEVBQzlFLEVBQUUsWUFBWSxFQUFFLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FDNUIsQ0FBQztZQUVGLE9BQVEsSUFBb0QsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FDckUsT0FBTyxHQUFHLENBQUMsSUFBSSxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQy9ELENBQUM7UUFDSixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxLQUFLLENBQUMsaUJBQWlCLENBQUMsS0FBYSxFQUFFLGFBQWdDO1FBQ3JFLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsRUFBRSxLQUFLLElBQUksRUFBRTtZQUNuRCxNQUFNLElBQUksQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBQyxXQUFXLEVBQUMsRUFBRTtnQkFDbkQsTUFBTSxHQUFHLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQztnQkFDdkIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsQ0FBQztnQkFDM0MsTUFBTSxZQUFZLEdBQUcsRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLGFBQWEsQ0FBQyxTQUFTLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDO2dCQUU5RSw4RkFBOEY7Z0JBQzlGLE1BQU0sSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQ3hCLGVBQWUsVUFBVSxvREFBb0QsRUFDN0UsRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLENBQzlCLENBQUM7Z0JBQ0YsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FDeEIsZUFBZSxVQUFVLG9HQUFvRyxFQUM3SCxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsQ0FDOUIsQ0FBQztZQUNKLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUssQ0FBQyxNQUFlO1FBQ3pCLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDdkMsSUFBSSxDQUFDO2dCQUNILE1BQU0sSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUMvQixDQUFDO1lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztnQkFDZixNQUFNLEVBQUUsS0FBSyxDQUFDLHFDQUFxQyxFQUFFO29CQUNuRCxLQUFLLEVBQUUsSUFBQSw0QkFBbUIsRUFBQyxLQUFLLENBQUM7aUJBQ2xDLENBQUMsQ0FBQztZQUNMLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxLQUFLLENBQUMsUUFBUSxDQUFJLFNBQWlCLEVBQUUsRUFBb0I7UUFDL0QsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsSUFBSSxLQUFLLFlBQVksOEJBQXFCO2dCQUFFLE1BQU0sS0FBSyxDQUFDO1lBQ3hELE1BQU0sSUFBSSwwQkFBaUIsQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDaEQsQ0FBQztJQUNILENBQUM7Q0FDRjtBQWhJRCxnQ0FnSUMifQ==

package/dist/stores/in-memory-store.d.ts

@@ -0,0 +1,11 @@
+import type { RunStore } from '../ports/run-store';
+import type { StepExecutionData } from '../types/step-execution-data';
+export default class InMemoryStore implements RunStore {
+    private readonly data;
+    init(): Promise<void>;
+    close(): Promise<void>;
+    getStepExecutions(runId: string): Promise<StepExecutionData[]>;
+    saveStepExecution(runId: string, stepExecution: StepExecutionData): Promise<void>;
+    private callPort;
+}
+//# sourceMappingURL=in-memory-store.d.ts.map

package/dist/stores/in-memory-store.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+class InMemoryStore {
+    constructor() {
+        this.data = new Map();
+    }
+    async init() {
+        return this.callPort('init', async () => {
+            // No-op: in-memory store requires no initialization
+        });
+    }
+    async close() {
+        return this.callPort('close', async () => {
+            // No-op: nothing to clean up
+        });
+    }
+    async getStepExecutions(runId) {
+        return this.callPort('getStepExecutions', async () => {
+            const runData = this.data.get(runId);
+            if (!runData)
+                return [];
+            return [...runData.values()].sort((a, b) => a.stepIndex - b.stepIndex);
+        });
+    }
+    async saveStepExecution(runId, stepExecution) {
+        return this.callPort('saveStepExecution', async () => {
+            let runData = this.data.get(runId);
+            if (!runData) {
+                runData = new Map();
+                this.data.set(runId, runData);
+            }
+            runData.set(stepExecution.stepIndex, stepExecution);
+        });
+    }
+    async callPort(operation, fn) {
+        try {
+            return await fn();
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.WorkflowExecutorError)
+                throw cause;
+            throw new errors_1.RunStorePortError(operation, cause);
+        }
+    }
+}
+exports.default = InMemoryStore;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW4tbWVtb3J5LXN0b3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0b3Jlcy9pbi1tZW1vcnktc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxzQ0FBcUU7QUFFckUsTUFBcUIsYUFBYTtJQUFsQztRQUNtQixTQUFJLEdBQUcsSUFBSSxHQUFHLEVBQTBDLENBQUM7SUE2QzVFLENBQUM7SUEzQ0MsS0FBSyxDQUFDLElBQUk7UUFDUixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLEtBQUssSUFBSSxFQUFFO1lBQ3RDLG9EQUFvRDtRQUN0RCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxLQUFLLENBQUMsS0FBSztRQUNULE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDdkMsNkJBQTZCO1FBQy9CLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxLQUFhO1FBQ25DLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsRUFBRSxLQUFLLElBQUksRUFBRTtZQUNuRCxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUVyQyxJQUFJLENBQUMsT0FBTztnQkFBRSxPQUFPLEVBQUUsQ0FBQztZQUV4QixPQUFPLENBQUMsR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxHQUFHLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUN6RSxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxLQUFLLENBQUMsaUJBQWlCLENBQUMsS0FBYSxFQUFFLGFBQWdDO1FBQ3JFLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsRUFBRSxLQUFLLElBQUksRUFBRTtZQUNuRCxJQUFJLE9BQU8sR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUVuQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQ2IsT0FBTyxHQUFHLElBQUksR0FBRyxFQUFFLENBQUM7Z0JBQ3BCLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FBQztZQUNoQyxDQUFDO1lBRUQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsU0FBUyxFQUFFLGFBQWEsQ0FBQyxDQUFDO1FBQ3RELENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLEtBQUssQ0FBQyxRQUFRLENBQUksU0FBaUIsRUFBRSxFQUFvQjtRQUMvRCxJQUFJLENBQUM7WUFDSCxPQUFPLE1BQU0sRUFBRSxFQUFFLENBQUM7UUFDcEIsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixJQUFJLEtBQUssWUFBWSw4QkFBcUI7Z0JBQUUsTUFBTSxLQUFLLENBQUM7WUFDeEQsTUFBTSxJQUFJLDBCQUFpQixDQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNoRCxDQUFDO0lBQ0gsQ0FBQztDQUNGO0FBOUNELGdDQThDQyJ9

package/dist/types/execution-context.d.ts

@@ -0,0 +1,37 @@
+import type ActivityLog from '../executors/activity-log';
+import type AgentWithLog from '../executors/agent-with-log';
+import type { Logger } from '../ports/logger-port';
+import type { RunStore } from '../ports/run-store';
+import type SchemaResolver from '../schema-resolver';
+import type { RecordRef } from './validated/collection';
+import type { AvailableStepExecution, Step, StepUser } from './validated/execution';
+import type { StepDefinition } from './validated/step-definition';
+import type { StepOutcome } from './validated/step-outcome';
+import type { BaseChatModel } from '@forestadmin/ai-proxy';
+export type { AvailableStepExecution, Step, StepUser };
+export interface StepExecutionResult {
+    stepOutcome: StepOutcome;
+}
+export interface IStepExecutor {
+    execute(): Promise<StepExecutionResult>;
+}
+export interface ExecutionContext<TStep extends StepDefinition = StepDefinition> {
+    readonly runId: string;
+    readonly stepId: string;
+    readonly stepIndex: number;
+    readonly collectionId: string;
+    readonly baseRecordRef: RecordRef;
+    readonly stepDefinition: TStep;
+    readonly model: BaseChatModel;
+    readonly agent: AgentWithLog;
+    readonly activityLog: ActivityLog;
+    readonly runStore: RunStore;
+    readonly user: StepUser;
+    readonly schemaResolver: SchemaResolver;
+    readonly previousSteps: ReadonlyArray<Readonly<Step>>;
+    readonly logger: Logger;
+    readonly incomingPendingData?: unknown;
+    readonly stepTimeoutMs?: number;
+    readonly aiInvokeTimeoutMs?: number;
+}
+//# sourceMappingURL=execution-context.d.ts.map

package/dist/types/execution-context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlY3V0aW9uLWNvbnRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvZXhlY3V0aW9uLWNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/types/step-execution-data.d.ts

@@ -0,0 +1,137 @@
+import type { RecordId, RecordRef } from './validated/collection';
+import type { LoadRelatedRecordConfirmation, McpConfirmation, TriggerActionConfirmation, UpdateRecordConfirmation } from '../http/pending-data-validators';
+interface BaseStepExecutionData {
+    stepIndex: number;
+}
+interface MutatingStepExecutionData extends BaseStepExecutionData {
+    idempotencyPhase?: 'executing' | 'done';
+}
+export interface WithUserConfirmation<T extends Record<string, unknown> = Record<string, unknown>> {
+    userConfirmation?: T;
+}
+export interface ConditionStepExecutionData extends BaseStepExecutionData {
+    type: 'condition';
+    executionParams: {
+        answer: string | null;
+        reasoning?: string;
+    };
+    executionResult?: {
+        answer: string;
+    };
+}
+export interface FieldRef {
+    name: string;
+    displayName: string;
+}
+export type FieldWithValue = FieldRef & {
+    value: unknown;
+};
+export interface FieldReadSuccess extends FieldRef {
+    value: unknown;
+}
+export interface FieldReadError extends FieldRef {
+    error: string;
+}
+export type FieldReadResult = FieldReadSuccess | FieldReadError;
+export interface ReadRecordStepExecutionData extends BaseStepExecutionData {
+    type: 'read-record';
+    executionParams: {
+        fields: FieldRef[];
+    };
+    executionResult: {
+        fields: FieldReadResult[];
+    };
+    selectedRecordRef: RecordRef;
+}
+export interface UpdateRecordStepExecutionData extends MutatingStepExecutionData, WithUserConfirmation<UpdateRecordConfirmation> {
+    type: 'update-record';
+    executionParams?: FieldWithValue;
+    executionResult?: {
+        updatedValues: Record<string, unknown>;
+    } | {
+        skipped: true;
+    };
+    pendingData?: FieldWithValue;
+    selectedRecordRef: RecordRef;
+}
+export interface ActionRef {
+    name: string;
+    displayName: string;
+}
+export interface RelationRef {
+    name: string;
+    displayName: string;
+}
+export interface TriggerRecordActionStepExecutionData extends MutatingStepExecutionData, WithUserConfirmation<TriggerActionConfirmation> {
+    type: 'trigger-action';
+    executionParams?: ActionRef;
+    executionResult?: {
+        success: true;
+        actionResult: unknown;
+    } | {
+        skipped: true;
+    };
+    pendingData?: ActionRef;
+    selectedRecordRef: RecordRef;
+}
+export interface McpToolRef {
+    name: string;
+    sourceId: string;
+}
+export interface McpToolCall extends McpToolRef {
+    input: Record<string, unknown>;
+}
+export interface McpStepExecutionData extends MutatingStepExecutionData, WithUserConfirmation<McpConfirmation> {
+    type: 'mcp';
+    executionParams?: McpToolCall;
+    executionResult?: {
+        success: true;
+        toolResult: unknown;
+        formattedResponse?: string;
+    } | {
+        skipped: true;
+    };
+    pendingData?: McpToolCall;
+}
+export interface RecordStepExecutionData extends BaseStepExecutionData {
+    type: 'record';
+    executionParams?: Record<string, unknown>;
+    executionResult?: Record<string, unknown>;
+    toolConfirmationInterruption?: Record<string, unknown>;
+}
+export interface LoadRelatedRecordCandidate {
+    recordId: RecordId;
+    referenceFieldValue: string | null;
+}
+export interface LoadRelatedRecordPendingData {
+    availableFields: RelationRef[];
+    suggestedField: RelationRef;
+    availableRecordIds: LoadRelatedRecordCandidate[];
+    suggestedRecord?: LoadRelatedRecordCandidate;
+}
+export interface LoadRelatedRecordStepExecutionData extends BaseStepExecutionData, WithUserConfirmation<LoadRelatedRecordConfirmation> {
+    type: 'load-related-record';
+    pendingData?: LoadRelatedRecordPendingData;
+    selectedRecordRef: RecordRef;
+    executionParams?: RelationRef;
+    executionResult?: {
+        relation: RelationRef;
+        record: RecordRef;
+    } | {
+        skipped: true;
+    };
+}
+export interface GuidanceStepExecutionData extends BaseStepExecutionData {
+    type: 'guidance';
+    pendingData?: {
+        userInput?: string;
+    };
+    executionResult?: {
+        userInput?: string;
+    };
+}
+export type ConfirmableStepExecutionData = UpdateRecordStepExecutionData | TriggerRecordActionStepExecutionData | McpStepExecutionData | LoadRelatedRecordStepExecutionData;
+export type StepExecutionData = ConditionStepExecutionData | ReadRecordStepExecutionData | UpdateRecordStepExecutionData | TriggerRecordActionStepExecutionData | RecordStepExecutionData | LoadRelatedRecordStepExecutionData | McpStepExecutionData | GuidanceStepExecutionData;
+export type ExecutedStepExecutionData = StepExecutionData;
+export {};
+//# sourceMappingURL=step-execution-data.d.ts.map

package/dist/types/step-execution-data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcC1leGVjdXRpb24tZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9zdGVwLWV4ZWN1dGlvbi1kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/types/validated/collection.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+export declare const PRIMITIVE_TYPES: readonly ["Boolean", "Binary", "Date", "Dateonly", "Enum", "File", "Json", "Number", "Point", "String", "Time", "Timeonly", "Uuid"];
+export type PrimitiveType = (typeof PRIMITIVE_TYPES)[number];
+export declare const FieldSchemaSchema: z.ZodObject<{
+    fieldName: z.ZodString;
+    displayName: z.ZodString;
+    isRelationship: z.ZodBoolean;
+    relationType: z.ZodOptional<z.ZodEnum<{
+        BelongsTo: "BelongsTo";
+        HasMany: "HasMany";
+        HasOne: "HasOne";
+        BelongsToMany: "BelongsToMany";
+    }>>;
+    relatedCollectionName: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>;
+    enumValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type FieldSchema = z.infer<typeof FieldSchemaSchema>;
+export declare const ActionSchemaSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    endpoint: z.ZodString;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+    hooks: z.ZodOptional<z.ZodObject<{
+        load: z.ZodBoolean;
+        change: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ActionSchema = z.infer<typeof ActionSchemaSchema>;
+export declare const CollectionSchemaSchema: z.ZodPipe<z.ZodObject<{
+    collectionName: z.ZodString;
+    collectionId: z.ZodString;
+    collectionDisplayName: z.ZodNullable<z.ZodString>;
+    primaryKeyFields: z.ZodArray<z.ZodString>;
+    referenceField: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fields: z.ZodArray<z.ZodObject<{
+        fieldName: z.ZodString;
+        displayName: z.ZodString;
+        isRelationship: z.ZodBoolean;
+        relationType: z.ZodOptional<z.ZodEnum<{
+            BelongsTo: "BelongsTo";
+            HasMany: "HasMany";
+            HasOne: "HasOne";
+            BelongsToMany: "BelongsToMany";
+        }>>;
+        relatedCollectionName: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodNullable<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>;
+        enumValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    actions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        displayName: z.ZodString;
+        endpoint: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+        hooks: z.ZodOptional<z.ZodObject<{
+            load: z.ZodBoolean;
+            change: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    collectionDisplayName: string;
+    collectionName: string;
+    collectionId: string;
+    primaryKeyFields: string[];
+    fields: {
+        fieldName: string;
+        displayName: string;
+        isRelationship: boolean;
+        relationType?: "BelongsTo" | "HasMany" | "HasOne" | "BelongsToMany";
+        relatedCollectionName?: string;
+        type?: any;
+        enumValues?: string[];
+    }[];
+    actions: {
+        name: string;
+        displayName: string;
+        endpoint: string;
+        fields?: {
+            [x: string]: unknown;
+        }[];
+        hooks?: {
+            load: boolean;
+            change: unknown[];
+        };
+    }[];
+    referenceField?: string;
+}, {
+    collectionName: string;
+    collectionId: string;
+    primaryKeyFields: string[];
+    fields: {
+        fieldName: string;
+        displayName: string;
+        isRelationship: boolean;
+        relationType?: "BelongsTo" | "HasMany" | "HasOne" | "BelongsToMany";
+        relatedCollectionName?: string;
+        type?: any;
+        enumValues?: string[];
+    }[];
+    actions: {
+        name: string;
+        displayName: string;
+        endpoint: string;
+        fields?: {
+            [x: string]: unknown;
+        }[];
+        hooks?: {
+            load: boolean;
+            change: unknown[];
+        };
+    }[];
+    collectionDisplayName?: string;
+    referenceField?: string;
+}>>;
+export type CollectionSchema = z.infer<typeof CollectionSchemaSchema>;
+export declare const RecordRefSchema: z.ZodObject<{
+    collectionName: z.ZodString;
+    recordId: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    stepIndex: z.ZodNumber;
+}, z.core.$strict>;
+export type RecordRef = z.infer<typeof RecordRefSchema>;
+export type RecordId = RecordRef['recordId'];
+export type RecordData = Omit<RecordRef, 'stepIndex'> & {
+    values: Record<string, unknown>;
+};
+//# sourceMappingURL=collection.d.ts.map

package/dist/types/validated/collection.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordRefSchema = exports.CollectionSchemaSchema = exports.ActionSchemaSchema = exports.FieldSchemaSchema = exports.PRIMITIVE_TYPES = void 0;
+const zod_1 = require("zod");
+// -- Schema types (structure of a collection — source: WorkflowPort) --
+//
+// These schemas (Field/Action/Collection) come from the orchestrator, which deploys independently
+// and evolves this contract over time. They intentionally omit `.strict()` so unknown keys are
+// stripped, not rejected, and require only structural fields — step-specific props are optional and
+// asserted at use-time by the consuming executor. Don't re-add `.strict()` here.
+// Mirrors PrimitiveTypes from @forestadmin/datasource-toolkit — kept local to avoid
+// adding a hard dependency on datasource-toolkit from the executor package.
+exports.PRIMITIVE_TYPES = [
+    'Boolean',
+    'Binary',
+    'Date',
+    'Dateonly',
+    'Enum',
+    'File',
+    'Json',
+    'Number',
+    'Point',
+    'String',
+    'Time',
+    'Timeonly',
+    'Uuid',
+];
+// Mirrors ColumnType = PrimitiveTypes | [ColumnType] | { [key: string]: ColumnType }.
+// The orchestrator additionally serializes composite types as { fields: [{ field, type }] }
+// (array-of-entries wire form) — accepted here and normalized to the native record shape.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ColumnTypeSchema = zod_1.z.lazy(() => zod_1.z.union([
+    zod_1.z.enum(exports.PRIMITIVE_TYPES),
+    zod_1.z.tuple([ColumnTypeSchema]),
+    zod_1.z.record(zod_1.z.string(), ColumnTypeSchema),
+    zod_1.z
+        .object({
+        fields: zod_1.z.array(zod_1.z.object({ field: zod_1.z.string(), type: ColumnTypeSchema })),
+    })
+        .transform(obj => Object.fromEntries(obj.fields.map(f => [f.field, f.type]))),
+]));
+exports.FieldSchemaSchema = zod_1.z.object({
+    fieldName: zod_1.z.string().min(1),
+    displayName: zod_1.z.string().min(1),
+    isRelationship: zod_1.z.boolean(),
+    relationType: zod_1.z.enum(['BelongsTo', 'HasMany', 'HasOne', 'BelongsToMany']).optional(),
+    relatedCollectionName: zod_1.z.string().optional(),
+    type: ColumnTypeSchema.nullable().optional(),
+    enumValues: zod_1.z.array(zod_1.z.string()).min(1).optional(),
+});
+// ActionSchema.fields / hooks content is a discriminated union owned by the upstream
+// `@forestadmin/forestadmin-client` lib and consumed downstream by `@forestadmin/agent-client`.
+// We validate the envelope shape only — detail re-validation would duplicate the lib's job.
+const ActionFieldsSchema = zod_1.z.array(zod_1.z.looseObject({})).optional();
+const ActionHooksSchema = zod_1.z
+    .object({
+    load: zod_1.z.boolean(),
+    change: zod_1.z.array(zod_1.z.unknown()),
+})
+    .optional();
+exports.ActionSchemaSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    displayName: zod_1.z.string().min(1),
+    endpoint: zod_1.z.string().min(1),
+    /** Static form fields. Used as fallback when the agent's /hooks/load route 404s (old Ruby agents). */
+    fields: ActionFieldsSchema,
+    /** Action lifecycle hooks. Drives agent-client's dynamic form loading. */
+    hooks: ActionHooksSchema,
+});
+exports.CollectionSchemaSchema = zod_1.z
+    .object({
+    collectionName: zod_1.z.string().min(1),
+    collectionId: zod_1.z.string().min(1),
+    // null when the rendering has no explicit displayName configured — normalized to collectionName.
+    collectionDisplayName: zod_1.z.string().nullable(),
+    primaryKeyFields: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    // Layout-level "reference field" used to display a record (e.g. "name", "title").
+    // Null when the team didn't configure one; callers fall back to the primary key.
+    referenceField: zod_1.z.string().nullable().optional(),
+    fields: zod_1.z.array(exports.FieldSchemaSchema),
+    actions: zod_1.z.array(exports.ActionSchemaSchema).optional().default([]),
+})
+    .transform(data => ({
+    ...data,
+    collectionDisplayName: data.collectionDisplayName || data.collectionName,
+}));
+// -- Record types (data — source: AgentPort/RunStore) --
+exports.RecordRefSchema = zod_1.z
+    .object({
+    collectionName: zod_1.z.string().min(1),
+    recordId: zod_1.z.array(zod_1.z.union([zod_1.z.string().min(1), zod_1.z.number()])).min(1),
+    // Index of the workflow step that loaded this record.
+    stepIndex: zod_1.z.number().int().nonnegative(),
+})
+    .strict();
+//# sourceMappingURL=data:application/json;base64,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