@protobase/server 0.42.0 → 0.43.1

package/dist/aggregate-groups.js

@@ -1,7 +1,7 @@
 import { badRequest } from "./problem.js";
+import { readTransaction } from "./transactions.js";
 import { parseParams } from "./params.js";
 import { labelRequests, relatedLabels } from "./related-labels.js";
-import { readTransaction } from "./transactions.js";
 import { splitGroups } from "./aggregate-splits.js";
 import { scoped, seriesRange } from "./aggregate-service.js";
 import { z } from "zod";

package/dist/aggregate-service.js

@@ -1,14 +1,14 @@
 import { badRequest } from "./problem.js";
 import { checkedFilter } from "./filter-input.js";
 import { readScope, requestAccess, requireOperation } from "./request-access.js";
-import { parseParams } from "./params.js";
+import { readTransaction } from "./transactions.js";
 import { columnId, filterCondition, scopeConditions, tableId, whereClause } from "./sql-parts.js";
+import { parseParams } from "./params.js";
 import { labelRequests, relatedLabels } from "./related-labels.js";
-import { readTransaction } from "./transactions.js";
 import { rangeEnd, rangeStart } from "./range-ends.js";
 import { z } from "zod";
-import { facetCounts, histogram, series, withoutField } from "@protobase/query";
 import { sql } from "kysely";
+import { facetCounts, histogram, series, withoutField } from "@protobase/query";
 //#region src/aggregate-service.ts
 const field = z.string().min(1);
 const filter = z.string().optional();

package/dist/aggregate-splits.js

@@ -1,5 +1,5 @@
-import { labelRequests, relatedLabels } from "./related-labels.js";
 import { readTransaction } from "./transactions.js";
+import { labelRequests, relatedLabels } from "./related-labels.js";
 import { series, splitSeries } from "@protobase/query";
 //#region src/aggregate-splits.ts
 /**

package/dist/ai/generate-route.js

@@ -1,6 +1,6 @@
 import { HttpProblem, badRequest, forbidden, notFound } from "../problem.js";
-import { readRecord } from "../read-service.js";
 import { runWrite } from "../write-pipeline.js";
+import { readRecord } from "../read-service.js";
 import { ModelError } from "../assistant/chat-completions.js";
 import { generateValue } from "./generate-value.js";
 import { promptFields } from "@protobase/schema/internal";

package/dist/assistant/batch-approval.js

@@ -0,0 +1,60 @@
+const shownResources = 20;
+const valueLength = 80;
+const nameLength = 60;
+const unicodeEscape = (char) => {
+	const code = char.codePointAt(0);
+	return code > 65535 ? `\\u{${code.toString(16)}}` : `\\u${code.toString(16).padStart(4, "0")}`;
+};
+const escaped = (json) => json.replace(/[\p{Cc}\p{Cf}\u2028\u2029`<>]/gu, unicodeEscape).replace(/"(?:[^"\\]|\\.)*"/g, (text) => text.replace(/[[\]]/g, unicodeEscape));
+const cut = (text, length) => text.length > length ? `${text.slice(0, length - 1)}…` : text;
+const quoted = (value, length) => cut(escaped(JSON.stringify(value) ?? "null"), length);
+const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+const counted = (value, length) => {
+	const text = escaped(JSON.stringify(value) ?? "null");
+	return text.length > length ? `${text.slice(0, length)}… (${plural(text.length - length, "more character")})` : text;
+};
+const fieldsOf = (data) => `{${Object.entries(data).map(([name, value]) => `${counted(name, nameLength)}:${counted(value, valueLength)}`).join(",")}}`;
+const lineOf = (operation, index) => {
+	const target = operation.op === "create" ? quoted(operation.resource, nameLength) : `${quoted(operation.resource, nameLength)} ${quoted(operation.key, nameLength)}`;
+	const values = operation.op === "delete" ? "" : ` ${fieldsOf(operation.data)}`;
+	return `${index + 1}. ${operation.op} ${target}${values}`;
+};
+const countsOf = (operations) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const { op, resource } of operations) {
+		const known = counts.get(resource) ?? {
+			create: 0,
+			update: 0,
+			delete: 0
+		};
+		known[op] += 1;
+		counts.set(resource, known);
+	}
+	return [...counts];
+};
+const capped = (lines) => lines.length > shownResources ? [...lines.slice(0, shownResources), `and ${plural(lines.length - shownResources, "more resource")}`] : lines;
+/**
+* The approval of `operations`; `softDeletes` names the resources whose deletes can be restored, and a delete on any
+* other is said to be permanent.
+*/
+const batchApproval = (operations, softDeletes) => {
+	const counts = countsOf(operations);
+	const permanent = counts.filter(([resource, { delete: deletes }]) => deletes > 0 && !softDeletes.has(resource));
+	const lasting = permanent.reduce((sum, [, { delete: deletes }]) => sum + deletes, 0);
+	const warning = lasting > 0 ? [`${plural(lasting, "delete")} cannot be undone:`, ...capped(permanent.map(([resource, { delete: deletes }]) => `${plural(deletes, "delete")} in ${quoted(resource, nameLength)}`))] : [];
+	const summary = capped(counts.map(([resource, count]) => `${quoted(resource, nameLength)}: ${plural(count.create, "create")}, ${plural(count.update, "update")}, ${plural(count.delete, "delete")}`));
+	const rest = operations.length - 50;
+	const lines = operations.slice(0, 50).map(lineOf);
+	return {
+		title: `Run ${plural(operations.length, "write")} in one transaction?`,
+		body: [
+			...warning,
+			"Either all of them are written or none.",
+			...summary
+		].join("\n"),
+		code: [...lines, ...rest > 0 ? [`and ${plural(rest, "more operation")}, counted above`] : []].join("\n"),
+		approveLabel: "Write all"
+	};
+};
+//#endregion
+export { batchApproval };

