vouchington-tooling 0.0.2 → 0.0.4

package/dist/gha-runtime-audit/scope.mjs

@@ -0,0 +1,39 @@
+function matchesWorkflowName(name, match) {
+    return typeof match === 'string' ? name === match : match.test(name);
+}
+export function parseWorkflowNameMatch(value) {
+    if (value.length >= 2 && value.startsWith('/') && value.endsWith('/')) {
+        return new RegExp(value.slice(1, -1));
+    }
+    return value;
+}
+export function resolveRuntimeAuditOptions(options) {
+    if (!/^[^/]+\/[^/]+$/.test(options.repository)) {
+        throw new Error('Repository must be owner/name');
+    }
+    if (options.workflows.length === 0) {
+        throw new Error('At least one workflow filter is required');
+    }
+    return {
+        repository: options.repository,
+        workflows: options.workflows,
+        branch: options.branch ?? 'main',
+        sampleLimit: options.sampleLimit ?? 5,
+        recentCompletedRunHorizon: options.recentCompletedRunHorizon ?? 10,
+        medianThresholdSeconds: options.medianThresholdSeconds ?? 360,
+        hardCeilingSeconds: options.hardCeilingSeconds ?? 600,
+    };
+}
+export function matchingWorkflowFilter(name, filters) {
+    return filters.find((filter) => matchesWorkflowName(name, filter.name));
+}
+export function isSelectedWorkflow(workflow, filters) {
+    return workflow.state === 'active' && matchingWorkflowFilter(workflow.name, filters) !== undefined;
+}
+export function isRunInScope(run, filter, branch) {
+    if (run.event !== filter.event)
+        return false;
+    if (filter.event === 'pull_request')
+        return run.pullRequestBaseBranches.includes(branch);
+    return run.headBranch === branch;
+}

package/dist/index.d.mts

@@ -1,3 +1,7 @@
 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';
+export { auditCiJobRuntime, parseWorkflowNameMatch } from './gha-runtime-audit/index.mts';
+export type { GhApiExecutor, RuntimeAuditOptions, RuntimeAuditResult, RuntimeAuditWorkflowFilter, RuntimeJobResult, RuntimeSample, } from './gha-runtime-audit/index.mts';

package/dist/index.mjs

@@ -1,2 +1,4 @@
 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';
+export { auditCiJobRuntime, parseWorkflowNameMatch } from './gha-runtime-audit/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[];