@schema-weaver/pg-connector 0.0.0-stage → 2.0.0

package/dist/cjs/execution/sql-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-parser.js","sourceRoot":"","sources":["../../../src/execution/sql-parser.ts"],"names":[],"mappings":"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"}

package/dist/cjs/execution/statement-classifier.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Statement classification, driven by the real PostgreSQL grammar.
+ *
+ * The previous implementation split the SQL on whitespace and looked at the
+ * first token. That is unsound: it classified `SELECT 1; DROP TABLE users` as a
+ * read, and it classified `SELECT * INTO t ...` as a read even though it
+ * creates a table. Both were reachable from the cloud and both executed.
+ *
+ * This implementation parses with libpg_query (WASM) and classifies from the
+ * AST. The guarantee it provides, and its exact limits:
+ *
+ *   - The number of statements is COUNTED by PostgreSQL's own grammar, so
+ *     multi-statement smuggling is structural rather than lexical: a `;` inside
+ *     a string literal, a dollar-quoted body, a quoted identifier or a comment
+ *     cannot split a statement, and a real second statement always is visible.
+ *     `statement_count !== 1` is never a read.
+ *   - Classification is ALLOWLIST-based on the root node: a statement type this
+ *     module does not recognise is `unknown`, which is not a read.
+ *   - `SELECT` is treated as a command envelope, not a read-only assertion.
+ *     `SELECT … INTO`, row-locking clauses, data-modifying CTEs, executable
+ *     blocks and denylisted volatile/privileged functions are detected anywhere
+ *     in the statement and demote it out of `read`.
+ *   - A parse failure and an unavailable parser both FAIL CLOSED: they throw,
+ *     and no lexical heuristic is ever consulted as a fallback. An
+ *     authorization decision must never be made from this module's guesswork.
+ *   - A function reference is a claim that has to be PROVED. Every function the
+ *     statement calls is resolved against `pg_proc` on the caller's connection
+ *     (`function-effects.ts`), and only `provolatile = 'i' AND prosecdef =
+ *     false` counts as a read. A VOLATILE or SECURITY DEFINER function, an
+ *     unknown one, and — deliberately — one the catalogue could not be asked
+ *     about all carry `side_effect` and are never a provable read. With no
+ *     resolver supplied every statement that calls anything is escalated; see
+ *     {@link ClassifyOptions.resolveFunctionEffects}.
+ *
+ * It is still not a substitute for PostgreSQL's own enforcement. The database
+ * is the authority on what a statement does, and the agent's read-only
+ * guarantee is `default_transaction_read_only = on` on the connection — which
+ * constrains WRITES only, and therefore does not constrain a function that
+ * reads a file, notifies a channel, or allocates a transaction id. Those are
+ * why the function-effect analysis above is a control in its own right rather
+ * than an optimisation of the deny-list in `sql-parser.ts`.
+ */
+import { SqlParseError, SqlParserUnavailableError, walkAst } from './sql-parser';
+import type { RawStmt } from './sql-parser';
+import type { FunctionEffectResolver } from './function-effects';
+import type { StatementClassification } from './types';
+/** Reasons a syntactically valid SELECT is still not a safe read. */
+export type ReadViolation = 'selects_into' | 'row_locking' | 'writable_cte' | 'denied_function' | 'side_effect' | 'multiple_statements' | 'executable_block' | 'parse_error' | 'parser_unavailable';
+/**
+ * Violations that mean "this parsed as a read but it is not one".
+ *
+ * A statement carrying any of these is never reported as a provable read, and
+ * the permission layer treats it as a privileged operation rather than a
+ * `query_read`.
+ */
+export declare const READ_ESCAPE_VIOLATIONS: ReadonlySet<ReadViolation>;
+/**
+ * Options for a classification that can consult a database.
+ *
+ * `resolveFunctionEffects` is optional and its absence is meaningful: without
+ * it this module cannot prove any function call is effect-free, so it reports
+ * `side_effect` for every one of them and the statement is escalated. That is
+ * the fail-closed direction, and it is required — the alternative (treating an
+ * absent catalogue verdict as "safe") is the vulnerability being fixed.
+ */
+export interface ClassifyOptions {
+    resolveFunctionEffects?: FunctionEffectResolver;
+}
+export declare class StatementClassificationError extends Error {
+    readonly code: ReadViolation | 'unknown_statement';
+    constructor(message: string, code: ReadViolation | 'unknown_statement');
+}
+/**
+ * Classify a SQL string using the PostgreSQL parser.
+ *
+ * @throws {SqlParserUnavailableError} if the parser has not been initialised
+ * @throws {SqlParseError} if PostgreSQL cannot parse the input
+ */
+export declare function classifyStatement(sql: string, options?: ClassifyOptions): Promise<StatementClassification>;
+/**
+ * Classify a parsed statement list, resolving every function the statements
+ * reference against `pg_proc` in ONE batched read.
+ *
+ * The names of every statement in the list are collected before the lookup, so
+ * a migration plan of twenty statements still costs one catalogue query.
+ */
+export declare function classifyStatements(stmts: RawStmt[], options?: ClassifyOptions): Promise<StatementClassification>;
+/**
+ * Classify using an already-parsed statement list (sync; parser must be ready).
+ *
+ * No catalogue is consulted here, so any statement that calls a function is
+ * escalated. Callers that hold a connection should use {@link classifyStatements}
+ * (or `classifyStatement`) with a resolver instead.
+ */
+export declare function classifyParsedStatements(stmts: RawStmt[]): StatementClassification;
+/**
+ * Classify and throw instead of returning, for call sites that must fail
+ * closed on anything they cannot prove is a read.
+ */
+export declare function assertSingleReadStatement(sql: string, options?: ClassifyOptions): Promise<StatementClassification>;
+export { SqlParseError, SqlParserUnavailableError };
+export { walkAst };
+//# sourceMappingURL=statement-classifier.d.ts.map

