14 files changed, 339 insertions, 282 deletions

diff --git a/server/lib/friends.js b/server/lib/friends.ts
index 6dd32406c..b32783019 100644
--- a/server/lib/friends.js
+++ b/server/lib/friends.ts
@@ -1,48 +1,35 @@
-'use strict'
+import { each, eachLimit, eachSeries, series, waterfall } from 'async'
+import request = require('request')
 
-const each = require('async/each')
-const eachLimit = require('async/eachLimit')
-const eachSeries = require('async/eachSeries')
-const series = require('async/series')
-const request = require('request')
-const waterfall = require('async/waterfall')
-
-const constants = require('../initializers/constants')
 const db = require('../initializers/database')
-const logger = require('../helpers/logger')
-const peertubeCrypto = require('../helpers/peertube-crypto')
-const requests = require('../helpers/requests')
-const utils = require('../helpers/utils')
-const RequestScheduler = require('./request/request-scheduler')
-const RequestVideoQaduScheduler = require('./request/request-video-qadu-scheduler')
-const RequestVideoEventScheduler = require('./request/request-video-event-scheduler')
-
-const ENDPOINT_ACTIONS = constants.REQUEST_ENDPOINT_ACTIONS[constants.REQUEST_ENDPOINTS.VIDEOS]
+import {
+  API_VERSION,
+  CONFIG,
+  REQUESTS_IN_PARALLEL,
+  REQUEST_ENDPOINTS,
+  REQUEST_ENDPOINT_ACTIONS,
+  REMOTE_SCHEME
+} from '../initializers'
+import {
+  logger,
+  getMyPublicCert,
+  makeSecureRequest,
+  makeRetryRequest,
+  createEmptyCallback
+} from '../helpers'
+import {
+  RequestScheduler,
+  RequestVideoQaduScheduler,
+  RequestVideoEventScheduler
+} from './request'
+
+const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
 
 const requestScheduler = new RequestScheduler()
 const requestVideoQaduScheduler = new RequestVideoQaduScheduler()
 const requestVideoEventScheduler = new RequestVideoEventScheduler()
 
