relq 1.0.0

package/dist/esm/cli/utils/schema-comparator.js

@@ -0,0 +1,307 @@
+import { createChange } from "./change-tracker.js";
+export function compareSchemas(before, after) {
+    const changes = [];
+    changes.push(...compareExtensions(before.extensions || [], after.extensions || []));
+    changes.push(...compareEnums(before.enums || [], after.enums || []));
+    changes.push(...compareDomains(before.domains || [], after.domains || []));
+    changes.push(...compareCompositeTypes(before.compositeTypes || [], after.compositeTypes || []));
+    changes.push(...compareTables(before.tables, after.tables));
+    const beforeViews = before.views || [];
+    const afterViews = after.views || [];
+    changes.push(...compareViews(beforeViews, afterViews));
+    changes.push(...compareFunctions(before.functions || [], after.functions || []));
+    changes.push(...compareTriggers(before.triggers || [], after.triggers || []));
+    return changes;
+}
+function compareExtensions(before, after) {
+    const changes = [];
+    const beforeSet = new Set(before);
+    const afterSet = new Set(after);
+    for (const ext of afterSet) {
+        if (!beforeSet.has(ext)) {
+            changes.push(createChange('CREATE', 'EXTENSION', ext, null, { name: ext }));
+        }
+    }
+    for (const ext of beforeSet) {
+        if (!afterSet.has(ext)) {
+            changes.push(createChange('DROP', 'EXTENSION', ext, { name: ext }, null));
+        }
+    }
+    return changes;
+}
+function compareEnums(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(e => [e.name, e]));
+    const afterMap = new Map(after.map(e => [e.name, e]));
+    for (const [name, enumDef] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'ENUM', name, null, enumDef));
+        }
+        else {
+            const beforeEnum = beforeMap.get(name);
+            const beforeValues = new Set(beforeEnum.values);
+            for (let i = 0; i < enumDef.values.length; i++) {
+                const value = enumDef.values[i];
+                if (!beforeValues.has(value)) {
+                    const afterValue = i > 0 ? enumDef.values[i - 1] : undefined;
+                    changes.push(createChange('CREATE', 'ENUM_VALUE', value, null, {
+                        enumName: name,
+                        value,
+                        after: afterValue,
+                    }, name));
+                }
+            }
+        }
+    }
+    for (const [name, enumDef] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'ENUM', name, enumDef, null));
+        }
+    }
+    return changes;
+}
+function compareDomains(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(d => [d.name, d]));
+    const afterMap = new Map(after.map(d => [d.name, d]));
+    for (const [name, domain] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'DOMAIN', name, null, {
+                name: domain.name,
+                baseType: domain.baseType,
+                notNull: domain.isNotNull,
+                default: domain.defaultValue,
+                check: domain.checkExpression,
+            }));
+        }
+    }
+    for (const [name, domain] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'DOMAIN', name, domain, null));
+        }
+    }
+    return changes;
+}
+function compareCompositeTypes(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(t => [t.name, t]));
+    const afterMap = new Map(after.map(t => [t.name, t]));
+    for (const [name, typeDef] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'COMPOSITE_TYPE', name, null, typeDef));
+        }
+    }
+    for (const [name, typeDef] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'COMPOSITE_TYPE', name, typeDef, null));
+        }
+    }
+    return changes;
+}
+function compareTables(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(t => [t.name, t]));
+    const afterMap = new Map(after.map(t => [t.name, t]));
+    for (const [name, table] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'TABLE', name, null, tableToChangeData(table)));
+        }
+        else {
+            const beforeTable = beforeMap.get(name);
+            changes.push(...compareColumns(beforeTable.columns, table.columns, name));
+            changes.push(...compareIndexes(beforeTable.indexes || [], table.indexes || [], name));
+            changes.push(...compareConstraints(beforeTable.constraints || [], table.constraints || [], name));
+        }
+    }
+    for (const [name, table] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'TABLE', name, tableToChangeData(table), null));
+        }
+    }
+    return changes;
+}
+function tableToChangeData(table) {
+    return {
+        name: table.name,
+        columns: table.columns.map(c => ({
+            name: c.name,
+            dataType: c.dataType,
+            isNullable: c.isNullable,
+            defaultValue: c.defaultValue,
+            isPrimaryKey: c.isPrimaryKey,
+            isUnique: c.isUnique,
+            references: c.references,
+        })),
+        constraints: table.constraints?.map(con => ({
+            name: con.name,
+            definition: con.definition,
+        })),
+        isPartitioned: table.isPartitioned,
+        partitionType: table.partitionType,
+        partitionKey: table.partitionKey,
+    };
+}
+function compareColumns(before, after, tableName) {
+    const changes = [];
+    const beforeMap = new Map(before.map(c => [c.name, c]));
+    const afterMap = new Map(after.map(c => [c.name, c]));
+    for (const [name, col] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'COLUMN', name, null, columnToChangeData(col), tableName));
+        }
+        else {
+            const beforeCol = beforeMap.get(name);
+            if (hasColumnChanged(beforeCol, col)) {
+                changes.push(createChange('ALTER', 'COLUMN', name, columnToChangeData(beforeCol), columnToChangeData(col), tableName));
+            }
+        }
+    }
+    for (const [name, col] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'COLUMN', name, columnToChangeData(col), null, tableName));
+        }
+    }
+    return changes;
+}
+function columnToChangeData(col) {
+    return {
+        name: col.name,
+        dataType: col.dataType,
+        isNullable: col.isNullable,
+        defaultValue: col.defaultValue,
+        isPrimaryKey: col.isPrimaryKey,
+        isUnique: col.isUnique,
+        maxLength: col.maxLength,
+        precision: col.precision,
+        scale: col.scale,
+    };
+}
+function hasColumnChanged(before, after) {
+    return (before.dataType.toLowerCase() !== after.dataType.toLowerCase() ||
+        before.isNullable !== after.isNullable ||
+        before.defaultValue !== after.defaultValue ||
+        before.isPrimaryKey !== after.isPrimaryKey ||
+        before.isUnique !== after.isUnique);
+}
+function compareIndexes(before, after, tableName) {
+    const changes = [];
+    const beforeMap = new Map(before.map(i => [i.name, i]));
+    const afterMap = new Map(after.map(i => [i.name, i]));
+    for (const [name, idx] of afterMap) {
+        if (!beforeMap.has(name) && !idx.isPrimary) {
+            changes.push(createChange('CREATE', 'INDEX', name, null, {
+                name: idx.name,
+                tableName,
+                columns: Array.isArray(idx.columns) ? idx.columns : [idx.columns],
+                isUnique: idx.isUnique,
+                type: idx.type,
+            }));
+        }
+    }
+    for (const [name, idx] of beforeMap) {
+        if (!afterMap.has(name) && !idx.isPrimary) {
+            changes.push(createChange('DROP', 'INDEX', name, {
+                name: idx.name,
+                tableName,
+                columns: idx.columns,
+            }, null));
+        }
+    }
+    return changes;
+}
+function compareConstraints(before, after, tableName) {
+    const changes = [];
+    const beforeMap = new Map(before.map(c => [c.name, c]));
+    const afterMap = new Map(after.map(c => [c.name, c]));
+    for (const [name, con] of afterMap) {
+        if (!beforeMap.has(name)) {
+            const objectType = constraintTypeToObjectType(con.type);
+            changes.push(createChange('CREATE', objectType, name, null, {
+                name: con.name,
+                definition: con.definition,
+            }, tableName));
+        }
+    }
+    for (const [name, con] of beforeMap) {
+        if (!afterMap.has(name)) {
+            const objectType = constraintTypeToObjectType(con.type);
+            changes.push(createChange('DROP', objectType, name, {
+                name: con.name,
+                definition: con.definition,
+            }, null, tableName));
+        }
+    }
+    return changes;
+}
+function constraintTypeToObjectType(type) {
+    const upper = type.toUpperCase();
+    if (upper.includes('PRIMARY'))
+        return 'PRIMARY_KEY';
+    if (upper.includes('FOREIGN'))
+        return 'FOREIGN_KEY';
+    if (upper.includes('CHECK'))
+        return 'CHECK';
+    if (upper.includes('EXCLUDE'))
+        return 'EXCLUSION';
+    return 'CONSTRAINT';
+}
+function compareViews(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(v => [v.name, v]));
+    const afterMap = new Map(after.map(v => [v.name, v]));
+    for (const [name, view] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'VIEW', name, null, view));
+        }
+        else {
+            const beforeView = beforeMap.get(name);
+            if (beforeView.definition !== view.definition) {
+                changes.push(createChange('ALTER', 'VIEW', name, beforeView, view));
+            }
+        }
+    }
+    for (const [name, view] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'VIEW', name, view, null));
+        }
+    }
+    return changes;
+}
+function compareFunctions(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(f => [f.name, f]));
+    const afterMap = new Map(after.map(f => [f.name, f]));
+    for (const [name, func] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'FUNCTION', name, null, {
+                name: func.name,
+                returns: func.returnType,
+                language: func.language,
+                body: func.definition || '',
+            }));
+        }
+    }
+    for (const [name, func] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'FUNCTION', name, func, null));
+        }
+    }
+    return changes;
+}
+function compareTriggers(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(t => [t.name, t]));
+    const afterMap = new Map(after.map(t => [t.name, t]));
+    for (const [name, trigger] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'TRIGGER', name, null, trigger, trigger.tableName));
+        }
+    }
+    for (const [name, trigger] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'TRIGGER', name, trigger, null, trigger.tableName));
+        }
+    }
+    return changes;
+}
+export { compareExtensions, compareEnums, compareDomains, compareTables };