package/dist/cjs/execution/statement-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-classifier.d.ts","sourceRoot":"","sources":["../../../src/execution/statement-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,EAML,aAAa,EACb,yBAAyB,EASzB,OAAO,EACR,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAgD,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE/G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAIvD,qEAAqE;AACrE,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,aAAa,GACb,cAAc,GACd,iBAAiB,GACjB,aAAa,GACb,qBAAqB,GACrB,kBAAkB,GAClB,aAAa,GACb,oBAAoB,CAAC;AAEzB;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,aAAa,CAO5D,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD;AAKD,qBAAa,4BAA6B,SAAQ,KAAK;aAGnC,IAAI,EAAE,aAAa,GAAG,mBAAmB;gBADzD,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,aAAa,GAAG,mBAAmB;CAK5D;AAgCD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAGlC;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CASlC;AAgBD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,uBAAuB,CAMlF;AA+YD;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CA0BlC;AAED,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/cjs/execution/statement-classifier.js

@@ -0,0 +1,535 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkAst = exports.SqlParserUnavailableError = exports.SqlParseError = exports.StatementClassificationError = exports.READ_ESCAPE_VIOLATIONS = void 0;
+exports.classifyStatement = classifyStatement;
+exports.classifyStatements = classifyStatements;
+exports.classifyParsedStatements = classifyParsedStatements;
+exports.assertSingleReadStatement = assertSingleReadStatement;
+/**
+ * Statement classification, driven by the real PostgreSQL grammar.
+ *
+ * The previous implementation split the SQL on whitespace and looked at the
+ * first token. That is unsound: it classified `SELECT 1; DROP TABLE users` as a
+ * read, and it classified `SELECT * INTO t ...` as a read even though it
+ * creates a table. Both were reachable from the cloud and both executed.
+ *
+ * This implementation parses with libpg_query (WASM) and classifies from the
+ * AST. The guarantee it provides, and its exact limits:
+ *
+ *   - The number of statements is COUNTED by PostgreSQL's own grammar, so
+ *     multi-statement smuggling is structural rather than lexical: a `;` inside
+ *     a string literal, a dollar-quoted body, a quoted identifier or a comment
+ *     cannot split a statement, and a real second statement always is visible.
+ *     `statement_count !== 1` is never a read.
+ *   - Classification is ALLOWLIST-based on the root node: a statement type this
+ *     module does not recognise is `unknown`, which is not a read.
+ *   - `SELECT` is treated as a command envelope, not a read-only assertion.
+ *     `SELECT … INTO`, row-locking clauses, data-modifying CTEs, executable
+ *     blocks and denylisted volatile/privileged functions are detected anywhere
+ *     in the statement and demote it out of `read`.
+ *   - A parse failure and an unavailable parser both FAIL CLOSED: they throw,
+ *     and no lexical heuristic is ever consulted as a fallback. An
+ *     authorization decision must never be made from this module's guesswork.
+ *   - A function reference is a claim that has to be PROVED. Every function the
+ *     statement calls is resolved against `pg_proc` on the caller's connection
+ *     (`function-effects.ts`), and only `provolatile = 'i' AND prosecdef =
+ *     false` counts as a read. A VOLATILE or SECURITY DEFINER function, an
+ *     unknown one, and — deliberately — one the catalogue could not be asked
+ *     about all carry `side_effect` and are never a provable read. With no
+ *     resolver supplied every statement that calls anything is escalated; see
+ *     {@link ClassifyOptions.resolveFunctionEffects}.
+ *
+ * It is still not a substitute for PostgreSQL's own enforcement. The database
+ * is the authority on what a statement does, and the agent's read-only
+ * guarantee is `default_transaction_read_only = on` on the connection — which
+ * constrains WRITES only, and therefore does not constrain a function that
+ * reads a file, notifies a channel, or allocates a transaction id. Those are
+ * why the function-effect analysis above is a control in its own right rather
+ * than an optimisation of the deny-list in `sql-parser.ts`.
+ */
+const sql_parser_1 = require("./sql-parser");
+Object.defineProperty(exports, "SqlParseError", { enumerable: true, get: function () { return sql_parser_1.SqlParseError; } });
+Object.defineProperty(exports, "SqlParserUnavailableError", { enumerable: true, get: function () { return sql_parser_1.SqlParserUnavailableError; } });
+Object.defineProperty(exports, "walkAst", { enumerable: true, get: function () { return sql_parser_1.walkAst; } });
+const function_effects_1 = require("./function-effects");
+/**
+ * Violations that mean "this parsed as a read but it is not one".
+ *
+ * A statement carrying any of these is never reported as a provable read, and
+ * the permission layer treats it as a privileged operation rather than a
+ * `query_read`.
+ */
+exports.READ_ESCAPE_VIOLATIONS = new Set([
+    'selects_into',
+    'row_locking',
+    'writable_cte',
+    'denied_function',
+    'side_effect',
+    'executable_block',
+]);
+/** An analysis that says nothing, used when there is nothing to say. */
+const NO_FUNCTION_EFFECTS = { records: [], analysed: true };
+class StatementClassificationError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'StatementClassificationError';
+    }
+}
+exports.StatementClassificationError = StatementClassificationError;
+function base(type, kind, transactional, verb, extra = {}, effects = NO_FUNCTION_EFFECTS) {
+    return {
+        type,
+        kind,
+        transactional,
+        verb,
+        statement_count: 1,
+        parse_ok: true,
+        read_violations: [],
+        function_effects: effects.records,
+        side_effects: uniqueSideEffects(effects.records),
+        ...extra,
+    };
+}
+function uniqueSideEffects(records) {
+    const kinds = new Set();
+    for (const record of records) {
+        for (const kind of record.side_effects)
+            kinds.add(kind);
+    }
+    return [...kinds];
+}
+/**
+ * Classify a SQL string using the PostgreSQL parser.
+ *
+ * @throws {SqlParserUnavailableError} if the parser has not been initialised
+ * @throws {SqlParseError} if PostgreSQL cannot parse the input
+ */
+async function classifyStatement(sql, options = {}) {
+    const { stmts } = (0, sql_parser_1.parseSql)(sql);
+    return classifyStatements(stmts, options);
+}
+/**
+ * Classify a parsed statement list, resolving every function the statements
+ * reference against `pg_proc` in ONE batched read.
+ *
+ * The names of every statement in the list are collected before the lookup, so
+ * a migration plan of twenty statements still costs one catalogue query.
+ */
+async function classifyStatements(stmts, options = {}) {
+    const names = stmts.flatMap((stmt) => (0, sql_parser_1.collectFunctionNames)(stmt));
+    const effects = names.length === 0
+        ? NO_FUNCTION_EFFECTS
+        : await (options.resolveFunctionEffects
+            ? options.resolveFunctionEffects(names)
+            : Promise.resolve(unanalysedAnalysis(names)));
+    return classifyParsedStatementsWith(stmts, effects);
+}
+/**
+ * An analysis for names nothing could be asked about.
+ *
+ * `resolved: false` and `effect: 'unknown'` for each, which is what makes
+ * `isProvableRead()` refuse the statement. The records are still emitted so the
+ * audit trail names the functions that could not be cleared.
+ */
+function unanalysedAnalysis(names) {
+    return {
+        records: names.map((name) => (0, function_effects_1.unresolvedRecord)(name)),
+        analysed: false,
+    };
+}
+/**
+ * Classify using an already-parsed statement list (sync; parser must be ready).
+ *
+ * No catalogue is consulted here, so any statement that calls a function is
+ * escalated. Callers that hold a connection should use {@link classifyStatements}
+ * (or `classifyStatement`) with a resolver instead.
+ */
+function classifyParsedStatements(stmts) {
+    const names = stmts.flatMap((stmt) => (0, sql_parser_1.collectFunctionNames)(stmt));
+    return classifyParsedStatementsWith(stmts, names.length === 0 ? NO_FUNCTION_EFFECTS : unanalysedAnalysis(names));
+}
+function classifyParsedStatementsWith(stmts, effects) {
+    const statementCount = stmts.length;
+    if (statementCount === 0) {
+        return base('unknown', 'EMPTY', true, '', {
+            statement_count: 0,
+            read_violations: ['parse_error'],
+        });
+    }
+    if (statementCount > 1) {
+        // Classify by the MOST dangerous statement present. Never let a leading
+        // SELECT launder a trailing DROP.
+        let worst = base('read', 'SELECT', true, 'SELECT', {
+            statement_count: statementCount,
+            read_violations: ['multiple_statements'],
+        });
+        const violations = ['multiple_statements'];
+        let sawNonRead = false;
+        for (const stmt of stmts) {
+            const one = classifySingleStatement(stmt, effects);
+            for (const v of one.read_violations) {
+                if (!violations.includes(v))
+                    violations.push(v);
+            }
+            if (one.type !== 'read')
+                sawNonRead = true;
+            if (severity(one.type) > severity(worst.type))
+                worst = one;
+        }
+        if (sawNonRead) {
+            // Keep `worst`'s kind/verb, but report it as a multi-statement payload
+            // with every violation the individual statements carried.
+            return {
+                ...worst,
+                statement_count: statementCount,
+                kind: `${worst.kind} + ${statementCount - 1} more statement(s)`,
+                read_violations: violations,
+            };
+        }
+        // Every statement parsed as a read; the payload is still refused because
+        // more than one statement would be executed in a single round trip.
+        return {
+            ...worst,
+            statement_count: statementCount,
+            kind: `${statementCount} statements`,
+            read_violations: violations,
+        };
+    }
+    return classifySingleStatement(stmts[0], effects);
+}
+function severity(t) {
+    switch (t) {
+        case 'read':
+            return 0;
+        case 'utility':
+            return 1;
+        case 'write':
+            return 2;
+        case 'ddl':
+            return 3;
+        default:
+            return 4;
+    }
+}
+function classifySingleStatement(stmt, effects) {
+    const rootType = (0, sql_parser_1.rootNodeType)(stmt);
+    const node = (0, sql_parser_1.rootNode)(stmt);
+    const verb = deriveVerb(rootType, node);
+    // ---- allowlisted reads -------------------------------------------------
+    if (sql_parser_1.READ_ROOTS.has(rootType)) {
+        if (rootType === 'SelectStmt')
+            return classifySelect(stmt, effects);
+        // VariableShowStmt (SHOW) has no expression context, so there is nothing
+        // for a function call to hide in.
+        return base('read', rootType, true, verb, {}, effects);
+    }
+    if (rootType === 'ExplainStmt') {
+        // EXPLAIN is transparent to the statement it wraps, so classify the inner
+        // statement with the same rules. EXPLAIN ANALYZE additionally EXECUTES it,
+        // which is only sound when the wrapped statement is itself a provable read.
+        const analyze = (0, sql_parser_1.explainExecutesStatement)(node);
+        const inner = classifySingleStatement({ stmt: node?.query }, effects);
+        if (inner.type === 'read' && inner.read_violations.length === 0) {
+            return base('read', analyze ? 'EXPLAIN ANALYZE' : 'EXPLAIN', true, 'EXPLAIN');
+        }
+        if (analyze) {
+            return {
+                ...inner,
+                kind: `EXPLAIN ANALYZE ${inner.kind}`,
+                read_violations: [
+                    ...inner.read_violations,
+                    ...(inner.read_violations.includes('executable_block')
+                        ? []
+                        : ['executable_block']),
+                ],
+            };
+        }
+        return { ...inner, kind: `EXPLAIN ${inner.kind}` };
+    }
+    // ---- writes ------------------------------------------------------------
+    if (sql_parser_1.WRITE_ROOTS.has(rootType)) {
+        return base('write', rootType.replace(/Stmt$/, ''), true, verb, {}, effects);
+    }
+    // Checked before the DDL and utility tables because two of these roots are
+    // listed there as well (`ExecuteStmt`, `CreatePLangFunctionStmt`). Matching
+    // them first is what makes `EXECUTE` and a PL/pgSQL `CREATE FUNCTION` carry
+    // `executable_block`, which is the signal auto-upgrade refuses on: both run
+    // code whose body was never classified.
+    if (sql_parser_1.EXECUTABLE_ROOTS.has(rootType)) {
+        return base('ddl', rootType.replace(/Stmt$/, ''), true, verb, {
+            read_violations: ['executable_block'],
+        });
+    }
+    if (rootType === 'CopyStmt') {
+        // COPY FROM writes rows. COPY TO PROGRAM runs a command on the server;
+        // COPY TO 'file' writes the server's filesystem. Only COPY … TO STDOUT is a
+        // read, and it is the only form the classifier will ever call one.
+        const isFrom = node?.is_from === true;
+        const hasProgram = Boolean(node?.is_program);
+        if (isFrom)
+            return base('write', 'COPY FROM', true, verb);
+        if (hasProgram) {
+            return base('ddl', 'COPY TO PROGRAM', true, verb, {
+                read_violations: ['executable_block'],
+            });
+        }
+        if (copyDestinationFile(node) !== null) {
+            return base('ddl', 'COPY TO FILE', true, verb);
+        }
+        return base('read', 'COPY TO STDOUT', true, verb);
+    }
+    // ---- schema / role / persistent state ---------------------------------
+    if (sql_parser_1.DDL_ROOTS.has(rootType)) {
+        return base('ddl', rootType.replace(/Stmt$/, ''), !(0, sql_parser_1.isNonTransactionalNode)(rootType, node), verb, {}, effects);
+    }
+    // ---- session / transaction utilities -----------------------------------
+    if (sql_parser_1.UTILITY_ROOTS.has(rootType)) {
+        if (rootType === 'VariableSetStmt')
+            return classifyVariableSet(node, verb);
+        return base('utility', rootType.replace(/Stmt$/, ''), !(0, sql_parser_1.isNonTransactionalNode)(rootType, node), verb, {}, effects);
+    }
+    // Unknown root node: NOT a read. Fail closed by requiring DDL capability.
+    return base('unknown', 'UNKNOWN', true, verb, {
+        read_violations: ['executable_block'],
+    });
+}
+/**
+ * The destination file of a `COPY … TO 'path'`, or `null` for `STDOUT` and
+ * `PROGRAM`. `pgsql-parser` normalises the path to a plain string; the wrapped
+ * `{ String: { sval } }` form is accepted too so a change in that library's
+ * shape cannot silently turn every `COPY TO` into a read.
+ */
+function copyDestinationFile(node) {
+    const filename = node?.filename;
+    const sval = typeof filename === 'string' ? filename : filename?.String?.sval;
+    return typeof sval === 'string' && sval.length > 0 ? sval : null;
+}
+/**
+ * Classify a `SELECT` envelope.
+ *
+ * `SELECT` is not a read-only assertion in PostgreSQL, so everything that can
+ * mutate state or reach outside the database is looked for across the whole
+ * statement — including sub-selects, CTEs and set-returning functions in FROM.
+ *
+ * The third source of demotion is the function catalogue: a call is only a read
+ * when `pg_proc` says `IMMUTABLE` and not `SECURITY DEFINER`. This is what
+ * catches a function no deny-list can name, because it does not depend on the
+ * name at all.
+ */
+function classifySelect(stmt, effects) {
+    const violations = [];
+    const shape = (0, sql_parser_1.findReadSideEffects)(stmt);
+    if (shape.selectsInto)
+        violations.push('selects_into');
+    if (shape.lockingClauses.length > 0)
+        violations.push('row_locking');
+    if (shape.writableCte)
+        violations.push('writable_cte');
+    const names = (0, sql_parser_1.collectFunctionNames)(stmt);
+    const denied = (0, sql_parser_1.findDeniedReadFunction)(names);
+    if (denied.length > 0)
+        violations.push('denied_function');
+    // Only this statement's own references, so a plan entry does not inherit the
+    // verdicts of its neighbours.
+    const referenced = new Set(names.map((name) => name.toLowerCase()));
+    const records = effects.records.filter((record) => referenced.has(record.name.toLowerCase()));
+    const unsafe = records.filter((record) => record.effect !== 'immutable' || !record.resolved);
+    if (records.length > 0 && unsafe.length > 0)
+        violations.push('side_effect');
+    if (violations.length > 0) {
+        const named = denied[0] ?? unsafe[0]?.name;
+        const kind = named ? `SELECT (${named})` : `SELECT (${violations.join(', ')})`;
+        // Not a read. Reported as `write` so it can never satisfy a `query_read`
+        // check, and so it is visible as a mutation attempt in the audit trail.
+        return base('write', kind, true, 'SELECT', { read_violations: violations }, { records, analysed: effects.analysed });
+    }
+    return base('read', 'SELECT', true, 'SELECT', {}, { records, analysed: effects.analysed });
+}
+/**
+ * `SET` / `RESET` classification.
+ *
+ * Most GUCs are harmless session tuning, but a handful change who the session
+ * is or what it is allowed to do. Those are privilege changes, not utilities,
+ * and must require the `ddl` capability.
+ */
+function classifyVariableSet(node, verb) {
+    const name = String(node?.name ?? '').toLowerCase();
+    const kind = String(node?.kind ?? 'VAR_SET_VALUE').toUpperCase();
+    const PRIVILEGE_GUCS = new Set([
+        'role',
+        'session_authorization',
+        'session_replication_role',
+        'transaction_read_only',
+        'default_transaction_read_only',
+    ]);
+    if (PRIVILEGE_GUCS.has(name) || makesTransactionWritable(node)) {
+        return base('ddl', `SET ${name.toUpperCase()}`, true, verb, {
+            read_violations: ['executable_block'],
+        });
+    }
+    return base('utility', `SET ${kind}`, true, verb);
+}
+/**
+ * True when the statement opens a writable transaction — `SET TRANSACTION READ
+ * WRITE` or `SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE`.
+ *
+ * `default_transaction_read_only = on` is not by itself sufficient: PostgreSQL
+ * lets a transaction override it with an explicit `READ WRITE`, so a statement
+ * that does this in the middle of a request is a request to leave read-only
+ * mode, not session tuning. The parse tree spells it as a `DefElem` with
+ * `defname: 'transaction_read_only'` whose argument is the boolean, where
+ * `false` means `READ WRITE`.
+ */
+function makesTransactionWritable(node) {
+    const args = Array.isArray(node?.args) ? node.args : [];
+    for (const arg of args) {
+        const elem = arg?.DefElem ?? arg;
+        const defname = String(elem?.defname ?? '').toLowerCase();
+        if (defname === 'transaction_read_only' || defname === 'default_transaction_read_only') {
+            if (isFalseArgument(elem))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * True when a `DefElem` argument is the boolean `false`.
+ *
+ * libpg_query's JSON encoding omits zero-valued protobuf fields, so `false`
+ * arrives either as an absent `ival`, as an empty `ival` object or as
+ * `ival: 0`, while `true` always arrives as `ival: { ival: 1 }`.
+ */
+function isFalseArgument(elem) {
+    const constant = elem?.arg?.A_Const;
+    if (constant === undefined || constant === null)
+        return true;
+    if (constant.sval !== undefined)
+        return false;
+    const ival = constant.ival;
+    if (ival === undefined)
+        return true;
+    return ival.ival === undefined || ival.ival === 0;
+}
+function deriveVerb(rootType, node) {
+    switch (rootType) {
+        case 'SelectStmt':
+            return 'SELECT';
+        case 'InsertStmt':
+            return 'INSERT';
+        case 'UpdateStmt':
+            return 'UPDATE';
+        case 'DeleteStmt':
+            return 'DELETE';
+        case 'MergeStmt':
+            return 'MERGE';
+        case 'CreateStmt':
+            return 'CREATE';
+        case 'IndexStmt':
+            return 'CREATE INDEX';
+        case 'CreateTableAsStmt':
+            return 'CREATE TABLE AS';
+        case 'ViewStmt':
+            return 'CREATE VIEW';
+        case 'AlterTableStmt':
+            return 'ALTER';
+        case 'DropStmt':
+            return 'DROP';
+        case 'TruncateStmt':
+            return 'TRUNCATE';
+        case 'GrantStmt':
+            return String(node?.is_grant === false ? 'REVOKE' : 'GRANT');
+        case 'GrantRoleStmt':
+            return String(node?.is_grant === false ? 'REVOKE ROLE' : 'GRANT ROLE');
+        case 'VariableSetStmt':
+            return 'SET';
+        case 'VariableShowStmt':
+            return 'SHOW';
+        case 'TransactionStmt':
+            return String(node?.kind ?? 'BEGIN').toUpperCase();
+        case 'ExplainStmt':
+            return 'EXPLAIN';
+        case 'CopyStmt':
+            return 'COPY';
+        case 'VacuumStmt':
+            return 'VACUUM';
+        case 'ReindexStmt':
+            return 'REINDEX';
+        case 'ClusterStmt':
+            return 'CLUSTER';
+        case 'DoStmt':
+            return 'DO';
+        case 'CallStmt':
+            return 'CALL';
+        case 'ExecuteStmt':
+            return 'EXECUTE';
+        case 'LockStmt':
+            return 'LOCK';
+        case 'AlterSystemStmt':
+            return 'ALTER SYSTEM';
+        case 'CreateRoleStmt':
+            return 'CREATE ROLE';
+        case 'AlterRoleStmt':
+            return 'ALTER ROLE';
+        case 'RefreshMatViewStmt':
+            return 'REFRESH MATERIALIZED VIEW';
+        case 'DeclareCursorStmt':
+            return 'DECLARE';
+        case 'CommentStmt':
+            return 'COMMENT';
+        default:
+            return rootType.replace(/Stmt$/, '').toUpperCase();
+    }
+}
+/*
+ * There are deliberately no `isReadOnly` / `isTransactional` / `extractVerb`
+ * wrappers here any more.
+ *
+ * They each parsed the SQL and then read a field off the classification the
+ * caller could already have, and nothing in production called them — the only
+ * references were tests written to exercise them, which made them look covered
+ * while shipping nothing. Every rule they named is enforced, in production, by
+ * the thing that actually needs it:
+ *
+ *   - "is this a provable read?" is `isProvableRead` in
+ *     `permissions/role-policy.ts`, the predicate `PermissionChecker.check` uses
+ *     for the `read_only`, `auto_upgrade` and `manual` levels and for the
+ *     capability a classification requires. It is the identical rule
+ *     (`type === 'read' && parse_ok && statement_count === 1 && no read
+ *     violations && every referenced function proved IMMUTABLE by pg_proc`);
+ *     keeping a second copy here invited the two to drift.
+ *   - "can this run inside a transaction?" is `classification.transactional`,
+ *     which `execution/non-tx-detector.ts` and the migration runner read, and
+ *     `aggregateClassification` in `permissions/checker.ts` combines.
+ *   - "what is the verb?" is `classification.verb`, interpolated into the
+ *     intent-mismatch reason in `permissions/checker.ts` and into the
+ *     auto-upgrade refusal reasons in `permissions/auto-upgrade.ts`.
+ */
+/**
+ * Classify and throw instead of returning, for call sites that must fail
+ * closed on anything they cannot prove is a read.
+ */
+async function assertSingleReadStatement(sql, options = {}) {
+    let classification;
+    try {
+        classification = await classifyStatement(sql, options);
+    }
+    catch (err) {
+        if (err instanceof sql_parser_1.SqlParserUnavailableError)
+            throw err;
+        if (err instanceof sql_parser_1.SqlParseError) {
+            throw new StatementClassificationError(`PostgreSQL rejected the statement: ${err.message}`, 'parse_error');
+        }
+        throw err;
+    }
+    if (!classification.parse_ok) {
+        throw new StatementClassificationError('Statement could not be parsed.', 'parse_error');
+    }
+    if (classification.statement_count !== 1) {
+        throw new StatementClassificationError(`Expected exactly one statement, found ${classification.statement_count}. ` +
+            'Multi-statement execution is not permitted.', 'multiple_statements');
+    }
+    return classification;
+}
+//# sourceMappingURL=statement-classifier.js.map