@protobase/workflow-plugins 0.0.0-stage → 0.68.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/app.d.ts

@@ -0,0 +1,13 @@
+//#region src/app.d.ts
+/** The built-in types, `app:<key>`: one plugin like any other, on the public interface alone. */
+export declare const appPlugin: {
+  readonly name: "app";
+  readonly label: "Built-in";
+  readonly steps: {
+    readonly [x: string]: import("@protobase/workflows/plugin").StepType;
+  };
+  readonly triggers: {
+    readonly [x: string]: import("@protobase/workflows/plugin").ReadyTrigger;
+  };
+};
+//#endregion

package/dist/app.js

@@ -0,0 +1,21 @@
+import { httpSteps } from "./http.js";
+import { mailSteps } from "./mail.js";
+import { pieceSteps } from "./piece.js";
+import { recordTriggers } from "./record-trigger.js";
+import { recordsSteps } from "./records.js";
+import { definePlugin } from "@protobase/workflows/plugin";
+//#region src/app.ts
+/** The built-in types, `app:<key>`: one plugin like any other, on the public interface alone. */
+const appPlugin = definePlugin({
+	name: "app",
+	label: "Built-in",
+	steps: {
+		...httpSteps,
+		...recordsSteps,
+		...mailSteps,
+		...pieceSteps
+	},
+	triggers: { ...recordTriggers }
+});
+//#endregion
+export { appPlugin };

package/dist/http.js