package/dist/esm/cli/utils/schema-diff.js

@@ -0,0 +1,276 @@
+import { colors } from "./spinner.js";
+export function diffSchemas(local, remote) {
+    const tables = diffTables(local.tables, remote.tables);
+    const extensions = diffExtensions(local.extensions, remote.extensions);
+    const summary = calculateSummary(tables, extensions);
+    const hasChanges = summary.tablesAdded > 0 || summary.tablesRemoved > 0 ||
+        summary.tablesModified > 0 || extensions.length > 0;
+    return { tables, extensions, summary, hasChanges };
+}
+function diffTables(local, remote) {
+    const diffs = [];
+    const localMap = new Map(local.map(t => [t.name, t]));
+    const remoteMap = new Map(remote.map(t => [t.name, t]));
+    for (const [name, remoteTable] of remoteMap) {
+        if (!localMap.has(name)) {
+            diffs.push({
+                name,
+                type: 'added',
+                columns: remoteTable.columns.map(c => ({ name: c.name, type: 'added' })),
+                indexes: remoteTable.indexes.map(i => ({ name: i.name, type: 'added' })),
+            });
+        }
+    }
+    for (const [name, localTable] of localMap) {
+        if (!remoteMap.has(name)) {
+            diffs.push({
+                name,
+                type: 'removed',
+                columns: localTable.columns.map(c => ({ name: c.name, type: 'removed' })),
+                indexes: localTable.indexes.map(i => ({ name: i.name, type: 'removed' })),
+            });
+        }
+    }
+    for (const [name, localTable] of localMap) {
+        const remoteTable = remoteMap.get(name);
+        if (remoteTable) {
+            const columnDiffs = diffColumns(localTable.columns, remoteTable.columns);
+            const indexDiffs = diffIndexes(localTable.indexes, remoteTable.indexes);
+            if (columnDiffs.length > 0 || indexDiffs.length > 0) {
+                diffs.push({
+                    name,
+                    type: 'modified',
+                    columns: columnDiffs,
+                    indexes: indexDiffs,
+                });
+            }
+        }
+    }
+    return diffs.sort((a, b) => a.name.localeCompare(b.name));
+}
+function diffColumns(local, remote) {
+    const diffs = [];
+    const localMap = new Map(local.map(c => [c.name, c]));
+    const remoteMap = new Map(remote.map(c => [c.name, c]));
+    for (const [name] of remoteMap) {
+        if (!localMap.has(name)) {
+            diffs.push({ name, type: 'added' });
+        }
+    }
+    for (const [name] of localMap) {
+        if (!remoteMap.has(name)) {
+            diffs.push({ name, type: 'removed' });
+        }
+    }
+    for (const [name, localCol] of localMap) {
+        const remoteCol = remoteMap.get(name);
+        if (remoteCol) {
+            const changes = compareColumns(localCol, remoteCol);
+            if (changes.length > 0) {
+                diffs.push({ name, type: 'modified', changes });
+            }
+        }
+    }
+    return diffs;
+}
+function compareColumns(local, remote) {
+    const changes = [];
+    if (local.type !== remote.type) {
+        changes.push({ field: 'type', from: local.type, to: remote.type });
+    }
+    if (local.nullable !== remote.nullable) {
+        changes.push({ field: 'nullable', from: local.nullable, to: remote.nullable });
+    }
+    if (local.length !== remote.length && (local.length || remote.length)) {
+        changes.push({ field: 'length', from: local.length, to: remote.length });
+    }
+    if (local.isPrimaryKey !== remote.isPrimaryKey) {
+        changes.push({ field: 'primaryKey', from: local.isPrimaryKey, to: remote.isPrimaryKey });
+    }
+    if (local.isUnique !== remote.isUnique) {
+        changes.push({ field: 'unique', from: local.isUnique, to: remote.isUnique });
+    }
+    return changes;
+}
+function diffIndexes(local, remote) {
+    const diffs = [];
+    const localMap = new Map(local.map(i => [i.name, i]));
+    const remoteMap = new Map(remote.map(i => [i.name, i]));
+    for (const [name] of remoteMap) {
+        if (!localMap.has(name)) {
+            diffs.push({ name, type: 'added' });
+        }
+    }
+    for (const [name] of localMap) {
+        if (!remoteMap.has(name)) {
+            diffs.push({ name, type: 'removed' });
+        }
+    }
+    return diffs;
+}
+function diffExtensions(local, remote) {
+    const diffs = [];
+    const localSet = new Set(local);
+    const remoteSet = new Set(remote);
+    for (const ext of remoteSet) {
+        if (!localSet.has(ext)) {
+            diffs.push({ name: ext, type: 'added' });
+        }
+    }
+    for (const ext of localSet) {
+        if (!remoteSet.has(ext)) {
+            diffs.push({ name: ext, type: 'removed' });
+        }
+    }
+    return diffs;
+}
+function calculateSummary(tables, _extensions) {
+    let tablesAdded = 0, tablesRemoved = 0, tablesModified = 0;
+    let columnsAdded = 0, columnsRemoved = 0, columnsModified = 0;
+    let indexesAdded = 0, indexesRemoved = 0;
+    for (const table of tables) {
+        if (table.type === 'added')
+            tablesAdded++;
+        else if (table.type === 'removed')
+            tablesRemoved++;
+        else if (table.type === 'modified')
+            tablesModified++;
+        for (const col of table.columns || []) {
+            if (col.type === 'added')
+                columnsAdded++;
+            else if (col.type === 'removed')
+                columnsRemoved++;
+            else if (col.type === 'modified')
+                columnsModified++;
+        }
+        for (const idx of table.indexes || []) {
+            if (idx.type === 'added')
+                indexesAdded++;
+            else if (idx.type === 'removed')
+                indexesRemoved++;
+        }
+    }
+    return {
+        tablesAdded, tablesRemoved, tablesModified,
+        columnsAdded, columnsRemoved, columnsModified,
+        indexesAdded, indexesRemoved,
+    };
+}
+export function formatDiff(diff) {
+    const lines = [];
+    if (!diff.hasChanges) {
+        lines.push(colors.green('✓ No changes detected'));
+        return lines.join('\n');
+    }
+    const { summary } = diff;
+    const parts = [];
+    if (summary.tablesAdded > 0)
+        parts.push(colors.green(`+${summary.tablesAdded} tables`));
+    if (summary.tablesRemoved > 0)
+        parts.push(colors.red(`-${summary.tablesRemoved} tables`));
+    if (summary.tablesModified > 0)
+        parts.push(colors.yellow(`~${summary.tablesModified} tables`));
+    lines.push(`Changes: ${parts.join(', ') || 'none'}`);
+    lines.push('');
+    for (const table of diff.tables) {
+        const icon = table.type === 'added' ? colors.green('+') :
+            table.type === 'removed' ? colors.red('-') :
+                colors.yellow('~');
+        lines.push(`${icon} ${colors.bold(table.name)}`);
+        for (const col of table.columns || []) {
+            const colIcon = col.type === 'added' ? colors.green('  +') :
+                col.type === 'removed' ? colors.red('  -') :
+                    colors.yellow('  ~');
+            if (col.changes && col.changes.length > 0) {
+                const changeStr = col.changes.map(c => `${c.field}: ${c.from} → ${c.to}`).join(', ');
+                lines.push(`${colIcon} ${col.name} (${colors.muted(changeStr)})`);
+            }
+            else {
+                lines.push(`${colIcon} ${col.name}`);
+            }
+        }
+        for (const idx of table.indexes || []) {
+            const idxIcon = idx.type === 'added' ? colors.green('  +') :
+                colors.red('  -');
+            lines.push(`${idxIcon} index: ${idx.name}`);
+        }
+    }
+    for (const ext of diff.extensions) {
+        const icon = ext.type === 'added' ? colors.green('+') : colors.red('-');
+        lines.push(`${icon} extension: ${ext.name}`);
+    }
+    return lines.join('\n');
+}
+export function formatSummary(diff) {
+    const { summary } = diff;
+    if (!diff.hasChanges) {
+        return colors.green('No changes');
+    }
+    const parts = [];
+    const tablesTotal = summary.tablesAdded + summary.tablesRemoved + summary.tablesModified;
+    const columnsTotal = summary.columnsAdded + summary.columnsRemoved + summary.columnsModified;
+    const indexesTotal = summary.indexesAdded + summary.indexesRemoved;
+    if (tablesTotal > 0) {
+        const detail = [];
+        if (summary.tablesAdded)
+            detail.push(`+${summary.tablesAdded}`);
+        if (summary.tablesRemoved)
+            detail.push(`-${summary.tablesRemoved}`);
+        if (summary.tablesModified)
+            detail.push(`~${summary.tablesModified}`);
+        parts.push(`${tablesTotal} tables (${detail.join(', ')})`);
+    }
+    if (columnsTotal > 0) {
+        const detail = [];
+        if (summary.columnsAdded)
+            detail.push(`+${summary.columnsAdded}`);
+        if (summary.columnsRemoved)
+            detail.push(`-${summary.columnsRemoved}`);
+        if (summary.columnsModified)
+            detail.push(`~${summary.columnsModified}`);
+        parts.push(`${columnsTotal} columns (${detail.join(', ')})`);
+    }
+    if (indexesTotal > 0) {
+        const detail = [];
+        if (summary.indexesAdded)
+            detail.push(`+${summary.indexesAdded}`);
+        if (summary.indexesRemoved)
+            detail.push(`-${summary.indexesRemoved}`);
+        parts.push(`${indexesTotal} indexes (${detail.join(', ')})`);
+    }
+    return parts.join(', ');
+}
+export function filterDiff(diff, ignorePatterns) {
+    const patterns = ignorePatterns.map(p => {
+        const regexStr = p.replace(/\*/g, '.*').replace(/\?/g, '.');
+        return new RegExp(`^${regexStr}$`, 'i');
+    });
+    const matchesPattern = (name) => patterns.some(p => p.test(name));
+    const tables = diff.tables.filter(t => !matchesPattern(t.name));
+    const summary = calculateSummary(tables, diff.extensions);
+    const hasChanges = tables.length > 0 || diff.extensions.length > 0;
+    return {
+        ...diff,
+        tables,
+        summary,
+        hasChanges,
+    };
+}
+export function hasDestructiveChanges(diff) {
+    if (diff.summary.tablesRemoved > 0 || diff.summary.columnsRemoved > 0) {
+        return true;
+    }
+    return false;
+}
+export function getDestructiveTables(diff) {
+    const tables = [];
+    for (const table of diff.tables) {
+        if (table.type === 'removed') {
+            tables.push(table.name);
+        }
+        else if (table.columns?.some(c => c.type === 'removed')) {
+            tables.push(table.name);
+        }
+    }
+    return tables;
+}

