@carno.js/cli 0.3.7 → 0.4.1

package/dist/src/migrator/migrator.js

@@ -0,0 +1,715 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migrator = void 0;
+const LoggerService_1 = require("@carno.js/logger/src/LoggerService");
+const orm_1 = require("@carno.js/orm");
+const orm_2 = require("@carno.js/orm");
+const globby_1 = __importDefault(require("globby"));
+const knex = __importStar(require("knex"));
+const diff_calculator_1 = require("./diff-calculator");
+const snapshot_manager_1 = require("./snapshot-manager");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+class Migrator {
+    constructor() {
+        this.entities = new orm_2.EntityStorage();
+        this.orm = orm_1.Orm.getInstance();
+        if (this.orm === undefined) {
+            (0, orm_1.setLogger)(new LoggerService_1.LoggerService({ pretty: true }));
+            this.orm = new orm_1.Orm();
+        }
+        this.entities = orm_2.EntityStorage.getInstance();
+        if (this.entities === undefined)
+            this.entities = new orm_2.EntityStorage();
+    }
+    async startConnection(basePath = process.cwd()) {
+        await this.initConfigFile(basePath);
+        await this.initKnex();
+    }
+    async initConfigFile(basePath) {
+        const paths = await (0, globby_1.default)(['carno.config.ts'], {
+            absolute: true,
+            cwd: basePath,
+        });
+        if (paths.length === 0) {
+            throw new Error('Config file not found');
+        }
+        const dynamicImport = new Function('specifier', 'return import(specifier)');
+        const config = await dynamicImport(paths[0]);
+        this.config = config.default;
+        if (typeof this.config.entities === 'string') {
+            const paths = await (0, globby_1.default)(this.config.entities, {
+                absolute: true,
+                cwd: basePath,
+            });
+            for (const path of paths) {
+                console.log(`Importing entity from: ${path}`);
+                await dynamicImport(path);
+            }
+        }
+        await this.initOrm();
+    }
+    async initOrm() {
+        if (this.orm.driverInstance) {
+            try {
+                await this.orm.driverInstance.executeSql('SELECT 1');
+                return;
+            }
+            catch (error) {
+            }
+        }
+        const serv = new orm_1.OrmService(this.orm, this.entities);
+        await serv.onInit(this.config);
+    }
+    initKnex() {
+        if (this.knex) {
+            return;
+        }
+        if (!this.orm.driverInstance) {
+            throw new Error('ORM must be initialized before Knex');
+        }
+        const clientType = this.orm.driverInstance.dbType === 'postgres' ? 'pg' : 'mysql2';
+        this.knex = knex.default({
+            client: clientType,
+            connection: {
+                host: this.config.host,
+                user: this.config.username,
+                password: this.config.password,
+                database: this.config.database,
+                uri: this.config.connectionString,
+            },
+            debug: true,
+        });
+    }
+    async run(diff) {
+        const sql = [];
+        const sortedDiff = this.sortTablesByDependencies(diff);
+        for (const tableDiff of sortedDiff) {
+            let query;
+            const partialIndexSql = this.buildPartialIndexStatements(tableDiff);
+            if (tableDiff.newTable) {
+                query = await this.createTable(tableDiff);
+            }
+            else {
+                const enumAlters = tableDiff.colDiffs.filter((diff) => diff.actionType === 'ALTER' &&
+                    diff.colType === 'enum' &&
+                    diff.colChanges?.enumItems);
+                for (const enumAlter of enumAlters) {
+                    const dropConstraints = this.dropEnumConstraints(tableDiff.tableName, enumAlter.colName);
+                    sql.push(...dropConstraints);
+                }
+                query = this.knex.schema
+                    .withSchema(tableDiff.schema)
+                    .table(tableDiff.tableName, (builder) => {
+                    for (const colDiff of tableDiff.colDiffs) {
+                        if (colDiff.actionType === 'INDEX') {
+                            colDiff.indexTables.forEach((indexTable) => {
+                                if (typeof indexTable.properties === 'undefined') {
+                                    builder.dropIndex([], indexTable.name);
+                                    return;
+                                }
+                                if (this.isPartialIndexTable(indexTable)) {
+                                    return;
+                                }
+                                builder.index(indexTable.properties, indexTable.name);
+                            });
+                        }
+                        if (colDiff.uniqueTables) {
+                            colDiff.uniqueTables.forEach((uniqueTable) => {
+                                if (typeof uniqueTable.properties === 'undefined') {
+                                    builder.dropUnique([], uniqueTable.name);
+                                    return;
+                                }
+                                builder.unique(uniqueTable.properties, uniqueTable.name);
+                            });
+                        }
+                        if (colDiff.actionType === 'DELETE') {
+                            builder.dropColumn(colDiff.colName);
+                            continue;
+                        }
+                        if (colDiff.actionType === 'ALTER' &&
+                            !colDiff.colType &&
+                            typeof colDiff.colChanges === 'undefined')
+                            continue;
+                        if (typeof colDiff.colChanges?.unique !== 'undefined') {
+                            if (colDiff.colChanges?.unique) {
+                                builder.unique([colDiff.colName], `${tableDiff.tableName}_${colDiff.colName}_key`);
+                            }
+                            else {
+                                builder.dropUnique([colDiff.colName], `${tableDiff.tableName}_${colDiff.colName}_key`);
+                            }
+                        }
+                        if (typeof colDiff.colChanges?.foreignKeys !== 'undefined') {
+                            if (colDiff.colChanges.foreignKeys.length !== 0) {
+                                colDiff.colChanges.foreignKeys.forEach((fk) => {
+                                    builder
+                                        .foreign(colDiff.colName, `${tableDiff.tableName}_${colDiff.colName}_fk`)
+                                        .references(`${fk.referencedTableName}.${fk.referencedColumnName}`);
+                                });
+                            }
+                            else {
+                                builder.dropForeign(colDiff.colName, `${tableDiff.tableName}_${colDiff.colName}_fk`);
+                            }
+                        }
+                        const columnBuilder = this.assignType(builder, colDiff, tableDiff);
+                        if (!columnBuilder)
+                            continue;
+                        if (colDiff.actionType === 'ALTER') {
+                            columnBuilder.alter({ alterNullable: false });
+                            continue;
+                        }
+                    }
+                })
+                    .toSQL();
+            }
+            sql.push(...query.flatMap((q) => q.sql.concat(';')));
+            sql.push(...partialIndexSql);
+        }
+        return sql;
+    }
+    async createTable(tableDiff) {
+        return await this.knex.schema
+            .withSchema(tableDiff.schema)
+            .createTable(tableDiff.tableName, (builder) => {
+            for (const diff of tableDiff.colDiffs) {
+                if (diff.actionType === 'INDEX') {
+                    diff.indexTables.forEach((indexTable) => {
+                        if (typeof indexTable.properties === 'undefined') {
+                            builder.dropIndex([], indexTable.name);
+                            return;
+                        }
+                        if (this.isPartialIndexTable(indexTable)) {
+                            return;
+                        }
+                        if (indexTable.name.includes('pkey')) {
+                            return;
+                        }
+                        builder.index(indexTable.properties, indexTable.name);
+                    });
+                }
+                if (diff.uniqueTables) {
+                    diff.uniqueTables.forEach((uniqueTable) => {
+                        if (typeof uniqueTable.properties === 'undefined') {
+                            builder.dropUnique([], uniqueTable.name);
+                            return;
+                        }
+                        builder.unique(uniqueTable.properties, uniqueTable.name);
+                    });
+                }
+                if (typeof diff.colChanges?.foreignKeys !== 'undefined') {
+                    if (diff.colChanges.foreignKeys.length !== 0) {
+                        diff.colChanges.foreignKeys.forEach((fk) => {
+                            builder
+                                .foreign(diff.colName, `${tableDiff.tableName}_${diff.colName}_fk`)
+                                .references(`${fk.referencedTableName}.${fk.referencedColumnName}`);
+                        });
+                    }
+                    else {
+                        builder.dropForeign(diff.colName, `${tableDiff.tableName}_${diff.colName}_fk`);
+                    }
+                }
+                this.assignType(builder, diff, tableDiff);
+                if (typeof diff.colChanges?.unique !== 'undefined') {
+                    if (diff.colChanges?.unique) {
+                        builder.unique([diff.colName], `${tableDiff.tableName}_${diff.colName}_key`);
+                    }
+                    else {
+                        builder.dropUnique([diff.colName], `${tableDiff.tableName}_${diff.colName}_key`);
+                    }
+                }
+            }
+        })
+            .toSQL();
+    }
+    buildPartialIndexStatements(tableDiff) {
+        const tables = this.collectPartialIndexTables(tableDiff.colDiffs);
+        const statements = tables.map((indexTable) => this.buildPartialIndexStatement(tableDiff, indexTable));
+        return statements;
+    }
+    collectPartialIndexTables(colDiffs) {
+        const tables = [];
+        for (const diff of colDiffs) {
+            if (diff.actionType !== 'INDEX' || !diff.indexTables) {
+                continue;
+            }
+            for (const indexTable of diff.indexTables) {
+                if (this.isPartialIndexTable(indexTable)) {
+                    tables.push(indexTable);
+                }
+            }
+        }
+        return tables;
+    }
+    buildPartialIndexStatement(tableDiff, indexTable) {
+        if (this.orm.driverInstance.dbType !== 'postgres') {
+            throw new Error('Partial indexes are only supported on postgres.');
+        }
+        const schema = tableDiff.schema ?? 'public';
+        const columns = this.formatIndexColumns(indexTable.properties);
+        const statement = `CREATE INDEX "${indexTable.name}" ON "${schema}"."${tableDiff.tableName}" (${columns}) WHERE ${indexTable.where};`;
+        return this.ensureStatement(statement);
+    }
+    ensureStatement(statement) {
+        const trimmed = statement.trim();
+        if (trimmed.endsWith(';')) {
+            return trimmed;
+        }
+        return `${trimmed};`;
+    }
+    isPartialIndexTable(indexTable) {
+        if (!indexTable.where) {
+            return false;
+        }
+        if (!indexTable.properties) {
+            return false;
+        }
+        return indexTable.properties.length > 0;
+    }
+    formatIndexColumns(properties) {
+        if (!properties) {
+            return '';
+        }
+        return properties.map((prop) => `"${prop}"`).join(', ');
+    }
+    sortTablesByDependencies(diff) {
+        const newTables = diff.filter((d) => d.newTable);
+        const alterTables = diff.filter((d) => !d.newTable);
+        if (newTables.length === 0) {
+            return diff;
+        }
+        const dependencies = new Map();
+        const allTables = new Set();
+        newTables.forEach((tableDiff) => {
+            allTables.add(tableDiff.tableName);
+            dependencies.set(tableDiff.tableName, new Set());
+            tableDiff.colDiffs.forEach((colDiff) => {
+                if (colDiff.colChanges?.foreignKeys) {
+                    colDiff.colChanges.foreignKeys.forEach((fk) => {
+                        dependencies.get(tableDiff.tableName).add(fk.referencedTableName);
+                    });
+                }
+            });
+        });
+        const sorted = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (tableName) => {
+            if (visited.has(tableName))
+                return;
+            if (visiting.has(tableName)) {
+                return;
+            }
+            visiting.add(tableName);
+            const deps = dependencies.get(tableName);
+            if (deps) {
+                deps.forEach((dep) => {
+                    if (allTables.has(dep)) {
+                        visit(dep);
+                    }
+                });
+            }
+            visiting.delete(tableName);
+            visited.add(tableName);
+            const tableDiff = newTables.find((t) => t.tableName === tableName);
+            if (tableDiff) {
+                sorted.push(tableDiff);
+            }
+        };
+        newTables.forEach((tableDiff) => visit(tableDiff.tableName));
+        newTables.forEach((tableDiff) => {
+            if (!visited.has(tableDiff.tableName)) {
+                sorted.push(tableDiff);
+            }
+        });
+        return [...sorted, ...alterTables];
+    }
+    dropEnumConstraints(tableName, columnName) {
+        const possibleConstraintNames = [
+            `${tableName}_${columnName}_check`,
+            `${columnName}_check`,
+        ];
+        return possibleConstraintNames.map((constraintName) => `alter table "${tableName}" drop constraint if exists "${constraintName}";`);
+    }
+    assignType(builder, diff, tableDiff) {
+        if (diff.actionType === 'ALTER') {
+            if (diff.colChanges?.nullable !== undefined) {
+                if (diff.colChanges?.nullable) {
+                    builder.setNullable(diff.colName);
+                }
+            }
+        }
+        if (!diff.colType)
+            return;
+        const columnName = diff.colName;
+        const columnType = diff.colType;
+        let columnBuilder;
+        if (diff.colChanges?.autoIncrement !== undefined) {
+            if (diff.colChanges?.autoIncrement) {
+                columnBuilder = builder.increments(diff.colName, {
+                    primaryKey: diff.colChanges?.primary,
+                });
+            }
+        }
+        else {
+            switch (columnType) {
+                case 'varchar':
+                    columnBuilder = builder.string(columnName, diff.colLength);
+                    break;
+                case 'text':
+                    columnBuilder = builder.text(columnName);
+                    break;
+                case 'int':
+                case 'numeric':
+                case 'integer':
+                    columnBuilder = builder.integer(columnName, diff.colLength);
+                    break;
+                case 'bigint':
+                    columnBuilder = builder.bigInteger(columnName);
+                    break;
+                case 'double precision':
+                case 'double':
+                    columnBuilder = builder.double(columnName, diff.colChanges?.precision, diff.colChanges?.scale);
+                    break;
+                case 'float4':
+                case 'real':
+                case 'float':
+                    columnBuilder = builder.float(columnName, diff.colChanges?.precision, diff.colChanges?.scale);
+                    break;
+                case 'decimal':
+                    columnBuilder = builder.decimal(columnName, diff.colChanges?.precision, diff.colChanges?.scale);
+                    break;
+                case 'date':
+                    columnBuilder = builder.date(columnName);
+                    break;
+                case 'datetime':
+                    columnBuilder = builder.datetime(columnName);
+                    break;
+                case 'time':
+                    columnBuilder = builder.time(columnName);
+                    break;
+                case 'timestamp':
+                    columnBuilder = builder.timestamp(columnName, {
+                        precision: diff.colLength,
+                    });
+                    break;
+                case 'boolean':
+                    columnBuilder = builder.boolean(columnName);
+                    break;
+                case 'json':
+                    columnBuilder = builder.json(columnName);
+                    break;
+                case 'jsonb':
+                    columnBuilder = builder.jsonb(columnName);
+                    break;
+                case 'enum':
+                    if (diff.actionType === 'ALTER' && diff.colChanges?.enumItems) {
+                        columnBuilder = builder
+                            .text(columnName)
+                            .checkIn(diff.colChanges.enumItems ?? [], `${columnName}_check`);
+                    }
+                    else {
+                        columnBuilder = builder.enum(columnName, diff.colChanges.enumItems ?? []);
+                    }
+                    break;
+                case 'array':
+                    columnBuilder = builder.specificType(columnName, 'text[]');
+                    break;
+                case 'uuid':
+                    columnBuilder = builder.uuid(columnName);
+                    break;
+                default:
+                    columnBuilder = builder.string(columnName, diff.colLength);
+                    break;
+            }
+        }
+        columnBuilder.notNullable();
+        if (diff.colChanges?.nullable !== undefined) {
+            if (diff.colChanges?.nullable) {
+                columnBuilder.nullable();
+            }
+        }
+        if (diff.colChanges?.default !== undefined) {
+            columnBuilder.defaultTo(diff.colChanges?.default);
+        }
+        if (typeof diff.colChanges?.primary !== 'undefined') {
+            if (diff.colChanges?.primary) {
+                columnBuilder.primary();
+            }
+            else {
+                builder.dropPrimary();
+            }
+        }
+        return columnBuilder;
+    }
+    async migrate() {
+        await this.startConnection();
+        const migrationTable = 'carno_migrations';
+        const migrationDirectory = path.join(process.cwd(), this.config.migrationPath ?? 'database/migrations');
+        const migrationFiles = fs
+            .readdirSync(migrationDirectory)
+            .filter((file) => file.endsWith('.sql'))
+            .sort();
+        if (migrationFiles.length === 0) {
+            this.orm.logger.info('No migration files found');
+            return;
+        }
+        await this.orm.transaction(async () => {
+            await this.orm.driverInstance.executeSql(`CREATE TABLE IF NOT EXISTS "${migrationTable}" ("migration_file" character varying(255) NOT NULL PRIMARY KEY UNIQUE);`);
+            const migrated = await this.orm.driverInstance.executeSql(`SELECT * FROM "${migrationTable}" ORDER BY "migration_file" ASC;`);
+            const migratedArray = Array.isArray(migrated) ? migrated : [];
+            const lastMigration = migratedArray[migratedArray.length - 1];
+            const lastMigrationIndex = migrationFiles.indexOf(lastMigration?.migration_file ?? '');
+            const migrationsToExecute = migrationFiles.slice(lastMigrationIndex + 1);
+            if (migrationsToExecute.length === 0) {
+                this.orm.logger.info('Database is up to date');
+                return;
+            }
+            for (const migrationFile of migrationsToExecute) {
+                const migrationFilePath = path.join(migrationDirectory, migrationFile);
+                const migrationContent = fs.readFileSync(migrationFilePath, {
+                    encoding: 'utf-8',
+                });
+                const sqlInstructions = migrationContent
+                    .split(';')
+                    .filter((sql) => sql.trim().length > 0);
+                this.orm.logger.info(`Executing migration: ${migrationFile}`);
+                for (const sqlInstruction of sqlInstructions) {
+                    await this.orm.driverInstance.executeSql(sqlInstruction);
+                }
+                await this.orm.driverInstance.executeSql(`INSERT INTO "${migrationTable}" ("migration_file") VALUES ('${migrationFile}');`);
+                this.orm.logger.info(`Migration executed: ${migrationFile}`);
+            }
+        });
+    }
+    async generateMigration(configFile = process.cwd(), onlySql = false) {
+        await this.startConnection(configFile);
+        const directory = path.join(process.cwd(), this.config.migrationPath ?? 'database/migrations');
+        const snapshotManager = new snapshot_manager_1.SnapshotManager(directory);
+        const snapshotEntities = await this.snapshotEntities();
+        const normalizedEntitiesSnapshot = this.normalizeSnapshotTypes(snapshotEntities);
+        let previousSnapshot = snapshotManager.loadSnapshot();
+        if (!previousSnapshot) {
+            previousSnapshot = await this.snapshotBd();
+        }
+        const normalizedPreviousSnapshot = this.normalizeSnapshotTypes(previousSnapshot);
+        const calculator = new diff_calculator_1.DiffCalculator(this.entities, this.orm.driverInstance);
+        const diff = calculator.diff(normalizedPreviousSnapshot, normalizedEntitiesSnapshot);
+        const sql = this.lastTreatment(await this.run(diff));
+        if (onlySql) {
+            return sql;
+        }
+        const fileName = `migration_${new Date().toISOString().replace(/[^\d]/g, '')}` + `.sql`;
+        const migrationFilePath = path.join(directory, fileName);
+        if (!fs.existsSync(directory)) {
+            fs.mkdirSync(directory, { recursive: true });
+        }
+        const migrationContent = sql.join('\n');
+        if (migrationContent.length === 0) {
+            this.orm.logger.info('No changes detected');
+            return;
+        }
+        else {
+            fs.writeFileSync(migrationFilePath, migrationContent);
+            this.orm.logger.info(`Migration file created: ${migrationFilePath}`);
+            snapshotManager.saveSnapshot(normalizedEntitiesSnapshot);
+            this.orm.logger.info(`Snapshot updated: ${snapshotManager.getSnapshotPath()}`);
+        }
+    }
+    lastTreatment(sql) {
+        const getDropIndexes = sql.filter((s) => s.startsWith('drop index'));
+        const getDropColumns = sql.filter((s) => s.includes('drop column'));
+        const dropIndexes = [];
+        for (const dropIndex of getDropIndexes) {
+            const rawToken = dropIndex.split(' ')[2];
+            const indexFullName = rawToken?.replace(/"/g, '');
+            if (!indexFullName)
+                continue;
+            const indexBase = indexFullName.includes('.')
+                ? indexFullName.split('.').pop() || indexFullName
+                : indexFullName;
+            const parts = indexBase.split('_');
+            let colName;
+            if (parts.length >= 3) {
+                colName = parts[parts.length - 2];
+            }
+            else if (parts.length >= 2) {
+                colName = parts[0];
+            }
+            if (!colName) {
+                continue;
+            }
+            const dropColumn = getDropColumns.find((s) => s.includes(colName));
+            if (dropColumn) {
+                dropIndexes.push(dropIndex);
+            }
+        }
+        const sqlFiltered = sql.filter((s) => !dropIndexes.includes(s));
+        const seen = new Set();
+        const deduped = sqlFiltered.filter((s) => {
+            if (seen.has(s))
+                return false;
+            seen.add(s);
+            return true;
+        });
+        return deduped;
+    }
+    normalizeSnapshotTypes(snapshot) {
+        if (!snapshot)
+            return [];
+        const normalizeType = (type) => {
+            if (!type)
+                return type;
+            const lower = type.toLowerCase();
+            if (lower.startsWith('decimal') || lower.startsWith('numeric')) {
+                return 'decimal';
+            }
+            if (lower === 'double precision' ||
+                lower === 'double' ||
+                lower === 'real' ||
+                lower.startsWith('float')) {
+                return 'float';
+            }
+            return lower;
+        };
+        return snapshot.map((table) => ({
+            ...table,
+            columns: table.columns.map((col) => ({
+                ...col,
+                type: normalizeType(col.type),
+                nullable: col.nullable ?? false,
+            })),
+            indexes: this.normalizeIndexes(table.indexes),
+            uniques: table.uniques ?? [],
+        }));
+    }
+    normalizeIndexes(indexes) {
+        if (!indexes) {
+            return [];
+        }
+        return indexes.map((index) => this.normalizeIndex(index));
+    }
+    normalizeIndex(index) {
+        if (!this.isIndexDefinition(index.columnName)) {
+            return index;
+        }
+        const parsed = this.parseIndexDefinition(index.columnName);
+        return {
+            ...index,
+            columnName: parsed.columns,
+            where: parsed.where ?? index.where,
+        };
+    }
+    isIndexDefinition(value) {
+        const upper = value.toUpperCase();
+        return upper.includes('CREATE INDEX') || upper.includes('CREATE UNIQUE INDEX');
+    }
+    parseIndexDefinition(definition) {
+        const columns = this.extractIndexColumns(definition);
+        const where = this.extractIndexWhere(definition);
+        return { columns, where };
+    }
+    extractIndexColumns(definition) {
+        const content = this.extractFirstParenContent(definition);
+        return this.normalizeIndexColumns(content);
+    }
+    extractFirstParenContent(definition) {
+        const match = definition.match(/\(([^)]+)\)/);
+        if (!match) {
+            return '';
+        }
+        return match[1];
+    }
+    normalizeIndexColumns(value) {
+        const tokens = value.split(',');
+        const cleaned = tokens.map((token) => this.cleanIndexToken(token));
+        return cleaned.join(',');
+    }
+    cleanIndexToken(token) {
+        const trimmed = token.trim();
+        return trimmed.replace(/"/g, '');
+    }
+    extractIndexWhere(definition) {
+        const match = definition.match(/WHERE (.+)$/i);
+        if (!match) {
+            return undefined;
+        }
+        return match[1].trim();
+    }
+    async snapshotBd() {
+        const snapshot = [];
+        for (const [_, values] of this.entities.entries()) {
+            const bd = await this.orm.driverInstance.snapshot(values.tableName);
+            if (!bd) {
+                continue;
+            }
+            snapshot.push(bd);
+        }
+        return snapshot;
+    }
+    async snapshotEntities() {
+        const snapshot = [];
+        const processedTables = new Set();
+        const tableToEntity = new Map();
+        for (const [entityClass, values] of this.entities.entries()) {
+            if (!tableToEntity.has(values.tableName)) {
+                tableToEntity.set(values.tableName, entityClass);
+            }
+        }
+        for (const [entityClass, values] of this.entities.entries()) {
+            if (processedTables.has(values.tableName)) {
+                continue;
+            }
+            if (tableToEntity.get(values.tableName) !== entityClass) {
+                continue;
+            }
+            const tableSnapshot = await this.entities.snapshot(values);
+            snapshot.push(tableSnapshot);
+            processedTables.add(values.tableName);
+        }
+        return snapshot;
+    }
+    async destroy() {
+        if (this.knex) {
+            await this.knex.destroy();
+            this.knex = null;
+        }
+    }
+}
+exports.Migrator = Migrator;
+//# sourceMappingURL=migrator.js.map