relq 1.0.5 → 1.0.6

package/dist/esm/cli/utils/ast-codegen.js

@@ -0,0 +1,945 @@
+import { toCamelCase, escapeString, isBalanced, } from "./ast/codegen/utils.js";
+import { astToBuilder } from "./ast/codegen/builder.js";
+import { getColumnBuilder, getColumnBuilderWithInfo } from "./ast/codegen/type-map.js";
+import { formatDefaultValue, resetDefaultImportFlags, getDefaultImportNeeded, getDefaultSqlImportNeeded, } from "./ast/codegen/defaults.js";
+import { extractEnumValues, generateConstraintCode, generateCheckConstraintsOption, resetSqlImportFlag, getSqlImportNeeded, } from "./ast/codegen/constraints.js";
+let needsDefaultImport = false;
+let needsSqlImport = false;
+let trackingIdCounter = 0;
+function generateTrackingId(prefix) {
+    trackingIdCounter++;
+    const base = (Date.now().toString(36) + trackingIdCounter.toString(36)).slice(-5);
+    return prefix + base.padStart(5, '0');
+}
+export function resetTrackingIdCounter() {
+    trackingIdCounter = 0;
+}
+function getExplicitFKName(constraintName, tableName, columnName) {
+    if (!constraintName)
+        return undefined;
+    const expectedAutoName = `${tableName}_${columnName}_fkey`;
+    if (constraintName.toLowerCase() === expectedAutoName.toLowerCase()) {
+        return undefined;
+    }
+    return constraintName;
+}
+function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOverride) {
+    const colName = useCamelCase ? toCamelCase(col.name) : col.name;
+    const commentSuffix = col.comment ? `.comment('${escapeString(col.comment)}')` : '';
+    let line;
+    const normalizedType = col.type.toLowerCase();
+    if (enumNames.has(normalizedType) || enumNames.has(col.type)) {
+        const enumName = `${toCamelCase(col.type)}Enum`;
+        line = `    ${colName}: enumType(${enumName})`;
+    }
+    else if (domainNames.has(normalizedType) || domainNames.has(col.type)) {
+        const domainName = `${toCamelCase(col.type)}Domain`;
+        line = `    ${colName}: domainType(${domainName})`;
+    }
+    else {
+        let typeBuilder;
+        if (useCamelCase && colName !== col.name) {
+            const builderInfo = getColumnBuilderWithInfo(col.type, col.typeParams);
+            typeBuilder = `${builderInfo.builderName}('${col.name}')`;
+            if (builderInfo.length != null) {
+                typeBuilder += `.length(${builderInfo.length})`;
+            }
+        }
+        else {
+            typeBuilder = getColumnBuilder(col.type, col.typeParams);
+        }
+        if (col.isArray) {
+            typeBuilder = `${typeBuilder}.array()`;
+        }
+        line = `    ${colName}: ${typeBuilder}`;
+    }
+    if (col.isPrimaryKey) {
+        line += '.primaryKey()';
+    }
+    if (col.isUnique && !col.isPrimaryKey) {
+        line += '.unique()';
+    }
+    if (checkOverride) {
+        const valuesStr = checkOverride.values.map(v => `'${escapeString(v)}'`).join(', ');
+        line += `.check('${checkOverride.name}', [${valuesStr}])`;
+    }
+    else if (col.checkConstraint) {
+        const enumValues = extractEnumValues(col.checkConstraint.expression);
+        if (enumValues && enumValues.length > 0) {
+            const valuesStr = enumValues.map(v => `'${escapeString(v)}'`).join(', ');
+            line += `.check('${col.checkConstraint.name}', [${valuesStr}])`;
+        }
+    }
+    if (col.hasDefault && col.defaultValue) {
+        const defaultVal = formatDefaultValue(col.defaultValue, col.type);
+        line += `.default(${defaultVal})`;
+    }
+    if (col.isGenerated && col.generatedExpression) {
+        const escapedExpr = col.generatedExpression.replace(/`/g, '\\`');
+        line += `.generatedAlwaysAs(F => F.raw(\`${escapedExpr}\`))`;
+    }
+    if (!col.isNullable && !col.isPrimaryKey) {
+        line += '.notNull()';
+    }
+    const trackingId = generateTrackingId('c');
+    line += `.$id('${trackingId}')`;
+    return line + commentSuffix;
+}
+function generateIndexCode(index, useCamelCase) {
+    const cols = index.columns.map(c => {
+        if (index.isExpression || c.includes('(') || c.includes(' ')) {
+            return `'${c}'`;
+        }
+        return `table.${useCamelCase ? toCamelCase(c) : c}`;
+    }).join(', ');
+    let line = `        index('${index.name}').on(${cols})`;
+    if (index.isUnique) {
+        line += '.unique()';
+    }
+    if (index.method && index.method.toUpperCase() !== 'BTREE') {
+        line += `.using('${index.method.toUpperCase()}')`;
+    }
+    if (index.opclass) {
+        line += `.opclass('${index.opclass}')`;
+    }
+    if (index.whereClauseAst) {
+        try {
+            const whereExpr = astToBuilder(index.whereClauseAst, {
+                prefix: 'table',
+                useCamelCase,
+                useTableRef: true
+            });
+            line += `.where(${whereExpr})`;
+        }
+        catch {
+            needsSqlImport = true;
+            line += `.where(sql\`${escapeString(index.whereClause || '')}\`)`;
+        }
+    }
+    else if (index.whereClause) {
+        const typedWhere = convertWhereClauseToTyped(index.whereClause, useCamelCase);
+        if (typedWhere.startsWith('sql`')) {
+            needsSqlImport = true;
+        }
+        line += `.where(${typedWhere})`;
+    }
+    if (index.includeColumns && index.includeColumns.length > 0) {
+        const includeCols = index.includeColumns.map(c => `table.${useCamelCase ? toCamelCase(c) : c}`).join(', ');
+        line += `.include(${includeCols})`;
+    }
+    const trackingId = generateTrackingId('i');
+    line += `.$id('${trackingId}')`;
+    if (index.comment) {
+        line += `.comment('${escapeString(index.comment)}')`;
+    }
+    return line;
+}
+function convertWhereClauseToTyped(whereClause, useCamelCase) {
+    const trimmed = whereClause.trim();
+    let expr = trimmed;
+    while (expr.startsWith('(') && expr.endsWith(')')) {
+        const inner = expr.slice(1, -1);
+        if (isBalanced(inner)) {
+            expr = inner;
+        }
+        else {
+            break;
+        }
+    }
+    const boolMatch = expr.match(/^(\w+)\s*=\s*(true|false)$/i);
+    if (boolMatch) {
+        const colName = useCamelCase ? toCamelCase(boolMatch[1]) : boolMatch[1];
+        const value = boolMatch[2].toLowerCase();
+        return `table.${colName}.eq(${value})`;
+    }
+    const numMatch = expr.match(/^(\w+)\s*=\s*(-?\d+(?:\.\d+)?)$/i);
+    if (numMatch) {
+        const colName = useCamelCase ? toCamelCase(numMatch[1]) : numMatch[1];
+        return `table.${colName}.eq(${numMatch[2]})`;
+    }
+    const strMatch = expr.match(/^(\w+)\s*=\s*'([^']*)'$/i);
+    if (strMatch) {
+        const colName = useCamelCase ? toCamelCase(strMatch[1]) : strMatch[1];
+        return `table.${colName}.eq('${strMatch[2]}')`;
+    }
+    const isNullMatch = expr.match(/^(\w+)\s+IS\s+NULL$/i);
+    if (isNullMatch) {
+        const colName = useCamelCase ? toCamelCase(isNullMatch[1]) : isNullMatch[1];
+        return `table.${colName}.isNull()`;
+    }
+    const isNotNullMatch = expr.match(/^(\w+)\s+IS\s+NOT\s+NULL$/i);
+    if (isNotNullMatch) {
+        const colName = useCamelCase ? toCamelCase(isNotNullMatch[1]) : isNotNullMatch[1];
+        return `table.${colName}.isNotNull()`;
+    }
+    const andMatch = expr.match(/^\((.+?)\)\s+AND\s+\((.+)\)$/i);
+    if (andMatch) {
+        const typed1 = convertWhereClauseToTyped(`(${andMatch[1]})`, useCamelCase);
+        const typed2 = convertWhereClauseToTyped(`(${andMatch[2]})`, useCamelCase);
+        if (!typed1.startsWith('sql`') && !typed2.startsWith('sql`')) {
+            return `${typed1}.and(${typed2})`;
+        }
+    }
+    const orMatch = expr.match(/^\((.+?)\)\s+OR\s+\((.+)\)$/i);
+    if (orMatch) {
+        const typed1 = convertWhereClauseToTyped(`(${orMatch[1]})`, useCamelCase);
+        const typed2 = convertWhereClauseToTyped(`(${orMatch[2]})`, useCamelCase);
+        if (!typed1.startsWith('sql`') && !typed2.startsWith('sql`')) {
+            return `${typed1}.or(${typed2})`;
+        }
+    }
+    return `sql\`${escapeString(whereClause)}\``;
+}
+function parsePartitionValues(valuesStr) {
+    const values = [];
+    let current = '';
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    for (let i = 0; i < valuesStr.length; i++) {
+        const char = valuesStr[i];
+        if (!inString && (char === "'" || char === '"')) {
+            inString = true;
+            stringChar = char;
+            current += char;
+        }
+        else if (inString && char === stringChar) {
+            if (i + 1 < valuesStr.length && valuesStr[i + 1] === stringChar) {
+                current += char + valuesStr[i + 1];
+                i++;
+            }
+            else {
+                inString = false;
+                current += char;
+            }
+        }
+        else if (!inString && char === '(') {
+            depth++;
+            current += char;
+        }
+        else if (!inString && char === ')') {
+            depth--;
+            current += char;
+        }
+        else if (!inString && char === ',' && depth === 0) {
+            if (current.trim()) {
+                values.push(current.trim());
+            }
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        values.push(current.trim());
+    }
+    return values;
+}
+function formatPartitionValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+        const inner = trimmed.slice(1, -1);
+        const parts = parsePartitionValues(inner);
+        return `[${parts.join(', ')}]`;
+    }
+    const upper = trimmed.toUpperCase();
+    if (upper === 'MINVALUE')
+        return "'MINVALUE'";
+    if (upper === 'MAXVALUE')
+        return "'MAXVALUE'";
+    return trimmed;
+}
+function generatePartitionCode(child, partitionType, useCamelCase) {
+    const childName = child.name;
+    const bound = child.partitionBound || '';
+    const partType = partitionType.toUpperCase();
+    if (bound.toUpperCase().includes('DEFAULT')) {
+        return `        partition('${childName}').default()`;
+    }
+    if (partType === 'LIST') {
+        const inMatch = bound.match(/FOR VALUES IN\s*\((.+)\)/i);
+        if (inMatch) {
+            const valuesStr = inMatch[1].trim();
+            const values = parsePartitionValues(valuesStr);
+            const formattedValues = values.map(formatPartitionValue).join(', ');
+            return `        partition('${childName}').in([${formattedValues}])`;
+        }
+    }
+    else if (partType === 'RANGE') {
+        const rangeMatch = bound.match(/FOR VALUES FROM\s*\((.+?)\)\s*TO\s*\((.+?)\)$/i);
+        if (rangeMatch) {
+            const fromRaw = rangeMatch[1].trim();
+            const toRaw = rangeMatch[2].trim();
+            let fromVal;
+            if (fromRaw.toUpperCase() === 'MINVALUE') {
+                fromVal = "'MINVALUE'";
+            }
+            else if (fromRaw.includes(',')) {
+                const fromParts = parsePartitionValues(fromRaw);
+                fromVal = `[${fromParts.map(formatPartitionValue).join(', ')}]`;
+            }
+            else {
+                fromVal = formatPartitionValue(fromRaw);
+            }
+            let toVal;
+            if (toRaw.toUpperCase() === 'MAXVALUE') {
+                toVal = "'MAXVALUE'";
+            }
+            else if (toRaw.includes(',')) {
+                const toParts = parsePartitionValues(toRaw);
+                toVal = `[${toParts.map(formatPartitionValue).join(', ')}]`;
+            }
+            else {
+                toVal = formatPartitionValue(toRaw);
+            }
+            return `        partition('${childName}').from(${fromVal}).to(${toVal})`;
+        }
+    }
+    else if (partType === 'HASH') {
+        const hashMatch = bound.match(/FOR VALUES WITH\s*\(MODULUS\s*(\d+),\s*REMAINDER\s*(\d+)\)/i);
+        if (hashMatch) {
+            const remainder = hashMatch[2];
+            return `        partition('${childName}').remainder(${remainder})`;
+        }
+    }
+    needsSqlImport = true;
+    return `        partition('${childName}').in([sql\`${escapeString(bound)}\`])`;
+}
+function generateTableCode(table, useCamelCase, enumNames, domainNames) {
+    const tableName = useCamelCase ? toCamelCase(table.name) : table.name;
+    const parts = [];
+    const tableComment = table.comment ? `    comment: '${escapeString(table.comment)}'` : null;
+    const columnChecks = new Map();
+    for (const c of table.constraints) {
+        if (c.type === 'CHECK' && c.expression) {
+            for (const col of table.columns) {
+                const colPattern = new RegExp(`\\(${col.name}\\)|\\b${col.name}\\b`, 'i');
+                if (colPattern.test(c.expression)) {
+                    const values = extractEnumValues(c.expression);
+                    if (values && values.length > 0) {
+                        columnChecks.set(col.name, { name: c.name, values });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    const singleColPkColumns = new Set();
+    for (const c of table.constraints) {
+        if (c.type === 'PRIMARY KEY' && c.columns.length === 1) {
+            const normalizedCol = useCamelCase ? toCamelCase(c.columns[0]) : c.columns[0];
+            singleColPkColumns.add(normalizedCol);
+        }
+    }
+    const compositeColPkColumns = new Set();
+    for (const c of table.constraints) {
+        if (c.type === 'PRIMARY KEY' && c.columns.length > 1) {
+            for (const col of c.columns) {
+                const normalizedCol = useCamelCase ? toCamelCase(col) : col;
+                compositeColPkColumns.add(normalizedCol);
+            }
+        }
+    }
+    const uniqueColumns = new Set();
+    for (const c of table.constraints) {
+        if (c.type === 'UNIQUE' && c.columns.length === 1) {
+            const normalizedCol = useCamelCase ? toCamelCase(c.columns[0]) : c.columns[0];
+            uniqueColumns.add(normalizedCol);
+        }
+    }
+    const updatedColumns = table.columns.map(col => {
+        const normalizedColName = useCamelCase ? toCamelCase(col.name) : col.name;
+        const isSingleColPk = singleColPkColumns.has(col.name) || singleColPkColumns.has(normalizedColName);
+        const isCompositePkMember = compositeColPkColumns.has(col.name) || compositeColPkColumns.has(normalizedColName);
+        return {
+            ...col,
+            isPrimaryKey: isSingleColPk && !isCompositePkMember,
+            isUnique: col.isUnique || uniqueColumns.has(col.name) || uniqueColumns.has(normalizedColName),
+        };
+    });
+    const columnLines = updatedColumns.map(col => generateColumnCode(col, useCamelCase, enumNames, domainNames, columnChecks.get(col.name)));
+    const optionParts = [];
+    if (table.isPartitioned && table.partitionType && table.partitionKey?.length) {
+        const partCol = useCamelCase ? toCamelCase(table.partitionKey[0]) : table.partitionKey[0];
+        const partType = table.partitionType.toLowerCase();
+        if (partType === 'hash') {
+            optionParts.push(`    partitionBy: (table, p) => p.hash(table.${partCol}, 4)`);
+        }
+        else {
+            optionParts.push(`    partitionBy: (table, p) => p.${partType}(table.${partCol})`);
+        }
+        if (table.childPartitions && table.childPartitions.length > 0) {
+            const partitionLines = table.childPartitions.map(child => {
+                return generatePartitionCode(child, table.partitionType, useCamelCase);
+            });
+            optionParts.push(`    partitions: (partition) => [\n${partitionLines.join(',\n')},\n    ]`);
+        }
+    }
+    const compositePKs = table.constraints.filter(c => c.type === 'PRIMARY KEY' && c.columns.length > 1);
+    const compositeUniques = table.constraints.filter(c => c.type === 'UNIQUE' && c.columns.length > 1);
+    const excludeConstraints = table.constraints.filter(c => c.type === 'EXCLUDE');
+    if (compositePKs.length > 0 || compositeUniques.length > 0 || excludeConstraints.length > 0) {
+        const constraintLines = generateConstraintCode([...compositePKs, ...compositeUniques, ...excludeConstraints], useCamelCase);
+        if (constraintLines.length > 0) {
+            optionParts.push(`    constraints: (table, constraint) => [\n${constraintLines.join(',\n')},\n    ]`);
+        }
+    }
+    const checkConstraintsOption = generateCheckConstraintsOption(table.constraints, useCamelCase);
+    if (checkConstraintsOption) {
+        optionParts.push(checkConstraintsOption);
+    }
+    if (table.indexes.length > 0) {
+        const indexLines = table.indexes.map(idx => generateIndexCode(idx, useCamelCase));
+        optionParts.push(`    indexes: (table, index) => [\n${indexLines.join(',\n')},\n    ]`);
+    }
+    if (tableComment) {
+        optionParts.push(tableComment);
+    }
+    const tableTrackingId = generateTrackingId('t');
+    optionParts.push(`    $trackingId: '${tableTrackingId}'`);
+    let tableCode;
+    if (optionParts.length > 0) {
+        tableCode = `export const ${tableName} = defineTable('${table.name}', {\n${columnLines.join(',\n')},\n}, {\n${optionParts.join(',\n')},\n})`;
+    }
+    else {
+        tableCode = `export const ${tableName} = defineTable('${table.name}', {\n${columnLines.join(',\n')},\n})`;
+    }
+    parts.push(tableCode);
+    return parts.join('\n');
+}
+function generateEnumCode(enumDef, useCamelCase) {
+    const baseName = useCamelCase ? toCamelCase(enumDef.name) : enumDef.name;
+    const enumName = `${baseName}Enum`;
+    const valuesStr = enumDef.values.map(v => `'${escapeString(v)}'`).join(', ');
+    return `export const ${enumName} = pgEnum('${enumDef.name}', [${valuesStr}])`;
+}
+function generateDomainCode(domain, useCamelCase) {
+    const baseName = useCamelCase ? toCamelCase(domain.name) : domain.name;
+    const domainName = `${baseName}Domain`;
+    const baseType = getColumnBuilder(domain.baseType);
+    let line = `export const ${domainName} = pgDomain('${domain.name}', ${baseType})`;
+    if (domain.notNull) {
+        line += '.notNull()';
+    }
+    if (domain.defaultValue) {
+        line += `.default(${formatDefaultValue(domain.defaultValue)})`;
+    }
+    if (domain.checkExpression) {
+        line += `.check('${escapeString(domain.checkExpression)}')`;
+    }
+    return line;
+}
+function generateExtensionsCode(extensions) {
+    if (extensions.length === 0)
+        return '';
+    const extList = extensions.map(e => `'${escapeString(e)}'`).join(', ');
+    return `export const extensions = pgExtensions(${extList})`;
+}
+function generateSequenceCode(seq, useCamelCase) {
+    const seqName = useCamelCase ? toCamelCase(seq.name) : seq.name;
+    const opts = [];
+    if (seq.startValue !== undefined)
+        opts.push(`start: ${seq.startValue}`);
+    if (seq.increment !== undefined)
+        opts.push(`increment: ${seq.increment}`);
+    if (seq.minValue !== undefined)
+        opts.push(`minValue: ${seq.minValue}`);
+    if (seq.maxValue !== undefined)
+        opts.push(`maxValue: ${seq.maxValue}`);
+    if (seq.cache !== undefined)
+        opts.push(`cache: ${seq.cache}`);
+    if (seq.cycle)
+        opts.push(`cycle: true`);
+    if (seq.ownedBy)
+        opts.push(`ownedBy: { table: '${seq.ownedBy.table}', column: '${seq.ownedBy.column}' }`);
+    const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+    return `export const ${seqName} = pgSequence('${seq.name}'${optsStr})`;
+}
+function generateFunctionCode(func, useCamelCase) {
+    const funcName = useCamelCase ? toCamelCase(func.name) : func.name;
+    const parts = [];
+    parts.push(`export const ${funcName} = pgFunction('${func.name}', {`);
+    if (func.args.length > 0) {
+        const argsStr = func.args.map(arg => {
+            const argParts = [`type: '${arg.type}'`];
+            if (arg.name)
+                argParts.push(`name: '${arg.name}'`);
+            if (arg.mode)
+                argParts.push(`mode: '${arg.mode}'`);
+            if (arg.default)
+                argParts.push(`default: '${escapeString(arg.default)}'`);
+            return `{ ${argParts.join(', ')} }`;
+        }).join(', ');
+        parts.push(`    args: [${argsStr}],`);
+    }
+    parts.push(`    returns: '${func.returnType}',`);
+    parts.push(`    language: '${func.language}',`);
+    const escapedBody = func.body.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    parts.push(`    body: \`${escapedBody}\`,`);
+    if (func.volatility)
+        parts.push(`    volatility: '${func.volatility}',`);
+    if (func.isStrict)
+        parts.push(`    strict: true,`);
+    if (func.securityDefiner)
+        parts.push(`    securityDefiner: true,`);
+    parts.push(`})`);
+    return parts.join('\n');
+}
+function generateViewCode(view, useCamelCase) {
+    const viewName = useCamelCase ? toCamelCase(view.name) : view.name;
+    const funcName = view.isMaterialized ? 'pgMaterializedView' : 'pgView';
+    const escapedDef = view.definition.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    return `export const ${viewName} = ${funcName}('${view.name}', \`${escapedDef}\`)`;
+}
+function generateTriggerCode(trigger, useCamelCase, functionNames) {
+    const triggerName = useCamelCase ? toCamelCase(trigger.name) : trigger.name;
+    const tableName = useCamelCase ? toCamelCase(trigger.table) : trigger.table;
+    const parts = [];
+    parts.push(`export const ${triggerName} = pgTrigger('${trigger.name}', {`);
+    parts.push(`    table: ${tableName},`);
+    parts.push(`    timing: '${trigger.timing}',`);
+    parts.push(`    events: [${trigger.events.map(e => `'${e}'`).join(', ')}],`);
+    parts.push(`    forEach: '${trigger.forEach}',`);
+    const funcVarName = useCamelCase ? toCamelCase(trigger.functionName) : trigger.functionName;
+    if (functionNames.has(trigger.functionName)) {
+        parts.push(`    execute: ${funcVarName},`);
+    }
+    else {
+        parts.push(`    execute: '${trigger.functionName}',`);
+    }
+    if (trigger.whenClause)
+        parts.push(`    when: '${escapeString(trigger.whenClause)}',`);
+    if (trigger.isConstraint)
+        parts.push(`    constraint: true,`);
+    if (trigger.deferrable)
+        parts.push(`    deferrable: true,`);
+    if (trigger.initiallyDeferred)
+        parts.push(`    initiallyDeferred: true,`);
+    parts.push(`})`);
+    return parts.join('\n');
+}
+export function generateTypeScriptFromAST(schema, options = {}) {
+    const { camelCase = true, importPath = 'relq/schema-builder', includeEnums = true, includeDomains = true, includeTables = true, includeFunctions = true, includeTriggers = true, } = options;
+    const parts = [];
+    parts.push('/**');
+    parts.push(' * Auto-generated by Relq CLI (AST-based)');
+    parts.push(` * Generated at: ${new Date().toISOString()}`);
+    parts.push(' * DO NOT EDIT - changes will be overwritten');
+    parts.push(' */');
+    parts.push('');
+    needsDefaultImport = false;
+    needsSqlImport = false;
+    resetDefaultImportFlags();
+    resetSqlImportFlag();
+    const needsPgExtensions = schema.extensions.length > 0;
+    const needsPgSequence = schema.sequences.length > 0;
+    const needsPgFunction = includeFunctions && schema.functions.length > 0;
+    const needsPgTrigger = includeTriggers && schema.triggers.length > 0;
+    const needsPgEnum = includeEnums && schema.enums.length > 0;
+    const needsPgView = options.includeViews !== false && schema.views.filter(v => !v.isMaterialized).length > 0;
+    const needsPgMaterializedView = options.includeViews !== false && schema.views.filter(v => v.isMaterialized).length > 0;
+    const enumNames = new Set(schema.enums.map(e => e.name.toLowerCase()));
+    const domainNames = new Set(schema.domains.map(d => d.name.toLowerCase()));
+    const tableCodeParts = [];
+    const usedColumnTypes = new Set();
+    let needsEnumType = false;
+    let needsDomainType = false;
+    const sortedTables = [...schema.tables].sort((a, b) => {
+        if (a.partitionOf)
+            return 1;
+        if (b.partitionOf)
+            return -1;
+        return a.name.localeCompare(b.name);
+    });
+    for (const table of sortedTables) {
+        if (table.partitionOf)
+            continue;
+        const code = generateTableCode(table, camelCase, enumNames, domainNames);
+        tableCodeParts.push(code);
+        for (const col of table.columns) {
+            if (enumNames.has(col.type.toLowerCase())) {
+                needsEnumType = true;
+            }
+            else if (domainNames.has(col.type.toLowerCase())) {
+                needsDomainType = true;
+            }
+            else {
+                const builder = getColumnBuilder(col.type, col.typeParams);
+                const typeName = builder.split('(')[0];
+                if (typeName) {
+                    usedColumnTypes.add(typeName);
+                }
+            }
+        }
+    }
+    const needsRelations = schema.tables.some(table => !table.partitionOf && (table.constraints.some(c => c.type === 'FOREIGN KEY' && c.references) ||
+        table.columns.some(c => c.references)));
+    const imports = ['defineTable'];
+    if (needsPgEnum)
+        imports.push('pgEnum');
+    if (needsEnumType)
+        imports.push('enumType');
+    if (includeDomains && schema.domains.length > 0)
+        imports.push('pgDomain');
+    if (needsDomainType)
+        imports.push('domainType');
+    if (needsPgExtensions)
+        imports.push('pgExtensions');
+    if (needsPgSequence)
+        imports.push('pgSequence');
+    if (needsPgView)
+        imports.push('pgView');
+    if (needsPgMaterializedView)
+        imports.push('pgMaterializedView');
+    if (needsPgFunction)
+        imports.push('pgFunction');
+    if (needsPgTrigger)
+        imports.push('pgTrigger');
+    const finalNeedsDefaultImport = needsDefaultImport || getDefaultImportNeeded();
+    const finalNeedsSqlImport = needsSqlImport || getSqlImportNeeded() || getDefaultSqlImportNeeded();
+    if (finalNeedsDefaultImport)
+        imports.push('DEFAULT');
+    if (finalNeedsSqlImport)
+        imports.push('sql');
+    if (needsRelations)
+        imports.push('pgRelations');
+    for (const type of usedColumnTypes) {
+        if (!imports.includes(type))
+            imports.push(type);
+    }
+    parts.push(`import {`);
+    parts.push(`    ${imports.join(',\n    ')},`);
+    parts.push(`    type RelqDatabaseSchema,`);
+    parts.push(`} from '${importPath}';`);
+    parts.push('');
+    if (needsPgExtensions) {
+        parts.push('// =============================================================================');
+        parts.push('// EXTENSIONS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        parts.push(generateExtensionsCode(schema.extensions));
+        parts.push('');
+    }
+    if (needsPgEnum) {
+        parts.push('// =============================================================================');
+        parts.push('// ENUMS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        for (const enumDef of schema.enums) {
+            parts.push(generateEnumCode(enumDef, camelCase));
+        }
+        parts.push('');
+    }
+    if (includeDomains && schema.domains.length > 0) {
+        parts.push('// =============================================================================');
+        parts.push('// DOMAINS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        for (const domain of schema.domains) {
+            parts.push(generateDomainCode(domain, camelCase));
+        }
+        parts.push('');
+    }
+    if (needsPgSequence) {
+        parts.push('// =============================================================================');
+        parts.push('// SEQUENCES');
+        parts.push('// =============================================================================');
+        parts.push('');
+        for (const seq of schema.sequences) {
+            parts.push(generateSequenceCode(seq, camelCase));
+        }
+        parts.push('');
+    }
+    if (includeTables && schema.tables.length > 0) {
+        parts.push('// =============================================================================');
+        parts.push('// TABLES');
+        parts.push('// =============================================================================');
+        parts.push('');
+        const sortedTables = [...schema.tables].sort((a, b) => {
+            if (a.partitionOf)
+                return 1;
+            if (b.partitionOf)
+                return -1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const table of sortedTables) {
+            if (table.partitionOf)
+                continue;
+            parts.push(generateTableCode(table, camelCase, enumNames, domainNames));
+            parts.push('');
+        }
+    }
+    if ((needsPgView || needsPgMaterializedView) && schema.views.length > 0) {
+        parts.push('// =============================================================================');
+        parts.push('// VIEWS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        for (const view of schema.views) {
+            parts.push(generateViewCode(view, camelCase));
+            parts.push('');
+        }
+    }
+    if (needsPgFunction) {
+        parts.push('// =============================================================================');
+        parts.push('// FUNCTIONS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        for (const func of schema.functions) {
+            parts.push(generateFunctionCode(func, camelCase));
+            parts.push('');
+        }
+    }
+    if (needsPgTrigger) {
+        parts.push('// =============================================================================');
+        parts.push('// TRIGGERS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        const functionNames = new Set(schema.functions.map(f => f.name));
+        for (const trigger of schema.triggers) {
+            parts.push(generateTriggerCode(trigger, camelCase, functionNames));
+            parts.push('');
+        }
+    }
+    parts.push('// =============================================================================');
+    parts.push('// SCHEMA EXPORT');
+    parts.push('// =============================================================================');
+    parts.push('');
+    const tableNames = schema.tables
+        .filter(t => !t.partitionOf)
+        .map(t => camelCase ? toCamelCase(t.name) : t.name)
+        .sort();
+    parts.push('export const schema = {');
+    for (const name of tableNames) {
+        parts.push(`    ${name},`);
+    }
+    parts.push('} as const;');
+    parts.push('');
+    parts.push('export type DatabaseSchema = RelqDatabaseSchema<typeof schema>;');
+    parts.push('');
+    const relationsCode = generateRelationsCode(schema, camelCase);
+    if (relationsCode) {
+        parts.push('// =============================================================================');
+        parts.push('// RELATIONS');
+        parts.push('// =============================================================================');
+        parts.push('');
+        parts.push(relationsCode);
+        parts.push('');
+    }
+    return parts.join('\n');
+}
+function generateRelationsCode(schema, camelCase) {
+    const foreignKeys = [];
+    for (const table of schema.tables) {
+        if (table.partitionOf)
+            continue;
+        for (const column of table.columns) {
+            if (column.references) {
+                foreignKeys.push({
+                    fromTable: table.name,
+                    fromColumn: column.name,
+                    toTable: column.references.table,
+                    toColumn: column.references.column,
+                    onDelete: column.references.onDelete,
+                    onUpdate: column.references.onUpdate,
+                    match: column.references.match,
+                    deferrable: column.references.deferrable,
+                    initiallyDeferred: column.references.initiallyDeferred,
+                });
+            }
+        }
+        for (const constraint of table.constraints) {
+            if (constraint.type === 'FOREIGN KEY' && constraint.references) {
+                if (constraint.columns.length === 1 && constraint.references.columns.length === 1) {
+                    const alreadyExists = foreignKeys.some(fk => fk.fromTable === table.name &&
+                        fk.fromColumn === constraint.columns[0] &&
+                        fk.toTable === constraint.references.table);
+                    if (!alreadyExists) {
+                        foreignKeys.push({
+                            fromTable: table.name,
+                            fromColumn: constraint.columns[0],
+                            toTable: constraint.references.table,
+                            toColumn: constraint.references.columns[0],
+                            constraintName: getExplicitFKName(constraint.name, table.name, constraint.columns[0]),
+                            onDelete: constraint.references.onDelete,
+                            onUpdate: constraint.references.onUpdate,
+                            match: constraint.references.match,
+                            deferrable: constraint.references.deferrable,
+                            initiallyDeferred: constraint.references.initiallyDeferred,
+                        });
+                    }
+                }
+                else if (constraint.columns.length > 1) {
+                    foreignKeys.push({
+                        fromTable: table.name,
+                        fromColumn: constraint.columns[0],
+                        toTable: constraint.references.table,
+                        toColumn: constraint.references.columns[0],
+                        constraintName: getExplicitFKName(constraint.name, table.name, constraint.columns[0]),
+                        onDelete: constraint.references.onDelete,
+                        onUpdate: constraint.references.onUpdate,
+                        match: constraint.references.match,
+                        deferrable: constraint.references.deferrable,
+                        initiallyDeferred: constraint.references.initiallyDeferred,
+                        isComposite: true,
+                        fromColumns: constraint.columns,
+                        toColumns: constraint.references.columns,
+                    });
+                }
+            }
+        }
+    }
+    if (foreignKeys.length === 0) {
+        return null;
+    }
+    const relationsByTable = new Map();
+    const usedRelationNames = new Map();
+    for (const fk of foreignKeys) {
+        const fromTableName = camelCase ? toCamelCase(fk.fromTable) : fk.fromTable;
+        const toTableName = camelCase ? toCamelCase(fk.toTable) : fk.toTable;
+        const fromColName = camelCase ? toCamelCase(fk.fromColumn) : fk.fromColumn;
+        const toColName = camelCase ? toCamelCase(fk.toColumn) : fk.toColumn;
+        const relationName = fromColName;
+        if (!usedRelationNames.has(fromTableName)) {
+            usedRelationNames.set(fromTableName, new Set());
+        }
+        const usedNames = usedRelationNames.get(fromTableName);
+        let finalRelationName = relationName;
+        let suffix = 1;
+        while (usedNames.has(finalRelationName)) {
+            finalRelationName = `${relationName}${suffix}`;
+            suffix++;
+        }
+        usedNames.add(finalRelationName);
+        const options = [];
+        if (fk.constraintName) {
+            options.push(`name: '${fk.constraintName}'`);
+        }
+        const isValidColumn = fk.toColumn &&
+            fk.toColumn.length > 0 &&
+            /^[a-zA-Z_]/.test(fk.toColumn) &&
+            fk.toColumn.toLowerCase() !== 'id';
+        if (isValidColumn) {
+            options.push(`references: t.${toColName}`);
+        }
+        if (fk.onDelete && fk.onDelete !== 'NO ACTION') {
+            options.push(`onDelete: '${fk.onDelete}'`);
+        }
+        if (fk.onUpdate && fk.onUpdate !== 'NO ACTION') {
+            options.push(`onUpdate: '${fk.onUpdate}'`);
+        }
+        if (fk.match && fk.match !== 'SIMPLE') {
+            options.push(`match: '${fk.match}'`);
+        }
+        if (fk.deferrable) {
+            options.push(`deferrable: true`);
+        }
+        if (fk.initiallyDeferred) {
+            options.push(`initiallyDeferred: true`);
+        }
+        if (fk.isComposite && fk.fromColumns && fk.toColumns) {
+            const fromCols = fk.fromColumns.map(c => `r.${fromTableName}.${camelCase ? toCamelCase(c) : c}`).join(', ');
+            const toCols = fk.toColumns.map(c => `t.${camelCase ? toCamelCase(c) : c}`).join(', ');
+            const hasName = fk.constraintName;
+            options.length = 0;
+            if (hasName) {
+                options.push(`name: '${fk.constraintName}'`);
+            }
+            options.push(`columns: [${fromCols}]`);
+            options.push(`references: [${toCols}]`);
+            if (fk.onDelete && fk.onDelete !== 'NO ACTION') {
+                options.push(`onDelete: '${fk.onDelete}'`);
+            }
+            if (fk.onUpdate && fk.onUpdate !== 'NO ACTION') {
+                options.push(`onUpdate: '${fk.onUpdate}'`);
+            }
+            if (fk.match && fk.match !== 'SIMPLE') {
+                options.push(`match: '${fk.match}'`);
+            }
+            if (fk.deferrable) {
+                options.push(`deferrable: true`);
+            }
+            if (fk.initiallyDeferred) {
+                options.push(`initiallyDeferred: true`);
+            }
+        }
+        const trackingId = generateTrackingId('f');
+        options.push(`trackingId: '${trackingId}'`);
+        const sqlComment = generateFKSQLComment(fk, camelCase);
+        if (sqlComment) {
+            options.push(`comment: '${escapeString(sqlComment)}'`);
+        }
+        let code;
+        if (options.length === 0) {
+            code = `${finalRelationName}: r.referenceTo.${toTableName}(t => ({}))`;
+        }
+        else {
+            const optionsStr = options.join(',\n            ');
+            code = `${finalRelationName}: r.referenceTo.${toTableName}(t => ({
+            ${optionsStr},
+        }))`;
+        }
+        if (!relationsByTable.has(fromTableName)) {
+            relationsByTable.set(fromTableName, []);
+        }
+        relationsByTable.get(fromTableName).push({ relationName: finalRelationName, code });
+    }
+    const lines = [];
+    const tableNames = new Set(schema.tables.map(t => camelCase ? toCamelCase(t.name) : t.name));
+    let relationsExportName = 'relations';
+    if (tableNames.has('relations')) {
+        if (!tableNames.has('dbRelations')) {
+            relationsExportName = 'dbRelations';
+        }
+        else if (!tableNames.has('fdbRelations')) {
+            relationsExportName = 'fdbRelations';
+        }
+        else {
+            relationsExportName = '_relqRelations';
+        }
+    }
+    lines.push(`export const ${relationsExportName} = pgRelations(schema, (tables) => ({`);
+    const sortedTables = [...relationsByTable.keys()].sort();
+    for (const tableName of sortedTables) {
+        const tableRelations = relationsByTable.get(tableName);
+        lines.push(`    ${tableName}: tables.${tableName}((r) => ({`);
+        for (const rel of tableRelations) {
+            lines.push(`        ${rel.code},`);
+        }
+        lines.push('    })),');
+    }
+    lines.push('}));');
+    return lines.join('\n');
+}
+function generateFKSQLComment(fk, camelCase) {
+    const parts = [];
+    const isValidCol = (col) => col && col.length > 0 && /^[a-zA-Z_]/.test(col);
+    if (fk.isComposite && fk.fromColumns) {
+        const validToCols = fk.toColumns?.filter(isValidCol);
+        if (validToCols && validToCols.length > 0) {
+            parts.push(`(${fk.fromColumns.join(', ')}) → ${fk.toTable}(${validToCols.join(', ')})`);
+        }
+        else {
+            parts.push(`(${fk.fromColumns.join(', ')}) → ${fk.toTable}`);
+        }
+    }
+    else {
+        const targetCol = isValidCol(fk.toColumn) && fk.toColumn.toLowerCase() !== 'id'
+            ? `(${fk.toColumn})`
+            : '';
+        parts.push(`→ ${fk.toTable}${targetCol}`);
+    }
+    if (fk.onDelete && fk.onDelete !== 'NO ACTION') {
+        parts.push(`ON DELETE ${fk.onDelete}`);
+    }
+    if (fk.onUpdate && fk.onUpdate !== 'NO ACTION') {
+        parts.push(`ON UPDATE ${fk.onUpdate}`);
+    }
+    if (fk.match && fk.match !== 'SIMPLE') {
+        parts.push(`MATCH ${fk.match}`);
+    }
+    if (fk.deferrable) {
+        parts.push(fk.initiallyDeferred ? 'DEFERRABLE INITIALLY DEFERRED' : 'DEFERRABLE');
+    }
+    return parts.join(' | ');
+}