relq 1.0.25 → 1.0.27

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

@@ -475,3 +475,392 @@ export function getDestructiveTables(diff) {
     }
     return tables;
 }
+export function compareSchemas(oldSchema, newSchema) {
+    const result = {
+        added: {
+            tables: [],
+            columns: [],
+            indexes: [],
+            enums: [],
+            domains: [],
+            compositeTypes: [],
+            sequences: [],
+            views: [],
+            functions: [],
+            triggers: [],
+            extensions: [],
+        },
+        removed: {
+            tables: [],
+            columns: [],
+            indexes: [],
+            enums: [],
+            domains: [],
+            compositeTypes: [],
+            sequences: [],
+            views: [],
+            functions: [],
+            triggers: [],
+            extensions: [],
+        },
+        renamed: {
+            tables: [],
+            columns: [],
+            indexes: [],
+            enums: [],
+            sequences: [],
+            functions: [],
+        },
+        modified: {
+            tables: [],
+            columns: [],
+            enums: [],
+        },
+        hasChanges: false,
+    };
+    compareTables(oldSchema.tables, newSchema.tables, result);
+    compareEnums(oldSchema.enums, newSchema.enums, result);
+    const oldExtensions = new Set(oldSchema.extensions);
+    const newExtensions = new Set(newSchema.extensions);
+    for (const ext of newExtensions) {
+        if (!oldExtensions.has(ext)) {
+            result.added.extensions.push(ext);
+        }
+    }
+    for (const ext of oldExtensions) {
+        if (!newExtensions.has(ext)) {
+            result.removed.extensions.push(ext);
+        }
+    }
+    compareByTrackingId(oldSchema.sequences, newSchema.sequences, (item) => item.name, (item) => item.trackingId, (item) => result.added.sequences.push(item), (item) => result.removed.sequences.push(item), (from, to, trackingId) => result.renamed.sequences.push({ from, to, trackingId }));
+    compareByTrackingId(oldSchema.functions, newSchema.functions, (item) => item.name, (item) => item.trackingId, (item) => result.added.functions.push(item), (item) => result.removed.functions.push(item), (from, to, trackingId) => result.renamed.functions.push({ from, to, trackingId }));
+    compareByName(oldSchema.views, newSchema.views, (item) => item.name, (item) => result.added.views.push(item), (item) => result.removed.views.push(item));
+    compareByName(oldSchema.triggers, newSchema.triggers, (item) => item.name, (item) => result.added.triggers.push(item), (item) => result.removed.triggers.push(item));
+    compareByName(oldSchema.domains, newSchema.domains, (item) => item.name, (item) => result.added.domains.push(item), (item) => result.removed.domains.push(item));
+    compareByName(oldSchema.compositeTypes, newSchema.compositeTypes, (item) => item.name, (item) => result.added.compositeTypes.push(item), (item) => result.removed.compositeTypes.push(item));
+    result.hasChanges =
+        result.added.tables.length > 0 ||
+            result.added.columns.length > 0 ||
+            result.added.indexes.length > 0 ||
+            result.added.enums.length > 0 ||
+            result.added.extensions.length > 0 ||
+            result.added.sequences.length > 0 ||
+            result.added.functions.length > 0 ||
+            result.added.views.length > 0 ||
+            result.added.triggers.length > 0 ||
+            result.added.domains.length > 0 ||
+            result.added.compositeTypes.length > 0 ||
+            result.removed.tables.length > 0 ||
+            result.removed.columns.length > 0 ||
+            result.removed.indexes.length > 0 ||
+            result.removed.enums.length > 0 ||
+            result.removed.extensions.length > 0 ||
+            result.removed.sequences.length > 0 ||
+            result.removed.functions.length > 0 ||
+            result.removed.views.length > 0 ||
+            result.removed.triggers.length > 0 ||
+            result.removed.domains.length > 0 ||
+            result.removed.compositeTypes.length > 0 ||
+            result.renamed.tables.length > 0 ||
+            result.renamed.columns.length > 0 ||
+            result.renamed.indexes.length > 0 ||
+            result.renamed.enums.length > 0 ||
+            result.renamed.sequences.length > 0 ||
+            result.renamed.functions.length > 0 ||
+            result.modified.tables.length > 0 ||
+            result.modified.columns.length > 0 ||
+            result.modified.enums.length > 0;
+    return result;
+}
+function compareTables(oldTables, newTables, result) {
+    const oldByName = new Map(oldTables.map(t => [t.name, t]));
+    const newByName = new Map(newTables.map(t => [t.name, t]));
+    const oldByTrackingId = new Map();
+    const newByTrackingId = new Map();
+    for (const t of oldTables) {
+        if (t.trackingId)
+            oldByTrackingId.set(t.trackingId, t);
+    }
+    for (const t of newTables) {
+        if (t.trackingId)
+            newByTrackingId.set(t.trackingId, t);
+    }
+    const processedOld = new Set();
+    const processedNew = new Set();
+    for (const [trackingId, oldTable] of oldByTrackingId) {
+        const newTable = newByTrackingId.get(trackingId);
+        if (newTable && newTable.name !== oldTable.name) {
+            result.renamed.tables.push({
+                from: oldTable.name,
+                to: newTable.name,
+                trackingId,
+            });
+            processedOld.add(oldTable.name);
+            processedNew.add(newTable.name);
+            compareTableColumns(oldTable, newTable, newTable.name, result);
+        }
+    }
+    for (const [name, newTable] of newByName) {
+        if (processedNew.has(name))
+            continue;
+        const oldTable = oldByName.get(name);
+        if (oldTable) {
+            processedOld.add(name);
+            compareTableColumns(oldTable, newTable, name, result);
+        }
+        else {
+            result.added.tables.push(newTable);
+        }
+    }
+    for (const [name, oldTable] of oldByName) {
+        if (processedOld.has(name))
+            continue;
+        if (!newByName.has(name)) {
+            result.removed.tables.push(oldTable);
+        }
+    }
+}
+function compareTableColumns(oldTable, newTable, tableName, result) {
+    const oldByName = new Map(oldTable.columns.map(c => [c.name, c]));
+    const newByName = new Map(newTable.columns.map(c => [c.name, c]));
+    const oldByTrackingId = new Map();
+    const newByTrackingId = new Map();
+    for (const c of oldTable.columns) {
+        if (c.trackingId)
+            oldByTrackingId.set(c.trackingId, c);
+    }
+    for (const c of newTable.columns) {
+        if (c.trackingId)
+            newByTrackingId.set(c.trackingId, c);
+    }
+    const processedOld = new Set();
+    const processedNew = new Set();
+    for (const [trackingId, oldCol] of oldByTrackingId) {
+        const newCol = newByTrackingId.get(trackingId);
+        if (newCol && newCol.name !== oldCol.name) {
+            result.renamed.columns.push({
+                table: tableName,
+                from: oldCol.name,
+                to: newCol.name,
+                trackingId,
+            });
+            processedOld.add(oldCol.name);
+            processedNew.add(newCol.name);
+            const changes = compareColumnProperties(oldCol, newCol);
+            if (changes.length > 0) {
+                result.modified.columns.push({
+                    table: tableName,
+                    column: newCol.name,
+                    changes,
+                });
+            }
+        }
+    }
+    for (const [name, newCol] of newByName) {
+        if (processedNew.has(name))
+            continue;
+        const oldCol = oldByName.get(name);
+        if (oldCol) {
+            processedOld.add(name);
+            const changes = compareColumnProperties(oldCol, newCol);
+            if (changes.length > 0) {
+                result.modified.columns.push({
+                    table: tableName,
+                    column: name,
+                    changes,
+                });
+            }
+        }
+        else {
+            result.added.columns.push({ table: tableName, column: newCol });
+        }
+    }
+    for (const [name, oldCol] of oldByName) {
+        if (processedOld.has(name))
+            continue;
+        if (!newByName.has(name)) {
+            result.removed.columns.push({ table: tableName, column: oldCol });
+        }
+    }
+    compareTableIndexes(oldTable, newTable, tableName, result);
+}
+function compareColumnProperties(oldCol, newCol) {
+    const changes = [];
+    const oldType = normalizeType(oldCol.type);
+    const newType = normalizeType(newCol.type);
+    if (oldType !== newType) {
+        changes.push({ field: 'type', from: oldCol.type, to: newCol.type });
+    }
+    if (oldCol.isNullable !== newCol.isNullable) {
+        changes.push({ field: 'nullable', from: oldCol.isNullable, to: newCol.isNullable });
+    }
+    if (oldCol.isPrimaryKey !== newCol.isPrimaryKey) {
+        changes.push({ field: 'primaryKey', from: oldCol.isPrimaryKey, to: newCol.isPrimaryKey });
+    }
+    if (oldCol.isUnique !== newCol.isUnique) {
+        changes.push({ field: 'unique', from: oldCol.isUnique, to: newCol.isUnique });
+    }
+    if (oldCol.defaultValue !== newCol.defaultValue) {
+        changes.push({ field: 'default', from: oldCol.defaultValue, to: newCol.defaultValue });
+    }
+    return changes;
+}
+function compareTableIndexes(oldTable, newTable, tableName, result) {
+    const oldByName = new Map(oldTable.indexes.map(i => [i.name, i]));
+    const newByName = new Map(newTable.indexes.map(i => [i.name, i]));
+    const oldByTrackingId = new Map();
+    const newByTrackingId = new Map();
+    for (const i of oldTable.indexes) {
+        if (i.trackingId)
+            oldByTrackingId.set(i.trackingId, i);
+    }
+    for (const i of newTable.indexes) {
+        if (i.trackingId)
+            newByTrackingId.set(i.trackingId, i);
+    }
+    const processedOld = new Set();
+    const processedNew = new Set();
+    for (const [trackingId, oldIdx] of oldByTrackingId) {
+        const newIdx = newByTrackingId.get(trackingId);
+        if (newIdx && newIdx.name !== oldIdx.name) {
+            result.renamed.indexes.push({
+                table: tableName,
+                from: oldIdx.name,
+                to: newIdx.name,
+                trackingId,
+            });
+            processedOld.add(oldIdx.name);
+            processedNew.add(newIdx.name);
+        }
+    }
+    for (const [name, newIdx] of newByName) {
+        if (processedNew.has(name))
+            continue;
+        if (!oldByName.has(name)) {
+            result.added.indexes.push({ table: tableName, index: newIdx });
+        }
+    }
+    for (const [name, oldIdx] of oldByName) {
+        if (processedOld.has(name))
+            continue;
+        if (!newByName.has(name)) {
+            result.removed.indexes.push({ table: tableName, index: oldIdx });
+        }
+    }
+}
+function compareEnums(oldEnums, newEnums, result) {
+    const oldByName = new Map(oldEnums.map(e => [e.name, e]));
+    const newByName = new Map(newEnums.map(e => [e.name, e]));
+    const oldByTrackingId = new Map();
+    const newByTrackingId = new Map();
+    for (const e of oldEnums) {
+        if (e.trackingId)
+            oldByTrackingId.set(e.trackingId, e);
+    }
+    for (const e of newEnums) {
+        if (e.trackingId)
+            newByTrackingId.set(e.trackingId, e);
+    }
+    const processedOld = new Set();
+    const processedNew = new Set();
+    for (const [trackingId, oldEnum] of oldByTrackingId) {
+        const newEnum = newByTrackingId.get(trackingId);
+        if (newEnum && newEnum.name !== oldEnum.name) {
+            result.renamed.enums.push({
+                from: oldEnum.name,
+                to: newEnum.name,
+                trackingId,
+            });
+            processedOld.add(oldEnum.name);
+            processedNew.add(newEnum.name);
+            const added = newEnum.values.filter(v => !oldEnum.values.includes(v));
+            const removed = oldEnum.values.filter(v => !newEnum.values.includes(v));
+            if (added.length > 0 || removed.length > 0) {
+                result.modified.enums.push({
+                    name: newEnum.name,
+                    changes: { added, removed },
+                });
+            }
+        }
+    }
+    for (const [name, newEnum] of newByName) {
+        if (processedNew.has(name))
+            continue;
+        const oldEnum = oldByName.get(name);
+        if (oldEnum) {
+            processedOld.add(name);
+            const added = newEnum.values.filter(v => !oldEnum.values.includes(v));
+            const removed = oldEnum.values.filter(v => !newEnum.values.includes(v));
+            if (added.length > 0 || removed.length > 0) {
+                result.modified.enums.push({
+                    name,
+                    changes: { added, removed },
+                });
+            }
+        }
+        else {
+            result.added.enums.push(newEnum);
+        }
+    }
+    for (const [name, oldEnum] of oldByName) {
+        if (processedOld.has(name))
+            continue;
+        if (!newByName.has(name)) {
+            result.removed.enums.push(oldEnum);
+        }
+    }
+}
+function compareByTrackingId(oldItems, newItems, getName, getTrackingId, onAdd, onRemove, onRename) {
+    const oldByName = new Map(oldItems.map(item => [getName(item), item]));
+    const newByName = new Map(newItems.map(item => [getName(item), item]));
+    const oldByTrackingId = new Map();
+    const newByTrackingId = new Map();
+    for (const item of oldItems) {
+        const tid = getTrackingId(item);
+        if (tid)
+            oldByTrackingId.set(tid, item);
+    }
+    for (const item of newItems) {
+        const tid = getTrackingId(item);
+        if (tid)
+            newByTrackingId.set(tid, item);
+    }
+    const processedOld = new Set();
+    const processedNew = new Set();
+    for (const [trackingId, oldItem] of oldByTrackingId) {
+        const newItem = newByTrackingId.get(trackingId);
+        if (newItem && getName(newItem) !== getName(oldItem)) {
+            onRename(getName(oldItem), getName(newItem), trackingId);
+            processedOld.add(getName(oldItem));
+            processedNew.add(getName(newItem));
+        }
+    }
+    for (const [name, item] of newByName) {
+        if (processedNew.has(name))
+            continue;
+        if (!oldByName.has(name)) {
+            onAdd(item);
+        }
+    }
+    for (const [name, item] of oldByName) {
+        if (processedOld.has(name))
+            continue;
+        if (!newByName.has(name)) {
+            onRemove(item);
+        }
+    }
+}
+function compareByName(oldItems, newItems, getName, onAdd, onRemove) {
+    const oldNames = new Set(oldItems.map(getName));
+    const newNames = new Set(newItems.map(getName));
+    for (const item of newItems) {
+        if (!oldNames.has(getName(item))) {
+            onAdd(item);
+        }
+    }
+    for (const item of oldItems) {
+        if (!newNames.has(getName(item))) {
+            onRemove(item);
+        }
+    }
+}

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

@@ -26,6 +26,7 @@ function normalizeTable(table) {
         isPartitioned: table.isPartitioned,
         partitionType: table.partitionType,
         partitionKey: table.partitionKey ? [...table.partitionKey] : undefined,
+        trackingId: table.trackingId,
     };
 }
 function normalizeColumn(col) {
@@ -37,6 +38,7 @@ function normalizeColumn(col) {
         isPrimaryKey: col.isPrimaryKey,
         isUnique: col.isUnique,
         length: col.maxLength || undefined,
+        trackingId: col.trackingId,
     };
 }
 function normalizeIndex(idx) {
@@ -45,6 +47,7 @@ function normalizeIndex(idx) {
         columns: [...idx.columns].sort(),
         unique: idx.isUnique,
         type: idx.type?.toUpperCase(),
+        trackingId: idx.trackingId,
     };
 }
 function normalizeConstraint(con) {
@@ -52,6 +55,7 @@ function normalizeConstraint(con) {
         name: con.name,
         type: con.type.toUpperCase(),
         definition: con.definition || undefined,
+        trackingId: con.trackingId,
     };
 }
 export function generateSchemaHash(schema) {