relq 1.0.4 → 1.0.6

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

@@ -48,21 +48,69 @@ function checkEnvVars() {
         DATABASE_NAME: process.env.DATABASE_NAME,
         DATABASE_USER: process.env.DATABASE_USER,
         DATABASE_PASSWORD: process.env.DATABASE_PASSWORD,
+        DATABASE_REGION: process.env.DATABASE_REGION,
+        AWS_DATABASE_HOST: process.env.AWS_DATABASE_HOST,
+        AWS_ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID,
+        AWS_DATABASE_USER: process.env.AWS_DATABASE_USER,
+        AWS_DATABASE_NAME: process.env.AWS_DATABASE_NAME,
+        AWS_DATABASE_PORT: process.env.AWS_DATABASE_PORT,
+        AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY,
         RELQ_PG_CONN_URL: process.env.RELQ_PG_CONN_URL,
     };
     const hasConnUrl = !!vars.RELQ_PG_CONN_URL;
-    const hasIndividual = !!(vars.DATABASE_HOST && vars.DATABASE_NAME);
+    const hasIndividual = !!(vars.DATABASE_HOST && vars.DATABASE_NAME && vars.DATABASE_USER && vars.DATABASE_PASSWORD);
+    const hasAws = !!(vars.AWS_ACCESS_KEY_ID && vars.AWS_SECRET_ACCESS_KEY && vars.DATABASE_REGION && vars.AWS_DATABASE_NAME && vars.AWS_DATABASE_HOST);
     return {
-        found: hasConnUrl || hasIndividual,
+        found: hasConnUrl || hasIndividual || hasAws,
+        hasConnUrl,
+        hasIndividual,
+        hasAws,
         vars,
     };
 }
