Merge branch 'postgresql'

14 files changed, 204 insertions, 371 deletions

diff --git a/server/initializers/checker.js b/server/initializers/checker.js
index aea013fa9..6471bb4f1 100644
--- a/server/initializers/checker.js
+++ b/server/initializers/checker.js
@@ -1,10 +1,8 @@
 'use strict'
 
 const config = require('config')
-const mongoose = require('mongoose')
 
-const Client = mongoose.model('OAuthClient')
-const User = mongoose.model('User')
+const db = require('./database')
 
 const checker = {
   checkConfig,
@@ -29,7 +27,7 @@ function checkConfig () {
 function checkMissedConfig () {
   const required = [ 'listen.port',
     'webserver.https', 'webserver.hostname', 'webserver.port',
-    'database.hostname', 'database.port', 'database.suffix',
+    'database.hostname', 'database.port', 'database.suffix', 'database.username', 'database.password',
     'storage.certs', 'storage.videos', 'storage.logs', 'storage.thumbnails', 'storage.previews'
   ]
   const miss = []
@@ -44,15 +42,15 @@ function checkMissedConfig () {
 }
 
 function clientsExist (callback) {
-  Client.list(function (err, clients) {
+  db.OAuthClient.countTotal(function (err, totalClients) {
     if (err) return callback(err)
 
-    return callback(null, clients.length !== 0)
+    return callback(null, totalClients !== 0)
   })
 }
 
 function usersExist (callback) {
-  User.countTotal(function (err, totalUsers) {
+  db.User.countTotal(function (err, totalUsers) {
     if (err) return callback(err)
 
     return callback(null, totalUsers !== 0)
diff --git a/server/initializers/constants.js b/server/initializers/constants.js
index 3ddf87454..97e3c5296 100644
--- a/server/initializers/constants.js
+++ b/server/initializers/constants.js
@@ -1,7 +1,6 @@
 'use strict'
 
 const config = require('config')
-const maxBy = require('lodash/maxBy')
 const path = require('path')
 
 // ---------------------------------------------------------------------------
@@ -14,13 +13,14 @@ const PAGINATION_COUNT_DEFAULT = 15
 
 // Sortable columns per schema
 const SEARCHABLE_COLUMNS = {
-  VIDEOS: [ 'name', 'magnetUri', 'podHost', 'author', 'tags' ]
+  VIDEOS: [ 'name', 'magnetUri', 'host', 'author', 'tags' ]
 }
 
 // Sortable columns per schema
 const SORTABLE_COLUMNS = {
-  USERS: [ 'username', '-username', 'createdDate', '-createdDate' ],
-  VIDEOS: [ 'name', '-name', 'duration', '-duration', 'createdDate', '-createdDate' ]
+  USERS: [ 'username', '-username', 'createdAt', '-createdAt' ],
+  VIDEO_ABUSES: [ 'createdAt', '-createdAt' ],
+  VIDEOS: [ 'name', '-name', 'duration', '-duration', 'createdAt', '-createdAt' ]
 }
 
 const OAUTH_LIFETIME = {
@@ -37,7 +37,9 @@ const CONFIG = {
   DATABASE: {
     DBNAME: 'peertube' + config.get('database.suffix'),
     HOSTNAME: config.get('database.hostname'),
-    PORT: config.get('database.port')
+    PORT: config.get('database.port'),
+    USERNAME: config.get('database.username'),
+    PASSWORD: config.get('database.password')
   },
   STORAGE: {
     CERT_DIR: path.join(__dirname, '..', '..', config.get('storage.certs')),
@@ -64,17 +66,19 @@ const CONSTRAINTS_FIELDS = {
     USERNAME: { min: 3, max: 20 }, // Length
     PASSWORD: { min: 6, max: 255 } // Length
   },
+  VIDEO_ABUSES: {
+    REASON: { min: 2, max: 300 } // Length
+  },
   VIDEOS: {
     NAME: { min: 3, max: 50 }, // Length
     DESCRIPTION: { min: 3, max: 250 }, // Length
-    MAGNET: {
-      INFO_HASH: { min: 10, max: 50 } // Length
-    },
+    EXTNAME: [ '.mp4', '.ogv', '.webm' ],
+    INFO_HASH: { min: 40, max: 40 }, // Length, infohash is 20 bytes length but we represent it in hexa so 20 * 2
     DURATION: { min: 1, max: 7200 }, // Number
     TAGS: { min: 1, max: 3 }, // Number of total tags
     TAG: { min: 2, max: 10 }, // Length
     THUMBNAIL: { min: 2, max: 30 },
-    THUMBNAIL64: { min: 0, max: 20000 } // Bytes
+    THUMBNAIL_DATA: { min: 0, max: 20000 } // Bytes
   }
 }
 
@@ -88,41 +92,7 @@ const FRIEND_SCORE = {
 
 // ---------------------------------------------------------------------------
 
-const MONGO_MIGRATION_SCRIPTS = [
-  {
-    script: '0005-create-application',
-    version: 5
-  },
-  {
-    script: '0010-users-password',
-    version: 10
-  },
-  {
-    script: '0015-admin-role',
-    version: 15
-  },
-  {
-    script: '0020-requests-endpoint',
-    version: 20
-  },
-  {
-    script: '0025-video-filenames',
-    version: 25
-  },
-  {
-    script: '0030-video-magnet',
-    version: 30
-  },
-  {
-    script: '0035-url-to-host',
-    version: 35
-  },
-  {
-    script: '0040-video-remote-id',
-    version: 40
-  }
-]
-const LAST_MONGO_SCHEMA_VERSION = (maxBy(MONGO_MIGRATION_SCRIPTS, 'version'))['version']
+const LAST_MIGRATION_VERSION = 0
 
 // ---------------------------------------------------------------------------
 
@@ -138,8 +108,10 @@ let REQUESTS_INTERVAL = 600000
 // Number of requests in parallel we can make
 const REQUESTS_IN_PARALLEL = 10
 
-// How many requests we put in request
-const REQUESTS_LIMIT = 10
+// To how many pods we send requests
+const REQUESTS_LIMIT_PODS = 10
+// How many requests we send to a pod per interval
+const REQUESTS_LIMIT_PER_POD = 5
 
 // Number of requests to retry for replay requests module
 const RETRY_REQUESTS = 5
@@ -148,16 +120,21 @@ const REQUEST_ENDPOINTS = {
   VIDEOS: 'videos'
 }
 
-// ---------------------------------------------------------------------------
-
 const REMOTE_SCHEME = {
   HTTP: 'https',
   WS: 'wss'
 }
 
+// ---------------------------------------------------------------------------
+
+const SIGNATURE_ALGORITHM = 'RSA-SHA256'
+const SIGNATURE_ENCODING = 'hex'
+
 // Password encryption
 const BCRYPT_SALT_SIZE = 10
 
+// ---------------------------------------------------------------------------
+
 // Express static paths (router)
 const STATIC_PATHS = {
   PREVIEWS: '/static/previews/',
@@ -173,6 +150,8 @@ let STATIC_MAX_AGE = '30d'
 const THUMBNAILS_SIZE = '200x110'
 const PREVIEWS_SIZE = '640x480'
 
+// ---------------------------------------------------------------------------
+
 const USER_ROLES = {
   ADMIN: 'admin',
   USER: 'user'
@@ -198,8 +177,7 @@ module.exports = {
   CONFIG,
   CONSTRAINTS_FIELDS,
   FRIEND_SCORE,
-  LAST_MONGO_SCHEMA_VERSION,
-  MONGO_MIGRATION_SCRIPTS,
+  LAST_MIGRATION_VERSION,
   OAUTH_LIFETIME,
   PAGINATION_COUNT_DEFAULT,
   PODS_SCORE,
@@ -208,9 +186,12 @@ module.exports = {
   REQUEST_ENDPOINTS,
   REQUESTS_IN_PARALLEL,
   REQUESTS_INTERVAL,
-  REQUESTS_LIMIT,
+  REQUESTS_LIMIT_PODS,
+  REQUESTS_LIMIT_PER_POD,
   RETRY_REQUESTS,
   SEARCHABLE_COLUMNS,
+  SIGNATURE_ALGORITHM,
+  SIGNATURE_ENCODING,
   SORTABLE_COLUMNS,
   STATIC_MAX_AGE,
   STATIC_PATHS,
diff --git a/server/initializers/database.js b/server/initializers/database.js
index 0564e4e77..f8f68adeb 100644
--- a/server/initializers/database.js
+++ b/server/initializers/database.js
@@ -1,37 +1,77 @@
 'use strict'
 
-const mongoose = require('mongoose')
+const fs = require('fs')
+const path = require('path')
+const Sequelize = require('sequelize')
 
 const constants = require('../initializers/constants')
 const logger = require('../helpers/logger')
+const utils = require('../helpers/utils')
 
-// Bootstrap models
-require('../models/application')
-require('../models/oauth-token')
-require('../models/user')
-require('../models/oauth-client')
-require('../models/video')
-// Request model needs Video model
-require('../models/pods')
-// Request model needs Pod model
-require('../models/request')
-
-const database = {
-  connect: connect
-}
+const database = {}
 
-function connect () {
-  mongoose.Promise = global.Promise
-  mongoose.connect('mongodb://' + constants.CONFIG.DATABASE.HOSTNAME + ':' + constants.CONFIG.DATABASE.PORT + '/' + constants.CONFIG.DATABASE.DBNAME)
-  mongoose.connection.on('error', function () {
-    throw new Error('Mongodb connection error.')
-  })
+const dbname = constants.CONFIG.DATABASE.DBNAME
+const username = constants.CONFIG.DATABASE.USERNAME
+const password = constants.CONFIG.DATABASE.PASSWORD
 
-  mongoose.connection.on('open', function () {
-    logger.info('Connected to mongodb.')
-  })
-}
+const sequelize = new Sequelize(dbname, username, password, {
+  dialect: 'postgres',
+  host: constants.CONFIG.DATABASE.HOSTNAME,
+  port: constants.CONFIG.DATABASE.PORT,
+  benchmark: utils.isTestInstance(),
+
+  logging: function (message, benchmark) {
+    let newMessage = message
+    if (benchmark !== undefined) {
+      newMessage += ' | ' + benchmark + 'ms'
+    }
+
+    logger.debug(newMessage)
+  }
+})
+
+database.sequelize = sequelize
+database.Sequelize = Sequelize
+database.init = init
 
 // ---------------------------------------------------------------------------
 
 module.exports = database
+
+// ---------------------------------------------------------------------------
+
+function init (silent, callback) {
+  if (!callback) {
+    callback = silent
+    silent = false
+  }
+
+  if (!callback) callback = function () {}
+
+  const modelDirectory = path.join(__dirname, '..', 'models')
+  fs.readdir(modelDirectory, function (err, files) {
+    if (err) throw err
+
+    files.filter(function (file) {
+      // For all models but not utils.js
+      if (file === 'utils.js') return false
+
+      return true
+    })
+    .forEach(function (file) {
+      const model = sequelize.import(path.join(modelDirectory, file))
+
+      database[model.name] = model
+    })
+
+    Object.keys(database).forEach(function (modelName) {
+      if ('associate' in database[modelName]) {
+        database[modelName].associate(database)
+      }
+    })
+
+    if (!silent) logger.info('Database is ready.')
+
+    return callback(null)
+  })
+}
diff --git a/server/initializers/installer.js b/server/initializers/installer.js
index 1df300ba8..fb63b81ac 100644
--- a/server/initializers/installer.js
+++ b/server/initializers/installer.js
@@ -3,26 +3,27 @@
 const config = require('config')
 const each = require('async/each')
 const mkdirp = require('mkdirp')
-const mongoose = require('mongoose')
 const passwordGenerator = require('password-generator')
 const path = require('path')
 const series = require('async/series')
 
 const checker = require('./checker')
 const constants = require('./constants')
+const db = require('./database')
 const logger = require('../helpers/logger')
 const peertubeCrypto = require('../helpers/peertube-crypto')
 
-const Application = mongoose.model('Application')
-const Client = mongoose.model('OAuthClient')
-const User = mongoose.model('User')
-
 const installer = {
   installApplication
 }
 
 function installApplication (callback) {
   series([
+    function createDatabase (callbackAsync) {
+      db.sequelize.sync().asCallback(callbackAsync)
+      // db.sequelize.sync({ force: true }).asCallback(callbackAsync)
+    },
+
     function createDirectories (callbackAsync) {
       createDirectoriesIfNotExist(callbackAsync)
     },
@@ -65,16 +66,18 @@ function createOAuthClientIfNotExist (callback) {
 
     logger.info('Creating a default OAuth Client.')
 
-    const secret = passwordGenerator(32, false)
-    const client = new Client({
+    const id = passwordGenerator(32, false, /[a-z0-9]/)
+    const secret = passwordGenerator(32, false, /[a-zA-Z0-9]/)
+    const client = db.OAuthClient.build({
+      clientId: id,
       clientSecret: secret,
       grants: [ 'password', 'refresh_token' ]
     })
 
-    client.save(function (err, createdClient) {
+    client.save().asCallback(function (err, createdClient) {
       if (err) return callback(err)
 
-      logger.info('Client id: ' + createdClient._id)
+      logger.info('Client id: ' + createdClient.clientId)
       logger.info('Client secret: ' + createdClient.clientSecret)
 
       return callback(null)
@@ -93,6 +96,7 @@ function createOAuthAdminIfNotExist (callback) {
 
     const username = 'root'
     const role = constants.USER_ROLES.ADMIN
+    const createOptions = {}
     let password = ''
 
     // Do not generate a random password for tests
@@ -102,25 +106,27 @@ function createOAuthAdminIfNotExist (callback) {
       if (process.env.NODE_APP_INSTANCE) {
         password += process.env.NODE_APP_INSTANCE
       }
+
+      // Our password is weak so do not validate it
+      createOptions.validate = false
     } else {
       password = passwordGenerator(8, true)
     }
 
-    const user = new User({
+    const userData = {
       username,
       password,
       role
-    })
+    }
 
-    user.save(function (err, createdUser) {
+    db.User.create(userData, createOptions).asCallback(function (err, createdUser) {
       if (err) return callback(err)
 
       logger.info('Username: ' + username)
       logger.info('User password: ' + password)
 
-      logger.info('Creating Application collection.')
-      const application = new Application({ mongoSchemaVersion: constants.LAST_MONGO_SCHEMA_VERSION })
-      application.save(callback)
+      logger.info('Creating Application table.')
+      db.Application.create({ migrationVersion: constants.LAST_MIGRATION_VERSION }).asCallback(callback)
     })
   })
 }
diff --git a/server/initializers/migrations/0005-create-application.js b/server/initializers/migrations/0005-create-application.js
deleted file mode 100644
index e99dec019..000000000
--- a/server/initializers/migrations/0005-create-application.js
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-  Create the application collection in MongoDB.
-  Used to store the actual MongoDB scheme version.
-*/
-
-const mongoose = require('mongoose')
-
-const Application = mongoose.model('Application')
-
-exports.up = function (callback) {
-  const application = new Application()
-  application.save(callback)
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0005-example.js b/server/initializers/migrations/0005-example.js
new file mode 100644
index 000000000..cedc42919
--- /dev/null
+++ b/server/initializers/migrations/0005-example.js
@@ -0,0 +1,14 @@
+// /*
+//   This is just an example.
+// */
+
+// const db = require('../database')
+
+// // options contains the transaction
+// exports.up = function (options, callback) {
+//   db.Application.create({ migrationVersion: 42 }, { transaction: options.transaction }).asCallback(callback)
+// }
+
+// exports.down = function (options, callback) {
+//   throw new Error('Not implemented.')
+// }
diff --git a/server/initializers/migrations/0010-users-password.js b/server/initializers/migrations/0010-users-password.js
deleted file mode 100644
index a0616a269..000000000
--- a/server/initializers/migrations/0010-users-password.js
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Convert plain user password to encrypted user password.
-*/
-
-const eachSeries = require('async/eachSeries')
-const mongoose = require('mongoose')
-
-const User = mongoose.model('User')
-
-exports.up = function (callback) {
-  User.list(function (err, users) {
-    if (err) return callback(err)
-
-    eachSeries(users, function (user, callbackEach) {
-      user.save(callbackEach)
-    }, callback)
-  })
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0015-admin-role.js b/server/initializers/migrations/0015-admin-role.js
deleted file mode 100644
index af06dca9e..000000000
--- a/server/initializers/migrations/0015-admin-role.js
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-  Set the admin role to the root user.
-*/
-
-const constants = require('../constants')
-const mongoose = require('mongoose')
-
-const User = mongoose.model('User')
-
-exports.up = function (callback) {
-  User.update({ username: 'root' }, { role: constants.USER_ROLES.ADMIN }, callback)
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0020-requests-endpoint.js b/server/initializers/migrations/0020-requests-endpoint.js
deleted file mode 100644
index 55feec571..000000000
--- a/server/initializers/migrations/0020-requests-endpoint.js
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
-  Set the endpoint videos for requests.
-*/
-
-const mongoose = require('mongoose')
-
-const Request = mongoose.model('Request')
-
-exports.up = function (callback) {
-  Request.update({ }, { endpoint: 'videos' }, callback)
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0025-video-filenames.js b/server/initializers/migrations/0025-video-filenames.js
deleted file mode 100644
index df21494d7..000000000
--- a/server/initializers/migrations/0025-video-filenames.js
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-  Rename thumbnails and video filenames to _id.extension
-*/
-
-const each = require('async/each')
-const fs = require('fs')
-const path = require('path')
-const mongoose = require('mongoose')
-
-const constants = require('../constants')
-const logger = require('../../helpers/logger')
-
-const Video = mongoose.model('Video')
-
-exports.up = function (callback) {
-  // Use of lean because the new Video scheme does not have filename field
-  Video.find({ filename: { $ne: null } }).lean().exec(function (err, videos) {
-    if (err) throw err
-
-    each(videos, function (video, callbackEach) {
-      const torrentName = video.filename + '.torrent'
-      const thumbnailName = video.thumbnail
-      const thumbnailExtension = path.extname(thumbnailName)
-      const videoName = video.filename
-      const videoExtension = path.extname(videoName)
-
-      const newTorrentName = video._id + '.torrent'
-      const newThumbnailName = video._id + thumbnailExtension
-      const newVideoName = video._id + videoExtension
-
-      const torrentsDir = constants.CONFIG.STORAGE.TORRENTS_DIR
-      const thumbnailsDir = constants.CONFIG.STORAGE.THUMBNAILS_DIR
-      const videosDir = constants.CONFIG.STORAGE.VIDEOS_DIR
-
-      logger.info('Renaming %s to %s.', torrentsDir + torrentName, torrentsDir + newTorrentName)
-      fs.renameSync(torrentsDir + torrentName, torrentsDir + newTorrentName)
-
-      logger.info('Renaming %s to %s.', thumbnailsDir + thumbnailName, thumbnailsDir + newThumbnailName)
-      fs.renameSync(thumbnailsDir + thumbnailName, thumbnailsDir + newThumbnailName)
-
-      logger.info('Renaming %s to %s.', videosDir + videoName, videosDir + newVideoName)
-      fs.renameSync(videosDir + videoName, videosDir + newVideoName)
-
-      Video.load(video._id, function (err, videoObj) {
-        if (err) return callbackEach(err)
-
-        videoObj.extname = videoExtension
-        videoObj.remoteId = null
-        videoObj.save(callbackEach)
-      })
-    }, callback)
-  })
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0030-video-magnet.js b/server/initializers/migrations/0030-video-magnet.js
deleted file mode 100644
index b9119d61c..000000000
--- a/server/initializers/migrations/0030-video-magnet.js
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-  Change video magnet structures
-*/
-
-const each = require('async/each')
-const magnet = require('magnet-uri')
-const mongoose = require('mongoose')
-
-const Video = mongoose.model('Video')
-
-exports.up = function (callback) {
-  // Use of lean because the new Video scheme does not have magnetUri field
-  Video.find({ }).lean().exec(function (err, videos) {
-    if (err) throw err
-
-    each(videos, function (video, callbackEach) {
-      const parsed = magnet.decode(video.magnetUri)
-      const infoHash = parsed.infoHash
-
-      Video.load(video._id, function (err, videoObj) {
-        if (err) return callbackEach(err)
-
-        videoObj.magnet.infoHash = infoHash
-        videoObj.save(callbackEach)
-      })
-    }, callback)
-  })
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0035-url-to-host.js b/server/initializers/migrations/0035-url-to-host.js
deleted file mode 100644
index 6243304d5..000000000
--- a/server/initializers/migrations/0035-url-to-host.js
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-  Change video magnet structures
-*/
-
-const each = require('async/each')
-const mongoose = require('mongoose')
-
-const Video = mongoose.model('Video')
-
-exports.up = function (callback) {
-  // Use of lean because the new Video scheme does not have podUrl field
-  Video.find({ }).lean().exec(function (err, videos) {
-    if (err) throw err
-
-    each(videos, function (video, callbackEach) {
-      Video.load(video._id, function (err, videoObj) {
-        if (err) return callbackEach(err)
-
-        const host = video.podUrl.split('://')[1]
-
-        videoObj.podHost = host
-        videoObj.save(callbackEach)
-      })
-    }, callback)
-  })
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
diff --git a/server/initializers/migrations/0040-video-remote-id.js b/server/initializers/migrations/0040-video-remote-id.js
deleted file mode 100644
index 46a14a689..000000000
--- a/server/initializers/migrations/0040-video-remote-id.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-  Use remote id as identifier
-*/
-
-const map = require('lodash/map')
-const mongoose = require('mongoose')
-const readline = require('readline')
-
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-})
-
-const logger = require('../../helpers/logger')
-const friends = require('../../lib/friends')
-
-const Pod = mongoose.model('Pod')
-const Video = mongoose.model('Video')
-
-exports.up = function (callback) {
-  Pod.find({}).lean().exec(function (err, pods) {
-    if (err) return callback(err)
-
-    // We need to quit friends first
-    if (pods.length === 0) {
-      return setVideosRemoteId(callback)
-    }
-
-    const timeout = setTimeout(function () {
-      throw new Error('You need to enter a value!')
-    }, 10000)
-
-    rl.question('I am sorry but I need to quit friends for upgrading. Do you want to continue? (yes/*)', function (answer) {
-      if (answer !== 'yes') throw new Error('I cannot continue.')
-
-      clearTimeout(timeout)
-      rl.close()
-
-      const urls = map(pods, 'url')
-      logger.info('Saying goodbye to: ' + urls.join(', '))
-
-      setVideosRemoteId(function () {
-        friends.quitFriends(callback)
-      })
-    })
-  })
-}
-
-exports.down = function (callback) {
-  throw new Error('Not implemented.')
-}
-
-function setVideosRemoteId (callback) {
-  Video.update({ filename: { $ne: null } }, { remoteId: null }, function (err) {
-    if (err) throw err
-
-    Video.update({ filename: null }, { remoteId: mongoose.Types.ObjectId() }, callback)
-  })
-}
diff --git a/server/initializers/migrator.js b/server/initializers/migrator.js
index 6b31d994f..e5288b615 100644
--- a/server/initializers/migrator.js
+++ b/server/initializers/migrator.js
@@ -1,48 +1,36 @@
 'use strict'
 
 const eachSeries = require('async/eachSeries')
-const mongoose = require('mongoose')
+const fs = require('fs')
 const path = require('path')
 
 const constants = require('./constants')
+const db = require('./database')
 const logger = require('../helpers/logger')
 
-const Application = mongoose.model('Application')
-
 const migrator = {
   migrate: migrate
 }
 
 function migrate (callback) {
-  Application.loadMongoSchemaVersion(function (err, actualVersion) {
+  db.Application.loadMigrationVersion(function (err, actualVersion) {
     if (err) return callback(err)
 
-    // If there are a new mongo schemas
-    if (!actualVersion || actualVersion < constants.LAST_MONGO_SCHEMA_VERSION) {
+    // If there are a new migration scripts
+    if (actualVersion < constants.LAST_MIGRATION_VERSION) {
       logger.info('Begin migrations.')
 
-      eachSeries(constants.MONGO_MIGRATION_SCRIPTS, function (entity, callbackEach) {
-        const versionScript = entity.version
-
-        // Do not execute old migration scripts
-        if (versionScript <= actualVersion) return callbackEach(null)
-
-        // Load the migration module and run it
-        const migrationScriptName = entity.script
-        logger.info('Executing %s migration script.', migrationScriptName)
+      getMigrationScripts(function (err, migrationScripts) {
+        if (err) return callback(err)
 
-        const migrationScript = require(path.join(__dirname, 'migrations', migrationScriptName))
-        migrationScript.up(function (err) {
-          if (err) return callbackEach(err)
+        eachSeries(migrationScripts, function (entity, callbackEach) {
+          executeMigration(actualVersion, entity, callbackEach)
+        }, function (err) {
+          if (err) return callback(err)
 
-          // Update the new mongo version schema
-          Application.updateMongoSchemaVersion(versionScript, callbackEach)
+          logger.info('Migrations finished. New migration version schema: %s', constants.LAST_MIGRATION_VERSION)
+          return callback(null)
         })
-      }, function (err) {
-        if (err) return callback(err)
-
-        logger.info('Migrations finished. New mongo version schema: %s', constants.LAST_MONGO_SCHEMA_VERSION)
-        return callback(null)
       })
     } else {
       return callback(null)
@@ -54,3 +42,57 @@ function migrate (callback) {
 
 module.exports = migrator
 
+// ---------------------------------------------------------------------------
+
+function getMigrationScripts (callback) {
+  fs.readdir(path.join(__dirname, 'migrations'), function (err, files) {
+    if (err) return callback(err)
+
+    const filesToMigrate = []
+
+    files.forEach(function (file) {
+      // Filename is something like 'version-blabla.js'
+      const version = file.split('-')[0]
+      filesToMigrate.push({
+        version,
+        script: file
+      })
+    })
+
+    return callback(err, filesToMigrate)
+  })
+}
+
+function executeMigration (actualVersion, entity, callback) {
+  const versionScript = entity.version
+
+  // Do not execute old migration scripts
+  if (versionScript <= actualVersion) return callback(null)
+
+  // Load the migration module and run it
+  const migrationScriptName = entity.script
+  logger.info('Executing %s migration script.', migrationScriptName)
+
+  const migrationScript = require(path.join(__dirname, 'migrations', migrationScriptName))
+
+  db.sequelize.transaction().asCallback(function (err, t) {
+    if (err) return callback(err)
+
+    migrationScript.up({ transaction: t }, 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)
+      })
+    })
+  })
+}