turbine-orm 0.81.0 → 0.90.0

package/dist/supplied-pool-types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * turbine-orm, Turbine's column readings on a pool the caller supplied.
+ *
+ * Turbine reads `bigint` (int8) as a number and, under `utcTimestamps`, the
+ * zone-less `timestamp` and `date` types (and their arrays) as UTC. On a pool
+ * Turbine opens, those parsers are registered on the pg module. A pool the
+ * caller supplies keeps the caller's parser table, so Turbine attaches its
+ * parsers to each of its OWN queries instead: node-postgres reads a
+ * query-level `types` in place of the connection's. The caller's own queries
+ * on the same pool keep the caller's parsers.
+ *
+ * Everything Turbine does not govern is read from the table the query would
+ * otherwise have used (the connection's, else the pool's `types` option, else
+ * the driver's), so a parser the caller installed for another type still
+ * applies to Turbine's reads.
+ */
+import type { PgCompatPool, PgCompatPoolClient } from './pg-types.js';
+/** Where node-postgres reads a parser from: `pg.types`, a pool's `types` option, a client's table. */
+export interface TypeParserTable {
+    getTypeParser(oid: number, format?: string): unknown;
+}
+/** int8 as a number while the number is exact, else the driver's string. */
+export declare const parseInt8: (text: string) => number | string;
+/**
+ * A parser table with Turbine's readings over `base`. `base` is read at lookup
+ * time, so a parser the caller registers later is still the fallback. Built
+ * parsers are cached per OID and rebuilt when what they were built over
+ * changes.
+ */
+export declare function turbineTypeTable(base: () => TypeParserTable, utcTimestamps: boolean): TypeParserTable;
+/**
+ * The pool Turbine sends its own queries through, for a caller-supplied
+ * PostgreSQL pool: `query` and every client from `connect` carry Turbine's
+ * parsers. Everything else (`end`, counts, events, `instanceof`) is the pool's
+ * own.
+ *
+ * Returns `undefined`, meaning "use the pool as it is", for a pool that is not
+ * built on node-postgres (it may not read a query config at all) and for a
+ * build without the driver's parsers. A driver that accepts a config but
+ * ignores its `types` keeps its own readings.
+ */
+export declare function typedQueryPool(pool: PgCompatPool, utcTimestamps: boolean): PgCompatPool | undefined;
+/**
+ * The driver connection behind a client {@link typedQueryPool} handed out, or
+ * `client` itself. Used where the caller is given the connection to run their
+ * own statements on, which keep the driver's readings.
+ */
+export declare function rawClientOf(client: PgCompatPoolClient): PgCompatPoolClient;

package/dist/supplied-pool-types.js

@@ -0,0 +1,247 @@
+/**
+ * turbine-orm, Turbine's column readings on a pool the caller supplied.
+ *
+ * Turbine reads `bigint` (int8) as a number and, under `utcTimestamps`, the
+ * zone-less `timestamp` and `date` types (and their arrays) as UTC. On a pool
+ * Turbine opens, those parsers are registered on the pg module. A pool the
+ * caller supplies keeps the caller's parser table, so Turbine attaches its
+ * parsers to each of its OWN queries instead: node-postgres reads a
+ * query-level `types` in place of the connection's. The caller's own queries
+ * on the same pool keep the caller's parsers.
+ *
+ * Everything Turbine does not govern is read from the table the query would
+ * otherwise have used (the connection's, else the pool's `types` option, else
+ * the driver's), so a parser the caller installed for another type still
+ * applies to Turbine's reads.
+ */
+import pg from '#pg';
+import { createFastTimestamptzParser, createPgArrayParser, createUtcDateParser, createUtcTimestampParser, isDefaultTextParser, markTurbineParser, } from './query/utils.js';
+/** Same key `markTurbineParser` sets (`Symbol.for`, so ESM and CJS copies agree). */
+const TURBINE_PARSER = Symbol.for('turbine.typeParser');
+/** Reads the driver connection back out of a typed client (see {@link rawClientOf}). */
+const RAW_CLIENT = Symbol.for('turbine.rawClient');
+function isTurbineParser(parser) {
+    return typeof parser === 'function' && parser[TURBINE_PARSER] === true;
+}
+/** int8 as a number while the number is exact, else the driver's string. */
+export const parseInt8 = markTurbineParser((text) => {
+    const n = Number(text);
+    return Number.isSafeInteger(n) ? n : text;
+});
+/** The OIDs `utcTimestamps` governs (1184/1185 only for decode speed, as in `registerUtcTemporalParsers`). */
+const UTC_OIDS = new Set([1082, 1114, 1115, 1182, 1184, 1185]);
+/** Array OID to element OID, for the forms built over a scalar parser. */
+const ARRAY_ELEMENT = { 1115: 1114, 1182: 1082, 1185: 1184 };
+/**
+ * A parser table with Turbine's readings over `base`. `base` is read at lookup
+ * time, so a parser the caller registers later is still the fallback. Built
+ * parsers are cached per OID and rebuilt when what they were built over
+ * changes.
+ */
+export function turbineTypeTable(base, utcTimestamps) {
+    const built = new Map();
+    const parserFor = (oid) => {
+        const fallback = base().getTypeParser(oid, 'text');
+        if (oid !== 20 && !(utcTimestamps && UTC_OIDS.has(oid)))
+            return fallback;
+        const elementOid = ARRAY_ELEMENT[oid];
+        const element = elementOid === undefined ? undefined : parserFor(elementOid);
+        const cached = built.get(oid);
+        if (cached && cached.from === fallback && cached.element === element)
+            return cached.parser;
+        const parser = isTurbineParser(fallback) ? fallback : build(oid, fallback, element);
+        built.set(oid, { from: fallback, element, parser });
+        return parser;
+    };
+    const build = (oid, fallback, element) => {
+        switch (oid) {
+            case 20:
+                return parseInt8;
+            case 1082:
+                return markTurbineParser(createUtcDateParser(fallback));
+            case 1114:
+                return markTurbineParser(createUtcTimestampParser(fallback));
+            case 1115:
+            case 1182:
+                return markTurbineParser(createPgArrayParser(element));
+            case 1184:
+                // Speed only: a caller's own timestamptz parser is kept, as on owned pools.
+                return isDefaultTextParser(1184, fallback)
+                    ? markTurbineParser(createFastTimestamptzParser(fallback))
+                    : fallback;
+            case 1185:
+                return isTurbineParser(element) && isDefaultTextParser(1185, fallback)
+                    ? markTurbineParser(createPgArrayParser(element))
+                    : fallback;
+            default:
+                return fallback;
+        }
+    };
+    return {
+        getTypeParser(oid, format = 'text') {
+            return format === 'text' ? parserFor(oid) : base().getTypeParser(oid, format);
+        },
+    };
+}
+let driverTypes;
+/**
+ * Whether this build has the real driver's parsers to build from. Under the
+ * `edge-light` and `browser` conditions `#pg` is a stand-in with none, so
+ * Turbine leaves a supplied pool's parsing to that pool's driver there.
+ */
+function driverTypesAvailable() {
+    if (driverTypes === undefined) {
+        try {
+            const arrays = pg.types
+                .arrayParser;
+            driverTypes = Array.isArray(arrays.create('{}', (v) => v).parse());
+        }
+        catch {
+            driverTypes = false;
+        }
+    }
+    return driverTypes;
+}
+function isTable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.getTypeParser === 'function');
+}
+/**
+ * The table a query on `pool` would use without Turbine: a connected client's
+ * (which already folds in the pool's `types` option and the driver copy the
+ * pool was built from), else the pool's `types` option, else this module's
+ * driver. pg-pool keeps every client it opened in `_clients`; a pool without
+ * that field falls through to the option and the driver.
+ */
+function poolTypeBase(pool) {
+    let fromClient;
+    return () => {
+        if (fromClient)
+            return fromClient;
+        const clients = pool._clients;
+        if (Array.isArray(clients)) {
+            for (const client of clients) {
+                const types = client?._types;
+                if (isTable(types)) {
+                    fromClient = types;
+                    return types;
+                }
+            }
+        }
+        const configured = pool.options?.types;
+        return isTable(configured) ? configured : pg.types;
+    };
+}
+/**
+ * `(text, values)` or a query config, with `types` attached. A submittable
+ * (a cursor) carries its own result: it gets the table the same way
+ * node-postgres gives it the connection's, only when it has none.
+ */
+function withTypes(textOrConfig, values, types) {
+    if (typeof textOrConfig === 'string') {
+        return values === undefined ? { text: textOrConfig, types } : { text: textOrConfig, values, types };
+    }
+    if (typeof textOrConfig !== 'object' || textOrConfig === null)
+        return textOrConfig;
+    const config = textOrConfig;
+    if (typeof config.submit === 'function') {
+        if (config._result && !config._result._types)
+            config._result._types = types;
+        return config;
+    }
+    if (config.types !== undefined)
+        return config;
+    return values === undefined ? { ...config, types } : { ...config, values, types };
+}
+/** Forward every other member to the target, bound to it, so the driver's internals see the real object. */
+function forwardingProxy(target, own) {
+    const bound = new Map();
+    return new Proxy(target, {
+        get(t, prop) {
+            const mine = own(prop);
+            if (mine !== undefined)
+                return mine;
+            const value = Reflect.get(t, prop, t);
+            if (typeof value !== 'function')
+                return value;
+            const hit = bound.get(prop);
+            if (hit && hit.fn === value)
+                return hit.bound;
+            const fn = value.bind(t);
+            bound.set(prop, { fn: value, bound: fn });
+            return fn;
+        },
+        set(t, prop, value) {
+            return Reflect.set(t, prop, value, t);
+        },
+    });
+}
+/**
+ * The pool Turbine sends its own queries through, for a caller-supplied
+ * PostgreSQL pool: `query` and every client from `connect` carry Turbine's
+ * parsers. Everything else (`end`, counts, events, `instanceof`) is the pool's
+ * own.
+ *
+ * Returns `undefined`, meaning "use the pool as it is", for a pool that is not
+ * built on node-postgres (it may not read a query config at all) and for a
+ * build without the driver's parsers. A driver that accepts a config but
+ * ignores its `types` keeps its own readings.
+ */
+export function typedQueryPool(pool, utcTimestamps) {
+    if (typeof pool.Client !== 'function' || !driverTypesAvailable()) {
+        return undefined;
+    }
+    const target = pool;
+    const table = turbineTypeTable(poolTypeBase(pool), utcTimestamps);
+    const clients = new WeakMap();
+    const typedClient = (client) => {
+        const known = clients.get(client);
+        if (known)
+            return known;
+        const own = client._types;
+        const clientTable = isTable(own) ? turbineTypeTable(() => own, utcTimestamps) : table;
+        const send = client.query;
+        const query = (textOrConfig, values, ...more) => more.length > 0 || typeof values === 'function'
+            ? send.call(client, textOrConfig, values, ...more)
+            : send.call(client, withTypes(textOrConfig, values, clientTable));
+        const typed = forwardingProxy(client, (prop) => {
+            if (prop === 'query')
+                return query;
+            if (prop === '_types')
+                return clientTable;
+            if (prop === RAW_CLIENT)
+                return client;
+            return undefined;
+        });
+        clients.set(client, typed);
+        return typed;
+    };
+    const query = (textOrConfig, values, ...more) => {
+        const send = target.query;
+        return more.length > 0 || typeof values === 'function'
+            ? send.call(pool, textOrConfig, values, ...more)
+            : send.call(pool, withTypes(textOrConfig, values, table));
+    };
+    const connect = (...args) => {
+        const open = target.connect;
+        if (args.length > 0)
+            return open.apply(pool, args);
+        return open.call(pool).then(typedClient);
+    };
+    return forwardingProxy(target, (prop) => {
+        if (prop === 'query')
+            return query;
+        if (prop === 'connect')
+            return connect;
+        return undefined;
+    });
+}
+/**
+ * The driver connection behind a client {@link typedQueryPool} handed out, or
+ * `client` itself. Used where the caller is given the connection to run their
+ * own statements on, which keep the driver's readings.
+ */
+export function rawClientOf(client) {
+    return client[RAW_CLIENT] ?? client;
+}