@@ -0,0 +1,151 @@
+import { AddressRefusedError, ResponseTooLargeError, StepError, fetchMaxBytes, isFileValue } from "@protobase/workflows/plugin";
+//#region src/http.ts
+/** How much of a failing answer's body its error keeps, after secrets are blanked out of it. */
+const causeBodyLength = 200;
+const methods = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+const textRecord = {
+	type: "object",
+	additionalProperties: { type: "string" }
+};
+const invalid = (reason) => new StepError("Http.InvalidArguments", reason);
+const checked = (input) => {
+	if (typeof input.url !== "string" || !URL.canParse(input.url)) throw invalid("url must be an http or https URL");
+	const method = input.method === void 0 ? "GET" : String(input.method).toUpperCase();
+	if (!methods.includes(method)) throw invalid(`method must be one of ${methods.join(", ")}`);
+	const url = new URL(input.url);
+	for (const [name, value] of Object.entries(input.query ?? {})) url.searchParams.append(name, value);
+	return {
+		url,
+		method,
+		headers: new Headers(input.headers),
+		reading: input.response ?? "json"
+	};
+};
+const requestBody = async (given, method, headers, { files }) => {
+	if (given === void 0 || method === "GET") return;
+	if (isFileValue(given)) {
+		const file = await files.read(given, "body");
+		if (!headers.has("content-type")) headers.set("content-type", file.type ?? "application/octet-stream");
+		return file.bytes;
+	}
+	if (typeof given === "string") return given;
+	if (!headers.has("content-type")) headers.set("content-type", "application/json");
+	return JSON.stringify(given);
+};
+const fileName = (url) => {
+	const segment = url.pathname.slice(url.pathname.lastIndexOf("/") + 1);
+	try {
+		return decodeURIComponent(segment);
+	} catch (error) {
+		if (!(error instanceof URIError)) throw error;
+		return segment;
+	}
+};
+const answerBody = async (bytes, reading, url, type, { files }) => {
+	if (reading === "file") return files.keep(bytes, fileName(url), type?.split(";")[0]?.trim() || "application/octet-stream");
+	const text = new TextDecoder().decode(bytes);
+	if (reading === "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"`);
+	}
+};
+const loggedUrl = (given) => given.replace(/^([^:/?#]+:\/\/)[^/?#]*@/, "$1").replace(/[?#].*$/, "");
+const send = async (context) => {
+	const { input, signal, log, redact } = context;
+	const { url, method, headers, reading } = checked(input);
+	const body = await requestBody(input.body, method, headers, context);
+	const started = Date.now();
+	const answer = await context.fetch(url.href, {
+		method,
+		headers,
+		...body !== void 0 && { body },
+		signal
+	}).catch((error) => {
+		if (error instanceof AddressRefusedError) throw new StepError("Http.AddressRefused", error.message);
+		if (error instanceof ResponseTooLargeError) throw new StepError("Http.ResponseTooLarge", `The answer's body is larger than ${fetchMaxBytes / 1024 / 1024} MiB, the most the http step reads`);
+		if (signal.aborted) throw error;
+		throw new StepError("Http.Network", `No answer from ${url.host}: ${error instanceof Error ? error.message : String(error)}`);
+	});
+	const bytes = new Uint8Array(await answer.arrayBuffer());
+	log(`${method} ${loggedUrl(input.url)}: ${answer.status} in ${Date.now() - started} ms`);
+	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"));
+	return {
+		status: answer.status,
+		headers: kept,
+		body: await answerBody(bytes, reading, url, answer.headers.get("content-type"), context)
+	};
+};
+/**
+* `app:http`: one request to a URL built at run time, through the plugin context's guarded `fetch`, which connects only
+* to a public address it checked, follows no redirect and reads at most 10 MiB of the answer.
+*/
+const httpSteps = { http: {
+	label: "HTTP request",
+	description: "Sends one HTTP request to a public address and reads the answer.",
+	errorPrefix: "Http",
+	input: {
+		type: "object",
+		required: ["url"],
+		properties: {
+			url: {
+				type: "string",
+				description: "an http or https URL"
+			},
+			method: {
+				type: "string",
+				description: "GET (default), POST, PUT, PATCH or DELETE"
+			},
+			headers: {
+				...textRecord,
+				description: "an object of text values"
+			},
+			query: {
+				...textRecord,
+				description: "an object of text values, added to the URL's query"
+			},
+			body: { description: "text sent as it is, a file value sent as its bytes, any other value sent as JSON; a GET sends none" },
+			response: {
+				enum: [
+					"json",
+					"text",
+					"file"
+				],
+				description: "how the answer's body is read: json (default; empty is null), text, or file (kept as a file value of the run)"
+			}
+		}
+	},
+	output: {
+		type: "object",
+		description: "{ status, headers, body }",
+		properties: {
+			status: { type: "integer" },
+			headers: { type: "object" },
+			body: {}
+		}
+	},
+	errors: {
+		Status: "a status outside 2xx; the cause names it with the start of the body",
+		Network: "no answer",
+		InvalidArguments: "an argument has the wrong type, named in the cause",
+		InvalidBody: "response json, and the body is not JSON",
+		AddressRefused: "the host is not a public address",
+		ResponseTooLarge: "a body over 10 MiB"
+	},
+	run: send
+} };
+//#endregion
+export { httpSteps };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { appPlugin } from "./app.js";
+export { appPlugin, appPlugin as default };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { appPlugin } from "./app.js";
+export { appPlugin, appPlugin as default };

package/dist/mail.js

