ddl-manager/dist/Comparator/CacheComparator.js

store postgres procedures and triggers in files

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CacheComparator = void 0;
const AbstractComparator_1 = require("./AbstractComparator");
const CacheTriggersBuilder_1 = require("../cache/CacheTriggersBuilder");
const Migration_1 = require("../Migrator/Migration");
const CacheColumnGraph_1 = require("./graph/CacheColumnGraph");
const CacheColumnBuilder_1 = require("./CacheColumnBuilder");
const Comment_1 = require("../database/schema/Comment");
class CacheComparator extends AbstractComparator_1.AbstractComparator {
    constructor(driver, database, fs, migration = Migration_1.Migration.empty()) {
        super(driver, database, fs, migration);
        this.allCacheTriggers = [];
        const allCache = this.fs.allCache();
        this.graph = CacheColumnGraph_1.CacheColumnGraph.build(database.aggregators, allCache);
        for (const cache of allCache) {
            const cacheTriggerFactory = new CacheTriggersBuilder_1.CacheTriggersBuilder(allCache, cache, this.database, this.graph, this.fs);
            const cacheTriggers = cacheTriggerFactory.createTriggers();
            for (const trigger of cacheTriggers) {
                this.allCacheTriggers.push(trigger);
            }
        }
        this.columnBuilder = new CacheColumnBuilder_1.CacheColumnBuilder({
            database: this.database,
            graph: this.graph,
            fs: this.fs,
            driver: this.driver
        });
    }
    async drop() {
        this.dropTrashColumns();
    }
    async create() {
        await this.createColumns();
        this.updateColumns();
    }
    getAllCacheTriggers() {
        return this.allCacheTriggers;
    }
    findChangedColumns() {
        const allCacheColumns = this.graph.getAllColumns();
        const changedColumns = allCacheColumns.filter(cacheColumn => {
            const table = this.database.getTable(cacheColumn.for.table);
            const dbColumn = table && table.getColumn(cacheColumn.name);
            if (!dbColumn) {
                return true;
            }
            const newComment = Comment_1.Comment.fromFs({
                objectType: "column",
                cacheSignature: cacheColumn.cache.signature,
                cacheSelect: cacheColumn.select.toString()
            });
            return !newComment.equal(dbColumn.comment);
        });
        return changedColumns;
    }
    async refreshCache(targetTablesOrColumns) {
        if (targetTablesOrColumns) {
            const concreteColumns = this.graph.findCacheColumnsForTablesOrColumns(targetTablesOrColumns);
            this.migration.create({
                updates: this.graph.generateUpdatesFor(concreteColumns)
            });
        }
        else {
            this.migration.create({
                updates: this.graph.generateAllUpdates()
            });
        }
    }
    dropTrashColumns() {
        for (const dbColumn of this.database.getAllColumns()) {
            this.tryDropColumn(dbColumn);
        }
    }
    tryDropColumn(dbColumn) {
        var _a;
        const cacheColumn = this.graph.getColumn(dbColumn.table, dbColumn.name);
        if (cacheColumn) {
            return;
        }
        if (!dbColumn.isFrozen()) {
            this.migration.drop({
                columns: [dbColumn]
            });
            return;
        }
        const legacyInfo = (_a = dbColumn.comment.legacyInfo) !== null && _a !== void 0 ? _a : {};
        if (legacyInfo.type || "nulls" in legacyInfo) {
            const oldDbColumn = dbColumn.clone({
                type: legacyInfo.type,
                nulls: legacyInfo.nulls,
                comment: undefined
            });
            this.migration.create({
                columns: [oldDbColumn]
            });
        }
    }
    async createColumns() {
        for (const cacheColumn of this.graph.getAllColumnsFromRootToDeps()) {
            await this.createColumn(cacheColumn);
        }
    }
    async createColumn(cacheColumn) {
        const existentColumn = this.database.getColumn(cacheColumn.for.table, cacheColumn.name);
        const columnToCreate = await this.columnBuilder.build(cacheColumn);
        if (existentColumn === null || existentColumn === void 0 ? void 0 : existentColumn.same(columnToCreate)) {
            return;
        }
        if (existentColumn === null || existentColumn === void 0 ? void 0 : existentColumn.isFrozen()) {
            columnToCreate.markColumnAsFrozen(existentColumn);
        }
        columnToCreate.startMigration();
        this.migration.create({
            columns: [columnToCreate]
        });
    }
    updateColumns() {
        const changedColumns = this.graph.getAllColumnsFromRootToDeps().filter(column => {
            const existentTable = this.database.getTable(column.for.table);
            const existentColumn = existentTable === null || existentTable === void 0 ? void 0 : existentTable.getColumn(column.name);
            return (!existentColumn ||
                existentColumn.comment.cacheSelect !== column.select.toString() ||
                existentColumn.hasNotFinishedMigration());
        });
        const requiredUpdates = this.graph.generateUpdatesFor(changedColumns);
        this.migration.create({
            updates: requiredUpdates
        });
    }
}
exports.CacheComparator = CacheComparator;
//# sourceMappingURL=CacheComparator.js.map