+async function askConnectionType(rl, options) {
+    const choices = [];
+    if (options.hasConnUrl) {
+        choices.push({ key: String(choices.length + 1), label: 'Connection URL (RELQ_PG_CONN_URL)', value: 'url' });
+    }
+    if (options.hasIndividual) {
+        choices.push({ key: String(choices.length + 1), label: 'Individual Config (DATABASE_HOST, DATABASE_NAME, ...)', value: 'individual' });
+    }
+    if (options.hasAws) {
+        choices.push({ key: String(choices.length + 1), label: 'AWS DSQL (AWS_ACCESS_KEY_ID, DATABASE_REGION, ...)', value: 'aws' });
+    }
+    if (choices.length === 1) {
+        return choices[0].value;
+    }
+    console.log('Multiple connection options found:');
+    console.log('');
+    for (const choice of choices) {
+        console.log(`   ${colors.cyan(choice.key)}. ${choice.label}`);
+    }
+    console.log('');
+    const answer = await ask(rl, `Which connection type? [${choices.map(c => c.key).join('/')}]`, '1');
+    const selected = choices.find(c => c.key === answer);
+    return selected?.value ?? choices[0].value;
+}
 function generateConfig(options) {
     let connectionBlock;
     if (options.useEnv) {
-        if (process.env.RELQ_PG_CONN_URL) {
+        if (options.connectionType === 'url') {
             connectionBlock = `    connection: {
         url: process.env.RELQ_PG_CONN_URL,
+    },`;
+        }
+        else if (options.connectionType === 'aws') {
+            connectionBlock = `    connection: {
+        database: process.env.AWS_DATABASE_NAME,
+        aws: {
+            hostname: process.env.AWS_DATABASE_HOST!,
+            region: process.env.DATABASE_REGION!,
+            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            user: process.env.AWS_DATABASE_USER || 'admin',
+            port: parseInt(process.env.AWS_DATABASE_PORT || '5432'),
+        },
     },`;
         }
         else {
@@ -287,30 +335,53 @@ export async function initCommand(context) {
         console.log('');
         const envCheck = checkEnvVars();
         let useEnv = false;
+        let connectionType = 'individual';
         let host = 'localhost';
         let port = '5432';
         let database = '';
         let user = 'postgres';
         let password = '';
         if (envCheck.found) {
-            console.log('Found database environment variables:');
-            if (envCheck.vars.RELQ_PG_CONN_URL) {
-                console.log('   RELQ_PG_CONN_URL');
+            console.log('Found database connection options:');
+            console.log('');
+            if (envCheck.hasConnUrl) {
+                console.log(`   ${colors.cyan('Connection URL')}`);
+                console.log(`      RELQ_PG_CONN_URL: ${envCheck.vars.RELQ_PG_CONN_URL?.substring(0, 40)}...`);
             }
-            else {
+            if (envCheck.hasIndividual) {
+                console.log(`   ${colors.cyan('Individual Config')}`);
                 if (envCheck.vars.DATABASE_HOST)
-                    console.log(`   DATABASE_HOST: ${envCheck.vars.DATABASE_HOST}`);
-                if (envCheck.vars.DATABASE_PORT)
-                    console.log(`   DATABASE_PORT: ${envCheck.vars.DATABASE_PORT}`);
+                    console.log(`      DATABASE_HOST: ${envCheck.vars.DATABASE_HOST}`);
                 if (envCheck.vars.DATABASE_NAME)
-                    console.log(`   DATABASE_NAME: ${envCheck.vars.DATABASE_NAME}`);
+                    console.log(`      DATABASE_NAME: ${envCheck.vars.DATABASE_NAME}`);
                 if (envCheck.vars.DATABASE_USER)
-                    console.log(`   DATABASE_USER: ${envCheck.vars.DATABASE_USER}`);
+                    console.log(`      DATABASE_USER: ${envCheck.vars.DATABASE_USER}`);
                 if (envCheck.vars.DATABASE_PASSWORD)
-                    console.log('   DATABASE_PASSWORD: ***');
+                    console.log('      DATABASE_PASSWORD: ***');
+            }
+            if (envCheck.hasAws) {
+                console.log(`   ${colors.cyan('AWS DSQL')}`);
+                if (envCheck.vars.AWS_DATABASE_HOST)
+                    console.log(`      AWS_DATABASE_HOST: ${envCheck.vars.AWS_DATABASE_HOST}`);
+                if (envCheck.vars.DATABASE_REGION)
+                    console.log(`      DATABASE_REGION: ${envCheck.vars.DATABASE_REGION}`);
+                if (envCheck.vars.AWS_DATABASE_NAME)
+                    console.log(`      AWS_DATABASE_NAME: ${envCheck.vars.AWS_DATABASE_NAME}`);
+                if (envCheck.vars.AWS_ACCESS_KEY_ID)
+                    console.log(`      AWS_ACCESS_KEY_ID: ${envCheck.vars.AWS_ACCESS_KEY_ID?.substring(0, 8)}...`);
+                console.log('      AWS_SECRET_ACCESS_KEY: ***');
             }
             console.log('');
-            useEnv = await askYesNo(rl, 'Use these environment variables?', true);
+            const optionCount = [envCheck.hasConnUrl, envCheck.hasIndividual, envCheck.hasAws].filter(Boolean).length;
+            if (optionCount > 1) {
+                connectionType = await askConnectionType(rl, envCheck);
+                console.log('');
+                useEnv = await askYesNo(rl, `Use ${connectionType === 'aws' ? 'AWS DSQL' : connectionType === 'url' ? 'Connection URL' : 'Individual Config'} from environment?`, true);
+            }
+            else {
+                connectionType = envCheck.hasConnUrl ? 'url' : envCheck.hasAws ? 'aws' : 'individual';
+                useEnv = await askYesNo(rl, 'Use these environment variables?', true);
+            }
             console.log('');
         }
         if (!useEnv) {
@@ -344,6 +415,7 @@ export async function initCommand(context) {
         if (!fs.existsSync(configPath)) {
             const configContent = generateConfig({
                 useEnv,
+                connectionType,
                 host,
                 port,
                 database,

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

@@ -2,11 +2,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { requireValidConfig } from "../utils/config-loader.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
-import { generateTypeScript } from "../utils/type-generator.js";
+import { introspectedToParsedSchema } from "../utils/ast-transformer.js";
+import { generateTypeScriptFromAST } from "../utils/ast-codegen.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { createSpinner, colors, formatBytes, formatDuration, fatal, confirm, warning } from "../utils/cli-utils.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";
-import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, } from "../utils/repo-manager.js";
+import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, markCommitAsPulled, } from "../utils/repo-manager.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
 function toCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
@@ -145,8 +146,8 @@ export async function pullCommand(context) {
     const author = config.author || 'Relq CLI';
     const schemaPathRaw = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
     const schemaPath = path.resolve(projectRoot, schemaPathRaw);
-    const includeFunctions = config.generate?.includeFunctions ?? false;
-    const includeTriggers = config.generate?.includeTriggers ?? false;
+    const includeFunctions = config.includeFunctions ?? true;
+    const includeTriggers = config.includeTriggers ?? true;
     const spinner = createSpinner();
     const startTime = Date.now();
     console.log('');
@@ -202,12 +203,36 @@ export async function pullCommand(context) {
             setFetchHead(remoteHead, projectRoot);
         }
         spinner.succeed(`Fetched ${remoteCommits.length} remote commits`);
-        spinner.start('Introspecting database...');
+        console.log('');
+        console.log(colors.bold('Introspecting database...'));
+        console.log('');
+        const progress = createMultiProgress();
+        const progressItems = [
+            { id: 'tables', label: 'tables', status: 'pending', count: 0 },
+            { id: 'columns', label: 'columns', status: 'pending', count: 0 },
+            { id: 'constraints', label: 'constraints', status: 'pending', count: 0 },
+            { id: 'indexes', label: 'indexes', status: 'pending', count: 0 },
+            { id: 'checks', label: 'checks', status: 'pending', count: 0 },
+            { id: 'enums', label: 'enums', status: 'pending', count: 0 },
+            { id: 'partitions', label: 'partitions', status: 'pending', count: 0 },
+            { id: 'extensions', label: 'extensions', status: 'pending', count: 0 },
+            ...(includeFunctions ? [{ id: 'functions', label: 'functions', status: 'pending', count: 0 }] : []),
+            ...(includeTriggers ? [{ id: 'triggers', label: 'triggers', status: 'pending', count: 0 }] : []),
+            { id: 'collations', label: 'collations', status: 'pending', count: 0 },
+            { id: 'foreign_servers', label: 'foreign servers', status: 'pending', count: 0 },
+            { id: 'foreign_tables', label: 'foreign tables', status: 'pending', count: 0 },
+        ];
+        progress.setItems(progressItems);
+        progress.start();
         const dbSchema = await fastIntrospectDatabase(connection, undefined, {
             includeFunctions,
             includeTriggers,
+            onDetailedProgress: (update) => {
+                progress.updateItem(update.step, { status: update.status, count: update.count });
+            },
         });
-        spinner.succeed(`Found ${dbSchema.tables.length} tables`);
+        progress.complete();
+        console.log('');
         const ignorePatterns = loadRelqignore(projectRoot);
         const filteredTables = dbSchema.tables
             .filter(t => !isTableIgnored(t.name, ignorePatterns).ignored)
@@ -241,12 +266,21 @@ export async function pullCommand(context) {
                     default: c.defaultValue,
                     primaryKey: c.isPrimaryKey,
                     unique: c.isUnique,
+                    maxLength: c.maxLength ?? null,
+                    precision: c.precision ?? null,
+                    scale: c.scale ?? null,
+                    comment: c.comment || undefined,
+                    isGenerated: c.isGenerated || false,
+                    generationExpression: c.generationExpression ?? null,
                 })),
                 indexes: t.indexes.map(i => ({
                     name: i.name,
                     columns: i.columns,
                     unique: i.isUnique,
                     type: i.type,
+                    definition: i.definition || undefined,
+                    whereClause: i.whereClause || undefined,
+                    comment: i.comment || undefined,
                 })),
                 constraints: t.constraints.map(c => ({
                     name: c.name,
@@ -256,6 +290,12 @@ export async function pullCommand(context) {
                 isPartitioned: t.isPartitioned,
                 partitionType: t.partitionType,
                 partitionKey: normalizePartitionKey(t.partitionKey),
+                comment: t.comment || undefined,
+                partitions: t.childPartitions?.map((p) => ({
+                    name: p.name,
+                    bound: p.partitionBound || '',
+                    boundType: p.partitionType,
+                })) || undefined,
             })),
             enums: filteredEnums.map(e => ({
                 name: e.name,
@@ -359,24 +399,43 @@ export async function pullCommand(context) {
             }
         }
         else if (!schemaExists) {
-            console.log('First pull - creating schema');
+            console.log(colors.bold('Creating schema') + colors.dim(' (first pull)'));
             console.log('');
+            const tableCount = filteredTables.length;
+            const columnCount = filteredTables.reduce((sum, t) => sum + t.columns.length, 0);
             const indexCount = filteredTables.reduce((sum, t) => sum + (t.indexes?.filter(i => !i.isPrimary).length || 0), 0);
-            const partitionCount = filteredTables.filter(t => t.isPartitioned).length;
+            const partitionedCount = filteredTables.filter(t => t.isPartitioned).length;
+            const childPartitionCount = filteredTables.reduce((sum, t) => sum + (t.childPartitions?.length || 0), 0);
             const tableCommentCount = filteredTables.filter(t => t.comment).length;
             const columnCommentCount = filteredTables.reduce((sum, t) => sum + t.columns.filter(c => c.comment).length, 0);
-            console.log('Schema Summary:');
-            console.log(`   ${colors.green(String(filteredTables.length))} tables`);
+            const indexCommentCount = filteredTables.reduce((sum, t) => sum + t.indexes.filter(i => i.comment).length, 0);
+            const summaryItems = [];
+            summaryItems.push({ count: tableCount, label: 'tables' });
+            summaryItems.push({ count: columnCount, label: 'columns' });
             if (indexCount > 0)
-                console.log(`   ${colors.green(String(indexCount))} indexes`);
-            if (partitionCount > 0)
-                console.log(`   ${colors.green(String(partitionCount))} partitioned tables`);
-            if (tableCommentCount > 0)
-                console.log(`   ${colors.green(String(tableCommentCount))} table comments`);
-            if (columnCommentCount > 0)
-                console.log(`   ${colors.green(String(columnCommentCount))} column comments`);
+                summaryItems.push({ count: indexCount, label: 'indexes' });
+            if (partitionedCount > 0) {
+                const partLabel = childPartitionCount > 0
+                    ? `partitioned (${childPartitionCount} child partitions)`
+                    : 'partitioned';
+                summaryItems.push({ count: partitionedCount, label: partLabel });
+            }
+            if (tableCommentCount > 0 || columnCommentCount > 0 || indexCommentCount > 0) {
+                const commentParts = [];
+                if (tableCommentCount > 0)
+                    commentParts.push(`${tableCommentCount} table`);
+                if (columnCommentCount > 0)
+                    commentParts.push(`${columnCommentCount} column`);
+                if (indexCommentCount > 0)
+                    commentParts.push(`${indexCommentCount} index`);
+                summaryItems.push({ count: tableCommentCount + columnCommentCount + indexCommentCount, label: `comments (${commentParts.join(', ')})` });
+            }
             if (dbSchema.extensions.length > 0)
-                console.log(`   ${colors.green(String(dbSchema.extensions.length))} extensions`);
+                summaryItems.push({ count: dbSchema.extensions.length, label: 'extensions' });
+            for (const item of summaryItems) {
+                const countStr = String(item.count).padStart(4);
+                console.log(`${colors.green('[+]')} ${colors.green(countStr)} ${item.label}`);
+            }
             console.log('');
         }
         if (dryRun) {
@@ -385,13 +444,10 @@ export async function pullCommand(context) {
             return;
         }
         spinner.start('Generating TypeScript schema...');
-        const typescript = generateTypeScript(dbSchema, {
-            includeDefineTables: true,
-            includeSchema: true,
-            includeIndexes: true,
-            includeFunctions,
-            includeTriggers,
+        const parsedSchema = await introspectedToParsedSchema(dbSchema);
+        const typescript = generateTypeScriptFromAST(parsedSchema, {
             camelCase: config.generate?.camelCase ?? true,
+            importPath: 'relq/schema-builder',
         });
         spinner.succeed('Generated TypeScript schema');
         const schemaDir = path.dirname(schemaPath);
@@ -494,6 +550,7 @@ export async function pullCommand(context) {
             triggers: filteredTriggers || [],
         };
         const schemaChanges = compareSchemas(beforeSchema, afterSchema);
+        applyTrackingIdsToSnapshot(typescript, currentSchema);
         saveSnapshot(currentSchema, projectRoot);
         const duration = Date.now() - startTime;
         if (noCommit) {
@@ -516,6 +573,7 @@ export async function pullCommand(context) {
             const connectionDesc = getConnectionDescription(connection);
             const commitMessage = `pull: sync from ${connectionDesc}`;
             const commit = createCommit(currentSchema, author, commitMessage, projectRoot);
+            markCommitAsPulled(commit.hash, connection, projectRoot);
             clearWorkingState(projectRoot);
             console.log('');
             console.log(`Pull completed in ${formatDuration(duration)}`);
@@ -598,3 +656,26 @@ 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, } from "../utils/repo-manager.js";
+import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, isCommitSyncedWith, markCommitAsPushed, getConnectionLabel, } from "../utils/repo-manager.js";
 export async function pushCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -41,7 +41,15 @@ export async function pushCommand(context) {
         const localCommits = getAllCommits(projectRoot);
         const remoteHashes = new Set(remoteCommits.map(c => c.hash));
         const localHashes = new Set(localCommits.map(c => c.hash));
-        const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
+        const toPush = localCommits.filter(c => {
+            if (remoteHashes.has(c.hash))
+                return false;
+            const syncStatus = isCommitSyncedWith(c, connection);
+            if (syncStatus.synced) {
+                return false;
+            }
+            return true;
+        });
         const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
         spinner.succeed('Checked remote commits');
         spinner.start('Introspecting remote database...');
@@ -131,9 +139,10 @@ export async function pushCommand(context) {
             const commitsToProcess = [...toPush].reverse();
             spinner.start(`Pushing ${toPush.length} commit(s)...`);
             for (const commit of commitsToProcess) {
-                await pushCommit(connection, commit);
+                await pushCommit(connection, commit, projectRoot);
+                markCommitAsPushed(commit.hash, connection, projectRoot);
             }
-            spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+            spinner.succeed(`Pushed ${toPush.length} commit(s) to ${getConnectionLabel(connection)}`);
         }
         if (applySQL) {
             spinner.start('Applying SQL changes...');
@@ -173,6 +182,32 @@ export async function pushCommand(context) {
                 }
                 await client.query('COMMIT');
                 spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+                let hasRenameOperations = false;
+                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.changes?.some((c) => c.type === 'RENAME')) {
+                            hasRenameOperations = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasRenameOperations) {
+                    spinner.start('Updating snapshot after RENAME...');
+                    try {
+                        const updatedSchema = await fastIntrospectDatabase(connection, undefined, {
+                            includeFunctions,
+                            includeTriggers,
+                        });
+                        const snapshotPath = path.join(projectRoot, '.relq', 'snapshot.json');
+                        fs.writeFileSync(snapshotPath, JSON.stringify(updatedSchema, null, 2));
+                        spinner.succeed('Snapshot updated with renamed objects');
+                    }
+                    catch (e) {
+                        spinner.warn('Could not update snapshot after RENAME - run "relq pull" manually');
+                    }
+                }
             }
             catch (error) {
                 try {

package/dist/esm/cli/index.js

@@ -62,7 +62,14 @@ function parseArgs(argv) {
                 flags[arg.slice(2, eqIndex)] = arg.slice(eqIndex + 1);
             }
             else {
-                flags[arg.slice(2)] = true;
+                const nextArg = argv[i + 1];
+                if (nextArg && !nextArg.startsWith('-')) {
+                    flags[arg.slice(2)] = nextArg;
+                    i++;
+                }
+                else {
+                    flags[arg.slice(2)] = true;
+                }
             }
         }
         else if (arg.startsWith('-') && arg.length === 2) {
@@ -175,6 +182,7 @@ async function main() {
         printHelp();
         process.exit(1);
     }
+    console.log('Command:', command);
     let config = null;
     let resolvedProjectRoot = process.cwd();
     if (requiresConfig(command)) {