relq 1.0.25 → 1.0.27

package/dist/cjs/cli/utils/ast-codegen.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetTrackingIdCounter = resetTrackingIdCounter;
+exports.assignTrackingIds = assignTrackingIds;
+exports.copyTrackingIdsToNormalized = copyTrackingIdsToNormalized;
 exports.generateTypeScriptFromAST = generateTypeScriptFromAST;
 const utils_1 = require("./ast/codegen/utils.cjs");
 const builder_1 = require("./ast/codegen/builder.cjs");
@@ -18,6 +20,96 @@ function generateTrackingId(prefix) {
 function resetTrackingIdCounter() {
     trackingIdCounter = 0;
 }
+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;
+}
+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;
@@ -85,7 +177,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;
 }
@@ -131,7 +223,7 @@ function generateIndexCode(index, useCamelCase) {
         const includeCols = index.includeColumns.map(c => `table.${useCamelCase ? (0, utils_1.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('${(0, utils_1.escapeString)(index.comment)}')`;
@@ -400,7 +492,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) {

package/dist/cjs/cli/utils/ast-transformer.cjs

@@ -486,6 +486,7 @@ async function parseSQL(sql) {
     const schema = {
         enums: [],
         domains: [],
+        compositeTypes: [],
         sequences: [],
         tables: [],
         views: [],
@@ -560,6 +561,7 @@ async function introspectedToParsedSchema(schema) {
         tables: [],
         enums: [],
         domains: [],
+        compositeTypes: [],
         sequences: [],
         views: [],
         functions: [],
@@ -581,6 +583,15 @@ async function introspectedToParsedSchema(schema) {
             checkExpression: d.checkExpression,
         });
     }
+    for (const ct of schema.compositeTypes || []) {
+        parsed.compositeTypes.push({
+            name: ct.name,
+            attributes: ct.attributes.map(attr => ({
+                name: attr.name,
+                type: attr.type,
+            })),
+        });
+    }
     for (const t of schema.tables || []) {
         const columns = [];
         for (const c of t.columns) {
@@ -814,6 +825,7 @@ function normalizedToParsedSchema(schema) {
             checkExpression: d.check,
             checkName: d.checkName,
         })),
+        compositeTypes: [],
         sequences: (schema.sequences || []).map(s => ({
             name: s.name,
             startValue: s.start,

package/dist/cjs/cli/utils/change-tracker.cjs

@@ -39,6 +39,7 @@ exports.createChange = createChange;
 exports.getChangeDisplayName = getChangeDisplayName;
 exports.sortChangesByDependency = sortChangesByDependency;
 exports.generateCombinedSQL = generateCombinedSQL;
+exports.generateDownSQL = generateDownSQL;
 const crypto = __importStar(require("crypto"));
 function generateChangeId(type, objectType, objectName, parentName) {
     const input = `${type}:${objectType}:${parentName || ''}:${objectName}:${Date.now()}`;
@@ -597,3 +598,137 @@ function generateCombinedSQL(changes) {
     }
     return lines.join('\n');
 }
+function generateDownSQL(changes) {
+    const reversed = [...changes].reverse();
+    const lines = [
+        '--',
+        '-- DOWN Migration (Rollback)',
+        `-- Generated at: ${new Date().toISOString()}`,
+        '--',
+        '',
+    ];
+    for (const change of reversed) {
+        const downSQL = generateDownSQLForChange(change);
+        if (downSQL) {
+            lines.push(downSQL);
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+function generateDownSQLForChange(change) {
+    const { type, objectType, objectName, parentName, before, after } = change;
+    switch (type) {
+        case 'CREATE':
+            return generateDropSQL(objectType, objectName, parentName);
+        case 'DROP':
+            if (before) {
+                return generateCreateSQL(objectType, objectName, before, parentName);
+            }
+            return `-- Cannot reverse DROP ${objectType} ${objectName} (no 'before' state saved)`;
+        case 'ALTER':
+            if (before && after) {
+                return generateAlterReverseSQL(objectType, objectName, after, before, parentName);
+            }
+            return `-- Cannot reverse ALTER ${objectType} ${objectName} (no state saved)`;
+        case 'RENAME':
+            if (before && after) {
+                const oldName = before.name || objectName;
+                const newName = after.name || objectName;
+                return generateRenameSQL(objectType, newName, oldName, parentName);
+            }
+            return `-- Cannot reverse RENAME ${objectType} ${objectName} (no state saved)`;
+        default:
+            return null;
+    }
+}
+function generateDropSQL(objectType, objectName, parentName) {
+    switch (objectType) {
+        case 'TABLE':
+            return `DROP TABLE IF EXISTS "${objectName}" CASCADE;`;
+        case 'COLUMN':
+            return `ALTER TABLE "${parentName}" DROP COLUMN IF EXISTS "${objectName}";`;
+        case 'INDEX':
+            return `DROP INDEX IF EXISTS "${objectName}";`;
+        case 'ENUM':
+            return `DROP TYPE IF EXISTS "${objectName}";`;
+        case 'SEQUENCE':
+            return `DROP SEQUENCE IF EXISTS "${objectName}";`;
+        case 'FUNCTION':
+            return `DROP FUNCTION IF EXISTS "${objectName}" CASCADE;`;
+        case 'TRIGGER':
+            return `DROP TRIGGER IF EXISTS "${objectName}" ON "${parentName}";`;
+        case 'VIEW':
+            return `DROP VIEW IF EXISTS "${objectName}";`;
+        case 'CONSTRAINT':
+        case 'CHECK':
+        case 'FOREIGN_KEY':
+        case 'PRIMARY_KEY':
+            return `ALTER TABLE "${parentName}" DROP CONSTRAINT IF EXISTS "${objectName}";`;
+        default:
+            return `-- Cannot generate DROP for ${objectType} ${objectName}`;
+    }
+}
+function generateCreateSQL(objectType, objectName, state, parentName) {
+    switch (objectType) {
+        case 'COLUMN':
+            if (state.dataType) {
+                const nullable = state.isNullable === false ? ' NOT NULL' : '';
+                const defaultVal = state.defaultValue ? ` DEFAULT ${state.defaultValue}` : '';
+                return `ALTER TABLE "${parentName}" ADD COLUMN "${objectName}" ${state.dataType}${nullable}${defaultVal};`;
+            }
+            break;
+        case 'INDEX':
+            if (state.columns) {
+                const unique = state.isUnique ? 'UNIQUE ' : '';
+                const cols = Array.isArray(state.columns) ? state.columns.join(', ') : state.columns;
+                return `CREATE ${unique}INDEX "${objectName}" ON "${state.tableName || parentName}" (${cols});`;
+            }
+            break;
+    }
+    return `-- Cannot reconstruct CREATE ${objectType} ${objectName} from saved state`;
+}
+function generateAlterReverseSQL(objectType, objectName, from, to, parentName) {
+    switch (objectType) {
+        case 'COLUMN':
+            const stmts = [];
+            if (from.dataType !== to.dataType && to.dataType) {
+                stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" TYPE ${to.dataType};`);
+            }
+            if (from.isNullable !== to.isNullable) {
+                if (to.isNullable === false) {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" SET NOT NULL;`);
+                }
+                else {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" DROP NOT NULL;`);
+                }
+            }
+            if (from.defaultValue !== to.defaultValue) {
+                if (to.defaultValue) {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" SET DEFAULT ${to.defaultValue};`);
+                }
+                else {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" DROP DEFAULT;`);
+                }
+            }
+            return stmts.length > 0 ? stmts.join('\n') : `-- No reverse ALTER needed for ${objectName}`;
+        default:
+            return `-- Cannot reverse ALTER ${objectType} ${objectName}`;
+    }
+}
+function generateRenameSQL(objectType, fromName, toName, parentName) {
+    switch (objectType) {
+        case 'TABLE':
+            return `ALTER TABLE "${fromName}" RENAME TO "${toName}";`;
+        case 'COLUMN':
+            return `ALTER TABLE "${parentName}" RENAME COLUMN "${fromName}" TO "${toName}";`;
+        case 'INDEX':
+            return `ALTER INDEX "${fromName}" RENAME TO "${toName}";`;
+        case 'ENUM':
+            return `ALTER TYPE "${fromName}" RENAME TO "${toName}";`;
+        case 'SEQUENCE':
+            return `ALTER SEQUENCE "${fromName}" RENAME TO "${toName}";`;
+        default:
+            return `-- Cannot rename ${objectType} ${fromName} to ${toName}`;
+    }
+}

package/dist/cjs/cli/utils/commit-manager.cjs

@@ -46,9 +46,14 @@ exports.getLatestRemoteCommit = getLatestRemoteCommit;
 exports.addRemoteCommit = addRemoteCommit;
 exports.createCommit = createCommit;
 exports.checkSyncStatus = checkSyncStatus;
+exports.generateASTHash = generateASTHash;
+exports.createCommitFromSchema = createCommitFromSchema;
+exports.createCommitFromSchemaWithRemote = createCommitFromSchemaWithRemote;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
 const schema_hash_1 = require("./schema-hash.cjs");
+const schema_to_ast_1 = require("./schema-to-ast.cjs");
 const RELQ_DIR = '.relq';
 const COMMITS_FILE = 'commits.json';
 const HEAD_FILE = 'HEAD';
@@ -237,3 +242,52 @@ async function checkSyncStatus(connection, baseDir = process.cwd()) {
     const remoteAhead = [...remoteHashes].filter(h => !localHashes.has(h)).length;
     return { inSync, localHead, remoteHead, localAhead, remoteAhead };
 }
+function generateASTHash(ast) {
+    const normalized = {
+        enums: [...ast.enums].sort((a, b) => a.name.localeCompare(b.name)),
+        domains: [...ast.domains].sort((a, b) => a.name.localeCompare(b.name)),
+        compositeTypes: [...ast.compositeTypes].sort((a, b) => a.name.localeCompare(b.name)),
+        sequences: [...ast.sequences].sort((a, b) => a.name.localeCompare(b.name)),
+        tables: [...ast.tables].sort((a, b) => a.name.localeCompare(b.name)),
+        views: [...ast.views].sort((a, b) => a.name.localeCompare(b.name)),
+        functions: [...ast.functions].sort((a, b) => a.name.localeCompare(b.name)),
+        triggers: [...ast.triggers].sort((a, b) => a.name.localeCompare(b.name)),
+        extensions: [...ast.extensions].sort(),
+    };
+    const json = JSON.stringify(normalized, null, 0);
+    return crypto
+        .createHash('sha1')
+        .update(json, 'utf8')
+        .digest('hex');
+}
+function createCommitFromSchema(schema, author, message, commitLimit = 1000, baseDir = process.cwd()) {
+    const parsedSchema = (0, schema_to_ast_1.schemaToAST)(schema);
+    const hash = generateASTHash(parsedSchema);
+    const parentHash = getLocalHead(baseDir);
+    const commit = {
+        hash,
+        parentHash,
+        schemaSnapshot: parsedSchema,
+        author,
+        message,
+        createdAt: new Date(),
+    };
+    addLocalCommit(commit, commitLimit, baseDir);
+    return commit;
+}
+async function createCommitFromSchemaWithRemote(schema, connection, author, message, commitLimit = 1000, baseDir = process.cwd()) {
+    const parsedSchema = (0, schema_to_ast_1.schemaToAST)(schema);
+    const hash = generateASTHash(parsedSchema);
+    const parentHash = getLocalHead(baseDir);
+    const commit = {
+        hash,
+        parentHash,
+        schemaSnapshot: parsedSchema,
+        author,
+        message,
+        createdAt: new Date(),
+    };
+    addLocalCommit(commit, commitLimit, baseDir);
+    await addRemoteCommit(connection, commit, commitLimit);
+    return commit;
+}