@protobase/server 0.67.10 → 0.67.12

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.67.10";
+var version = "0.67.12";
 //#endregion
 export { version };

package/dist/workflows/input-limits.js

@@ -12,11 +12,13 @@ const checkRunInput = (input) => {
 };
 /**
 * The same limits on a run's input as the API sent it, before the body is validated, whose walk of a deeply nested
-* value would overflow the call stack.
+* value would overflow the call stack; a re-run takes the input of the run it re-runs, so it is given none.
 */
 const runInputCheck = async ({ resource, operation, body }) => {
 	if (resource !== "workflow_runs" || operation !== "create" || typeof body !== "object" || body === null) return;
-	checkRunInput(body.input);
+	const { input, rerun_of } = body;
+	if (rerun_of != null && input != null) throw badRequest("rerun-input", "A re-run runs on the input of the run it re-runs: give it no input");
+	checkRunInput(input);
 };
 //#endregion
 export { checkRunInput, runInputCheck };

package/dist/workflows/mcp/workflow-read-tools.js

@@ -121,6 +121,8 @@ const runFields = [
 	"id",
 	"workflow_id",
 	"version",
+	"rerun_of",
+	"started_by",
 	"status",
 	"input",
 	"output",

package/dist/workflows/mcp/workflow-write-tools.js

@@ -108,12 +108,16 @@ const updateWorkflowTool = (input = {}) => defineTool({
 /** Starts a run of a workflow with an input once the user approves it. */
 const runWorkflowTool = (input = {}) => defineTool({
 	name: "run_workflow",
-	description: `Starts a run of a workflow's current version with an input, which its states read as $states.context.Execution.Input, and returns JSON { run_id, status }. The run goes on in the background, doing what its steps do (requests, mail, record writes) as the workflow's last editor: read it with get_workflow_run until its status is succeeded or failed. The user approves each run in their client first.${onlyNote(input)}`,
+	description: `Starts a run of a workflow's current version with an input, which its states read as $states.context.Execution.Input, and returns JSON { run_id, status }. With rerun_of, the id of a failed run of the workflow, it re-runs that run instead: on its input, keeping the steps before the one that failed, and going on from that step on the current version, so fix the workflow first. The run goes on in the background, doing what its steps do (requests, mail, record writes) as the workflow's last editor: read it with get_workflow_run until its status is succeeded or failed. The user approves each run in their client first.${onlyNote(input)}`,
 	parameters: {
 		type: "object",
 		properties: {
 			id: idParameter,
-			input: { description: "The run's input, any JSON value, at most 1 MiB; an empty object by default." }
+			input: { description: "The run's input, any JSON value, at most 1 MiB; an empty object by default. Not with rerun_of." },
+			rerun_of: {
+				type: "string",
+				description: "The id of a failed run of this workflow to re-run from its failed step."
+			}
 		},
 		required: ["id"]
 	},
@@ -126,7 +130,12 @@ const runWorkflowTool = (input = {}) => defineTool({
 		if (!id) return "Pass { \"id\": \"<id>\", \"input\": { ... } }.";
 		const refusal = outside(input, "workflow_runs");
 		if (refusal) return refusal;
-		const data = {
+		const rerun = textOf(args.rerun_of);
+		if (rerun && args.input !== void 0) return "A re-run runs on the input of the run it re-runs: pass rerun_of without input.";
+		const data = rerun ? {
+			workflow_id: id,
+			rerun_of: rerun
+		} : {
 			workflow_id: id,
 			input: args.input ?? {}
 		};

package/dist/workflows/rerun.js

@@ -0,0 +1,36 @@
+import { badRequest, notFound } from "../problem.js";
+import { requestAccess, requireOperation } from "../request-access.js";
+import { deletedRows } from "../params.js";
+import { fetchReadable } from "../fetch-readable.js";
+import { sql } from "kysely";
+import { rerunSteps } from "@protobase/workflows";
+//#region src/workflows/rerun.ts
+/**
+* Starts a re-run where the failed run it re-runs left off: refuses a run the caller cannot read (404), one of another
+* workflow and one that did not fail, and copies the steps a re-run keeps to the new run, in one statement, so the
+* runner takes it up after them on the workflow's version now. The table's trigger gave it the earlier run's input.
+*/
+const keepEarlierSteps = async (trx, deps, schema, event) => {
+	const run = String(event.after.id);
+	const earlier = String(event.after.rerun_of);
+	const access = await requestAccess(deps, deps.registry.find("workflow_runs"), {
+		user: event.user,
+		...event.tenant !== void 0 && { tenant: event.tenant }
+	});
+	requireOperation(access, "read");
+	const found = await fetchReadable(trx, access, [earlier], deletedRows(access.full, false), { fields: [access.full.fields.workflow_id, access.full.fields.status] });
+	if (!found || found.record.workflow_id !== event.after.workflow_id) throw notFound("No run of this workflow to re-run with this key");
+	if (found.record.status !== "failed") throw badRequest("run-not-failed", `Only a failed run is re-run; this one is ${String(found.record.status)}`);
+	const { rows: versions } = await sql`select v.definition from ${sql.id(schema, "runs")} r
+    join ${sql.id(schema, "versions")} v on v.workflow_id = r.workflow_id and v.version = r.version where r.id = ${run}`.execute(trx);
+	const steps = sql.id(schema, "steps");
+	const { rows } = await sql`select id, scope, seq, state, status, next from ${steps} where run_id = ${earlier}`.execute(trx);
+	const kept = rerunSteps(versions[0].definition.stateMachine, rows);
+	if ("problem" in kept) throw badRequest("rerun-refused", `The run cannot be re-run on the workflow as it is now: ${kept.problem}`);
+	if (kept.steps.length === 0) return;
+	const columns = sql.raw("scope, seq, state, type, status, attempt, input, output, assigned, next, resume_at, error, cause, logs, started_at, finished_at");
+	await sql`insert into ${steps} (run_id, tenant_id, ${columns}) select ${run}, tenant_id, ${columns} from ${steps}
+    where id in (${sql.join(kept.steps.map((step) => step.id))})`.execute(trx);
+};
+//#endregion
+export { keepEarlierSteps };

package/dist/workflows/save-hook.js

@@ -1,18 +1,37 @@
 import { badRequest } from "../problem.js";
+import { requiredStepInputs } from "@protobase/schema/internal";
 import { sql } from "kysely";
 import { checkDefinition, problemText } from "@protobase/workflows";
 //#region src/workflows/save-hook.ts
 /**
 * Checks a workflow's definition on every save that changes it, against the language's schema and the named-reads
 * profile, with the step types the app has, and keeps it as the version the table's trigger numbered, saved by the
-* caller. A refusal is a 400 problem naming each state and field, also listed as `problems`; the write rolls back.
+* caller. A refusal is a 400 problem naming each state and field, also listed as `problems`, and as the `definition`
+* field's `errors` with the state and field in their `params`, for a form to show each on its step; the write rolls back.
 */
 const workflowSaveHook = (schema, stepTypes) => async (event, trx) => {
 	if (event.resource.name !== "workflows" || !event.after) return;
 	if (event.operation !== "create" && event.operation !== "update") return;
 	if (event.operation === "update" && event.after.version === event.before?.version) return;
-	const problems = checkDefinition(event.after.definition, { resources: stepTypes });
-	if (problems.length > 0) throw badRequest("invalid-workflow", `The workflow cannot be saved: ${problems.map(problemText).join("; ")}`, { problems });
+	const problems = checkDefinition(event.after.definition, {
+		resources: stepTypes,
+		required: requiredStepInputs
+	});
+	if (problems.length > 0) {
+		const errors = problems.map((problem) => ({
+			code: "invalid-workflow",
+			field: "definition",
+			message: problemText(problem),
+			params: {
+				state: problem.state,
+				field: problem.field
+			}
+		}));
+		throw badRequest("invalid-workflow", `The workflow cannot be saved: ${problems.map(problemText).join("; ")}`, {
+			problems,
+			errors
+		});
+	}
 	await sql`insert into ${sql.id(schema, "versions")} (workflow_id, version, definition, saved_by, tenant_id)
     select w.id, w.version, w.definition, ${String(event.user.id)}, w.tenant_id from ${sql.id(schema, "workflows")} w where w.id = ${String(event.after.id)}`.execute(trx);
 };

package/dist/workflows/schema-sql.js

@@ -1,6 +1,6 @@
 import { quoteIdent } from "../changes/capture-sql.js";
 /** The comment the schema's function carries, which the startup check reads. */
-const workflowsComment = `Protobase workflows 3`;
+const workflowsComment = `Protobase workflows 4`;
 const commentVersion = (comment) => {
 	const match = comment?.match(/^Protobase workflows (\d+)$/);
 	return match ? Number(match[1]) : void 0;
@@ -46,6 +46,7 @@ create table if not exists ${s}."runs" (
   "cause" text,
   "resume_at" timestamptz,
   "started_by" text,
+  "rerun_of" uuid references ${s}."runs" ("id") on delete set null,
   "tenant_id" text,
   "created_at" timestamptz not null default now(),
   "finished_at" timestamptz,
@@ -88,6 +89,8 @@ create index if not exists "workflows_name_search" on ${s}."workflows" using gin
 create index if not exists "versions_tenant" on ${s}."versions" ("tenant_id");
 alter table ${s}."runs" add column if not exists "key" text;
 create unique index if not exists "runs_key" on ${s}."runs" ("workflow_id", "key");
+alter table ${s}."runs" add column if not exists "rerun_of" uuid references ${s}."runs" ("id") on delete set null;
+create index if not exists "runs_rerun_of" on ${s}."runs" ("rerun_of");
 create index if not exists "runs_workflow" on ${s}."runs" ("workflow_id", "created_at");
 create index if not exists "runs_tenant" on ${s}."runs" ("tenant_id");
 create index if not exists "runs_status" on ${s}."runs" ("status");
@@ -102,7 +105,7 @@ const workflowsTriggers = ["workflow_version", "run_version"];
 * A workflow numbers its next version as a save changes its definition, in the row the write returns, so its ETag is
 * the saved row's; the save hook keeps that version's definition and who saved it. A run takes its workflow's current
 * version as it is created, and refuses a workflow of another tenant as one that is not there, and one that has no
-* saved version.
+* saved version. A re-run takes the input of the run it re-runs, which the start hook checks.
 */
 const functionsSql = (schema) => {
 	const s = quoteIdent(schema);
@@ -136,6 +139,9 @@ begin
     raise exception 'Workflow % has no saved version', new.workflow_id using errcode = '23503';
   end if;
   new.version := found.version;
+  if new.rerun_of is not null then
+    select r.input into new.input from ${s}."runs" r where r.id = new.rerun_of and r.workflow_id = new.workflow_id;
+  end if;
   return new;
 end
 $$;

package/dist/workflows/schema.js

@@ -13,7 +13,7 @@ const readWorkflowsSchema = async (db, schema) => {
 	const row = rows[0];
 	return {
 		tables: row.found,
-		current: row.found && commentVersion(row.comment) === 3 && row.triggers === workflowsTriggers.length
+		current: row.found && commentVersion(row.comment) === 4 && row.triggers === workflowsTriggers.length
 	};
 };
 /**

package/dist/workflows/start-hook.js

@@ -3,13 +3,15 @@ import { requestAccess, requireOperation } from "../request-access.js";
 import { deletedRows } from "../params.js";
 import { fetchReadable } from "../fetch-readable.js";
 import { checkRunInput } from "./input-limits.js";
+import { keepEarlierSteps } from "./rerun.js";
 //#region src/workflows/start-hook.ts
 /**
 * Starts a run as it is created through the API, in the write's transaction: it refuses an input over its limits and
-* a workflow the caller cannot read in their tenant (404, as the API answers for it), and queues the run's first
-* segment, which runs once the write commits. The resource records who started it, as the run's author.
+* a workflow the caller cannot read in their tenant (404, as the API answers for it), takes a re-run up after the steps
+* it keeps of the run it re-runs, and queues the run's first segment, which runs once the write commits. The resource
+* records who started it, as the run's author.
 */
-const runStartHook = (runner, deps) => async (event, trx) => {
+const runStartHook = (runner, deps, schema) => async (event, trx) => {
 	if (event.resource.name !== "workflow_runs" || event.operation !== "create" || !event.after) return;
 	checkRunInput(event.after.input);
 	const entry = deps().registry.find("workflows");
@@ -20,6 +22,10 @@ const runStartHook = (runner, deps) => async (event, trx) => {
 	requireOperation(access, "read");
 	const key = access.full.fields[access.full.primaryKey[0]];
 	if (!await fetchReadable(trx, access, [String(event.after.workflow_id)], deletedRows(access.full, false), { fields: [key] })) throw notFound(`No ${entry.name} with this key`);
+	if (event.after.rerun_of) await keepEarlierSteps(trx, deps(), schema, {
+		...event,
+		after: event.after
+	});
 	await runner.start(trx, String(event.after.id));
 };
 //#endregion

package/dist/workflows/step-types.js

@@ -2,17 +2,10 @@ import { httpStep } from "./http-step.js";
 import { mailStep } from "./mail-step.js";
 import { pieceStep } from "./piece-step.js";
 import { recordsSteps } from "./records-step.js";
+import { workflowStepTypes } from "@protobase/schema/internal";
 //#region src/workflows/step-types.ts
-/** The step types a Task names as its `Resource`, as the language report lists them. */
-const stepTypeNames = [
-	"app:http",
-	"app:records.create",
-	"app:records.update",
-	"app:records.get",
-	"app:records.list",
-	"app:mail.send",
-	"app:piece"
-];
+/** The step types a Task names as its `Resource`, as the editor offers them. */
+const stepTypeNames = Object.keys(workflowStepTypes);
 /** The step types of one segment, which sends mail with the mailer of the job that runs it. */
 const stepTypes = ({ deps, schema, roles, allowPrivateAddresses }, mail) => {
 	const files = () => deps().files;

package/dist/workflows/store.js

@@ -17,15 +17,18 @@ const postgresRunStore = (schema) => {
         from ${steps} where run_id = ${id} order by scope, seq`.execute(db);
 			return rows;
 		},
-		save: async (db, id, step) => {
+		save: async (db, id, records) => {
+			const row = (step) => sql`(${step.scope}, ${step.seq}::integer, ${step.state}, ${step.type}, ${step.status}, ${step.attempt}::integer,
+        ${json(step.input)}::jsonb, ${json(step.output)}::jsonb, ${json(step.assigned)}::jsonb, ${step.next}, ${step.resumeAt ?? null}::timestamptz,
+        ${step.error ?? null}, ${step.cause ?? null}, ${JSON.stringify(step.logs)}::jsonb, ${step.startedAt}::timestamptz, ${step.finishedAt}::timestamptz)`;
 			const { rows } = await sql`insert into ${steps}
         (run_id, tenant_id, scope, seq, state, type, status, attempt, input, output, assigned, next, resume_at, error, cause, logs, started_at, finished_at)
-        select r.id, r.tenant_id, ${step.scope}, ${step.seq}, ${step.state}, ${step.type}, ${step.status}, ${step.attempt}, ${json(step.input)}::jsonb,
-          ${json(step.output)}::jsonb, ${json(step.assigned)}::jsonb, ${step.next}, ${step.resumeAt ?? null}, ${step.error ?? null}, ${step.cause ?? null},
-          ${JSON.stringify(step.logs)}::jsonb, ${step.startedAt}, ${step.finishedAt}
-        from ${runs} r where r.id = ${id}
+        select r.id, r.tenant_id, s.*
+        from ${runs} r, (values ${sql.join(records.map(row))})
+          as s (scope, seq, state, type, status, attempt, input, output, assigned, next, resume_at, error, cause, logs, started_at, finished_at)
+        where r.id = ${id}
         on conflict (run_id, scope, seq) do nothing returning id`.execute(db);
-			return rows.length > 0;
+			return rows.length === records.length;
 		},
 		update: async (db, id, change) => {
 			const ended = change.status === "succeeded" || change.status === "failed";

package/dist/workflows/workflow-engine.js

@@ -28,7 +28,7 @@ const workflowEngine = (options, deps, auth) => {
 		secrets
 	});
 	return {
-		hooks: [workflowSaveHook(schema, stepTypeNames), runStartHook(runner, deps)],
+		hooks: [workflowSaveHook(schema, stepTypeNames), runStartHook(runner, deps, schema)],
 		writeChecks: [runInputCheck],
 		job
 	};

package/dist/workflows/workflows-module.d.ts

@@ -54,6 +54,7 @@ export declare const workflowsModule: (options?: WorkflowsOptions) => {
     readonly cause: import("@protobase/schema").Field<string | null>;
     readonly resume_at: import("@protobase/schema").Field<string | null>;
     readonly started_by: import("@protobase/schema").Field<string | null>;
+    readonly rerun_of: import("@protobase/schema").Field<string | number | null>;
     readonly tenant_id: import("@protobase/schema").Field<string | null>;
     readonly created_at: import("@protobase/schema").Field<string>;
     readonly finished_at: import("@protobase/schema").Field<string | null>;
@@ -71,6 +72,7 @@ export declare const workflowsModule: (options?: WorkflowsOptions) => {
     readonly cause: import("@protobase/schema").Field<string | null>;
     readonly resume_at: import("@protobase/schema").Field<string | null>;
     readonly started_by: import("@protobase/schema").Field<string | null>;
+    readonly rerun_of: import("@protobase/schema").Field<string | number | null>;
     readonly tenant_id: import("@protobase/schema").Field<string | null>;
     readonly created_at: import("@protobase/schema").Field<string>;
     readonly finished_at: import("@protobase/schema").Field<string | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.67.10",
+  "version": "0.67.12",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -44,10 +44,10 @@
     "@better-auth/sso": "^1.7.12",
     "@livekit/protocol": "1.53.1",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.67.10",
-    "@protobase/query": "0.67.10",
-    "@protobase/schema": "0.67.10",
-    "@protobase/workflows": "0.67.10",
+    "@protobase/layout": "0.67.12",
+    "@protobase/query": "0.67.12",
+    "@protobase/schema": "0.67.12",
+    "@protobase/workflows": "0.67.12",
     "@react-email/render": "^2.1.0",
     "@react-pdf/primitives": "^4.4.0",
     "@react-pdf/renderer": "^4.9.0",