@protobase/server 0.67.12 → 0.68.0

package/dist/workflows/start-workflow.d.ts

@@ -17,10 +17,12 @@ export type StartWorkflowOptions = {
   key?: string;
   /** The schema of `workflows`, when the config names another. Default `workflows`. */
   schema?: string;
+  /** The version to run, as a trigger runs the enabled one; default the workflow's current version. */
+  version?: number;
 };
 /**
  * Starts a run of a workflow from the app's own code, such as a job or a write hook, and returns the run's id. In
  * `db`'s own transaction when it is one, so the run starts when the caller's writes commit, or not at all.
  */
-export declare const startWorkflow: (db: Db, { workflow, input, tenant, startedBy, key, schema }: StartWorkflowOptions) => Promise<string>;
+export declare const startWorkflow: (db: Db, { workflow, input, tenant, startedBy, key, schema, version }: StartWorkflowOptions) => Promise<string>;
 //#endregion

package/dist/workflows/start-workflow.js

@@ -7,13 +7,13 @@ import { sql } from "kysely";
 * Starts a run of a workflow from the app's own code, such as a job or a write hook, and returns the run's id. In
 * `db`'s own transaction when it is one, so the run starts when the caller's writes commit, or not at all.
 */
-const startWorkflow = async (db, { workflow, input, tenant, startedBy, key, schema = "workflows" }) => {
+const startWorkflow = async (db, { workflow, input, tenant, startedBy, key, schema = "workflows", version }) => {
 	checkRunInput(input);
 	const job = currentJobs().definition(segmentJobName);
 	if (!job) throw new Error("Workflows are not running in this app: add `workflows: {}` to protobase.config.ts");
 	const runs = sql.id(schema, "runs");
-	const { rows } = await sql`insert into ${runs} (workflow_id, input, tenant_id, started_by, key)
-    values (${workflow}, ${input === void 0 ? null : JSON.stringify(input)}::jsonb, ${tenant === void 0 ? null : String(tenant)}, ${startedBy ?? null}, ${key ?? null})
+	const { rows } = await sql`insert into ${runs} (workflow_id, version, input, tenant_id, started_by, key)
+    values (${workflow}, ${version ?? null}, ${input === void 0 ? null : JSON.stringify(input)}::jsonb, ${tenant === void 0 ? null : String(tenant)}, ${startedBy ?? null}, ${key ?? null})
     on conflict (workflow_id, key) do nothing returning id`.execute(db);
 	if (rows.length === 0) {
 		const existing = (await sql`select id, status from ${runs} where workflow_id = ${workflow} and key = ${key}`.execute(db)).rows[0];

package/dist/workflows/triggers/trigger-jobs.js

@@ -0,0 +1,114 @@
+import { defineJob } from "../../jobs/define-job.js";
+import { readyAt, readyWhen, resolveTimeTerms } from "../ready/ready-when.js";
+import { activeTriggers, currentTrigger, triggerFailed } from "./trigger-row.js";
+import { orRefusal, readyContext, startIfReady } from "../ready/ready-start.js";
+import { encodeKey } from "@protobase/schema/internal";
+import { printFilter } from "@protobase/schema";
+import { sql } from "kysely";
+//#region src/workflows/triggers/trigger-jobs.ts
+/** Records one enable pass reads per job. */
+const passSize = 100;
+/**
+* The jobs that run triggers on every server process, so turning a workflow on, changing or turning it off needs no
+* restart: `workflows.trigger-start` (for a ready trigger, one pass over the records that already match, 100 per job),
+* `workflows.trigger-stop` (removes a stopped trigger), and `workflows.ready-check` (starts a run of one record when it
+* is ready, at the time its time terms say). Each acts only on the generation it was queued for.
+*/
+const triggerJobs = (input) => {
+	const { schema } = input;
+	const readyCheck = defineJob({
+		name: "workflows.ready-check",
+		timeout: "5 minutes",
+		run: async ({ trigger: id, generation, key }, { db }) => {
+			const trigger = await currentTrigger(db, schema, id, generation);
+			if (!trigger) return;
+			if (await startIfReady(input, db, trigger, key)) await start.enqueue(db, {
+				trigger: id,
+				generation
+			});
+		}
+	});
+	const queueCheck = async (db, trigger, primaryKey, timeTerms, record) => {
+		const at = readyAt(timeTerms, record, /* @__PURE__ */ new Date());
+		if (!at) return;
+		const key = Object.fromEntries(primaryKey.map((name) => [name, record[name]]));
+		const recordKey = encodeKey(primaryKey.map((name) => record[name]));
+		await readyCheck.enqueue(db, {
+			trigger: trigger.id,
+			generation: trigger.generation,
+			key
+		}, {
+			runAt: at,
+			key: `ready:${trigger.id}:${trigger.generation}:${recordKey}:${at.toISOString()}`
+		});
+	};
+	const start = defineJob({
+		name: "workflows.trigger-start",
+		timeout: "5 minutes",
+		run: async ({ trigger: id, generation, page_token }, { db }) => {
+			const trigger = await currentTrigger(db, schema, id, generation);
+			if (!trigger || !input.declared(trigger.type)) return;
+			const found = await orRefusal(readyContext(input, trigger));
+			if ("refused" in found) return triggerFailed(db, schema, trigger, "refused", found.refused);
+			if (!found.value) return;
+			const { spec, model, records } = found.value;
+			const split = readyWhen(spec.when);
+			if (!split.ok) return;
+			const filter = split.when.filter && printFilter(split.when.filter);
+			const listed = await orRefusal(records.list(spec.resource, {
+				...filter && { filter },
+				page_size: passSize,
+				...page_token && { page_token }
+			}));
+			if ("refused" in listed) return triggerFailed(db, schema, trigger, "refused", listed.refused);
+			const page = listed.value;
+			const timeTerms = resolveTimeTerms(model, split.when.timeTerms);
+			for (const record of page.items) await queueCheck(db, trigger, model.primaryKey, timeTerms, record);
+			if (page.next_page_token) await start.enqueue(db, {
+				trigger: id,
+				generation,
+				page_token: page.next_page_token
+			});
+		}
+	});
+	const stop = defineJob({
+		name: "workflows.trigger-stop",
+		run: async ({ trigger }, { db }) => {
+			await sql`delete from ${sql.id(schema, "triggers")} where id = ${trigger} and status = 'stopping'`.execute(db);
+		}
+	});
+	/**
+	* Routes each dispatched change to the ready triggers on its resource and tenant: it queues the check of the record at
+	* the time it becomes ready, in the dispatch's transaction. No sweep runs: a record becomes ready by a write, or at a
+	* time a write set.
+	*/
+	const onChanges = async (db, changes) => {
+		const types = [...input.readyTypes];
+		if (types.length === 0) return;
+		const triggers = await activeTriggers(db, schema, types);
+		for (const trigger of triggers) {
+			const spec = input.declared(trigger.type)?.ready(trigger.input);
+			const model = spec && input.deps().registry.find(spec.resource)?.model;
+			const split = spec && readyWhen(spec.when);
+			if (!spec || !model || !split?.ok) continue;
+			const timeTerms = resolveTimeTerms(model, split.when.timeTerms);
+			for (const change of changes) {
+				if (change.resource !== spec.resource || !change.after) continue;
+				if (String(change.tenant ?? "") !== String(trigger.tenant_id ?? "")) continue;
+				await queueCheck(db, trigger, model.primaryKey, timeTerms, change.after);
+			}
+		}
+	};
+	return {
+		jobs: [
+			start,
+			stop,
+			readyCheck
+		],
+		start,
+		stop,
+		onChanges
+	};
+};
+//#endregion
+export { triggerJobs };

package/dist/workflows/triggers/trigger-row.js

@@ -0,0 +1,36 @@
+import { sql } from "kysely";
+//#region src/workflows/triggers/trigger-row.ts
+/**
+* The trigger with this id while it is running on this generation, with who saved its version: `undefined` once it
+* was changed, stopped or removed, so a job queued for it before then does nothing.
+*/
+const currentTrigger = async (db, schema, id, generation) => {
+	const { rows } = await sql`select t.id, t.workflow_id, t.version, t.tenant_id, t.type, t.input, t.generation, t.status, v.saved_by
+    from ${sql.id(schema, "triggers")} t join ${sql.id(schema, "versions")} v on v.workflow_id = t.workflow_id and v.version = t.version
+    where t.id = ${id} and t.generation = ${generation} and t.status in ('active', 'failing')`.execute(db);
+	return rows[0];
+};
+/**
+* The running triggers of these types, failing ones included so a write can show they work again; each dispatch of
+* changes reads them, and the `(status, type)` index serves it.
+*/
+const activeTriggers = async (db, schema, types) => (await sql`select id, workflow_id, version, tenant_id, type, input, generation, status from ${sql.id(schema, "triggers")}
+    where status in ('active', 'failing') and type = any(${types})`.execute(db)).rows;
+/** Marks a trigger failing with an error its owner sees; the message names no secret. */
+const triggerFailed = async (db, schema, { id, generation, version }, code, message) => {
+	await sql`update ${sql.id(schema, "triggers")} set status = 'failing', consecutive_failures = consecutive_failures + 1,
+    last_error = ${JSON.stringify({
+		code,
+		message,
+		at: (/* @__PURE__ */ new Date()).toISOString()
+	})}::jsonb, updated_at = now()
+    where id = ${id} and generation = ${generation} and version = ${version}`.execute(db);
+};
+/** Marks a failing trigger active again once it read a record; whether this call was the one that did. */
+const triggerRecovered = async (db, schema, { id, generation, version }) => {
+	const { rows } = await sql`update ${sql.id(schema, "triggers")} set status = 'active', consecutive_failures = 0, last_error = null, updated_at = now()
+    where id = ${id} and generation = ${generation} and version = ${version} and status = 'failing' returning id`.execute(db);
+	return rows.length > 0;
+};
+//#endregion
+export { activeTriggers, currentTrigger, triggerFailed, triggerRecovered };

package/dist/workflows/triggers/trigger-sync.js

@@ -0,0 +1,48 @@
+import { badRequest } from "../../problem.js";
+import { sql } from "kysely";
+//#region src/workflows/triggers/trigger-sync.ts
+const triggerOf = (definition) => {
+	const [type, input] = Object.entries(definition.trigger)[0];
+	return type === "manual" ? void 0 : {
+		type,
+		input
+	};
+};
+/**
+* Keeps a workflow's trigger row in step with its enabled version, in the write's transaction, queueing its jobs in that
+* same write: turning it on inserts a running trigger and queues its start; a new version with the same type and input
+* keeps the row, so its state carries over, and passes over the records again; any other change, or turning it off, stops the old row and starts a new one.
+* Only the current version can be turned on.
+*/
+const syncTrigger = async (trx, schema, jobs, workflow) => {
+	const enabled = workflow.enabled_version;
+	if (enabled !== null && enabled !== workflow.version) throw badRequest("invalid-workflow", `Only the current version can be enabled: set enabled_version to ${String(workflow.version)}, or clear it to turn the workflow off`);
+	const wanted = enabled === null ? void 0 : triggerOf(workflow.definition);
+	const triggers = sql.id(schema, "triggers");
+	const id = String(workflow.id);
+	const { rows } = await sql`select id, generation, version, (type = ${wanted?.type ?? null} and input = ${JSON.stringify(wanted?.input ?? null)}::jsonb and connection_id is null) as same
+    from ${triggers} where workflow_id = ${id} and status <> 'stopping'`.execute(trx);
+	const existing = rows[0];
+	if (existing?.same) {
+		if (existing.version === enabled) return;
+		await sql`update ${triggers} set version = ${enabled}, status = 'active', consecutive_failures = 0, last_error = null, updated_at = now() where id = ${existing.id}`.execute(trx);
+		await jobs.start.enqueue(trx, {
+			trigger: existing.id,
+			generation: existing.generation
+		});
+		return;
+	}
+	if (existing) {
+		await sql`update ${triggers} set status = 'stopping', generation = generation + 1, updated_at = now() where id = ${existing.id}`.execute(trx);
+		await jobs.stop.enqueue(trx, { trigger: existing.id });
+	}
+	if (!wanted) return;
+	const trigger = (await sql`insert into ${triggers} (workflow_id, version, tenant_id, type, input, status, generation, consecutive_failures)
+    values (${id}, ${enabled}, ${workflow.tenant_id ?? null}, ${wanted.type}, ${JSON.stringify(wanted.input)}::jsonb, 'active', 1, 0) returning id`.execute(trx)).rows[0].id;
+	await jobs.start.enqueue(trx, {
+		trigger,
+		generation: 1
+	}, { key: `trigger:${trigger}` });
+};
+//#endregion
+export { syncTrigger };

package/dist/workflows/workflow-engine.js

@@ -1,14 +1,16 @@
-import { stepTypeNames, stepTypes } from "./step-types.js";
 import { betterAuthOwnerRoles } from "../webhooks/table/owner-roles.js";
 import { runInputCheck } from "./input-limits.js";
 import { workflowSecrets, workflowsSchema } from "./options.js";
 import { workflowSaveHook } from "./save-hook.js";
 import { workflowsRunner } from "./segment-job.js";
 import { runStartHook } from "./start-hook.js";
+import { triggerJobs } from "./triggers/trigger-jobs.js";
+import { workflowTypes } from "./workflow-types.js";
 //#region src/workflows/workflow-engine.ts
 /**
 * What `createAdmin` needs for `workflows`: the hooks that check saves and start runs, the check of a run's input before
-* it is validated, and the segment job, whose step
+* it is validated, the app's trigger and step types, the segment and trigger jobs, the routing of changes to
+* ready triggers, and the segment job, whose step
 * types act on records as each workflow's last editor (from Better Auth unless the options say otherwise).
 */
 const workflowEngine = (options, deps, auth) => {
@@ -22,15 +24,25 @@ const workflowEngine = (options, deps, auth) => {
 		allowPrivateAddresses: Boolean(options.allowPrivateAddresses)
 	};
 	const secrets = workflowSecrets(options, globalThis.process?.env ?? {});
+	const types = workflowTypes(options.plugins, (name) => deps().registry.find(name)?.model);
 	const { runner, job } = workflowsRunner({
 		schema,
-		tasks: (context) => stepTypes(input, context.mail),
+		tasks: (context) => types.tasks(input, context.mail),
 		secrets
 	});
+	const triggers = triggerJobs({
+		deps,
+		schema,
+		roles,
+		declared: (type) => types.ready.get(type),
+		readyTypes: [...types.ready.keys()].filter((id) => types.check.triggers[id] !== void 0)
+	});
 	return {
-		hooks: [workflowSaveHook(schema, stepTypeNames), runStartHook(runner, deps, schema)],
+		hooks: [workflowSaveHook(schema, types.check, triggers), runStartHook(runner, deps, schema)],
 		writeChecks: [runInputCheck],
-		job
+		jobs: [job, ...triggers.jobs],
+		onChanges: triggers.onChanges,
+		types
 	};
 };
 //#endregion

package/dist/workflows/workflow-types-route.js

@@ -0,0 +1,22 @@
+import { requestAccess, requireOperation } from "../request-access.js";
+import { Hono } from "hono";
+import { typeCatalog } from "@protobase/workflows";
+//#region src/workflows/workflow-types-route.ts
+/**
+* The app's trigger and step types, `GET /` at `workflowTypesPath`, as `list_workflow_types` lists them: the editor
+* draws its menus, forms and check from them. Only for a caller who may read the app's workflows, refused as reading a
+* workflow is.
+*/
+const workflowTypesRoute = (deps, types) => {
+	const catalog = typeCatalog(types);
+	const app = new Hono();
+	app.get("/", async (c) => {
+		const entry = deps.registry.find("workflows");
+		if (!entry) throw new Error("The workflow types are served only in an app with workflows");
+		requireOperation(await requestAccess(deps, entry, c.get("session")), "read");
+		return c.json(catalog);
+	});
+	return app;
+};
+//#endregion
+export { workflowTypesRoute };

package/dist/workflows/workflow-types.d.ts

@@ -0,0 +1,22 @@
+import { Mailer } from "../mail/mail-message.js";
+import { ServicesInput } from "./plugin-services.js";
+import { ResourceModel } from "@protobase/schema";
+import { CheckOptions, LoadedPlugin, TaskHandlers } from "@protobase/workflows";
+import { Plugin, ReadyTrigger } from "@protobase/workflows/plugin";
+//#region src/workflows/workflow-types.d.ts
+type Models = (name: string) => ResourceModel | undefined;
+/**
+ * The trigger and step types of an app: the built-in plugin, `app`, then the app's own, all through the same loader and
+ * interface. `types` is the list the MCP tools and the editor read; `check` is what a save checks a definition against,
+ * the available types only, and `checkWith` the same check against other resources, such as those a caller may read.
+ */
+export declare const workflowTypes: (loaded?: readonly LoadedPlugin[], models?: Models) => {
+  plugins: Plugin[];
+  types: import("@protobase/workflows").TypeEntry[];
+  check: CheckOptions;
+  checkWith: (against: Models) => CheckOptions;
+  tasks: (input: ServicesInput, mail: Mailer | undefined) => TaskHandlers;
+  ready: Map<string, ReadyTrigger>;
+};
+export type WorkflowTypes = ReturnType<typeof workflowTypes>;
+//#endregion

package/dist/workflows/workflow-types.js

@@ -0,0 +1,63 @@
+import { pluginServices } from "./plugin-services.js";
+import { readyProblems } from "./ready/ready-check.js";
+import { loadPlugins, stepHandlers, triggerChecks, typeList } from "@protobase/workflows";
+import { ConnectionError } from "@protobase/workflows/plugin";
+import { appPlugin } from "@protobase/workflow-plugins";
+//#region src/workflows/workflow-types.ts
+const unavailable = (type) => {
+	if (type.connection) return "It signs in through a connection, which this app cannot make yet";
+	if (type.kind === "polling" || type.kind === "webhook") return `This app does not run ${type.kind} triggers yet`;
+};
+const noConnection = (stepId, name) => ({ accessToken: () => Promise.reject(new ConnectionError("not_connected", `${stepId} signs in through "${name}", and this workflow has no sign-in for it`)) });
+const requiredInputs = (input) => Array.isArray(input.required) ? input.required : [];
+/** The ready triggers of `plugins`, by id. */
+const readyTriggers = (plugins) => new Map(plugins.flatMap((plugin) => Object.entries(plugin.triggers ?? {}).flatMap(([key, type]) => type.kind === "ready" ? [[`${plugin.name}:${key}`, type]] : [])));
+/**
+* The trigger and step types of an app: the built-in plugin, `app`, then the app's own, all through the same loader and
+* interface. `types` is the list the MCP tools and the editor read; `check` is what a save checks a definition against,
+* the available types only, and `checkWith` the same check against other resources, such as those a caller may read.
+*/
+const workflowTypes = (loaded = [], models = () => void 0) => {
+	const plugins = loadPlugins([{
+		plugin: appPlugin,
+		source: "@protobase/workflow-plugins"
+	}, ...loaded]);
+	const types = typeList(plugins, unavailable);
+	const available = new Set(types.filter((type) => type.kind !== "step" && type.available).map((type) => type.id));
+	const ready = readyTriggers(plugins);
+	const steps = types.filter((type) => type.kind === "step" && type.available);
+	const reasons = Object.fromEntries(types.flatMap((type) => type.reason === void 0 ? [] : [[type.id, type.reason]]));
+	const own = triggerChecks(plugins);
+	const checkWith = (against) => {
+		const checks = Object.entries(own).map(([id, check]) => {
+			const declared = ready.get(id);
+			if (!declared) return [id, check];
+			return [id, (input) => {
+				const problems = check(input);
+				return problems.length > 0 ? problems : readyProblems(against, declared.ready(input));
+			}];
+		});
+		return {
+			resources: steps.map((type) => type.id),
+			required: Object.fromEntries(steps.map((type) => [type.id, requiredInputs(type.input)])),
+			triggers: Object.fromEntries(checks.filter(([id]) => available.has(id))),
+			unavailable: reasons
+		};
+	};
+	const check = checkWith(models);
+	/** The step types of one segment, which sends mail with the mailer of the job that runs it. */
+	const tasks = (input, mail) => stepHandlers(plugins, {
+		services: pluginServices(input, mail),
+		connection: noConnection
+	});
+	return {
+		plugins,
+		types,
+		check,
+		checkWith,
+		tasks,
+		ready
+	};
+};
+//#endregion
+export { readyTriggers, workflowTypes };

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

@@ -5,13 +5,14 @@ import { WorkflowsOptions } from "./options.js";
  * over a `workflows` schema that `protobase migration` writes. Who may make, change and run them and read their runs
  * is the resources' access (`workflows.create`, `workflow_runs.create`, `workflow_steps.read`, ...).
  */
-export declare const workflowsModule: (options?: WorkflowsOptions) => {
+export declare const workflowsModule: (options?: Pick<WorkflowsOptions, "schema">) => {
   workflows: import("@protobase/schema").ResourceBuilder<{
     readonly id: import("@protobase/schema").Field<string>;
     readonly name: import("@protobase/schema").Field<string>;
     readonly description: import("@protobase/schema").Field<string | null>;
     readonly definition: import("@protobase/schema").Field<import("zod").JSONType>;
     readonly version: import("@protobase/schema").Field<number | null>;
+    readonly enabled_version: import("@protobase/schema").Field<number | null>;
     readonly tenant_id: import("@protobase/schema").Field<string | null>;
     readonly created_at: import("@protobase/schema").Field<string>;
     readonly updated_at: import("@protobase/schema").Field<string>;
@@ -22,6 +23,7 @@ export declare const workflowsModule: (options?: WorkflowsOptions) => {
     readonly description: import("@protobase/schema").Field<string | null>;
     readonly definition: import("@protobase/schema").Field<import("zod").JSONType>;
     readonly version: import("@protobase/schema").Field<number | null>;
+    readonly enabled_version: import("@protobase/schema").Field<number | null>;
     readonly tenant_id: import("@protobase/schema").Field<string | null>;
     readonly created_at: import("@protobase/schema").Field<string>;
     readonly updated_at: import("@protobase/schema").Field<string>;
@@ -122,5 +124,27 @@ export declare const workflowsModule: (options?: WorkflowsOptions) => {
     readonly finished_at: import("@protobase/schema").Field<string>;
     readonly duration_ms: import("@protobase/schema").Field<string | null>;
   }, import("@protobase/schema").Ref<"id", string>>>;
+  workflowTriggers: import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly workflow_id: import("@protobase/schema").Field<string | number>;
+    readonly version: import("@protobase/schema").Field<number>;
+    readonly type: import("@protobase/schema").Field<string>;
+    readonly status: import("@protobase/schema").Field<"active" | "failing" | "needs_sign_in" | "stopping">;
+    readonly last_error: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly next_poll_at: import("@protobase/schema").Field<string | null>;
+    readonly tenant_id: import("@protobase/schema").Field<string | null>;
+    readonly updated_at: import("@protobase/schema").Field<string>;
+  }, import("@protobase/schema").Ref<"id", string>>;
+  workflowTriggersView: import("@protobase/schema").ViewBuilder<import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly workflow_id: import("@protobase/schema").Field<string | number>;
+    readonly version: import("@protobase/schema").Field<number>;
+    readonly type: import("@protobase/schema").Field<string>;
+    readonly status: import("@protobase/schema").Field<"active" | "failing" | "needs_sign_in" | "stopping">;
+    readonly last_error: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly next_poll_at: import("@protobase/schema").Field<string | null>;
+    readonly tenant_id: import("@protobase/schema").Field<string | null>;
+    readonly updated_at: import("@protobase/schema").Field<string>;
+  }, import("@protobase/schema").Ref<"id", string>>>;
 };
 //#endregion

package/package.json

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

package/dist/workflows/http-step.js

@@ -1,103 +0,0 @@
-import { AddressRefusedError, pinnedRequest } from "../webhooks/table/pinned-request.js";
-import { readLimited } from "../webhooks/table/read-limited.js";
-import { isFileValue, readRunFile, storeRunFile } from "./run-files.js";
-import { StepError } from "@protobase/workflows";
-//#region src/workflows/http-step.ts
-/** The most of an answer's body the `http` step reads; a larger one fails the step. */
-const httpBodyLimit = 10485760;
-/** How much of a failing answer's body its error keeps, after secrets are blanked out of it. */
-const causeBodyLength = 200;
-const methods = /* @__PURE__ */ new Set([
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE"
-]);
-const readings = /* @__PURE__ */ new Set([
-	"json",
-	"text",
-	"file"
-]);
-const invalid = (reason) => new StepError("Http.InvalidArguments", reason);
-const isTextRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
-const checked = (args) => {
-	if (typeof args.url !== "string" || !URL.canParse(args.url)) throw invalid("url must be an http or https URL");
-	const method = args.method === void 0 ? "GET" : String(args.method).toUpperCase();
-	if (!methods.has(method)) throw invalid(`method must be one of ${[...methods].join(", ")}`);
-	if (args.headers !== void 0 && !isTextRecord(args.headers)) throw invalid("headers must be an object of text values");
-	if (args.query !== void 0 && !isTextRecord(args.query)) throw invalid("query must be an object of text values");
-	const response = args.response ?? "json";
-	if (typeof response !== "string" || !readings.has(response)) throw invalid("response must be json, text or file");
-	const url = new URL(args.url);
-	for (const [name, value] of Object.entries(args.query ?? {})) url.searchParams.append(name, value);
-	return {
-		url,
-		method,
-		headers: new Headers(args.headers),
-		response
-	};
-};
-const answerBody = async (bytes, response, url, type, keep) => {
-	if (response === "file") return keep(bytes, decodeURIComponent(url.pathname.slice(url.pathname.lastIndexOf("/") + 1)), type?.split(";")[0]?.trim() || "application/octet-stream");
-	const text = new TextDecoder().decode(bytes);
-	if (response === "text") return text;
-	if (text.trim() === "") return null;
-	try {
-		return JSON.parse(text);
-	} catch (error) {
-		if (!(error instanceof SyntaxError)) throw error;
-		throw new StepError("Http.InvalidBody", `${url.host} answered with a body that is not JSON; read it with "response": "text"`);
-	}
-};
-/**
-* The `app:http` step: one request to `url`, built at run time, through the pinned request, which resolves its host
-* once and connects only to a public address it checked. It follows no redirect, reads at most `httpBodyLimit` of
-* the answer, and fails with `Http.Status` on a status outside 2xx, `Http.Network` when no answer came.
-*/
-const httpStep = ({ allowPrivateAddresses = false, resolve, files = () => void 0 } = {}) => async (args, { runId, signal, log, redact }) => {
-	const given = args ?? {};
-	const { url, method, headers, response: reading } = checked(given);
-	let body;
-	if (given.body !== void 0 && method !== "GET") {
-		if (isFileValue(given.body)) {
-			const file = await readRunFile(files(), runId, given.body, "body");
-			body = file.bytes;
-			if (!headers.has("content-type")) headers.set("content-type", file.ref.type ?? "application/octet-stream");
-		} else if (typeof given.body === "string") body = given.body;
-		else {
-			body = JSON.stringify(given.body);
-			if (!headers.has("content-type")) headers.set("content-type", "application/json");
-		}
-	}
-	const started = Date.now();
-	const answer = await pinnedRequest(url.href, {
-		method,
-		headers,
-		...body !== void 0 && { body },
-		signal
-	}, {
-		allowPrivateAddresses,
-		...resolve && { resolve }
-	}).catch((error) => {
-		if (error instanceof AddressRefusedError) throw new StepError("Http.AddressRefused", error.message);
-		if (signal.aborted) throw error;
-		throw new StepError("Http.Network", `No answer from ${url.host}: ${error instanceof Error ? error.message : String(error)}`);
-	});
-	const bytes = await readLimited(answer, 10485761);
-	log(`${method} ${given.url}`.replace(/[?#].*$/, "") + `: ${answer.status} in ${Date.now() - started} ms`);
-	if (bytes.length > 10485760) throw new StepError("Http.ResponseTooLarge", `The answer's body is larger than ${httpBodyLimit / 1024 / 1024} MiB, the most the http step reads`);
-	if (answer.status < 200 || answer.status > 299) {
-		const excerpt = redact(new TextDecoder().decode(bytes)).slice(0, causeBodyLength);
-		throw new StepError("Http.Status", `${url.host} answered ${answer.status}${excerpt ? `: ${excerpt}` : ""}`);
-	}
-	const kept = Object.fromEntries([...answer.headers].filter(([name]) => name !== "set-cookie"));
-	const keep = (data, name, type) => storeRunFile(files(), runId, data, name, type);
-	return {
-		status: answer.status,
-		headers: kept,
-		body: await answerBody(bytes, reading, url, answer.headers.get("content-type"), keep)
-	};
-};
-//#endregion
-export { httpBodyLimit, httpStep };

package/dist/workflows/mail-step.js

@@ -1,58 +0,0 @@
-import { readRunFile, runFileLimit } from "./run-files.js";
-import { StepError } from "@protobase/workflows";
-const invalid = (reason) => new StepError("Mail.InvalidArguments", reason);
-const line = (value, name) => {
-	if (typeof value !== "string" || value.trim() === "") throw invalid(`${name} must be text`);
-	if (/[\r\n]/.test(value)) throw invalid(`${name} must be one line`);
-	return value;
-};
-const recipients = (value) => {
-	const list = Array.isArray(value) ? value : [value];
-	if (list.length === 0 || list.length > 50) throw invalid(`to must be one address or a list of 1 to 50`);
-	return list.map((address, index) => {
-		const name = Array.isArray(value) ? `to[${index}]` : "to";
-		if (/[,;]/.test(line(address, name))) throw invalid(`${name} must be one address; give several as a list`);
-		return address;
-	}).join(", ");
-};
-const attachmentsOf = async (value, files, runId) => {
-	if (value === void 0 || value === null) return [];
-	if (!Array.isArray(value)) throw invalid("attachments must be a list of file values");
-	const attachments = [];
-	let total = 0;
-	for (const [index, item] of value.entries()) {
-		const { ref, bytes } = await readRunFile(files, runId, item, `attachments[${index}]`);
-		total += bytes.length;
-		if (total > 10485760) throw invalid(`attachments are larger than ${runFileLimit / 1024 / 1024} MiB together`);
-		attachments.push({
-			filename: ref.name,
-			content: bytes,
-			...ref.type && { contentType: ref.type }
-		});
-	}
-	return attachments;
-};
-/**
-* The `app:mail.send` step: one message from the app's own sender, with the app's mailer; a workflow cannot set the
-* sender. Its Message-ID comes from the step's idempotency key, the same for each try, so a receiver can tell a
-* repeated try from a new mail.
-*/
-const mailStep = (mail, files) => async (args, { runId, idempotencyKey }) => {
-	const given = args ?? {};
-	const mailer = mail();
-	if (!mailer) throw new StepError("States.TaskFailed", "The app sends no mail: set its mailer, or PROTOBASE_SMTP_URL and PROTOBASE_MAIL_FROM");
-	if (typeof given.text !== "string") throw invalid("text must be text");
-	if (given.html !== void 0 && typeof given.html !== "string") throw invalid("html must be text");
-	const messageId = `<${idempotencyKey.replace(/[^A-Za-z0-9.-]/g, ".")}@workflows.invalid>`;
-	await mailer.send({
-		to: recipients(given.to),
-		subject: line(given.subject, "subject"),
-		text: given.text,
-		...given.html !== void 0 && { html: given.html },
-		headers: { "Message-ID": messageId },
-		attachments: await attachmentsOf(given.attachments, files(), runId)
-	});
-	return { message_id: messageId };
-};
-//#endregion
-export { mailStep };