vouchington-tooling 0.0.2 → 0.0.3

package/README.md

@@ -35,4 +35,6 @@ import {
   listenOnRunnerUnreservedEphemeralPort,
   runnerPortPolicy,
 } from 'vouchington-tooling/runner-port-policy'
+import { initSqlAst, extractCreateTableMetadata } from 'vouchington-tooling/sql-ast'
+import { splitSqlStatements, stripSqlComments } from 'vouchington-tooling/sql-scanner'
 ```

package/dist/index.d.mts

@@ -1,3 +1,5 @@
 export { EphemeralListenerAttemptsExhaustedError, isRunnerReservedPort, listenOnRunnerUnreservedEphemeralPort, loadRunnerPortPolicy, runnerPortPolicy, validateRunnerPortPolicy, } from './runner-port-policy/index.mts';
 export type { EphemeralListenerOptions, RunnerPortPolicy } from './runner-port-policy/index.mts';
-export { extractAlterTableAddColumnLocations, initSqlAst, lineOfUtf8ByteOffset, MissingSqlAstParserError, } from './sql-ast/index.mts';
+export { extractAlterTableAddColumnLocations, extractCreateIndexMetadata, extractCreateTableMetadata, extractDefaultFunction, extractDropIndexMetadata, extractFuncCallArgColumnNames, extractMigrationConstraintMetadata, initSqlAst, lineOfUtf8ByteOffset, MissingSqlAstParserError, parseSql, } from './sql-ast/index.mts';
+export type { ForeignKey, SqlCreateIndexMetadata, SqlCreateTableColumn, SqlCreateTableMetadata, SqlDropIndexMetadata, SqlIndexParam, SqlMigrationConstraintMetadata, } from './sql-ast/index.mts';
+export { dollarQuoteEnd, lineOf, maskSqlQuotedText, readDollarQuoteDelimiter, readStringLiteral, splitSqlStatements, sqlFragments, stripSqlComments, } from './sql-scanner/index.mts';

package/dist/index.mjs

@@ -1,2 +1,3 @@
 export { EphemeralListenerAttemptsExhaustedError, isRunnerReservedPort, listenOnRunnerUnreservedEphemeralPort, loadRunnerPortPolicy, runnerPortPolicy, validateRunnerPortPolicy, } from './runner-port-policy/index.mjs';
-export { extractAlterTableAddColumnLocations, initSqlAst, lineOfUtf8ByteOffset, MissingSqlAstParserError, } from './sql-ast/index.mjs';
+export { extractAlterTableAddColumnLocations, extractCreateIndexMetadata, extractCreateTableMetadata, extractDefaultFunction, extractDropIndexMetadata, extractFuncCallArgColumnNames, extractMigrationConstraintMetadata, initSqlAst, lineOfUtf8ByteOffset, MissingSqlAstParserError, parseSql, } from './sql-ast/index.mjs';
+export { dollarQuoteEnd, lineOf, maskSqlQuotedText, readDollarQuoteDelimiter, readStringLiteral, splitSqlStatements, sqlFragments, stripSqlComments, } from './sql-scanner/index.mjs';

package/dist/sql-ast/add-column.d.mts

@@ -0,0 +1 @@
+export declare function extractAlterTableAddColumnLocations(content: string): number[];

package/dist/sql-ast/add-column.mjs

@@ -0,0 +1,22 @@
+import { parseSql } from './parser.mjs';
+export function extractAlterTableAddColumnLocations(content) {
+    const locations = [];
+    const parseResult = parseSql(content);
+    for (const rawStmt of parseResult.stmts ?? []) {
+        const node = rawStmt.stmt;
+        if (!node || !('AlterTableStmt' in node))
+            continue;
+        for (const rawCommand of node.AlterTableStmt.cmds ?? []) {
+            if (!rawCommand || !('AlterTableCmd' in rawCommand))
+                continue;
+            const command = rawCommand.AlterTableCmd;
+            if (command.subtype !== 'AT_AddColumn')
+                continue;
+            const definition = command.def;
+            if (!definition || !('ColumnDef' in definition))
+                continue;
+            locations.push(rawStmt.stmt_location ?? 0);
+        }
+    }
+    return locations;
+}

package/dist/sql-ast/constraint-do-block.d.mts

@@ -0,0 +1,11 @@
+import type { AlterTableStmt, DoStmt } from '@libpg-query/parser';
+import { type SqlMigrationConstraintMetadata } from './constraint-shared.mts';
+/**
+ * Applies AT_AddConstraint / AT_ValidateConstraint commands from one ALTER TABLE to `result`.
+ *
+ * `trackConstraintValidation` gates NOT VALID/VALIDATE pairing bookkeeping. Callers that
+ * parse ALTER TABLE text out of a DO body should pass false so only `foreignKeys` is filled.
+ */
+export declare function processAlterTableStmt(statement: AlterTableStmt, baseOffset: number, result: SqlMigrationConstraintMetadata, trackConstraintValidation?: boolean): void;
+/** Idempotent migrations wrap `ALTER TABLE ... ADD CONSTRAINT` in `DO $$ ... $$` catalog checks. */
+export declare function collectDoStmtConstraints(content: string, statement: DoStmt, stmtLocation: number, result: SqlMigrationConstraintMetadata): void;

package/dist/sql-ast/constraint-do-block.mjs

@@ -0,0 +1,83 @@
+import { fkAttrNames, foreignKeyFromConstraint, } from './constraint-shared.mjs';
+import { parseSql } from './parser.mjs';
+/**
+ * Applies AT_AddConstraint / AT_ValidateConstraint commands from one ALTER TABLE to `result`.
+ *
+ * `trackConstraintValidation` gates NOT VALID/VALIDATE pairing bookkeeping. Callers that
+ * parse ALTER TABLE text out of a DO body should pass false so only `foreignKeys` is filled.
+ */
+export function processAlterTableStmt(statement, baseOffset, result, trackConstraintValidation = true) {
+    const tableName = statement.relation?.relname;
+    /* v8 ignore next */
+    if (!tableName)
+        return;
+    for (const rawCommand of statement.cmds ?? []) {
+        /* v8 ignore next */
+        if (!rawCommand || !('AlterTableCmd' in rawCommand))
+            continue;
+        const command = rawCommand.AlterTableCmd;
+        if (command.subtype === 'AT_ValidateConstraint' && command.name) {
+            if (trackConstraintValidation)
+                result.validatedConstraints.add(`${tableName}.${command.name}`);
+            continue;
+        }
+        /* v8 ignore next */
+        if (command.subtype !== 'AT_AddConstraint')
+            continue;
+        const definition = command.def;
+        /* v8 ignore next */
+        if (!definition || !('Constraint' in definition))
+            continue;
+        const constraint = definition.Constraint;
+        /* v8 ignore next */
+        if (!constraint)
+            continue;
+        if (constraint.contype === 'CONSTR_FOREIGN') {
+            const constraintRecord = constraint;
+            result.foreignKeys.push(foreignKeyFromConstraint(constraintRecord, tableName, fkAttrNames(constraintRecord), baseOffset));
+        }
+        if (!trackConstraintValidation)
+            continue;
+        /* v8 ignore next */
+        if (constraint.contype !== 'CONSTR_CHECK' && constraint.contype !== 'CONSTR_FOREIGN')
+            continue;
+        result.addedConstraints.push({
+            /* v8 ignore next 3 */
+            constraintType: constraint.contype ?? null,
+            location: baseOffset + (constraint.location ?? 0),
+            name: constraint.conname ?? null,
+            tableName,
+        });
+    }
+}
+const ALTER_TABLE_STATEMENT_RE = /ALTER\s+TABLE\b[^;]*;/gi;
+/** Idempotent migrations wrap `ALTER TABLE ... ADD CONSTRAINT` in `DO $$ ... $$` catalog checks. */
+/* v8 ignore start -- DO-body regex/parse fallbacks */
+export function collectDoStmtConstraints(content, statement, stmtLocation, result) {
+    for (const arg of statement.args ?? []) {
+        const defElem = arg && 'DefElem' in arg ? arg.DefElem : undefined;
+        const stringArg = defElem?.arg && 'String' in defElem.arg ? defElem.arg.String : undefined;
+        const body = typeof stringArg?.sval === 'string' ? stringArg.sval : '';
+        for (const match of body.matchAll(ALTER_TABLE_STATEMENT_RE)) {
+            const baseOffset = content.indexOf(match[0], stmtLocation);
+            /* v8 ignore next */
+            if (baseOffset === -1)
+                continue;
+            let nested;
+            try {
+                nested = parseSql(match[0]);
+            }
+            catch {
+                /* v8 ignore next */
+                continue;
+            }
+            for (const nestedStmt of nested.stmts ?? []) {
+                const node = nestedStmt.stmt;
+                if (node && 'AlterTableStmt' in node) {
+                    processAlterTableStmt(node.AlterTableStmt, baseOffset, result, false);
+                }
+            }
+        }
+    }
+}
+/* v8 ignore stop */

package/dist/sql-ast/constraint-shared.d.mts

@@ -0,0 +1,19 @@
+export type SqlMigrationConstraintMetadata = {
+    addedConstraints: Array<{
+        constraintType: string | null;
+        location: number;
+        name: string | null;
+        tableName: string;
+    }>;
+    foreignKeys: Array<{
+        columnNames: string[];
+        deleteAction: string | null;
+        location: number;
+        referencedTableName: string | null;
+        tableName: string | null;
+    }>;
+    validatedConstraints: Set<string>;
+};
+export type ForeignKey = SqlMigrationConstraintMetadata['foreignKeys'][number];
+export declare function fkAttrNames(constraint: Record<string, unknown>): string[];
+export declare function foreignKeyFromConstraint(constraint: Record<string, unknown>, tableName: string | null, columnNames: string[], baseOffset?: number): ForeignKey;

package/dist/sql-ast/constraint-shared.mjs

@@ -0,0 +1,20 @@
+import { isRecord } from './unknown-record.mjs';
+export function fkAttrNames(constraint) {
+    const attrs = constraint.fk_attrs;
+    if (!Array.isArray(attrs))
+        return [];
+    return attrs.flatMap((attr) => {
+        const sval = isRecord(attr) && isRecord(attr.String) ? attr.String.sval : undefined;
+        return typeof sval === 'string' ? [sval] : [];
+    });
+}
+export function foreignKeyFromConstraint(constraint, tableName, columnNames, baseOffset = 0) {
+    const pktable = constraint.pktable;
+    return {
+        columnNames,
+        deleteAction: typeof constraint.fk_del_action === 'string' ? constraint.fk_del_action : null,
+        location: baseOffset + (typeof constraint.location === 'number' ? constraint.location : 0),
+        referencedTableName: isRecord(pktable) && typeof pktable.relname === 'string' ? pktable.relname : null,
+        tableName,
+    };
+}

package/dist/sql-ast/constraint.d.mts

@@ -0,0 +1,2 @@
+import { type SqlMigrationConstraintMetadata } from './constraint-shared.mts';
+export declare function extractMigrationConstraintMetadata(content: string): SqlMigrationConstraintMetadata;

package/dist/sql-ast/constraint.mjs

@@ -0,0 +1,63 @@
+import { collectDoStmtConstraints, processAlterTableStmt } from './constraint-do-block.mjs';
+import { fkAttrNames, foreignKeyFromConstraint, } from './constraint-shared.mjs';
+import { parseSql } from './parser.mjs';
+import { isRecord } from './unknown-record.mjs';
+/** Inline `col UUID REFERENCES ...` and table-level `FOREIGN KEY (...) REFERENCES ...` forms. */
+/* v8 ignore start -- defensive parse-tree walks */
+function collectCreateStmtForeignKeys(statement, foreignKeys) {
+    const relation = statement.relation;
+    const tableName = isRecord(relation) && typeof relation.relname === 'string' ? relation.relname : null;
+    const tableElts = statement.tableElts;
+    if (!Array.isArray(tableElts))
+        return;
+    for (const element of tableElts) {
+        if (!isRecord(element))
+            continue;
+        if (isRecord(element.ColumnDef)) {
+            const column = element.ColumnDef;
+            const colname = typeof column.colname === 'string' ? column.colname : null;
+            for (const constraintNode of column.constraints ?? []) {
+                /* v8 ignore next 3 */
+                if (!isRecord(constraintNode) || !isRecord(constraintNode.Constraint))
+                    continue;
+                const constraint = constraintNode.Constraint;
+                if (constraint.contype !== 'CONSTR_FOREIGN')
+                    continue;
+                foreignKeys.push(foreignKeyFromConstraint(constraint, tableName, colname ? [colname] : []));
+            }
+            continue;
+        }
+        if (isRecord(element.Constraint) && element.Constraint.contype === 'CONSTR_FOREIGN') {
+            foreignKeys.push(foreignKeyFromConstraint(element.Constraint, tableName, fkAttrNames(element.Constraint)));
+        }
+    }
+}
+/* v8 ignore stop */
+export function extractMigrationConstraintMetadata(content) {
+    const result = {
+        addedConstraints: [],
+        foreignKeys: [],
+        validatedConstraints: new Set(),
+    };
+    const parseResult = parseSql(content);
+    for (const rawStmt of parseResult.stmts ?? []) {
+        const node = rawStmt.stmt;
+        /* v8 ignore next */
+        if (!node)
+            continue;
+        const stmtLocation = rawStmt.stmt_location ?? 0;
+        if ('CreateStmt' in node) {
+            collectCreateStmtForeignKeys(node.CreateStmt, result.foreignKeys);
+            continue;
+        }
+        if ('DoStmt' in node) {
+            collectDoStmtConstraints(content, node.DoStmt, stmtLocation, result);
+            continue;
+        }
+        /* v8 ignore next */
+        if (!('AlterTableStmt' in node))
+            continue;
+        processAlterTableStmt(node.AlterTableStmt, 0, result);
+    }
+    return result;
+}

package/dist/sql-ast/create-table.d.mts

@@ -0,0 +1,25 @@
+export type SqlCreateTableColumnConstraint = {
+    contype: string | null;
+};
+export type SqlCreateTableColumn = {
+    name: string;
+    location: number | null;
+    constraints: SqlCreateTableColumnConstraint[];
+    isPrimaryKey: boolean;
+    defaultFunction: string | null;
+    /** Function name of a CONSTR_GENERATED expression (e.g. `uuid_extract_timestamp`), null if not generated or unrecognized. */
+    generatedFunction: string | null;
+    /** Lowercased argument column names of a CONSTR_GENERATED expression's function call (e.g. `['id']`). */
+    generatedFunctionArgColumns: string[];
+};
+export type SqlCreateTableMetadata = {
+    tableName: string;
+    columns: SqlCreateTableColumn[];
+};
+/**
+ * A column is a primary key via either the inline `col TYPE PRIMARY KEY` constraint
+ * (nested inside its ColumnDef) or the table-level `PRIMARY KEY (col)` constraint
+ * (a bare `Constraint` sibling in tableElts, referencing the column by name in `keys`).
+ * Both forms are checked so table-level-PK migrations aren't silently mis-detected.
+ */
+export declare function extractCreateTableMetadata(content: string): SqlCreateTableMetadata[];

package/dist/sql-ast/create-table.mjs

@@ -0,0 +1,79 @@
+import { extractDefaultFunction, extractFuncCallArgColumnNames } from './default-function.mjs';
+import { parseSql } from './parser.mjs';
+/**
+ * A column is a primary key via either the inline `col TYPE PRIMARY KEY` constraint
+ * (nested inside its ColumnDef) or the table-level `PRIMARY KEY (col)` constraint
+ * (a bare `Constraint` sibling in tableElts, referencing the column by name in `keys`).
+ * Both forms are checked so table-level-PK migrations aren't silently mis-detected.
+ */
+export function extractCreateTableMetadata(content) {
+    const tables = [];
+    const parseResult = parseSql(content);
+    for (const rawStmt of parseResult.stmts ?? []) {
+        const node = rawStmt.stmt;
+        if (!node || !('CreateStmt' in node))
+            continue;
+        const createStmt = node.CreateStmt;
+        const tableName = createStmt.relation?.relname;
+        if (!tableName)
+            continue;
+        const tableLevelPrimaryKeyColumns = new Set((createStmt.tableElts ?? []).flatMap((elt) => {
+            /* v8 ignore next 8 */
+            if (!elt || typeof elt !== 'object' || !('Constraint' in elt))
+                return [];
+            const constraint = elt.Constraint;
+            if (constraint.contype !== 'CONSTR_PRIMARY')
+                return [];
+            return (constraint.keys ?? []).flatMap((key) => key && typeof key === 'object' && 'String' in key && typeof key.String.sval === 'string'
+                ? [key.String.sval]
+                : []);
+        }));
+        tables.push({
+            tableName,
+            columns: (createStmt.tableElts ?? []).flatMap((elt) => {
+                if (!elt || typeof elt !== 'object' || !('ColumnDef' in elt))
+                    return [];
+                const column = elt.ColumnDef;
+                if (!column || typeof column !== 'object' || !column.colname)
+                    return [];
+                const rawConstraints = (column.constraints ?? []).flatMap((constraint) => {
+                    /* v8 ignore next 4 */
+                    if (!constraint || typeof constraint !== 'object' || !('Constraint' in constraint)) {
+                        return [];
+                    }
+                    return constraint.Constraint ? [constraint.Constraint] : [];
+                });
+                let defaultConstraint;
+                let generatedConstraint;
+                for (const constraint of rawConstraints) {
+                    if (constraint.contype === 'CONSTR_DEFAULT')
+                        defaultConstraint ??= constraint;
+                    if (constraint.contype === 'CONSTR_GENERATED')
+                        generatedConstraint ??= constraint;
+                }
+                return [
+                    {
+                        name: column.colname,
+                        location: column.location ?? null,
+                        constraints: rawConstraints.map((constraint) => ({
+                            /* v8 ignore next */
+                            contype: constraint.contype ?? null,
+                        })),
+                        isPrimaryKey: rawConstraints.some((constraint) => constraint.contype === 'CONSTR_PRIMARY') ||
+                            tableLevelPrimaryKeyColumns.has(column.colname),
+                        defaultFunction: defaultConstraint
+                            ? extractDefaultFunction(defaultConstraint.raw_expr)
+                            : null,
+                        generatedFunction: generatedConstraint
+                            ? extractDefaultFunction(generatedConstraint.raw_expr)
+                            : null,
+                        generatedFunctionArgColumns: generatedConstraint
+                            ? extractFuncCallArgColumnNames(generatedConstraint.raw_expr)
+                            : [],
+                    },
+                ];
+            }),
+        });
+    }
+    return tables;
+}

package/dist/sql-ast/default-function.d.mts

@@ -0,0 +1,18 @@
+import type { Node } from '@libpg-query/parser';
+/**
+ * Resolves a CONSTR_DEFAULT constraint's raw_expr to a lowercase function/op name.
+ * Handles the shapes @libpg-query/parser produces for column defaults:
+ * - `FuncCall` (e.g. `uuidv7()`, `now()`): last segment of `funcname`, lowercased.
+ * - `SQLValueFunction` (e.g. bare `CURRENT_TIMESTAMP`): mapped from its `op` enum.
+ * - `TypeCast` (e.g. `now()::timestamptz`): recurses into the cast's inner arg.
+ * Returns null for any other/unrecognized raw_expr shape.
+ */
+export declare function extractDefaultFunction(rawExpr: Node | undefined): string | null;
+/**
+ * Resolves a FuncCall raw_expr's argument column names, lowercased (e.g. the `id` in
+ * `uuid_extract_timestamp(id)`). Used to verify a GENERATED column expression references
+ * a specific source column, not just that it calls the expected function.
+ * Returns an empty array for non-FuncCall shapes, a TypeCast-wrapped call recurses into
+ * its inner arg; non-column-ref args are skipped.
+ */
+export declare function extractFuncCallArgColumnNames(rawExpr: Node | undefined): string[];

package/dist/sql-ast/default-function.mjs

@@ -0,0 +1,53 @@
+/**
+ * Resolves a CONSTR_DEFAULT constraint's raw_expr to a lowercase function/op name.
+ * Handles the shapes @libpg-query/parser produces for column defaults:
+ * - `FuncCall` (e.g. `uuidv7()`, `now()`): last segment of `funcname`, lowercased.
+ * - `SQLValueFunction` (e.g. bare `CURRENT_TIMESTAMP`): mapped from its `op` enum.
+ * - `TypeCast` (e.g. `now()::timestamptz`): recurses into the cast's inner arg.
+ * Returns null for any other/unrecognized raw_expr shape.
+ */
+export function extractDefaultFunction(rawExpr) {
+    if (!rawExpr)
+        return null;
+    if ('TypeCast' in rawExpr) {
+        return extractDefaultFunction(rawExpr.TypeCast.arg);
+    }
+    if ('FuncCall' in rawExpr) {
+        const funcname = rawExpr.FuncCall.funcname ?? [];
+        const last = funcname.at(-1);
+        if (last && 'String' in last && typeof last.String.sval === 'string') {
+            return last.String.sval.toLowerCase();
+        }
+        return null;
+    }
+    if ('SQLValueFunction' in rawExpr) {
+        return rawExpr.SQLValueFunction.op === 'SVFOP_CURRENT_TIMESTAMP' ? 'current_timestamp' : null;
+    }
+    return null;
+}
+/**
+ * Resolves a FuncCall raw_expr's argument column names, lowercased (e.g. the `id` in
+ * `uuid_extract_timestamp(id)`). Used to verify a GENERATED column expression references
+ * a specific source column, not just that it calls the expected function.
+ * Returns an empty array for non-FuncCall shapes, a TypeCast-wrapped call recurses into
+ * its inner arg; non-column-ref args are skipped.
+ */
+export function extractFuncCallArgColumnNames(rawExpr) {
+    if (!rawExpr)
+        return [];
+    if ('TypeCast' in rawExpr) {
+        return extractFuncCallArgColumnNames(rawExpr.TypeCast.arg);
+    }
+    if (!('FuncCall' in rawExpr))
+        return [];
+    return (rawExpr.FuncCall.args ?? []).flatMap((arg) => {
+        if (!arg || typeof arg !== 'object' || !('ColumnRef' in arg))
+            return [];
+        const fields = arg.ColumnRef.fields ?? [];
+        const last = fields.at(-1);
+        /* v8 ignore next 4 */
+        return last && 'String' in last && typeof last.String.sval === 'string'
+            ? [last.String.sval.toLowerCase()]
+            : [];
+    });
+}

package/dist/sql-ast/drop-index.d.mts

@@ -0,0 +1,5 @@
+export type SqlDropIndexMetadata = {
+    idxname: string;
+    location: number;
+};
+export declare function extractDropIndexMetadata(content: string): SqlDropIndexMetadata[];

package/dist/sql-ast/drop-index.mjs

@@ -0,0 +1,31 @@
+import { parseSql } from './parser.mjs';
+import { isRecord } from './unknown-record.mjs';
+export function extractDropIndexMetadata(content) {
+    const indexes = [];
+    const parseResult = parseSql(content);
+    for (const rawStmt of parseResult.stmts ?? []) {
+        const node = rawStmt.stmt;
+        /* v8 ignore next 2 */
+        if (!node || !('DropStmt' in node) || node.DropStmt.removeType !== 'OBJECT_INDEX')
+            continue;
+        for (const object of node.DropStmt.objects ?? []) {
+            const objectValue = object;
+            const items = isRecord(objectValue) && isRecord(objectValue['List'])
+                ? objectValue['List']['items']
+                : undefined;
+            if (!Array.isArray(items))
+                continue;
+            const names = items.flatMap((item) => {
+                const itemValue = item;
+                const value = isRecord(itemValue) && isRecord(itemValue['String'])
+                    ? itemValue['String']['sval']
+                    : undefined;
+                return typeof value === 'string' ? [value] : [];
+            });
+            const idxname = names.at(-1);
+            if (idxname)
+                indexes.push({ idxname, location: rawStmt.stmt_location ?? 0 });
+        }
+    }
+    return indexes;
+}

package/dist/sql-ast/implicit-indexes.d.mts

@@ -0,0 +1,3 @@
+import type { SqlCreateIndexMetadata } from './index-metadata.mts';
+/** UNIQUE/PRIMARY KEY create implicit unique indexes that never appear as CREATE INDEX. */
+export declare function collectCreateStmtImplicitIndexes(statement: Record<string, unknown>, location: number, indexes: SqlCreateIndexMetadata[]): void;

package/dist/sql-ast/implicit-indexes.mjs

@@ -0,0 +1,66 @@
+import { isRecord } from './unknown-record.mjs';
+function implicitIndexParam(name) {
+    return { name, opclass: null, ordering: null, nullsOrdering: null };
+}
+function pushImplicitIndex(indexes, relname, location, columnNames) {
+    indexes.push({
+        relname,
+        idxname: null,
+        unique: true,
+        indexParams: columnNames,
+        indexParamDetails: columnNames.map(implicitIndexParam),
+        includeParams: [],
+        whereClause: null,
+        whereClauseKey: null,
+        accessMethod: 'btree',
+        location,
+    });
+}
+function constraintKeyNames(constraint) {
+    const keys = constraint.keys;
+    if (!Array.isArray(keys))
+        return [];
+    return keys.flatMap((key) => {
+        const sval = isRecord(key) && isRecord(key.String) ? key.String.sval : undefined;
+        /* v8 ignore next */
+        return typeof sval === 'string' ? [sval] : [];
+    });
+}
+/** UNIQUE/PRIMARY KEY create implicit unique indexes that never appear as CREATE INDEX. */
+export function collectCreateStmtImplicitIndexes(statement, location, indexes) {
+    const relation = statement.relation;
+    const relname = isRecord(relation) && typeof relation.relname === 'string' ? relation.relname : null;
+    const tableElts = statement.tableElts;
+    if (!relname || !Array.isArray(tableElts))
+        return;
+    for (const element of tableElts) {
+        if (!isRecord(element))
+            continue;
+        if (isRecord(element.ColumnDef)) {
+            const column = element.ColumnDef;
+            const colname = typeof column.colname === 'string' ? column.colname : null;
+            if (!colname)
+                continue;
+            for (const constraintNode of column.constraints ?? []) {
+                /* v8 ignore next */
+                if (!isRecord(constraintNode) || !isRecord(constraintNode.Constraint))
+                    continue;
+                const contype = constraintNode.Constraint.contype;
+                if (contype !== 'CONSTR_UNIQUE' && contype !== 'CONSTR_PRIMARY')
+                    continue;
+                pushImplicitIndex(indexes, relname, location, [colname]);
+            }
+            continue;
+        }
+        /* v8 ignore next */
+        if (!isRecord(element.Constraint))
+            continue;
+        const contype = element.Constraint.contype;
+        if (contype !== 'CONSTR_UNIQUE' && contype !== 'CONSTR_PRIMARY')
+            continue;
+        const columnNames = constraintKeyNames(element.Constraint);
+        if (columnNames.length === 0)
+            continue;
+        pushImplicitIndex(indexes, relname, location, columnNames);
+    }
+}

package/dist/sql-ast/index-metadata.d.mts

@@ -0,0 +1,19 @@
+export type SqlIndexParam = {
+    name: string | null;
+    opclass: string | null;
+    ordering: string | null;
+    nullsOrdering: string | null;
+};
+export type SqlCreateIndexMetadata = {
+    relname: string;
+    idxname: string | null;
+    unique: boolean;
+    indexParams: Array<string | null>;
+    indexParamDetails: SqlIndexParam[];
+    includeParams: string[];
+    whereClause: unknown;
+    whereClauseKey: string | null;
+    accessMethod: string;
+    location: number;
+};
+export declare function extractCreateIndexMetadata(content: string): SqlCreateIndexMetadata[];

package/dist/sql-ast/index-metadata.mjs

@@ -0,0 +1,100 @@
+import { collectCreateStmtImplicitIndexes } from './implicit-indexes.mjs';
+import { parseSql } from './parser.mjs';
+import { isRecord } from './unknown-record.mjs';
+function indexElemName(param) {
+    if (!isRecord(param) || !isRecord(param.IndexElem))
+        return null;
+    const name = param.IndexElem.name;
+    return typeof name === 'string' ? name : null;
+}
+function indexElemOpclass(param) {
+    if (!isRecord(param) || !isRecord(param.IndexElem))
+        return null;
+    const opclass = param.IndexElem.opclass;
+    if (!Array.isArray(opclass))
+        return null;
+    const names = opclass.flatMap((node) => {
+        const sval = isRecord(node) && isRecord(node.String) ? node.String.sval : undefined;
+        /* v8 ignore next */
+        return typeof sval === 'string' ? [sval] : [];
+    });
+    return names.length > 0 ? names.join('.') : null;
+}
+/** Sort direction and NULLS placement together — PostgreSQL resolves both from the same `IndexElem`. */
+function indexElemSortSpec(param) {
+    if (!isRecord(param) || !isRecord(param.IndexElem))
+        return { ordering: null, nullsOrdering: null };
+    const { ordering, nulls_ordering: nullsOrdering } = param.IndexElem;
+    return {
+        ordering: typeof ordering === 'string' ? ordering : null,
+        nullsOrdering: typeof nullsOrdering === 'string' ? nullsOrdering : null,
+    };
+}
+function indexParamDetail(param) {
+    return {
+        name: indexElemName(param),
+        opclass: indexElemOpclass(param),
+        ...indexElemSortSpec(param),
+    };
+}
+/**
+ * Deep-clones a parser AST node with `location` fields stripped, so two
+ * predicates that are byte-identical apart from source position compare
+ * equal via JSON.stringify.
+ */
+function stripLocations(value) {
+    if (Array.isArray(value))
+        return value.map(stripLocations);
+    if (!isRecord(value))
+        return value;
+    const result = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'location')
+            continue;
+        result[key] = stripLocations(child);
+    }
+    return result;
+}
+function whereClauseKey(whereClause) {
+    if (whereClause === undefined || whereClause === null)
+        return null;
+    return JSON.stringify(stripLocations(whereClause));
+}
+export function extractCreateIndexMetadata(content) {
+    const indexes = [];
+    const parseResult = parseSql(content);
+    for (const rawStmt of parseResult.stmts ?? []) {
+        const node = rawStmt.stmt;
+        /* v8 ignore next */
+        if (!node)
+            continue;
+        if ('CreateStmt' in node) {
+            collectCreateStmtImplicitIndexes(node.CreateStmt, rawStmt.stmt_location ?? 0, indexes);
+            continue;
+        }
+        /* v8 ignore next */
+        if (!('IndexStmt' in node))
+            continue;
+        const indexStmt = node.IndexStmt;
+        const relname = indexStmt.relation?.relname;
+        /* v8 ignore next */
+        if (!relname)
+            continue;
+        const indexParams = indexStmt.indexParams ?? [];
+        indexes.push({
+            relname,
+            idxname: indexStmt.idxname ?? null,
+            unique: indexStmt.unique === true,
+            indexParams: indexParams.map(indexElemName),
+            indexParamDetails: indexParams.map(indexParamDetail),
+            includeParams: (indexStmt.indexIncludingParams ?? [])
+                .map(indexElemName)
+                .filter((name) => name !== null),
+            whereClause: indexStmt.whereClause ?? null,
+            whereClauseKey: whereClauseKey(indexStmt.whereClause),
+            accessMethod: indexStmt.accessMethod ?? 'btree',
+            location: rawStmt.stmt_location ?? 0,
+        });
+    }
+    return indexes;
+}

package/dist/sql-ast/index.d.mts

@@ -1,12 +1,12 @@
-type LibPgQuery = typeof import('@libpg-query/parser');
-export declare class MissingSqlAstParserError extends Error {
-    constructor();
-}
-export declare function extractAlterTableAddColumnLocations(content: string): number[];
-/**
- * Ensures the @libpg-query/parser WASM module is loaded.
- * Must be awaited once before any synchronous parseSync() calls.
- */
-export declare function initSqlAst(importer?: () => Promise<LibPgQuery>): Promise<void>;
-export declare function lineOfUtf8ByteOffset(content: string | Buffer, byteOffset: number): number;
-export {};
+export { extractAlterTableAddColumnLocations } from './add-column.mts';
+export { extractMigrationConstraintMetadata } from './constraint.mts';
+export type { ForeignKey, SqlMigrationConstraintMetadata } from './constraint-shared.mts';
+export { extractCreateTableMetadata } from './create-table.mts';
+export type { SqlCreateTableColumn, SqlCreateTableColumnConstraint, SqlCreateTableMetadata, } from './create-table.mts';
+export { extractDefaultFunction, extractFuncCallArgColumnNames } from './default-function.mts';
+export { extractDropIndexMetadata } from './drop-index.mts';
+export type { SqlDropIndexMetadata } from './drop-index.mts';
+export { extractCreateIndexMetadata } from './index-metadata.mts';
+export type { SqlCreateIndexMetadata, SqlIndexParam } from './index-metadata.mts';
+export { lineOfUtf8ByteOffset } from './line-of-offset.mts';
+export { initSqlAst, MissingSqlAstParserError, parseSql } from './parser.mts';

package/dist/sql-ast/index.mjs

@@ -1,79 +1,8 @@
-let parser;
-let moduleLoad;
-export class MissingSqlAstParserError extends Error {
-    constructor() {
-        super('vouchington-tooling/sql-ast requires the optional dependency @libpg-query/parser. Install it in the consuming package.');
-        this.name = 'MissingSqlAstParserError';
-    }
-}
-export function extractAlterTableAddColumnLocations(content) {
-    const locations = [];
-    const parseResult = requireParser().parseSync(content);
-    for (const rawStmt of parseResult.stmts ?? []) {
-        const node = rawStmt.stmt;
-        if (!node || !('AlterTableStmt' in node))
-            continue;
-        for (const rawCommand of node.AlterTableStmt.cmds ?? []) {
-            if (!rawCommand || !('AlterTableCmd' in rawCommand))
-                continue;
-            const command = rawCommand.AlterTableCmd;
-            if (command.subtype !== 'AT_AddColumn')
-                continue;
-            const definition = command.def;
-            if (!definition || !('ColumnDef' in definition))
-                continue;
-            locations.push(rawStmt.stmt_location ?? 0);
-        }
-    }
-    return locations;
-}
-/**
- * Ensures the @libpg-query/parser WASM module is loaded.
- * Must be awaited once before any synchronous parseSync() calls.
- */
-export function initSqlAst(importer = () => import('@libpg-query/parser')) {
-    return (moduleLoad ??= loadParser(importer)
-        .then(async (loaded) => {
-        await loaded.loadModule();
-        parser = loaded;
-    })
-        .catch((error) => {
-        moduleLoad = undefined;
-        parser = undefined;
-        throw error;
-    }));
-}
-export function lineOfUtf8ByteOffset(content, byteOffset) {
-    const buffer = typeof content === 'string' ? Buffer.from(content, 'utf8') : content;
-    if (byteOffset > buffer.length) {
-        throw new RangeError(`byteOffset ${byteOffset} is out of range for buffer length ${buffer.length}`);
-    }
-    let line = 1;
-    for (let i = 0; i < byteOffset; i++) {
-        if (buffer[i] === 10)
-            line++;
-    }
-    return line;
-}
-function requireParser() {
-    if (!parser) {
-        throw new Error('initSqlAst() must be awaited before calling parse helpers');
-    }
-    return parser;
-}
-async function loadParser(importer) {
-    try {
-        return await importer();
-    }
-    catch (error) {
-        if (isModuleNotFound(error))
-            throw new MissingSqlAstParserError();
-        throw error;
-    }
-}
-function isModuleNotFound(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === 'ERR_MODULE_NOT_FOUND');
-}
+export { extractAlterTableAddColumnLocations } from './add-column.mjs';
+export { extractMigrationConstraintMetadata } from './constraint.mjs';
+export { extractCreateTableMetadata } from './create-table.mjs';
+export { extractDefaultFunction, extractFuncCallArgColumnNames } from './default-function.mjs';
+export { extractDropIndexMetadata } from './drop-index.mjs';
+export { extractCreateIndexMetadata } from './index-metadata.mjs';
+export { lineOfUtf8ByteOffset } from './line-of-offset.mjs';
+export { initSqlAst, MissingSqlAstParserError, parseSql } from './parser.mjs';

package/dist/sql-ast/line-of-offset.d.mts

@@ -0,0 +1 @@
+export declare function lineOfUtf8ByteOffset(content: string | Buffer, byteOffset: number): number;

package/dist/sql-ast/line-of-offset.mjs

@@ -0,0 +1,12 @@
+export function lineOfUtf8ByteOffset(content, byteOffset) {
+    const buffer = typeof content === 'string' ? Buffer.from(content, 'utf8') : content;
+    if (byteOffset > buffer.length) {
+        throw new RangeError(`byteOffset ${byteOffset} is out of range for buffer length ${buffer.length}`);
+    }
+    let line = 1;
+    for (let i = 0; i < byteOffset; i++) {
+        if (buffer[i] === 10)
+            line++;
+    }
+    return line;
+}

package/dist/sql-ast/parser.d.mts

@@ -0,0 +1,11 @@
+type LibPgQuery = typeof import('@libpg-query/parser');
+export declare class MissingSqlAstParserError extends Error {
+    constructor();
+}
+/**
+ * Ensures the @libpg-query/parser WASM module is loaded.
+ * Must be awaited once before any synchronous parseSql() calls.
+ */
+export declare function initSqlAst(importer?: () => Promise<LibPgQuery>): Promise<void>;
+export declare function parseSql(content: string): ReturnType<LibPgQuery['parseSync']>;
+export {};

package/dist/sql-ast/parser.mjs

@@ -0,0 +1,46 @@
+let parser;
+let moduleLoad;
+export class MissingSqlAstParserError extends Error {
+    constructor() {
+        super('vouchington-tooling/sql-ast requires the optional dependency @libpg-query/parser. Install it in the consuming package.');
+        this.name = 'MissingSqlAstParserError';
+    }
+}
+/**
+ * Ensures the @libpg-query/parser WASM module is loaded.
+ * Must be awaited once before any synchronous parseSql() calls.
+ */
+export function initSqlAst(importer = () => import('@libpg-query/parser')) {
+    return (moduleLoad ??= loadParser(importer)
+        .then(async (loaded) => {
+        await loaded.loadModule();
+        parser = loaded;
+    })
+        .catch((error) => {
+        moduleLoad = undefined;
+        parser = undefined;
+        throw error;
+    }));
+}
+export function parseSql(content) {
+    if (!parser) {
+        throw new Error('initSqlAst() must be awaited before calling parse helpers');
+    }
+    return parser.parseSync(content);
+}
+async function loadParser(importer) {
+    try {
+        return await importer();
+    }
+    catch (error) {
+        if (isModuleNotFound(error))
+            throw new MissingSqlAstParserError();
+        throw error;
+    }
+}
+function isModuleNotFound(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ERR_MODULE_NOT_FOUND');
+}

package/dist/sql-ast/unknown-record.d.mts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/sql-ast/unknown-record.mjs

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/sql-scanner/index.d.mts

@@ -0,0 +1,7 @@
+export { dollarQuoteEnd, maskSqlQuotedText, readDollarQuoteDelimiter, readStringLiteral, sqlFragments, } from './literals.mts';
+export declare function lineOf(content: string, index: number): number;
+export declare function stripSqlComments(content: string): string;
+export declare function splitSqlStatements(content: string): {
+    text: string;
+    index: number;
+}[];

package/dist/sql-scanner/index.mjs

@@ -0,0 +1,172 @@
+import { readDollarQuoteDelimiter, stringLiteralQuoteStart } from './literals.mjs';
+export { dollarQuoteEnd, maskSqlQuotedText, readDollarQuoteDelimiter, readStringLiteral, sqlFragments, } from './literals.mjs';
+function maskNonNewlines(value) {
+    return value.replace(/[^\n]/g, ' ');
+}
+export function lineOf(content, index) {
+    return content.slice(0, index).split('\n').length;
+}
+function lineCommentEnd(content, start) {
+    let end = start;
+    while (end < content.length && content[end] !== '\n')
+        end++;
+    return end;
+}
+function blockCommentEnd(content, start) {
+    let depth = 1;
+    let end = start + 2;
+    while (end < content.length) {
+        if (content[end] === '/' && content[end + 1] === '*') {
+            depth++;
+            end += 2;
+        }
+        else if (content[end] === '*' && content[end + 1] === '/') {
+            depth--;
+            if (depth === 0)
+                return end + 2;
+            end += 2;
+        }
+        else {
+            end++;
+        }
+    }
+    return content.length;
+}
+export function stripSqlComments(content) {
+    let stripped = '';
+    let inSingleQuote = false;
+    let inEscapeString = false;
+    let dollarQuoteDelimiter = null;
+    for (let i = 0; i < content.length; i++) {
+        if (dollarQuoteDelimiter) {
+            if (content.startsWith(dollarQuoteDelimiter, i)) {
+                stripped += dollarQuoteDelimiter;
+                i += dollarQuoteDelimiter.length - 1;
+                dollarQuoteDelimiter = null;
+            }
+            else {
+                stripped += content[i];
+            }
+            continue;
+        }
+        if (inSingleQuote) {
+            stripped += content[i];
+            if (inEscapeString && content[i] === '\\' && i + 1 < content.length) {
+                stripped += content[i + 1];
+                i++;
+                continue;
+            }
+            if (content[i] === "'") {
+                if (content[i + 1] === "'") {
+                    stripped += content[i + 1];
+                    i++;
+                }
+                else {
+                    inSingleQuote = false;
+                    inEscapeString = false;
+                }
+            }
+            continue;
+        }
+        const dollarQuote = readDollarQuoteDelimiter(content, i);
+        if (dollarQuote) {
+            dollarQuoteDelimiter = dollarQuote;
+            stripped += dollarQuote;
+            i += dollarQuote.length - 1;
+            continue;
+        }
+        const stringStart = stringLiteralQuoteStart(content, i);
+        if (stringStart) {
+            inSingleQuote = true;
+            inEscapeString = stringStart.escapeString;
+            stripped += content.slice(i, stringStart.quoteStart + 1);
+            i = stringStart.quoteStart;
+            continue;
+        }
+        if (content[i] === '-' && content[i + 1] === '-') {
+            const end = lineCommentEnd(content, i);
+            if (end === content.length) {
+                stripped += ' '.repeat(content.length - i);
+                break;
+            }
+            stripped += `${' '.repeat(end - i)}\n`;
+            i = end;
+            continue;
+        }
+        if (content[i] === '/' && content[i + 1] === '*') {
+            const end = blockCommentEnd(content, i);
+            stripped += maskNonNewlines(content.slice(i, end));
+            i = end - 1;
+            continue;
+        }
+        stripped += content[i];
+    }
+    return stripped;
+}
+export function splitSqlStatements(content) {
+    const statements = [];
+    let currentStmt = '';
+    let stmtStart = 0;
+    let inSingleQuote = false;
+    let inEscapeString = false;
+    let dollarQuoteDelimiter = null;
+    for (let i = 0; i < content.length; i++) {
+        const ch = content[i];
+        if (dollarQuoteDelimiter) {
+            if (content.startsWith(dollarQuoteDelimiter, i)) {
+                currentStmt += dollarQuoteDelimiter;
+                i += dollarQuoteDelimiter.length - 1;
+                dollarQuoteDelimiter = null;
+            }
+            else {
+                currentStmt += ch;
+            }
+            continue;
+        }
+        if (inSingleQuote) {
+            currentStmt += ch;
+            if (inEscapeString && ch === '\\' && i + 1 < content.length) {
+                currentStmt += content[i + 1];
+                i++;
+                continue;
+            }
+            if (ch === "'") {
+                if (content[i + 1] === "'") {
+                    currentStmt += content[i + 1];
+                    i++;
+                }
+                else {
+                    inSingleQuote = false;
+                    inEscapeString = false;
+                }
+            }
+            continue;
+        }
+        const dollarQuote = readDollarQuoteDelimiter(content, i);
+        if (dollarQuote) {
+            dollarQuoteDelimiter = dollarQuote;
+            currentStmt += dollarQuote;
+            i += dollarQuote.length - 1;
+            continue;
+        }
+        const stringStart = stringLiteralQuoteStart(content, i);
+        if (stringStart) {
+            inSingleQuote = true;
+            inEscapeString = stringStart.escapeString;
+            currentStmt += content.slice(i, stringStart.quoteStart + 1);
+            i = stringStart.quoteStart;
+        }
+        else if (ch === ';') {
+            statements.push({ text: currentStmt, index: stmtStart });
+            currentStmt = '';
+            stmtStart = i + 1;
+        }
+        else {
+            currentStmt += ch;
+        }
+    }
+    if (currentStmt.trim()) {
+        statements.push({ text: currentStmt, index: stmtStart });
+    }
+    return statements;
+}

package/dist/sql-scanner/literals.d.mts

@@ -0,0 +1,17 @@
+export type SqlStringLiteralStart = {
+    quoteStart: number;
+    escapeString: boolean;
+};
+export declare function readDollarQuoteDelimiter(content: string, index: number): string | null;
+export declare function stringLiteralQuoteStart(content: string, index: number): SqlStringLiteralStart | null;
+export declare function maskSqlQuotedText(content: string): string;
+export declare function readStringLiteral(content: string, index: number): {
+    text: string;
+    index: number;
+    end: number;
+} | null;
+export declare function dollarQuoteEnd(content: string, start: number, delimiter: string): number;
+export declare function sqlFragments(content: string): {
+    text: string;
+    index: number;
+}[];

package/dist/sql-scanner/literals.mjs

@@ -0,0 +1,158 @@
+export function readDollarQuoteDelimiter(content, index) {
+    if (content[index] !== '$')
+        return null;
+    /* v8 ignore next */
+    if (/[A-Za-z0-9_$]/.test(content[index - 1] ?? ''))
+        return null;
+    const dollarQuoteRe = /\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/y;
+    dollarQuoteRe.lastIndex = index;
+    const match = dollarQuoteRe.exec(content);
+    /* v8 ignore next */
+    return match?.[0] ?? null;
+}
+function isEscapeStringStart(content, index) {
+    /* v8 ignore next */
+    return /[Ee]/.test(content[index] ?? '') && content[index + 1] === "'";
+}
+export function stringLiteralQuoteStart(content, index) {
+    if (isEscapeStringStart(content, index))
+        return { quoteStart: index + 1, escapeString: true };
+    if (/[Uu]/.test(content[index] ?? '') &&
+        content[index + 1] === '&' &&
+        content[index + 2] === "'") {
+        return { quoteStart: index + 2, escapeString: false };
+    }
+    if (content[index] === "'")
+        return { quoteStart: index, escapeString: false };
+    return null;
+}
+function singleQuoteEnd(content, start, escapeString) {
+    for (let i = start + 1; i < content.length; i++) {
+        if (escapeString && content[i] === '\\') {
+            i++;
+            continue;
+        }
+        if (content[i] !== "'")
+            continue;
+        if (content[i + 1] === "'") {
+            i++;
+        }
+        else {
+            return i;
+        }
+    }
+    return content.length;
+}
+function decodeSqlStringBody(content, escapeString) {
+    let decoded = '';
+    for (let i = 0; i < content.length; i++) {
+        if (escapeString && content[i] === '\\' && i + 1 < content.length) {
+            const escaped = content[i + 1];
+            decoded += escaped === 'n' ? '\n' : escaped === 'r' ? '\r' : escaped === 't' ? '\t' : escaped;
+            i++;
+        }
+        else if (content[i] === "'" && content[i + 1] === "'") {
+            decoded += "'";
+            i++;
+        }
+        else {
+            decoded += content[i];
+        }
+    }
+    return decoded;
+}
+export function maskSqlQuotedText(content) {
+    let masked = '';
+    let inSingleQuote = false;
+    let inEscapeString = false;
+    let dollarQuoteDelimiter = null;
+    for (let i = 0; i < content.length; i++) {
+        if (dollarQuoteDelimiter) {
+            if (content.startsWith(dollarQuoteDelimiter, i)) {
+                masked += ' '.repeat(dollarQuoteDelimiter.length);
+                i += dollarQuoteDelimiter.length - 1;
+                dollarQuoteDelimiter = null;
+            }
+            else {
+                masked += content[i] === '\n' ? '\n' : ' ';
+            }
+            continue;
+        }
+        if (inSingleQuote) {
+            masked += ' ';
+            if (inEscapeString && content[i] === '\\' && i + 1 < content.length) {
+                masked += ' ';
+                i++;
+                continue;
+            }
+            if (content[i] === "'") {
+                if (content[i + 1] === "'") {
+                    masked += ' ';
+                    i++;
+                }
+                else {
+                    inSingleQuote = false;
+                    inEscapeString = false;
+                }
+            }
+            continue;
+        }
+        const dollarQuote = readDollarQuoteDelimiter(content, i);
+        if (dollarQuote) {
+            dollarQuoteDelimiter = dollarQuote;
+            masked += ' '.repeat(dollarQuote.length);
+            i += dollarQuote.length - 1;
+            continue;
+        }
+        const stringStart = stringLiteralQuoteStart(content, i);
+        if (stringStart) {
+            inSingleQuote = true;
+            inEscapeString = stringStart.escapeString;
+            masked += ' '.repeat(stringStart.quoteStart - i + 1);
+            i = stringStart.quoteStart;
+        }
+        else {
+            masked += content[i];
+        }
+    }
+    return masked;
+}
+export function readStringLiteral(content, index) {
+    const start = stringLiteralQuoteStart(content, index);
+    if (!start)
+        return null;
+    const bodyEnd = singleQuoteEnd(content, start.quoteStart, start.escapeString);
+    return {
+        text: decodeSqlStringBody(content.slice(start.quoteStart + 1, bodyEnd), start.escapeString),
+        index: start.quoteStart + 1,
+        end: bodyEnd + 1,
+    };
+}
+export function dollarQuoteEnd(content, start, delimiter) {
+    for (let i = start; i < content.length; i++) {
+        if (content.startsWith(delimiter, i))
+            return i;
+    }
+    return -1;
+}
+export function sqlFragments(content) {
+    const fragments = [];
+    for (let i = 0; i < content.length; i++) {
+        const dollarQuote = readDollarQuoteDelimiter(content, i);
+        if (dollarQuote) {
+            const bodyStart = i + dollarQuote.length;
+            const bodyEnd = dollarQuoteEnd(content, bodyStart, dollarQuote);
+            if (bodyEnd === -1)
+                break;
+            fragments.push({ text: content.slice(bodyStart, bodyEnd), index: bodyStart });
+            i = bodyEnd + dollarQuote.length - 1;
+            continue;
+        }
+        const literal = readStringLiteral(content, i);
+        if (literal) {
+            fragments.push({ text: literal.text, index: literal.index });
+            i = literal.end - 1;
+        }
+    }
+    return fragments;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {
@@ -40,6 +40,11 @@
       "import": "./dist/sql-ast/index.mjs",
       "default": "./dist/sql-ast/index.mjs"
     },
+    "./sql-scanner": {
+      "types": "./dist/sql-scanner/index.d.mts",
+      "import": "./dist/sql-scanner/index.mjs",
+      "default": "./dist/sql-scanner/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -51,7 +56,7 @@
     "typecheck": "tsc --noEmit --project tsconfig.json"
   },
   "optionalDependencies": {
-    "@libpg-query/parser": "^17.6.10"
+    "@libpg-query/parser": "^18.0.0"
   },
   "engines": {
     "node": ">=24.0.0"