rawsql-ts 0.12.0 → 0.12.1

package/dist/esm/transformers/DDLToFixtureConverter.js

@@ -0,0 +1,202 @@
+import { MultiQuerySplitter } from '../utils/MultiQuerySplitter';
+import { SqlParser } from '../parsers/SqlParser';
+import { CreateTableQuery } from '../models/CreateTableQuery';
+import { InsertQuery } from '../models/InsertQuery';
+import { ValuesQuery } from '../models/ValuesQuery';
+import { createTableDefinitionRegistryFromCreateTableQueries } from '../models/TableDefinitionModel';
+import { LiteralValue } from '../models/ValueComponent';
+import { SqlFormatter } from './SqlFormatter';
+export class DDLToFixtureConverter {
+    /**
+     * Converts DDL statements (CREATE TABLE) in the provided SQL text to a Fixture JSON object.
+     * Ignores non-DDL statements and parse errors.
+     *
+     * @param ddlSql The SQL text containing CREATE TABLE statements.
+     * @returns A Record representing the Fixture JSON.
+     */
+    /**
+     * Converts DDL statements (CREATE TABLE) in the provided SQL text to a Fixture JSON object.
+     * Ignores non-DDL statements and parse errors.
+     *
+     * @param ddlSql The SQL text containing CREATE TABLE statements.
+     * @returns A Record representing the Fixture JSON.
+     */
+    static convert(ddlSql) {
+        const splitResult = MultiQuerySplitter.split(ddlSql);
+        const createTableQueries = [];
+        const insertQueries = [];
+        for (const query of splitResult.queries) {
+            if (query.isEmpty)
+                continue;
+            try {
+                const ast = SqlParser.parse(query.sql);
+                if (ast instanceof CreateTableQuery) {
+                    createTableQueries.push(ast);
+                }
+                else if (ast instanceof InsertQuery) {
+                    insertQueries.push(ast);
+                }
+            }
+            catch (e) {
+                // Ignore parse errors for non-DDL or invalid SQL
+            }
+        }
+        const registry = createTableDefinitionRegistryFromCreateTableQueries(createTableQueries);
+        const fixtureJson = {};
+        // Initialize fixtureJson with empty rows
+        for (const [tableName, def] of Object.entries(registry)) {
+            fixtureJson[tableName] = {
+                columns: def.columns.map(col => ({
+                    name: col.name,
+                    type: col.typeName,
+                    default: this.formatDefaultValue(col.defaultValue)
+                })),
+                rows: []
+            };
+        }
+        // Sequence counters for nextval defaults: table -> column -> counter
+        const sequences = {};
+        // Process INSERT statements
+        for (const insert of insertQueries) {
+            // Only support INSERT ... VALUES
+            if (!(insert.selectQuery instanceof ValuesQuery)) {
+                continue;
+            }
+            const tableName = insert.insertClause.source.getAliasName();
+            if (!tableName || !fixtureJson[tableName]) {
+                // Ignore INSERTs for unknown tables
+                continue;
+            }
+            const tableDef = registry[tableName];
+            const targetColumns = insert.insertClause.columns;
+            const valuesQuery = insert.selectQuery;
+            // If columns are not specified, use all columns in order
+            const columnNames = targetColumns
+                ? targetColumns.map(c => c.name)
+                : tableDef.columns.map(c => c.name);
+            for (const tuple of valuesQuery.tuples) {
+                const row = {};
+                // Map provided values
+                for (let i = 0; i < columnNames.length; i++) {
+                    const colName = columnNames[i];
+                    if (i < tuple.values.length) {
+                        const val = tuple.values[i];
+                        row[colName] = this.extractValue(val);
+                    }
+                }
+                // Fill missing columns with defaults
+                for (const colDef of tableDef.columns) {
+                    if (row[colDef.name] !== undefined) {
+                        continue;
+                    }
+                    // Check for NOT NULL constraint without default
+                    // TableColumnDefinitionModel.required is true if NOT NULL and no default/identity
+                    if (colDef.required) {
+                        throw new Error(`Column '${colDef.name}' in table '${tableName}' cannot be null and has no default value.`);
+                    }
+                    const hasDefault = colDef.defaultValue !== null && colDef.defaultValue !== undefined;
+                    if (hasDefault) {
+                        const defaultValStr = this.formatDefaultValue(colDef.defaultValue);
+                        if (defaultValStr) {
+                            const trimmedDefault = defaultValStr.trim();
+                            const lowerTrimmed = trimmedDefault.toLowerCase();
+                            const stringLiteralValue = trimmedDefault.startsWith("'") && trimmedDefault.endsWith("'")
+                                ? trimmedDefault.slice(1, -1).replace(/''/g, "'")
+                                : trimmedDefault;
+                            // Normalize literal NULLs (even when quoted) into JS null
+                            if (stringLiteralValue.toLowerCase() === 'null') {
+                                row[colDef.name] = null;
+                            }
+                            else if (lowerTrimmed.includes('nextval')) {
+                                // Handle nextval sequence
+                                if (!sequences[tableName])
+                                    sequences[tableName] = {};
+                                if (!sequences[tableName][colDef.name])
+                                    sequences[tableName][colDef.name] = 0;
+                                sequences[tableName][colDef.name]++;
+                                row[colDef.name] = sequences[tableName][colDef.name];
+                            }
+                            else if (lowerTrimmed.includes('now') || lowerTrimmed.includes('current_timestamp')) {
+                                // Handle timestamp defaults - use a fixed date for consistency or current date
+                                // Using a fixed date makes tests deterministic
+                                row[colDef.name] = "2023-01-01 00:00:00";
+                            }
+                            else {
+                                // Use the literal default value
+                                // Try to unquote if it's a string literal
+                                if (trimmedDefault.startsWith("'") && trimmedDefault.endsWith("'")) {
+                                    row[colDef.name] = stringLiteralValue;
+                                }
+                                else {
+                                    // Try to parse number/boolean/null
+                                    const num = Number(trimmedDefault);
+                                    if (!isNaN(num)) {
+                                        row[colDef.name] = num;
+                                    }
+                                    else {
+                                        const lower = trimmedDefault.toLowerCase();
+                                        if (lower === 'true') {
+                                            row[colDef.name] = true;
+                                        }
+                                        else if (lower === 'false') {
+                                            row[colDef.name] = false;
+                                        }
+                                        else if (lower === 'null') {
+                                            row[colDef.name] = null;
+                                        }
+                                        else {
+                                            row[colDef.name] = trimmedDefault;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Default to null
+                        row[colDef.name] = null;
+                    }
+                }
+                fixtureJson[tableName].rows.push(row);
+            }
+        }
+        return fixtureJson;
+    }
+    static extractValue(value) {
+        if (value instanceof LiteralValue) {
+            return value.value;
+        }
+        // For other types, try to format to string
+        try {
+            const formatter = new SqlFormatter({ keywordCase: 'none' });
+            const { formattedSql } = formatter.format(value);
+            // Remove quotes if it looks like a string literal
+            if (formattedSql.startsWith("'") && formattedSql.endsWith("'")) {
+                return formattedSql.slice(1, -1).replace(/''/g, "'");
+            }
+            return formattedSql;
+        }
+        catch (e) {
+            return String(value);
+        }
+    }
+    static formatDefaultValue(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        try {
+            // Use SqlFormatter to print the AST node
+            const formatter = new SqlFormatter({ keywordCase: 'none' });
+            const { formattedSql } = formatter.format(value);
+            return formattedSql;
+        }
+        catch (e) {
+            // Fallback if formatter fails
+            return String(value);
+        }
+    }
+}
+//# sourceMappingURL=DDLToFixtureConverter.js.map

package/dist/esm/transformers/DDLToFixtureConverter.js.map

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

package/dist/esm/transformers/DeleteResultSelectConverter.d.ts

@@ -0,0 +1,53 @@
+import { DeleteQuery } from '../models/DeleteQuery';
+import { SimpleSelectQuery } from '../models/SelectQuery';
+import { TableDefinitionModel, TableDefinitionRegistry } from '../models/TableDefinitionModel';
+import { FixtureTableDefinition } from './FixtureCteBuilder';
+import type { MissingFixtureStrategy } from './InsertResultSelectConverter';
+/** Options that control how DELETE-to-SELECT conversion resolves metadata and fixtures. */
+export interface DeleteResultSelectOptions {
+    /** Optional registry keyed by table name (matching the target table name case). */
+    tableDefinitions?: TableDefinitionRegistry;
+    /** Optional callback that resolves metadata by table name (useful for schemified targets). */
+    tableDefinitionResolver?: (tableName: string) => TableDefinitionModel | undefined;
+    /** Optional fixtures that should shadow real tables inside the generated SELECT. */
+    fixtureTables?: FixtureTableDefinition[];
+    /** Strategy for how missing fixtures should be tolerated. */
+    missingFixtureStrategy?: MissingFixtureStrategy;
+}
+export declare class DeleteResultSelectConverter {
+    private static readonly DEFAULT_MISSING_FIXTURE_STRATEGY;
+    /**
+     * Converts a DELETE (with optional RETURNING) into a SELECT that mirrors its output rows.
+     */
+    static toSelectQuery(deleteQuery: DeleteQuery, options?: DeleteResultSelectOptions): SimpleSelectQuery;
+    private static buildReturningSelectClause;
+    private static buildReturningSelectItems;
+    private static isWildcardReturningItem;
+    private static expandReturningWildcard;
+    private static buildDeleteReturningSelectItem;
+    private static buildDeleteColumnReference;
+    private static composeDeleteColumnReference;
+    private static getReturningAlias;
+    private static buildCountSelectClause;
+    private static buildFromClause;
+    private static buildReturningContext;
+    private static buildTableContexts;
+    private static parseReturningColumnName;
+    private static findTableContextForNamespaces;
+    private static ensureColumnExists;
+    private static resolveTableDefinition;
+    private static convertFixtureToTableDefinition;
+    private static buildTableDefinitionMap;
+    private static extractTargetTableName;
+    private static buildFixtureCtes;
+    private static collectPhysicalTableReferences;
+    private static buildFixtureTableMap;
+    private static filterFixtureTablesForReferences;
+    private static collectReferencedTablesFromWithClause;
+    private static ensureFixtureCoverage;
+    private static collectReferencedTables;
+    private static collectCteNamesFromWithClause;
+    private static getMissingFixtureTables;
+    private static mergeWithClause;
+    private static normalizeIdentifier;
+}

package/dist/esm/transformers/DeleteResultSelectConverter.js

@@ -0,0 +1,410 @@
+import { FromClause, JoinClause, SelectClause, SelectItem, TableSource, WithClause } from '../models/Clause';
+import { SimpleSelectQuery } from '../models/SelectQuery';
+import { ColumnReference, FunctionCall, RawString } from '../models/ValueComponent';
+import { TableSourceCollector } from './TableSourceCollector';
+import { FixtureCteBuilder } from './FixtureCteBuilder';
+import { SelectQueryWithClauseHelper } from '../utils/SelectQueryWithClauseHelper';
+import { rewriteValueComponentWithColumnResolver } from '../utils/ValueComponentRewriter';
+import { tableNameVariants } from '../utils/TableNameUtils';
+import { FullNameParser } from '../parsers/FullNameParser';
+export class DeleteResultSelectConverter {
+    /**
+     * Converts a DELETE (with optional RETURNING) into a SELECT that mirrors its output rows.
+     */
+    static toSelectQuery(deleteQuery, options) {
+        var _a, _b, _c, _d;
+        const targetTableName = this.extractTargetTableName(deleteQuery.deleteClause);
+        const tableDefinition = this.resolveTableDefinition(targetTableName, options);
+        const targetAlias = deleteQuery.deleteClause.getSourceAliasName();
+        // Build the SELECT structure that mirrors the DELETE source/join semantics.
+        const returningContext = deleteQuery.returningClause
+            ? this.buildReturningContext(deleteQuery.deleteClause, deleteQuery.usingClause, targetAlias, tableDefinition, options)
+            : null;
+        const selectClause = deleteQuery.returningClause
+            ? this.buildReturningSelectClause(deleteQuery.returningClause, returningContext)
+            : this.buildCountSelectClause();
+        const fromClause = this.buildFromClause(deleteQuery.deleteClause, deleteQuery.usingClause);
+        const whereClause = (_a = deleteQuery.whereClause) !== null && _a !== void 0 ? _a : null;
+        const selectQuery = new SimpleSelectQuery({
+            withClause: (_b = deleteQuery.withClause) !== null && _b !== void 0 ? _b : undefined,
+            selectClause,
+            fromClause,
+            whereClause
+        });
+        // Ensure fixture coverage before weaving CTEs back into the SELECT.
+        const fixtureTables = (_c = options === null || options === void 0 ? void 0 : options.fixtureTables) !== null && _c !== void 0 ? _c : [];
+        const fixtureMap = this.buildFixtureTableMap(fixtureTables);
+        const missingStrategy = (_d = options === null || options === void 0 ? void 0 : options.missingFixtureStrategy) !== null && _d !== void 0 ? _d : this.DEFAULT_MISSING_FIXTURE_STRATEGY;
+        const originalWithClause = SelectQueryWithClauseHelper.detachWithClause(selectQuery);
+        const referencedTables = this.collectPhysicalTableReferences(selectQuery, originalWithClause);
+        const cteNames = this.collectCteNamesFromWithClause(originalWithClause);
+        const targetVariants = tableNameVariants(targetTableName);
+        for (const variant of targetVariants) {
+            if (!cteNames.has(variant)) {
+                referencedTables.add(variant);
+            }
+        }
+        this.ensureFixtureCoverage(referencedTables, fixtureMap, missingStrategy);
+        const filteredFixtures = this.filterFixtureTablesForReferences(fixtureTables, referencedTables);
+        const fixtureCtes = this.buildFixtureCtes(filteredFixtures);
+        const mergedWithClause = this.mergeWithClause(originalWithClause, fixtureCtes);
+        SelectQueryWithClauseHelper.setWithClause(selectQuery, mergedWithClause);
+        return selectQuery;
+    }
+    static buildReturningSelectClause(returning, context) {
+        const selectItems = this.buildReturningSelectItems(returning, context);
+        return new SelectClause(selectItems);
+    }
+    static buildReturningSelectItems(returning, context) {
+        // Build SELECT entries from RETURNING items, expanding wildcards before expression rewriting.
+        const selectItems = [];
+        for (const item of returning.items) {
+            if (this.isWildcardReturningItem(item)) {
+                selectItems.push(...this.expandReturningWildcard(context));
+                continue;
+            }
+            selectItems.push(this.buildDeleteReturningSelectItem(item, context));
+        }
+        return selectItems;
+    }
+    static isWildcardReturningItem(item) {
+        return (item.value instanceof ColumnReference &&
+            item.value.column.name === '*');
+    }
+    static expandReturningWildcard(context) {
+        if (!context.targetDefinition) {
+            throw new Error('Cannot expand RETURNING * without table definition.');
+        }
+        return context.targetDefinition.columns.map((column) => {
+            const expression = this.composeDeleteColumnReference({ namespaces: null, column: column.name }, context);
+            return new SelectItem(expression, column.name);
+        });
+    }
+    static buildDeleteReturningSelectItem(item, context) {
+        const expression = rewriteValueComponentWithColumnResolver(item.value, (column) => this.buildDeleteColumnReference(column, context));
+        const alias = this.getReturningAlias(item);
+        return new SelectItem(expression, alias);
+    }
+    static buildDeleteColumnReference(column, context) {
+        const parsed = this.parseReturningColumnName(column.toString());
+        return this.composeDeleteColumnReference(parsed, context);
+    }
+    static composeDeleteColumnReference(parsedColumn, context) {
+        var _a;
+        const tableContext = this.findTableContextForNamespaces(parsedColumn.namespaces, context);
+        const definitionToValidate = (_a = tableContext === null || tableContext === void 0 ? void 0 : tableContext.tableDefinition) !== null && _a !== void 0 ? _a : (parsedColumn.namespaces ? undefined : context.targetDefinition);
+        if (definitionToValidate) {
+            this.ensureColumnExists(parsedColumn.column, definitionToValidate);
+        }
+        const columnNamespace = parsedColumn.namespaces && parsedColumn.namespaces.length > 0
+            ? [...parsedColumn.namespaces]
+            : context.targetAlias
+                ? [context.targetAlias]
+                : null;
+        return new ColumnReference(columnNamespace, parsedColumn.column);
+    }
+    static getReturningAlias(item) {
+        var _a;
+        if ((_a = item.identifier) === null || _a === void 0 ? void 0 : _a.name) {
+            return item.identifier.name;
+        }
+        if (item.value instanceof ColumnReference) {
+            return item.value.toString();
+        }
+        return null;
+    }
+    static buildCountSelectClause() {
+        // Count rows when no RETURNING clause is present.
+        const countFunction = new FunctionCall(null, 'count', new RawString('*'), null);
+        const selectItem = new SelectItem(countFunction, 'count');
+        return new SelectClause([selectItem]);
+    }
+    static buildFromClause(deleteClause, usingClause) {
+        var _a;
+        if (!((_a = usingClause === null || usingClause === void 0 ? void 0 : usingClause.sources) === null || _a === void 0 ? void 0 : _a.length)) {
+            return new FromClause(deleteClause.source, null);
+        }
+        // Cross join each USING source so their columns remain available for predicates.
+        const joins = usingClause.sources.map((source) => new JoinClause('cross join', source, null, false));
+        return new FromClause(deleteClause.source, joins);
+    }
+    static buildReturningContext(deleteClause, usingClause, targetAlias, targetDefinition, options) {
+        const { aliasMap, tableNameMap } = this.buildTableContexts(deleteClause, usingClause, options);
+        return {
+            aliasMap,
+            tableNameMap,
+            targetAlias,
+            targetDefinition
+        };
+    }
+    static buildTableContexts(deleteClause, usingClause, options) {
+        const aliasMap = new Map();
+        const tableNameMap = new Map();
+        // Capture alias and table name contexts to resolve metadata for both identifiers.
+        const collectSource = (source) => {
+            const alias = source.getAliasName();
+            if (!alias || !(source.datasource instanceof TableSource)) {
+                return;
+            }
+            const normalizedAlias = this.normalizeIdentifier(alias);
+            if (aliasMap.has(normalizedAlias)) {
+                return;
+            }
+            const tableName = source.datasource.getSourceName();
+            const tableDefinition = this.resolveTableDefinition(tableName, options);
+            const context = {
+                alias,
+                tableName,
+                tableDefinition
+            };
+            aliasMap.set(normalizedAlias, context);
+            for (const variant of tableNameVariants(tableName)) {
+                if (!tableNameMap.has(variant)) {
+                    tableNameMap.set(variant, context);
+                }
+            }
+        };
+        collectSource(deleteClause.source);
+        if (usingClause) {
+            for (const source of usingClause.sources) {
+                collectSource(source);
+            }
+        }
+        return { aliasMap, tableNameMap };
+    }
+    static parseReturningColumnName(columnName) {
+        const trimmed = columnName.trim();
+        if (!trimmed) {
+            throw new Error('Returning column name cannot be empty.');
+        }
+        try {
+            const parsed = FullNameParser.parse(trimmed);
+            return {
+                namespaces: parsed.namespaces,
+                column: parsed.name.name
+            };
+        }
+        catch (_a) {
+            const parts = trimmed.split('.').map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+            if (parts.length === 0) {
+                return { namespaces: null, column: trimmed };
+            }
+            const column = parts.pop();
+            return {
+                namespaces: parts.length > 0 ? parts : null,
+                column
+            };
+        }
+    }
+    static findTableContextForNamespaces(namespaces, context) {
+        if (!(namespaces === null || namespaces === void 0 ? void 0 : namespaces.length)) {
+            return undefined;
+        }
+        for (let depth = namespaces.length; depth > 0; depth--) {
+            const candidateParts = namespaces.slice(namespaces.length - depth);
+            const identifier = candidateParts.join('.');
+            const normalized = this.normalizeIdentifier(identifier);
+            const aliasContext = context.aliasMap.get(normalized);
+            if (aliasContext) {
+                return aliasContext;
+            }
+            const tableContext = context.tableNameMap.get(normalized);
+            if (tableContext) {
+                return tableContext;
+            }
+        }
+        return undefined;
+    }
+    static ensureColumnExists(columnName, tableDefinition) {
+        if (!tableDefinition) {
+            return;
+        }
+        const normalized = this.normalizeIdentifier(columnName);
+        const exists = tableDefinition.columns.some((column) => this.normalizeIdentifier(column.name) === normalized);
+        if (!exists) {
+            throw new Error(`Column '${columnName}' cannot be resolved for RETURNING output.`);
+        }
+    }
+    static resolveTableDefinition(tableName, options) {
+        if (options === null || options === void 0 ? void 0 : options.tableDefinitionResolver) {
+            const resolved = options.tableDefinitionResolver(tableName);
+            if (resolved !== undefined) {
+                return resolved;
+            }
+        }
+        const normalizedVariants = new Set(tableNameVariants(tableName));
+        if (options === null || options === void 0 ? void 0 : options.tableDefinitions) {
+            const map = this.buildTableDefinitionMap(options.tableDefinitions);
+            for (const variant of normalizedVariants) {
+                const definition = map.get(variant);
+                if (definition) {
+                    return definition;
+                }
+            }
+        }
+        if (options === null || options === void 0 ? void 0 : options.fixtureTables) {
+            const fixture = options.fixtureTables.find((f) => tableNameVariants(f.tableName).some((variant) => normalizedVariants.has(variant)));
+            if (fixture) {
+                return this.convertFixtureToTableDefinition(fixture);
+            }
+        }
+        return undefined;
+    }
+    static convertFixtureToTableDefinition(fixture) {
+        return {
+            name: fixture.tableName,
+            columns: fixture.columns.map(col => {
+                var _a;
+                return ({
+                    name: col.name,
+                    typeName: col.typeName,
+                    required: false,
+                    defaultValue: (_a = col.defaultValue) !== null && _a !== void 0 ? _a : null
+                });
+            })
+        };
+    }
+    static buildTableDefinitionMap(registry) {
+        const map = new Map();
+        for (const definition of Object.values(registry)) {
+            for (const variant of tableNameVariants(definition.name)) {
+                map.set(variant, definition);
+            }
+        }
+        return map;
+    }
+    static extractTargetTableName(deleteClause) {
+        const datasource = deleteClause.source.datasource;
+        if (datasource instanceof TableSource) {
+            return datasource.getSourceName();
+        }
+        throw new Error('Delete target must be a table source for conversion.');
+    }
+    static buildFixtureCtes(fixtures) {
+        if (!fixtures || fixtures.length === 0) {
+            return [];
+        }
+        return FixtureCteBuilder.buildFixtures(fixtures);
+    }
+    static collectPhysicalTableReferences(selectQuery, withClause) {
+        const referencedTables = this.collectReferencedTables(selectQuery);
+        const ignoredTables = this.collectCteNamesFromWithClause(withClause);
+        const tablesToShadow = new Set();
+        // Keep only concrete tables that are not defined via WITH clause aliases.
+        for (const table of referencedTables) {
+            if (ignoredTables.has(table)) {
+                continue;
+            }
+            tablesToShadow.add(table);
+        }
+        const cteReferencedTables = this.collectReferencedTablesFromWithClause(withClause);
+        for (const table of cteReferencedTables) {
+            if (ignoredTables.has(table)) {
+                continue;
+            }
+            tablesToShadow.add(table);
+        }
+        return tablesToShadow;
+    }
+    static buildFixtureTableMap(fixtures) {
+        const map = new Map();
+        for (const fixture of fixtures) {
+            for (const variant of tableNameVariants(fixture.tableName)) {
+                map.set(variant, fixture);
+            }
+        }
+        return map;
+    }
+    static filterFixtureTablesForReferences(fixtures, referencedTables) {
+        if (!fixtures.length || referencedTables.size === 0) {
+            return [];
+        }
+        const filtered = [];
+        for (const fixture of fixtures) {
+            const fixtureVariants = tableNameVariants(fixture.tableName);
+            if (fixtureVariants.some((variant) => referencedTables.has(variant))) {
+                filtered.push(fixture);
+            }
+        }
+        return filtered;
+    }
+    static collectReferencedTablesFromWithClause(withClause) {
+        const tables = new Set();
+        if (!(withClause === null || withClause === void 0 ? void 0 : withClause.tables)) {
+            return tables;
+        }
+        for (const cte of withClause.tables) {
+            for (const table of this.collectReferencedTables(cte.query)) {
+                tables.add(table);
+            }
+        }
+        return tables;
+    }
+    static ensureFixtureCoverage(referencedTables, fixtureMap, strategy) {
+        if (referencedTables.size === 0) {
+            return;
+        }
+        const missingTables = this.getMissingFixtureTables(referencedTables, fixtureMap);
+        if (missingTables.length === 0) {
+            return;
+        }
+        if (strategy === 'error') {
+            throw new Error(`Delete SELECT refers to tables without fixture coverage: ${missingTables.join(', ')}.`);
+        }
+    }
+    static collectReferencedTables(query) {
+        const collector = new TableSourceCollector(false);
+        const sources = collector.collect(query);
+        const normalized = new Set();
+        for (const source of sources) {
+            for (const variant of tableNameVariants(source.getSourceName())) {
+                normalized.add(variant);
+            }
+        }
+        return normalized;
+    }
+    static collectCteNamesFromWithClause(withClause) {
+        const names = new Set();
+        if (!(withClause === null || withClause === void 0 ? void 0 : withClause.tables)) {
+            return names;
+        }
+        for (const table of withClause.tables) {
+            for (const variant of tableNameVariants(table.getSourceAliasName())) {
+                names.add(variant);
+            }
+        }
+        return names;
+    }
+    static getMissingFixtureTables(referencedTables, fixtureMap) {
+        const missing = [];
+        for (const table of referencedTables) {
+            const covered = tableNameVariants(table).some((variant) => fixtureMap.has(variant));
+            if (!covered) {
+                missing.push(table);
+            }
+        }
+        return missing;
+    }
+    static mergeWithClause(original, fixtureCtes) {
+        var _a;
+        if (!fixtureCtes.length && !original) {
+            return null;
+        }
+        const combinedTables = [...fixtureCtes];
+        if (original === null || original === void 0 ? void 0 : original.tables) {
+            combinedTables.push(...original.tables);
+        }
+        if (!combinedTables.length) {
+            return null;
+        }
+        const merged = new WithClause((_a = original === null || original === void 0 ? void 0 : original.recursive) !== null && _a !== void 0 ? _a : false, combinedTables);
+        merged.globalComments = (original === null || original === void 0 ? void 0 : original.globalComments) ? [...original.globalComments] : null;
+        merged.trailingComments = (original === null || original === void 0 ? void 0 : original.trailingComments) ? [...original.trailingComments] : null;
+        return merged;
+    }
+    static normalizeIdentifier(value) {
+        return value.trim().toLowerCase();
+    }
+}
+DeleteResultSelectConverter.DEFAULT_MISSING_FIXTURE_STRATEGY = 'error';
+//# sourceMappingURL=DeleteResultSelectConverter.js.map