package/dist/transaction-control.d.ts

@@ -0,0 +1,51 @@
+/**
+ * turbine-orm, finding transaction-control statements in SQL the caller wrote
+ *
+ * A `COMMIT`, `ROLLBACK`, `BEGIN`, `SAVEPOINT` (and the rest of the family) sent
+ * through a transaction's raw paths ends or reshapes the transaction behind the
+ * state that tracks it: later statements autocommit, a savepoint sits on a stack
+ * Turbine did not push, and the final COMMIT or ROLLBACK reports on a transaction
+ * that is no longer there. {@link TransactionState.runRaw} refuses them, and this
+ * leaf is how it recognises one.
+ *
+ * It reads statement STARTS only: the leading words of every statement in the
+ * text, found with the lexical rules of the engine that will run it, so a
+ * `COMMIT` inside a string literal, a quoted identifier, a dollar-quoted body or a
+ * comment is not mistaken for a statement. It is NOT a second statement
+ * splitter: `cli/sql-statements.ts` owns that job for migrations, and
+ * `src/test/fx-tx-control.test.ts` holds this file to it (same statement
+ * boundaries, same first word, over an adversarial corpus). It lives apart from
+ * that file because the CLI tokenizer is a CLI module (the library imports one
+ * file from `cli/`, `destructive.ts`, and nothing else), and importing it here
+ * would put it in every engine entry and the edge entry, whose size is a
+ * published claim.
+ *
+ * Where a reading is ambiguous the scan treats more text as quoted, never less:
+ * a statement it fails to see goes through exactly as it did before this guard
+ * existed, while one it invents inside a literal would refuse a valid query.
+ *
+ * Zero imports.
+ */
+/** Which engine's lexical rules to read the text with. */
+export type ControlSyntax = 'postgresql' | 'mysql' | 'sqlite' | 'mssql';
+export type ControlKind = 'begin' | 'commit' | 'rollback' | 'rollback-to' | 'savepoint' | 'release' | 'set-transaction' | 'prepare';
+/** One transaction-control statement found in a piece of SQL. */
+export interface ControlStatement {
+    readonly kind: ControlKind;
+    /** The statement's leading keyword(s) in upper case, for a message (`COMMIT`, `START TRANSACTION`). */
+    readonly label: string;
+}
+/**
+ * Every transaction-control statement in `sql`, in order. Empty when there is
+ * none, which is the answer for almost every statement and costs one pass.
+ */
+export declare function findTransactionControl(sql: string, syntax: ControlSyntax): ControlStatement[];
+/**
+ * The leading words of every statement in `sql`, lower-cased (`?` stands for a
+ * token that is not a word: a literal, a quoted identifier, a symbol). This is
+ * the whole of what the scan decides, exported so the test that holds it to
+ * `cli/sql-statements.ts` can compare statement boundaries directly.
+ */
+export declare function leadingWords(sql: string, syntax: ControlSyntax): string[][];
+/** Whether `text` could hold a transaction-control statement at all (a cheap test before the scan). */
+export declare function mayHoldTransactionControl(text: string): boolean;

