@protobase/server 0.26.5 → 0.26.7

package/dist/rest/respond.js

@@ -0,0 +1,35 @@
+import { restError } from "./rest-error.js";
+import { contentRange, rangeStatus } from "./content-range.js";
+//#region src/rest/respond.ts
+const jsonType = "application/json; charset=utf-8";
+const objectType = "application/vnd.pgrst.object+json; charset=utf-8";
+/** Whether the client asked for one object rather than an array, as `.single()` and `.maybeSingle()` do. */
+const wantsObject = (request) => (request.headers.get("accept") ?? "").includes("application/vnd.pgrst.object+json");
+/** PGRST116 unless there is exactly one row, which an object response needs. */
+const checkSingle = (rows) => {
+	if (rows !== 1) throw restError(406, "PGRST116", "Cannot coerce the result to a single JSON object", `The result contains ${rows} rows`);
+};
+/** The one element of a JSON array of one element, as Postgres's `json_agg` writes it: `[` and `]` around it. */
+const onlyElement = (array) => array.slice(1, -1);
+/** The response of a page of rows read from `offset`: an array, or one object when asked for. */
+const pageResponse = (page, offset, object, headers = {}) => {
+	const status = rangeStatus(offset, page.page, page.total);
+	if (object) checkSingle(page.page);
+	return new Response(object ? onlyElement(page.body) : page.body, {
+		status,
+		headers: {
+			"content-range": contentRange(offset, page.page, page.total),
+			"content-type": object ? objectType : jsonType,
+			...headers
+		}
+	});
+};
+const errorResponse = (error) => new Response(JSON.stringify(error.body), {
+	status: error.status,
+	headers: {
+		"content-type": jsonType,
+		...error.headers
+	}
+});
+//#endregion
+export { checkSingle, errorResponse, jsonType, objectType, onlyElement, pageResponse, wantsObject };

package/dist/rest/rest-context.js

@@ -0,0 +1,31 @@
+import { readTransaction, writeTransaction } from "../transactions.js";
+import { wakeDispatch } from "../changes/actor.js";
+import { callerSettings } from "./caller-settings.js";
+import { restError } from "./rest-error.js";
+//#region src/rest/rest-context.ts
+/**
+* Runs `work` in one transaction as the request's caller (see `callerSettings`), under the statement timeout;
+* read-only for a read, so a function that writes fails as on PostgREST.
+*/
+const asCaller = async (deps, c, readOnly, work) => {
+	const settings = callerSettings(c.get("caller"), deps.actorSetting);
+	if (readOnly) return readTransaction(deps.db, deps.statementTimeoutMs, work, settings);
+	const result = await writeTransaction(deps.db, deps.statementTimeoutMs, work, settings);
+	wakeDispatch(deps);
+	return result;
+};
+/** The request's query parameters in order, decoded as `URLSearchParams` decodes them. */
+const queryParams = (c) => [...new URL(c.req.url).searchParams];
+/** The JSON body; `empty` when there is none, as a function called without arguments may send. Invalid JSON is PGRST102. */
+const readBody = async (c, empty) => {
+	const text = await c.req.text();
+	if (text.trim() === "" && empty !== void 0) return empty;
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw restError(400, "PGRST102", "Empty or invalid json");
+		throw error;
+	}
+};
+//#endregion
+export { asCaller, queryParams, readBody };

package/dist/rest/rest-error.js

