relq 1.0.4 → 1.0.6

package/dist/config.d.ts

@@ -253,6 +253,14 @@ declare class ClientBase extends events.EventEmitter {
 	getTypeParser: typeof getTypeParser;
 	on<E extends "drain" | "error" | "notice" | "notification" | "end">(event: E, listener: E extends "drain" | "end" ? () => void : E extends "error" ? (err: Error) => void : E extends "notice" ? (notice: NoticeMessage) => void : (message: Notification) => void): this;
 }
+/**
+ * Type-safe PostgreSQL DEFAULT value helpers
+ * Covers all PostgreSQL default value types with 100% typed output
+ */
+export interface DefaultValue {
+	readonly $sql: string;
+	readonly $isDefault: true;
+}
 declare const EMPTY_OBJECT: unique symbol;
 declare const EMPTY_ARRAY: unique symbol;
 export interface ColumnConfig<T = unknown> {
@@ -260,7 +268,7 @@ export interface ColumnConfig<T = unknown> {
 	$sqlType?: string;
 	$tsType?: T;
 	$nullable?: boolean;
-	$default?: T | (() => T) | string | object | typeof EMPTY_OBJECT | typeof EMPTY_ARRAY;
+	$default?: T | (() => T) | string | object | typeof EMPTY_OBJECT | typeof EMPTY_ARRAY | DefaultValue;
 	$primaryKey?: boolean;
 	$unique?: boolean;
 	$references?: {
@@ -282,6 +290,7 @@ export interface ColumnConfig<T = unknown> {
 	$scale?: number;
 	$withTimezone?: boolean;
 	$columnName?: string;
+	$trackingId?: string;
 }
 /**
  * Partition Types and Builders
@@ -332,6 +341,58 @@ export interface IndexDefinition {
 	include?: string[];
 	/** Expression for expression-based indexes */
 	expression?: string;
+	/**
+	 * Generate CREATE INDEX IF NOT EXISTS instead of CREATE INDEX.
+	 *
+	 * When true, the generated SQL will be:
+	 * `CREATE INDEX IF NOT EXISTS index_name ON table_name (...)`
+	 *
+	 * This makes index creation idempotent - if the index already exists,
+	 * PostgreSQL will skip creation instead of throwing an error.
+	 *
+	 * Use cases:
+	 * - Idempotent migrations that can be run multiple times safely
+	 * - Manual schema management where you want to avoid errors on re-runs
+	 * - Incremental schema updates in development environments
+	 * - CI/CD pipelines where schema might already exist
+	 *
+	 * @default false
+	 */
+	ifNotExists?: boolean;
+	/**
+	 * Use ON ONLY clause for partitioned tables.
+	 *
+	 * When true, the generated SQL will be:
+	 * `CREATE INDEX index_name ON ONLY table_name (...)`
+	 *
+	 * This creates an index on the parent partitioned table only, without
+	 * automatically creating matching indexes on child partitions. Each
+	 * partition must have its own index created separately.
+	 *
+	 * Use cases:
+	 * - When you want different index configurations per partition
+	 * - When partitions have different access patterns
+	 * - When you want to control index creation timing per partition
+	 * - For declarative partitioning with custom index strategies
+	 * - When some partitions don't need certain indexes (e.g., archive partitions)
+	 *
+	 * @default false
+	 * @see https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE-MAINTENANCE
+	 */
+	tableOnly?: boolean;
+	/** Index comment/description */
+	comment?: string;
+	/** Tracking ID for rename detection */
+	trackingId?: string;
+}
+/** Constraint definition result */
+export interface ConstraintDef {
+	readonly $type: "PRIMARY KEY" | "UNIQUE" | "EXCLUDE";
+	readonly $name: string;
+	readonly $columns: string[];
+	readonly $expression?: string;
+	/** Tracking ID for rename detection */
+	readonly $trackingId?: string;
 }
 export type IsSerialType<T extends string> = T extends "SERIAL" | "BIGSERIAL" | "SMALLSERIAL" | "SERIAL4" | "SERIAL2" | "SERIAL8" ? true : false;
 export type HasDefault<C> = C extends {
@@ -417,6 +478,8 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 		expression: string;
 		name?: string;
 	}>;
+	/** Table-level constraints (composite PKs, etc.) */
+	$constraints?: ConstraintDef[];
 	$foreignKeys?: Array<{
 		columns: string[];
 		references: {
@@ -426,17 +489,93 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 		onDelete?: string;
 		onUpdate?: string;
 		name?: string;
+		/** Tracking ID for rename detection */
+		trackingId?: string;
 	}>;
 	$indexes?: IndexDefinition[];
 	$inherits?: string[];
 	$partitionBy?: PartitionStrategyDef;
 	$tablespace?: string;
 	$withOptions?: Record<string, unknown>;
+	/** Whether to use CREATE TABLE IF NOT EXISTS */
+	$ifNotExists?: boolean;
+	/** Tracking ID for rename detection */
+	$trackingId?: string;
 	$inferSelect: BuildSelectType<T>;
 	$inferInsert: BuildInsertType<T>;
 	toSQL(): string;
 	toCreateIndexSQL(): string[];
 }
+/**
+ * AWS regions with autocomplete support
+ * Includes all standard AWS regions that may support DSQL
+ */
+export type AwsRegion = "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-central-1" | "eu-central-2" | "eu-north-1" | "eu-south-1" | "eu-south-2" | "ap-east-1" | "ap-south-1" | "ap-south-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ap-southeast-1" | "ap-southeast-2" | "ap-southeast-3" | "ap-southeast-4" | "me-south-1" | "me-central-1" | "af-south-1" | "il-central-1" | "sa-east-1" | "ca-central-1" | "ca-west-1" | "us-gov-east-1" | "us-gov-west-1" | (string & {});
+/**
+ * AWS DSQL (Aurora Serverless) configuration
+ * When provided, Relq automatically handles IAM token generation and caching
+ *
+ * @example
+ * ```typescript
+ * const db = new Relq(schema, {
+ *     database: 'postgres',
+ *     aws: {
+ *         hostname: 'abc123.dsql.us-east-1.on.aws',
+ *         region: 'us-east-1', // Autocomplete supported!
+ *         accessKeyId: 'AKIA...',
+ *         secretAccessKey: '...'
+ *     }
+ * });
+ * ```
+ */
+export interface AwsDbConfig {
+	/**
+	 * DSQL cluster hostname
+	 * @example "7btnrhwkzis7lsxg24cqdyzsm4.dsql.us-east-1.on.aws"
+	 */
+	hostname: string;
+	/**
+	 * AWS region with autocomplete support
+	 * @example "us-east-1"
+	 */
+	region: AwsRegion;
+	/**
+	 * AWS Access Key ID
+	 * Required unless useDefaultCredentials is true
+	 */
+	accessKeyId?: string;
+	/**
+	 * AWS Secret Access Key
+	 * Required unless useDefaultCredentials is true
+	 */
+	secretAccessKey?: string;
+	/**
+	 * Database port (inherited from root config if not specified)
+	 * @default 5432
+	 */
+	port?: number;
+	/**
+	 * Database user (inherited from root config if not specified)
+	 * @default 'admin'
+	 */
+	user?: string;
+	/**
+	 * Enable SSL/TLS for connection
+	 * @default true (DSQL typically requires SSL)
+	 */
+	ssl?: boolean;
+	/**
+	 * Use AWS default credential provider chain
+	 * (env vars, IAM role, ~/.aws/credentials)
+	 * @default false
+	 */
+	useDefaultCredentials?: boolean;
+	/**
+	 * Token expiration time in seconds
+	 * @default 604800 (7 days)
+	 */
+	tokenExpiresIn?: number;
+}
 export interface RelqMigrationConfig {
 	directory: string;
 	tableName?: string;
@@ -466,6 +605,12 @@ export interface RelqCacheConfig {
 export interface RelqConnectionConfig extends Omit<PoolConfig, "ssl"> {
 	url?: string;
 	ssl?: boolean | "require" | "prefer" | "allow" | "disable" | PoolConfig["ssl"];
+	/**
+	 * AWS DSQL configuration
+	 * When provided, enables first-class AWS Aurora DSQL support
+	 * with automatic IAM token generation and caching
+	 */
+	aws?: AwsDbConfig;
 }
 export interface RelqGenerateConfig {
 	outDir: string;

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

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

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

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