package/dist/transaction-control.js

@@ -0,0 +1,311 @@
+/**
+ * turbine-orm, finding transaction-control statements in SQL the caller wrote
+ *
+ * A `COMMIT`, `ROLLBACK`, `BEGIN`, `SAVEPOINT` (and the rest of the family) sent
+ * through a transaction's raw paths ends or reshapes the transaction behind the
+ * state that tracks it: later statements autocommit, a savepoint sits on a stack
+ * Turbine did not push, and the final COMMIT or ROLLBACK reports on a transaction
+ * that is no longer there. {@link TransactionState.runRaw} refuses them, and this
+ * leaf is how it recognises one.
+ *
+ * It reads statement STARTS only: the leading words of every statement in the
+ * text, found with the lexical rules of the engine that will run it, so a
+ * `COMMIT` inside a string literal, a quoted identifier, a dollar-quoted body or a
+ * comment is not mistaken for a statement. It is NOT a second statement
+ * splitter: `cli/sql-statements.ts` owns that job for migrations, and
+ * `src/test/fx-tx-control.test.ts` holds this file to it (same statement
+ * boundaries, same first word, over an adversarial corpus). It lives apart from
+ * that file because the CLI tokenizer is a CLI module (the library imports one
+ * file from `cli/`, `destructive.ts`, and nothing else), and importing it here
+ * would put it in every engine entry and the edge entry, whose size is a
+ * published claim.
+ *
+ * Where a reading is ambiguous the scan treats more text as quoted, never less:
+ * a statement it fails to see goes through exactly as it did before this guard
+ * existed, while one it invents inside a literal would refuse a valid query.
+ *
+ * Zero imports.
+ */
+/** Words that may follow `BEGIN` when it opens a transaction (and not a block, `BEGIN TRY`, `BEGIN ATOMIC`). */
+const BEGIN_NEXT = new Set([
+    'work',
+    'transaction',
+    'tran',
+    'isolation',
+    'read',
+    'not',
+    'deferrable',
+    'deferred',
+    'immediate',
+    'exclusive',
+    'distributed',
+]);
+/** Leading words kept per statement: enough for `ROLLBACK WORK TO SAVEPOINT name`. */
+const LEADING_WORDS = 4;
+const WORD_START = /[A-Za-z_\u0080-￿]/;
+const WORD_PART = /[A-Za-z0-9_$\u0080-￿]/;
+const RULES = {
+    postgresql: {
+        nestedBlockComments: true,
+        hashComment: false,
+        dashNeedsSpace: false,
+        backslashAlways: false,
+        dollarQuotes: true,
+        backtick: false,
+        bracket: false,
+    },
+    mysql: {
+        nestedBlockComments: false,
+        hashComment: true,
+        dashNeedsSpace: true,
+        backslashAlways: true,
+        dollarQuotes: false,
+        backtick: true,
+        bracket: false,
+    },
+    sqlite: {
+        nestedBlockComments: false,
+        hashComment: false,
+        dashNeedsSpace: false,
+        backslashAlways: false,
+        dollarQuotes: false,
+        backtick: true,
+        bracket: true,
+    },
+    mssql: {
+        nestedBlockComments: true,
+        hashComment: false,
+        dashNeedsSpace: false,
+        backslashAlways: false,
+        dollarQuotes: false,
+        backtick: false,
+        bracket: true,
+    },
+};
+/** Offset just past the quoted run that opens at `i`, doubled closing quotes honoured. */
+function skipQuoted(sql, i, close, backslash) {
+    const n = sql.length;
+    let j = i + 1;
+    while (j < n) {
+        const ch = sql[j];
+        if (backslash && ch === '\\') {
+            j += 2;
+            continue;
+        }
+        if (ch === close) {
+            if (sql[j + 1] === close) {
+                j += 2;
+                continue;
+            }
+            return j + 1;
+        }
+        j++;
+    }
+    return n;
+}
+/** Offset just past the block comment that opens at `i`. */
+function skipBlockComment(sql, i, nests) {
+    const n = sql.length;
+    let depth = 1;
+    let j = i + 2;
+    while (j < n) {
+        if (nests && sql[j] === '/' && sql[j + 1] === '*') {
+            depth++;
+            j += 2;
+        }
+        else if (sql[j] === '*' && sql[j + 1] === '/') {
+            j += 2;
+            if (--depth === 0)
+                return j;
+        }
+        else {
+            j++;
+        }
+    }
+    return n;
+}
+/** Offset just past the end of the line that `i` is on. */
+function skipLine(sql, i) {
+    const end = sql.indexOf('\n', i);
+    return end === -1 ? sql.length : end + 1;
+}
+/**
+ * Every transaction-control statement in `sql`, in order. Empty when there is
+ * none, which is the answer for almost every statement and costs one pass.
+ */
+export function findTransactionControl(sql, syntax) {
+    const found = [];
+    for (const words of leadingWords(sql, syntax)) {
+        const statement = classify(words, syntax);
+        if (statement !== undefined)
+            found.push(statement);
+    }
+    return found;
+}
+/**
+ * The leading words of every statement in `sql`, lower-cased (`?` stands for a
+ * token that is not a word: a literal, a quoted identifier, a symbol). This is
+ * the whole of what the scan decides, exported so the test that holds it to
+ * `cli/sql-statements.ts` can compare statement boundaries directly.
+ */
+export function leadingWords(sql, syntax) {
+    const rules = RULES[syntax];
+    const statements = [];
+    const n = sql.length;
+    let words = [];
+    /** Where the previous word ended, and the word, so `E'...'` is read as one token. */
+    let lastWordEnd = -1;
+    let lastWord = '';
+    /** Inside a `BEGIN ATOMIC ... END` routine body, whose semicolons do not end the statement. */
+    let atomic = false;
+    let caseDepth = 0;
+    const finish = () => {
+        if (words.length > 0)
+            statements.push(words);
+        words = [];
+    };
+    const note = (word) => {
+        if (words.length < LEADING_WORDS)
+            words.push(word);
+    };
+    let i = 0;
+    while (i < n) {
+        const ch = sql[i];
+        if (ch === ';') {
+            if (!atomic)
+                finish();
+            i++;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '\f') {
+            i++;
+            continue;
+        }
+        if (ch === '-' && sql[i + 1] === '-') {
+            const after = sql[i + 2];
+            if (!rules.dashNeedsSpace || after === undefined || /\s/.test(after) || after.charCodeAt(0) < 32) {
+                i = skipLine(sql, i);
+                continue;
+            }
+        }
+        if (ch === '#' && rules.hashComment) {
+            i = skipLine(sql, i);
+            continue;
+        }
+        if (ch === '/' && sql[i + 1] === '*') {
+            i = skipBlockComment(sql, i, rules.nestedBlockComments);
+            continue;
+        }
+        if (ch === "'") {
+            // PostgreSQL's `E'...'` honours backslash escapes; every other `'...'` there does not.
+            const escaped = rules.backslashAlways || (syntax === 'postgresql' && lastWordEnd === i && /^[eE]$/.test(lastWord));
+            i = skipQuoted(sql, i, "'", escaped);
+            note('?');
+            continue;
+        }
+        if (ch === '"') {
+            i = skipQuoted(sql, i, '"', rules.backslashAlways);
+            note('?');
+            continue;
+        }
+        if (ch === '`' && rules.backtick) {
+            i = skipQuoted(sql, i, '`', false);
+            note('?');
+            continue;
+        }
+        if (ch === '[' && rules.bracket) {
+            i = skipQuoted(sql, i, ']', false);
+            note('?');
+            continue;
+        }
+        if (ch === '$' && rules.dollarQuotes) {
+            const tag = /^\$([A-Za-z_\u0080-￿][A-Za-z0-9_\u0080-￿]*)?\$/.exec(sql.slice(i, i + 130));
+            if (tag) {
+                const close = sql.indexOf(tag[0], i + tag[0].length);
+                i = close === -1 ? n : close + tag[0].length;
+                note('?');
+                continue;
+            }
+        }
+        if (WORD_START.test(ch)) {
+            // A whole identifier, so a `$` inside it never opens a dollar quote.
+            let j = i + 1;
+            while (j < n && WORD_PART.test(sql[j]))
+                j++;
+            const word = sql.slice(i, j).toLowerCase();
+            if (syntax === 'postgresql') {
+                // PostgreSQL 14's SQL-standard function body: its inner semicolons are not statement ends.
+                // `CASE ... END` inside it is the only other END a body can hold.
+                if (!atomic && word === 'atomic' && lastWord === 'begin' && lastWordEnd <= i && sqlGap(sql, lastWordEnd, i)) {
+                    atomic = true;
+                    caseDepth = 0;
+                }
+                else if (atomic) {
+                    if (word === 'case')
+                        caseDepth++;
+                    else if (word === 'end') {
+                        if (caseDepth > 0)
+                            caseDepth--;
+                        else
+                            atomic = false;
+                    }
+                }
+            }
+            note(word);
+            lastWordEnd = j;
+            lastWord = word;
+            i = j;
+            continue;
+        }
+        note('?');
+        lastWord = '';
+        i++;
+    }
+    finish();
+    return statements;
+}
+/** Whether only whitespace lies between `from` and `to` (comments count as something). */
+function sqlGap(sql, from, to) {
+    return /^\s*$/.test(sql.slice(from, to));
+}
+/** The control statement whose leading `words` these are, if they are one. */
+function classify(words, syntax) {
+    const [w0, w1, w2] = words;
+    switch (w0) {
+        case 'begin':
+            return w1 === undefined || BEGIN_NEXT.has(w1) ? { kind: 'begin', label: 'BEGIN' } : undefined;
+        case 'start':
+            return w1 === 'transaction' ? { kind: 'begin', label: 'START TRANSACTION' } : undefined;
+        case 'commit':
+            return { kind: 'commit', label: 'COMMIT' };
+        case 'end':
+            return (syntax === 'postgresql' || syntax === 'sqlite') &&
+                (w1 === undefined || w1 === 'work' || w1 === 'transaction' || w1 === 'and')
+                ? { kind: 'commit', label: 'END' }
+                : undefined;
+        case 'rollback':
+            return w1 === 'to' || ((w1 === 'work' || w1 === 'transaction' || w1 === 'tran') && w2 === 'to')
+                ? { kind: 'rollback-to', label: 'ROLLBACK TO SAVEPOINT' }
+                : { kind: 'rollback', label: 'ROLLBACK' };
+        case 'abort':
+            return syntax === 'postgresql' ? { kind: 'rollback', label: 'ABORT' } : undefined;
+        case 'savepoint':
+            return { kind: 'savepoint', label: 'SAVEPOINT' };
+        case 'save':
+            return syntax === 'mssql' && (w1 === 'tran' || w1 === 'transaction')
+                ? { kind: 'savepoint', label: 'SAVE TRANSACTION' }
+                : undefined;
+        case 'release':
+            return { kind: 'release', label: 'RELEASE SAVEPOINT' };
+        case 'set':
+            return w1 === 'transaction' ? { kind: 'set-transaction', label: 'SET TRANSACTION' } : undefined;
+        case 'prepare':
+            return w1 === 'transaction' ? { kind: 'prepare', label: 'PREPARE TRANSACTION' } : undefined;
+        default:
+            return undefined;
+    }
+}
+/** Whether `text` could hold a transaction-control statement at all (a cheap test before the scan). */
+export function mayHoldTransactionControl(text) {
+    return /\b(?:begin|start|commit|end|rollback|abort|savepoint|save|release|set|prepare)\b/i.test(text);
+}