relq 1.0.26 → 1.0.28

package/dist/cjs/cli/utils/fast-introspect.cjs

@@ -453,6 +453,10 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 JOIN pg_language l ON p.prolang = l.oid
                 WHERE n.nspname = 'public'
                     AND p.prokind IN ('f', 'a')
+                    -- Exclude C language functions (typically extension functions like pgcrypto)
+                    AND l.lanname != 'c'
+                    -- Exclude internal language functions
+                    AND l.lanname != 'internal'
                 ORDER BY p.proname;
             `);
             functions = functionsResult.rows.map(f => ({
@@ -486,6 +490,10 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                         WHEN t.tgtype & 16 > 0 THEN 'UPDATE'
                         ELSE 'UNKNOWN'
                     END as event,
+                    CASE
+                        WHEN t.tgtype & 1 > 0 THEN 'ROW'
+                        ELSE 'STATEMENT'
+                    END as for_each,
                     p.proname as function_name,
                     pg_get_triggerdef(t.oid) as definition,
                     t.tgenabled != 'D' as is_enabled
@@ -495,6 +503,11 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 JOIN pg_proc p ON t.tgfoid = p.oid
                 WHERE n.nspname = 'public'
                     AND NOT t.tgisinternal
+                    -- Exclude triggers on partition child tables
+                    AND NOT EXISTS (
+                        SELECT 1 FROM pg_inherits i
+                        WHERE i.inhrelid = c.oid
+                    )
                 ORDER BY c.relname, t.tgname;
             `);
             triggers = triggersResult.rows.map(t => ({
@@ -502,6 +515,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 tableName: t.table_name,
                 timing: t.timing,
                 event: t.event,
+                forEach: t.for_each,
                 functionName: t.function_name,
                 definition: t.definition || '',
                 isEnabled: t.is_enabled,

package/dist/cjs/cli/utils/schema-comparator.cjs

@@ -91,6 +91,30 @@ function compareDomains(before, after) {
             changes.push((0, change_tracker_1.createChange)('DROP', 'DOMAIN', name, domain, null));
         }
     }
+    for (const [name, afterDomain] of afterMap) {
+        const beforeDomain = beforeMap.get(name);
+        if (!beforeDomain)
+            continue;
+        const baseTypeChanged = beforeDomain.baseType !== afterDomain.baseType;
+        const notNullChanged = (beforeDomain.isNotNull || false) !== (afterDomain.isNotNull || false);
+        const defaultChanged = (beforeDomain.defaultValue || null) !== (afterDomain.defaultValue || null);
+        const checkChanged = (beforeDomain.checkExpression || null) !== (afterDomain.checkExpression || null);
+        if (baseTypeChanged || notNullChanged || defaultChanged || checkChanged) {
+            changes.push((0, change_tracker_1.createChange)('ALTER', 'DOMAIN', name, {
+                name: beforeDomain.name,
+                baseType: beforeDomain.baseType,
+                notNull: beforeDomain.isNotNull,
+                default: beforeDomain.defaultValue,
+                check: beforeDomain.checkExpression,
+            }, {
+                name: afterDomain.name,
+                baseType: afterDomain.baseType,
+                notNull: afterDomain.isNotNull,
+                default: afterDomain.defaultValue,
+                check: afterDomain.checkExpression,
+            }));
+        }
+    }
     return changes;
 }
 function compareCompositeTypes(before, after) {

package/dist/cjs/cli/utils/schema-introspect.cjs

@@ -286,7 +286,7 @@ async function introspectDatabase(connection, onProgress, options) {
         if (includeFunctions) {
             onProgress?.('fetching_functions');
             const functionsResult = await pool.query(`
-                SELECT 
+                SELECT
                     p.proname as name,
                     n.nspname as schema,
                     pg_get_function_result(p.oid) as return_type,
@@ -300,6 +300,17 @@ async function introspectDatabase(connection, onProgress, options) {
                 JOIN pg_language l ON p.prolang = l.oid
                 WHERE n.nspname = 'public'
                     AND p.prokind IN ('f', 'a')
+                    -- Exclude functions that belong to extensions (e.g., pgcrypto, uuid-ossp)
+                    AND NOT EXISTS (
+                        SELECT 1 FROM pg_depend d
+                        JOIN pg_extension e ON d.refobjid = e.oid
+                        WHERE d.objid = p.oid
+                        AND d.deptype = 'e'
+                    )
+                    -- Exclude C language functions (typically extension functions)
+                    AND l.lanname != 'c'
+                    -- Exclude internal language functions
+                    AND l.lanname != 'internal'
                 ORDER BY p.proname;
             `);
             functions = functionsResult.rows.map(f => ({
@@ -316,20 +327,24 @@ async function introspectDatabase(connection, onProgress, options) {
         let triggers = [];
         if (includeTriggers) {
             const triggersResult = await pool.query(`
-                SELECT 
+                SELECT
                     t.tgname as name,
                     c.relname as table_name,
-                    CASE 
+                    CASE
                         WHEN t.tgtype & 2 > 0 THEN 'BEFORE'
                         WHEN t.tgtype & 64 > 0 THEN 'INSTEAD OF'
                         ELSE 'AFTER'
                     END as timing,
-                    CASE 
+                    CASE
                         WHEN t.tgtype & 4 > 0 THEN 'INSERT'
                         WHEN t.tgtype & 8 > 0 THEN 'DELETE'
                         WHEN t.tgtype & 16 > 0 THEN 'UPDATE'
                         ELSE 'UNKNOWN'
                     END as event,
+                    CASE
+                        WHEN t.tgtype & 1 > 0 THEN 'ROW'
+                        ELSE 'STATEMENT'
+                    END as for_each,
                     p.proname as function_name,
                     pg_get_triggerdef(t.oid) as definition,
                     t.tgenabled != 'D' as is_enabled
@@ -339,6 +354,11 @@ async function introspectDatabase(connection, onProgress, options) {
                 JOIN pg_proc p ON t.tgfoid = p.oid
                 WHERE n.nspname = 'public'
                     AND NOT t.tgisinternal
+                    -- Exclude triggers on partition child tables (only show on parent)
+                    AND NOT EXISTS (
+                        SELECT 1 FROM pg_inherits i
+                        WHERE i.inhrelid = c.oid
+                    )
                 ORDER BY c.relname, t.tgname;
             `);
             triggers = triggersResult.rows.map(t => ({
@@ -346,6 +366,7 @@ async function introspectDatabase(connection, onProgress, options) {
                 tableName: t.table_name,
                 timing: t.timing,
                 event: t.event,
+                forEach: t.for_each,
                 functionName: t.function_name,
                 definition: t.definition || '',
                 isEnabled: t.is_enabled,

package/dist/cjs/cli/utils/sql-parser.cjs

@@ -868,7 +868,9 @@ function parseTriggers(sql) {
         const tableMatch = body.match(/\bON\s+(\w+)/i);
         const tableName = tableMatch ? tableMatch[1] : '';
         const forEachMatch = body.match(/FOR\s+EACH\s+(ROW|STATEMENT)/i);
-        const forEach = forEachMatch ? forEachMatch[1].toUpperCase() : 'STATEMENT';
+        const forEach = forEachMatch
+            ? forEachMatch[1].toUpperCase()
+            : 'ROW';
         const whenMatch = body.match(/WHEN\s*\((.+?)\)\s*(?:EXECUTE|$)/is);
         const condition = whenMatch ? whenMatch[1].trim() : undefined;
         const refOldMatch = body.match(/REFERENCING\s+.*?OLD\s+TABLE\s+AS\s+(\w+)/i);
@@ -884,6 +886,7 @@ function parseTriggers(sql) {
                 tableName,
                 timing,
                 event: events[0] || 'INSERT',
+                forEach,
                 functionName,
                 definition: match[0],
                 isEnabled: true,

package/dist/cjs/config/config.cjs

@@ -198,5 +198,8 @@ function validateConfig(config) {
             errors.push('Pool max must be at least 1');
         }
     }
+    if (config.includeTriggers && !config.includeFunctions) {
+        errors.push('Triggers require functions to be enabled. Set includeFunctions: true in your config.');
+    }
     return { valid: errors.length === 0, errors };
 }

package/dist/cjs/schema-definition/pg-function.cjs

@@ -100,6 +100,10 @@ function pgFunction(name, options) {
                 trackingId: this.$trackingId,
             };
         },
+        $id(trackingId) {
+            this.$trackingId = trackingId;
+            return this;
+        },
     };
 }
 function isFunctionConfig(value) {

package/dist/cjs/schema-definition/pg-trigger.cjs

@@ -26,7 +26,7 @@ function getFunctionName(func) {
 }
 function generateTriggerSQL(config) {
     const { $triggerName, $options } = config;
-    const { on, before, after, insteadOf, updateOf, forEachRow = true, forEachStatement, when, referencing, constraint, deferrable, initially, execute, executeArgs, } = $options;
+    const { on, before, after, insteadOf, updateOf, forEach = 'ROW', when, referencing, constraint, deferrable, initially, execute, executeArgs, } = $options;
     const parts = ['CREATE'];
     if (constraint) {
         parts.push('CONSTRAINT');
@@ -74,10 +74,10 @@ function generateTriggerSQL(config) {
         }
         parts.push(refParts.join(' '));
     }
-    if (forEachStatement) {
+    if (forEach === 'STATEMENT') {
         parts.push('\n    FOR EACH STATEMENT');
     }
-    else if (forEachRow !== false) {
+    else {
         parts.push('\n    FOR EACH ROW');
     }
     if (when) {
@@ -119,7 +119,7 @@ function pgTrigger(name, options) {
                 timing = 'BEFORE';
                 events = ['INSERT'];
             }
-            const forEach = opts.forEachStatement ? 'STATEMENT' : 'ROW';
+            const forEachLevel = opts.forEach || 'ROW';
             const functionName = typeof opts.execute === 'string'
                 ? opts.execute
                 : opts.execute.$functionName;
@@ -128,7 +128,7 @@ function pgTrigger(name, options) {
                 table: getTableName(opts.on),
                 timing,
                 events,
-                forEach,
+                forEach: forEachLevel,
                 functionName,
                 whenClause: opts.when,
                 isConstraint: opts.constraint ?? false,
@@ -137,6 +137,10 @@ function pgTrigger(name, options) {
                 trackingId: this.$trackingId,
             };
         },
+        $id(trackingId) {
+            this.$trackingId = trackingId;
+            return this;
+        },
     };
 }
 function isTriggerConfig(value) {

package/dist/esm/cli/commands/export.js

@@ -229,6 +229,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/esm/cli/commands/import.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { parseFunctions, parseTriggers, parseComments } from "../utils/sql-parser.js";
-import { generateTypeScriptFromAST } from "../utils/ast-codegen.js";
+import { generateTypeScriptFromAST, assignTrackingIds, generateFunctionsFile, generateTriggersFile } from "../utils/ast-codegen.js";
 import { parseSQL, normalizedToParsedSchema } from "../utils/ast-transformer.js";
 import { saveSnapshot, loadSnapshot, isInitialized, initRepository, stageChanges, addUnstagedChanges } from "../utils/repo-manager.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
@@ -206,6 +206,31 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         return;
     }
     spinner.start('Generating TypeScript schema');
+    const outputPath = options.output || 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');
+            fatal(`Existing schema contains ${items.join(' and ')} definitions`, `Functions and triggers should be in separate files:\n` +
+                `  ${colors.cyan(`${schemaBaseName}.functions.ts`)} - for functions\n` +
+                `  ${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 ${colors.cyan('relq import')} again\n\n` +
+                `Or use ${colors.cyan('relq import --force')} to overwrite and regenerate all files.`);
+        }
+    }
     spinner.succeed('Generated TypeScript schema');
     const incomingSchema = convertToNormalizedSchema(filteredSchema, filteredFunctions, triggers);
     const existingSnapshot = loadSnapshot(projectRoot);
@@ -353,10 +378,11 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
             when: t.when,
         })) : [],
     });
+    assignTrackingIds(astSchema);
     const finalTypescriptContent = generateTypeScriptFromAST(astSchema, {
         camelCase: true,
-        includeFunctions,
-        includeTriggers,
+        includeFunctions: false,
+        includeTriggers: false,
     });
     if (dryRun) {
         console.log('');
@@ -373,14 +399,39 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         console.log('');
         return;
     }
-    const outputPath = options.output || 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 ${colors.cyan(absoluteOutputPath)} ${colors.gray(`(${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 = generateFunctionsFile(astSchema, {
+            camelCase: true,
+            importPath: 'relq/schema-builder',
+            schemaImportPath: `./${schemaBaseName}`,
+        });
+        if (functionsCode) {
+            fs.writeFileSync(functionsPath, functionsCode, 'utf-8');
+            console.log(`Written ${colors.cyan(functionsPath)} ${colors.gray(`(${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 = generateTriggersFile(astSchema, {
+            camelCase: true,
+            importPath: 'relq/schema-builder',
+            schemaImportPath: `./${schemaBaseName}`,
+            functionsImportPath: `./${schemaBaseName}.functions`,
+        });
+        if (triggersCode) {
+            fs.writeFileSync(triggersPath, triggersCode, 'utf-8');
+            console.log(`Written ${colors.cyan(triggersPath)} ${colors.gray(`(${formatBytes(triggersCode.length)})`)}`);
+        }
+    }
     applyTrackingIdsToSnapshot(finalTypescriptContent, mergedSchema);
     saveSnapshot(mergedSchema, projectRoot);
     if (changes.length > 0) {
@@ -624,7 +675,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 => ({
@@ -706,6 +757,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,
@@ -809,6 +861,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/esm/cli/commands/pull.js

@@ -3,7 +3,7 @@ import * as path from 'path';
 import { requireValidConfig, getSchemaPath } from "../utils/config-loader.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { introspectedToParsedSchema } from "../utils/ast-transformer.js";
-import { generateTypeScriptFromAST, assignTrackingIds, copyTrackingIdsToNormalized } from "../utils/ast-codegen.js";
+import { generateTypeScriptFromAST, assignTrackingIds, copyTrackingIdsToNormalized, generateFunctionsFile, generateTriggersFile } from "../utils/ast-codegen.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
 import { createSpinner, colors, formatBytes, formatDuration, fatal, confirm, warning, createMultiProgress } from "../utils/cli-utils.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
@@ -339,10 +339,154 @@ export async function pullCommand(context) {
             fatal('You have unresolved merge conflicts', `Use ${colors.cyan('relq resolve')} to see and resolve conflicts\nOr use ${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 = 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 = {
@@ -364,17 +508,27 @@ export async function pullCommand(context) {
                 }
                 fatal('Automatic merge failed; fix conflicts and then commit', `${colors.cyan('relq resolve --theirs <name>')}  Take remote version\n${colors.cyan('relq resolve --all-theirs')}     Take all remote\n${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(`${colors.yellow('Remote has changes:')}`);
-            if (added.length > 0) {
-                console.log(`   ${colors.green(`+${added.length}`)} tables added`);
+            for (const chg of changeDisplays.slice(0, 15)) {
+                let colorFn = colors.cyan;
+                let prefix = '~';
+                if (chg.action === 'added') {
+                    colorFn = colors.green;
+                    prefix = '+';
+                }
+                else if (chg.action === 'removed') {
+                    colorFn = colors.red;
+                    prefix = '-';
+                }
+                console.log(`   ${colorFn(prefix)} ${chg.type}: ${colors.bold(chg.name)}`);
             }
-            if (removed.length > 0) {
-                console.log(`   ${colors.red(`-${removed.length}`)} tables removed`);
+            if (changeDisplays.length > 15) {
+                console.log(`   ${colors.muted(`... and ${changeDisplays.length - 15} more`)}`);
             }
             console.log('');
             const noAutoMerge = flags['no-auto-merge'] === true;
@@ -448,12 +602,35 @@ export 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');
+                fatal(`Existing schema contains ${items.join(' and ')} definitions`, `Functions and triggers should be in separate files:\n` +
+                    `  ${colors.cyan(`${schemaBaseName}.functions.ts`)} - for functions\n` +
+                    `  ${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 ${colors.cyan('relq pull')} again\n\n` +
+                    `Or use ${colors.cyan('relq pull --force')} to overwrite and regenerate all files.`);
+            }
+        }
         spinner.start('Generating TypeScript schema...');
         const parsedSchema = await introspectedToParsedSchema(dbSchema);
         assignTrackingIds(parsedSchema);
         const typescript = 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);
@@ -466,6 +643,35 @@ export async function pullCommand(context) {
         spinner.succeed(`Written ${colors.cyan(schemaPath)} ${colors.muted(`(${formatBytes(fileSize)})`)}`);
         const fileHash = hashFileContent(typescript);
         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 = 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 ${colors.cyan(functionsPath)} ${colors.muted(`(${formatBytes(funcFileSize)})`)}`);
+            }
+        }
+        if (includeTriggers && parsedSchema.triggers.length > 0) {
+            const schemaBaseName = path.basename(schemaPath, '.ts');
+            const triggersPath = path.join(schemaDir, `${schemaBaseName}.triggers.ts`);
+            const triggersCode = 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 ${colors.cyan(triggersPath)} ${colors.muted(`(${formatBytes(trigFileSize)})`)}`);
+            }
+        }
         const oldSnapshot = loadSnapshot(projectRoot);
         const beforeSchema = oldSnapshot ? {
             extensions: oldSnapshot.extensions?.map(e => e.name) || [],

package/dist/esm/cli/commands/sync.js

@@ -1,7 +1,7 @@
 import { requireValidConfig } from "../utils/config-loader.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
 import { colors, createSpinner, fatal, success } from "../utils/cli-utils.js";
-import { isInitialized, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, } from "../utils/repo-manager.js";
+import { isInitialized, initRepository, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, } from "../utils/repo-manager.js";
 import { pullCommand } from "./pull.js";
 export async function syncCommand(context) {
     const { config, flags } = context;
@@ -13,7 +13,10 @@ export async function syncCommand(context) {
     const { projectRoot } = context;
     console.log('');
     if (!isInitialized(projectRoot)) {
-        fatal('not a relq repository (or any parent directories): .relq', `Run ${colors.cyan('relq init')} to initialize.`);
+        console.log(`${colors.yellow('Initializing')} .relq repository...`);
+        initRepository(projectRoot);
+        console.log(`${colors.green('✓')} Repository initialized`);
+        console.log('');
     }
     const spinner = createSpinner();
     try {