@tablecraft-app/plugin-postgres 1.12.1 → 1.14.0

package/index.js

@@ -10823,7 +10823,8 @@ var CAPABILITIES$1 = [
 	"commands",
 	"keyValue",
 	"nodes",
-	"serverInfo"
+	"serverInfo",
+	"serverTimeout"
 ];
 /** The message that stands for the ones past `SERVER_MESSAGE_LIMIT`. */
 function omittedMessages(count) {
@@ -11025,6 +11026,11 @@ function urlSetsDeclared(connection) {
 	if (url?.sets === void 0) return true;
 	return Object.entries(url.sets).every(([scheme, values]) => url.schemes.includes(scheme) && Object.keys(values).every((key) => connection.fields.some((field) => field.key === key)));
 }
+/** A database product a plugin speaks; `id` is a simple-icons slug, `name` what a row shows. */
+var brandSchema = strictObject({
+	id: string$1().regex(/^[a-z0-9_]+$/, { message: "expected a simple-icons slug: lower-case letters, digits and underscores" }),
+	name: string$1().min(1)
+});
 function includesAny(capabilities, ...wanted) {
 	return wanted.some((capability) => capabilities.includes(capability));
 }
@@ -11038,6 +11044,8 @@ strictObject({
 	capabilities: array(_enum(CAPABILITIES$1)),
 	/** The highlighter the console uses for this plugin's dialect (decision 008). */
 	highlight: string$1().min(1),
+	/** The database products the plugin speaks, its default first (decision 128). Absent: rows name the plugin. */
+	brands: array(brandSchema).min(1).refine((brands) => new Set(brands.map((brand) => brand.id)).size === brands.length, { message: "brand ids must be unique" }).optional(),
 	/** The connection form, readable without running plugin code (decision 019). */
 	connection: strictObject({
 		fields: array(connectionFieldSchema).min(1),
@@ -25225,6 +25233,39 @@ function postgresSessions(client, open) {
 		terminateSession: (target) => stop(target, terminateStatement, "terminate")
 	};
 }
+// ../../plugins/postgres/src/timeout.ts
+/**
+* PostgreSQL's `statement_timeout` covers every statement and, measured against PostgreSQL 17,
+* keeps counting while a `pg-cursor` result waits to be read: the cursor's `Execute` is sent
+* without a `Sync`, so the statement is still running (decision 129).
+*/
+var POSTGRES_SERVER_TIMEOUT = {
+	setting: "statement_timeout",
+	covers: "all",
+	counts: "statement"
+};
+var READ_TIMEOUT_SQL = "SHOW statement_timeout";
+var SET_TIMEOUT_SQL = "SELECT set_config('statement_timeout', $1, false)";
+/** A statement naming the setting may have changed it behind the plugin's back. */
+var TIMEOUT_SETTING = /statement_timeout/i;
+function namesServerTimeout(sql) {
+	return TIMEOUT_SETTING.test(sql);
+}
+/** `SHOW`'s units for a time setting, in milliseconds; a bare number is milliseconds already. */
+var UNIT_MS = {
+	ms: 1,
+	s: 1e3,
+	min: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+var DURATION = /^(\d+(?:\.\d+)?)\s*(ms|s|min|h|d)?$/;
+/** `SHOW statement_timeout` as milliseconds: `5s`, `1min`, `250ms`, `0`; anything unreadable is 0, no limit. */
+function postgresDurationMs(text) {
+	const match = DURATION.exec(text.trim());
+	if (match === null) return 0;
+	return Math.round(Number(match[1]) * (UNIT_MS[match[2] ?? "ms"] ?? 1));
+}
 // ../../plugins/postgres/src/tls.ts
 var SSL_MODES = [
 	"disable",
@@ -25323,6 +25364,10 @@ function tlsInfoOf(socket) {
 }
 // ../../plugins/postgres/src/index.ts
 var PLUGIN_ID = "postgres";
+var CANCEL_REACH = {
+	method: "pg_cancel_backend",
+	reaches: "statement"
+};
 var CAPABILITIES = [
 	"sql",
 	"cancel",
@@ -25337,7 +25382,8 @@ var CAPABILITIES = [
 	"objects",
 	"serverMessages",
 	"sessions",
-	"routineCall"
+	"routineCall",
+	"serverTimeout"
 ];
 /** Function bodies live in dollar quotes; `BEGIN ATOMIC … END` holds a SQL-standard body. */
 var DIALECT = {
@@ -25433,6 +25479,7 @@ var RELEASE_SQL = "RELEASE SAVEPOINT table_craft_insert";
 var ROLLBACK_TO_SQL = "ROLLBACK TO SAVEPOINT table_craft_insert";
 var OPEN_TRANSACTION_MESSAGE = "A transaction is open; commit or roll it back before switching to auto-commit.";
 var BUSY_MESSAGE = "Another statement is still running in this session.";
+var CANCELLED_MESSAGE = "The statement was cancelled.";
 var DEFAULT_PORT = 5432;
 var MAX_PORT = 65535;
 var DEFAULT_CONNECT_TIMEOUT_SECONDS = 10;
@@ -25560,6 +25607,18 @@ async function openClient(config, options) {
 	}
 	return client;
 }
+function startRunning() {
+	return {
+		cancelRequested: false,
+		startedAt: Date.now(),
+		limitMs: null
+	};
+}
+/**
+* `#appliedTimeoutMs` once a transaction ended after the plugin set the limit: a `ROLLBACK` may
+* have undone it, so the next statement sets it again whatever it asks for.
+*/
+var UNKNOWN_TIMEOUT = -1;
 function readBatch(cursor) {
 	return new Promise((resolve, reject) => {
 		cursor.read(FETCH_ROWS, (error, rows, result) => {
@@ -25607,7 +25666,15 @@ var PostgresSession = class PostgresSession {
 		mode: "auto",
 		open: false
 	};
+	/** The session's own `statement_timeout` in ms, 0 for none; read before the first limited statement. */
+	#ownTimeoutMs = null;
+	/** The limit this plugin last set; null before it set one; `UNKNOWN_TIMEOUT` after a transaction ended. */
+	#appliedTimeoutMs = null;
 	serverVersion;
+	/** The manifest's one brand. */
+	serverBrand = "postgresql";
+	serverTimeout = POSTGRES_SERVER_TIMEOUT;
+	cancelReach = CANCEL_REACH;
 	tls;
 	introspector;
 	transactions;
@@ -25661,7 +25728,7 @@ var PostgresSession = class PostgresSession {
 		if (this.#broken !== null) throw new PluginError("connectionLost", `The connection was lost: ${this.#broken.message}`);
 		if (this.#running !== null) throw new PluginError("sessionBusy", BUSY_MESSAGE);
 		await this.#cancelling.catch(() => void 0);
-		const running = { cancelRequested: false };
+		const running = startRunning();
 		this.#running = running;
 		const effect = transactionEffect(sql, DIALECT);
 		const state = this.#transaction;
@@ -25670,6 +25737,10 @@ var PostgresSession = class PostgresSession {
 				await this.#client.query(BEGIN_SQL);
 				state.open = true;
 			}
+			running.limitMs = await this.#applyTimeout(options.serverTimeoutMs);
+			if (namesServerTimeout(sql)) this.#appliedTimeoutMs = null;
+			if (running.cancelRequested) throw new Error(CANCELLED_MESSAGE);
+			running.startedAt = Date.now();
 		} catch (cause) {
 			this.#running = null;
 			throw this.#failure(cause, running);
@@ -25682,10 +25753,11 @@ var PostgresSession = class PostgresSession {
 		}));
 		try {
 			const first = await readBatch(cursor).catch((cause) => {
-				if (effect === "end") state.open = false;
+				if (effect === "end") this.#transactionEnded();
 				throw cause;
 			});
-			if (effect !== null) state.open = effect === "begin";
+			if (effect === "end") this.#transactionEnded();
+			else if (effect !== null) state.open = true;
 			const fields = first.result.fields;
 			if (fields.length === 0) {
 				this.#notices = null;
@@ -25740,7 +25812,7 @@ var PostgresSession = class PostgresSession {
 		if (this.#running !== null) throw new PluginError("sessionBusy", BUSY_MESSAGE);
 		if (rows.length === 0) return;
 		await this.#cancelling.catch(() => void 0);
-		const running = { cancelRequested: false };
+		const running = startRunning();
 		this.#running = running;
 		const state = this.#transaction;
 		try {
@@ -25783,7 +25855,8 @@ var PostgresSession = class PostgresSession {
 		if (!verdict.ok) throw new PluginError("explainUnsupported", verdict.reason);
 		const statement = explainStatement(sql, options.analyze);
 		const rows = [];
-		const result = await this.execute(statement);
+		const limit = options.serverTimeoutMs;
+		const result = await this.execute(statement, [], limit === void 0 ? {} : { serverTimeoutMs: limit });
 		for await (const row of result.rows) rows.push(row);
 		return {
 			...readPlan(planText(rows), statement, options.analyze),
@@ -25815,7 +25888,9 @@ var PostgresSession = class PostgresSession {
 	}
 	#failure(cause, running, sql) {
 		const code = cause.code;
-		if (running.cancelRequested || code === QUERY_CANCELED) return new PluginError("cancelled", "The statement was cancelled.", { cause });
+		const limit = running.limitMs;
+		if (!running.cancelRequested && code === QUERY_CANCELED && limit !== null && Date.now() - running.startedAt >= limit) return new PluginError("timedOut", `PostgreSQL stopped the statement at its ${String(limit / MS_PER_SECOND)} s limit (statement_timeout).`, { cause });
+		if (running.cancelRequested || code === QUERY_CANCELED) return new PluginError("cancelled", CANCELLED_MESSAGE, { cause });
 		const position = sql === void 0 ? void 0 : serverErrorPosition(sql, cause);
 		return new PluginError("statementFailed", messageOf(cause), {
 			cause,
@@ -25852,7 +25927,37 @@ var PostgresSession = class PostgresSession {
 		} catch (cause) {
 			throw new PluginError("statementFailed", messageOf(cause), { cause });
 		} finally {
-			this.#transaction.open = false;
+			this.#transactionEnded();
+		}
+	}
+	/** `statement_timeout` is transactional: a `ROLLBACK` undoes a `SET` made inside it. */
+	#transactionEnded() {
+		this.#transaction.open = false;
+		if (this.#appliedTimeoutMs !== null) this.#appliedTimeoutMs = UNKNOWN_TIMEOUT;
+	}
+	/**
+	* Sets `statement_timeout` to `requested`, never above the session's own, or puts the own back
+	* when nothing is requested; sends nothing when the value would not change (decision 129). In a
+	* failed transaction, which refuses the `SET`, it is skipped and the statement fails on its own.
+	* Returns the limit the statement runs under, null for none.
+	*/
+	async #applyTimeout(requested) {
+		if (requested === void 0 && this.#appliedTimeoutMs === null) return null;
+		try {
+			if (this.#ownTimeoutMs === null) {
+				const shown = await this.#client.query(READ_TIMEOUT_SQL);
+				this.#ownTimeoutMs = postgresDurationMs(shown.rows[0]?.statement_timeout ?? "0");
+			}
+			const own = this.#ownTimeoutMs;
+			const want = requested === void 0 ? own : own === 0 ? requested : Math.min(own, requested);
+			if (want !== this.#appliedTimeoutMs) {
+				await this.#client.query(SET_TIMEOUT_SQL, [String(want)]);
+				this.#appliedTimeoutMs = want;
+			}
+			return want === 0 ? null : want;
+		} catch (cause) {
+			if (cause.code !== "25P02") throw cause;
+			return null;
 		}
 	}
 	async close() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablecraft-app/plugin-postgres",
-  "version": "1.12.1",
+  "version": "1.14.0",
   "description": "The PostgreSQL datasource plugin for TableCraft, downloaded by the app when a data source needs it.",
   "license": "MIT",
   "type": "module",
@@ -24,6 +24,6 @@
   },
   "tableCraft": {
     "id": "postgres",
-    "apiVersion": "1.5.0"
+    "apiVersion": "1.7.0"
   }
 }

package/table-craft-plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "postgres",
   "name": "PostgreSQL",
-  "version": "1.12.1",
-  "apiVersion": "1.5.0",
+  "version": "1.14.0",
+  "apiVersion": "1.7.0",
   "entry": "index.js",
   "capabilities": [
     "sql",
@@ -18,9 +18,16 @@
     "objects",
     "serverMessages",
     "sessions",
-    "routineCall"
+    "routineCall",
+    "serverTimeout"
   ],
   "highlight": "postgresql",
+  "brands": [
+    {
+      "id": "postgresql",
+      "name": "PostgreSQL"
+    }
+  ],
   "connection": {
     "fields": [
       {