package/dist/assistant/batch-write-args.js

@@ -0,0 +1,63 @@
+//#region src/assistant/batch-write-args.ts
+/**
+* The `batch_write` tool's arguments, checked before anything is asked or written: only creates, updates and deletes,
+* only the fields each takes, an update's ETag always given, and no more operations than the REST batch takes. A
+* delete's ETag passes exactly as sent, so one left out stays left out.
+*/
+const fieldsOf = {
+	create: [
+		"op",
+		"resource",
+		"data",
+		"ref"
+	],
+	update: [
+		"op",
+		"resource",
+		"key",
+		"etag",
+		"data"
+	],
+	delete: [
+		"op",
+		"resource",
+		"key",
+		"etag"
+	]
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isText = (value) => typeof value === "string" && value.trim() !== "";
+const isRef = (value) => isObject(value) && isText(value.$ref) && Object.keys(value).every((name) => name === "$ref" || name === "field" && isText(value.field));
+const isPart = (value) => typeof value === "string" || typeof value === "number" && Number.isFinite(value) || isRef(value);
+const isKey = (value) => isPart(value) || Array.isArray(value) && value.length > 0 && value.every(isPart);
+const problemOf = (value, index) => {
+	const at = `operations[${index}]`;
+	if (!isObject(value)) return `${at} is not an object`;
+	const op = value.op;
+	if (op !== "create" && op !== "update" && op !== "delete") return `${at} has op ${JSON.stringify(op)}; a batch takes create, update and delete`;
+	const unknown = Object.keys(value).filter((name) => !fieldsOf[op].includes(name));
+	if (unknown.length > 0) return `${at} has fields a ${op} does not take: ${unknown.map((name) => JSON.stringify(name)).join(", ")}`;
+	if (!isText(value.resource)) return `${at} needs the resource's name`;
+	if (op !== "delete" && !isObject(value.data)) return `${at} needs its data as an object of field names to values`;
+	if (op === "create") return value.ref === void 0 || isText(value.ref) ? void 0 : `${at} has a ref that is not a name`;
+	if (!isKey(value.key)) return `${at} needs the record's key: a string, a number, a list of them, or { "$ref": "<name>" }`;
+	if (op === "update" && !isText(value.etag)) return `${at} needs the etag the record was read with, or "*" to update any version`;
+	if (op === "delete" && "etag" in value && typeof value.etag !== "string") return `${at} has an etag that is not a string`;
+};
+/** The operations to run, or why the batch is refused, naming the operation at fault. */
+const batchOperationsOf = (args) => {
+	const unknown = Object.keys(args).filter((name) => name !== "operations");
+	if (unknown.length > 0) return { problem: `The batch takes only "operations", not ${unknown.map((name) => JSON.stringify(name)).join(", ")}` };
+	const operations = args.operations;
+	if (!Array.isArray(operations) || operations.length === 0) return { problem: "Pass the writes as { \"operations\": [{ \"op\": \"create\" | \"update\" | \"delete\", \"resource\": \"<name>\", ... }] }" };
+	if (operations.length > 500) return { problem: `A batch takes at most 500 operations, not ${operations.length}` };
+	for (const [index, operation] of operations.entries()) {
+		const problem = problemOf(operation, index);
+		if (problem) return { problem };
+	}
+	const refs = operations.flatMap((operation) => operation.ref === void 0 ? [] : [operation.ref]);
+	if (new Set(refs).size !== refs.length) return { problem: "Each create may use a ref name once" };
+	return { operations };
+};
+//#endregion
+export { batchOperationsOf };

package/dist/assistant/batch-write-tool.d.ts

@@ -0,0 +1,7 @@
+import { AssistantTool } from "./tools.js";
+import { WriteRecordToolsInput } from "./write-tool-limits.js";
+import "./write-record-tools.js";
+//#region src/assistant/batch-write-tool.d.ts
+/** Runs many writes in one transaction once the user approves them, under the caller's access rules. */
+export declare const batchWriteTool: (input?: WriteRecordToolsInput) => AssistantTool;
+//#endregion

package/dist/assistant/batch-write-tool.js

@@ -0,0 +1,115 @@
+import { HttpProblem } from "../problem.js";
+import { defineTool } from "./tools.js";
+import { batchApproval } from "./batch-approval.js";
+import { batchOperationsOf } from "./batch-write-args.js";
+//#region src/assistant/batch-write-tool.ts
+/**
+* `batch_write`: many creates, updates and deletes across resources in one transaction, through the REST API's batch
+* write, after the user approves the batch once. Over MCP the tool runs again from the start with the user's answer, so
+* everything before `approve` only checks the arguments and builds the approval text: nothing is read or written.
+*/
+const writes = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	openWorldHint: false
+};
+const refusal = (error, message, extras = {}) => JSON.stringify({
+	error,
+	message,
+	...extras
+});
+const refused = (error) => {
+	if (!(error instanceof HttpProblem) || error.status >= 500) throw error;
+	return refusal(error.slug, `${error.detail}; nothing was written.`, error.extras);
+};
+const outside = ({ resources }, operations) => {
+	if (!resources) return void 0;
+	const index = operations.findIndex((operation) => !resources.includes(operation.resource));
+	if (index === -1) return void 0;
+	const { op, resource } = operations[index];
+	return refusal("forbidden", `Writes over MCP reach only ${resources.join(", ")}; operations[${index}] names another resource, so nothing was written.`, {
+		operation: index,
+		op,
+		resource
+	});
+};
+const softDeleteSet = async (context, operations) => {
+	for (const [index, operation] of operations.entries()) {
+		if (operation.op !== "update") continue;
+		const field = await context.records.softDeleteField(operation.resource);
+		if (field && Object.hasOwn(operation.data, field)) return refusal("forbidden", `operations[${index}] sets ${field}, which deleting sets; delete with a delete operation. Nothing was written.`, {
+			operation: index,
+			op: operation.op,
+			resource: operation.resource
+		});
+	}
+};
+const softDeletesFor = async (context, operations) => {
+	if (!operations.some((operation) => operation.op === "delete")) return /* @__PURE__ */ new Set();
+	const { models } = await context.resources();
+	return new Set(models.filter((model) => model.softDelete).map((model) => model.name));
+};
+const operationsParameter = (input) => ({
+	type: "array",
+	minItems: 1,
+	description: `The writes, run in order.${input.resources ? ` Each names one of ${input.resources.join(", ")}.` : ""}`,
+	items: {
+		type: "object",
+		properties: {
+			op: {
+				type: "string",
+				description: "create, update or delete."
+			},
+			resource: {
+				type: "string",
+				description: "The resource's name, as list_resources gives it."
+			},
+			key: {
+				anyOf: [
+					{ type: "string" },
+					{ type: "number" },
+					{ type: "array" },
+					{ type: "object" }
+				],
+				description: "An update's or delete's record key: its value, the values of its key fields in order, or { \"$ref\": \"<name>\" } for a record created earlier in the batch."
+			},
+			etag: {
+				type: "string",
+				description: "The etag the record was read with: required on an update (\"*\" for any version), optional on a delete."
+			},
+			data: {
+				type: "object",
+				description: "A create's or update's field names to values; a value { \"$ref\": \"<name>\" } is the key of a record created earlier in the batch."
+			},
+			ref: {
+				type: "string",
+				description: "A create's name, for later operations to point at."
+			}
+		}
+	}
+});
+/** Runs many writes in one transaction once the user approves them, under the caller's access rules. */
+const batchWriteTool = (input = {}) => defineTool({
+	name: "batch_write",
+	description: `Creates, updates and deletes records across resources in one transaction: either all are written or none, and an update or delete with an etag fails the batch when its record changed since. Returns { results } with each created or updated record and its new etag. The user approves the batch in their client first; nothing is written without it.${input.resources ? ` It writes only ${input.resources.join(", ")}.` : ""}`,
+	parameters: {
+		type: "object",
+		properties: { operations: operationsParameter(input) },
+		required: ["operations"]
+	},
+	annotations: writes,
+	run: async (args, context) => {
+		const parsed = batchOperationsOf(args);
+		if ("problem" in parsed) return refusal("invalid-argument", `${parsed.problem}; nothing was written.`);
+		const { operations } = parsed;
+		const outsideRefusal = outside(input, operations);
+		if (outsideRefusal) return outsideRefusal;
+		const softDeleteRefusal = await softDeleteSet(context, operations).catch(refused);
+		if (softDeleteRefusal) return softDeleteRefusal;
+		const answer = await context.approve(batchApproval(operations, await softDeletesFor(context, operations)));
+		if (answer !== "approved") return `The user did not approve this batch (${answer}); nothing was written.`;
+		return context.records.batch(operations).then((results) => JSON.stringify({ results }), refused);
+	}
+});
+//#endregion
+export { batchWriteTool };