-const friends = {
-  activate,
-  addVideoToFriends,
-  updateVideoToFriends,
-  reportAbuseVideoToFriend,
-  quickAndDirtyUpdateVideoToFriends,
-  quickAndDirtyUpdatesVideoToFriends,
-  addEventToRemoteVideo,
-  addEventsToRemoteVideo,
-  hasFriends,
-  makeFriends,
-  quitFriends,
-  removeVideoToFriends,
-  sendOwnedVideosToPod,
-  getRequestScheduler,
-  getRequestVideoQaduScheduler,
-  getRequestVideoEventScheduler
-}
-
-function activate () {
+function activateSchedulers () {
   requestScheduler.activate()
   requestVideoQaduScheduler.activate()
   requestVideoEventScheduler.activate()
@@ -51,7 +38,7 @@ function activate () {
 function addVideoToFriends (videoData, transaction, callback) {
   const options = {
     type: ENDPOINT_ACTIONS.ADD,
-    endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
+    endpoint: REQUEST_ENDPOINTS.VIDEOS,
     data: videoData,
     transaction
   }
@@ -61,7 +48,7 @@ function addVideoToFriends (videoData, transaction, callback) {
 function updateVideoToFriends (videoData, transaction, callback) {
   const options = {
     type: ENDPOINT_ACTIONS.UPDATE,
-    endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
+    endpoint: REQUEST_ENDPOINTS.VIDEOS,
     data: videoData,
     transaction
   }
@@ -71,7 +58,7 @@ function updateVideoToFriends (videoData, transaction, callback) {
 function removeVideoToFriends (videoParams) {
   const options = {
     type: ENDPOINT_ACTIONS.REMOVE,
-    endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
+    endpoint: REQUEST_ENDPOINTS.VIDEOS,
     data: videoParams
   }
   createRequest(options)
@@ -80,14 +67,14 @@ function removeVideoToFriends (videoParams) {
 function reportAbuseVideoToFriend (reportData, video) {
   const options = {
     type: ENDPOINT_ACTIONS.REPORT_ABUSE,
-    endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
+    endpoint: REQUEST_ENDPOINTS.VIDEOS,
     data: reportData,
     toIds: [ video.Author.podId ]
   }
   createRequest(options)
 }
 
-function quickAndDirtyUpdateVideoToFriends (qaduParams, transaction, callback) {
+function quickAndDirtyUpdateVideoToFriends (qaduParams, transaction?, callback?) {
   const options = {
     videoId: qaduParams.videoId,
     type: qaduParams.type,
@@ -110,7 +97,7 @@ function quickAndDirtyUpdatesVideoToFriends (qadusParams, transaction, finalCall
   series(tasks, finalCallback)
 }
 
-function addEventToRemoteVideo (eventParams, transaction, callback) {
+function addEventToRemoteVideo (eventParams, transaction?, callback?) {
   const options = {
     videoId: eventParams.videoId,
     type: eventParams.type,
@@ -146,7 +133,7 @@ function makeFriends (hosts, callback) {
   const podsScore = {}
 
   logger.info('Make friends!')
-  peertubeCrypto.getMyPublicCert(function (err, cert) {
+  getMyPublicCert(function (err, cert) {
     if (err) {
       logger.error('Cannot read public cert.')
       return callback(err)
@@ -186,16 +173,17 @@ function quitFriends (callback) {
     function announceIQuitMyFriends (pods, callbackAsync) {
       const requestParams = {
         method: 'POST',
-        path: '/api/' + constants.API_VERSION + '/remote/pods/remove',
-        sign: true
+        path: '/api/' + API_VERSION + '/remote/pods/remove',
+        sign: true,
+        toPod: null
       }
 
       // Announce we quit them
       // We don't care if the request fails
       // The other pod will exclude us automatically after a while
-      eachLimit(pods, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
+      eachLimit(pods, REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
         requestParams.toPod = pod
-        requests.makeSecureRequest(requestParams, callbackEach)
+        makeSecureRequest(requestParams, callbackEach)
       }, function (err) {
         if (err) {
           logger.error('Some errors while quitting friends.', { err: err })
@@ -207,7 +195,7 @@ function quitFriends (callback) {
     },
 
     function removePodsFromDB (pods, callbackAsync) {
-      each(pods, function (pod, callbackEach) {
+      each(pods, function (pod: any, callbackEach) {
         pod.destroy().asCallback(callbackEach)
       }, callbackAsync)
     }
@@ -239,7 +227,7 @@ function sendOwnedVideosToPod (podId) {
 
         const options = {
           type: 'add',
-          endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
+          endpoint: REQUEST_ENDPOINTS.VIDEOS,
           data: remoteVideo,
           toIds: [ podId ]
         }
@@ -263,7 +251,24 @@ function getRequestVideoEventScheduler () {
 
 // ---------------------------------------------------------------------------
 
-module.exports = friends
+export {
+  activateSchedulers,
+  addVideoToFriends,
+  updateVideoToFriends,
+  reportAbuseVideoToFriend,
+  quickAndDirtyUpdateVideoToFriends,
+  quickAndDirtyUpdatesVideoToFriends,
+  addEventToRemoteVideo,
+  addEventsToRemoteVideo,
+  hasFriends,
+  makeFriends,
+  quitFriends,
+  removeVideoToFriends,
+  sendOwnedVideosToPod,
+  getRequestScheduler,
+  getRequestVideoQaduScheduler,
+  getRequestVideoEventScheduler
+}
 
 // ---------------------------------------------------------------------------
 
@@ -304,9 +309,9 @@ function computeWinningPods (hosts, podsScore) {
 }
 
 function getForeignPodsList (host, callback) {
-  const path = '/api/' + constants.API_VERSION + '/pods'
+  const path = '/api/' + API_VERSION + '/pods'
 
-  request.get(constants.REMOTE_SCHEME.HTTP + '://' + host + path, function (err, response, body) {
+  request.get(REMOTE_SCHEME.HTTP + '://' + host + path, function (err, response, body) {
     if (err) return callback(err)
 
     try {
@@ -324,18 +329,18 @@ function makeRequestsToWinningPods (cert, podsList, callback) {
   // Flush pool requests
   requestScheduler.forceSend()
 
-  eachLimit(podsList, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
+  eachLimit(podsList, REQUESTS_IN_PARALLEL, function (pod: any, callbackEach) {
     const params = {
-      url: constants.REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + constants.API_VERSION + '/pods/',
+      url: REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + API_VERSION + '/pods/',
       method: 'POST',
       json: {
-        host: constants.CONFIG.WEBSERVER.HOST,
-        email: constants.CONFIG.ADMIN.EMAIL,
+        host: CONFIG.WEBSERVER.HOST,
+        email: CONFIG.ADMIN.EMAIL,
         publicKey: cert
       }
     }
 
-    requests.makeRetryRequest(params, function (err, res, body) {
+    makeRetryRequest(params, function (err, res, body) {
       if (err) {
         logger.error('Error with adding %s pod.', pod.host, { error: err })
         // Don't break the process
@@ -372,8 +377,8 @@ function makeRequestsToWinningPods (cert, podsList, callback) {
 
 // Wrapper that populate "toIds" argument with all our friends if it is not specified
 // { type, endpoint, data, toIds, transaction }
-function createRequest (options, callback) {
-  if (!callback) callback = function () {}
+function createRequest (options, callback?) {
+  if (!callback) callback = function () { /* empty */ }
   if (options.toIds) return requestScheduler.createRequest(options, callback)
 
   // If the "toIds" pods is not specified, we send the request to all our friends
@@ -389,17 +394,17 @@ function createRequest (options, callback) {
 }
 
 function createVideoQaduRequest (options, callback) {
-  if (!callback) callback = utils.createEmptyCallback()
+  if (!callback) callback = createEmptyCallback()
 
   requestVideoQaduScheduler.createRequest(options, callback)
 }
 
 function createVideoEventRequest (options, callback) {
-  if (!callback) callback = utils.createEmptyCallback()
+  if (!callback) callback = createEmptyCallback()
 
   requestVideoEventScheduler.createRequest(options, callback)
 }
 
 function isMe (host) {
-  return host === constants.CONFIG.WEBSERVER.HOST
+  return host === CONFIG.WEBSERVER.HOST
 }
diff --git a/server/lib/index.ts b/server/lib/index.ts
new file mode 100644
index 000000000..b8697fb96
--- /dev/null
+++ b/server/lib/index.ts
@@ -0,0 +1,4 @@
+export * from './jobs'
+export * from './request'
+export * from './friends'
+export * from './oauth-model'
diff --git a/server/lib/jobs/handlers/index.js b/server/lib/jobs/handlers/index.js
deleted file mode 100644
index 59c1ccce5..000000000
--- a/server/lib/jobs/handlers/index.js
+++ /dev/null
@@ -1,7 +0,0 @@
-'use strict'
-
-const videoTranscoder = require('./video-transcoder')
-
-module.exports = {
-  videoTranscoder
-}
diff --git a/server/lib/jobs/handlers/index.ts b/server/lib/jobs/handlers/index.ts
new file mode 100644
index 000000000..ae5440031
--- /dev/null
+++ b/server/lib/jobs/handlers/index.ts
@@ -0,0 +1,9 @@
+import * as videoTranscoder from './video-transcoder'
+
+const jobHandlers = {
+  videoTranscoder
+}
+
+export {
+  jobHandlers
+}
diff --git a/server/lib/jobs/handlers/video-transcoder.js b/server/lib/jobs/handlers/video-transcoder.ts
index d2ad4f9c7..35db5fb96 100644
--- a/server/lib/jobs/handlers/video-transcoder.js
+++ b/server/lib/jobs/handlers/video-transcoder.ts
@@ -1,16 +1,6 @@
-'use strict'
-
 const db = require('../../../initializers/database')
-const logger = require('../../../helpers/logger')
-const friends = require('../../../lib/friends')
-
-const VideoTranscoderHandler = {
-  process,
-  onError,
-  onSuccess
-}
-
-// ---------------------------------------------------------------------------
+import { logger } from '../../../helpers'
+import { addVideoToFriends } from '../../../lib'
 
 function process (data, callback) {
   db.Video.loadAndPopulateAuthorAndPodAndTags(data.id, function (err, video) {
@@ -34,10 +24,14 @@ function onSuccess (data, jobId, video, callback) {
     if (err) return callback(err)
 
     // Now we'll add the video's meta data to our friends
-    friends.addVideoToFriends(remoteVideo, null, callback)
+    addVideoToFriends(remoteVideo, null, callback)
   })
 }
 
 // ---------------------------------------------------------------------------
 
-module.exports = VideoTranscoderHandler
+export {
+  process,
+  onError,
+  onSuccess
+}
diff --git a/server/lib/jobs/index.ts b/server/lib/jobs/index.ts
new file mode 100644
index 000000000..b18a3d845
--- /dev/null
+++ b/server/lib/jobs/index.ts
@@ -0,0 +1 @@
+export * from './job-scheduler'
diff --git a/server/lib/jobs/job-scheduler.js b/server/lib/jobs/job-scheduler.js
deleted file mode 100644
index 7b239577f..000000000
--- a/server/lib/jobs/job-scheduler.js
+++ /dev/null
@@ -1,129 +0,0 @@
-'use strict'
-
-const forever = require('async/forever')
-const queue = require('async/queue')
-
-const constants = require('../../initializers/constants')
-const db = require('../../initializers/database')
-const logger = require('../../helpers/logger')
-
-const jobHandlers = require('./handlers')
-
-const jobScheduler = {
-  activate,
-  createJob
-}
-
-function activate () {
-  const limit = constants.JOBS_FETCH_LIMIT_PER_CYCLE
-
-  logger.info('Jobs scheduler activated.')
-
-  const jobsQueue = queue(processJob)
-
-  // Finish processing jobs from a previous start
-  const state = constants.JOB_STATES.PROCESSING
-  db.Job.listWithLimit(limit, state, function (err, jobs) {
-    enqueueJobs(err, jobsQueue, jobs)
-
-    forever(
-      function (next) {
-        if (jobsQueue.length() !== 0) {
-          // Finish processing the queue first
-          return setTimeout(next, constants.JOBS_FETCHING_INTERVAL)
-        }
-
-        const state = constants.JOB_STATES.PENDING
-        db.Job.listWithLimit(limit, state, function (err, jobs) {
-          if (err) {
-            logger.error('Cannot list pending jobs.', { error: err })
-          } else {
-            jobs.forEach(function (job) {
-              jobsQueue.push(job)
-            })
-          }
-
-          // Optimization: we could use "drain" from queue object
-          return setTimeout(next, constants.JOBS_FETCHING_INTERVAL)
-        })
-      }
-    )
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-module.exports = jobScheduler
-
-// ---------------------------------------------------------------------------
-
-function enqueueJobs (err, jobsQueue, jobs) {
-  if (err) {
-    logger.error('Cannot list pending jobs.', { error: err })
-  } else {
-    jobs.forEach(function (job) {
-      jobsQueue.push(job)
-    })
-  }
-}
-
-function createJob (transaction, handlerName, handlerInputData, callback) {
-  const createQuery = {
-    state: constants.JOB_STATES.PENDING,
-    handlerName,
-    handlerInputData
-  }
-  const options = { transaction }
-
-  db.Job.create(createQuery, options).asCallback(callback)
-}
-
-function processJob (job, callback) {
-  const jobHandler = jobHandlers[job.handlerName]
-
-  logger.info('Processing job %d with handler %s.', job.id, job.handlerName)
-
-  job.state = constants.JOB_STATES.PROCESSING
-  job.save().asCallback(function (err) {
-    if (err) return cannotSaveJobError(err, callback)
-
-    if (jobHandler === undefined) {
-      logger.error('Unknown job handler for job %s.', jobHandler.handlerName)
-      return callback()
-    }
-
-    return jobHandler.process(job.handlerInputData, function (err, result) {
-      if (err) {
-        logger.error('Error in job handler %s.', job.handlerName, { error: err })
-        return onJobError(jobHandler, job, result, callback)
-      }
-
-      return onJobSuccess(jobHandler, job, result, callback)
-    })
-  })
-}
-
-function onJobError (jobHandler, job, jobResult, callback) {
-  job.state = constants.JOB_STATES.ERROR
-
-  job.save().asCallback(function (err) {
-    if (err) return cannotSaveJobError(err, callback)
-
-    return jobHandler.onError(err, job.id, jobResult, callback)
-  })
-}
-
-function onJobSuccess (jobHandler, job, jobResult, callback) {
-  job.state = constants.JOB_STATES.SUCCESS
-
-  job.save().asCallback(function (err) {
-    if (err) return cannotSaveJobError(err, callback)
-
-    return jobHandler.onSuccess(err, job.id, jobResult, callback)
-  })
-}
-
-function cannotSaveJobError (err, callback) {
-  logger.error('Cannot save new job state.', { error: err })
-  return callback(err)
-}
diff --git a/server/lib/jobs/job-scheduler.ts b/server/lib/jobs/job-scheduler.ts
new file mode 100644
index 000000000..7b8c6faf9
--- /dev/null
+++ b/server/lib/jobs/job-scheduler.ts
@@ -0,0 +1,137 @@
+import { forever, queue } from 'async'
+
+const db = require('../../initializers/database')
+import {
+  JOBS_FETCHING_INTERVAL,
+  JOBS_FETCH_LIMIT_PER_CYCLE,
+  JOB_STATES
+} from '../../initializers'
+import { logger } from '../../helpers'
+import { jobHandlers } from './handlers'
+
+class JobScheduler {
+
+  private static instance: JobScheduler
+
+  private constructor () { }
+
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+
+  activate () {
+    const limit = JOBS_FETCH_LIMIT_PER_CYCLE
+
+    logger.info('Jobs scheduler activated.')
+
+    const jobsQueue = queue(this.processJob)
+
+    // Finish processing jobs from a previous start
+    const state = JOB_STATES.PROCESSING
+    db.Job.listWithLimit(limit, state, (err, jobs) => {
+      this.enqueueJobs(err, jobsQueue, jobs)
+
+      forever(
+        next => {
+          if (jobsQueue.length() !== 0) {
+            // Finish processing the queue first
+            return setTimeout(next, JOBS_FETCHING_INTERVAL)
+          }
+
+          const state = JOB_STATES.PENDING
+          db.Job.listWithLimit(limit, state, (err, jobs) => {
+            if (err) {
+              logger.error('Cannot list pending jobs.', { error: err })
+            } else {
+              jobs.forEach(job => {
+                jobsQueue.push(job)
+              })
+            }
+
+            // Optimization: we could use "drain" from queue object
+            return setTimeout(next, JOBS_FETCHING_INTERVAL)
+          })
+        },
+
+        err => { logger.error('Error in job scheduler queue.', { error: err }) }
+      )
+    })
+  }
+
+  createJob (transaction, handlerName, handlerInputData, callback) {
+    const createQuery = {
+      state: JOB_STATES.PENDING,
+      handlerName,
+      handlerInputData
+    }
+    const options = { transaction }
+
+    db.Job.create(createQuery, options).asCallback(callback)
+  }
+
+  private enqueueJobs (err, jobsQueue, jobs) {
+    if (err) {
+      logger.error('Cannot list pending jobs.', { error: err })
+    } else {
+      jobs.forEach(job => {
+        jobsQueue.push(job)
+      })
+    }
+  }
+
+  private processJob (job, callback) {
+    const jobHandler = jobHandlers[job.handlerName]
+
+    logger.info('Processing job %d with handler %s.', job.id, job.handlerName)
+
+    job.state = JOB_STATES.PROCESSING
+    job.save().asCallback(err => {
+      if (err) return this.cannotSaveJobError(err, callback)
+
+      if (jobHandler === undefined) {
+        logger.error('Unknown job handler for job %s.', jobHandler.handlerName)
+        return callback()
+      }
+
+      return jobHandler.process(job.handlerInputData, (err, result) => {
+        if (err) {
+          logger.error('Error in job handler %s.', job.handlerName, { error: err })
+          return this.onJobError(jobHandler, job, result, callback)
+        }
+
+        return this.onJobSuccess(jobHandler, job, result, callback)
+      })
+    })
+  }
+
+  private onJobError (jobHandler, job, jobResult, callback) {
+    job.state = JOB_STATES.ERROR
+
+    job.save().asCallback(err => {
+      if (err) return this.cannotSaveJobError(err, callback)
+
+      return jobHandler.onError(err, job.id, jobResult, callback)
+    })
+  }
+
+  private onJobSuccess (jobHandler, job, jobResult, callback) {
+    job.state = JOB_STATES.SUCCESS
+
+    job.save().asCallback(err => {
+      if (err) return this.cannotSaveJobError(err, callback)
+
+      return jobHandler.onSuccess(err, job.id, jobResult, callback)
+    })
+  }
+
+  private cannotSaveJobError (err, callback) {
+    logger.error('Cannot save new job state.', { error: err })
+    return callback(err)
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  JobScheduler
+}
diff --git a/server/lib/oauth-model.js b/server/lib/oauth-model.ts
index 1c12f1b14..00b1afcf5 100644
--- a/server/lib/oauth-model.js
+++ b/server/lib/oauth-model.ts
@@ -1,15 +1,5 @@
 const db = require('../initializers/database')
-const logger = require('../helpers/logger')
-
-// See https://github.com/oauthjs/node-oauth2-server/wiki/Model-specification for the model specifications
-const OAuthModel = {
-  getAccessToken,
-  getClient,
-  getRefreshToken,
-  getUser,
-  revokeToken,
-  saveToken
-}
+import { logger } from '../helpers'
 
 // ---------------------------------------------------------------------------
 
@@ -94,4 +84,12 @@ function saveToken (token, client, user) {
 
 // ---------------------------------------------------------------------------
 
-module.exports = OAuthModel
+// See https://github.com/oauthjs/node-oauth2-server/wiki/Model-specification for the model specifications
+export {
+  getAccessToken,
+  getClient,
+  getRefreshToken,
+  getUser,
+  revokeToken,
+  saveToken
+}
diff --git a/server/lib/request/base-request-scheduler.js b/server/lib/request/base-request-scheduler.ts
index 782448340..7fc88b5f1 100644
--- a/server/lib/request/base-request-scheduler.js
+++ b/server/lib/request/base-request-scheduler.ts
@@ -1,19 +1,31 @@
-'use strict'
+import { eachLimit } from 'async/eachLimit'
 
-const eachLimit = require('async/eachLimit')
-
-const constants = require('../../initializers/constants')
 const db = require('../../initializers/database')
-const logger = require('../../helpers/logger')
-const requests = require('../../helpers/requests')
-
-module.exports = class BaseRequestScheduler {
-  constructor (options) {
+import { logger, makeSecureRequest } from '../../helpers'
+import {
+  API_VERSION,
+  REQUESTS_IN_PARALLEL,
+  REQUESTS_INTERVAL
+} from '../../initializers'
+
+abstract class BaseRequestScheduler {
+  protected lastRequestTimestamp: number
+  protected timer: NodeJS.Timer
+  protected requestInterval: number
+  protected limitPods: number
+  protected limitPerPod: number
+  protected description: string
+
+  constructor () {
     this.lastRequestTimestamp = 0
     this.timer = null
-    this.requestInterval = constants.REQUESTS_INTERVAL
+    this.requestInterval = REQUESTS_INTERVAL
   }
 
+  abstract getRequestModel ()
+  abstract getRequestToPodModel ()
+  abstract buildRequestObjects (requests: any)
+
   activate () {
     logger.info('Requests scheduler activated.')
     this.lastRequestTimestamp = Date.now()
@@ -38,30 +50,34 @@ module.exports = class BaseRequestScheduler {
   remainingMilliSeconds () {
     if (this.timer === null) return -1
 
-    return constants.REQUESTS_INTERVAL - (Date.now() - this.lastRequestTimestamp)
+    return REQUESTS_INTERVAL - (Date.now() - this.lastRequestTimestamp)
   }
 
   remainingRequestsCount (callback) {
     return this.getRequestModel().countTotalRequests(callback)
   }
 
+  flush (callback) {
+    this.getRequestModel().removeAll(callback)
+  }
+
   // ---------------------------------------------------------------------------
 
   // Make a requests to friends of a certain type
-  makeRequest (toPod, requestEndpoint, requestsToMake, callback) {
-    if (!callback) callback = function () {}
+  protected makeRequest (toPod, requestEndpoint, requestsToMake, callback) {
+    if (!callback) callback = function () { /* empty */ }
 
     const params = {
       toPod: toPod,
       sign: true, // Prove our identity
       method: 'POST',
-      path: '/api/' + constants.API_VERSION + '/remote/' + requestEndpoint,
+      path: '/api/' + API_VERSION + '/remote/' + requestEndpoint,
       data: requestsToMake // Requests we need to make
     }
 
     // Make multiple retry requests to all of pods
     // The function fire some useful callbacks
-    requests.makeSecureRequest(params, (err, res) => {
+    makeSecureRequest(params, (err, res) => {
       if (err || (res.statusCode !== 200 && res.statusCode !== 201 && res.statusCode !== 204)) {
         err = err ? err.message : 'Status code not 20x : ' + res.statusCode
         logger.error('Error sending secure request to %s pod.', toPod.host, { error: err })
@@ -74,7 +90,7 @@ module.exports = class BaseRequestScheduler {
   }
 
     // Make all the requests of the scheduler
-  makeRequests () {
+  protected makeRequests () {
     this.getRequestModel().listWithLimitAndRandom(this.limitPods, this.limitPerPod, (err, requests) => {
       if (err) {
         logger.error('Cannot get the list of "%s".', this.description, { err: err })
@@ -95,7 +111,7 @@ module.exports = class BaseRequestScheduler {
       const goodPods = []
       const badPods = []
 
-      eachLimit(Object.keys(requestsToMakeGrouped), constants.REQUESTS_IN_PARALLEL, (hashKey, callbackEach) => {
+      eachLimit(Object.keys(requestsToMakeGrouped), REQUESTS_IN_PARALLEL, (hashKey, callbackEach) => {
         const requestToMake = requestsToMakeGrouped[hashKey]
         const toPod = requestToMake.toPod
 
@@ -122,15 +138,17 @@ module.exports = class BaseRequestScheduler {
     })
   }
 
-  flush (callback) {
-    this.getRequestModel().removeAll(callback)
-  }
-
-  afterRequestHook () {
+  protected afterRequestHook () {
    // Nothing to do, let children reimplement it
   }
 
-  afterRequestsHook () {
+  protected afterRequestsHook () {
    // Nothing to do, let children reimplement it
   }
 }
+
+// ---------------------------------------------------------------------------
+
+export {
+  BaseRequestScheduler
+}
diff --git a/server/lib/request/index.ts b/server/lib/request/index.ts
new file mode 100644
index 000000000..c98f956db
--- /dev/null
+++ b/server/lib/request/index.ts
@@ -0,0 +1,3 @@
+export * from './request-scheduler'
+export * from './request-video-event-scheduler'
+export * from './request-video-qadu-scheduler'
diff --git a/server/lib/request/request-scheduler.js b/server/lib/request/request-scheduler.ts
index 555ec3e54..2006a6f03 100644
--- a/server/lib/request/request-scheduler.js
+++ b/server/lib/request/request-scheduler.ts
@@ -1,17 +1,18 @@
-'use strict'
-
-const constants = require('../../initializers/constants')
-const BaseRequestScheduler = require('./base-request-scheduler')
 const db = require('../../initializers/database')
-const logger = require('../../helpers/logger')
-
-module.exports = class RequestScheduler extends BaseRequestScheduler {
+import { BaseRequestScheduler } from './base-request-scheduler'
+import { logger } from '../../helpers'
+import {
+  REQUESTS_LIMIT_PODS,
+  REQUESTS_LIMIT_PER_POD
+} from '../../initializers'
+
+class RequestScheduler extends BaseRequestScheduler {
   constructor () {
     super()
 
     // We limit the size of the requests
-    this.limitPods = constants.REQUESTS_LIMIT_PODS
-    this.limitPerPod = constants.REQUESTS_LIMIT_PER_POD
+    this.limitPods = REQUESTS_LIMIT_PODS
+    this.limitPerPod = REQUESTS_LIMIT_PER_POD
 
     this.description = 'requests'
   }
@@ -95,3 +96,9 @@ module.exports = class RequestScheduler extends BaseRequestScheduler {
     })
   }
 }
+
+// ---------------------------------------------------------------------------
+
+export {
+  RequestScheduler
+}
diff --git a/server/lib/request/request-video-event-scheduler.js b/server/lib/request/request-video-event-scheduler.ts
index e54d34f4a..6e5306c7d 100644
--- a/server/lib/request/request-video-event-scheduler.js
+++ b/server/lib/request/request-video-event-scheduler.ts
@@ -1,16 +1,18 @@
-'use strict'
-
-const BaseRequestScheduler = require('./base-request-scheduler')
-const constants = require('../../initializers/constants')
 const db = require('../../initializers/database')
-
-module.exports = class RequestVideoEventScheduler extends BaseRequestScheduler {
+import { BaseRequestScheduler } from './base-request-scheduler'
+import {
+  REQUESTS_VIDEO_EVENT_LIMIT_PODS,
+  REQUESTS_VIDEO_EVENT_LIMIT_PER_POD,
+  REQUEST_VIDEO_EVENT_ENDPOINT
+} from '../../initializers'
+
+class RequestVideoEventScheduler extends BaseRequestScheduler {
   constructor () {
     super()
 
     // We limit the size of the requests
-    this.limitPods = constants.REQUESTS_VIDEO_EVENT_LIMIT_PODS
-    this.limitPerPod = constants.REQUESTS_VIDEO_EVENT_LIMIT_PER_POD
+    this.limitPods = REQUESTS_VIDEO_EVENT_LIMIT_PODS
+    this.limitPerPod = REQUESTS_VIDEO_EVENT_LIMIT_PER_POD
 
     this.description = 'video event requests'
   }
@@ -45,7 +47,7 @@ module.exports = class RequestVideoEventScheduler extends BaseRequestScheduler {
         if (!requestsToMakeGrouped[toPodId]) {
           requestsToMakeGrouped[toPodId] = {
             toPod: eventToProcess.pod,
-            endpoint: constants.REQUEST_VIDEO_EVENT_ENDPOINT,
+            endpoint: REQUEST_VIDEO_EVENT_ENDPOINT,
             ids: [], // request ids, to delete them from the DB in the future
             datas: [] // requests data
           }
@@ -94,7 +96,7 @@ module.exports = class RequestVideoEventScheduler extends BaseRequestScheduler {
 
     if (count === undefined) count = 1
 
-    const dbRequestOptions = {}
+    const dbRequestOptions: { transaction?: any } = {}
     if (transaction) dbRequestOptions.transaction = transaction
 
     const createQuery = {
@@ -106,3 +108,9 @@ module.exports = class RequestVideoEventScheduler extends BaseRequestScheduler {
     return db.RequestVideoEvent.create(createQuery, dbRequestOptions).asCallback(callback)
   }
 }
+
+// ---------------------------------------------------------------------------
+
+export {
+  RequestVideoEventScheduler
+}
diff --git a/server/lib/request/request-video-qadu-scheduler.js b/server/lib/request/request-video-qadu-scheduler.ts
index 17402b556..d81822723 100644
--- a/server/lib/request/request-video-qadu-scheduler.js
+++ b/server/lib/request/request-video-qadu-scheduler.ts
@@ -1,17 +1,20 @@
-'use strict'
-
-const BaseRequestScheduler = require('./base-request-scheduler')
-const constants = require('../../initializers/constants')
 const db = require('../../initializers/database')
-const logger = require('../../helpers/logger')
-
-module.exports = class RequestVideoQaduScheduler extends BaseRequestScheduler {
+import { BaseRequestScheduler } from './base-request-scheduler'
+import { logger } from '../../helpers'
+import {
+  REQUESTS_VIDEO_QADU_LIMIT_PODS,
+  REQUESTS_VIDEO_QADU_LIMIT_PER_POD,
+  REQUEST_VIDEO_QADU_ENDPOINT,
+  REQUEST_VIDEO_QADU_TYPES
+} from '../../initializers'
+
+class RequestVideoQaduScheduler extends BaseRequestScheduler {
   constructor () {
     super()
 
     // We limit the size of the requests
-    this.limitPods = constants.REQUESTS_VIDEO_QADU_LIMIT_PODS
-    this.limitPerPod = constants.REQUESTS_VIDEO_QADU_LIMIT_PER_POD
+    this.limitPods = REQUESTS_VIDEO_QADU_LIMIT_PODS
+    this.limitPerPod = REQUESTS_VIDEO_QADU_LIMIT_PER_POD
 
     this.description = 'video QADU requests'
   }
@@ -37,7 +40,7 @@ module.exports = class RequestVideoQaduScheduler extends BaseRequestScheduler {
         if (!requestsToMakeGrouped[hashKey]) {
           requestsToMakeGrouped[hashKey] = {
             toPod: pod,
-            endpoint: constants.REQUEST_VIDEO_QADU_ENDPOINT,
+            endpoint: REQUEST_VIDEO_QADU_ENDPOINT,
             ids: [], // request ids, to delete them from the DB in the future
             datas: [], // requests data
             videos: {}
@@ -49,15 +52,15 @@ module.exports = class RequestVideoQaduScheduler extends BaseRequestScheduler {
         if (!videoData) videoData = {}
 
         switch (request.type) {
-          case constants.REQUEST_VIDEO_QADU_TYPES.LIKES:
+          case REQUEST_VIDEO_QADU_TYPES.LIKES:
             videoData.likes = video.likes
             break
 
-          case constants.REQUEST_VIDEO_QADU_TYPES.DISLIKES:
+          case REQUEST_VIDEO_QADU_TYPES.DISLIKES:
             videoData.dislikes = video.dislikes
             break
 
-          case constants.REQUEST_VIDEO_QADU_TYPES.VIEWS:
+          case REQUEST_VIDEO_QADU_TYPES.VIEWS:
             videoData.views = video.views
             break
 
@@ -99,7 +102,7 @@ module.exports = class RequestVideoQaduScheduler extends BaseRequestScheduler {
     const videoId = options.videoId
     const transaction = options.transaction
 
-    const dbRequestOptions = {}
+    const dbRequestOptions: { transaction?: any } = {}
     if (transaction) dbRequestOptions.transaction = transaction
 
     // Send the update to all our friends
@@ -115,3 +118,9 @@ module.exports = class RequestVideoQaduScheduler extends BaseRequestScheduler {
     })
   }
 }
+
+// ---------------------------------------------------------------------------
+
+export {
+  RequestVideoQaduScheduler
+}