@@ -0,0 +1,84 @@
+import { StepError } from "@protobase/workflows/plugin";
+/** The most bytes the attachments of one mail hold together. */
+const attachmentBytes = 10485760;
+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 }) => {
+	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 file = await files.read(item, `attachments[${index}]`);
+		total += file.bytes.length;
+		if (total > attachmentBytes) throw invalid(`attachments are larger than ${attachmentBytes / 1024 / 1024} MiB together`);
+		attachments.push({
+			filename: file.name,
+			content: file.bytes,
+			...file.type && { contentType: file.type }
+		});
+	}
+	return attachments;
+};
+const send = async (context) => {
+	const { input, mail, idempotencyKey } = context;
+	if (!mail) throw new StepError("States.TaskFailed", "The app sends no mail: set its mailer, or PROTOBASE_SMTP_URL and PROTOBASE_MAIL_FROM");
+	if (typeof input.text !== "string") throw invalid("text must be text");
+	if (input.html !== void 0 && typeof input.html !== "string") throw invalid("html must be text");
+	const messageId = `<${idempotencyKey.replace(/[^A-Za-z0-9.-]/g, ".")}@workflows.invalid>`;
+	await mail.send({
+		to: recipients(input.to),
+		subject: line(input.subject, "subject"),
+		text: input.text,
+		...input.html !== void 0 && { html: input.html },
+		headers: { "Message-ID": messageId },
+		attachments: await attachmentsOf(input.attachments, context)
+	});
+	return { message_id: messageId };
+};
+/**
+* `app:mail.send`: one message from the app's own sender; 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 mailSteps = { "mail.send": {
+	label: "Send mail",
+	description: "Sends a mail from the app's own sender.",
+	errorPrefix: "Mail",
+	input: {
+		type: "object",
+		required: [
+			"to",
+			"subject",
+			"text"
+		],
+		properties: {
+			to: { description: `one address, or a list of at most 50` },
+			subject: { description: "one line of text" },
+			text: { description: "the body as text" },
+			html: { description: "the body as HTML too" },
+			attachments: { description: "a list of file values the run keeps, at most 10 MiB together" }
+		}
+	},
+	output: {
+		type: "object",
+		description: "{ message_id }",
+		properties: { message_id: { type: "string" } }
+	},
+	errors: { InvalidArguments: "an argument has the wrong type, named in the cause" },
+	run: send
+} };
+//#endregion
+export { mailSteps };

package/dist/piece.js

@@ -0,0 +1,35 @@
+import { StepError } from "@protobase/workflows/plugin";
+//#region src/piece.ts
+/**
+* `app:piece`, which a definition may name but which runs no piece yet: it fails with `Piece.Error` until a plugin gives
+* connectors a handler that sends through the plugin context's guarded fetch.
+*/
+const pieceSteps = { piece: {
+	label: "Connector action",
+	description: "Runs an action of a connector. Not implemented yet: a run fails it.",
+	errorPrefix: "Piece",
+	input: {
+		type: "object",
+		required: [
+			"piece",
+			"action",
+			"connection"
+		],
+		properties: {
+			piece: { description: "the connector's name" },
+			action: { description: "one of its actions" },
+			connection: { description: "the connection holding its sign-in" },
+			props: { description: "the action's arguments, by name" }
+		}
+	},
+	output: { description: "what the action returns" },
+	errors: {
+		Error: "always, until connectors are implemented",
+		InvalidArguments: "piece, action or connection is missing"
+	},
+	run: async () => {
+		throw new StepError("Piece.Error", "No piece runs in this app yet");
+	}
+} };
+//#endregion
+export { pieceSteps };

package/dist/record-trigger.js

@@ -0,0 +1,46 @@
+//#region src/record-trigger.ts
+const name = {
+	type: "string",
+	minLength: 1
+};
+/**
+* `app:record`: one run per record of `resource` that becomes ready, as `when` says, with the record as the run's input.
+* Without `when`, every record is ready once it exists, so each new record starts one run.
+*/
+const recordTriggers = { record: {
+	kind: "ready",
+	label: "Record ready",
+	description: "Starts one run for each record that becomes ready, at once or when a time in it comes, once per ready key.",
+	input: {
+		type: "object",
+		additionalProperties: false,
+		required: ["resource"],
+		properties: {
+			resource: {
+				...name,
+				description: "the resource's name, as list_resources gives it"
+			},
+			when: {
+				type: "string",
+				minLength: 1,
+				description: "a filter on indexed fields, such as status = 'sent' and due_at <= now() - 3d; without it every record is ready"
+			},
+			key: {
+				type: "array",
+				items: name,
+				description: "fields whose new value makes a record ready again, such as due_at"
+			}
+		}
+	},
+	output: {
+		type: "object",
+		description: "{ resource, key, record }: the record as the workflow's last editor reads it"
+	},
+	ready: (input) => ({
+		resource: input.resource,
+		...input.when !== void 0 && { when: input.when },
+		...input.key !== void 0 && { key: input.key }
+	})
+} };
+//#endregion
+export { recordTriggers };

