relq 1.0.25 → 1.0.27

package/dist/cjs/cli/commands/commit.cjs

@@ -40,8 +40,11 @@ const repo_manager_1 = require("../utils/repo-manager.cjs");
 const config_1 = require("../../config/config.cjs");
 const config_loader_1 = require("../utils/config-loader.cjs");
 const change_tracker_1 = require("../utils/change-tracker.cjs");
+const commit_manager_1 = require("../utils/commit-manager.cjs");
+const schema_to_ast_1 = require("../utils/schema-to-ast.cjs");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const jiti_1 = require("jiti");
 async function commitCommand(context) {
     const { config, flags, args, projectRoot } = context;
     const author = config?.author || 'Developer <dev@example.com>';
@@ -52,6 +55,9 @@ async function commitCommand(context) {
     const schemaPath = path.resolve(projectRoot, (0, config_loader_1.getSchemaPath)(config ?? undefined));
     const { requireValidSchema } = await Promise.resolve().then(() => __importStar(require("../utils/config-loader.cjs")));
     await requireValidSchema(schemaPath, flags);
+    if (flags['from-schema']) {
+        return commitFromSchema(context, schemaPath, author);
+    }
     const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
     if (staged.length === 0) {
         console.log('nothing to commit, working tree clean');
@@ -76,6 +82,8 @@ async function commitCommand(context) {
     }
     const sortedChanges = (0, change_tracker_1.sortChangesByDependency)(staged);
     const sql = (0, change_tracker_1.generateCombinedSQL)(sortedChanges);
+    const downSQL = (0, change_tracker_1.generateDownSQL)(sortedChanges);
+    const snapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
     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;
@@ -96,6 +104,8 @@ async function commitCommand(context) {
         timestamp: new Date().toISOString(),
         changes: sortedChanges,
         sql,
+        downSQL,
+        schema: snapshot,
         snapshotHash: hash.substring(0, 12),
         stats: {
             creates,
@@ -149,4 +159,74 @@ async function commitCommand(context) {
     (0, cli_utils_1.hint)("run 'relq export' to export as SQL file");
     console.log('');
 }
+async function commitFromSchema(context, schemaPath, author) {
+    const { config, flags, args, projectRoot } = context;
+    const spinner = (0, cli_utils_1.createSpinner)();
+    let message = flags['m'] || flags['message'];
+    if (!message) {
+        if (args.length > 0) {
+            message = args.join(' ');
+        }
+        else {
+            (0, cli_utils_1.fatal)('commit message required', "usage: relq commit --from-schema -m '<message>'");
+        }
+    }
+    spinner.start('Loading schema file');
+    let schemaModule;
+    try {
+        const jiti = (0, jiti_1.createJiti)(path.dirname(schemaPath), { interopDefault: true });
+        const module = await jiti.import(schemaPath);
+        if (module && module.default && typeof module.default === 'object') {
+            schemaModule = module.default;
+        }
+        else if (module && typeof module === 'object') {
+            schemaModule = module;
+        }
+        else {
+            throw new Error('Schema file must export an object with table/enum definitions');
+        }
+        spinner.succeed('Loaded schema file');
+    }
+    catch (err) {
+        spinner.fail('Failed to load schema');
+        (0, cli_utils_1.fatal)(`Could not load schema: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    spinner.start('Converting schema to AST');
+    const ast = (0, schema_to_ast_1.schemaToAST)(schemaModule);
+    spinner.succeed('Converted schema to AST');
+    const schemaHash = (0, commit_manager_1.generateASTHash)(ast);
+    spinner.start('Creating commit');
+    try {
+        const commit = (0, commit_manager_1.createCommitFromSchema)(schemaModule, author, message, config?.commitLimit ?? 1000, projectRoot);
+        spinner.succeed('Created commit');
+        const tableCount = ast.tables.length;
+        const enumCount = ast.enums.length;
+        const functionCount = ast.functions.length;
+        const viewCount = ast.views.length;
+        const triggerCount = ast.triggers.length;
+        console.log('');
+        console.log(`[${(0, repo_manager_1.shortHash)(commit.hash)}] ${message}`);
+        const statsParts = [];
+        if (tableCount > 0)
+            statsParts.push(`${tableCount} table(s)`);
+        if (enumCount > 0)
+            statsParts.push(`${enumCount} enum(s)`);
+        if (functionCount > 0)
+            statsParts.push(`${functionCount} function(s)`);
+        if (viewCount > 0)
+            statsParts.push(`${viewCount} view(s)`);
+        if (triggerCount > 0)
+            statsParts.push(`${triggerCount} trigger(s)`);
+        console.log(` ${statsParts.length > 0 ? statsParts.join(', ') : 'empty schema'}`);
+        console.log('');
+        console.log(cli_utils_1.colors.muted(`Schema hash: ${schemaHash.substring(0, 12)}`));
+        console.log('');
+        (0, cli_utils_1.hint)("run 'relq push' to apply changes to database");
+        (0, cli_utils_1.hint)("run 'relq log' to view commit history");
+    }
+    catch (err) {
+        spinner.fail('Failed to create commit');
+        (0, cli_utils_1.fatal)(`Could not create commit: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 exports.default = commitCommand;

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

@@ -211,6 +211,7 @@ async function importCommand(sqlFilePath, options = {}, projectRoot = process.cw
         tables: filteredTables,
         enums: filteredEnums,
         domains: filteredDomains,
+        compositeTypes: parsedSchema.compositeTypes || [],
         sequences: filteredSequences,
         views: parsedSchema.views,
         functions: parsedSchema.functions,

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

@@ -375,10 +375,92 @@ 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 tablesAdded = allChanges.filter(c => c.type === 'CREATE' && c.objectType === 'TABLE').length;
+            const tablesRemoved = allChanges.filter(c => c.type === 'DROP' && c.objectType === 'TABLE').length;
+            const columnsChanged = allChanges.filter(c => c.objectType === 'COLUMN').length;
+            const indexesChanged = allChanges.filter(c => c.objectType === 'INDEX').length;
+            const otherChanges = allChanges.filter(c => c.objectType !== 'TABLE' && c.objectType !== 'COLUMN' && c.objectType !== 'INDEX').length;
             const conflicts = detectObjectConflicts(localSnapshot, currentSchema);
             if (conflicts.length > 0 && !force) {
                 const mergeState = {
@@ -400,26 +482,40 @@ 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`);
+            if (tablesAdded > 0) {
+                console.log(`   ${cli_utils_1.colors.green(`+${tablesAdded}`)} table(s) added`);
+            }
+            if (tablesRemoved > 0) {
+                console.log(`   ${cli_utils_1.colors.red(`-${tablesRemoved}`)} table(s) removed`);
+            }
+            if (columnsChanged > 0) {
+                console.log(`   ${cli_utils_1.colors.cyan(`~${columnsChanged}`)} column change(s)`);
             }
-            if (removed.length > 0) {
-                console.log(`   ${cli_utils_1.colors.red(`-${removed.length}`)} tables removed`);
+            if (indexesChanged > 0) {
+                console.log(`   ${cli_utils_1.colors.cyan(`~${indexesChanged}`)} index change(s)`);
+            }
+            if (otherChanges > 0) {
+                console.log(`   ${cli_utils_1.colors.cyan(`~${otherChanges}`)} other change(s)`);
             }
             console.log('');
-            if (!dryRun) {
+            const noAutoMerge = flags['no-auto-merge'] === true;
+            if (!dryRun && noAutoMerge) {
                 const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.bold('Pull these changes?')}`, true);
                 if (!proceed) {
                     (0, cli_utils_1.fatal)('Operation cancelled by user');
                 }
                 console.log('');
             }
+            else if (!dryRun) {
+                console.log(`${cli_utils_1.colors.green('Auto-merging')} (no conflicts detected)`);
+                console.log('');
+            }
         }
         else if (schemaExists && !force) {
             (0, cli_utils_1.warning)('Local schema exists but not tracked');
@@ -481,6 +577,7 @@ async function pullCommand(context) {
         }
         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',
@@ -586,7 +683,7 @@ async function pullCommand(context) {
             triggers: filteredTriggers || [],
         };
         const schemaChanges = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
-        applyTrackingIdsToSnapshot(typescript, currentSchema);
+        (0, ast_codegen_1.copyTrackingIdsToNormalized)(parsedSchema, currentSchema);
         (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
         const duration = Date.now() - startTime;
         if (noCommit) {
@@ -692,26 +789,3 @@ function detectObjectConflicts(local, remote) {
     }
     return conflicts;
 }
-function applyTrackingIdsToSnapshot(typescript, snapshot) {
-    for (const table of snapshot.tables) {
-        const tablePattern = new RegExp(`defineTable\\s*\\(\\s*['"]${table.name}['"]\\s*,\\s*\\{[^}]+\\}\\s*,\\s*\\{[^}]*\\$trackingId:\\s*['"]([^'"]+)['"]`, 's');
-        const tableMatch = typescript.match(tablePattern);
-        if (tableMatch) {
-            table.trackingId = tableMatch[1];
-        }
-        for (const col of table.columns) {
-            const colPattern = new RegExp(`(?:${col.tsName}|${col.name}):\\s*\\w+\\([^)]*\\)[^\\n]*\\.\\\$id\\(['"]([^'"]+)['"]\\)`);
-            const colMatch = typescript.match(colPattern);
-            if (colMatch) {
-                col.trackingId = colMatch[1];
-            }
-        }
-        for (const idx of table.indexes) {
-            const idxPattern = new RegExp(`index\\s*\\(\\s*['"]${idx.name}['"]\\s*\\)[^\\n]*\\.\\\$id\\(['"]([^'"]+)['"]\\)`);
-            const idxMatch = typescript.match(idxPattern);
-            if (idxMatch) {
-                idx.trackingId = idxMatch[1];
-            }
-        }
-    }
-}

package/dist/cjs/cli/commands/push.cjs

@@ -52,7 +52,7 @@ async function pushCommand(context) {
     const { projectRoot } = context;
     const force = flags['force'] === true;
     const dryRun = flags['dry-run'] === true;
-    const applySQL = flags['apply'] === true;
+    const metadataOnly = flags['metadata-only'] === true;
     const noVerify = flags['no-verify'] === true;
     const skipPrompt = flags['yes'] === true || flags['y'] === true;
     const includeFunctions = config.includeFunctions ?? false;
@@ -165,9 +165,46 @@ async function pushCommand(context) {
             console.log('');
         }
         if (dryRun) {
-            console.log(`${cli_utils_1.colors.yellow('Dry run')} - no changes applied`);
+            console.log(`${cli_utils_1.colors.yellow('Dry run')} - showing changes that would be applied`);
             console.log('');
-            console.log(`${cli_utils_1.colors.muted('Use')} ${cli_utils_1.colors.cyan('relq push --apply')} ${cli_utils_1.colors.muted('to execute.')}`);
+            if (hasObjectsToDrop && force) {
+                console.log(`${cli_utils_1.colors.red('DROP statements:')}`);
+                for (const obj of analysis.objectsToDrop.slice(0, 5)) {
+                    console.log(`   ${generateDropSQL(obj)}`);
+                }
+                if (analysis.objectsToDrop.length > 5) {
+                    console.log(`   ${cli_utils_1.colors.muted(`... and ${analysis.objectsToDrop.length - 5} more`)}`);
+                }
+                console.log('');
+            }
+            const commitsToProcess = [...toPush].reverse();
+            let totalStatements = 0;
+            for (const commit of commitsToProcess) {
+                const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
+                if (fs.existsSync(commitPath)) {
+                    const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                    if (enhancedCommit.sql && enhancedCommit.sql.trim()) {
+                        const statements = enhancedCommit.sql.split(';').filter(s => s.trim());
+                        totalStatements += statements.length;
+                        console.log(`${cli_utils_1.colors.cyan(`Commit ${(0, repo_manager_1.shortHash)(commit.hash)}:`)} ${commit.message}`);
+                        for (const stmt of statements.slice(0, 3)) {
+                            console.log(`   ${stmt.trim().substring(0, 80)}${stmt.trim().length > 80 ? '...' : ''};`);
+                        }
+                        if (statements.length > 3) {
+                            console.log(`   ${cli_utils_1.colors.muted(`... and ${statements.length - 3} more statements`)}`);
+                        }
+                        console.log('');
+                    }
+                }
+            }
+            if (totalStatements === 0 && !hasObjectsToDrop) {
+                console.log(`${cli_utils_1.colors.muted('No SQL changes to apply')}`);
+            }
+            else {
+                console.log(`${cli_utils_1.colors.muted('Total:')} ${totalStatements + (hasObjectsToDrop ? analysis.objectsToDrop.length : 0)} statements`);
+            }
+            console.log('');
+            console.log(`${cli_utils_1.colors.muted('Remove')} ${cli_utils_1.colors.cyan('--dry-run')} ${cli_utils_1.colors.muted('to execute these changes.')}`);
             console.log('');
             return;
         }
@@ -180,8 +217,8 @@ async function pushCommand(context) {
             }
             spinner.succeed(`Pushed ${toPush.length} commit(s) to ${(0, repo_manager_1.getConnectionLabel)(connection)}`);
         }
-        if (applySQL) {
-            spinner.start('Applying SQL changes...');
+        if (!metadataOnly && !dryRun) {
+            spinner.start('Applying schema changes...');
             const pg = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
             const client = new pg.Client({
                 host: connection.host,
@@ -218,6 +255,9 @@ async function pushCommand(context) {
                 }
                 await client.query('COMMIT');
                 spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+                for (const commit of commitsToProcess) {
+                    await (0, repo_manager_1.markCommitAsApplied)(connection, commit.hash);
+                }
                 let hasRenameOperations = false;
                 for (const commit of commitsToProcess) {
                     const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
@@ -262,13 +302,13 @@ async function pushCommand(context) {
         const oldHash = remoteHead ? (0, repo_manager_1.shortHash)(remoteHead) : '(none)';
         const newHash = (0, repo_manager_1.shortHash)(localHead);
         console.log(`   ${oldHash}..${newHash}  ${cli_utils_1.colors.muted('main -> main')}`);
-        if (hasObjectsToDrop && force && applySQL) {
+        if (hasObjectsToDrop && force && !metadataOnly && !dryRun) {
             console.log('');
             (0, cli_utils_1.warning)(`Dropped ${analysis.objectsToDrop.length} object(s) from remote`);
         }
-        if (!applySQL) {
+        if (metadataOnly) {
             console.log('');
-            console.log(`${cli_utils_1.colors.muted('Use')} ${cli_utils_1.colors.cyan('relq push --apply')} ${cli_utils_1.colors.muted('to execute SQL.')}`);
+            console.log(`${cli_utils_1.colors.muted('Metadata only - SQL not executed. Remove')} ${cli_utils_1.colors.cyan('--metadata-only')} ${cli_utils_1.colors.muted('to apply changes.')}`);
         }
         console.log('');
     }