package/dist/assistant/record-tool-args.js

@@ -8,6 +8,15 @@ const refused = (error) => {
 	});
 	throw error;
 };
+/** `show_deleted` as JSON `true` or `false`, absent being `false`; undefined for any other value, such as `"true"` or `1`. */
+const showDeletedOf = (args) => {
+	if (args.show_deleted === void 0) return false;
+	return typeof args.show_deleted === "boolean" ? args.show_deleted : void 0;
+};
+const invalidShowDeleted = JSON.stringify({
+	error: "invalid-parameter",
+	message: "Invalid parameter show_deleted: pass true or false"
+});
 const resourceOf = (args) => typeof args.resource === "string" && args.resource ? args.resource : void 0;
 const keyOf = (value) => {
 	if (typeof value === "string" || typeof value === "number") return value;
@@ -29,5 +38,9 @@ const keyParameter = {
 		}
 	]
 };
+const showDeletedParameter = {
+	type: "boolean",
+	description: "true also returns soft-deleted records; only on a resource list_resources marks soft_delete."
+};
 //#endregion
-export { keyOf, keyParameter, refused, resourceOf, resourceParameter };
+export { invalidShowDeleted, keyOf, keyParameter, refused, resourceOf, resourceParameter, showDeletedOf, showDeletedParameter };