package/dist/records.js

@@ -0,0 +1,115 @@
+import { StepError } from "@protobase/workflows/plugin";
+//#region src/records.ts
+const resource = {
+	type: "string",
+	minLength: 1,
+	description: "the resource's name, as list_resources gives it"
+};
+const key = {
+	description: "the record's key",
+	anyOf: [
+		{ type: "string" },
+		{ type: "number" },
+		{
+			type: "array",
+			items: { type: ["string", "number"] }
+		}
+	]
+};
+const fieldValues = {
+	type: "object",
+	description: "an object of field values"
+};
+const errors = {
+	Refused: "the API refused it, its status and message in the cause",
+	InvalidArguments: "an argument has the wrong type, named in the cause"
+};
+const step = (label, description, input, output, run) => ({
+	label,
+	description,
+	errorPrefix: "Records",
+	input: {
+		type: "object",
+		...input
+	},
+	output: { description: output },
+	errors,
+	run
+});
+const listOf = (data) => {
+	if (!Array.isArray(data)) return;
+	return data.map((item, index) => {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) throw new StepError("Records.InvalidArguments", `data[${index}] must be an object of field values`);
+		return item;
+	});
+};
+/**
+* The `app:records.*` steps: create, update, get and list through the app's API as the user who saved the version the
+* run runs, so its access rules, tenant scope, validation and write hooks apply as they do to that user's requests.
+*/
+const recordsSteps = {
+	"records.create": step("Create records", "Creates records of the app's resources, as the workflow's last editor.", {
+		required: ["resource", "data"],
+		properties: {
+			resource,
+			data: {
+				description: "an object of field values, or a list of them, created in one batch: all or none",
+				anyOf: [fieldValues, {
+					type: "array",
+					items: fieldValues
+				}]
+			}
+		}
+	}, "the created record, or the list of them", async ({ input, records }) => {
+		const many = listOf(input.data);
+		if (many) return records.createMany(input.resource, many);
+		return records.create(input.resource, input.data);
+	}),
+	"records.update": step("Update a record", "Updates one record, as the workflow's last editor.", {
+		required: [
+			"resource",
+			"key",
+			"data"
+		],
+		properties: {
+			resource,
+			key,
+			data: {
+				...fieldValues,
+				description: "an object of the field values to change"
+			}
+		}
+	}, "the updated record", async ({ input, records }) => records.update(input.resource, input.key, input.data)),
+	"records.get": step("Get a record", "Reads one record, as the workflow's last editor.", {
+		required: ["resource", "key"],
+		properties: {
+			resource,
+			key
+		}
+	}, "the record", async ({ input, records }) => records.get(input.resource, input.key)),
+	"records.list": step("List records", "Lists records, as the workflow's last editor.", {
+		required: ["resource"],
+		properties: {
+			resource,
+			filter: {
+				type: "string",
+				description: "a filter in the API's syntax, such as status = \"open\""
+			},
+			order_by: {
+				type: "string",
+				description: "such as \"created_at desc\""
+			},
+			limit: {
+				type: "integer",
+				minimum: 1,
+				description: "how many at most"
+			}
+		}
+	}, "{ records }", async ({ input, records }) => ({ records: await records.list(input.resource, {
+		...input.filter !== void 0 && { filter: input.filter },
+		...input.order_by !== void 0 && { order_by: input.order_by },
+		...input.limit !== void 0 && { limit: input.limit }
+	}) }))
+};
+//#endregion
+export { recordsSteps };

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@protobase/workflow-plugins",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.68.1",
+  "description": "The built-in workflow trigger and step types, written on the public plugin interface like any other plugin.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PrototeamHQ/protobase.git",
+    "directory": "packages/workflow-plugins"
+  },
+  "homepage": "https://docs.protobase.net",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "prepack": "tsdown"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@protobase/workflows": "0.68.1"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.