agnostic-sql-migrator/dist/migrations.js

Database agnostic migrator tool for SQL databases

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.executeMigrations = exports.migrateDb = exports.validateMigrations = exports.getMigrationFiles = void 0;
const fs_1 = require("fs");
const version_1 = require("./version");
const path = require("path");
const getMigrationFiles = (config) => {
    const files = fs_1.readdirSync(config.MigrationConfig.migrationsPath);
    if (files.length === 0) {
        throw new Error('No migrations found - check migrations folder');
    }
    const RollBackward = files
        .map((file) => {
        const numbers = file.split('.')[0];
        const number1 = Number.parseInt(numbers.split('-')[0]);
        const number2 = Number.parseInt(numbers.split('-')[1]);
        if (number1 > number2) {
            return {
                Path: path.join(config.MigrationConfig.migrationsPath, file),
                VersionTo: number2,
                VersionFrom: number1,
            };
        }
    })
        .filter((item) => item !== undefined)
        .sort((a, b) => (a.VersionTo > b.VersionTo ? -1 : 1));
    const RollForward = files
        .map((file) => {
        const numbers = file.split('.')[0];
        const number1 = Number.parseInt(numbers.split('-')[0]);
        const number2 = Number.parseInt(numbers.split('-')[1]);
        if (number1 < number2) {
            return {
                Path: path.join(config.MigrationConfig.migrationsPath, file),
                VersionTo: number2,
                VersionFrom: number1,
            };
        }
    })
        .filter((item) => item !== undefined)
        .sort((a, b) => (a.VersionTo > b.VersionTo ? 1 : -1));
    return {
        RollBackward,
        RollForward,
    };
};
exports.getMigrationFiles = getMigrationFiles;
const validateMigrations = (versionTo, versionFrom, migrations) => {
    let migrationsValid = true;
    return migrationsValid;
};
exports.validateMigrations = validateMigrations;
const migrateDb = (client, adapter, version, migrations, adapterType) => __awaiter(void 0, void 0, void 0, function* () {
    const versionExists = yield version_1.Version.exists(client, adapter, adapterType);
    if (!versionExists) {
        yield version_1.Version.create(client, adapter, adapterType);
    }
    let currentVersion = yield version_1.Version.get(client, adapter, adapterType);
    if (currentVersion === version) {
        console.log('DB is already at the specified version - no migrations to carry out.');
    }
    if (currentVersion < version) {
        console.log('Rolling forwards to version: ', version);
        const rollforward = migrations.RollForward.filter((item) => item.VersionFrom <= version &&
            item.VersionTo <= version &&
            item.VersionTo > currentVersion);
        yield exports.executeMigrations(client, adapter, version, rollforward, adapterType);
    }
    if (currentVersion > version) {
        console.log('Rolling backwards to version: ', version);
        const rollbackward = migrations.RollBackward.filter((item) => item.VersionFrom >= version &&
            item.VersionTo >= version &&
            item.VersionTo < currentVersion);
        yield exports.executeMigrations(client, adapter, version, rollbackward, adapterType);
    }
});
exports.migrateDb = migrateDb;
const executeMigrations = (client, adapter, version, migrations, adapterType) => __awaiter(void 0, void 0, void 0, function* () {
    if (migrations.length === 0) {
        return;
    }
    for (let i = 0; i < migrations.length; i++) {
        const migration = migrations[i];
        const query = fs_1.readFileSync(migration.Path).toString();
        console.log('Executing migration: ', query);
        try {
            yield adapter.query(client, query);
            yield version_1.Version.update(client, adapter, migration.VersionTo, adapterType);
        }
        catch (err) {
            throw new Error(`Failed to execute migration with error: ${err}`);
        }
    }
    console.log('Migrations successfully completed. DB is now on version: ', version);
});
exports.executeMigrations = executeMigrations;
//# sourceMappingURL=migrations.js.map