relq 1.0.25 → 1.0.26

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

@@ -10,6 +10,14 @@ function pgView(name, definition) {
         name,
         definition: definition.trim(),
         isMaterialized: false,
+        toAST() {
+            return {
+                name: this.name,
+                definition: this.definition,
+                isMaterialized: false,
+                trackingId: this.$trackingId,
+            };
+        },
     };
 }
 function pgMaterializedView(name, definition, options) {
@@ -19,6 +27,15 @@ function pgMaterializedView(name, definition, options) {
         definition: definition.trim(),
         isMaterialized: true,
         withData: options?.withData,
+        toAST() {
+            return {
+                name: this.name,
+                definition: this.definition,
+                isMaterialized: true,
+                withData: this.withData,
+                trackingId: this.$trackingId,
+            };
+        },
     };
 }
 function viewToSQL(view) {

package/dist/cjs/schema-definition/sql-expressions.cjs

@@ -188,6 +188,9 @@ function pgExtensions(...extensions) {
         toSQL() {
             return extensions.map(ext => `CREATE EXTENSION IF NOT EXISTS "${ext}";`);
         },
+        toAST() {
+            return [...extensions];
+        },
     };
 }
 function getSql(expr) {

package/dist/cjs/schema-definition/table-definition.cjs

@@ -7,6 +7,7 @@ exports.defineTable = defineTable;
 const pg_format_1 = __importDefault(require("../addon/pg-format/index.cjs"));
 const partitions_1 = require("./partitions.cjs");
 const sql_expressions_1 = require("./sql-expressions.cjs");
+const schema_to_ast_1 = require("../cli/utils/schema-to-ast.cjs");
 function formatWhereValue(val) {
     if (val === null)
         return 'NULL';
@@ -481,6 +482,9 @@ function defineTable(name, columns, options) {
         },
         toCreateIndexSQL() {
             return generateIndexSQL(this);
+        },
+        toAST() {
+            return (0, schema_to_ast_1.tableToAST)(this);
         }
     };
     return definition;

package/dist/config.d.ts

@@ -261,6 +261,102 @@ export interface DefaultValue {
 	readonly $sql: string;
 	readonly $isDefault: true;
 }
+/**
+ * AST Type Definitions
+ *
+ * Type definitions for parsed PostgreSQL schema objects.
+ * These are intermediate representations between pgsql-parser AST and TypeScript code generation.
+ */
+export interface ParsedColumn {
+	name: string;
+	type: string;
+	typeParams?: {
+		precision?: number;
+		scale?: number;
+		length?: number;
+	};
+	isNullable: boolean;
+	isPrimaryKey: boolean;
+	isUnique: boolean;
+	hasDefault: boolean;
+	defaultValue?: string;
+	isGenerated: boolean;
+	generatedExpression?: string;
+	generatedExpressionAst?: any;
+	checkConstraint?: {
+		name: string;
+		expression: string;
+		expressionAst?: any;
+	};
+	references?: {
+		table: string;
+		column: string;
+		onDelete?: string;
+		onUpdate?: string;
+		match?: "SIMPLE" | "FULL";
+		deferrable?: boolean;
+		initiallyDeferred?: boolean;
+	};
+	isArray: boolean;
+	arrayDimensions?: number;
+	comment?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedConstraint {
+	name: string;
+	type: "PRIMARY KEY" | "UNIQUE" | "FOREIGN KEY" | "CHECK" | "EXCLUDE";
+	columns: string[];
+	expression?: string;
+	expressionAst?: any;
+	comment?: string;
+	references?: {
+		table: string;
+		columns: string[];
+		onDelete?: string;
+		onUpdate?: string;
+		match?: "SIMPLE" | "FULL";
+		deferrable?: boolean;
+		initiallyDeferred?: boolean;
+	};
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedIndex {
+	name: string;
+	columns: string[];
+	isUnique: boolean;
+	method?: string;
+	whereClause?: string;
+	whereClauseAst?: any;
+	includeColumns?: string[];
+	opclass?: string;
+	isExpression?: boolean;
+	expressions?: string[];
+	comment?: string;
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
+export interface ParsedTable {
+	name: string;
+	schema?: string;
+	columns: ParsedColumn[];
+	constraints: ParsedConstraint[];
+	indexes: ParsedIndex[];
+	isPartitioned: boolean;
+	partitionType?: "RANGE" | "LIST" | "HASH";
+	partitionKey?: string[];
+	partitionOf?: string;
+	partitionBound?: string;
+	inherits?: string[];
+	comment?: string;
+	childPartitions?: {
+		name: string;
+		partitionBound: string;
+	}[];
+	/** Tracking ID for rename detection in versioning */
+	trackingId?: string;
+}
 declare const EMPTY_OBJECT: unique symbol;
 declare const EMPTY_ARRAY: unique symbol;
 export interface ColumnConfig<T = unknown> {
@@ -505,6 +601,8 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 	$inferInsert: BuildInsertType<T>;
 	toSQL(): string;
 	toCreateIndexSQL(): string[];
+	/** Returns AST for schema diffing and migration generation */
+	toAST(): ParsedTable;
 }
 /**
  * AWS regions with autocomplete support

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

@@ -1,11 +1,14 @@
 import * as crypto from 'crypto';
-import { fatal, hint } from "../utils/cli-utils.js";
-import { isInitialized, getHead, getStagedChanges, getUnstagedChanges, shortHash, hashFileContent, saveFileHash, } from "../utils/repo-manager.js";
+import { colors, createSpinner, fatal, hint } from "../utils/cli-utils.js";
+import { isInitialized, getHead, getStagedChanges, getUnstagedChanges, loadSnapshot, shortHash, hashFileContent, saveFileHash, } from "../utils/repo-manager.js";
 import { loadConfig } from "../../config/config.js";
 import { getSchemaPath } from "../utils/config-loader.js";
-import { sortChangesByDependency, generateCombinedSQL, } from "../utils/change-tracker.js";
+import { sortChangesByDependency, generateCombinedSQL, generateDownSQL, } from "../utils/change-tracker.js";
+import { createCommitFromSchema, generateASTHash, } from "../utils/commit-manager.js";
+import { schemaToAST } from "../utils/schema-to-ast.js";
 import * as fs from 'fs';
 import * as path from 'path';
+import { createJiti } from 'jiti';
 export async function commitCommand(context) {
     const { config, flags, args, projectRoot } = context;
     const author = config?.author || 'Developer <dev@example.com>';
@@ -16,6 +19,9 @@ export async function commitCommand(context) {
     const schemaPath = path.resolve(projectRoot, getSchemaPath(config ?? undefined));
     const { requireValidSchema } = await import("../utils/config-loader.js");
     await requireValidSchema(schemaPath, flags);
+    if (flags['from-schema']) {
+        return commitFromSchema(context, schemaPath, author);
+    }
     const staged = getStagedChanges(projectRoot);
     if (staged.length === 0) {
         console.log('nothing to commit, working tree clean');
@@ -40,6 +46,8 @@ export async function commitCommand(context) {
     }
     const sortedChanges = sortChangesByDependency(staged);
     const sql = generateCombinedSQL(sortedChanges);
+    const downSQL = generateDownSQL(sortedChanges);
+    const snapshot = 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;
@@ -60,6 +68,8 @@ export async function commitCommand(context) {
         timestamp: new Date().toISOString(),
         changes: sortedChanges,
         sql,
+        downSQL,
+        schema: snapshot,
         snapshotHash: hash.substring(0, 12),
         stats: {
             creates,
@@ -113,4 +123,74 @@ export async function commitCommand(context) {
     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 = createSpinner();
+    let message = flags['m'] || flags['message'];
+    if (!message) {
+        if (args.length > 0) {
+            message = args.join(' ');
+        }
+        else {
+            fatal('commit message required', "usage: relq commit --from-schema -m '<message>'");
+        }
+    }
+    spinner.start('Loading schema file');
+    let schemaModule;
+    try {
+        const jiti = 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');
+        fatal(`Could not load schema: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    spinner.start('Converting schema to AST');
+    const ast = schemaToAST(schemaModule);
+    spinner.succeed('Converted schema to AST');
+    const schemaHash = generateASTHash(ast);
+    spinner.start('Creating commit');
+    try {
+        const commit = 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(`[${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(colors.muted(`Schema hash: ${schemaHash.substring(0, 12)}`));
+        console.log('');
+        hint("run 'relq push' to apply changes to database");
+        hint("run 'relq log' to view commit history");
+    }
+    catch (err) {
+        spinner.fail('Failed to create commit');
+        fatal(`Could not create commit: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 export default commitCommand;

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

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

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 } from "../utils/ast-codegen.js";
+import { generateTypeScriptFromAST, assignTrackingIds, copyTrackingIdsToNormalized } 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";
@@ -377,13 +377,18 @@ export async function pullCommand(context) {
                 console.log(`   ${colors.red(`-${removed.length}`)} tables removed`);
             }
             console.log('');
-            if (!dryRun) {
+            const noAutoMerge = flags['no-auto-merge'] === true;
+            if (!dryRun && noAutoMerge) {
                 const proceed = await confirm(`${colors.bold('Pull these changes?')}`, true);
                 if (!proceed) {
                     fatal('Operation cancelled by user');
                 }
                 console.log('');
             }
+            else if (!dryRun) {
+                console.log(`${colors.green('Auto-merging')} (no conflicts detected)`);
+                console.log('');
+            }
         }
         else if (schemaExists && !force) {
             warning('Local schema exists but not tracked');
@@ -445,6 +450,7 @@ export async function pullCommand(context) {
         }
         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',
@@ -550,7 +556,7 @@ export async function pullCommand(context) {
             triggers: filteredTriggers || [],
         };
         const schemaChanges = compareSchemas(beforeSchema, afterSchema);
-        applyTrackingIdsToSnapshot(typescript, currentSchema);
+        copyTrackingIdsToNormalized(parsedSchema, currentSchema);
         saveSnapshot(currentSchema, projectRoot);
         const duration = Date.now() - startTime;
         if (noCommit) {
@@ -656,26 +662,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/esm/cli/commands/push.js

@@ -5,7 +5,7 @@ import { getConnectionDescription } from "../utils/env-loader.js";
 import { colors, createSpinner, fatal, confirm, warning } from "../utils/cli-utils.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isEnumIgnored, isDomainIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
-import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, isCommitSyncedWith, markCommitAsPushed, getConnectionLabel, } from "../utils/repo-manager.js";
+import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, isCommitSyncedWith, markCommitAsPushed, markCommitAsApplied, getConnectionLabel, } from "../utils/repo-manager.js";
 export async function pushCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -16,7 +16,7 @@ export 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;
@@ -129,9 +129,46 @@ export async function pushCommand(context) {
             console.log('');
         }
         if (dryRun) {
-            console.log(`${colors.yellow('Dry run')} - no changes applied`);
+            console.log(`${colors.yellow('Dry run')} - showing changes that would be applied`);
             console.log('');
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq push --apply')} ${colors.muted('to execute.')}`);
+            if (hasObjectsToDrop && force) {
+                console.log(`${colors.red('DROP statements:')}`);
+                for (const obj of analysis.objectsToDrop.slice(0, 5)) {
+                    console.log(`   ${generateDropSQL(obj)}`);
+                }
+                if (analysis.objectsToDrop.length > 5) {
+                    console.log(`   ${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(`${colors.cyan(`Commit ${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(`   ${colors.muted(`... and ${statements.length - 3} more statements`)}`);
+                        }
+                        console.log('');
+                    }
+                }
+            }
+            if (totalStatements === 0 && !hasObjectsToDrop) {
+                console.log(`${colors.muted('No SQL changes to apply')}`);
+            }
+            else {
+                console.log(`${colors.muted('Total:')} ${totalStatements + (hasObjectsToDrop ? analysis.objectsToDrop.length : 0)} statements`);
+            }
+            console.log('');
+            console.log(`${colors.muted('Remove')} ${colors.cyan('--dry-run')} ${colors.muted('to execute these changes.')}`);
             console.log('');
             return;
         }
@@ -144,8 +181,8 @@ export async function pushCommand(context) {
             }
             spinner.succeed(`Pushed ${toPush.length} commit(s) to ${getConnectionLabel(connection)}`);
         }
-        if (applySQL) {
-            spinner.start('Applying SQL changes...');
+        if (!metadataOnly && !dryRun) {
+            spinner.start('Applying schema changes...');
             const pg = await import("../../addon/pg/index.js");
             const client = new pg.Client({
                 host: connection.host,
@@ -182,6 +219,9 @@ export async function pushCommand(context) {
                 }
                 await client.query('COMMIT');
                 spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+                for (const commit of commitsToProcess) {
+                    await markCommitAsApplied(connection, commit.hash);
+                }
                 let hasRenameOperations = false;
                 for (const commit of commitsToProcess) {
                     const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
@@ -226,13 +266,13 @@ export async function pushCommand(context) {
         const oldHash = remoteHead ? shortHash(remoteHead) : '(none)';
         const newHash = shortHash(localHead);
         console.log(`   ${oldHash}..${newHash}  ${colors.muted('main -> main')}`);
-        if (hasObjectsToDrop && force && applySQL) {
+        if (hasObjectsToDrop && force && !metadataOnly && !dryRun) {
             console.log('');
             warning(`Dropped ${analysis.objectsToDrop.length} object(s) from remote`);
         }
-        if (!applySQL) {
+        if (metadataOnly) {
             console.log('');
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq push --apply')} ${colors.muted('to execute SQL.')}`);
+            console.log(`${colors.muted('Metadata only - SQL not executed. Remove')} ${colors.cyan('--metadata-only')} ${colors.muted('to apply changes.')}`);
         }
         console.log('');
     }