code-auditor-mcp 4.1.0 → 5.0.1

package/dist/languages/sql/sqlAst.d.ts

@@ -0,0 +1,494 @@
+/**
+ * SQL as a parsed format — the AST seam.
+ *
+ * Spec 70 R1: a SQL grammar joins the shipped grammars, SQL strings reaching a
+ * data-access call site are parsed into an AST like any other format, and the
+ * dialect is a *closed decision* — one named grammar, not a fallback ladder.
+ * Here that grammar is `node-sql-parser`; the dialect is a required parameter
+ * (the corpus's named {@link Dialect} discriminant, from the discovery-query
+ * registry), never a hardcoded constant — guessing `sqlite` on a Postgres repo
+ * would be a silent wrong answer. It is pure JavaScript (no WASM, no two-phase
+ * init), so it loads synchronously through the ordinary dependency path rather
+ * than the `initParsers()` WASM loader.
+ *
+ * The seam is {@link parseSql}: `{ ok: true, ast }` or `{ ok: false, reason }`.
+ * Every rule that reads SQL facts gets an AST or it gets nothing. There is no
+ * regex path to fall back to — a string the grammar cannot parse is a parse
+ * failure, and the caller turns that into `cannot-fire` with the reason. The
+ * twelve regex sites in the security family convert by consuming the helpers
+ * below (statement kind, relations, where facts, tenant predicate, insert
+ * columns, DDL facts), each of which walks the AST rather than scanning text.
+ *
+ * `node-sql-parser` is a CommonJS module; the default import is required in ESM.
+ */
+import { type AST } from 'node-sql-parser';
+import type { Dialect } from '../../mcp-tools/discoveryQueries.js';
+/**
+ * The named default dialect a caller parses under when detection names none.
+ *
+ * Spec 70 R2: parsing a SQL literal does not require *proving* the site's
+ * dialect first — one grammar is named, with its dialect stated, and the parse
+ * is attempted under it. When {@link detectDialect} returns null (a repo names
+ * no driver, or names several), the caller still attempts the parse under this
+ * default rather than abstaining before it has looked. The default is sqlite:
+ * node-sql-parser's sqlite grammar is the most permissive, and the rest of this
+ * module already standardizes on "the sqlite grammar" as the baseline (see the
+ * `truncateConflictClause` / `ON CONFLICT` notes below).
+ *
+ * The honesty rule is not weakened, it moves: a literal that *parses* under the
+ * default yields facts; a literal that *fails* is reported `cannot-fire` with a
+ * reason naming **both** the parse failure and the fact that the dialect is
+ * undetermined (so the failure may be dialect-specific syntax), never a silent
+ * empty fact set.
+ */
+export declare const DEFAULT_SQL_DIALECT: Dialect;
+export type SqlStatementKind = 'select' | 'insert' | 'replace' | 'update' | 'delete' | 'create' | 'alter' | 'drop' | 'use' | 'other';
+export interface SqlParseOk {
+    readonly ok: true;
+    readonly ast: AST;
+    readonly kind: SqlStatementKind;
+    /** When the input was several statements, every per-statement AST (in order). */
+    readonly statements?: AST[];
+    /**
+     * True when a top-level `ON CONFLICT` clause was truncated before parsing (see
+     * {@link truncateConflictClause}). The clause's update action is "present but
+     * unread" — every fact actually extracted (target table, write status,
+     * predicate presence) is answered by the parsed prefix, and this flag records
+     * that a conflict clause existed rather than silently dropping it.
+     */
+    readonly conflictClauseTruncated?: boolean;
+}
+export interface SqlParseFail {
+    readonly ok: false;
+    readonly reason: string;
+}
+export type SqlParseResult = SqlParseOk | SqlParseFail;
+/** DDL statement kinds — schema definition (CREATE/ALTER/DROP/USE), not a
+ *  row-level data-access query. Schema is extracted separately by the `.sql`
+ *  visitor and Durable Object DDL (`pipelineAdapters.ts`); a data-access call is
+ *  a DML query or an ORM operation, and a DDL literal must not surface as one. */
+export declare function isDdlStatementKind(kind: SqlStatementKind): boolean;
+/**
+ * Rewrite D1-style numbered positional parameters (`?1`, `?2`, …) to the bare
+ * `?` the sqlite grammar accepts. Parameter numbering is an ordering hint, not a
+ * fact: it does not affect which tables are read or whether a tenant predicate
+ * exists, so the rewrite is lossless for every consumer of this module. A `?`
+ * inside a single-quoted string literal is left untouched (that `?` is literal
+ * text, not a placeholder); quoted identifiers (`"…"`, `` `…` ``) are also
+ * skipped so an identifier containing `?` is not rewritten. A doubled quote
+ * (`''` inside a string) stays inside the region.
+ * @param sql The SQL text to rewrite.
+ * @returns The SQL with D1-style numbered parameters (`?1`) rewritten to bare `?`.
+ */
+export declare function normalizePositionalParams(sql: string): string;
+/**
+ * Rewrite a JavaScript template substitution (`${…}`) to the SQL placeholder
+ * `?`. A `${…}` in the SQL text is a host-language interpolation — a value,
+ * identifier, or table name filled in at query-composition time — which the SQL
+ * grammar cannot tokenize (`${` is not a SQL spelling). A value-position
+ * substitution (`WHERE id = ${id}`, `SELECT ${cols} …`) is exactly a parameter,
+ * so `?` is a lossless rewrite: it preserves every table/filter fact the AST
+ * walk reads. A *table-position* substitution (`FROM ${table}`) rewrites to
+ * `FROM ?`, which the grammar rejects — the honest `cannot-fire`, because a
+ * dynamic table name is genuinely unreadable. A `${…}` inside a quoted string
+ * or quoted identifier is literal text the grammar already accepts, so it is
+ * left untouched (rewriting it would corrupt a string literal that happens to
+ * contain `$`).
+ * @param sql The SQL text to rewrite.
+ * @returns The SQL with `${…}` template substitutions rewritten to `?` placeholders.
+ */
+export declare function normalizeTemplateSubstitutions(sql: string): string;
+/**
+ * Rewrite sqlite's length-qualified `TEXT(N)` type spelling to `VARCHAR(N)`.
+ * Drizzle's sqlite dialect emits `text(N)` for string columns, and
+ * node-sql-parser's sqlite grammar accepts the length form only for `varchar(N)`
+ * — it rejects `text(N)` even though sqlite itself accepts it. SQLite gives
+ * `TEXT(N)` and `VARCHAR(N)` the same TEXT affinity, so the rewrite is lossless
+ * for every fact an AST walk reads (table/column names, types, declared lengths)
+ * and recovers a statement that would otherwise report a spurious `cannot-fire`.
+ * Only the `text` keyword *immediately followed by `(`* is rewritten — a bare
+ * `text` (no length), a longer identifier (`textual`), and any occurrence inside
+ * a string literal or quoted identifier are left intact.
+ * @param sql The SQL text to rewrite.
+ * @returns The SQL with length-qualified `text(N)` rewritten to `varchar(N)`.
+ */
+export declare function normalizeSqliteTextLength(sql: string): string;
+/**
+ * Rewrite a string literal whose entire content is one backslash (`'\'`) to the
+ * doubled spelling (`'\\'`). SQLite spells "the escape character is a single
+ * backslash" as `'\'`, but node-sql-parser's lexer reads the bare `'\'` as an
+ * unterminated escaped-quote (`\'` with no closing quote) and rejects the whole
+ * statement — so a `LIKE … ESCAPE '\'` clause (recall-protocol's FTS-escape
+ * spelling) fails to parse. Doubling the backslash is the same value spelled the
+ * way the grammar accepts (`'\\'` is one literal backslash), so the rewrite is
+ * lossless: the escape character is still one backslash, and no fact a rule
+ * reads (relations, filters, statement kind) changes. Only the exact three-char
+ * sequence `'\'` is rewritten, and only where it opens a string literal (never
+ * inside a quoted identifier or a longer string), so a `'\''` (backslash then
+ * escaped quote) or a double-quoted identifier containing `'\'` is left intact.
+ * @param sql The SQL text to rewrite.
+ * @returns The SQL with a lone-backslash string literal rewritten to `'\\'`.
+ */
+export declare function normalizeEscapeClause(sql: string): string;
+/**
+ * Rewrite a bare `?` placeholder in a `LIMIT`/`OFFSET` clause to a literal
+ * (`LIMIT 1` / `OFFSET 0`). node-sql-parser's sqlite grammar accepts `LIMIT 5`
+ * but rejects `LIMIT ?` (a bound-parameter limit) even though sqlite itself
+ * accepts it — so a parameterized `SELECT … LIMIT ? OFFSET ?` (recall-protocol's
+ * paging spelling) fails to parse. The fact a rule reads from a LIMIT/OFFSET
+ * clause is *presence*, not the value (see `whereFacts`), so substituting a
+ * concrete literal is lossless: `LIMIT ?` still reports "has a limit". The
+ * rewrite fires only on a bare `?` immediately after the keyword (whitespace
+ * optional), and skips string literals and quoted identifiers.
+ * @param sql The SQL text to rewrite.
+ * @returns The SQL with `LIMIT ?` → `LIMIT 1` and `OFFSET ?` → `OFFSET 0`.
+ */
+export declare function normalizeLimitOffsetPlaceholders(sql: string): string;
+/**
+ * Rewrite a `CREATE VIRTUAL TABLE name USING fts5(cols…)` declaration to the
+ * `CREATE TABLE name (cols…)` the sqlite grammar accepts. node-sql-parser's
+ * sqlite grammar has no `CREATE VIRTUAL TABLE`, so a full-text-search table
+ * (recall-protocol's `strategies_fts`, declared `USING fts5(...)`) fails to parse
+ * and blanks the table — even though a virtual table is a first-class queryable
+ * relation the lifecycle rules track exactly like a stored table. The facts a
+ * rule reads from the declaration are the table name and its column names; the
+ * FTS5 module wrapper (`USING fts5`, a column's `UNINDEXED`, the trailing
+ * `tokenize = '…'` option) is module configuration, not a table fact. So the
+ * rewrite drops the module syntax and keeps the columns, recovering the same
+ * table/column facts a `CREATE TABLE` would carry. Only a `CREATE VIRTUAL TABLE`
+ * (word-boundary matched, case-insensitive) whose module argument list parses to
+ * at least one bare column is rewritten; anything else — a module option list
+ * with no columns, an unexpected shape — is left untouched and reports an honest
+ * parse failure rather than a fabricated table.
+ * @param sql The SQL text to rewrite.
+ * @returns The SQL with `CREATE VIRTUAL TABLE … USING <module>(cols)` rewritten to `CREATE TABLE … (cols)`.
+ */
+export declare function normalizeVirtualTable(sql: string): string;
+/**
+ * Split a (possibly multi-statement) SQL string on top-level `;`. Semicolons
+ * inside single/double-quoted strings and backtick identifiers are not statement
+ * boundaries, and empty fragments (a trailing `;`) are dropped. A single string
+ * literal carrying several DDL statements (`DROP TABLE a; DROP TABLE b;`) parses
+ * as its statements instead of failing "expected a single statement".
+ *
+ * A `CREATE TRIGGER … BEGIN … END` body carries `;` between its own statements
+ * that are not statement boundaries, so the trigger's `BEGIN … END` block is
+ * tracked and its internal `;` kept inside the statement — otherwise a trigger
+ * would be mid-body-split into a dangling header and a bare `END`. The tracking
+ * is scoped to a statement whose leading text is `CREATE TRIGGER`, so a
+ * transaction's `BEGIN;` or a stray `CASE`/`END` in ordinary SQL is split exactly
+ * as before. A `CASE … END` inside the body is tracked so its `END` is not
+ * mistaken for the trigger's closing `END`.
+ * @param sql The SQL text to split.
+ * @returns The top-level statements, in order, with empty fragments dropped.
+ */
+export declare function splitSqlStatements(sql: string): string[];
+/**
+ * Truncate a SQL string at its top-level `ON CONFLICT` clause, returning the
+ * prefix and a flag recording that a conflict clause was present but not parsed.
+ *
+ * Spec 70 (ON CONFLICT disposition): node-sql-parser's `sqlite` grammar has no
+ * `ON CONFLICT`, so a D1 `INSERT … ON CONFLICT (…) DO UPDATE` upsert is a parse
+ * failure — and the failure took the whole statement down, blanking the target
+ * table / write-status facts the prefix already answers. Those facts (target
+ * table, write status, predicate presence) are all answered by the
+ * `INSERT INTO x (cols) VALUES (…)` prefix, so the clause is cut at a *top-level*
+ * `ON CONFLICT` (not inside a string literal, comment, or parenthesized
+ * subexpression) and the prefix is parsed. The flag keeps "an upsert is present"
+ * distinct from "the write is a plain INSERT" — a future rule reading the update
+ * action sees "present but unread" rather than absent. This is a truncation, not
+ * a normalization: the clause's update action is recorded as dropped, never
+ * silently re-written into an equivalent spelling.
+ * @param sql The SQL text to scan.
+ * @returns The prefix before a top-level `ON CONFLICT` clause, plus a flag recording that a clause was truncated.
+ */
+export declare function truncateConflictClause(sql: string): {
+    text: string;
+    truncated: boolean;
+};
+/**
+ * Parse a SQL string — one statement, or several separated by `;`. Returns
+ * `{ ok: false, reason }` on an empty string, a parse error (after the declared
+ * normalization below), or a program where any statement fails to parse. A
+ * multi-statement string that fully parses is `ok` with `statements` holding
+ * every AST.
+ *
+ * Normalization, applied before the grammar: (a) D1 numbered parameters `?n` →
+ * `?`; (b) a multi-statement string is split on top-level `;` and each statement
+ * parsed individually; (c) a standalone transaction-control statement is
+ * recognized as SQL with no facts. Anything still failing after those is a
+ * genuine `cannot-fire` (e.g. `ON CONFLICT … DO UPDATE`, a Postgres `::` cast).
+ *
+ * @param text The SQL text to parse.
+ * @param dialect The dialect to parse under — the corpus's named dialect, or
+ *   {@link DEFAULT_SQL_DIALECT} when detection named none. The caller is still
+ *   responsible for the honesty: when it supplied the default because the dialect
+ *   is undetermined, a parse failure must be reported naming both the failure and
+ *   the undetermined dialect.
+ * @returns `{ ok: true, ast, kind }` on success (with `statements` for a multi-statement string), or `{ ok: false, reason }` on an empty string, parse error, or unparseable program.
+ */
+export declare function parseSql(text: string, dialect: Dialect): SqlParseResult;
+/** The result of parsing a `.sql` file — a list of statements or a failure. */
+export type SqlProgramResult = {
+    readonly ok: true;
+    readonly statements: AST[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * Parse a `.sql` file's full text into its statements. Used by the DDL
+ * discovery path (which reads whole migration files), not by the per-call-site
+ * parse. Empty text is an empty program, not a failure; a templated migration
+ * (`{{…}}`) is "not SQL until rendered"; a syntax error anywhere is a failure of
+ * the whole file (the same "parse or nothing" contract as {@link parseSql}).
+ *
+ * D1 numbered parameters (`?n` → `?`) are normalized before parsing, as in
+ * {@link parseSql}.
+ *
+ * @param text The `.sql` file's full text.
+ * @param dialect The corpus's named dialect.
+ * @returns A parsed program, or a failure reason (templated migration / syntax error).
+ */
+export declare function parseSqlProgram(text: string, dialect: Dialect): SqlProgramResult;
+/** One statement of a program that failed to parse. */
+export interface SqlStatementFailure {
+    readonly index: number;
+    readonly reason: string;
+}
+/** A tolerant program parse: every statement that parsed, plus the ones that
+ *  failed (with their reasons). */
+export interface TolerantSqlProgram {
+    readonly statements: AST[];
+    readonly failures: readonly SqlStatementFailure[];
+    /** Indices into `statements` whose text carried a top-level `ON CONFLICT`
+     *  clause truncated before parsing (see {@link truncateConflictClause}). */
+    readonly truncatedConflictIndices: readonly number[];
+}
+/**
+ * Parse a `.sql` migration file tolerantly — statement by statement. The
+ * `parseSqlProgram` all-or-nothing contract is right for a single call-site
+ * query string (a query either parses or it is `cannot-fire`), but a migration
+ * file is a *sequence* of DDL statements, and one statement the grammar rejects
+ * (an `UPDATE … FROM`, a Drizzle `ALTER COLUMN "a" TO "a" <type>`) must not
+ * discard the well-formed `CREATE TABLE` beside it. Each statement is split on a
+ * top-level `;` and parsed individually; a `PRAGMA` / `DROP INDEX` / `DROP VIEW`
+ * / `DROP TRIGGER` / `CREATE VIEW` / `CREATE TRIGGER` is *recognized* as no-fact
+ * DDL (not parsed, not a failure), the successes are walked for DDL facts, and
+ * the remaining failures are reported so the caller can account for what it did
+ * not read. This is the honest successor to the regex scanners, which silently
+ * skipped whatever they did not match.
+ *
+ * @param text The `.sql` file's full text.
+ * @param dialect The corpus's named dialect.
+ * @param recognizeNoFactsDdl When true (a migration file), a `PRAGMA` /
+ *   `DROP INDEX` / `DROP VIEW` / `DROP TRIGGER` / `CREATE VIEW` / `CREATE TRIGGER`
+ *   is recognized as no-fact DDL rather than a parse failure. When false (a code
+ *   SQL argument — see {@link parseSqlTables}), it is left to the grammar, so a
+ *   `PRAGMA table_info(x)` surfaces as a parse failure (it names `x`) rather than
+ *   reading "no tables" as clean.
+ * @returns The statements that parsed, the failures with reasons, and the indices of statements whose `ON CONFLICT` clause was truncated.
+ */
+export declare function parseSqlProgramTolerant(text: string, dialect: Dialect, recognizeNoFactsDdl?: boolean): TolerantSqlProgram;
+export interface RelationRef {
+    /** The relation name (a table name, or a CTE alias before filtering). */
+    readonly name: string;
+    /** Which clause the relation came from. */
+    readonly via: 'from' | 'join' | 'into' | 'target' | 'rename' | 'drop';
+}
+/**
+ * Collect every relation referenced by a statement — the raw FROM/JOIN/INTO/
+ * target/rename/drop relations, *without* the CTE-alias filter. This is the
+ * AST replacement for site #1's `extractTables` plus its bolted-on alias filter:
+ * the CTE names are subtracted in {@link extractTableNames}, because a CTE name
+ * is a named result set, not a stored table.
+ *
+ * The walk descends into CTE bodies (`WITH x AS (SELECT … FROM orders)`) and
+ * into `FROM (SELECT …)` subqueries, so a real table referenced only inside a
+ * CTE or subquery is still collected — the flat text scan saw those, and an AST
+ * walk that did not would silently under-count.
+ * @param ast The parsed statement (or program) to walk.
+ * @returns Every relation referenced, with the clause it came from, before CTE filtering.
+ */
+export declare function collectRelations(ast: AST): RelationRef[];
+/** The names of the CTEs declared by a `WITH` clause, lowercased.
+ * @param ast The parsed statement.
+ * @returns The lowercased CTE names. */
+export declare function cteNames(ast: AST): Set<string>;
+/**
+ * The set of table names a statement references, CTE aliases excluded. This is
+ * the AST replacement for `extractTables`: walk FROM/JOIN/INTO/target clauses,
+ * collect relation nodes, then drop the CTE names declared in `WITH`. A CTE
+ * name and a stored table of the same name resolve to the CTE, so a CTE
+ * declaration wins.
+ * @param ast The parsed statement.
+ * @returns The referenced table names, de-duplicated, with CTE aliases excluded.
+ */
+export declare function extractTableNames(ast: AST): string[];
+export type SchemaRefType = 'select' | 'insert' | 'update' | 'delete' | 'create';
+export interface TypedRelation {
+    readonly table: string;
+    /** Schema qualifier (`db` in `db.table`), null when unqualified. */
+    readonly db: string | null;
+    readonly type: SchemaRefType;
+    /**
+     * True when this relation's statement carried a top-level `ON CONFLICT` clause
+     * that was truncated before parsing (see {@link truncateConflictClause}). The
+     * write facts (target table, write status) are answered by the prefix; this
+     * flag records that an upsert action was present but unread.
+     */
+    readonly conflictClauseTruncated?: boolean;
+}
+/** The typed relations of a parsed SQL program (one or more statements), with
+ *  CTE names and ALTER RENAME targets subtracted and nested statements descended.
+ *  `truncatedConflictIndices` names the statements whose text carried a top-level
+ *  `ON CONFLICT` clause (truncated before parsing); their relations are flagged
+ *  `conflictClauseTruncated` so a write is recorded as "upsert present but
+ *  unread" rather than a plain INSERT.
+ * @param statements The parsed statements of the program.
+ * @param truncatedConflictIndices Indices into `statements` whose `ON CONFLICT` clause was truncated.
+ * @returns The typed relations, with CTE names and ALTER RENAME targets subtracted. */
+export declare function collectTypedRelations(statements: AST[], truncatedConflictIndices?: ReadonlySet<number>): TypedRelation[];
+export interface WhereFacts {
+    readonly hasWhere: boolean;
+    readonly hasHaving: boolean;
+    readonly hasLimit: boolean;
+    /** The WHERE clause is entirely tautology (`WHERE 1=1` / `WHERE TRUE`), limiting nothing. */
+    readonly whereIsTautology: boolean;
+}
+/**
+ * Row-limiting facts about a statement — the AST replacement for site #2's
+ * `hasQueryFilter` + `whereClauseIsTautology`. A WHERE carrying a real predicate
+ * (any non-tautology), a HAVING, or a LIMIT limits rows; a bare `WHERE 1=1` does
+ * not.
+ * @param ast The parsed statement.
+ * @returns Row-limiting facts: presence of WHERE/HAVING/LIMIT and whether the WHERE is tautological.
+ */
+export declare function whereFacts(ast: AST): WhereFacts;
+/**
+ * True when a statement is a write (INSERT/DELETE/UPDATE/REPLACE) — the AST
+ * replacement for site #3's `hasWriteVerb`, which had to regex `REPLACE INTO`
+ * as a two-word clause to avoid the `REPLACE()` string function. The statement
+ * kind is that distinction, structurally.
+ */
+export declare function isWriteStatement(ast: AST): boolean;
+/**
+ * True when a statement mass-mutates existing rows (`UPDATE … SET`), the AST
+ * replacement for `hasMassWriteVerb`. `DELETE` is deliberately excluded (Spec 68
+ * disposition (a)); `INSERT`/`REPLACE` target specific rows.
+ */
+export declare function isMassWriteStatement(ast: AST): boolean;
+/**
+ * True when a statement is an upsert — a `REPLACE`, or an `INSERT` carrying an
+ * `ON CONFLICT` / `ON DUPLICATE KEY` clause — the AST replacement for
+ * `isUpsertForm`. An upsert is keyed by construction, so it never reads as an
+ * "unfiltered" mass write.
+ * @param ast The parsed statement.
+ * @returns True when the statement is an upsert (`REPLACE`, or `INSERT` with an `OR` / `ON DUPLICATE KEY` clause).
+ */
+export declare function isUpsertStatement(ast: AST): boolean;
+/**
+ * The column list of an INSERT/REPLACE — the AST replacement for site #6's
+ * `rawInsertColumnList`. `null` columns (an `INSERT … VALUES` with no column
+ * list) yields an empty array, which is a distinct, honest result.
+ * @param ast The parsed statement.
+ * @returns The INSERT/REPLACE column list, or an empty array when there is none.
+ */
+export declare function insertColumns(ast: AST): string[];
+/**
+ * The column references that appear as *predicate operands* in a statement's
+ * WHERE tree — the AST replacement for site #5's four regex families, collapsed
+ * to one walk. A column name in the SELECT list, an INSERT column list, or a
+ * comment is *not* an operand, so a projection can no longer masquerade as a
+ * filter (the Spec 68 Thing 2 `sample_ownership` defect). A quoted identifier on
+ * the left of a comparison (`"org_id" = ?`, the knex/Postgres form) is collected
+ * too, because under a PostgreSQL-style dialect it is a column, not a string
+ * literal.
+ * @param ast The parsed statement.
+ * @returns The lowercased column names that appear as WHERE-tree predicate operands.
+ */
+export declare function whereColumnRefs(ast: AST): Set<string>;
+/**
+ * True when a statement's WHERE clause applies an org/tenant-scoping predicate —
+ * a `col op value` shape where `col` is in the tenant column set. This is the
+ * AST form of `hasOrganizationFilter`; the tenant vocabulary is passed in (the
+ * same vocabulary discovery uses), so the predicate and the tier set can never
+ * read two different vocabularies.
+ *
+ * @param ast The parsed statement.
+ * @param tenantColumns The tenant column names (lowercased) that count as scope.
+ * @returns True when any WHERE predicate operand is a tenant column.
+ */
+export declare function hasTenantPredicate(ast: AST, tenantColumns: ReadonlySet<string>): boolean;
+/** True when a statement is table DDL (`CREATE TABLE` / `DROP TABLE` / `ALTER TABLE`).
+ * @param ast The parsed statement.
+ * @returns True when the statement is `CREATE TABLE`, `DROP TABLE`, or `ALTER TABLE`. */
+export declare function isDdlStatement(ast: AST): boolean;
+/** The table names a DDL statement names (create target, drop names, alter target + rename).
+ * @param ast The parsed statement.
+ * @returns The table names the DDL statement names (create target, drop names, alter target + rename). */
+export declare function ddlTableNames(ast: AST): string[];
+export interface DdlColumn {
+    readonly table: string;
+    readonly column: string;
+    readonly primaryKey: boolean;
+    readonly notNull: boolean;
+    readonly unique: boolean;
+    readonly dataType: string | null;
+}
+export interface DdlForeignKey {
+    readonly table: string;
+    readonly columns: string[];
+    readonly referencesTable: string;
+    readonly referencesColumns: string[];
+}
+/** One ordered migration op (`CREATE` / `DROP` / `RENAME`) for a table. */
+export interface DdlMigrationOp {
+    readonly op: 'CREATE' | 'DROP' | 'RENAME';
+    readonly table: string;
+    readonly newTable?: string;
+}
+/**
+ * Extract every column defined by a `CREATE TABLE` (or `ALTER TABLE … ADD
+ * COLUMN`) statement — the AST replacement for site #9's
+ * `extractDdlTableColumns` + `leadingColumnName` + `splitColumnDefs`, which
+ * hand-rolled paren-depth and quote tracking. The column name and its
+ * constraints (primary-key / not-null / unique) come straight off the
+ * definition nodes.
+ * @param ast The parsed `CREATE TABLE` or `ALTER TABLE … ADD COLUMN` statement.
+ * @returns Each column with its primary-key / not-null / unique flags and data type.
+ */
+export declare function ddlColumnDefinitions(ast: AST): DdlColumn[];
+/**
+ * Extract the foreign-key constraints of a `CREATE TABLE` or `ALTER TABLE … ADD
+ * CONSTRAINT … FOREIGN KEY` statement — the AST replacement for site #10's FK
+ * regexes. Covers the three DDL spellings: column-level `REFERENCES`, table-level
+ * `FOREIGN KEY (…) REFERENCES`, and ALTER `ADD CONSTRAINT … FOREIGN KEY`. The
+ * referenced table and columns come straight off the `reference_definition` node.
+ * @param ast The parsed `CREATE TABLE` or `ALTER TABLE` statement.
+ * @returns The foreign-key constraints, with local columns and the referenced table/columns.
+ */
+export declare function ddlForeignKeys(ast: AST): DdlForeignKey[];
+/**
+ * The ordered CREATE / DROP / RENAME ops of a table-DDL statement — the AST
+ * replacement for site #7's `DDL_RE` (which had to regex the whole
+ * create/drop/alter-rename vocabulary as one alternation). The statement kind and
+ * its target/rename nodes are read directly.
+ * @param ast The parsed table-DDL statement.
+ * @returns The ordered CREATE / DROP / RENAME ops.
+ */
+export declare function ddlMigrationOps(ast: AST): DdlMigrationOp[];
+/**
+ * The columns of a table-level or ALTER-added UNIQUE / PRIMARY KEY constraint —
+ * the AST replacement for the table-level halves of `extractDdlUniqueColumns` and
+ * `extractDdlPrimaryKeyColumns`, which had to hand-roll paren matching to find
+ * the column list inside `UNIQUE (…)`. Column-level `UNIQUE` / `PRIMARY KEY` is
+ * already carried by {@link ddlColumnDefinitions}.
+ * @param ast The parsed `CREATE TABLE` or `ALTER TABLE` statement.
+ * @param constraintType `'unique'` or `'primary key'`.
+ * @returns The lowercased columns of table-level / ALTER-added constraints of that kind.
+ */
+export declare function ddlConstraintColumns(ast: AST, constraintType: 'unique' | 'primary key'): string[];
+/** The {@link SqlStatementKind} of a parsed statement. */
+export declare function kindOf(ast: AST): SqlStatementKind;
+//# sourceMappingURL=sqlAst.d.ts.map

package/dist/languages/sql/sqlAst.d.ts.map

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