-import { waterfall, eachSeries } from 'async'
-import * as fs from 'fs'
import * as path from 'path'
-import * as Sequelize from 'sequelize'
-
-import { database as db } from './database'
+import { readdirPromise } from '../helpers/core-utils'
+import { logger } from '../helpers/logger'
import { LAST_MIGRATION_VERSION } from './constants'
-import { logger } from '../helpers'
-import { ApplicationInstance } from '../models'
-
-function migrate (finalCallback: (err: Error) => void) {
- waterfall([
-
- function checkApplicationTableExists (callback) {
- db.sequelize.getQueryInterface().showAllTables().asCallback(function (err, tables) {
- if (err) return callback(err)
-
- // No tables, we don't need to migrate anything
- // The installer will do that
- if (tables.length === 0) return finalCallback(null)
+import { sequelizeTypescript } from './database'
- return callback(null)
- })
- },
-
- function loadMigrationVersion (callback) {
- db.Application.loadMigrationVersion(callback)
- },
+async function migrate () {
+ const tables = await sequelizeTypescript.getQueryInterface().showAllTables()
- function createMigrationRowIfNotExists (actualVersion, callback) {
- if (actualVersion === null) {
- db.Application.create({
- migrationVersion: 0
- }, function (err) {
- return callback(err, 0)
- })
- }
+ // No tables, we don't need to migrate anything
+ // The installer will do that
+ if (tables.length === 0) return
- return callback(null, actualVersion)
- },
+ let actualVersion: number = null
- function abortMigrationIfNotNeeded (actualVersion, callback) {
- // No need migrations
- if (actualVersion >= LAST_MIGRATION_VERSION) return finalCallback(null)
+ const [ rows ] = await sequelizeTypescript.query('SELECT "migrationVersion" FROM "application"')
+ if (rows && rows[0] && rows[0].migrationVersion) {
+ actualVersion = rows[0].migrationVersion
+ }
- return callback(null, actualVersion)
- },
+ if (actualVersion === null) {
+ await sequelizeTypescript.query('INSERT INTO "application" ("migrationVersion") VALUES (0)')
+ actualVersion = 0
+ }
- function getMigrations (actualVersion, callback) {
- // If there are a new migration scripts
- logger.info('Begin migrations.')
+ // No need migrations, abort
+ if (actualVersion >= LAST_MIGRATION_VERSION) return
- getMigrationScripts(function (err, migrationScripts) {
- return callback(err, actualVersion, migrationScripts)
- })
- },
+ // If there are a new migration scripts
+ logger.info('Begin migrations.')
- function doMigrations (actualVersion, migrationScripts, callback) {
- eachSeries(migrationScripts, function (entity: any, callbackEach) {
- executeMigration(actualVersion, entity, callbackEach)
- }, function (err) {
- if (err) return callback(err)
+ const migrationScripts = await getMigrationScripts()
- logger.info('Migrations finished. New migration version schema: %s', LAST_MIGRATION_VERSION)
- return callback(null)
- })
+ for (const migrationScript of migrationScripts) {
+ try {
+ await executeMigration(actualVersion, migrationScript)
+ } catch (err) {
+ logger.error('Cannot execute migration %s.', migrationScript.version, { err })
+ process.exit(-1)
}
- ], finalCallback)
+ }
+
+ logger.info('Migrations finished. New migration version schema: %s', LAST_MIGRATION_VERSION)
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
-type GetMigrationScriptsCallback = (err: Error, filesToMigrate?: { version: string, script: string }[]) => void
-function getMigrationScripts (callback: GetMigrationScriptsCallback) {
- fs.readdir(path.join(__dirname, 'migrations'), function (err, files) {
- if (err) return callback(err)
-
- const filesToMigrate = []
+async function getMigrationScripts () {
+ const files = await readdirPromise(path.join(__dirname, 'migrations'))
+ const filesToMigrate: {
+ version: string,
+ script: string
+ }[] = []
- files.forEach(function (file) {
+ files
+ .filter(file => file.endsWith('.js.map') === false)
+ .forEach(file => {
// Filename is something like 'version-blabla.js'
const version = file.split('-')[0]
filesToMigrate.push({
})
})
- return callback(err, filesToMigrate)
- })
+ return filesToMigrate
}
-function executeMigration (actualVersion: number, entity: { version: string, script: string }, callback: (err: Error) => void) {
+async function executeMigration (actualVersion: number, entity: { version: string, script: string }) {
const versionScript = parseInt(entity.version, 10)
// Do not execute old migration scripts
- if (versionScript <= actualVersion) return callback(null)
+ if (versionScript <= actualVersion) return undefined
// Load the migration module and run it
const migrationScriptName = entity.script
const migrationScript = require(path.join(__dirname, 'migrations', migrationScriptName))
- db.sequelize.transaction().asCallback(function (err, t) {
- if (err) return callback(err)
-
+ return sequelizeTypescript.transaction(async t => {
const options = {
transaction: t,
- queryInterface: db.sequelize.getQueryInterface(),
- sequelize: db.sequelize,
- Sequelize: Sequelize
+ queryInterface: sequelizeTypescript.getQueryInterface(),
+ sequelize: sequelizeTypescript
}
- migrationScript.up(options, function (err) {
- if (err) {
- t.rollback()
- return callback(err)
- }
-
- // Update the new migration version
- db.Application.updateMigrationVersion(versionScript, t, function (err) {
- if (err) {
- t.rollback()
- return callback(err)
- }
-
- t.commit().asCallback(callback)
- })
- })
+
+ await migrationScript.up(options)
+
+ // Update the new migration version
+ await sequelizeTypescript.query('UPDATE "application" SET "migrationVersion" = ' + versionScript, { transaction: t })
})
}