relq 1.0.5 → 1.0.7

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

@@ -1,11 +1,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { parseSqlFile, parseFunctions, parseTriggers, parseComments } from "../utils/sql-parser.js";
-import { generateTypeScript } from "../utils/type-generator.js";
+import { parseFunctions, parseTriggers, parseComments } from "../utils/sql-parser.js";
+import { generateTypeScriptFromAST } from "../utils/ast-codegen.js";
+import { parseSQL, normalizedToParsedSchema } from "../utils/ast-transformer.js";
 import { saveSnapshot, loadSnapshot, isInitialized, initRepository, stageChanges, addUnstagedChanges } from "../utils/repo-manager.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
 import { getChangeDisplayName } from "../utils/change-tracker.js";
-import { loadRelqignore, validateIgnoreDependencies, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isSequenceIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
+import { loadRelqignore, validateIgnoreDependencies, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isSequenceIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
 import { colors, fatal, warning, hint, getWorkingTreeStatus, printDirtyWorkingTreeError, printMergeStrategyHelp, readSQLFile, createSpinner, formatBytes, } from "../utils/git-utils.js";
 export async function importCommand(sqlFilePath, options = {}, projectRoot = process.cwd()) {
     const { includeFunctions = false, includeTriggers = false, force = false, dryRun = false } = options;
@@ -66,7 +67,7 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         }
     }
     spinner.start('Parsing SQL schema');
-    const parsedSchema = parseSqlFile(sqlContent);
+    const parsedSchema = await parseSQL(sqlContent);
     const functions = includeFunctions ? parseFunctions(sqlContent) : [];
     const triggers = includeTriggers ? parseTriggers(sqlContent) : [];
     const comments = parseComments(sqlContent);
@@ -154,13 +155,6 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         }
         return true;
     });
-    const filteredCompositeTypes = parsedSchema.compositeTypes.filter(c => {
-        if (isCompositeTypeIgnored(c.name, ignorePatterns).ignored) {
-            ignoredCount++;
-            return false;
-        }
-        return true;
-    });
     const filteredSequences = parsedSchema.sequences.filter(s => {
         if (isSequenceIgnored(s.name, ignorePatterns).ignored) {
             ignoredCount++;
@@ -179,15 +173,11 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         tables: filteredTables,
         enums: filteredEnums,
         domains: filteredDomains,
-        compositeTypes: filteredCompositeTypes,
         sequences: filteredSequences,
-        collations: parsedSchema.collations,
-        foreignTables: parsedSchema.foreignTables,
         views: parsedSchema.views,
-        materializedViews: parsedSchema.materializedViews,
-        foreignServers: parsedSchema.foreignServers,
+        functions: parsedSchema.functions,
+        triggers: parsedSchema.triggers,
         extensions: parsedSchema.extensions,
-        partitions: parsedSchema.partitions,
     };
     if (ignoredCount > 0) {
         console.log(`${ignoredCount} object(s) ignored by .relqignore`);
@@ -197,14 +187,14 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
             name: t.name,
             columns: t.columns.map(c => ({
                 name: c.name,
-                type: c.dataType,
+                type: c.type,
                 default: c.defaultValue,
             })),
         })),
         enums: parsedSchema.enums,
         domains: parsedSchema.domains,
         sequences: parsedSchema.sequences,
-        compositeTypes: parsedSchema.compositeTypes,
+        compositeTypes: [],
     }, ignorePatterns);
     if (dependencyErrors.length > 0) {
         spinner.stop();
@@ -213,12 +203,6 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         return;
     }
     spinner.start('Generating TypeScript schema');
-    const dbSchema = convertToDbSchema(filteredSchema, filteredFunctions, triggers, comments);
-    const typescriptContent = generateTypeScript(dbSchema, {
-        camelCase: true,
-        includeFunctions,
-        includeTriggers,
-    });
     spinner.succeed('Generated TypeScript schema');
     const incomingSchema = convertToNormalizedSchema(filteredSchema, filteredFunctions, triggers);
     const existingSnapshot = loadSnapshot(projectRoot);
@@ -282,8 +266,91 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
         changes = [];
         console.log(`${colors.cyan('First import')} - creating initial snapshot`);
     }
