relq 1.0.26 → 1.0.28

package/dist/cjs/cli/commands/export.cjs

@@ -265,6 +265,7 @@ function normalizedToDbSchema(normalized) {
             tableName: t.table,
             event: t.events.join(' OR '),
             timing: t.timing,
+            forEach: t.forEach || 'ROW',
             functionName: t.functionName,
             definition: '',
             isEnabled: t.isEnabled !== false,

package/dist/cjs/cli/commands/import.cjs

@@ -242,6 +242,31 @@ async function importCommand(sqlFilePath, options = {}, projectRoot = process.cw
         return;
     }
     spinner.start('Generating TypeScript schema');
+    const outputPath = options.output || (0, config_loader_1.getSchemaPath)(config);
+    const absoluteOutputPath = path.resolve(projectRoot, outputPath);
+    const schemaExists = fs.existsSync(absoluteOutputPath);
+    if (schemaExists && (includeFunctions || includeTriggers)) {
+        const existingContent = fs.readFileSync(absoluteOutputPath, 'utf-8');
+        const hasPgFunction = /\bpgFunction\s*\(/.test(existingContent);
+        const hasPgTrigger = /\bpgTrigger\s*\(/.test(existingContent);
+        if (hasPgFunction || hasPgTrigger) {
+            spinner.stop();
+            const items = [];
+            if (hasPgFunction)
+                items.push('pgFunction');
+            if (hasPgTrigger)
+                items.push('pgTrigger');
+            const schemaBaseName = path.basename(absoluteOutputPath, '.ts');
+            (0, git_utils_1.fatal)(`Existing schema contains ${items.join(' and ')} definitions`, `Functions and triggers should be in separate files:\n` +
+                `  ${git_utils_1.colors.cyan(`${schemaBaseName}.functions.ts`)} - for functions\n` +
+                `  ${git_utils_1.colors.cyan(`${schemaBaseName}.triggers.ts`)} - for triggers\n\n` +
+                `To migrate:\n` +
+                `  1. Move pgFunction definitions to ${schemaBaseName}.functions.ts\n` +
+                `  2. Move pgTrigger definitions to ${schemaBaseName}.triggers.ts\n` +
+                `  3. Run ${git_utils_1.colors.cyan('relq import')} again\n\n` +
+                `Or use ${git_utils_1.colors.cyan('relq import --force')} to overwrite and regenerate all files.`);
+        }
+    }
     spinner.succeed('Generated TypeScript schema');
     const incomingSchema = convertToNormalizedSchema(filteredSchema, filteredFunctions, triggers);
     const existingSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
@@ -389,10 +414,11 @@ async function importCommand(sqlFilePath, options = {}, projectRoot = process.cw
             when: t.when,
         })) : [],
     });
