relq 1.0.5 → 1.0.7

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

@@ -1,16 +1,18 @@
 import * as fs from 'fs';
+import stripComments from 'strip-comments';
 import { colors, fatal, warning } from "../utils/spinner.js";
 import { loadRelqignore, isIgnored, } from "../utils/relqignore.js";
 import { loadConfig } from "../../config/config.js";
 import * as path from 'path';
-import { isInitialized, loadSnapshot, getUnstagedChanges, getStagedChanges, stageChanges, detectFileChanges, addUnstagedChanges, clearUnstagedChanges, } from "../utils/repo-manager.js";
+import { isInitialized, loadSnapshot, getUnstagedChanges, getStagedChanges, stageChanges, detectFileChanges, addUnstagedChanges, clearUnstagedChanges, cleanupStagedChanges, } from "../utils/repo-manager.js";
 import { getChangeDisplayName } from "../utils/change-tracker.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
 function parseSchemaFileForComparison(schemaPath) {
     if (!fs.existsSync(schemaPath)) {
         return null;
     }
-    const content = fs.readFileSync(schemaPath, 'utf-8');
+    const rawContent = fs.readFileSync(schemaPath, 'utf-8');
+    const content = stripComments(rawContent);
     const tables = [];
     const tableStartRegex = /defineTable\s*\(\s*['"]([^'"]+)['"],\s*\{/g;
     let tableStartMatch;
@@ -50,15 +52,21 @@ function parseSchemaFileForComparison(schemaPath) {
         const tsToDbNameMap = new Map();
         const lines = columnsBlock.split('\n');
         let currentColDef = '';
+        let pendingJsDocComment = null;
         for (const line of lines) {
             const trimmed = line.trim();
+            const jsDocMatch = trimmed.match(/^\/\*\*\s*(.*?)\s*\*\/$/);
+            if (jsDocMatch) {
+                pendingJsDocComment = jsDocMatch[1];
+                continue;
+            }
             if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*'))
                 continue;
             currentColDef += ' ' + trimmed;
             if (trimmed.endsWith(',') || trimmed.endsWith(')')) {
                 const colDef = currentColDef.trim();
                 currentColDef = '';
-                const typePattern = 'varchar|text|uuid|integer|bigint|boolean|timestamp|date|jsonb|json|numeric|serial|bigserial|smallserial|tsvector|smallint|real|doublePrecision|char|inet|cidr|macaddr|macaddr8|interval|time|point|line|lseg|box|path|polygon|circle|bytea|bit|varbit|money|xml|oid';
+                const typePattern = 'varchar|text|uuid|integer|bigint|boolean|timestamptz|timestamp|date|jsonb|json|numeric|serial|bigserial|smallserial|tsvector|smallint|real|doublePrecision|char|inet|cidr|macaddr|macaddr8|interval|timetz|time|point|line|lseg|box|path|polygon|circle|bytea|bit|varbit|money|xml|oid|enumType|domainType';
                 const colMatch = colDef.match(new RegExp(`^(\\w+):\\s*(${typePattern})`));
                 if (!colMatch)
                     continue;
@@ -74,13 +82,17 @@ function parseSchemaFileForComparison(schemaPath) {
                 if (bigintMatch) {
                     defaultValue = bigintMatch[1];
                 }
-                const funcDefaultMatch = !defaultValue && colDef.match(/\.default\(\s*(genRandomUuid|now|currentDate|currentTimestamp|emptyArray|emptyObject)\s*\(\s*\)\s*\)/);
+                const bigintLiteralMatch = !defaultValue && colDef.match(/\.default\(\s*(-?\d+)n\s*\)/);
+                if (bigintLiteralMatch) {
+                    defaultValue = bigintLiteralMatch[1];
+                }
+                const funcDefaultMatch = !defaultValue && colDef.match(/\.default\(\s*(?:DEFAULT\.)?(genRandomUuid|now|currentDate|currentTimestamp|emptyArray|emptyObject|emptyJsonb)\s*\(\s*\)\s*\)/);
                 if (funcDefaultMatch) {
                     const funcName = funcDefaultMatch[1];
                     if (funcName === 'emptyArray') {
                         defaultValue = isJsonbColumn ? "'[]'::jsonb" : "'{}'::text[]";
                     }
-                    else if (funcName === 'emptyObject') {
+                    else if (funcName === 'emptyObject' || funcName === 'emptyJsonb') {
                         defaultValue = "'{}'::jsonb";
                     }
                     else {
@@ -145,10 +157,22 @@ function parseSchemaFileForComparison(schemaPath) {
                 if (commentMatch) {
                     comment = commentMatch[2];
                 }
+                else if (pendingJsDocComment) {
+                    comment = pendingJsDocComment;
+                }
+                pendingJsDocComment = null;
                 if (colDef.includes('.identity()')) {
                     defaultValue = defaultValue || 'GENERATED BY DEFAULT AS IDENTITY';
                 }
-                const isArray = colDef.includes('.array()');
+                let trackingId = undefined;
+                const trackingIdMatch = colDef.match(/\.\$id\(\s*['"]([^'"]+)['"]\s*\)/);
+                if (trackingIdMatch) {
+                    trackingId = trackingIdMatch[1];
+                }
+                const hasArrayModifier = colDef.includes('.array()');
+                const hasEmptyArrayDefault = colDef.includes('emptyArray()');
+                const isJsonbType = type === 'jsonb' || type === 'json';
+                const isArray = hasArrayModifier || (hasEmptyArrayDefault && !isJsonbType);
                 columns.push({
                     name: dbColName,
                     dataType: isArray ? `${type}[]` : type,
@@ -161,6 +185,7 @@ function parseSchemaFileForComparison(schemaPath) {
                     scale: null,
                     references: null,
                     comment,
+                    trackingId,
                 });
             }
         }
@@ -173,8 +198,13 @@ function parseSchemaFileForComparison(schemaPath) {
                 const tsColName = c.trim().replace(/table\.\s*/, '');
                 return tsToDbNameMap.get(tsColName) || tsColName;
             });
-            const isUnique = optionsBlock.includes(`index('${indexName}')`) &&
-                optionsBlock.substring(optionsBlock.indexOf(`index('${indexName}')`)).split('\n')[0].includes('.unique()');
+            const indexStart = optionsBlock.indexOf(`index('${indexName}')`);
+            const indexLine = indexStart >= 0 ? optionsBlock.substring(indexStart).split('\n')[0] : '';
+            const isUnique = indexLine.includes('.unique()');
+            const commentMatch = indexLine.match(/\.comment\(\s*(['"])([^'"]*)\1\s*\)/);
+            const comment = commentMatch ? commentMatch[2] : null;
+            const trackingIdMatch = indexLine.match(/\.\$id\(\s*(['"])([^'"]+)\1\s*\)/);
+            const trackingId = trackingIdMatch ? trackingIdMatch[2] : undefined;
             indexes.push({
                 name: indexName,
                 columns: indexCols,
@@ -184,6 +214,8 @@ function parseSchemaFileForComparison(schemaPath) {
                 definition: '',
                 whereClause: null,
                 expression: null,
+                comment,
+                trackingId,
             });
         }
         const checkRegexLegacy = /check\s*\(\s*['"]([^'"]+)['"]\s*,\s*sql`([^`]+)`\s*\)/g;
@@ -234,6 +266,83 @@ function parseSchemaFileForComparison(schemaPath) {
             const dbPartitionKey = tsToDbNameMap.get(tsPartitionKey) || tsPartitionKey;
             partitionKey = [dbPartitionKey];
         }
+        const pkColumns = columns.filter(c => c.isPrimaryKey).map(c => c.name);
+        if (pkColumns.length > 0) {
+            const pkName = `${tableName}_pkey`;
+            if (!constraints.some(c => c.type === 'PRIMARY KEY')) {
+                constraints.push({
+                    name: pkName,
+                    type: 'PRIMARY KEY',
+                    columns: pkColumns,
+                    definition: '',
+                });
+            }
+        }
+        for (const col of columns) {
+            if (col.isUnique && !col.isPrimaryKey) {
+                const uniqueName = `${tableName}_${col.name}_key`;
+                col.isUnique = false;
+                if (!constraints.some(c => c.name === uniqueName)) {
+                    constraints.push({
+                        name: uniqueName,
+                        type: 'UNIQUE',
+                        columns: [col.name],
+                        definition: '',
+                    });
+                }
+            }
+        }
+        const uniqueConstraintRegex = /constraint\.unique\s*\(\s*\{\s*name:\s*['"]([^'"]+)['"]\s*,\s*columns:\s*\[([^\]]+)\]/g;
+        let uniqueMatch;
+        while ((uniqueMatch = uniqueConstraintRegex.exec(optionsBlock)) !== null) {
+            const constraintName = uniqueMatch[1];
+            const colsStr = uniqueMatch[2];
+            const uniqueCols = colsStr.split(',').map(c => {
+                const tsColName = c.trim().replace(/table\.\s*/, '');
+                return tsToDbNameMap.get(tsColName) || tsColName;
+            });
+            if (!constraints.some(c => c.name === constraintName)) {
+                constraints.push({
+                    name: constraintName,
+                    type: 'UNIQUE',
+                    columns: uniqueCols,
+                    definition: '',
+                });
+            }
+        }
+        const pkConstraintRegex = /constraint\.primaryKey\s*\(\s*\{\s*name:\s*['"]([^'"]+)['"]\s*,\s*columns:\s*\[([^\]]+)\]/g;
+        let pkMatch;
+        while ((pkMatch = pkConstraintRegex.exec(optionsBlock)) !== null) {
+            const constraintName = pkMatch[1];
+            const colsStr = pkMatch[2];
+            const pkCols = colsStr.split(',').map(c => {
+                const tsColName = c.trim().replace(/table\.\s*/, '');
+                return tsToDbNameMap.get(tsColName) || tsColName;
+            });
+            const existingPkIdx = constraints.findIndex(c => c.type === 'PRIMARY KEY');
+            if (existingPkIdx >= 0) {
+                constraints[existingPkIdx] = {
+                    name: constraintName,
+                    type: 'PRIMARY KEY',
+                    columns: pkCols,
+                    definition: '',
+                };
+            }
+            else {
+                constraints.push({
+                    name: constraintName,
+                    type: 'PRIMARY KEY',
+                    columns: pkCols,
+                    definition: '',
+                });
+            }
+            for (const dbColName of pkCols) {
+                const col = columns.find(c => c.name === dbColName);
+                if (col) {
+                    col.isPrimaryKey = true;
+                }
+            }
+        }
         tables.push({
             name: tableName,
             schema: 'public',
@@ -269,6 +378,80 @@ function parseSchemaFileForComparison(schemaPath) {
             }
         }
     }
+    const toSnakeCase = (str) => {
+        return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+    };
+    const pgRelationsStart = content.indexOf('pgRelations(');
+    let relationsBlock = '';
+    if (pgRelationsStart !== -1) {
+        const arrowStart = content.indexOf('=> ({', pgRelationsStart);
+        if (arrowStart !== -1) {
+            const blockStart = arrowStart + 5;
+            let depth = 1;
+            let i = blockStart;
+            while (i < content.length && depth > 0) {
+                if (content[i] === '{')
+                    depth++;
+                else if (content[i] === '}')
+                    depth--;
+                i++;
+            }
+            relationsBlock = content.slice(blockStart, i - 1);
+        }
+    }
+    if (relationsBlock) {
+        const tableEntryRegex = /(\w+):\s*tables\.\1\s*\(\s*\([^)]*\)\s*=>\s*\(\{/g;
+        let tableMatch;
+        while ((tableMatch = tableEntryRegex.exec(relationsBlock)) !== null) {
+            const tableTsName = tableMatch[1];
+            const tableDbName = toSnakeCase(tableTsName);
+            const entryStart = tableMatch.index + tableMatch[0].length;
+            let depth = 1;
+            let j = entryStart;
+            while (j < relationsBlock.length && depth > 0) {
+                if (relationsBlock[j] === '{')
+                    depth++;
+                else if (relationsBlock[j] === '}')
+                    depth--;
+                j++;
+            }
+            const tableRelationsContent = relationsBlock.slice(entryStart, j - 1);
+            const table = tables.find(t => t.name === tableDbName);
+            if (!table)
+                continue;
+            const fkRegex = /(\w+):\s*r\.referenceTo\.(\w+)\s*\(\s*\w*\s*=>\s*\(\{([^}]*)\}\)/g;
+            let fkMatch;
+            while ((fkMatch = fkRegex.exec(tableRelationsContent)) !== null) {
+                const colTsName = fkMatch[1];
+                const refTableTsName = fkMatch[2];
+                const fkOptionsStr = fkMatch[3];
+                const colDbName = toSnakeCase(colTsName);
+                const refTableDbName = toSnakeCase(refTableTsName);
+                let onDelete;
+                let onUpdate;
+                const nameMatch = fkOptionsStr.match(/name:\s*['"]([^'"]+)['"]/);
+                const onDeleteMatch = fkOptionsStr.match(/onDelete:\s*['"]([^'"]+)['"]/);
+                const onUpdateMatch = fkOptionsStr.match(/onUpdate:\s*['"]([^'"]+)['"]/);
+                if (onDeleteMatch)
+                    onDelete = onDeleteMatch[1];
+                if (onUpdateMatch)
+                    onUpdate = onUpdateMatch[1];
+                const fkName = nameMatch ? nameMatch[1] : `${tableDbName}_${colDbName}_fkey`;
+                if (!table.constraints.some(c => c.name === fkName || (c.type === 'FOREIGN KEY' && c.columns?.includes(colDbName)))) {
+                    table.constraints.push({
+                        name: fkName,
+                        type: 'FOREIGN KEY',
+                        columns: [colDbName],
+                        definition: '',
+                        referencedTable: refTableDbName,
+                        referencedColumns: ['id'],
+                        onDelete,
+                        onUpdate,
+                    });
+                }
+            }
+        }
+    }
     return {
         tables,
         enums,
@@ -301,6 +484,7 @@ function snapshotToDatabaseSchema(snapshot) {
             scale: null,
             references: null,
             comment: c.comment || null,
+            trackingId: c.trackingId,
         })),
         indexes: (t.indexes || []).map(i => ({
             name: i.name,
@@ -311,6 +495,7 @@ function snapshotToDatabaseSchema(snapshot) {
             definition: i.definition || '',
             whereClause: i.whereClause || null,
             expression: null,
+            trackingId: i.trackingId,
         })),
         constraints: (t.constraints || []).map(c => ({
             name: c.name,
@@ -339,6 +524,57 @@ function snapshotToDatabaseSchema(snapshot) {
         extensions: (snapshot.extensions || []).map(e => typeof e === 'string' ? e : e.name),
     };
 }
+let trackingIdCounter = 0;
+function generateTrackingId(prefix) {
+    trackingIdCounter++;
+    const base = (Date.now().toString(36) + trackingIdCounter.toString(36)).slice(-5);
+    return prefix + base.padStart(5, '0');
+}
+function injectTrackingIds(schemaPath) {
+    if (!fs.existsSync(schemaPath)) {
+        return 0;
+    }
+    let content = fs.readFileSync(schemaPath, 'utf-8');
+    let injectedCount = 0;
+    const columnLineRegex = /^(\s*)(\w+):\s*(varchar|text|uuid|integer|bigint|boolean|timestamptz|timestamp|date|jsonb|json|numeric|serial|bigserial|smallserial|tsvector|smallint|real|doublePrecision|char|inet|cidr|macaddr|macaddr8|interval|timetz|time|point|line|lseg|box|path|polygon|circle|bytea|bit|varbit|money|xml|oid|enumType|domainType)\s*\([^)]*\)([^,\n]*)(,?)$/gm;
+    content = content.replace(columnLineRegex, (match, indent, colName, type, modifiers, comma) => {
+        if (modifiers.includes('.$id(')) {
+            return match;
+        }
+        const commentMatch = modifiers.match(/^(.*)(\.\s*comment\s*\([^)]+\))$/);
+        if (commentMatch) {
+            const beforeComment = commentMatch[1];
+            const comment = commentMatch[2];
+            const trackingId = generateTrackingId('c');
+            injectedCount++;
+            return `${indent}${colName}: ${type}(${match.split('(')[1].split(')')[0]})${beforeComment}.$id('${trackingId}')${comment}${comma}`;
+        }
+        const trackingId = generateTrackingId('c');
+        injectedCount++;
+        return `${indent}${colName}: ${type}(${match.split('(')[1].split(')')[0]})${modifiers}.$id('${trackingId}')${comma}`;
+    });
+    const indexLineRegex = /^(\s*)(index\s*\(\s*['"][^'"]+['"]\s*\)\s*\.on\s*\([^)]+\)[^,\n]*)(,?)$/gm;
+    content = content.replace(indexLineRegex, (match, indent, indexDef, comma) => {
+        if (indexDef.includes('.$id(')) {
+            return match;
+        }
+        const commentMatch = indexDef.match(/^(.*)(\.\s*comment\s*\([^)]+\))$/);
+        if (commentMatch) {
+            const beforeComment = commentMatch[1];
+            const comment = commentMatch[2];
+            const trackingId = generateTrackingId('i');
+            injectedCount++;
+            return `${indent}${beforeComment}.$id('${trackingId}')${comment}${comma}`;
+        }
+        const trackingId = generateTrackingId('i');
+        injectedCount++;
+        return `${indent}${indexDef}.$id('${trackingId}')${comma}`;
+    });
+    if (injectedCount > 0) {
+        fs.writeFileSync(schemaPath, content, 'utf-8');
+    }
+    return injectedCount;
+}
 export async function addCommand(context) {
     const { args, projectRoot } = context;
     console.log('');
@@ -347,8 +583,12 @@ export async function addCommand(context) {
     }
     const ignorePatterns = loadRelqignore(projectRoot);
     const config = await loadConfig();
-    const schemaPathRaw = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
+    const schemaPathRaw = typeof config?.schema === 'string' ? config.schema : './db/schema.ts';
     const schemaPath = path.resolve(projectRoot, schemaPathRaw);
+    const injectedCount = injectTrackingIds(schemaPath);
+    if (injectedCount > 0) {
+        console.log(colors.muted(`Injected ${injectedCount} tracking ID(s) into schema.ts`));
+    }
     const fileChange = detectFileChanges(schemaPath, projectRoot);
     if (fileChange) {
         const currentSchema = parseSchemaFileForComparison(schemaPath);
@@ -356,16 +596,13 @@ export async function addCommand(context) {
         if (currentSchema && snapshot) {
             const snapshotAsDbSchema = snapshotToDatabaseSchema(snapshot);
             const schemaChanges = compareSchemas(snapshotAsDbSchema, currentSchema);
+            cleanupStagedChanges(schemaChanges, projectRoot);
             if (schemaChanges.length > 0) {
                 clearUnstagedChanges(projectRoot);
                 addUnstagedChanges(schemaChanges, projectRoot);
             }
             else {
-                const existingUnstaged = getUnstagedChanges(projectRoot);
-                const hasFileChange = existingUnstaged.some(c => c.objectType === 'SCHEMA_FILE');
-                if (!hasFileChange) {
-                    addUnstagedChanges([fileChange], projectRoot);
-                }
+                clearUnstagedChanges(projectRoot);
             }
         }
     }
@@ -377,16 +614,16 @@ export async function addCommand(context) {
         if (result.ignored) {
             return false;
         }
-        if (['FUNCTION', 'PROCEDURE'].includes(change.objectType) && !config.includeFunctions) {
+        if (['FUNCTION', 'PROCEDURE'].includes(change.objectType) && !config?.includeFunctions) {
             return false;
         }
-        if (change.objectType === 'TRIGGER' && !config.includeTriggers) {
+        if (change.objectType === 'TRIGGER' && !config?.includeTriggers) {
             return false;
         }
-        if (['VIEW', 'MATERIALIZED_VIEW'].includes(change.objectType) && !config.includeViews) {
+        if (['VIEW', 'MATERIALIZED_VIEW'].includes(change.objectType) && !config?.includeViews) {
             return false;
         }
-        if (change.objectType === 'FOREIGN_TABLE' && !config.includeFDW) {
+        if (change.objectType === 'FOREIGN_TABLE' && !config?.includeFDW) {
             return false;
         }
         return true;

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

@@ -39,6 +39,7 @@ export async function commitCommand(context) {
     const creates = staged.filter(c => c.type === 'CREATE').length;
     const alters = staged.filter(c => c.type === 'ALTER').length;
     const drops = staged.filter(c => c.type === 'DROP').length;
+    const renames = staged.filter(c => c.type === 'RENAME').length;
     const parentHash = getHead(projectRoot);
     const hashInput = JSON.stringify({
         changes: staged.map(c => c.id),
@@ -60,6 +61,7 @@ export async function commitCommand(context) {
             creates,
             alters,
             drops,
+            renames,
             total: staged.length,
         },
     };
@@ -84,7 +86,7 @@ export async function commitCommand(context) {
         }
     }
     const commitConfig = await loadConfig();
-    const schemaPathRaw = typeof commitConfig.schema === 'string' ? commitConfig.schema : './db/schema.ts';
+    const schemaPathRaw = typeof commitConfig?.schema === 'string' ? commitConfig.schema : './db/schema.ts';
     const schemaFilePath = path.resolve(projectRoot, schemaPathRaw);
     if (fs.existsSync(schemaFilePath)) {
         const currentContent = fs.readFileSync(schemaFilePath, 'utf-8');
@@ -92,7 +94,16 @@ export async function commitCommand(context) {
         saveFileHash(currentHash, projectRoot);
     }
     console.log(`[${shortHash(hash)}] ${message}`);
-    console.log(` ${creates} create(s), ${alters} alter(s), ${drops} drop(s)`);
+    const statsParts = [];
+    if (creates > 0)
+        statsParts.push(`${creates} create(s)`);
+    if (alters > 0)
+        statsParts.push(`${alters} alter(s)`);
+    if (drops > 0)
+        statsParts.push(`${drops} drop(s)`);
+    if (renames > 0)
+        statsParts.push(`${renames} rename(s)`);
+    console.log(` ${statsParts.length > 0 ? statsParts.join(', ') : 'no changes'}`);
     console.log('');
     hint("run 'relq push' to apply changes to database");
     hint("run 'relq export' to export as SQL file");

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

@@ -6,7 +6,6 @@ import { isInitialized, getStagedChanges, getUnstagedChanges, loadSnapshot, } fr
 import { generateCombinedSQL, sortChangesByDependency, getChangeDisplayName, } from "../utils/change-tracker.js";
 import { generateFullSchemaSQL } from "../utils/sql-generator.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isSequenceIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
-import { loadConfig } from "../../config/config.js";
 export async function exportCommand(context) {
     const spinner = createSpinner();
     const { args, flags, projectRoot } = context;
@@ -28,9 +27,9 @@ export async function exportCommand(context) {
     if (fromDb) {
         return exportFromDatabase(context, absoluteOutputPath, options);
     }
-    return exportFromSnapshot(projectRoot, absoluteOutputPath, options);
+    return exportFromSnapshot(projectRoot, absoluteOutputPath, options, context.config ?? undefined);
 }
-async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
+async function exportFromSnapshot(projectRoot, absoluteOutputPath, options, config) {
     const spinner = createSpinner();
     if (!isInitialized(projectRoot)) {
         console.log(`${colors.red('error:')} relq not initialized`);
@@ -47,13 +46,13 @@ async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
         return;
     }
     spinner.succeed('Loaded snapshot');
-    const config = await loadConfig();
+    const cfg = config || {};
     const ignorePatterns = loadRelqignore(projectRoot);
     const filteredSnapshot = filterNormalizedSchema(snapshot, ignorePatterns, {
-        includeFunctions: config.includeFunctions ?? options.includeFunctions ?? false,
-        includeTriggers: config.includeTriggers ?? options.includeTriggers ?? false,
-        includeViews: config.includeViews ?? false,
-        includeFDW: config.includeFDW ?? false,
+        includeFunctions: cfg.includeFunctions ?? options.includeFunctions ?? true,
+        includeTriggers: cfg.includeTriggers ?? options.includeTriggers ?? true,
+        includeViews: cfg.includeViews ?? false,
+        includeFDW: cfg.includeFDW ?? false,
     });
     const schema = normalizedToDbSchema(filteredSnapshot);
     const ignoredCount = (snapshot.tables.length - filteredSnapshot.tables.length) +
@@ -77,7 +76,12 @@ async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
         console.log(`  ${colors.muted(`${ignoredCount} object(s) filtered by .relqignore`)}`);
     }
     spinner.start('Generating SQL statements');
-    const sqlContent = generateFullSQL(schema, options);
+    const exportOptions = {
+        ...options,
+        includeFunctions: cfg.includeFunctions ?? options.includeFunctions ?? true,
+        includeTriggers: cfg.includeTriggers ?? options.includeTriggers ?? true,
+    };
+    const sqlContent = generateFullSQL(schema, exportOptions);
     spinner.succeed('Generated SQL statements');
     const outputDir = path.dirname(absoluteOutputPath);
     if (!fs.existsSync(outputDir)) {
@@ -147,15 +151,9 @@ function normalizedToDbSchema(normalized) {
                 defaultValue: c.default,
                 isPrimaryKey: c.primaryKey,
                 isUnique: c.unique,
-                maxLength: null,
-                precision: null,
-                scale: null,
-                references: c.references ? {
-                    table: c.references.table,
-                    column: c.references.column,
-                    onDelete: c.references.onDelete,
-                    onUpdate: c.references.onUpdate,
-                } : null,
+                maxLength: c.maxLength ?? null,
+                precision: c.precision ?? null,
+                scale: c.scale ?? null,
                 check: c.check ?? undefined,
                 comment: c.comment ?? undefined,
                 isGenerated: c.isGenerated || false,
@@ -171,6 +169,7 @@ function normalizedToDbSchema(normalized) {
                 definition: i.definition,
                 whereClause: i.whereClause ?? null,
                 expression: i.columnDefs?.find(cd => cd.expression)?.expression ?? null,
+                comment: i.comment ?? null,
             })),
             constraints: t.constraints.map(c => ({
                 name: c.name,
@@ -185,6 +184,7 @@ function normalizedToDbSchema(normalized) {
             isPartitioned: t.isPartitioned || t.partitionType !== undefined,
             partitionType: t.partitionType,
             partitionKey: t.partitionKey,
+            comment: t.comment ?? null,
         })),
         enums: normalized.enums.map(e => ({
             name: e.name,
@@ -233,7 +233,13 @@ function normalizedToDbSchema(normalized) {
             definition: '',
             isEnabled: t.isEnabled !== false,
         })),
-        partitions: [],
+        partitions: normalized.tables.flatMap(t => (t.partitions || []).map(p => ({
+            name: p.name,
+            parentTable: t.name,
+            partitionBound: p.bound || '',
+            partitionType: (p.boundType || t.partitionType || 'LIST'),
+            partitionKey: t.partitionKey || [],
+        }))),
         policies: [],
         foreignServers: [],
         foreignTables: [],