package/dist/assistant/record-tools.js

@@ -1,5 +1,5 @@
 import { defineTool } from "./tools.js";
-import { keyOf, keyParameter, refused, resourceOf, resourceParameter } from "./record-tool-args.js";
+import { invalidShowDeleted, keyOf, keyParameter, refused, resourceOf, resourceParameter, showDeletedOf, showDeletedParameter } from "./record-tool-args.js";
 //#region src/assistant/record-tools.ts
 const readOnly = {
 	readOnlyHint: true,
@@ -27,13 +27,14 @@ const resourceEntry = (model, view) => ({
 	...view?.names && { label: view.names.plural },
 	...view?.help && { help: view.help },
 	key: model.primaryKey,
+	soft_delete: model.softDelete !== void 0,
 	fields: Object.values(model.fields).map((field) => fieldEntry(field, view))
 });
 const described = ({ models, views }) => models.map((model) => resourceEntry(model, views.find((view) => view.resource === model.name)));
 /** Lists the resources the caller may read, with their fields, labels and which fields filters and sorts take. */
 const listResourcesTool = () => defineTool({
 	name: "list_resources",
-	description: "Lists the resources you may read, as JSON: each with its name, label, key fields and fields (name, type, label, enum values, the resource a relation links to, and whether it is optional, read-only, filterable and sortable). Filters and order_by in list_records take only fields marked filterable or sortable.",
+	description: "Lists the resources you may read, as JSON: each with its name, label, key fields, whether it soft deletes (soft_delete) and fields (name, type, label, enum values, the resource a relation links to, and whether it is optional, read-only, filterable and sortable). Filters and order_by in list_records take only fields marked filterable or sortable.",
 	parameters: {
 		type: "object",
 		properties: {}
@@ -44,7 +45,7 @@ const listResourcesTool = () => defineTool({
 /** Finds records of a resource with the REST API's filters, sorting and pages, under the caller's access rules. */
 const listRecordsTool = () => defineTool({
 	name: "list_records",
-	description: `Finds records of a resource and returns a page of them as JSON ({ items, next_page_token, total_size_estimate }). filter uses AIP-160 syntax, such as status = "open" AND amount > 10, and order_by a comma-separated list of fields, each optionally followed by desc. Pass next_page_token back as page_token for the next page; it is empty on the last.`,
+	description: `Finds records of a resource and returns a page of them as JSON ({ items, next_page_token, total_size_estimate }). filter uses AIP-160 syntax, such as status = "open" AND amount > 10, and order_by a comma-separated list of fields, each optionally followed by desc. Pass next_page_token back as page_token for the next page; it is empty on the last. show_deleted: true also returns soft-deleted records.`,
 	parameters: {
 		type: "object",
 		properties: {
@@ -66,7 +67,8 @@ const listRecordsTool = () => defineTool({
 			page_token: {
 				type: "string",
 				description: "The next_page_token of the previous page."
-			}
+			},
+			show_deleted: showDeletedParameter
 		},
 		required: ["resource"]
 	},
@@ -74,11 +76,14 @@ const listRecordsTool = () => defineTool({
 	run: async (args, context) => {
 		const resource = resourceOf(args);
 		if (!resource) return "Pass the resource as { \"resource\": \"<name>\" }.";
+		const showDeleted = showDeletedOf(args);
+		if (showDeleted === void 0) return invalidShowDeleted;
 		const params = {
 			...typeof args.filter === "string" && { filter: args.filter },
 			...typeof args.order_by === "string" && { order_by: args.order_by },
 			...typeof args.page_token === "string" && { page_token: args.page_token },
-			page_size: typeof args.page_size === "number" ? Math.min(args.page_size, maxPageSize) : defaultPageSize
+			page_size: typeof args.page_size === "number" ? Math.min(args.page_size, maxPageSize) : defaultPageSize,
+			...showDeleted && { show_deleted: true }
 		};
 		return context.records.list(resource, params).then((page) => JSON.stringify(page), refused);
 	}
@@ -86,12 +91,13 @@ const listRecordsTool = () => defineTool({
 /** Reads one record by its key, under the caller's access rules. */
 const getRecordTool = () => defineTool({
 	name: "get_record",
-	description: "Reads one record of a resource by its key and returns it as JSON ({ record, etag }).",
+	description: "Reads one record of a resource by its key and returns it as JSON ({ record, etag }). show_deleted: true also finds a soft-deleted record.",
 	parameters: {
 		type: "object",
 		properties: {
 			resource: resourceParameter,
-			key: keyParameter
+			key: keyParameter,
+			show_deleted: showDeletedParameter
 		},
 		required: ["resource", "key"]
 	},
@@ -100,7 +106,9 @@ const getRecordTool = () => defineTool({
 		const resource = resourceOf(args);
 		const key = keyOf(args.key);
 		if (!resource || key === void 0) return "Pass the resource and key as { \"resource\": \"<name>\", \"key\": \"<key>\" }.";
-		return context.records.get(resource, key).then((record) => JSON.stringify(record), refused);
+		const showDeleted = showDeletedOf(args);
+		if (showDeleted === void 0) return invalidShowDeleted;
+		return context.records.get(resource, key, { show_deleted: showDeleted }).then((record) => JSON.stringify(record), refused);
 	}
 });
 /** `list_resources`, `list_records` and `get_record`: reading the app's records as the caller, through the REST API's rules. */

package/dist/assistant/records.d.ts

@@ -1,5 +1,7 @@
 import { Row } from "../types.js";
 import "../deps.js";
+import { BatchOperation } from "../batch/schema.js";
+import { BatchResult } from "../batch/run-batch.js";
 //#region src/assistant/records.d.ts
 /** A record's key: its URL text (`a,b` when composite), a scalar, or its parts. */
 export type RecordKeyInput = string | number | Array<string | number>;
@@ -40,7 +42,10 @@ export type RecordPage = {
  */
 export type ToolRecords = {
   list: (resource: string, params?: ListParams) => Promise<RecordPage>;
-  get: (resource: string, key: RecordKeyInput) => Promise<ToolRecord>;
+  /** With `show_deleted`, also finds a soft-deleted record, as the REST API's `show_deleted` does. */
+  get: (resource: string, key: RecordKeyInput, options?: {
+    show_deleted?: boolean;
+  }) => Promise<ToolRecord>;
   create: (resource: string, data: Row) => Promise<ToolRecord>;
   /** With `etag`, fails with 412 when the record changed since it was read; without, it updates any version. */
   update: (resource: string, key: RecordKeyInput, data: Row, options?: {
@@ -55,5 +60,10 @@ export type ToolRecords = {
   }) => Promise<ToolRecord>;
   /** The field a delete sets on a resource with `.softDelete()`, from its config; undefined when a delete removes the record. */
   softDeleteField: (resource: string) => Promise<string | undefined>;
+  /**
+   * The operations in order in one transaction, as the REST API's batch write runs them: all are written or none, and
+   * a refusal names the failing operation (`extras.operation`, its index).
+   */
+  batch: (operations: BatchOperation[]) => Promise<BatchResult[]>;
 };
 //#endregion

package/dist/assistant/records.js

@@ -1,8 +1,9 @@
 import { notFound } from "../problem.js";
+import { runWrite } from "../write-pipeline.js";
 import { decodeKeyText } from "../key.js";
+import { runBatch } from "../batch/run-batch.js";
 import { listRecords } from "../list-service.js";
 import { readRecord } from "../read-service.js";
-import { runWrite } from "../write-pipeline.js";
 import { encodeKey } from "@protobase/schema/internal";
 //#region src/assistant/records.ts
 const filterLength = 2e5;
@@ -22,9 +23,9 @@ const assistantRecords = (deps, session) => {
 	};
 	return {
 		list: async (resource, params = {}) => (await listRecords(deps, entryOf(resource), session, params, filterLength)).body,
-		get: async (resource, input) => {
+		get: async (resource, input, { show_deleted } = {}) => {
 			const { entry, key } = keyOf(resource, input);
-			const { record, etag } = await readRecord(deps, entry, session, key);
+			const { record, etag } = await readRecord(deps, entry, session, key, show_deleted);
 			return {
 				record,
 				etag
@@ -51,7 +52,8 @@ const assistantRecords = (deps, session) => {
 				ifMatch: etag ?? "*"
 			});
 		},
-		softDeleteField: async (resource) => entryOf(resource).model.softDelete
+		softDeleteField: async (resource) => entryOf(resource).model.softDelete,
+		batch: (operations) => runBatch(deps, session, operations)
 	};
 };
 const withoutAdmin = () => Promise.reject(/* @__PURE__ */ new Error("This assistant has no records: ToolContext.records works in the built-in assistant"));
@@ -62,7 +64,8 @@ const noRecords = {
 	create: withoutAdmin,
 	update: withoutAdmin,
 	delete: withoutAdmin,
-	softDeleteField: withoutAdmin
+	softDeleteField: withoutAdmin,
+	batch: withoutAdmin
 };
 //#endregion
 export { assistantRecords, noRecords };

package/dist/batch/reorder.js

@@ -3,8 +3,8 @@ import { tenantScope } from "../tenant.js";
 import { requireOperation, targetFilter, writableFields } from "../request-access.js";
 import { columnId, keyConditions, scopeConditions, tableId, whereClause } from "../sql-parts.js";
 import { fetchRecord } from "../records.js";
-import { refuseUnknownField, validateBody } from "../validate-body.js";
 import { missing, shown } from "../write-shared.js";
+import { refuseUnknownField, validateBody } from "../validate-body.js";
 import { applyUpdate, planUpdate } from "../write-update.js";
 import { checkRankAfter } from "../rank-after.js";
 import { encodeKey } from "@protobase/schema/internal";

package/dist/batch/run-batch.d.ts

@@ -0,0 +1,26 @@
+import { Row } from "../types.js";
+import "../deps.js";
+import { WriteResult } from "../write-shared.js";
+import "./schema.js";
+//#region src/batch/run-batch.d.ts
+export type BatchResult = {
+  op: 'create';
+  resource: string;
+  ref?: string;
+  record: Row;
+  etag: string;
+} | {
+  op: 'update';
+  resource: string;
+  record: Row;
+  etag: string;
+} | {
+  op: 'delete';
+  resource: string;
+  deleted: true;
+} | {
+  op: 'reorder';
+  resource: string;
+  records: WriteResult[];
+};
+//#endregion

package/dist/batch/run-batch.js

@@ -1,8 +1,8 @@
 import { HttpProblem, badRequest, notFound } from "../problem.js";
 import { requestAccess } from "../request-access.js";
-import { writeTransaction } from "../transactions.js";
-import { problemOf } from "../error-handler.js";
 import { actorSettings, wakeDispatch } from "../changes/actor.js";
+import { problemOf } from "../error-handler.js";
+import { writeTransaction } from "../transactions.js";
 import { keyOf } from "../write-shared.js";
 import { writeIn } from "../write-pipeline.js";
 import { resolveData, resolveKey } from "./refs.js";