-    const mergedDbSchema = snapshotToDbSchemaForGeneration(mergedSchema);
-    const finalTypescriptContent = generateTypeScript(mergedDbSchema, {
+    const astSchema = normalizedToParsedSchema({
+        tables: mergedSchema.tables.map(t => ({
+            name: t.name,
+            schema: t.schema,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                type: c.type,
+                nullable: c.nullable,
+                default: c.default,
+                primaryKey: c.primaryKey,
+                unique: c.unique,
+                check: c.check,
+                checkName: c.checkName,
+                references: c.references,
+                comment: c.comment,
+                isGenerated: c.isGenerated,
+                generatedExpression: c.generationExpression,
+                generatedExpressionAst: c.generatedExpressionAst,
+            })),
+            indexes: t.indexes.map(i => ({
+                name: i.name,
+                columns: i.columns,
+                unique: i.unique,
+                type: i.type,
+                definition: i.definition,
+                whereClause: i.whereClause,
+                whereClauseAst: i.whereClauseAst,
+            })),
+            constraints: t.constraints?.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: c.columns,
+                definition: c.definition,
+                references: c.references,
+            })),
+            isPartitioned: t.isPartitioned,
+            partitionType: t.partitionType,
+            partitionKey: t.partitionKey,
+            comment: t.comment,
+        })),
+        enums: mergedSchema.enums.map(e => ({
+            name: e.name,
+            schema: e.schema,
+            values: e.values,
+        })),
+        domains: mergedSchema.domains?.map(d => ({
+            name: d.name,
+            baseType: d.baseType,
+            notNull: d.notNull,
+            default: d.default ?? undefined,
+            check: d.check ?? undefined,
+            checkName: d.checkName,
+        })),
+        sequences: mergedSchema.sequences?.map(s => ({
+            name: s.name,
+            start: s.start,
+            increment: s.increment,
+            minValue: s.minValue,
+            maxValue: s.maxValue,
+            cache: s.cache,
+            cycle: s.cycle,
+        })),
+        extensions: mergedSchema.extensions?.map(e => e.name),
+        functions: includeFunctions ? mergedSchema.functions?.map(f => ({
+            name: f.name,
+            schema: f.schema,
+            args: f.args || [],
+            returnType: f.returnType,
+            language: f.language,
+            body: f.body,
+            volatility: f.volatility,
+            isStrict: f.isStrict,
+            securityDefiner: f.securityDefiner,
+        })) : [],
+        triggers: includeTriggers ? mergedSchema.triggers?.map(t => ({
+            name: t.name,
+            table: t.table,
+            timing: t.timing,
+            events: t.events,
+            level: t.level,
+            functionName: t.functionName,
+            when: t.when,
+        })) : [],
+    });
+    const finalTypescriptContent = generateTypeScriptFromAST(astSchema, {
         camelCase: true,
         includeFunctions,
         includeTriggers,
@@ -311,6 +378,7 @@ export async function importCommand(sqlFilePath, options = {}, projectRoot = pro
     }
     fs.writeFileSync(absoluteOutputPath, finalTypescriptContent, 'utf-8');
     console.log(`Written ${colors.cyan(absoluteOutputPath)} ${colors.gray(`(${formatBytes(finalTypescriptContent.length)})`)}`);
+    applyTrackingIdsToSnapshot(finalTypescriptContent, mergedSchema);
     saveSnapshot(mergedSchema, projectRoot);
     if (changes.length > 0) {
         addUnstagedChanges(changes, projectRoot);
@@ -359,36 +427,50 @@ function convertToDbSchema(parsed, functions = [], triggers = [], comments = [])
     return {
         tables: parsed.tables.map(t => ({
             name: t.name,
-            schema: t.schema,
+            schema: t.schema || 'public',
             comment: tableComments.get(t.name) || null,
-            columns: t.columns.map(c => ({
+            columns: t.columns
+                .filter(c => {
+                if (!c.type) {
+                    console.warn(`Warning: Skipping column ${t.name}.${c.name} (no type)`);
+                    return false;
+                }
+                return true;
+            })
+                .map(c => ({
                 name: c.name,
-                dataType: c.dataType,
-                udtName: c.dataType,
+                dataType: c.type,
+                udtName: c.type,
                 isNullable: c.isNullable,
-                defaultValue: c.defaultValue,
+                defaultValue: c.defaultValue ?? null,
                 isPrimaryKey: c.isPrimaryKey,
                 isUnique: c.isUnique,
-                maxLength: c.maxLength,
-                precision: c.precision,
-                scale: c.scale,
+                maxLength: c.typeParams?.length ?? null,
+                precision: c.typeParams?.precision ?? null,
+                scale: c.typeParams?.scale ?? null,
                 references: c.references ? `${c.references.table}.${c.references.column}` : null,
                 comment: columnComments.get(`${t.name}.${c.name}`) || c.comment || null,
                 isGenerated: c.isGenerated || false,
-                generationExpression: c.generationExpression || null,
+                generationExpression: c.generatedExpression || null,
             })),
             indexes: t.indexes.map(idx => ({
                 name: idx.name,
                 columns: idx.columns,
                 isUnique: idx.isUnique,
-                isPrimary: idx.isPrimary,
-                type: idx.type,
-                definition: idx.definition,
+                isPrimary: false,
+                type: idx.method || 'btree',
+                definition: idx.expressions?.join(', ') || idx.columns.join(', '),
                 whereClause: idx.whereClause,
-                expression: idx.expression,
+                whereClauseAst: idx.whereClauseAst,
+                expression: idx.expressions?.[0],
                 comment: indexComments.get(idx.name) || null,
             })),
-            constraints: t.constraints,
+            constraints: t.constraints.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: c.columns,
+                definition: c.expression || c.columns.join(', '),
+            })),
             rowCount: 0,
             isPartitioned: t.isPartitioned,
             partitionType: t.partitionType,
@@ -398,34 +480,31 @@ function convertToDbSchema(parsed, functions = [], triggers = [], comments = [])
             name: e.name,
             values: e.values,
         })),
-        domains: parsed.domains?.map((d) => ({
+        domains: parsed.domains.map(d => ({
             name: d.name,
             baseType: d.baseType,
             isNotNull: d.notNull || false,
-            defaultValue: d.default || null,
-            checkExpression: d.check || null,
-            check: d.check,
-            default: d.default,
+            defaultValue: d.defaultValue || null,
+            checkExpression: d.checkExpression || null,
+            check: d.checkExpression,
+            default: d.defaultValue,
             notNull: d.notNull,
-        })) || [],
-        compositeTypes: parsed.compositeTypes?.map((c) => ({
-            name: c.name,
-            attributes: c.attributes || [],
-        })) || [],
-        sequences: parsed.sequences?.map((s) => ({
+        })),
+        compositeTypes: [],
+        sequences: parsed.sequences.map(s => ({
             name: s.name,
-            dataType: s.dataType,
-            start: s.start,
+            dataType: 'bigint',
+            start: s.startValue,
             increment: s.increment,
             minValue: s.minValue,
             maxValue: s.maxValue,
             cache: s.cache,
             cycle: s.cycle,
-            ownedBy: s.ownedBy,
-        })) || [],
+            ownedBy: s.ownedBy ? `${s.ownedBy.table}.${s.ownedBy.column}` : undefined,
+        })),
         collations: [],
         extensions: parsed.extensions,
-        partitions: parsed.partitions,
+        partitions: [],
         functions: functions.map(f => ({
             ...f,
             comment: functionComments.get(f.name) || null,
@@ -440,79 +519,95 @@ function convertToDbSchema(parsed, functions = [], triggers = [], comments = [])
     };
 }
 function convertToNormalizedSchema(parsed, functions = [], triggers = []) {
+    const regularViews = parsed.views.filter(v => !v.isMaterialized);
+    const materializedViews = parsed.views.filter(v => v.isMaterialized);
     return {
         extensions: parsed.extensions.map(ext => ({ name: ext })),
         enums: parsed.enums.map(e => ({
             name: e.name,
-            schema: 'public',
+            schema: e.schema || 'public',
             values: e.values,
         })),
         domains: parsed.domains.map(d => ({
             name: d.name,
-            schema: 'public',
+            schema: d.schema || 'public',
             baseType: d.baseType,
             notNull: d.notNull || false,
-            default: d.default || null,
-            check: d.check || null,
-        })),
-        compositeTypes: parsed.compositeTypes.map(c => ({
-            name: c.name,
-            schema: 'public',
-            attributes: c.attributes,
+            default: d.defaultValue || null,
+            check: d.checkExpression || null,
         })),
+        compositeTypes: [],
         sequences: parsed.sequences.map(s => ({
             name: s.name,
-            schema: 'public',
+            schema: s.schema || 'public',
             dataType: 'bigint',
-            startValue: s.start || 1,
+            startValue: s.startValue || 1,
             increment: s.increment || 1,
             minValue: s.minValue || null,
             maxValue: s.maxValue || null,
-            cache: 1,
-            cycle: false,
-            ownedBy: null,
+            cache: s.cache || 1,
+            cycle: s.cycle || false,
+            ownedBy: s.ownedBy ? `${s.ownedBy.table}.${s.ownedBy.column}` : null,
         })),
         collations: [],
         tables: parsed.tables.map(t => {
-            const childPartitions = parsed.partitions.filter(p => p.parentTable === t.name);
             return {
                 name: t.name,
-                schema: t.schema,
-                columns: t.columns.map(c => ({
-                    name: c.name,
-                    tsName: toCamelCase(c.name),
-                    type: c.dataType,
-                    nullable: c.isNullable,
-                    default: c.defaultValue,
-                    primaryKey: c.isPrimaryKey,
-                    unique: c.isUnique,
-                    identity: c.identityGeneration ? {
-                        type: c.identityGeneration,
-                    } : undefined,
-                    isGenerated: c.isGenerated,
-                    generationExpression: c.generationExpression,
-                })),
+                schema: t.schema || 'public',
+                columns: t.columns.map(c => {
+                    const col = {
+                        name: c.name,
+                        tsName: toCamelCase(c.name),
+                        type: c.type,
+                        nullable: c.isNullable,
+                        default: c.defaultValue,
+                        primaryKey: c.isPrimaryKey,
+                        unique: c.isUnique,
+                        isGenerated: c.isGenerated,
+                        generationExpression: c.generatedExpression,
+                        generatedExpressionAst: c.generatedExpressionAst,
+                    };
+                    return col;
+                }),
                 indexes: t.indexes.map(idx => ({
                     name: idx.name,
                     columns: idx.columns,
                     unique: idx.isUnique,
-                    type: idx.type || 'btree',
-                    definition: idx.definition,
+                    type: idx.method || 'btree',
+                    definition: idx.expressions?.join(', ') || idx.columns.join(', '),
                     whereClause: idx.whereClause,
-                    expression: idx.expression,
-                })),
-                constraints: t.constraints.map(c => ({
-                    name: c.name,
-                    type: c.type,
-                    definition: c.definition,
+                    whereClauseAst: idx.whereClauseAst,
+                    expression: idx.expressions?.[0],
                 })),
+                constraints: t.constraints.map(c => {
+                    const base = {
+                        name: c.name,
+                        type: c.type,
+                        definition: c.expression || c.columns.join(', '),
+                        columns: c.columns,
+                    };
+                    if (c.type === 'FOREIGN KEY' && c.references) {
+                        base.referencedTable = c.references.table;
+                        base.referencedColumns = c.references.columns;
+                        if (c.references.onDelete)
+                            base.onDelete = c.references.onDelete;
+                        if (c.references.onUpdate)
+                            base.onUpdate = c.references.onUpdate;
+                        if (c.references.match)
+                            base.matchType = c.references.match;
+                        if (c.references.deferrable)
+                            base.deferrable = c.references.deferrable;
+                        if (c.references.initiallyDeferred)
+                            base.initiallyDeferred = c.references.initiallyDeferred;
+                    }
+                    if (c.type === 'CHECK' && c.expression) {
+                        base.checkExpression = c.expression;
+                    }
+                    return base;
+                }),
                 isPartitioned: t.isPartitioned,
                 partitionType: t.partitionType,
                 partitionKey: t.partitionKey,
-                partitions: childPartitions.length > 0 ? childPartitions.map(p => ({
-                    name: p.name,
-                    bound: p.partitionBound || '',
-                })) : undefined,
             };
         }),
         functions: functions.map(f => ({
@@ -529,16 +624,16 @@ function convertToNormalizedSchema(parsed, functions = [], triggers = []) {
             forEach: 'STATEMENT',
             functionName: t.functionName || '',
         })),
-        views: parsed.views.map(v => ({
+        views: regularViews.map(v => ({
             name: v.name,
             schema: v.schema || 'public',
             definition: v.definition,
         })),
-        materializedViews: parsed.materializedViews.map(mv => ({
+        materializedViews: materializedViews.map(mv => ({
             name: mv.name,
             schema: mv.schema || 'public',
             definition: mv.definition,
-            withData: mv.withData ?? true,
+            withData: true,
         })),
     };
 }
@@ -650,6 +745,7 @@ function snapshotToDbSchemaForGeneration(snapshot) {
                 type: i.type || 'btree',
                 definition: i.definition,
                 whereClause: i.whereClause,
+                whereClauseAst: i.whereClauseAst,
                 comment: null,
             })),
             constraints: t.constraints?.map(c => ({
@@ -749,4 +845,27 @@ function mergeSchemas(existing, incoming, replaceAll = false) {
         foreignTables: mergeByName(existing.foreignTables || [], incoming.foreignTables || []),
     };
 }
+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];
+            }
+        }
+    }
+}
 export default importCommand;

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,