@@ -0,0 +1,80 @@
+import { isDatabaseError } from "../error-handler.js";
+//#region src/rest/rest-error.ts
+/** A `/rest/v1` error: its status, the body, and headers such as `Content-Range`. Thrown anywhere below the route. */
+var RestError = class RestError extends Error {
+	status;
+	body;
+	headers;
+	constructor(status, body, headers = {}) {
+		super(body.message);
+		this.status = status;
+		this.body = body;
+		this.headers = headers;
+	}
+	withHeaders(headers) {
+		return new RestError(this.status, this.body, {
+			...this.headers,
+			...headers
+		});
+	}
+};
+const restError = (status, code, message, details = null, hint = null) => new RestError(status, {
+	code,
+	details,
+	hint,
+	message
+});
+/** PGRST100: a query parameter that does not parse. */
+const parseError = (message, details = null) => restError(400, "PGRST100", message, details);
+const prefixStatus = [
+	["08", 503],
+	["09", 500],
+	["0L", 403],
+	["0P", 403],
+	["25", 500],
+	["28", 403],
+	["2D", 500],
+	["38", 500],
+	["39", 500],
+	["3B", 500],
+	["40", 500],
+	["53", 503],
+	["54", 500],
+	["55", 500],
+	["57", 500],
+	["58", 500],
+	["F0", 500],
+	["HV", 500],
+	["P0", 500],
+	["XX", 500]
+];
+const codeStatus = {
+	"23503": 409,
+	"23505": 409,
+	"25006": 405,
+	"53400": 500,
+	"57P01": 503,
+	P0001: 400,
+	"42883": 404,
+	"42P01": 404,
+	"42P17": 500
+};
+const databaseStatus = (code, message, anonymous) => {
+	if (code === "42501") return anonymous ? 401 : 403;
+	if (code.startsWith("PT")) return Number(code.slice(2)) || 500;
+	if (code === "21000") return message.endsWith("requires a WHERE clause") ? 400 : 500;
+	return codeStatus[code] ?? prefixStatus.find(([prefix]) => code.startsWith(prefix))?.[1] ?? 400;
+};
+/**
+* The `/rest/v1` error an error stands for: its own, or a database error with PostgREST's status and the error's
+* message, detail and hint, which PostgREST passes on as they are. Other errors give `undefined`. Refusing a write by
+* RLS is 401 for an anonymous caller and 403 for others, as on Supabase.
+*/
+const restErrorOf = (error, anonymous) => {
+	if (error instanceof RestError) return error;
+	if (!isDatabaseError(error)) return void 0;
+	const { code, message, detail, hint } = error;
+	return restError(databaseStatus(code, message, anonymous), code, message, detail ?? null, hint ?? null);
+};
+//#endregion
+export { RestError, parseError, restError, restErrorOf };

package/dist/rest/rest-routes.js

@@ -0,0 +1,33 @@
+import { HttpProblem } from "../problem.js";
+import { restError, restErrorOf } from "./rest-error.js";
+import { errorResponse } from "./respond.js";
+import { rpcRoute } from "./rpc-route.js";
+import { tableRoutes } from "./table-routes.js";
+import { Hono } from "hono";
+//#region src/rest/rest-routes.ts
+/**
+* The PostgREST-compatible API supabase-js's `from()` and `rpc()` call, mounted at `/rest/v1`. Each request runs in one
+* transaction as `anon`, `authenticated` or the app's own role, so the tables' RLS policies decide what it may read and
+* write. Errors come back as PostgREST's `{ code, details, hint, message }`; an unexpected one as a 500 that names
+* nothing of it.
+*/
+const restRoutes = ({ deps, caller, report }) => {
+	const app = new Hono();
+	app.onError((error, c) => {
+		const known = restErrorOf(error, c.get("caller")?.role === "anon");
+		if (known) return errorResponse(known);
+		if (error instanceof HttpProblem) return errorResponse(restError(error.status, error.status === 401 ? "PGRST301" : "PGRST000", error.detail).withHeaders(error.headers));
+		report?.(error, c.req.raw);
+		return errorResponse(restError(500, "PGRST000", "The server failed to handle the request"));
+	});
+	app.use("*", async (c, next) => {
+		c.set("caller", await caller(c.req.raw));
+		await next();
+	});
+	app.route("/", rpcRoute(deps));
+	app.route("/", tableRoutes(deps));
+	app.notFound(() => errorResponse(restError(404, "PGRST125", "Invalid path specified in request URL")));
+	return app;
+};
+//#endregion
+export { restRoutes };

package/dist/rest/rest-scan.js

