vouchington-tooling 0.0.2 → 0.0.4

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;
+}