package/dist/esm/cli/utils/schema-hash.js

@@ -0,0 +1,69 @@
+import * as crypto from 'crypto';
+export function normalizeSchema(schema) {
+    const userTables = schema.tables.filter(t => !t.name.startsWith('_relq') &&
+        !t.name.startsWith('relq_'));
+    const tables = userTables
+        .map(normalizeTable)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const extensions = [...schema.extensions].sort();
+    return { tables, extensions };
+}
+function normalizeTable(table) {
+    const columns = table.columns
+        .map(normalizeColumn)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const indexes = (table.indexes || [])
+        .map(normalizeIndex)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const constraints = (table.constraints || [])
+        .map(normalizeConstraint)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        name: table.name,
+        columns,
+        indexes,
+        constraints,
+        partitionType: table.partitionType,
+        partitionKey: table.partitionKey?.sort(),
+    };
+}
+function normalizeColumn(col) {
+    return {
+        name: col.name,
+        type: col.dataType.toUpperCase(),
+        nullable: col.isNullable,
+        defaultValue: col.defaultValue || undefined,
+        isPrimaryKey: col.isPrimaryKey,
+        isUnique: col.isUnique,
+        length: col.maxLength || undefined,
+    };
+}
+function normalizeIndex(idx) {
+    return {
+        name: idx.name,
+        columns: [...idx.columns].sort(),
+        unique: idx.isUnique,
+        type: idx.type?.toUpperCase(),
+    };
+}
+function normalizeConstraint(con) {
+    return {
+        name: con.name,
+        type: con.type.toUpperCase(),
+        definition: con.definition || undefined,
+    };
+}
+export function generateSchemaHash(schema) {
+    const normalized = normalizeSchema(schema);
+    const json = JSON.stringify(normalized, null, 0);
+    return crypto
+        .createHash('sha1')
+        .update(json, 'utf8')
+        .digest('hex');
+}
+export function generateShortHash(schema) {
+    return generateSchemaHash(schema).substring(0, 7);
+}
+export function schemasMatch(schema1, schema2) {
+    return generateSchemaHash(schema1) === generateSchemaHash(schema2);
+}