@@ -0,0 +1,94 @@
+import { restError } from "./rest-error.js";
+//#region src/rest/rest-scan.ts
+const needs = {
+	eq: "equality",
+	neq: "btree",
+	gt: "btree",
+	gte: "btree",
+	lt: "btree",
+	lte: "btree",
+	in: "btree",
+	is: "btree",
+	isdistinct: "btree",
+	like: "trigram",
+	ilike: "trigram",
+	match: "trigram",
+	imatch: "trigram",
+	fts: "gin",
+	plfts: "gin",
+	phfts: "gin",
+	wfts: "gin",
+	cs: "containment",
+	cd: "containment",
+	ov: "containment",
+	sl: "gist",
+	sr: "gist",
+	nxr: "gist",
+	nxl: "gist",
+	adj: "gist"
+};
+const trigramClasses = ["gin_trgm_ops", "gist_trgm_ops"];
+const quoted = (name) => `"${name.replaceAll("\"", "\"\"")}"`;
+const pathKey = (path) => path.column + path.json.map((step) => `${step.arrow}${typeof step.key === "number" ? step.key : `'${step.key}'`}`).join("");
+const normalized = (definition) => definition.replaceAll("::text", "").replace(/[\s()"]/g, "");
+const keyMatches = (key, path) => path.json.length === 0 ? key.column === path.column : key.column === null && normalized(key.definition) === pathKey(path);
+const keyName = (key) => key.column ?? normalized(key.definition);
+const serves = (index, read, pinned) => {
+	if (index.partial) return false;
+	const position = index.keys.findIndex((key) => keyMatches(key, read.field));
+	if (position < 0) return false;
+	switch (read.need) {
+		case "equality":
+			if (trigramClasses.includes(index.keys[position].opclass)) return true;
+			return index.method === "btree" && index.keys.slice(0, position).every((key) => pinned.has(keyName(key)));
+		case "btree": return index.method === "btree" && index.keys.slice(0, position).every((key) => pinned.has(keyName(key)));
+		case "trigram": return trigramClasses.includes(index.keys[position].opclass);
+		case "gin":
+		case "containment": return index.method === "gin" || index.method === "gist";
+		case "gist": return index.method === "gist";
+	}
+};
+const pinnedFields = (filter) => {
+	if (filter.negated) return [];
+	if (filter.kind === "and") return filter.args.flatMap(pinnedFields);
+	if (filter.kind === "condition" && [
+		"eq",
+		"in",
+		"is"
+	].includes(filter.operator) && !filter.quantifier) return [pathKey(filter.field)];
+	return [];
+};
+const filterReads = (filter) => filter.kind === "condition" ? [{
+	field: filter.field,
+	need: needs[filter.operator],
+	use: "filter"
+}] : filter.args.flatMap(filterReads);
+const suggestion = (table, read) => {
+	const column = read.field.json.length === 0 ? quoted(read.field.column) : `(${pathKey(read.field).replace(read.field.column, quoted(read.field.column))})`;
+	if (read.need === "trigram") return `create index on ${table} using gin (${column} gin_trgm_ops)`;
+	if (read.need === "gin" || read.need === "containment") return `create index on ${table} using gin (${column})`;
+	if (read.need === "gist") return `create index on ${table} using gist (${column})`;
+	return `create index on ${table} (${column})`;
+};
+/**
+* The reads of a request no index of the table serves: each filtered field, by the kind of index its operator needs,
+* and the first sort field. A view or a foreign table has no indexes of its own and is not judged.
+*/
+const uncoveredReads = (table, filters, order) => {
+	if (table.kind !== "table") return [];
+	const pinned = new Set(filters.flatMap(pinnedFields));
+	return [...filters.flatMap(filterReads), ...order[0] ? [{
+		field: order[0].field,
+		need: "btree",
+		use: "sort"
+	}] : []].filter((read) => !table.indexes.some((index) => serves(index, read, pinned)));
+};
+/** The 400 error of a read no index serves, with the statement that adds one as its hint. */
+const scanRefusal = (table, read) => {
+	const tableName = table.schema ? `${quoted(table.schema)}.${quoted(table.name)}` : quoted(table.name);
+	const what = read.use === "sort" ? "Sorting by" : "Filtering on";
+	const index = read.need === "btree" || read.need === "equality" ? "an index" : read.need === "trigram" ? "a pg_trgm index" : read.need === "gist" ? "a GiST index" : "a GIN index";
+	return restError(400, "expensive-query", `${what} "${pathKey(read.field)}" needs ${index} that serves it`, null, suggestion(tableName, read));
+};
+//#endregion
+export { scanRefusal, uncoveredReads };

package/dist/rest/rpc-route.js

@@ -0,0 +1,65 @@
+import { jsonType, onlyElement, pageResponse, wantsObject } from "./respond.js";
+import { callSource, chooseFunction, findFunctions } from "./functions.js";
+import { parsePrefer } from "./parse-prefer.js";
+import { parseQuery } from "./parse-query.js";
+import { readRows } from "./read-rows.js";
+import { asCaller, queryParams, readBody } from "./rest-context.js";
+import { Hono } from "hono";
+import { sql } from "kysely";
+//#region src/rest/rpc-route.ts
+const reserved = /* @__PURE__ */ new Set([
+	"select",
+	"order",
+	"limit",
+	"offset",
+	"on_conflict",
+	"columns"
+]);
+/**
+* Calls a function of the `public` schema: by POST with its arguments in a JSON object, or the whole body as its one
+* unnamed json argument; by GET with them in the query string, in a read-only transaction. A function returning rows
+* is read like a table, with `select`, filters, `order`, a range and a count; one returning one row gives an object,
+* a scalar its JSON value, `void` 204.
+*/
+const call = async (deps, c) => {
+	const name = c.req.param("fn");
+	const get = c.req.method === "GET";
+	const params = queryParams(c);
+	const body = get ? void 0 : await readBody(c, {});
+	const prefer = parsePrefer(c.req.header("prefer") ?? null);
+	const object = wantsObject(c.req.raw);
+	return asCaller(deps, c, get, async (trx) => {
+		const candidates = await findFunctions(trx, name);
+		const inputs = new Set(candidates.flatMap((info) => info.inputs.map((input) => input.name)));
+		const given = get ? params.map(([key]) => key).filter((key) => !reserved.has(key) && inputs.has(key)) : typeof body === "object" && body !== null && !Array.isArray(body) ? Object.keys(body) : [];
+		const chosen = chooseFunction(name, candidates, given);
+		const args = get ? Object.fromEntries(params.filter(([key]) => given.includes(key))) : body;
+		const source = callSource(chosen, args);
+		const query = parseQuery(params, c.req.header("range") ?? null, new Set(given));
+		if (chosen.info.returns === "void") {
+			await sql`select 1 from ${source.from}`.execute(trx);
+			return new Response(null, {
+				status: 204,
+				headers: { "content-range": "0-0/*" }
+			});
+		}
+		if (!chosen.info.set) {
+			const page = await readRows(trx, source, query);
+			return new Response(onlyElement(page.body), {
+				status: 200,
+				headers: {
+					"content-range": "0-0/*",
+					"content-type": jsonType
+				}
+			});
+		}
+		return pageResponse(await readRows(trx, source, query, prefer.count), query.range.offset, object);
+	});
+};
+const rpcRoute = (deps) => {
+	const app = new Hono();
+	app.on(["GET", "POST"], "/rpc/:fn", (c) => call(deps, c));
+	return app;
+};
+//#endregion
+export { rpcRoute };

package/dist/rest/shape-sql.js

@@ -0,0 +1,20 @@
+import { pathName } from "./field-path.js";
+import { fieldSql } from "./filter-sql.js";
+import { sql } from "kysely";
+//#region src/rest/shape-sql.ts
+/**
+* The select list of `select` on the rows of `source`: `*` its columns, a field under its alias, its JSON path's last
+* key or its column, cast when asked. Cast types are checked to be bare type names when parsed.
+*/
+const selectSql = (source, items) => sql.join(items.map((item) => {
+	if (item.kind === "all") return sql`${sql.id(source)}.*`;
+	const value = fieldSql(source, item.field);
+	const cast = item.cast === void 0 ? value : sql`cast(${value} as ${sql.raw(item.cast)})`;
+	return sql`${cast} as ${sql.id(item.alias ?? pathName(item.field))}`;
+}));
+/** ` order by ...` for the terms; nothing without any. */
+const orderSql = (source, terms) => terms.length === 0 ? sql`` : sql` order by ${sql.join(terms.map((term) => sql`${fieldSql(source, term.field)}${sql.raw(term.direction ? ` ${term.direction}` : "")}${sql.raw(term.nulls ? ` nulls ${term.nulls}` : "")}`))}`;
+/** ` limit ... offset ...` for the range. */
+const rangeSql = (range) => sql`${range.limit === void 0 ? sql`` : sql` limit ${range.limit}`}${range.offset === 0 ? sql`` : sql` offset ${range.offset}`}`;
+//#endregion
+export { orderSql, rangeSql, selectSql };

package/dist/rest/split-list.js

@@ -0,0 +1,38 @@
+import { parseError } from "./rest-error.js";
+//#region src/rest/split-list.ts
+const closers = {
+	"(": ")",
+	"{": "}"
+};
+/**
+* Splits `text` at the commas outside double quotes, parentheses and braces: `a,in.(1,2),b.cs.{x,y}` gives three parts. A
+* backslash in quotes escapes the next character. An unclosed quote, parenthesis or brace does not parse.
+*/
+const splitList = (text) => {
+	const parts = [];
+	const open = [];
+	let quoted = false;
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const char = text[i];
+		if (quoted) {
+			if (char === "\\") i++;
+			else if (char === "\"") quoted = false;
+			continue;
+		}
+		if (char === "\"") quoted = true;
+		else if (char in closers) open.push(closers[char]);
+		else if (char === open.at(-1)) open.pop();
+		else if (char === "," && open.length === 0) {
+			parts.push(text.slice(start, i));
+			start = i + 1;
+		}
+	}
+	if (quoted || open.length > 0) throw parseError(`"${text}" has an unclosed quote, parenthesis or brace`);
+	parts.push(text.slice(start));
+	return parts;
+};
+/** A value in double quotes without them and with its escapes undone; any other value as it is. */
+const unquote = (text) => text.length >= 2 && text.startsWith("\"") && text.endsWith("\"") ? text.slice(1, -1).replace(/\\(.)/g, "$1") : text;
+//#endregion
+export { splitList, unquote };

package/dist/rest/table-routes.js

@@ -0,0 +1,156 @@
+import { tableId } from "../sql-parts.js";
+import { restError } from "./rest-error.js";
+import { contentRange } from "./content-range.js";
+import { checkSingle, jsonType, objectType, onlyElement, pageResponse, wantsObject } from "./respond.js";
+import { parsePrefer } from "./parse-prefer.js";
+import { parseQuery } from "./parse-query.js";
+import { readRows } from "./read-rows.js";
+import { asCaller, queryParams, readBody } from "./rest-context.js";
+import { scanRefusal, uncoveredReads } from "./rest-scan.js";
+import { deleteRows, insertRows, updateRows } from "./write-rows.js";
+import { Hono } from "hono";
+import { sql } from "kysely";
+//#region src/rest/table-routes.ts
+/**
+* The resource whose table `name` is, in the `public` schema or the search path's: `/rest/v1` serves the tables the app
+* declares as resources, as PostgREST serves those of its exposed schema. Any other is 404 (PGRST205).
+*/
+const tableEntry = (deps, name) => {
+	const entry = deps.registry.entries.find((one) => one.model.table.name === name && (one.model.table.schema ?? "public") === "public");
+	if (!entry) throw restError(404, "PGRST205", `Could not find the table 'public.${name}' in the schema cache`);
+	return entry;
+};
+const targetOf = (entry) => ({
+	table: tableId(entry.model),
+	alias: entry.model.table.name
+});
+/** Refuses filters and a sort no index serves, as the scan guard does on `/api/v1`; in `warn` mode, a warning header instead. */
+const scanCheck = async (deps, entry, filters, order) => {
+	if (deps.guard.mode === "off") return {};
+	const [first] = uncoveredReads(await deps.guard.indexesOf(entry), filters, order);
+	if (!first) return {};
+	const refusal = scanRefusal(entry.model.table, first);
+	if (deps.guard.mode === "warn") return { "X-Protobase-Warning": refusal.body.message };
+	throw refusal;
+};
+const returningOf = (prefer, query) => prefer.return === "representation" ? { select: query.select } : void 0;
+const counted = (prefer, total) => prefer.count === void 0 ? void 0 : total;
+/** A write's response: the rows it returns when asked for, as an array or one object; else no body, with `emptyStatus`. */
+const writeResponse = (written, object, status, emptyStatus, range) => {
+	if (written.body === void 0) return new Response(null, {
+		status: emptyStatus,
+		headers: { "content-range": range }
+	});
+	return new Response(object ? onlyElement(written.body) : written.body, {
+		status,
+		headers: {
+			"content-range": range,
+			"content-type": object ? objectType : jsonType
+		}
+	});
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* The rows and columns of an insert's body: an object or an array of objects. The columns are `columns` when given,
+* as supabase-js sends with several rows; otherwise the keys, which every row must then share (PGRST102).
+*/
+const insertRowsOf = (body, query) => {
+	const rows = Array.isArray(body) ? body : [body];
+	if (!rows.every(isRecord)) throw restError(400, "PGRST102", "Empty or invalid json");
+	if (query.columns) return {
+		rows,
+		columns: query.columns
+	};
+	const columns = Object.keys(rows[0] ?? {});
+	const same = (row) => Object.keys(row).length === columns.length && columns.every((column) => Object.hasOwn(row, column));
+	if (!rows.every(same)) throw restError(400, "PGRST102", "All object keys must match");
+	return {
+		rows,
+		columns
+	};
+};
+const read = async (deps, c) => {
+	const entry = tableEntry(deps, c.req.param("table"));
+	const query = parseQuery(queryParams(c), c.req.header("range") ?? null);
+	const prefer = parsePrefer(c.req.header("prefer") ?? null);
+	const warning = await scanCheck(deps, entry, query.filters, query.order);
+	const alias = entry.model.table.name;
+	const source = {
+		from: sql`${tableId(entry.model)} as ${sql.id(alias)}`,
+		alias
+	};
+	const page = await asCaller(deps, c, true, (trx) => readRows(trx, source, query, prefer.count));
+	return pageResponse(page, query.range.offset, wantsObject(c.req.raw), warning);
+};
+const insert = async (deps, c) => {
+	const entry = tableEntry(deps, c.req.param("table"));
+	const query = parseQuery(queryParams(c));
+	const prefer = parsePrefer(c.req.header("prefer") ?? null);
+	const object = wantsObject(c.req.raw);
+	const { rows, columns } = insertRowsOf(await readBody(c), query);
+	if (columns.length === 0 && rows.length > 1) throw restError(400, "PGRST102", "Several rows without any column cannot be inserted at once");
+	if (rows.length === 0 && object) checkSingle(0);
+	const conflict = query.onConflict ?? entry.model.primaryKey.map((name) => entry.model.fields[name].column);
+	const written = rows.length === 0 ? {
+		total: 0,
+		...prefer.return === "representation" && { body: "[]" }
+	} : await asCaller(deps, c, false, async (trx) => {
+		const result = await insertRows(trx, targetOf(entry), {
+			rows,
+			columns,
+			defaults: prefer.missing === "default",
+			resolution: prefer.resolution,
+			conflict
+		}, returningOf(prefer, query));
+		if (object) checkSingle(result.total);
+		return result;
+	});
+	const status = written.inserted === 0 ? 200 : 201;
+	return writeResponse(written, object, status, status, `*/${counted(prefer, written.total) ?? "*"}`);
+};
+const update = async (deps, c) => {
+	const entry = tableEntry(deps, c.req.param("table"));
+	const query = parseQuery(queryParams(c));
+	const prefer = parsePrefer(c.req.header("prefer") ?? null);
+	const object = wantsObject(c.req.raw);
+	const body = await readBody(c);
+	if (!isRecord(body)) throw restError(400, "PGRST102", "Empty or invalid json");
+	const warning = await scanCheck(deps, entry, query.filters, []);
+	const written = Object.keys(body).length === 0 ? {
+		total: 0,
+		...prefer.return === "representation" && { body: "[]" }
+	} : await asCaller(deps, c, false, async (trx) => {
+		const result = await updateRows(trx, targetOf(entry), body, query.filters, returningOf(prefer, query));
+		if (object) checkSingle(result.total);
+		return result;
+	});
+	const response = writeResponse(written, object, 200, 204, contentRange(0, written.total, counted(prefer, written.total)));
+	for (const [name, value] of Object.entries(warning)) response.headers.set(name, value);
+	return response;
+};
+const remove = async (deps, c) => {
+	const entry = tableEntry(deps, c.req.param("table"));
+	const query = parseQuery(queryParams(c));
+	const prefer = parsePrefer(c.req.header("prefer") ?? null);
+	const object = wantsObject(c.req.raw);
+	const warning = await scanCheck(deps, entry, query.filters, []);
+	const written = await asCaller(deps, c, false, async (trx) => {
+		const result = await deleteRows(trx, targetOf(entry), query.filters, returningOf(prefer, query));
+		if (object) checkSingle(result.total);
+		return result;
+	});
+	const response = writeResponse(written, object, 200, 204, `*/${counted(prefer, written.total) ?? "*"}`);
+	for (const [name, value] of Object.entries(warning)) response.headers.set(name, value);
+	return response;
+};
+/** `/rest/v1/<table>`: read with GET and HEAD, insert and upsert with POST, update with PATCH, delete with DELETE. */
+const tableRoutes = (deps) => {
+	const app = new Hono();
+	app.get("/:table", (c) => read(deps, c));
+	app.post("/:table", (c) => insert(deps, c));
+	app.patch("/:table", (c) => update(deps, c));
+	app.delete("/:table", (c) => remove(deps, c));
+	return app;
+};
+//#endregion
+export { tableRoutes };

package/dist/rest/write-rows.js

@@ -0,0 +1,49 @@
+import { whereSql } from "./filter-sql.js";
+import { selectSql } from "./shape-sql.js";
+import { sql } from "kysely";
+//#region src/rest/write-rows.ts
+const returningSql = (target, returning, upsert) => {
+	const row = returning ? sql`${sql.id(target.alias)} as pgrst_row` : sql`1 as pgrst_one`;
+	return upsert ? sql` returning ${row}, (${sql.id(target.alias)}.xmax = 0) as pgrst_inserted` : sql` returning ${row}`;
+};
+const run = async (trx, target, payload, write, returning, upsert) => {
+	const inserted = upsert ? sql`(select count(*) from pgrst_source where pgrst_inserted)` : sql`null::bigint`;
+	const body = returning ? sql`(select coalesce(json_agg(pgrst_rows), '[]')::text from (select ${selectSql(target.alias, returning.select)} from (select (pgrst_source.pgrst_row).* from pgrst_source) as ${sql.id(target.alias)}) as pgrst_rows)` : sql`null::text`;
+	const { rows: [result] } = await sql`
+    with pgrst_payload as (select ${JSON.stringify(payload ?? null)}::json as body), pgrst_source as (${write}${returningSql(target, returning, upsert)})
+    select (select count(*) from pgrst_source) as total, ${inserted} as inserted, ${body} as body
+  `.execute(trx);
+	return {
+		total: Number(result.total),
+		...result.inserted !== null && { inserted: Number(result.inserted) },
+		...result.body !== null && { body: result.body }
+	};
+};
+const valuesSql = (target, insert) => {
+	const columns = sql.join(insert.columns.map((column) => sql.id(column)));
+	if (!insert.defaults) return sql`(${columns}) select ${sql.join(insert.columns.map((column) => sql`pgrst_body.${sql.id(column)}`))} from pgrst_payload, json_populate_recordset(null::${target.table}, pgrst_payload.body) as pgrst_body`;
+	const rows = insert.rows.map((row, i) => sql`(${sql.join(insert.columns.map((column) => Object.hasOwn(row, column) ? sql`(json_populate_record(null::${target.table}, (select body -> ${sql.raw(String(i))} from pgrst_payload))).${sql.id(column)}` : sql`default`))})`);
+	return sql`(${columns}) values ${sql.join(rows)}`;
+};
+const conflictSql = (insert) => {
+	if (!insert.resolution) return sql``;
+	const target = sql.join(insert.conflict.map((column) => sql.id(column)));
+	if (insert.resolution === "ignore-duplicates") return sql` on conflict (${target}) do nothing`;
+	return sql` on conflict (${target}) do update set ${sql.join(insert.columns.map((column) => sql`${sql.id(column)} = excluded.${sql.id(column)}`))}`;
+};
+/** Inserts the rows, or upserts them with a resolution, in one statement. */
+const insertRows = (trx, target, insert, returning) => {
+	const values = insert.columns.length === 0 ? sql` default values` : sql` ${valuesSql(target, insert)}`;
+	const write = sql`insert into ${target.table} as ${sql.id(target.alias)}${values}${conflictSql(insert)}`;
+	return run(trx, target, insert.rows, write, returning, insert.resolution !== void 0);
+};
+/** Sets the columns of the body on every row the filters keep. */
+const updateRows = (trx, target, values, filters, returning) => {
+	const set = sql.join(Object.keys(values).map((column) => sql`${sql.id(column)} = pgrst_body.${sql.id(column)}`));
+	const from = sql`json_populate_record(null::${target.table}, (select body from pgrst_payload)) as pgrst_body`;
+	return run(trx, target, values, sql`update ${target.table} as ${sql.id(target.alias)} set ${set} from ${from}${whereSql(target.alias, filters)}`, returning, false);
+};
+/** Deletes every row the filters keep. */
+const deleteRows = (trx, target, filters, returning) => run(trx, target, null, sql`delete from ${target.table} as ${sql.id(target.alias)}${whereSql(target.alias, filters)}`, returning, false);
+//#endregion
+export { deleteRows, insertRows, updateRows };

package/dist/scan-guard.js

@@ -28,7 +28,7 @@ const createScanGuard = (db, options = {}) => {
 		return read;
 	};
 	/** Throws a 400 problem for a column no index serves in `reject` mode; in `warn` mode returns the warning text. */
-	return async (entry, query, context) => {
+	const check = async (entry, query, context) => {
 		if (mode === "off") return void 0;
 		const columns = uncoveredColumns(context.model, await indexesOf(entry), query, context.scope);
 		const first = columns[0];
@@ -40,6 +40,10 @@ const createScanGuard = (db, options = {}) => {
 			suggestion: first.suggestion
 		});
 	};
+	return Object.assign(check, {
+		mode,
+		indexesOf
+	});
 };
 //#endregion
 export { createScanGuard };

package/dist/transactions.js

@@ -13,9 +13,9 @@ const writeTransaction = (db, timeoutMs, run, settings = {}) => db.transaction()
 	return run(trx);
 });
 /** Same, and Postgres refuses any write inside it. */
-const readTransaction = (db, timeoutMs, run) => writeTransaction(db, timeoutMs, async (trx) => {
+const readTransaction = (db, timeoutMs, run, settings = {}) => writeTransaction(db, timeoutMs, async (trx) => {
 	await sql`set transaction read only`.execute(trx);
 	return run(trx);
-});
+}, settings);
 //#endregion
 export { readTransaction, writeTransaction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.26.5",
+  "version": "0.26.7",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -32,9 +32,9 @@
   "dependencies": {
     "@better-auth/passkey": "^1.7.7",
     "@better-auth/sso": "^1.7.7",
-    "@protobase/layout": "0.26.5",
-    "@protobase/query": "0.26.5",
-    "@protobase/schema": "0.26.5",
+    "@protobase/layout": "0.26.7",
+    "@protobase/query": "0.26.7",
+    "@protobase/schema": "0.26.7",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",