relq 1.0.24 → 1.0.26

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

@@ -2,110 +2,231 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { requireValidConfig } from "../utils/config-loader.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { colors, confirm, fatal, warning } from "../utils/cli-utils.js";
-function parseMigration(content) {
-    const upMatch = content.match(/--\s*UP\s*\n([\s\S]*?)(?=--\s*DOWN|$)/i);
-    const downMatch = content.match(/--\s*DOWN\s*\n([\s\S]*?)$/i);
-    return {
-        up: upMatch?.[1]?.trim() || '',
-        down: downMatch?.[1]?.trim() || '',
-    };
-}
+import { colors, createSpinner, fatal, confirm, warning } from "../utils/cli-utils.js";
+import { isInitialized, getHead, getAllCommits, shortHash, ensureRemoteTable, markCommitAsRolledBack, } from "../utils/repo-manager.js";
+import { compareSchemas } from "../utils/schema-diff.js";
+import { generateMigrationFromComparison } from "../utils/migration-generator.js";
 export async function rollbackCommand(context) {
     const { config, args, flags } = context;
     if (!config) {
-        fatal('No configuration found', `run ${colors.cyan('relq init')} to create a configuration file`);
-        return;
+        fatal('No configuration found', `Run ${colors.cyan('relq init')} to create one.`);
     }
     await requireValidConfig(config, { calledFrom: 'rollback' });
     const connection = config.connection;
-    const migrationsDir = config.migrations?.directory || './migrations';
-    const tableName = config.migrations?.tableName || '_relq_migrations';
-    const count = parseInt(args[0]) || 1;
-    const dryRun = flags['dry-run'] === true;
-    const force = flags['force'] === true;
-    console.log(`Rolling back ${count} migration(s)...`);
-    console.log(`   Connection: ${getConnectionDescription(connection)}`);
+    const { projectRoot } = context;
+    const preview = flags['preview'] === true || flags['dry-run'] === true;
+    const skipPrompt = flags['yes'] === true || flags['y'] === true;
     console.log('');
+    if (!isInitialized(projectRoot)) {
+        fatal('not a relq repository (or any parent directories): .relq', `Run ${colors.cyan('relq init')} to initialize.`);
+    }
+    const localHead = getHead(projectRoot);
+    if (!localHead) {
+        fatal('no commits to rollback', 'Repository has no commits.');
+    }
+    const targetRef = args[0] || 'HEAD~1';
+    const target = resolveTarget(projectRoot, targetRef, localHead);
+    if (!target) {
+        fatal(`invalid rollback target: ${targetRef}`, 'Use a commit hash or HEAD~N notation.');
+    }
+    if (target.commitsToRollback.length === 0) {
+        console.log('Nothing to rollback - already at target commit.');
+        console.log('');
+        return;
+    }
+    const spinner = createSpinner();
     try {
-        const { Pool } = await import("../../addon/pg/index.js");
-        const pool = new Pool({
-            host: connection.host,
-            port: connection.port || 5432,
-            database: connection.database,
-            user: connection.user,
-            password: connection.password,
-            connectionString: connection.url,
-        });
-        try {
-            const result = await pool.query(`
-                SELECT name FROM "${tableName}" 
-                ORDER BY id DESC 
-                LIMIT $1;
-            `, [count]);
-            if (result.rows.length === 0) {
-                console.log('No migrations to rollback.');
-                return;
-            }
-            const toRollback = result.rows.map(r => r.name);
-            console.log('Migrations to rollback:');
-            for (const name of toRollback) {
-                console.log(`  - ${name}`);
-            }
+        console.log(`Rolling back to ${colors.yellow(shortHash(target.hash))}`);
+        console.log(`${colors.muted(target.message)}`);
+        console.log('');
+        console.log(`${colors.red('Commits to rollback:')} ${target.commitsToRollback.length}`);
+        for (const commit of target.commitsToRollback.slice(0, 5)) {
+            console.log(`   ${colors.red('↩')} ${shortHash(commit.hash)} ${commit.message}`);
+        }
+        if (target.commitsToRollback.length > 5) {
+            console.log(`   ${colors.muted(`... and ${target.commitsToRollback.length - 5} more`)}`);
+        }
+        console.log('');
+        const currentCommitPath = path.join(projectRoot, '.relq', 'commits', `${localHead}.json`);
+        const targetCommitPath = path.join(projectRoot, '.relq', 'commits', `${target.hash}.json`);
+        if (!fs.existsSync(currentCommitPath)) {
+            fatal(`current commit not found: ${localHead}`);
+        }
+        if (!fs.existsSync(targetCommitPath)) {
+            fatal(`target commit not found: ${target.hash}`);
+        }
+        const currentCommit = JSON.parse(fs.readFileSync(currentCommitPath, 'utf-8'));
+        const targetCommit = JSON.parse(fs.readFileSync(targetCommitPath, 'utf-8'));
+        let rollbackSQL = [];
+        if (currentCommit.schemaAST && targetCommit.schemaAST) {
+            const comparison = compareSchemas(currentCommit.schemaAST, targetCommit.schemaAST);
+            const migration = generateMigrationFromComparison(comparison);
+            rollbackSQL = migration.down;
+        }
+        else {
+            warning('No schema AST found - using commit SQL reversal (may be incomplete)');
             console.log('');
-            if (!force && !dryRun) {
-                const proceed = await confirm(`${colors.red('This will undo ' + toRollback.length + ' migration(s). Continue?')}`, false);
-                if (!proceed) {
-                    console.log('Cancelled.');
-                    return;
+            for (const commit of target.commitsToRollback) {
+                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.downSQL) {
+                        rollbackSQL.push(enhancedCommit.downSQL);
+                    }
                 }
             }
-            for (const name of toRollback) {
-                const filePath = path.join(migrationsDir, name);
-                if (!fs.existsSync(filePath)) {
-                    warning(`Migration file not found: ${name}`);
-                    continue;
-                }
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const { down } = parseMigration(content);
-                if (!down) {
-                    warning(`No DOWN section in: ${name}`);
-                    continue;
+        }
+        if (rollbackSQL.length === 0) {
+            warning('No rollback SQL generated - manual intervention may be required');
+            console.log('');
+        }
+        if (preview) {
+            console.log(`${colors.yellow('Preview')} - showing rollback SQL`);
+            console.log('');
+            if (rollbackSQL.length > 0) {
+                for (const sql of rollbackSQL.slice(0, 10)) {
+                    console.log(`   ${sql.substring(0, 100)}${sql.length > 100 ? '...' : ''}`);
                 }
-                if (dryRun) {
-                    console.log(`[dry-run] Would rollback: ${name}`);
-                    console.log(down);
-                    console.log('');
+                if (rollbackSQL.length > 10) {
+                    console.log(`   ${colors.muted(`... and ${rollbackSQL.length - 10} more statements`)}`);
                 }
-                else {
-                    console.log(`Rolling back: ${name}...`);
-                    const client = await pool.connect();
-                    try {
-                        await client.query('BEGIN');
-                        await client.query(down);
-                        await client.query(`DELETE FROM "${tableName}" WHERE name = $1`, [name]);
-                        await client.query('COMMIT');
-                        console.log('   Rolled back');
-                    }
-                    catch (error) {
-                        await client.query('ROLLBACK');
-                        throw error;
-                    }
-                    finally {
-                        client.release();
+            }
+            else {
+                console.log(`   ${colors.muted('(no SQL statements)')}`);
+            }
+            console.log('');
+            console.log(`${colors.muted('Remove')} ${colors.cyan('--preview')} ${colors.muted('to execute rollback.')}`);
+            console.log('');
+            return;
+        }
+        if (!skipPrompt) {
+            warning('This will modify your database!');
+            console.log('');
+            const confirmed = await confirm(`Rollback ${target.commitsToRollback.length} commit(s)?`, false);
+            if (!confirmed) {
+                fatal('Rollback cancelled by user');
+            }
+        }
+        spinner.start('Connecting to remote...');
+        await ensureRemoteTable(connection);
+        spinner.succeed(`Connected to ${colors.cyan(getConnectionDescription(connection))}`);
+        if (rollbackSQL.length > 0) {
+            spinner.start('Executing rollback...');
+            const pg = await import("../../addon/pg/index.js");
+            const client = new pg.Client({
+                host: connection.host,
+                port: connection.port,
+                database: connection.database,
+                user: connection.user,
+                password: connection.password,
+            });
+            try {
+                await client.connect();
+                await client.query('BEGIN');
+                let statementsRun = 0;
+                for (const sql of rollbackSQL) {
+                    if (sql.trim()) {
+                        await client.query(sql);
+                        statementsRun++;
                     }
                 }
+                await client.query('COMMIT');
+                spinner.succeed(`Executed ${statementsRun} rollback statement(s)`);
+            }
+            catch (error) {
+                try {
+                    await client.query('ROLLBACK');
+                    spinner.fail('Rollback failed - transaction rolled back');
+                }
+                catch {
+                    spinner.fail('Rollback failed');
+                }
+                throw error;
             }
-            if (!dryRun) {
-                console.log('');
-                console.log(`Rolled back ${toRollback.length} migration(s).`);
+            finally {
+                await client.end();
             }
         }
-        finally {
-            await pool.end();
+        spinner.start('Updating commit status...');
+        for (const commit of target.commitsToRollback) {
+            await markCommitAsRolledBack(connection, commit.hash);
         }
+        spinner.succeed('Marked commits as rolled back');
+        const headPath = path.join(projectRoot, '.relq', 'HEAD');
+        fs.writeFileSync(headPath, target.hash);
+        if (targetCommit.schema) {
+            const snapshotPath = path.join(projectRoot, '.relq', 'snapshot.json');
+            fs.writeFileSync(snapshotPath, JSON.stringify(targetCommit.schema, null, 2));
+        }
+        console.log('');
+        console.log(`${colors.green('Rollback complete')}`);
+        console.log(`   ${shortHash(localHead)} → ${shortHash(target.hash)}`);
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Rollback failed');
+        fatal(err instanceof Error ? err.message : String(err));
     }
-    catch (error) {
-        fatal('Rollback failed', error instanceof Error ? error.message : String(error));
+}
+function resolveTarget(projectRoot, ref, currentHead) {
+    const commits = getAllCommits(projectRoot);
+    const commitsByHash = new Map(commits.map(c => [c.hash, c]));
+    if (ref.startsWith('HEAD~')) {
+        const n = parseInt(ref.slice(5), 10);
+        if (isNaN(n) || n < 1)
+            return null;
+        let current = currentHead;
+        const commitsToRollback = [];
+        for (let i = 0; i < n; i++) {
+            const commitPath = path.join(projectRoot, '.relq', 'commits', `${current}.json`);
+            if (!fs.existsSync(commitPath))
+                return null;
+            const commit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+            commitsToRollback.push(commit);
+            if (!commit.parentHash) {
+                if (i < n - 1) {
+                    return null;
+                }
+                return {
+                    hash: commit.hash,
+                    message: '(initial state)',
+                    commitsToRollback: commitsToRollback.slice(0, -1),
+                };
+            }
+            current = commit.parentHash;
+        }
+        const targetPath = path.join(projectRoot, '.relq', 'commits', `${current}.json`);
+        if (!fs.existsSync(targetPath))
+            return null;
+        const targetCommit = JSON.parse(fs.readFileSync(targetPath, 'utf-8'));
+        return {
+            hash: current,
+            message: targetCommit.message,
+            commitsToRollback,
+        };
     }
+    const normalizedRef = ref.length < 40 ? commits.find(c => c.hash.startsWith(ref))?.hash : ref;
+    if (!normalizedRef || !commitsByHash.has(normalizedRef)) {
+        return null;
+    }
+    const commitsToRollback = [];
+    let current = currentHead;
+    while (current && current !== normalizedRef) {
+        const commitPath = path.join(projectRoot, '.relq', 'commits', `${current}.json`);
+        if (!fs.existsSync(commitPath))
+            break;
+        const commit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+        commitsToRollback.push(commit);
+        current = commit.parentHash || '';
+    }
+    if (current !== normalizedRef) {
+        return null;
+    }
+    const targetCommit = commitsByHash.get(normalizedRef);
+    return {
+        hash: normalizedRef,
+        message: targetCommit?.message || '',
+        commitsToRollback,
+    };
 }
+export default rollbackCommand;

package/dist/esm/cli/commands/schema-ast.js

@@ -0,0 +1,183 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createJiti } from 'jiti';
+import { getSchemaPath } from "../utils/config-loader.js";
+import { schemaToAST } from "../utils/schema-to-ast.js";
+import { colors, createSpinner } from "../utils/spinner.js";
+export async function schemaAstCommand(context) {
+    const { config, args, flags, projectRoot } = context;
+    const spinner = createSpinner();
+    console.log('');
+    const options = {
+        json: Boolean(flags.json),
+        output: flags.output,
+        pretty: flags.pretty !== false,
+    };
+    let schemaPath;
+    if (args.length > 0) {
+        schemaPath = path.resolve(projectRoot, args[0]);
+    }
+    else {
+        schemaPath = path.resolve(projectRoot, getSchemaPath(config ?? undefined));
+    }
+    const relativePath = path.relative(process.cwd(), schemaPath);
+    spinner.start(`Loading schema from ${colors.cyan(relativePath)}`);
+    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 from ${colors.cyan(relativePath)}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to load schema`);
+        console.log('');
+        console.log(colors.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        console.log('');
+        console.log(colors.yellow('hint:') + ` Make sure ${relativePath} is a valid TypeScript schema file.`);
+        console.log('');
+        process.exit(1);
+    }
+    spinner.start('Converting schema to AST');
+    let ast;
+    try {
+        ast = schemaToAST(schemaModule);
+        spinner.succeed('Converted schema to AST');
+    }
+    catch (error) {
+        spinner.fail('Failed to convert schema');
+        console.log('');
+        console.log(colors.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        console.log('');
+        process.exit(1);
+    }
+    const indent = options.pretty ? 2 : 0;
+    const output = JSON.stringify(ast, null, indent);
+    if (options.output) {
+        const outputPath = path.resolve(projectRoot, options.output);
+        const outputDir = path.dirname(outputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, output, 'utf-8');
+        console.log('');
+        console.log(`Written AST to ${colors.cyan(options.output)}`);
+    }
+    else if (options.json) {
+        console.log(output);
+    }
+    else {
+        console.log('');
+        printAstSummary(ast);
+        console.log('');
+        console.log(colors.muted(`Use ${colors.cyan('--json')} for full AST output or ${colors.cyan('--output <file>')} to write to file.`));
+    }
+    console.log('');
+}
+function printAstSummary(ast) {
+    console.log(colors.bold('Schema AST Summary'));
+    console.log('');
+    if (ast.extensions.length > 0) {
+        console.log(colors.cyan('Extensions:') + ` ${ast.extensions.length}`);
+        for (const ext of ast.extensions) {
+            console.log(`  ${colors.green('•')} ${ext}`);
+        }
+        console.log('');
+    }
+    if (ast.enums.length > 0) {
+        console.log(colors.cyan('Enums:') + ` ${ast.enums.length}`);
+        for (const e of ast.enums) {
+            const tid = e.trackingId ? colors.muted(` [${e.trackingId}]`) : '';
+            console.log(`  ${colors.green('•')} ${e.name}${tid}: (${e.values.join(', ')})`);
+        }
+        console.log('');
+    }
+    if (ast.domains.length > 0) {
+        console.log(colors.cyan('Domains:') + ` ${ast.domains.length}`);
+        for (const d of ast.domains) {
+            const tid = d.trackingId ? colors.muted(` [${d.trackingId}]`) : '';
+            console.log(`  ${colors.green('•')} ${d.name}${tid}: ${d.baseType}`);
+        }
+        console.log('');
+    }
+    if (ast.compositeTypes.length > 0) {
+        console.log(colors.cyan('Composite Types:') + ` ${ast.compositeTypes.length}`);
+        for (const c of ast.compositeTypes) {
+            const tid = c.trackingId ? colors.muted(` [${c.trackingId}]`) : '';
+            const attrs = c.attributes.map(a => a.name).join(', ');
+            console.log(`  ${colors.green('•')} ${c.name}${tid}: (${attrs})`);
+        }
+        console.log('');
+    }
+    if (ast.sequences.length > 0) {
+        console.log(colors.cyan('Sequences:') + ` ${ast.sequences.length}`);
+        for (const s of ast.sequences) {
+            const tid = s.trackingId ? colors.muted(` [${s.trackingId}]`) : '';
+            console.log(`  ${colors.green('•')} ${s.name}${tid}`);
+        }
+        console.log('');
+    }
+    if (ast.tables.length > 0) {
+        console.log(colors.cyan('Tables:') + ` ${ast.tables.length}`);
+        for (const t of ast.tables) {
+            const tid = t.trackingId ? colors.muted(` [${t.trackingId}]`) : '';
+            console.log(`  ${colors.green('•')} ${t.name}${tid}`);
+            console.log(`      Columns: ${t.columns.length}`);
+            for (const col of t.columns.slice(0, 5)) {
+                const colTid = col.trackingId ? colors.muted(` [${col.trackingId}]`) : '';
+                const pk = col.isPrimaryKey ? colors.yellow(' PK') : '';
+                const nullable = col.isNullable ? '' : colors.red(' NOT NULL');
+                console.log(`        - ${col.name}${colTid}: ${col.type}${pk}${nullable}`);
+            }
+            if (t.columns.length > 5) {
+                console.log(`        ${colors.muted(`... and ${t.columns.length - 5} more`)}`);
+            }
+            if (t.indexes.length > 0) {
+                console.log(`      Indexes: ${t.indexes.length}`);
+            }
+            if (t.constraints.length > 0) {
+                console.log(`      Constraints: ${t.constraints.length}`);
+            }
+        }
+        console.log('');
+    }
+    if (ast.views.length > 0) {
+        console.log(colors.cyan('Views:') + ` ${ast.views.length}`);
+        for (const v of ast.views) {
+            const tid = v.trackingId ? colors.muted(` [${v.trackingId}]`) : '';
+            const mat = v.isMaterialized ? colors.yellow(' (materialized)') : '';
+            console.log(`  ${colors.green('•')} ${v.name}${tid}${mat}`);
+        }
+        console.log('');
+    }
+    if (ast.functions.length > 0) {
+        console.log(colors.cyan('Functions:') + ` ${ast.functions.length}`);
+        for (const f of ast.functions) {
+            const tid = f.trackingId ? colors.muted(` [${f.trackingId}]`) : '';
+            const args = f.args.map(a => a.type).join(', ');
+            console.log(`  ${colors.green('•')} ${f.name}${tid}(${args}) -> ${f.returnType}`);
+        }
+        console.log('');
+    }
+    if (ast.triggers.length > 0) {
+        console.log(colors.cyan('Triggers:') + ` ${ast.triggers.length}`);
+        for (const tr of ast.triggers) {
+            const tid = tr.trackingId ? colors.muted(` [${tr.trackingId}]`) : '';
+            console.log(`  ${colors.green('•')} ${tr.name}${tid} on ${tr.table}`);
+        }
+        console.log('');
+    }
+    const total = ast.tables.length + ast.enums.length + ast.views.length +
+        ast.functions.length + ast.triggers.length + ast.sequences.length +
+        ast.domains.length + ast.compositeTypes.length;
+    console.log(colors.bold(`Total: ${total} schema objects`));
+}
+export default schemaAstCommand;

package/dist/esm/cli/index.js

@@ -22,6 +22,7 @@ import { tagCommand } from "./commands/tag.js";
 import { cherryPickCommand } from "./commands/cherry-pick.js";
 import { remoteCommand } from "./commands/remote.js";
 import { validateCommand } from "./commands/validate.js";
+import { schemaAstCommand } from "./commands/schema-ast.js";
 import * as fs from 'fs';
 import * as path from 'path';
 function loadEnvFile() {
@@ -132,6 +133,7 @@ Other Commands:
   introspect          Parse database schema
   import <sql-file>   Import SQL file to schema
   export [file]       Export schema to SQL file
+  schema:ast [file]   Convert schema to AST (JSON)
 
 Options:
   --help, -h          Show this help
@@ -323,6 +325,10 @@ async function main() {
             case 'validate':
                 await validateCommand(context);
                 break;
+            case 'schema:ast':
+            case 'ast':
+                await schemaAstCommand(context);
+                break;
             case 'sync':
                 await syncCommand(context);
                 break;

package/dist/esm/cli/utils/ast-codegen.js

@@ -14,6 +14,96 @@ function generateTrackingId(prefix) {
 export function resetTrackingIdCounter() {
     trackingIdCounter = 0;
 }
+export function assignTrackingIds(schema) {
+    for (const table of schema.tables) {
+        if (!table.trackingId) {
+            table.trackingId = generateTrackingId('t');
+        }
+        for (const col of table.columns) {
+            if (!col.trackingId) {
+                col.trackingId = generateTrackingId('c');
+            }
+        }
+        for (const idx of table.indexes) {
+            if (!idx.trackingId) {
+                idx.trackingId = generateTrackingId('i');
+            }
+        }
+    }
+    for (const e of schema.enums) {
+        if (!e.trackingId) {
+            e.trackingId = generateTrackingId('t');
+        }
+    }
+    for (const f of schema.functions) {
+        if (!f.trackingId) {
+            f.trackingId = generateTrackingId('f');
+        }
+    }
+    for (const s of schema.sequences) {
+        if (!s.trackingId) {
+            s.trackingId = generateTrackingId('t');
+        }
+    }
+    for (const v of schema.views) {
+        if (!v.trackingId) {
+            v.trackingId = generateTrackingId('t');
+        }
+    }
+    for (const d of schema.domains) {
+        if (!d.trackingId) {
+            d.trackingId = generateTrackingId('t');
+        }
+    }
+    for (const tr of schema.triggers) {
+        if (!tr.trackingId) {
+            tr.trackingId = generateTrackingId('t');
+        }
+    }
+    return schema;
+}
+export function copyTrackingIdsToNormalized(parsedSchema, normalizedSchema) {
+    const tableMap = new Map();
+    for (const table of parsedSchema.tables) {
+        const columnMap = new Map();
+        for (const col of table.columns) {
+            if (col.trackingId) {
+                columnMap.set(col.name, col.trackingId);
+            }
+        }
+        const indexMap = new Map();
+        for (const idx of table.indexes) {
+            if (idx.trackingId) {
+                indexMap.set(idx.name, idx.trackingId);
+            }
+        }
+        tableMap.set(table.name, {
+            trackingId: table.trackingId,
+            columns: columnMap,
+            indexes: indexMap,
+        });
+    }
+    for (const table of normalizedSchema.tables) {
+        const parsed = tableMap.get(table.name);
+        if (!parsed)
+            continue;
+        if (parsed.trackingId) {
+            table.trackingId = parsed.trackingId;
+        }
+        for (const col of table.columns) {
+            const colTrackingId = parsed.columns.get(col.name);
+            if (colTrackingId) {
+                col.trackingId = colTrackingId;
+            }
+        }
+        for (const idx of table.indexes) {
+            const idxTrackingId = parsed.indexes.get(idx.name);
+            if (idxTrackingId) {
+                idx.trackingId = idxTrackingId;
+            }
+        }
+    }
+}
 function getExplicitFKName(constraintName, tableName, columnName) {
     if (!constraintName)
         return undefined;
@@ -81,7 +171,7 @@ function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOver
     if (!col.isNullable && !col.isPrimaryKey) {
         line += '.notNull()';
     }
-    const trackingId = generateTrackingId('c');
+    const trackingId = col.trackingId || generateTrackingId('c');
     line += `.$id('${trackingId}')`;
     return line + commentSuffix;
 }
@@ -127,7 +217,7 @@ function generateIndexCode(index, useCamelCase) {
         const includeCols = index.includeColumns.map(c => `table.${useCamelCase ? toCamelCase(c) : c}`).join(', ');
         line += `.include(${includeCols})`;
     }
-    const trackingId = generateTrackingId('i');
+    const trackingId = index.trackingId || generateTrackingId('i');
     line += `.$id('${trackingId}')`;
     if (index.comment) {
         line += `.comment('${escapeString(index.comment)}')`;
@@ -396,7 +486,7 @@ function generateTableCode(table, useCamelCase, enumNames, domainNames) {
     if (tableComment) {
         optionParts.push(tableComment);
     }
-    const tableTrackingId = generateTrackingId('t');
+    const tableTrackingId = table.trackingId || generateTrackingId('t');
     optionParts.push(`    $trackingId: '${tableTrackingId}'`);
     let tableCode;
     if (optionParts.length > 0) {