relq 1.0.24 → 1.0.26

package/dist/cjs/cli/commands/schema-ast.cjs

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaAstCommand = schemaAstCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const jiti_1 = require("jiti");
+const config_loader_1 = require("../utils/config-loader.cjs");
+const schema_to_ast_1 = require("../utils/schema-to-ast.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+async function schemaAstCommand(context) {
+    const { config, args, flags, projectRoot } = context;
+    const spinner = (0, spinner_1.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, (0, config_loader_1.getSchemaPath)(config ?? undefined));
+    }
+    const relativePath = path.relative(process.cwd(), schemaPath);
+    spinner.start(`Loading schema from ${spinner_1.colors.cyan(relativePath)}`);
+    let schemaModule;
+    try {
+        const jiti = (0, jiti_1.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 ${spinner_1.colors.cyan(relativePath)}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to load schema`);
+        console.log('');
+        console.log(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        console.log('');
+        console.log(spinner_1.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 = (0, schema_to_ast_1.schemaToAST)(schemaModule);
+        spinner.succeed('Converted schema to AST');
+    }
+    catch (error) {
+        spinner.fail('Failed to convert schema');
+        console.log('');
+        console.log(spinner_1.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 ${spinner_1.colors.cyan(options.output)}`);
+    }
+    else if (options.json) {
+        console.log(output);
+    }
+    else {
+        console.log('');
+        printAstSummary(ast);
+        console.log('');
+        console.log(spinner_1.colors.muted(`Use ${spinner_1.colors.cyan('--json')} for full AST output or ${spinner_1.colors.cyan('--output <file>')} to write to file.`));
+    }
+    console.log('');
+}
+function printAstSummary(ast) {
+    console.log(spinner_1.colors.bold('Schema AST Summary'));
+    console.log('');
+    if (ast.extensions.length > 0) {
+        console.log(spinner_1.colors.cyan('Extensions:') + ` ${ast.extensions.length}`);
+        for (const ext of ast.extensions) {
+            console.log(`  ${spinner_1.colors.green('•')} ${ext}`);
+        }
+        console.log('');
+    }
+    if (ast.enums.length > 0) {
+        console.log(spinner_1.colors.cyan('Enums:') + ` ${ast.enums.length}`);
+        for (const e of ast.enums) {
+            const tid = e.trackingId ? spinner_1.colors.muted(` [${e.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${e.name}${tid}: (${e.values.join(', ')})`);
+        }
+        console.log('');
+    }
+    if (ast.domains.length > 0) {
+        console.log(spinner_1.colors.cyan('Domains:') + ` ${ast.domains.length}`);
+        for (const d of ast.domains) {
+            const tid = d.trackingId ? spinner_1.colors.muted(` [${d.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${d.name}${tid}: ${d.baseType}`);
+        }
+        console.log('');
+    }
+    if (ast.compositeTypes.length > 0) {
+        console.log(spinner_1.colors.cyan('Composite Types:') + ` ${ast.compositeTypes.length}`);
+        for (const c of ast.compositeTypes) {
+            const tid = c.trackingId ? spinner_1.colors.muted(` [${c.trackingId}]`) : '';
+            const attrs = c.attributes.map(a => a.name).join(', ');
+            console.log(`  ${spinner_1.colors.green('•')} ${c.name}${tid}: (${attrs})`);
+        }
+        console.log('');
+    }
+    if (ast.sequences.length > 0) {
+        console.log(spinner_1.colors.cyan('Sequences:') + ` ${ast.sequences.length}`);
+        for (const s of ast.sequences) {
+            const tid = s.trackingId ? spinner_1.colors.muted(` [${s.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${s.name}${tid}`);
+        }
+        console.log('');
+    }
+    if (ast.tables.length > 0) {
+        console.log(spinner_1.colors.cyan('Tables:') + ` ${ast.tables.length}`);
+        for (const t of ast.tables) {
+            const tid = t.trackingId ? spinner_1.colors.muted(` [${t.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${t.name}${tid}`);
+            console.log(`      Columns: ${t.columns.length}`);
+            for (const col of t.columns.slice(0, 5)) {
+                const colTid = col.trackingId ? spinner_1.colors.muted(` [${col.trackingId}]`) : '';
+                const pk = col.isPrimaryKey ? spinner_1.colors.yellow(' PK') : '';
+                const nullable = col.isNullable ? '' : spinner_1.colors.red(' NOT NULL');
+                console.log(`        - ${col.name}${colTid}: ${col.type}${pk}${nullable}`);
+            }
+            if (t.columns.length > 5) {
+                console.log(`        ${spinner_1.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(spinner_1.colors.cyan('Views:') + ` ${ast.views.length}`);
+        for (const v of ast.views) {
+            const tid = v.trackingId ? spinner_1.colors.muted(` [${v.trackingId}]`) : '';
+            const mat = v.isMaterialized ? spinner_1.colors.yellow(' (materialized)') : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${v.name}${tid}${mat}`);
+        }
+        console.log('');
+    }
+    if (ast.functions.length > 0) {
+        console.log(spinner_1.colors.cyan('Functions:') + ` ${ast.functions.length}`);
+        for (const f of ast.functions) {
+            const tid = f.trackingId ? spinner_1.colors.muted(` [${f.trackingId}]`) : '';
+            const args = f.args.map(a => a.type).join(', ');
+            console.log(`  ${spinner_1.colors.green('•')} ${f.name}${tid}(${args}) -> ${f.returnType}`);
+        }
+        console.log('');
+    }
+    if (ast.triggers.length > 0) {
+        console.log(spinner_1.colors.cyan('Triggers:') + ` ${ast.triggers.length}`);
+        for (const tr of ast.triggers) {
+            const tid = tr.trackingId ? spinner_1.colors.muted(` [${tr.trackingId}]`) : '';
+            console.log(`  ${spinner_1.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(spinner_1.colors.bold(`Total: ${total} schema objects`));
+}
+exports.default = schemaAstCommand;

package/dist/cjs/cli/index.cjs

@@ -58,6 +58,7 @@ const tag_1 = require("./commands/tag.cjs");
 const cherry_pick_1 = require("./commands/cherry-pick.cjs");
 const remote_1 = require("./commands/remote.cjs");
 const validate_1 = require("./commands/validate.cjs");
+const schema_ast_1 = require("./commands/schema-ast.cjs");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function loadEnvFile() {
@@ -168,6 +169,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
@@ -359,6 +361,10 @@ async function main() {
             case 'validate':
                 await (0, validate_1.validateCommand)(context);
                 break;
+            case 'schema:ast':
+            case 'ast':
+                await (0, schema_ast_1.schemaAstCommand)(context);
+                break;
             case 'sync':
                 await (0, sync_1.syncCommand)(context);
                 break;

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;
+}