+    (0, ast_codegen_1.assignTrackingIds)(astSchema);
     const finalTypescriptContent = (0, ast_codegen_1.generateTypeScriptFromAST)(astSchema, {
         camelCase: true,
-        includeFunctions,
-        includeTriggers,
+        includeFunctions: false,
+        includeTriggers: false,
     });
     if (dryRun) {
         console.log('');
@@ -409,14 +435,39 @@ async function importCommand(sqlFilePath, options = {}, projectRoot = process.cw
         console.log('');
         return;
     }
-    const outputPath = options.output || (0, config_loader_1.getSchemaPath)(config);
-    const absoluteOutputPath = path.resolve(projectRoot, outputPath);
     const outputDir = path.dirname(absoluteOutputPath);
     if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
     fs.writeFileSync(absoluteOutputPath, finalTypescriptContent, 'utf-8');
     console.log(`Written ${git_utils_1.colors.cyan(absoluteOutputPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(finalTypescriptContent.length)})`)}`);
+    if (includeFunctions && astSchema.functions.length > 0) {
+        const schemaBaseName = path.basename(absoluteOutputPath, '.ts');
+        const functionsPath = path.join(outputDir, `${schemaBaseName}.functions.ts`);
+        const functionsCode = (0, ast_codegen_1.generateFunctionsFile)(astSchema, {
+            camelCase: true,
+            importPath: 'relq/schema-builder',
+            schemaImportPath: `./${schemaBaseName}`,
+        });
+        if (functionsCode) {
+            fs.writeFileSync(functionsPath, functionsCode, 'utf-8');
+            console.log(`Written ${git_utils_1.colors.cyan(functionsPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(functionsCode.length)})`)}`);
+        }
+    }
+    if (includeTriggers && astSchema.triggers.length > 0) {
+        const schemaBaseName = path.basename(absoluteOutputPath, '.ts');
+        const triggersPath = path.join(outputDir, `${schemaBaseName}.triggers.ts`);
+        const triggersCode = (0, ast_codegen_1.generateTriggersFile)(astSchema, {
+            camelCase: true,
+            importPath: 'relq/schema-builder',
+            schemaImportPath: `./${schemaBaseName}`,
+            functionsImportPath: `./${schemaBaseName}.functions`,
+        });
+        if (triggersCode) {
+            fs.writeFileSync(triggersPath, triggersCode, 'utf-8');
+            console.log(`Written ${git_utils_1.colors.cyan(triggersPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(triggersCode.length)})`)}`);
+        }
+    }
     applyTrackingIdsToSnapshot(finalTypescriptContent, mergedSchema);
     (0, repo_manager_1.saveSnapshot)(mergedSchema, projectRoot);
     if (changes.length > 0) {
@@ -660,7 +711,7 @@ function convertToNormalizedSchema(parsed, functions = [], triggers = []) {
             table: t.tableName,
             events: [t.event],
             timing: t.timing,
-            forEach: 'STATEMENT',
+            forEach: (t.forEach || 'ROW'),
             functionName: t.functionName || '',
         })),
         views: regularViews.map(v => ({
@@ -742,6 +793,7 @@ function snapshotToDbSchema(snapshot) {
             tableName: t.table,
             timing: t.timing,
             event: t.events?.[0] || '',
+            forEach: (t.forEach || 'ROW'),
             functionName: t.functionName || '',
             definition: '',
             isEnabled: t.isEnabled ?? true,
@@ -845,6 +897,7 @@ function snapshotToDbSchemaForGeneration(snapshot) {
             tableName: t.table,
             timing: t.timing,
             event: t.events?.[0] || '',
+            forEach: (t.forEach || 'ROW'),
             functionName: t.functionName || '',
             definition: '',
             isEnabled: t.isEnabled ?? true,

package/dist/cjs/cli/commands/pull.cjs

@@ -375,10 +375,154 @@ async function pullCommand(context) {
             (0, cli_utils_1.fatal)('You have unresolved merge conflicts', `Use ${cli_utils_1.colors.cyan('relq resolve')} to see and resolve conflicts\nOr use ${cli_utils_1.colors.cyan('relq pull --force')} to overwrite local`);
         }
         if (schemaExists && localSnapshot && !force) {
-            const localTables = new Set(localSnapshot.tables.map(t => t.name));
-            const remoteTables = new Set(currentSchema.tables.map(t => t.name));
-            const added = [...remoteTables].filter(t => !localTables.has(t));
-            const removed = [...localTables].filter(t => !remoteTables.has(t));
+            const localForCompare = {
+                extensions: localSnapshot.extensions?.map(e => e.name) || [],
+                enums: localSnapshot.enums || [],
+                domains: localSnapshot.domains?.map(d => ({
+                    name: d.name,
+                    baseType: d.baseType,
+                    isNotNull: d.notNull,
+                    defaultValue: d.default,
+                    checkExpression: d.check,
+                })) || [],
+                compositeTypes: localSnapshot.compositeTypes || [],
+                sequences: localSnapshot.sequences || [],
+                tables: localSnapshot.tables.map(t => ({
+                    name: t.name,
+                    schema: t.schema,
+                    columns: t.columns.map(c => ({
+                        name: c.name,
+                        dataType: c.type,
+                        isNullable: c.nullable,
+                        defaultValue: c.default,
+                        isPrimaryKey: c.primaryKey,
+                        isUnique: c.unique,
+                        comment: c.comment,
+                    })),
+                    indexes: t.indexes.map(i => ({
+                        name: i.name,
+                        columns: i.columns,
+                        isUnique: i.unique,
+                        type: i.type,
+                        comment: i.comment,
+                    })),
+                    constraints: t.constraints || [],
+                    isPartitioned: t.isPartitioned,
+                    partitionType: t.partitionType,
+                    partitionKey: t.partitionKey,
+                    comment: t.comment,
+                })),
+                functions: localSnapshot.functions || [],
+                triggers: localSnapshot.triggers || [],
+            };
+            const remoteForCompare = {
+                extensions: dbSchema.extensions || [],
+                enums: filteredEnums || [],
+                domains: filteredDomains?.map(d => ({
+                    name: d.name,
+                    baseType: d.baseType,
+                    isNotNull: d.isNotNull,
+                    defaultValue: d.defaultValue,
+                    checkExpression: d.checkExpression,
+                })) || [],
+                compositeTypes: filteredCompositeTypes || [],
+                sequences: [],
+                tables: filteredTables.map(t => ({
+                    name: t.name,
+                    schema: t.schema,
+                    columns: t.columns.map(c => ({
+                        name: c.name,
+                        dataType: c.dataType,
+                        isNullable: c.isNullable,
+                        defaultValue: c.defaultValue,
+                        isPrimaryKey: c.isPrimaryKey,
+                        isUnique: c.isUnique,
+                        comment: c.comment,
+                    })),
+                    indexes: t.indexes.map(i => ({
+                        name: i.name,
+                        columns: i.columns,
+                        isUnique: i.isUnique,
+                        type: i.type,
+                        comment: i.comment,
+                    })),
+                    constraints: t.constraints || [],
+                    isPartitioned: t.isPartitioned,
+                    partitionType: t.partitionType,
+                    partitionKey: t.partitionKey,
+                    comment: t.comment,
+                })),
+                functions: filteredFunctions || [],
+                triggers: filteredTriggers || [],
+            };
+            const allChanges = (0, schema_comparator_1.compareSchemas)(localForCompare, remoteForCompare);
+            const changeDisplays = [];
+            for (const change of allChanges) {
+                const objType = change.objectType;
+                const changeType = change.type;
+                let action;
+                if (changeType === 'CREATE')
+                    action = 'added';
+                else if (changeType === 'DROP')
+                    action = 'removed';
+                else
+                    action = 'modified';
+                let type;
+                let name;
+                if (objType === 'TABLE') {
+                    type = 'table';
+                    name = change.objectName;
+                }
+                else if (objType === 'COLUMN') {
+                    type = 'column';
+                    name = change.parentName ? `${change.parentName}.${change.objectName}` : change.objectName;
+                }
+                else if (objType === 'INDEX') {
+                    type = 'index';
+                    name = change.parentName ? `${change.parentName}:${change.objectName}` : change.objectName;
+                }
+                else if (objType === 'COLUMN_COMMENT') {
+                    type = 'column comment';
+                    const colName = change.after?.columnName || change.before?.columnName || change.objectName;
+                    const tblName = change.after?.tableName || change.before?.tableName || change.parentName;
+                    name = tblName ? `${tblName}.${colName}` : colName;
+                }
+                else if (objType === 'TABLE_COMMENT') {
+                    type = 'table comment';
+                    name = change.after?.tableName || change.before?.tableName || change.objectName;
+                }
+                else if (objType === 'INDEX_COMMENT') {
+                    type = 'index comment';
+                    const idxName = change.after?.indexName || change.before?.indexName || change.objectName;
+                    const tblName = change.after?.tableName || change.before?.tableName || change.parentName;
+                    name = tblName ? `${tblName}:${idxName}` : idxName;
+                }
+                else if (objType === 'CONSTRAINT' || objType === 'FOREIGN_KEY' || objType === 'PRIMARY_KEY' || objType === 'CHECK') {
+                    type = objType.toLowerCase().replace(/_/g, ' ');
+                    name = change.parentName ? `${change.parentName}::${change.objectName}` : change.objectName;
+                }
+                else if (objType === 'ENUM') {
+                    type = 'enum';
+                    name = change.objectName;
+                }
+                else if (objType === 'DOMAIN') {
+                    type = 'domain';
+                    name = change.objectName;
+                }
+                else if (objType === 'FUNCTION') {
+                    type = 'function';
+                    name = change.objectName;
+                }
+                else if (objType === 'TRIGGER') {
+                    type = 'trigger';
+                    name = change.objectName;
+                }
+                else {
+                    type = objType.toLowerCase().replace(/_/g, ' ');
+                    name = change.objectName;
+                }
+                changeDisplays.push({ action, type, name });
+            }
             const conflicts = detectObjectConflicts(localSnapshot, currentSchema);
             if (conflicts.length > 0 && !force) {
                 const mergeState = {
@@ -400,17 +544,27 @@ async function pullCommand(context) {
                 }
                 (0, cli_utils_1.fatal)('Automatic merge failed; fix conflicts and then commit', `${cli_utils_1.colors.cyan('relq resolve --theirs <name>')}  Take remote version\n${cli_utils_1.colors.cyan('relq resolve --all-theirs')}     Take all remote\n${cli_utils_1.colors.cyan('relq pull --force')}             Force overwrite local`);
             }
-            if (added.length === 0 && removed.length === 0) {
+            if (allChanges.length === 0) {
                 console.log('Already up to date with remote');
                 console.log('');
                 return;
             }
             console.log(`${cli_utils_1.colors.yellow('Remote has changes:')}`);
-            if (added.length > 0) {
-                console.log(`   ${cli_utils_1.colors.green(`+${added.length}`)} tables added`);
+            for (const chg of changeDisplays.slice(0, 15)) {
+                let colorFn = cli_utils_1.colors.cyan;
+                let prefix = '~';
+                if (chg.action === 'added') {
+                    colorFn = cli_utils_1.colors.green;
+                    prefix = '+';
+                }
+                else if (chg.action === 'removed') {
+                    colorFn = cli_utils_1.colors.red;
+                    prefix = '-';
+                }
+                console.log(`   ${colorFn(prefix)} ${chg.type}: ${cli_utils_1.colors.bold(chg.name)}`);
             }
-            if (removed.length > 0) {
-                console.log(`   ${cli_utils_1.colors.red(`-${removed.length}`)} tables removed`);
+            if (changeDisplays.length > 15) {
+                console.log(`   ${cli_utils_1.colors.muted(`... and ${changeDisplays.length - 15} more`)}`);
             }
             console.log('');
             const noAutoMerge = flags['no-auto-merge'] === true;
@@ -484,12 +638,35 @@ async function pullCommand(context) {
             console.log('');
             return;
         }
+        if (schemaExists && (includeFunctions || includeTriggers)) {
+            const existingContent = fs.readFileSync(schemaPath, 'utf-8');
+            const hasPgFunction = /\bpgFunction\s*\(/.test(existingContent);
+            const hasPgTrigger = /\bpgTrigger\s*\(/.test(existingContent);
+            if (hasPgFunction || hasPgTrigger) {
+                const items = [];
+                if (hasPgFunction)
+                    items.push('pgFunction');
+                if (hasPgTrigger)
+                    items.push('pgTrigger');
+                const schemaBaseName = path.basename(schemaPath, '.ts');
+                (0, cli_utils_1.fatal)(`Existing schema contains ${items.join(' and ')} definitions`, `Functions and triggers should be in separate files:\n` +
+                    `  ${cli_utils_1.colors.cyan(`${schemaBaseName}.functions.ts`)} - for functions\n` +
+                    `  ${cli_utils_1.colors.cyan(`${schemaBaseName}.triggers.ts`)} - for triggers\n\n` +
+                    `To migrate:\n` +
+                    `  1. Move pgFunction definitions to ${schemaBaseName}.functions.ts\n` +
+                    `  2. Move pgTrigger definitions to ${schemaBaseName}.triggers.ts\n` +
+                    `  3. Run ${cli_utils_1.colors.cyan('relq pull')} again\n\n` +
+                    `Or use ${cli_utils_1.colors.cyan('relq pull --force')} to overwrite and regenerate all files.`);
+            }
+        }
         spinner.start('Generating TypeScript schema...');
         const parsedSchema = await (0, ast_transformer_1.introspectedToParsedSchema)(dbSchema);
         (0, ast_codegen_1.assignTrackingIds)(parsedSchema);
         const typescript = (0, ast_codegen_1.generateTypeScriptFromAST)(parsedSchema, {
             camelCase: config.generate?.camelCase ?? true,
             importPath: 'relq/schema-builder',
+            includeFunctions: false,
+            includeTriggers: false,
         });
         spinner.succeed('Generated TypeScript schema');
         const schemaDir = path.dirname(schemaPath);
@@ -502,6 +679,35 @@ async function pullCommand(context) {
         spinner.succeed(`Written ${cli_utils_1.colors.cyan(schemaPath)} ${cli_utils_1.colors.muted(`(${(0, cli_utils_1.formatBytes)(fileSize)})`)}`);
         const fileHash = (0, repo_manager_1.hashFileContent)(typescript);
         (0, repo_manager_1.saveFileHash)(fileHash, projectRoot);
+        if (includeFunctions && parsedSchema.functions.length > 0) {
+            const schemaBaseName = path.basename(schemaPath, '.ts');
+            const functionsPath = path.join(schemaDir, `${schemaBaseName}.functions.ts`);
+            const functionsCode = (0, ast_codegen_1.generateFunctionsFile)(parsedSchema, {
+                camelCase: config.generate?.camelCase ?? true,
+                importPath: 'relq/schema-builder',
+                schemaImportPath: `./${schemaBaseName}`,
+            });
+            if (functionsCode) {
+                fs.writeFileSync(functionsPath, functionsCode, 'utf-8');
+                const funcFileSize = Buffer.byteLength(functionsCode, 'utf8');
+                spinner.succeed(`Written ${cli_utils_1.colors.cyan(functionsPath)} ${cli_utils_1.colors.muted(`(${(0, cli_utils_1.formatBytes)(funcFileSize)})`)}`);
+            }
+        }
+        if (includeTriggers && parsedSchema.triggers.length > 0) {
+            const schemaBaseName = path.basename(schemaPath, '.ts');
+            const triggersPath = path.join(schemaDir, `${schemaBaseName}.triggers.ts`);
+            const triggersCode = (0, ast_codegen_1.generateTriggersFile)(parsedSchema, {
+                camelCase: config.generate?.camelCase ?? true,
+                importPath: 'relq/schema-builder',
+                schemaImportPath: `./${schemaBaseName}`,
+                functionsImportPath: `./${schemaBaseName}.functions`,
+            });
+            if (triggersCode) {
+                fs.writeFileSync(triggersPath, triggersCode, 'utf-8');
+                const trigFileSize = Buffer.byteLength(triggersCode, 'utf8');
+                spinner.succeed(`Written ${cli_utils_1.colors.cyan(triggersPath)} ${cli_utils_1.colors.muted(`(${(0, cli_utils_1.formatBytes)(trigFileSize)})`)}`);
+            }
+        }
         const oldSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
         const beforeSchema = oldSnapshot ? {
             extensions: oldSnapshot.extensions?.map(e => e.name) || [],

package/dist/cjs/cli/commands/sync.cjs

@@ -16,7 +16,10 @@ async function syncCommand(context) {
     const { projectRoot } = context;
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
-        (0, cli_utils_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${cli_utils_1.colors.cyan('relq init')} to initialize.`);
+        console.log(`${cli_utils_1.colors.yellow('Initializing')} .relq repository...`);
+        (0, repo_manager_1.initRepository)(projectRoot);
+        console.log(`${cli_utils_1.colors.green('✓')} Repository initialized`);
+        console.log('');
     }
     const spinner = (0, cli_utils_1.createSpinner)();
     try {

package/dist/cjs/cli/utils/ast-codegen.cjs

@@ -4,7 +4,10 @@ exports.resetTrackingIdCounter = resetTrackingIdCounter;
 exports.assignTrackingIds = assignTrackingIds;
 exports.copyTrackingIdsToNormalized = copyTrackingIdsToNormalized;
 exports.generateTypeScriptFromAST = generateTypeScriptFromAST;
+exports.generateFunctionsFile = generateFunctionsFile;
+exports.generateTriggersFile = generateTriggersFile;
 const utils_1 = require("./ast/codegen/utils.cjs");
+const sql_formatter_1 = require("sql-formatter");
 const builder_1 = require("./ast/codegen/builder.cjs");
 const type_map_1 = require("./ast/codegen/type-map.cjs");
 const defaults_1 = require("./ast/codegen/defaults.cjs");
@@ -552,16 +555,17 @@ function generateSequenceCode(seq, useCamelCase) {
     const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
     return `export const ${seqName} = pgSequence('${seq.name}'${optsStr})`;
 }
-function generateFunctionCode(func, useCamelCase) {
-    const funcName = useCamelCase ? (0, utils_1.toCamelCase)(func.name) : func.name;
+function generateFunctionCode(func, useCamelCase, varNameOverride) {
+    const funcName = varNameOverride || (useCamelCase ? (0, utils_1.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)
+        const argsStr = func.args.map((arg, index) => {
+            const argParts = [];
+            const argName = arg.name || `$${index + 1}`;
+            argParts.push(`name: '${argName}'`);
+            argParts.push(`type: '${arg.type}'`);
+            if (arg.mode && arg.mode !== 'IN')
                 argParts.push(`mode: '${arg.mode}'`);
             if (arg.default)
                 argParts.push(`default: '${(0, utils_1.escapeString)(arg.default)}'`);
@@ -571,8 +575,26 @@ function generateFunctionCode(func, useCamelCase) {
     }
     parts.push(`    returns: '${func.returnType}',`);
     parts.push(`    language: '${func.language}',`);
-    const escapedBody = func.body.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
-    parts.push(`    body: \`${escapedBody}\`,`);
+    let formattedBody = func.body;
+    const lang = func.language?.toLowerCase();
+    if (func.body && (lang === 'plpgsql' || lang === 'sql')) {
+        try {
+            formattedBody = (0, sql_formatter_1.format)(func.body, {
+                language: 'postgresql',
+                tabWidth: 4,
+                keywordCase: 'upper',
+            });
+        }
+        catch {
+            formattedBody = func.body;
+        }
+    }
+    const escapedBody = formattedBody.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    const indentedBody = escapedBody
+        .split('\n')
+        .map(line => '        ' + line)
+        .join('\n');
+    parts.push(`    body: \`\n${indentedBody}\n    \`,`);
     if (func.volatility)
         parts.push(`    volatility: '${func.volatility}',`);
     if (func.isStrict)
@@ -580,6 +602,9 @@ function generateFunctionCode(func, useCamelCase) {
     if (func.securityDefiner)
         parts.push(`    securityDefiner: true,`);
     parts.push(`})`);
+    if (func.trackingId) {
+        parts[parts.length - 1] = parts[parts.length - 1].replace('})', `}).$id('${func.trackingId}')`);
+    }
     return parts.join('\n');
 }
 function generateViewCode(view, useCamelCase) {
@@ -1039,3 +1064,134 @@ function generateFKSQLComment(fk, camelCase) {
     }
     return parts.join(' | ');
 }
+function resolveFunctionVarName(func, usedNames, useCamelCase) {
+    const baseName = useCamelCase ? (0, utils_1.toCamelCase)(func.name) : func.name;
+    const count = usedNames.get(baseName) || 0;
+    usedNames.set(baseName, count + 1);
+    if (count === 0) {
+        return baseName;
+    }
+    return `${baseName}_${count + 1}`;
+}
+function generateFunctionsFile(schema, options = {}) {
+    const { camelCase = true, importPath = 'relq/schema-builder', schemaImportPath = './schema', } = options;
+    if (schema.functions.length === 0) {
+        return null;
+    }
+    const parts = [];
+    parts.push('/**');
+    parts.push(' * Auto-generated by Relq CLI');
+    parts.push(` * Generated at: ${new Date().toISOString()}`);
+    parts.push(' * DO NOT EDIT - changes will be overwritten');
+    parts.push(' */');
+    parts.push('');
+    parts.push(`import { pgFunction } from '${importPath}';`);
+    void schemaImportPath;
+    parts.push('');
+    const usedNames = new Map();
+    const functionVarNames = [];
+    parts.push('// =============================================================================');
+    parts.push('// FUNCTIONS');
+    parts.push('// =============================================================================');
+    parts.push('');
+    for (const func of schema.functions) {
+        const varName = resolveFunctionVarName(func, usedNames, camelCase);
+        functionVarNames.push(varName);
+        parts.push(generateFunctionCode(func, camelCase, varName));
+        parts.push('');
+    }
+    parts.push('// =============================================================================');
+    parts.push('// EXPORTS');
+    parts.push('// =============================================================================');
+    parts.push('');
+    parts.push('export const functions = {');
+    for (const name of functionVarNames) {
+        parts.push(`    ${name},`);
+    }
+    parts.push('} as const;');
+    parts.push('');
+    return parts.join('\n');
+}
+function generateTriggersFile(schema, options = {}) {
+    const { camelCase = true, importPath = 'relq/schema-builder', schemaImportPath = './schema', functionsImportPath = './schema.functions', } = options;
+    if (schema.triggers.length === 0) {
+        return null;
+    }
+    const parts = [];
+    parts.push('/**');
+    parts.push(' * Auto-generated by Relq CLI');
+    parts.push(` * Generated at: ${new Date().toISOString()}`);
+    parts.push(' * DO NOT EDIT - changes will be overwritten');
+    parts.push(' */');
+    parts.push('');
+    parts.push(`import { pgTrigger } from '${importPath}';`);
+    parts.push(`import { schema } from '${schemaImportPath}';`);
+    if (schema.functions.length > 0) {
+        parts.push(`import { functions } from '${functionsImportPath}';`);
+    }
+    parts.push('');
+    const functionNames = new Set();
+    const usedFuncNames = new Map();
+    for (const func of schema.functions) {
+        const varName = resolveFunctionVarName(func, usedFuncNames, camelCase);
+        functionNames.add(varName);
+    }
+    parts.push('// =============================================================================');
+    parts.push('// TRIGGERS');
+    parts.push('// =============================================================================');
+    parts.push('');
+    const triggerVarNames = [];
+    for (const trigger of schema.triggers) {
+        const triggerName = camelCase ? (0, utils_1.toCamelCase)(trigger.name) : trigger.name;
+        const tableName = camelCase ? (0, utils_1.toCamelCase)(trigger.table) : trigger.table;
+        triggerVarNames.push(triggerName);
+        parts.push(`export const ${triggerName} = pgTrigger('${trigger.name}', {`);
+        parts.push(`    on: schema.${tableName},`);
+        const events = trigger.events.length === 1
+            ? `'${trigger.events[0]}'`
+            : `[${trigger.events.map(e => `'${e}'`).join(', ')}]`;
+        if (trigger.timing === 'BEFORE') {
+            parts.push(`    before: ${events},`);
+        }
+        else if (trigger.timing === 'AFTER') {
+            parts.push(`    after: ${events},`);
+        }
+        else if (trigger.timing === 'INSTEAD OF') {
+            parts.push(`    insteadOf: ${events},`);
+        }
+        parts.push(`    forEach: '${trigger.forEach || 'ROW'}',`);
+        const funcVarName = camelCase ? (0, utils_1.toCamelCase)(trigger.functionName) : trigger.functionName;
+        if (functionNames.has(funcVarName)) {
+            parts.push(`    execute: functions.${funcVarName},`);
+        }
+        else {
+            parts.push(`    execute: '${trigger.functionName}',`);
+        }
+        if (trigger.whenClause)
+            parts.push(`    when: '${(0, utils_1.escapeString)(trigger.whenClause)}',`);
+        if (trigger.isConstraint)
+            parts.push(`    constraint: true,`);
+        if (trigger.deferrable)
+            parts.push(`    deferrable: true,`);
+        if (trigger.initiallyDeferred)
+            parts.push(`    initially: 'DEFERRED',`);
+        if (trigger.trackingId) {
+            parts.push(`}).$id('${trigger.trackingId}');`);
+        }
+        else {
+            parts.push(`});`);
+        }
+        parts.push('');
+    }
+    parts.push('// =============================================================================');
+    parts.push('// EXPORTS');
+    parts.push('// =============================================================================');
+    parts.push('');
+    parts.push('export const triggers = {');
+    for (const name of triggerVarNames) {
+        parts.push(`    ${name},`);
+    }
+    parts.push('} as const;');
+    parts.push('');
+    return parts.join('\n');
+}

package/dist/cjs/cli/utils/ast-transformer.cjs

@@ -708,7 +708,8 @@ async function introspectedToParsedSchema(schema) {
             args: parseArgTypes(f.argTypes),
             returnType: f.returnType,
             language: f.language,
-            body: f.definition || '',
+            body: extractFunctionBody(f.definition || ''),
+            volatility: f.volatility,
             isStrict: false,
             securityDefiner: false,
         });
@@ -719,7 +720,7 @@ async function introspectedToParsedSchema(schema) {
             table: t.tableName,
             timing: t.timing,
             events: [t.event],
-            forEach: 'STATEMENT',
+            forEach: t.forEach || 'ROW',
             functionName: t.functionName || '',
             isConstraint: false,
         });
@@ -809,6 +810,19 @@ function parseArgTypes(argTypes) {
         type: typeof arg === 'string' ? arg.trim() : String(arg),
     }));
 }
+function extractFunctionBody(definition) {
+    if (!definition)
+        return '';
+    const bodyMatch = definition.match(/AS\s+\$([a-zA-Z_]*)\$\s*([\s\S]*?)\s*\$\1\$/i);
+    if (bodyMatch) {
+        return bodyMatch[2].trim();
+    }
+    const singleQuoteMatch = definition.match(/AS\s+'([\s\S]*?)'\s*$/i);
+    if (singleQuoteMatch) {
+        return singleQuoteMatch[1].replace(/''/g, "'");
+    }
+    return '';
+}
 function normalizedToParsedSchema(schema) {
     return {
         extensions: (schema.extensions || []).map(e => typeof e === 'string' ? e : e.name),