68 files changed, 0 insertions, 5608 deletions

diff --git a/server/initializers/checker-after-init.ts b/server/initializers/checker-after-init.ts
deleted file mode 100644
index 4281e2bb5..000000000
--- a/server/initializers/checker-after-init.ts
+++ /dev/null
@@ -1,325 +0,0 @@
-import config from 'config'
-import { readFileSync, writeFileSync } from 'fs-extra'
-import { URL } from 'url'
-import { uniqify } from '@shared/core-utils'
-import { getFFmpegVersion } from '@shared/ffmpeg'
-import { VideoRedundancyConfigFilter } from '@shared/models/redundancy/video-redundancy-config-filter.type'
-import { RecentlyAddedStrategy } from '../../shared/models/redundancy'
-import { isProdInstance, parseBytes, parseSemVersion } from '../helpers/core-utils'
-import { isArray } from '../helpers/custom-validators/misc'
-import { logger } from '../helpers/logger'
-import { ApplicationModel, getServerActor } from '../models/application/application'
-import { OAuthClientModel } from '../models/oauth/oauth-client'
-import { UserModel } from '../models/user/user'
-import { CONFIG, getLocalConfigFilePath, isEmailEnabled, reloadConfig } from './config'
-import { WEBSERVER } from './constants'
-
-async function checkActivityPubUrls () {
-  const actor = await getServerActor()
-
-  const parsed = new URL(actor.url)
-  if (WEBSERVER.HOST !== parsed.host) {
-    const NODE_ENV = config.util.getEnv('NODE_ENV')
-    const NODE_CONFIG_DIR = config.util.getEnv('NODE_CONFIG_DIR')
-
-    logger.warn(
-      'It seems PeerTube was started (and created some data) with another domain name. ' +
-      'This means you will not be able to federate! ' +
-      'Please use %s %s npm run update-host to fix this.',
-      NODE_CONFIG_DIR ? `NODE_CONFIG_DIR=${NODE_CONFIG_DIR}` : '',
-      NODE_ENV ? `NODE_ENV=${NODE_ENV}` : ''
-    )
-  }
-}
-
-// Some checks on configuration files or throw if there is an error
-function checkConfig () {
-
-  const configFiles = config.util.getConfigSources().map(s => s.name).join(' -> ')
-  logger.info('Using following configuration file hierarchy: %s.', configFiles)
-
-  checkRemovedConfigKeys()
-
-  checkSecretsConfig()
-  checkEmailConfig()
-  checkNSFWPolicyConfig()
-  checkLocalRedundancyConfig()
-  checkRemoteRedundancyConfig()
-  checkStorageConfig()
-  checkTranscodingConfig()
-  checkImportConfig()
-  checkBroadcastMessageConfig()
-  checkSearchConfig()
-  checkLiveConfig()
-  checkObjectStorageConfig()
-  checkVideoStudioConfig()
-}
-
-// We get db by param to not import it in this file (import orders)
-async function clientsExist () {
-  const totalClients = await OAuthClientModel.countTotal()
-
-  return totalClients !== 0
-}
-
-// We get db by param to not import it in this file (import orders)
-async function usersExist () {
-  const totalUsers = await UserModel.countTotal()
-
-  return totalUsers !== 0
-}
-
-// We get db by param to not import it in this file (import orders)
-async function applicationExist () {
-  const totalApplication = await ApplicationModel.countTotal()
-
-  return totalApplication !== 0
-}
-
-async function checkFFmpegVersion () {
-  const version = await getFFmpegVersion()
-  const { major, minor, patch } = parseSemVersion(version)
-
-  if (major < 4 || (major === 4 && minor < 1)) {
-    logger.warn('Your ffmpeg version (%s) is outdated. PeerTube supports ffmpeg >= 4.1. Please upgrade ffmpeg.', version)
-  }
-
-  if (major === 4 && minor === 4 && patch === 0) {
-    logger.warn('There is a bug in ffmpeg 4.4.0 with HLS videos. Please upgrade ffmpeg.')
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  checkConfig,
-  clientsExist,
-  checkFFmpegVersion,
-  usersExist,
-  applicationExist,
-  checkActivityPubUrls
-}
-
-// ---------------------------------------------------------------------------
-
-function checkRemovedConfigKeys () {
-  // Moved configuration keys
-  if (config.has('services.csp-logger')) {
-    logger.warn('services.csp-logger configuration has been renamed to csp.report_uri. Please update your configuration file.')
-  }
-
-  if (config.has('transcoding.webtorrent.enabled')) {
-    const localConfigPath = getLocalConfigFilePath()
-
-    const content = readFileSync(localConfigPath, { encoding: 'utf-8' })
-    if (!content.includes('"webtorrent"')) {
-      throw new Error('Please rename transcoding.webtorrent.enabled key to transcoding.web_videos.enabled in your configuration file')
-    }
-
-    try {
-      logger.info(
-        'Replacing "transcoding.webtorrent.enabled" key to "transcoding.web_videos.enabled" in your local configuration ' + localConfigPath
-      )
-
-      writeFileSync(localConfigPath, content.replace('"webtorrent"', '"web_videos"'), { encoding: 'utf-8' })
-
-      reloadConfig()
-    } catch (err) {
-      logger.error('Cannot write new configuration to file ' + localConfigPath, { err })
-    }
-  }
-}
-
-function checkSecretsConfig () {
-  if (!CONFIG.SECRETS.PEERTUBE) {
-    throw new Error('secrets.peertube is missing in config. Generate one using `openssl rand -hex 32`')
-  }
-}
-
-function checkEmailConfig () {
-  if (!isEmailEnabled()) {
-    if (CONFIG.SIGNUP.ENABLED && CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION) {
-      throw new Error('SMTP is not configured but you require signup email verification.')
-    }
-
-    if (CONFIG.SIGNUP.ENABLED && CONFIG.SIGNUP.REQUIRES_APPROVAL) {
-      // eslint-disable-next-line max-len
-      logger.warn('SMTP is not configured but signup approval is enabled: PeerTube will not be able to send an email to the user upon acceptance/rejection of the registration request')
-    }
-
-    if (CONFIG.CONTACT_FORM.ENABLED) {
-      logger.warn('SMTP is not configured so the contact form will not work.')
-    }
-  }
-}
-
-function checkNSFWPolicyConfig () {
-  const defaultNSFWPolicy = CONFIG.INSTANCE.DEFAULT_NSFW_POLICY
-
-  const available = [ 'do_not_list', 'blur', 'display' ]
-  if (available.includes(defaultNSFWPolicy) === false) {
-    throw new Error('NSFW policy setting should be ' + available.join(' or ') + ' instead of ' + defaultNSFWPolicy)
-  }
-}
-
-function checkLocalRedundancyConfig () {
-  const redundancyVideos = CONFIG.REDUNDANCY.VIDEOS.STRATEGIES
-
-  if (isArray(redundancyVideos)) {
-    const available = [ 'most-views', 'trending', 'recently-added' ]
-
-    for (const r of redundancyVideos) {
-      if (available.includes(r.strategy) === false) {
-        throw new Error('Videos redundancy should have ' + available.join(' or ') + ' strategy instead of ' + r.strategy)
-      }
-
-      // Lifetime should not be < 10 hours
-      if (isProdInstance() && r.minLifetime < 1000 * 3600 * 10) {
-        throw new Error('Video redundancy minimum lifetime should be >= 10 hours for strategy ' + r.strategy)
-      }
-    }
-
-    const filtered = uniqify(redundancyVideos.map(r => r.strategy))
-    if (filtered.length !== redundancyVideos.length) {
-      throw new Error('Redundancy video entries should have unique strategies')
-    }
-
-    const recentlyAddedStrategy = redundancyVideos.find(r => r.strategy === 'recently-added') as RecentlyAddedStrategy
-    if (recentlyAddedStrategy && isNaN(recentlyAddedStrategy.minViews)) {
-      throw new Error('Min views in recently added strategy is not a number')
-    }
-  } else {
-    throw new Error('Videos redundancy should be an array (you must uncomment lines containing - too)')
-  }
-}
-
-function checkRemoteRedundancyConfig () {
-  const acceptFrom = CONFIG.REMOTE_REDUNDANCY.VIDEOS.ACCEPT_FROM
-  const acceptFromValues = new Set<VideoRedundancyConfigFilter>([ 'nobody', 'anybody', 'followings' ])
-
-  if (acceptFromValues.has(acceptFrom) === false) {
-    throw new Error('remote_redundancy.videos.accept_from has an incorrect value')
-  }
-}
-
-function checkStorageConfig () {
-  // Check storage directory locations
-  if (isProdInstance()) {
-    const configStorage = config.get<{ [ name: string ]: string }>('storage')
-
-    for (const key of Object.keys(configStorage)) {
-      if (configStorage[key].startsWith('storage/')) {
-        logger.warn(
-          'Directory of %s should not be in the production directory of PeerTube. Please check your production configuration file.',
-          key
-        )
-      }
-    }
-  }
-
-  if (CONFIG.STORAGE.WEB_VIDEOS_DIR === CONFIG.STORAGE.REDUNDANCY_DIR) {
-    logger.warn('Redundancy directory should be different than the videos folder.')
-  }
-}
-
-function checkTranscodingConfig () {
-  if (CONFIG.TRANSCODING.ENABLED) {
-    if (CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED === false && CONFIG.TRANSCODING.HLS.ENABLED === false) {
-      throw new Error('You need to enable at least Web Video transcoding or HLS transcoding.')
-    }
-
-    if (CONFIG.TRANSCODING.CONCURRENCY <= 0) {
-      throw new Error('Transcoding concurrency should be > 0')
-    }
-  }
-
-  if (CONFIG.IMPORT.VIDEOS.HTTP.ENABLED || CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED) {
-    if (CONFIG.IMPORT.VIDEOS.CONCURRENCY <= 0) {
-      throw new Error('Video import concurrency should be > 0')
-    }
-  }
-}
-
-function checkImportConfig () {
-  if (CONFIG.IMPORT.VIDEO_CHANNEL_SYNCHRONIZATION.ENABLED && !CONFIG.IMPORT.VIDEOS.HTTP) {
-    throw new Error('You need to enable HTTP import to allow synchronization')
-  }
-}
-
-function checkBroadcastMessageConfig () {
-  if (CONFIG.BROADCAST_MESSAGE.ENABLED) {
-    const currentLevel = CONFIG.BROADCAST_MESSAGE.LEVEL
-    const available = [ 'info', 'warning', 'error' ]
-
-    if (available.includes(currentLevel) === false) {
-      throw new Error('Broadcast message level should be ' + available.join(' or ') + ' instead of ' + currentLevel)
-    }
-  }
-}
-
-function checkSearchConfig () {
-  if (CONFIG.SEARCH.SEARCH_INDEX.ENABLED === true) {
-    if (CONFIG.SEARCH.REMOTE_URI.USERS === false) {
-      throw new Error('You cannot enable search index without enabling remote URI search for users.')
-    }
-  }
-}
-
-function checkLiveConfig () {
-  if (CONFIG.LIVE.ENABLED === true) {
-    if (CONFIG.LIVE.ALLOW_REPLAY === true && CONFIG.TRANSCODING.ENABLED === false) {
-      throw new Error('Live allow replay cannot be enabled if transcoding is not enabled.')
-    }
-
-    if (CONFIG.LIVE.RTMP.ENABLED === false && CONFIG.LIVE.RTMPS.ENABLED === false) {
-      throw new Error('You must enable at least RTMP or RTMPS')
-    }
-
-    if (CONFIG.LIVE.RTMPS.ENABLED) {
-      if (!CONFIG.LIVE.RTMPS.KEY_FILE) {
-        throw new Error('You must specify a key file to enable RTMPS')
-      }
-
-      if (!CONFIG.LIVE.RTMPS.CERT_FILE) {
-        throw new Error('You must specify a cert file to enable RTMPS')
-      }
-    }
-  }
-}
-
-function checkObjectStorageConfig () {
-  if (CONFIG.OBJECT_STORAGE.ENABLED === true) {
-
-    if (!CONFIG.OBJECT_STORAGE.WEB_VIDEOS.BUCKET_NAME) {
-      throw new Error('videos_bucket should be set when object storage support is enabled.')
-    }
-
-    if (!CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.BUCKET_NAME) {
-      throw new Error('streaming_playlists_bucket should be set when object storage support is enabled.')
-    }
-
-    if (
-      CONFIG.OBJECT_STORAGE.WEB_VIDEOS.BUCKET_NAME === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.BUCKET_NAME &&
-      CONFIG.OBJECT_STORAGE.WEB_VIDEOS.PREFIX === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.PREFIX
-    ) {
-      if (CONFIG.OBJECT_STORAGE.WEB_VIDEOS.PREFIX === '') {
-        throw new Error('Object storage bucket prefixes should be set when the same bucket is used for both types of video.')
-      }
-
-      throw new Error(
-        'Object storage bucket prefixes should be set to different values when the same bucket is used for both types of video.'
-      )
-    }
-
-    if (CONFIG.OBJECT_STORAGE.MAX_UPLOAD_PART > parseBytes('250MB')) {
-      // eslint-disable-next-line max-len
-      logger.warn(`Object storage max upload part seems to have a big value (${CONFIG.OBJECT_STORAGE.MAX_UPLOAD_PART} bytes). Consider using a lower one (like 100MB).`)
-    }
-  }
-}
-
-function checkVideoStudioConfig () {
-  if (CONFIG.VIDEO_STUDIO.ENABLED === true && CONFIG.TRANSCODING.ENABLED === false) {
-    throw new Error('Video studio cannot be enabled if transcoding is disabled')
-  }
-}
diff --git a/server/initializers/checker-before-init.ts b/server/initializers/checker-before-init.ts
deleted file mode 100644
index 0139ded4f..000000000
--- a/server/initializers/checker-before-init.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import { IConfig } from 'config'
-import { promisify0 } from '@shared/core-utils'
-import { parseSemVersion } from '../helpers/core-utils'
-import { logger } from '../helpers/logger'
-
-// Special behaviour for config because we can reload it
-const config: IConfig = require('config')
-
-// ONLY USE CORE MODULES IN THIS FILE!
-
-// Check the config files
-function checkMissedConfig () {
-  const required = [ 'listen.port', 'listen.hostname',
-    'webserver.https', 'webserver.hostname', 'webserver.port',
-    'secrets.peertube',
-    'trust_proxy',
-    'oauth2.token_lifetime.access_token', 'oauth2.token_lifetime.refresh_token',
-    'database.hostname', 'database.port', 'database.username', 'database.password', 'database.pool.max',
-    'smtp.hostname', 'smtp.port', 'smtp.username', 'smtp.password', 'smtp.tls', 'smtp.from_address',
-    'email.body.signature', 'email.subject.prefix',
-    'storage.avatars', 'storage.web_videos', 'storage.logs', 'storage.previews', 'storage.thumbnails', 'storage.torrents', 'storage.cache',
-    'storage.redundancy', 'storage.tmp', 'storage.streaming_playlists', 'storage.plugins', 'storage.well_known',
-    'log.level', 'log.rotation.enabled', 'log.rotation.max_file_size', 'log.rotation.max_files', 'log.anonymize_ip',
-    'log.log_ping_requests', 'log.log_tracker_unknown_infohash', 'log.prettify_sql', 'log.accept_client_log',
-    'open_telemetry.metrics.enabled', 'open_telemetry.metrics.prometheus_exporter.hostname',
-    'open_telemetry.metrics.prometheus_exporter.port', 'open_telemetry.tracing.enabled', 'open_telemetry.tracing.jaeger_exporter.endpoint',
-    'open_telemetry.metrics.http_request_duration.enabled',
-    'user.history.videos.enabled', 'user.video_quota', 'user.video_quota_daily',
-    'video_channels.max_per_user',
-    'csp.enabled', 'csp.report_only', 'csp.report_uri',
-    'security.frameguard.enabled', 'security.powered_by_header.enabled',
-    'cache.previews.size', 'cache.captions.size', 'cache.torrents.size', 'cache.storyboards.size',
-    'admin.email', 'contact_form.enabled',
-    'signup.enabled', 'signup.limit', 'signup.requires_approval', 'signup.requires_email_verification', 'signup.minimum_age',
-    'signup.filters.cidr.whitelist', 'signup.filters.cidr.blacklist',
-    'redundancy.videos.strategies', 'redundancy.videos.check_interval',
-    'transcoding.enabled', 'transcoding.threads', 'transcoding.allow_additional_extensions', 'transcoding.web_videos.enabled',
-    'transcoding.hls.enabled', 'transcoding.profile', 'transcoding.concurrency',
-    'transcoding.resolutions.0p', 'transcoding.resolutions.144p', 'transcoding.resolutions.240p', 'transcoding.resolutions.360p',
-    'transcoding.resolutions.480p', 'transcoding.resolutions.720p', 'transcoding.resolutions.1080p', 'transcoding.resolutions.1440p',
-    'transcoding.resolutions.2160p', 'transcoding.always_transcode_original_resolution', 'transcoding.remote_runners.enabled',
-    'video_studio.enabled', 'video_studio.remote_runners.enabled',
-    'video_file.update.enabled',
-    'remote_runners.stalled_jobs.vod', 'remote_runners.stalled_jobs.live',
-    'import.videos.http.enabled', 'import.videos.torrent.enabled', 'import.videos.concurrency', 'import.videos.timeout',
-    'import.video_channel_synchronization.enabled', 'import.video_channel_synchronization.max_per_user',
-    'import.video_channel_synchronization.check_interval', 'import.video_channel_synchronization.videos_limit_per_synchronization',
-    'import.video_channel_synchronization.full_sync_videos_limit',
-    'auto_blacklist.videos.of_users.enabled', 'trending.videos.interval_days',
-    'client.videos.miniature.display_author_avatar',
-    'client.videos.miniature.prefer_author_display_name', 'client.menu.login.redirect_on_single_external_auth',
-    'defaults.publish.download_enabled', 'defaults.publish.comments_enabled', 'defaults.publish.privacy', 'defaults.publish.licence',
-    'instance.name', 'instance.short_description', 'instance.description', 'instance.terms', 'instance.default_client_route',
-    'instance.is_nsfw', 'instance.default_nsfw_policy', 'instance.robots', 'instance.securitytxt',
-    'services.twitter.username', 'services.twitter.whitelisted',
-    'followers.instance.enabled', 'followers.instance.manual_approval',
-    'tracker.enabled', 'tracker.private', 'tracker.reject_too_many_announces',
-    'history.videos.max_age', 'views.videos.remote.max_age', 'views.videos.local_buffer_update_interval', 'views.videos.ip_view_expiration',
-    'rates_limit.api.window', 'rates_limit.api.max', 'rates_limit.login.window', 'rates_limit.login.max',
-    'rates_limit.signup.window', 'rates_limit.signup.max', 'rates_limit.ask_send_email.window', 'rates_limit.ask_send_email.max',
-    'rates_limit.receive_client_log.window', 'rates_limit.receive_client_log.max', 'rates_limit.plugins.window', 'rates_limit.plugins.max',
-    'rates_limit.well_known.window', 'rates_limit.well_known.max', 'rates_limit.feeds.window', 'rates_limit.feeds.max',
-    'rates_limit.activity_pub.window', 'rates_limit.activity_pub.max', 'rates_limit.client.window', 'rates_limit.client.max',
-    'static_files.private_files_require_auth',
-    'object_storage.enabled', 'object_storage.endpoint', 'object_storage.region', 'object_storage.upload_acl.public',
-    'object_storage.upload_acl.private', 'object_storage.proxy.proxify_private_files', 'object_storage.credentials.access_key_id',
-    'object_storage.credentials.secret_access_key', 'object_storage.max_upload_part', 'object_storage.streaming_playlists.bucket_name',
-    'object_storage.streaming_playlists.prefix', 'object_storage.streaming_playlists.base_url', 'object_storage.web_videos.bucket_name',
-    'object_storage.web_videos.prefix', 'object_storage.web_videos.base_url',
-    'theme.default',
-    'feeds.videos.count', 'feeds.comments.count',
-    'geo_ip.enabled', 'geo_ip.country.database_url',
-    'remote_redundancy.videos.accept_from',
-    'federation.videos.federate_unlisted', 'federation.videos.cleanup_remote_interactions',
-    'peertube.check_latest_version.enabled', 'peertube.check_latest_version.url',
-    'search.remote_uri.users', 'search.remote_uri.anonymous', 'search.search_index.enabled', 'search.search_index.url',
-    'search.search_index.disable_local_search', 'search.search_index.is_default_search',
-    'live.enabled', 'live.allow_replay', 'live.latency_setting.enabled', 'live.max_duration',
-    'live.max_user_lives', 'live.max_instance_lives',
-    'live.rtmp.enabled', 'live.rtmp.port', 'live.rtmp.hostname', 'live.rtmp.public_hostname',
-    'live.rtmps.enabled', 'live.rtmps.port', 'live.rtmps.hostname', 'live.rtmps.public_hostname',
-    'live.rtmps.key_file', 'live.rtmps.cert_file',
-    'live.transcoding.enabled', 'live.transcoding.threads', 'live.transcoding.profile',
-    'live.transcoding.resolutions.144p', 'live.transcoding.resolutions.240p', 'live.transcoding.resolutions.360p',
-    'live.transcoding.resolutions.480p', 'live.transcoding.resolutions.720p', 'live.transcoding.resolutions.1080p',
-    'live.transcoding.resolutions.1440p', 'live.transcoding.resolutions.2160p', 'live.transcoding.always_transcode_original_resolution',
-    'live.transcoding.remote_runners.enabled'
-  ]
-
-  const requiredAlternatives = [
-    [ // set
-      [ 'redis.hostname', 'redis.port' ], // alternative
-      [ 'redis.socket' ],
-      [ 'redis.sentinel.master_name', 'redis.sentinel.sentinels[0].hostname', 'redis.sentinel.sentinels[0].port' ]
-    ]
-  ]
-  const miss: string[] = []
-
-  for (const key of required) {
-    if (!config.has(key)) {
-      miss.push(key)
-    }
-  }
-
-  const redundancyVideos = config.get<any>('redundancy.videos.strategies')
-
-  if (Array.isArray(redundancyVideos)) {
-    for (const r of redundancyVideos) {
-      if (!r.size) miss.push('redundancy.videos.strategies.size')
-      if (!r.min_lifetime) miss.push('redundancy.videos.strategies.min_lifetime')
-    }
-  }
-
-  const missingAlternatives = requiredAlternatives.filter(
-    set => !set.find(alternative => !alternative.find(key => !config.has(key)))
-  )
-
-  missingAlternatives
-    .forEach(set => set[0].forEach(key => miss.push(key)))
-
-  return miss
-}
-
-// Check the available codecs
-// We get CONFIG by param to not import it in this file (import orders)
-async function checkFFmpeg (CONFIG: { TRANSCODING: { ENABLED: boolean } }) {
-  if (CONFIG.TRANSCODING.ENABLED === false) return undefined
-
-  const Ffmpeg = require('fluent-ffmpeg')
-  const getAvailableCodecsPromise = promisify0(Ffmpeg.getAvailableCodecs)
-  const codecs = await getAvailableCodecsPromise()
-  const canEncode = [ 'libx264' ]
-
-  for (const codec of canEncode) {
-    if (codecs[codec] === undefined) {
-      throw new Error('Unknown codec ' + codec + ' in FFmpeg.')
-    }
-
-    if (codecs[codec].canEncode !== true) {
-      throw new Error('Unavailable encode codec ' + codec + ' in FFmpeg')
-    }
-  }
-}
-
-function checkNodeVersion () {
-  const v = process.version
-  const { major } = parseSemVersion(v)
-
-  logger.debug('Checking NodeJS version %s.', v)
-
-  if (major <= 12) {
-    throw new Error('Your NodeJS version ' + v + ' is not supported. Please upgrade.')
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  checkFFmpeg,
-  checkMissedConfig,
-  checkNodeVersion
-}
diff --git a/server/initializers/config.ts b/server/initializers/config.ts
deleted file mode 100644
index 3e3b8ad1f..000000000
--- a/server/initializers/config.ts
+++ /dev/null
@@ -1,688 +0,0 @@
-import bytes from 'bytes'
-import { IConfig } from 'config'
-import { dirname, join } from 'path'
-import { decacheModule } from '@server/helpers/decache'
-import { VideoRedundancyConfigFilter } from '@shared/models/redundancy/video-redundancy-config-filter.type'
-import { BroadcastMessageLevel } from '@shared/models/server'
-import { buildPath, root } from '../../shared/core-utils'
-import { VideoPrivacy, VideosRedundancyStrategy } from '../../shared/models'
-import { NSFWPolicyType } from '../../shared/models/videos/nsfw-policy.type'
-import { parseBytes, parseDurationToMs } from '../helpers/core-utils'
-
-// Use a variable to reload the configuration if we need
-let config: IConfig = require('config')
-
-const configChangedHandlers: Function[] = []
-
-const CONFIG = {
-  CUSTOM_FILE: getLocalConfigFilePath(),
-  LISTEN: {
-    PORT: config.get<number>('listen.port'),
-    HOSTNAME: config.get<string>('listen.hostname')
-  },
-  SECRETS: {
-    PEERTUBE: config.get<string>('secrets.peertube')
-  },
-  DATABASE: {
-    DBNAME: config.has('database.name') ? config.get<string>('database.name') : 'peertube' + config.get<string>('database.suffix'),
-    HOSTNAME: config.get<string>('database.hostname'),
-    PORT: config.get<number>('database.port'),
-    SSL: config.get<boolean>('database.ssl'),
-    USERNAME: config.get<string>('database.username'),
-    PASSWORD: config.get<string>('database.password'),
-    POOL: {
-      MAX: config.get<number>('database.pool.max')
-    }
-  },
-  REDIS: {
-    HOSTNAME: config.has('redis.hostname') ? config.get<string>('redis.hostname') : null,
-    PORT: config.has('redis.port') ? config.get<number>('redis.port') : null,
-    SOCKET: config.has('redis.socket') ? config.get<string>('redis.socket') : null,
-    AUTH: config.has('redis.auth') ? config.get<string>('redis.auth') : null,
-    DB: config.has('redis.db') ? config.get<number>('redis.db') : null,
-    SENTINEL: {
-      ENABLED: config.has('redis.sentinel.enabled') ? config.get<boolean>('redis.sentinel.enabled') : false,
-      ENABLE_TLS: config.has('redis.sentinel.enable_tls') ? config.get<boolean>('redis.sentinel.enable_tls') : false,
-      SENTINELS: config.has('redis.sentinel.sentinels') ? config.get<{ hostname: string, port: number }[]>('redis.sentinel.sentinels') : [],
-      MASTER_NAME: config.has('redis.sentinel.master_name') ? config.get<string>('redis.sentinel.master_name') : null
-    }
-  },
-  SMTP: {
-    TRANSPORT: config.has('smtp.transport') ? config.get<string>('smtp.transport') : 'smtp',
-    SENDMAIL: config.has('smtp.sendmail') ? config.get<string>('smtp.sendmail') : null,
-    HOSTNAME: config.get<string>('smtp.hostname'),
-    PORT: config.get<number>('smtp.port'),
-    USERNAME: config.get<string>('smtp.username'),
-    PASSWORD: config.get<string>('smtp.password'),
-    TLS: config.get<boolean>('smtp.tls'),
-    DISABLE_STARTTLS: config.get<boolean>('smtp.disable_starttls'),
-    CA_FILE: config.get<string>('smtp.ca_file'),
-    FROM_ADDRESS: config.get<string>('smtp.from_address')
-  },
-  EMAIL: {
-    BODY: {
-      SIGNATURE: config.get<string>('email.body.signature')
-    },
-    SUBJECT: {
-      PREFIX: config.get<string>('email.subject.prefix') + ' '
-    }
-  },
-
-  CLIENT: {
-    VIDEOS: {
-      MINIATURE: {
-        get PREFER_AUTHOR_DISPLAY_NAME () { return config.get<boolean>('client.videos.miniature.prefer_author_display_name') },
-        get DISPLAY_AUTHOR_AVATAR () { return config.get<boolean>('client.videos.miniature.display_author_avatar') }
-      },
-      RESUMABLE_UPLOAD: {
-        get MAX_CHUNK_SIZE () { return parseBytes(config.get<number>('client.videos.resumable_upload.max_chunk_size') || 0) }
-      }
-    },
-    MENU: {
-      LOGIN: {
-        get REDIRECT_ON_SINGLE_EXTERNAL_AUTH () { return config.get<boolean>('client.menu.login.redirect_on_single_external_auth') }
-      }
-    }
-  },
-
-  DEFAULTS: {
-    PUBLISH: {
-      DOWNLOAD_ENABLED: config.get<boolean>('defaults.publish.download_enabled'),
-      COMMENTS_ENABLED: config.get<boolean>('defaults.publish.comments_enabled'),
-      PRIVACY: config.get<VideoPrivacy>('defaults.publish.privacy'),
-      LICENCE: config.get<number>('defaults.publish.licence')
-    },
-    P2P: {
-      WEBAPP: {
-        ENABLED: config.get<boolean>('defaults.p2p.webapp.enabled')
-      },
-      EMBED: {
-        ENABLED: config.get<boolean>('defaults.p2p.embed.enabled')
-      }
-    }
-  },
-
-  STORAGE: {
-    TMP_DIR: buildPath(config.get<string>('storage.tmp')),
-    TMP_PERSISTENT_DIR: buildPath(config.get<string>('storage.tmp_persistent')),
-    BIN_DIR: buildPath(config.get<string>('storage.bin')),
-    ACTOR_IMAGES_DIR: buildPath(config.get<string>('storage.avatars')),
-    LOG_DIR: buildPath(config.get<string>('storage.logs')),
-    WEB_VIDEOS_DIR: buildPath(config.get<string>('storage.web_videos')),
-    STREAMING_PLAYLISTS_DIR: buildPath(config.get<string>('storage.streaming_playlists')),
-    REDUNDANCY_DIR: buildPath(config.get<string>('storage.redundancy')),
-    THUMBNAILS_DIR: buildPath(config.get<string>('storage.thumbnails')),
-    STORYBOARDS_DIR: buildPath(config.get<string>('storage.storyboards')),
-    PREVIEWS_DIR: buildPath(config.get<string>('storage.previews')),
-    CAPTIONS_DIR: buildPath(config.get<string>('storage.captions')),
-    TORRENTS_DIR: buildPath(config.get<string>('storage.torrents')),
-    CACHE_DIR: buildPath(config.get<string>('storage.cache')),
-    PLUGINS_DIR: buildPath(config.get<string>('storage.plugins')),
-    CLIENT_OVERRIDES_DIR: buildPath(config.get<string>('storage.client_overrides')),
-    WELL_KNOWN_DIR: buildPath(config.get<string>('storage.well_known'))
-  },
-  STATIC_FILES: {
-    PRIVATE_FILES_REQUIRE_AUTH: config.get<boolean>('static_files.private_files_require_auth')
-  },
-  OBJECT_STORAGE: {
-    ENABLED: config.get<boolean>('object_storage.enabled'),
-    MAX_UPLOAD_PART: bytes.parse(config.get<string>('object_storage.max_upload_part')),
-    ENDPOINT: config.get<string>('object_storage.endpoint'),
-    REGION: config.get<string>('object_storage.region'),
-    UPLOAD_ACL: {
-      PUBLIC: config.get<string>('object_storage.upload_acl.public'),
-      PRIVATE: config.get<string>('object_storage.upload_acl.private')
-    },
-    CREDENTIALS: {
-      ACCESS_KEY_ID: config.get<string>('object_storage.credentials.access_key_id'),
-      SECRET_ACCESS_KEY: config.get<string>('object_storage.credentials.secret_access_key')
-    },
-    PROXY: {
-      PROXIFY_PRIVATE_FILES: config.get<boolean>('object_storage.proxy.proxify_private_files')
-    },
-    WEB_VIDEOS: {
-      BUCKET_NAME: config.get<string>('object_storage.web_videos.bucket_name'),
-      PREFIX: config.get<string>('object_storage.web_videos.prefix'),
-      BASE_URL: config.get<string>('object_storage.web_videos.base_url')
-    },
-    STREAMING_PLAYLISTS: {
-      BUCKET_NAME: config.get<string>('object_storage.streaming_playlists.bucket_name'),
-      PREFIX: config.get<string>('object_storage.streaming_playlists.prefix'),
-      BASE_URL: config.get<string>('object_storage.streaming_playlists.base_url')
-    }
-  },
-  WEBSERVER: {
-    SCHEME: config.get<boolean>('webserver.https') === true ? 'https' : 'http',
-    WS: config.get<boolean>('webserver.https') === true ? 'wss' : 'ws',
-    HOSTNAME: config.get<string>('webserver.hostname'),
-    PORT: config.get<number>('webserver.port')
-  },
-  OAUTH2: {
-    TOKEN_LIFETIME: {
-      ACCESS_TOKEN: parseDurationToMs(config.get<string>('oauth2.token_lifetime.access_token')),
-      REFRESH_TOKEN: parseDurationToMs(config.get<string>('oauth2.token_lifetime.refresh_token'))
-    }
-  },
-  RATES_LIMIT: {
-    API: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.api.window')),
-      MAX: config.get<number>('rates_limit.api.max')
-    },
-    SIGNUP: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.signup.window')),
-      MAX: config.get<number>('rates_limit.signup.max')
-    },
-    LOGIN: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.login.window')),
-      MAX: config.get<number>('rates_limit.login.max')
-    },
-    RECEIVE_CLIENT_LOG: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.receive_client_log.window')),
-      MAX: config.get<number>('rates_limit.receive_client_log.max')
-    },
-    ASK_SEND_EMAIL: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.ask_send_email.window')),
-      MAX: config.get<number>('rates_limit.ask_send_email.max')
-    },
-    PLUGINS: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.plugins.window')),
-      MAX: config.get<number>('rates_limit.plugins.max')
-    },
-    WELL_KNOWN: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.well_known.window')),
-      MAX: config.get<number>('rates_limit.well_known.max')
-    },
-    FEEDS: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.feeds.window')),
-      MAX: config.get<number>('rates_limit.feeds.max')
-    },
-    ACTIVITY_PUB: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.activity_pub.window')),
-      MAX: config.get<number>('rates_limit.activity_pub.max')
-    },
-    CLIENT: {
-      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.client.window')),
-      MAX: config.get<number>('rates_limit.client.max')
-    }
-  },
-  TRUST_PROXY: config.get<string[]>('trust_proxy'),
-  LOG: {
-    LEVEL: config.get<string>('log.level'),
-    ROTATION: {
-      ENABLED: config.get<boolean>('log.rotation.enabled'),
-      MAX_FILE_SIZE: bytes.parse(config.get<string>('log.rotation.max_file_size')),
-      MAX_FILES: config.get<number>('log.rotation.max_files')
-    },
-    ANONYMIZE_IP: config.get<boolean>('log.anonymize_ip'),
-    LOG_PING_REQUESTS: config.get<boolean>('log.log_ping_requests'),
-    LOG_TRACKER_UNKNOWN_INFOHASH: config.get<boolean>('log.log_tracker_unknown_infohash'),
-    PRETTIFY_SQL: config.get<boolean>('log.prettify_sql'),
-    ACCEPT_CLIENT_LOG: config.get<boolean>('log.accept_client_log')
-  },
-  OPEN_TELEMETRY: {
-    METRICS: {
-      ENABLED: config.get<boolean>('open_telemetry.metrics.enabled'),
-
-      HTTP_REQUEST_DURATION: {
-        ENABLED: config.get<boolean>('open_telemetry.metrics.http_request_duration.enabled')
-      },
-
-      PROMETHEUS_EXPORTER: {
-        HOSTNAME: config.get<string>('open_telemetry.metrics.prometheus_exporter.hostname'),
-        PORT: config.get<number>('open_telemetry.metrics.prometheus_exporter.port')
-      }
-    },
-    TRACING: {
-      ENABLED: config.get<boolean>('open_telemetry.tracing.enabled'),
-
-      JAEGER_EXPORTER: {
-        ENDPOINT: config.get<string>('open_telemetry.tracing.jaeger_exporter.endpoint')
-      }
-    }
-  },
-  TRENDING: {
-    VIDEOS: {
-      INTERVAL_DAYS: config.get<number>('trending.videos.interval_days'),
-      ALGORITHMS: {
-        get ENABLED () { return config.get<string[]>('trending.videos.algorithms.enabled') },
-        get DEFAULT () { return config.get<string>('trending.videos.algorithms.default') }
-      }
-    }
-  },
-  REDUNDANCY: {
-    VIDEOS: {
-      CHECK_INTERVAL: parseDurationToMs(config.get<string>('redundancy.videos.check_interval')),
-      STRATEGIES: buildVideosRedundancy(config.get<any[]>('redundancy.videos.strategies'))
-    }
-  },
-  REMOTE_REDUNDANCY: {
-    VIDEOS: {
-      ACCEPT_FROM: config.get<VideoRedundancyConfigFilter>('remote_redundancy.videos.accept_from')
-    }
-  },
-  CSP: {
-    ENABLED: config.get<boolean>('csp.enabled'),
-    REPORT_ONLY: config.get<boolean>('csp.report_only'),
-    REPORT_URI: config.get<string>('csp.report_uri')
-  },
-  SECURITY: {
-    FRAMEGUARD: {
-      ENABLED: config.get<boolean>('security.frameguard.enabled')
-    },
-    POWERED_BY_HEADER: {
-      ENABLED: config.get<boolean>('security.powered_by_header.enabled')
-    }
-  },
-  TRACKER: {
-    ENABLED: config.get<boolean>('tracker.enabled'),
-    PRIVATE: config.get<boolean>('tracker.private'),
-    REJECT_TOO_MANY_ANNOUNCES: config.get<boolean>('tracker.reject_too_many_announces')
-  },
-  HISTORY: {
-    VIDEOS: {
-      MAX_AGE: parseDurationToMs(config.get('history.videos.max_age'))
-    }
-  },
-  VIEWS: {
-    VIDEOS: {
-      REMOTE: {
-        MAX_AGE: parseDurationToMs(config.get('views.videos.remote.max_age'))
-      },
-      LOCAL_BUFFER_UPDATE_INTERVAL: parseDurationToMs(config.get('views.videos.local_buffer_update_interval')),
-      IP_VIEW_EXPIRATION: parseDurationToMs(config.get('views.videos.ip_view_expiration'))
-    }
-  },
-  GEO_IP: {
-    ENABLED: config.get<boolean>('geo_ip.enabled'),
-    COUNTRY: {
-      DATABASE_URL: config.get<string>('geo_ip.country.database_url')
-    }
-  },
-  PLUGINS: {
-    INDEX: {
-      ENABLED: config.get<boolean>('plugins.index.enabled'),
-      CHECK_LATEST_VERSIONS_INTERVAL: parseDurationToMs(config.get<string>('plugins.index.check_latest_versions_interval')),
-      URL: config.get<string>('plugins.index.url')
-    }
-  },
-  FEDERATION: {
-    VIDEOS: {
-      FEDERATE_UNLISTED: config.get<boolean>('federation.videos.federate_unlisted'),
-      CLEANUP_REMOTE_INTERACTIONS: config.get<boolean>('federation.videos.cleanup_remote_interactions')
-    },
-    SIGN_FEDERATED_FETCHES: config.get<boolean>('federation.sign_federated_fetches')
-  },
-  PEERTUBE: {
-    CHECK_LATEST_VERSION: {
-      ENABLED: config.get<boolean>('peertube.check_latest_version.enabled'),
-      URL: config.get<string>('peertube.check_latest_version.url')
-    }
-  },
-  WEBADMIN: {
-    CONFIGURATION: {
-      EDITION: {
-        ALLOWED: config.get<boolean>('webadmin.configuration.edition.allowed')
-      }
-    }
-  },
-  FEEDS: {
-    VIDEOS: {
-      COUNT: config.get<number>('feeds.videos.count')
-    },
-    COMMENTS: {
-      COUNT: config.get<number>('feeds.comments.count')
-    }
-  },
-  REMOTE_RUNNERS: {
-    STALLED_JOBS: {
-      LIVE: parseDurationToMs(config.get<string>('remote_runners.stalled_jobs.live')),
-      VOD: parseDurationToMs(config.get<string>('remote_runners.stalled_jobs.vod'))
-    }
-  },
-  ADMIN: {
-    get EMAIL () { return config.get<string>('admin.email') }
-  },
-  CONTACT_FORM: {
-    get ENABLED () { return config.get<boolean>('contact_form.enabled') }
-  },
-  SIGNUP: {
-    get ENABLED () { return config.get<boolean>('signup.enabled') },
-    get REQUIRES_APPROVAL () { return config.get<boolean>('signup.requires_approval') },
-    get LIMIT () { return config.get<number>('signup.limit') },
-    get REQUIRES_EMAIL_VERIFICATION () { return config.get<boolean>('signup.requires_email_verification') },
-    get MINIMUM_AGE () { return config.get<number>('signup.minimum_age') },
-    FILTERS: {
-      CIDR: {
-        get WHITELIST () { return config.get<string[]>('signup.filters.cidr.whitelist') },
-        get BLACKLIST () { return config.get<string[]>('signup.filters.cidr.blacklist') }
-      }
-    }
-  },
-  USER: {
-    HISTORY: {
-      VIDEOS: {
-        get ENABLED () { return config.get<boolean>('user.history.videos.enabled') }
-      }
-    },
-    get VIDEO_QUOTA () { return parseBytes(config.get<number>('user.video_quota')) },
-    get VIDEO_QUOTA_DAILY () { return parseBytes(config.get<number>('user.video_quota_daily')) }
-  },
-  VIDEO_CHANNELS: {
-    get MAX_PER_USER () { return config.get<number>('video_channels.max_per_user') }
-  },
-  TRANSCODING: {
-    get ENABLED () { return config.get<boolean>('transcoding.enabled') },
-    get ALLOW_ADDITIONAL_EXTENSIONS () { return config.get<boolean>('transcoding.allow_additional_extensions') },
-    get ALLOW_AUDIO_FILES () { return config.get<boolean>('transcoding.allow_audio_files') },
-    get THREADS () { return config.get<number>('transcoding.threads') },
-    get CONCURRENCY () { return config.get<number>('transcoding.concurrency') },
-    get PROFILE () { return config.get<string>('transcoding.profile') },
-    get ALWAYS_TRANSCODE_ORIGINAL_RESOLUTION () { return config.get<boolean>('transcoding.always_transcode_original_resolution') },
-    RESOLUTIONS: {
-      get '0p' () { return config.get<boolean>('transcoding.resolutions.0p') },
-      get '144p' () { return config.get<boolean>('transcoding.resolutions.144p') },
-      get '240p' () { return config.get<boolean>('transcoding.resolutions.240p') },
-      get '360p' () { return config.get<boolean>('transcoding.resolutions.360p') },
-      get '480p' () { return config.get<boolean>('transcoding.resolutions.480p') },
-      get '720p' () { return config.get<boolean>('transcoding.resolutions.720p') },
-      get '1080p' () { return config.get<boolean>('transcoding.resolutions.1080p') },
-      get '1440p' () { return config.get<boolean>('transcoding.resolutions.1440p') },
-      get '2160p' () { return config.get<boolean>('transcoding.resolutions.2160p') }
-    },
-    HLS: {
-      get ENABLED () { return config.get<boolean>('transcoding.hls.enabled') }
-    },
-    WEB_VIDEOS: {
-      get ENABLED () { return config.get<boolean>('transcoding.web_videos.enabled') }
-    },
-    REMOTE_RUNNERS: {
-      get ENABLED () { return config.get<boolean>('transcoding.remote_runners.enabled') }
-    }
-  },
-  LIVE: {
-    get ENABLED () { return config.get<boolean>('live.enabled') },
-
-    get MAX_DURATION () { return parseDurationToMs(config.get<string>('live.max_duration')) },
-    get MAX_INSTANCE_LIVES () { return config.get<number>('live.max_instance_lives') },
-    get MAX_USER_LIVES () { return config.get<number>('live.max_user_lives') },
-
-    get ALLOW_REPLAY () { return config.get<boolean>('live.allow_replay') },
-
-    LATENCY_SETTING: {
-      get ENABLED () { return config.get<boolean>('live.latency_setting.enabled') }
-    },
-
-    RTMP: {
-      get ENABLED () { return config.get<boolean>('live.rtmp.enabled') },
-      get PORT () { return config.get<number>('live.rtmp.port') },
-      get HOSTNAME () { return config.get<number>('live.rtmp.hostname') },
-      get PUBLIC_HOSTNAME () { return config.get<number>('live.rtmp.public_hostname') }
-    },
-
-    RTMPS: {
-      get ENABLED () { return config.get<boolean>('live.rtmps.enabled') },
-      get PORT () { return config.get<number>('live.rtmps.port') },
-      get HOSTNAME () { return config.get<number>('live.rtmps.hostname') },
-      get PUBLIC_HOSTNAME () { return config.get<number>('live.rtmps.public_hostname') },
-      get KEY_FILE () { return config.get<string>('live.rtmps.key_file') },
-      get CERT_FILE () { return config.get<string>('live.rtmps.cert_file') }
-    },
-
-    TRANSCODING: {
-      get ENABLED () { return config.get<boolean>('live.transcoding.enabled') },
-      get THREADS () { return config.get<number>('live.transcoding.threads') },
-      get PROFILE () { return config.get<string>('live.transcoding.profile') },
-
-      get ALWAYS_TRANSCODE_ORIGINAL_RESOLUTION () { return config.get<boolean>('live.transcoding.always_transcode_original_resolution') },
-
-      RESOLUTIONS: {
-        get '144p' () { return config.get<boolean>('live.transcoding.resolutions.144p') },
-        get '240p' () { return config.get<boolean>('live.transcoding.resolutions.240p') },
-        get '360p' () { return config.get<boolean>('live.transcoding.resolutions.360p') },
-        get '480p' () { return config.get<boolean>('live.transcoding.resolutions.480p') },
-        get '720p' () { return config.get<boolean>('live.transcoding.resolutions.720p') },
-        get '1080p' () { return config.get<boolean>('live.transcoding.resolutions.1080p') },
-        get '1440p' () { return config.get<boolean>('live.transcoding.resolutions.1440p') },
-        get '2160p' () { return config.get<boolean>('live.transcoding.resolutions.2160p') }
-      },
-      REMOTE_RUNNERS: {
-        get ENABLED () { return config.get<boolean>('live.transcoding.remote_runners.enabled') }
-      }
-    }
-  },
-  VIDEO_STUDIO: {
-    get ENABLED () { return config.get<boolean>('video_studio.enabled') },
-    REMOTE_RUNNERS: {
-      get ENABLED () { return config.get<boolean>('video_studio.remote_runners.enabled') }
-    }
-  },
-  VIDEO_FILE: {
-    UPDATE: {
-      get ENABLED () { return config.get<boolean>('video_file.update.enabled') }
-    }
-  },
-  IMPORT: {
-    VIDEOS: {
-      get CONCURRENCY () { return config.get<number>('import.videos.concurrency') },
-      get TIMEOUT () { return parseDurationToMs(config.get<string>('import.videos.timeout')) },
-
-      HTTP: {
-        get ENABLED () { return config.get<boolean>('import.videos.http.enabled') },
-
-        YOUTUBE_DL_RELEASE: {
-          get URL () { return config.get<string>('import.videos.http.youtube_dl_release.url') },
-          get NAME () { return config.get<string>('import.videos.http.youtube_dl_release.name') },
-          get PYTHON_PATH () { return config.get<string>('import.videos.http.youtube_dl_release.python_path') }
-        },
-
-        get FORCE_IPV4 () { return config.get<boolean>('import.videos.http.force_ipv4') }
-      },
-      TORRENT: {
-        get ENABLED () { return config.get<boolean>('import.videos.torrent.enabled') }
-      }
-    },
-    VIDEO_CHANNEL_SYNCHRONIZATION: {
-      get ENABLED () { return config.get<boolean>('import.video_channel_synchronization.enabled') },
-      get MAX_PER_USER () { return config.get<number>('import.video_channel_synchronization.max_per_user') },
-      get CHECK_INTERVAL () { return parseDurationToMs(config.get<string>('import.video_channel_synchronization.check_interval')) },
-      get VIDEOS_LIMIT_PER_SYNCHRONIZATION () {
-        return config.get<number>('import.video_channel_synchronization.videos_limit_per_synchronization')
-      },
-      get FULL_SYNC_VIDEOS_LIMIT () {
-        return config.get<number>('import.video_channel_synchronization.full_sync_videos_limit')
-      }
-    }
-  },
-  AUTO_BLACKLIST: {
-    VIDEOS: {
-      OF_USERS: {
-        get ENABLED () { return config.get<boolean>('auto_blacklist.videos.of_users.enabled') }
-      }
-    }
-  },
-  CACHE: {
-    PREVIEWS: {
-      get SIZE () { return config.get<number>('cache.previews.size') }
-    },
-    VIDEO_CAPTIONS: {
-      get SIZE () { return config.get<number>('cache.captions.size') }
-    },
-    TORRENTS: {
-      get SIZE () { return config.get<number>('cache.torrents.size') }
-    },
-    STORYBOARDS: {
-      get SIZE () { return config.get<number>('cache.storyboards.size') }
-    }
-  },
-  INSTANCE: {
-    get NAME () { return config.get<string>('instance.name') },
-    get SHORT_DESCRIPTION () { return config.get<string>('instance.short_description') },
-    get DESCRIPTION () { return config.get<string>('instance.description') },
-    get TERMS () { return config.get<string>('instance.terms') },
-    get CODE_OF_CONDUCT () { return config.get<string>('instance.code_of_conduct') },
-
-    get CREATION_REASON () { return config.get<string>('instance.creation_reason') },
-
-    get MODERATION_INFORMATION () { return config.get<string>('instance.moderation_information') },
-    get ADMINISTRATOR () { return config.get<string>('instance.administrator') },
-    get MAINTENANCE_LIFETIME () { return config.get<string>('instance.maintenance_lifetime') },
-    get BUSINESS_MODEL () { return config.get<string>('instance.business_model') },
-    get HARDWARE_INFORMATION () { return config.get<string>('instance.hardware_information') },
-
-    get LANGUAGES () { return config.get<string[]>('instance.languages') || [] },
-    get CATEGORIES () { return config.get<number[]>('instance.categories') || [] },
-
-    get IS_NSFW () { return config.get<boolean>('instance.is_nsfw') },
-    get DEFAULT_NSFW_POLICY () { return config.get<NSFWPolicyType>('instance.default_nsfw_policy') },
-
-    get DEFAULT_CLIENT_ROUTE () { return config.get<string>('instance.default_client_route') },
-
-    CUSTOMIZATIONS: {
-      get JAVASCRIPT () { return config.get<string>('instance.customizations.javascript') },
-      get CSS () { return config.get<string>('instance.customizations.css') }
-    },
-    get ROBOTS () { return config.get<string>('instance.robots') },
-    get SECURITYTXT () { return config.get<string>('instance.securitytxt') },
-    get SECURITYTXT_CONTACT () { return config.get<string>('admin.email') }
-  },
-  SERVICES: {
-    TWITTER: {
-      get USERNAME () { return config.get<string>('services.twitter.username') },
-      get WHITELISTED () { return config.get<boolean>('services.twitter.whitelisted') }
-    }
-  },
-  FOLLOWERS: {
-    INSTANCE: {
-      get ENABLED () { return config.get<boolean>('followers.instance.enabled') },
-      get MANUAL_APPROVAL () { return config.get<boolean>('followers.instance.manual_approval') }
-    }
-  },
-  FOLLOWINGS: {
-    INSTANCE: {
-      AUTO_FOLLOW_BACK: {
-        get ENABLED () {
-          return config.get<boolean>('followings.instance.auto_follow_back.enabled')
-        }
-      },
-      AUTO_FOLLOW_INDEX: {
-        get ENABLED () {
-          return config.get<boolean>('followings.instance.auto_follow_index.enabled')
-        },
-        get INDEX_URL () {
-          return config.get<string>('followings.instance.auto_follow_index.index_url')
-        }
-      }
-    }
-  },
-  THEME: {
-    get DEFAULT () { return config.get<string>('theme.default') }
-  },
-  BROADCAST_MESSAGE: {
-    get ENABLED () { return config.get<boolean>('broadcast_message.enabled') },
-    get MESSAGE () { return config.get<string>('broadcast_message.message') },
-    get LEVEL () { return config.get<BroadcastMessageLevel>('broadcast_message.level') },
-    get DISMISSABLE () { return config.get<boolean>('broadcast_message.dismissable') }
-  },
-  SEARCH: {
-    REMOTE_URI: {
-      get USERS () { return config.get<boolean>('search.remote_uri.users') },
-      get ANONYMOUS () { return config.get<boolean>('search.remote_uri.anonymous') }
-    },
-    SEARCH_INDEX: {
-      get ENABLED () { return config.get<boolean>('search.search_index.enabled') },
-      get URL () { return config.get<string>('search.search_index.url') },
-      get DISABLE_LOCAL_SEARCH () { return config.get<boolean>('search.search_index.disable_local_search') },
-      get IS_DEFAULT_SEARCH () { return config.get<boolean>('search.search_index.is_default_search') }
-    }
-  }
-
-}
-
-function registerConfigChangedHandler (fun: Function) {
-  configChangedHandlers.push(fun)
-}
-
-function isEmailEnabled () {
-  if (CONFIG.SMTP.TRANSPORT === 'sendmail' && CONFIG.SMTP.SENDMAIL) return true
-
-  if (CONFIG.SMTP.TRANSPORT === 'smtp' && CONFIG.SMTP.HOSTNAME && CONFIG.SMTP.PORT) return true
-
-  return false
-}
-
-function getLocalConfigFilePath () {
-  const localConfigDir = getLocalConfigDir()
-
-  let filename = 'local'
-  if (process.env.NODE_ENV) filename += `-${process.env.NODE_ENV}`
-  if (process.env.NODE_APP_INSTANCE) filename += `-${process.env.NODE_APP_INSTANCE}`
-
-  return join(localConfigDir, filename + '.json')
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  CONFIG,
-  getLocalConfigFilePath,
-  registerConfigChangedHandler,
-  isEmailEnabled
-}
-
-// ---------------------------------------------------------------------------
-
-function getLocalConfigDir () {
-  if (process.env.PEERTUBE_LOCAL_CONFIG) return process.env.PEERTUBE_LOCAL_CONFIG
-
-  const configSources = config.util.getConfigSources()
-  if (configSources.length === 0) throw new Error('Invalid config source.')
-
-  return dirname(configSources[0].name)
-}
-
-function buildVideosRedundancy (objs: any[]): VideosRedundancyStrategy[] {
-  if (!objs) return []
-
-  if (!Array.isArray(objs)) return objs
-
-  return objs.map(obj => {
-    return Object.assign({}, obj, {
-      minLifetime: parseDurationToMs(obj.min_lifetime),
-      size: bytes.parse(obj.size),
-      minViews: obj.min_views
-    })
-  })
-}
-
-export function reloadConfig () {
-
-  function getConfigDirectories () {
-    if (process.env.NODE_CONFIG_DIR) {
-      return process.env.NODE_CONFIG_DIR.split(':')
-    }
-
-    return [ join(root(), 'config') ]
-  }
-
-  function purge () {
-    const directories = getConfigDirectories()
-
-    for (const fileName in require.cache) {
-      if (directories.some((dir) => fileName.includes(dir)) === false) {
-        continue
-      }
-
-      delete require.cache[fileName]
-    }
-
-    decacheModule('config')
-  }
-
-  purge()
-
-  config = require('config')
-
-  for (const configChangedHandler of configChangedHandlers) {
-    configChangedHandler()
-  }
-}
diff --git a/server/initializers/constants.ts b/server/initializers/constants.ts
deleted file mode 100644
index de5f11f8f..000000000
--- a/server/initializers/constants.ts
+++ /dev/null
@@ -1,1396 +0,0 @@
-import { RepeatOptions } from 'bullmq'
-import { Encoding, randomBytes } from 'crypto'
-import { invert } from 'lodash'
-import { join } from 'path'
-import { randomInt, root } from '@shared/core-utils'
-import {
-  AbuseState,
-  JobType,
-  RunnerJobState,
-  UserRegistrationState,
-  VideoChannelSyncState,
-  VideoImportState,
-  VideoPrivacy,
-  VideoRateType,
-  VideoResolution,
-  VideoState,
-  VideoTranscodingFPS
-} from '../../shared/models'
-import { ActivityPubActorType } from '../../shared/models/activitypub'
-import { ActorImageType, FollowState } from '../../shared/models/actors'
-import { NSFWPolicyType } from '../../shared/models/videos/nsfw-policy.type'
-import { VideoPlaylistPrivacy } from '../../shared/models/videos/playlist/video-playlist-privacy.model'
-import { VideoPlaylistType } from '../../shared/models/videos/playlist/video-playlist-type.model'
-// Do not use barrels, remain constants as independent as possible
-import { isTestInstance, isTestOrDevInstance, parseDurationToMs, sanitizeHost, sanitizeUrl } from '../helpers/core-utils'
-import { CONFIG, registerConfigChangedHandler } from './config'
-
-// ---------------------------------------------------------------------------
-
-const LAST_MIGRATION_VERSION = 800
-
-// ---------------------------------------------------------------------------
-
-const API_VERSION = 'v1'
-const PEERTUBE_VERSION: string = require(join(root(), 'package.json')).version
-
-const PAGINATION = {
-  GLOBAL: {
-    COUNT: {
-      DEFAULT: 15,
-      MAX: 100
-    }
-  },
-  OUTBOX: {
-    COUNT: {
-      MAX: 50
-    }
-  }
-}
-
-const WEBSERVER = {
-  URL: '',
-  HOST: '',
-  SCHEME: '',
-  WS: '',
-  HOSTNAME: '',
-  PORT: 0,
-
-  RTMP_URL: '',
-  RTMPS_URL: '',
-
-  RTMP_BASE_LIVE_URL: '',
-  RTMPS_BASE_LIVE_URL: ''
-}
-
-// Sortable columns per schema
-const SORTABLE_COLUMNS = {
-  ADMIN_USERS: [ 'id', 'username', 'videoQuotaUsed', 'createdAt', 'lastLoginDate', 'role' ],
-  USER_SUBSCRIPTIONS: [ 'id', 'createdAt' ],
-  ACCOUNTS: [ 'createdAt' ],
-  JOBS: [ 'createdAt' ],
-  VIDEO_CHANNELS: [ 'id', 'name', 'updatedAt', 'createdAt' ],
-  VIDEO_IMPORTS: [ 'createdAt' ],
-  VIDEO_CHANNEL_SYNCS: [ 'externalChannelUrl', 'videoChannel', 'createdAt', 'lastSyncAt', 'state' ],
-
-  VIDEO_COMMENT_THREADS: [ 'createdAt', 'totalReplies' ],
-  VIDEO_COMMENTS: [ 'createdAt' ],
-
-  VIDEO_PASSWORDS: [ 'createdAt' ],
-
-  VIDEO_RATES: [ 'createdAt' ],
-  BLACKLISTS: [ 'id', 'name', 'duration', 'views', 'likes', 'dislikes', 'uuid', 'createdAt' ],
-
-  INSTANCE_FOLLOWERS: [ 'createdAt', 'state', 'score' ],
-  INSTANCE_FOLLOWING: [ 'createdAt', 'redundancyAllowed', 'state' ],
-  ACCOUNT_FOLLOWERS: [ 'createdAt' ],
-  CHANNEL_FOLLOWERS: [ 'createdAt' ],
-
-  USER_REGISTRATIONS: [ 'createdAt', 'state' ],
-
-  RUNNERS: [ 'createdAt' ],
-  RUNNER_REGISTRATION_TOKENS: [ 'createdAt' ],
-  RUNNER_JOBS: [ 'updatedAt', 'createdAt', 'priority', 'state', 'progress' ],
-
-  VIDEOS: [ 'name', 'duration', 'createdAt', 'publishedAt', 'originallyPublishedAt', 'views', 'likes', 'trending', 'hot', 'best' ],
-
-  // Don't forget to update peertube-search-index with the same values
-  VIDEOS_SEARCH: [ 'name', 'duration', 'createdAt', 'publishedAt', 'originallyPublishedAt', 'views', 'likes', 'match' ],
-  VIDEO_CHANNELS_SEARCH: [ 'match', 'displayName', 'createdAt' ],
-  VIDEO_PLAYLISTS_SEARCH: [ 'match', 'displayName', 'createdAt' ],
-
-  ABUSES: [ 'id', 'createdAt', 'state' ],
-
-  ACCOUNTS_BLOCKLIST: [ 'createdAt' ],
-  SERVERS_BLOCKLIST: [ 'createdAt' ],
-
-  USER_NOTIFICATIONS: [ 'createdAt', 'read' ],
-
-  VIDEO_PLAYLISTS: [ 'name', 'displayName', 'createdAt', 'updatedAt' ],
-
-  PLUGINS: [ 'name', 'createdAt', 'updatedAt' ],
-
-  AVAILABLE_PLUGINS: [ 'npmName', 'popularity' ],
-
-  VIDEO_REDUNDANCIES: [ 'name' ]
-}
-
-const ROUTE_CACHE_LIFETIME = {
-  FEEDS: '15 minutes',
-  ROBOTS: '2 hours',
-  SITEMAP: '1 day',
-  SECURITYTXT: '2 hours',
-  NODEINFO: '10 minutes',
-  DNT_POLICY: '1 week',
-  ACTIVITY_PUB: {
-    VIDEOS: '1 second' // 1 second, cache concurrent requests after a broadcast for example
-  },
-  STATS: '4 hours',
-  WELL_KNOWN: '1 day'
-}
-
-// ---------------------------------------------------------------------------
-
-// Number of points we add/remove after a successful/bad request
-const ACTOR_FOLLOW_SCORE = {
-  PENALTY: -10,
-  BONUS: 10,
-  BASE: 1000,
-  MAX: 10000
-}
-
-const FOLLOW_STATES: { [ id: string ]: FollowState } = {
-  PENDING: 'pending',
-  ACCEPTED: 'accepted',
-  REJECTED: 'rejected'
-}
-
-const REMOTE_SCHEME = {
-  HTTP: 'https',
-  WS: 'wss'
-}
-
-// ---------------------------------------------------------------------------
-
-const JOB_ATTEMPTS: { [id in JobType]: number } = {
-  'activitypub-http-broadcast': 1,
-  'activitypub-http-broadcast-parallel': 1,
-  'activitypub-http-unicast': 1,
-  'activitypub-http-fetcher': 2,
-  'activitypub-follow': 5,
-  'activitypub-cleaner': 1,
-  'video-file-import': 1,
-  'video-transcoding': 1,
-  'video-import': 1,
-  'email': 5,
-  'actor-keys': 3,
-  'videos-views-stats': 1,
-  'activitypub-refresher': 1,
-  'video-redundancy': 1,
-  'video-live-ending': 1,
-  'video-studio-edition': 1,
-  'manage-video-torrent': 1,
-  'video-channel-import': 1,
-  'after-video-channel-import': 1,
-  'move-to-object-storage': 3,
-  'transcoding-job-builder': 1,
-  'generate-video-storyboard': 1,
-  'notify': 1,
-  'federate-video': 1
-}
-// Excluded keys are jobs that can be configured by admins
-const JOB_CONCURRENCY: { [id in Exclude<JobType, 'video-transcoding' | 'video-import'>]: number } = {
-  'activitypub-http-broadcast': 1,
-  'activitypub-http-broadcast-parallel': 30,
-  'activitypub-http-unicast': 30,
-  'activitypub-http-fetcher': 3,
-  'activitypub-cleaner': 1,
-  'activitypub-follow': 1,
-  'video-file-import': 1,
-  'email': 5,
-  'actor-keys': 1,
-  'videos-views-stats': 1,
-  'activitypub-refresher': 1,
-  'video-redundancy': 1,
-  'video-live-ending': 10,
-  'video-studio-edition': 1,
-  'manage-video-torrent': 1,
-  'move-to-object-storage': 1,
-  'video-channel-import': 1,
-  'after-video-channel-import': 1,
-  'transcoding-job-builder': 1,
-  'generate-video-storyboard': 1,
-  'notify': 5,
-  'federate-video': 3
-}
-const JOB_TTL: { [id in JobType]: number } = {
-  'activitypub-http-broadcast': 60000 * 10, // 10 minutes
-  'activitypub-http-broadcast-parallel': 60000 * 10, // 10 minutes
-  'activitypub-http-unicast': 60000 * 10, // 10 minutes
-  'activitypub-http-fetcher': 1000 * 3600 * 10, // 10 hours
-  'activitypub-follow': 60000 * 10, // 10 minutes
-  'activitypub-cleaner': 1000 * 3600, // 1 hour
-  'video-file-import': 1000 * 3600, // 1 hour
-  'video-transcoding': 1000 * 3600 * 48, // 2 days, transcoding could be long
-  'video-studio-edition': 1000 * 3600 * 10, // 10 hours
-  'video-import': CONFIG.IMPORT.VIDEOS.TIMEOUT,
-  'email': 60000 * 10, // 10 minutes
-  'actor-keys': 60000 * 20, // 20 minutes
-  'videos-views-stats': undefined, // Unlimited
-  'activitypub-refresher': 60000 * 10, // 10 minutes
-  'video-redundancy': 1000 * 3600 * 3, // 3 hours
-  'video-live-ending': 1000 * 60 * 10, // 10 minutes
-  'generate-video-storyboard': 1000 * 60 * 10, // 10 minutes
-  'manage-video-torrent': 1000 * 3600 * 3, // 3 hours
-  'move-to-object-storage': 1000 * 60 * 60 * 3, // 3 hours
-  'video-channel-import': 1000 * 60 * 60 * 4, // 4 hours
-  'after-video-channel-import': 60000 * 5, // 5 minutes
-  'transcoding-job-builder': 60000, // 1 minute
-  'notify': 60000 * 5, // 5 minutes
-  'federate-video': 60000 * 5 // 5 minutes
-}
-const REPEAT_JOBS: { [ id in JobType ]?: RepeatOptions } = {
-  'videos-views-stats': {
-    pattern: randomInt(1, 20) + ' * * * *' // Between 1-20 minutes past the hour
-  },
-  'activitypub-cleaner': {
-    pattern: '30 5 * * ' + randomInt(0, 7) // 1 time per week (random day) at 5:30 AM
-  }
-}
-const JOB_PRIORITY = {
-  TRANSCODING: 100,
-  VIDEO_STUDIO: 150
-}
-
-const JOB_REMOVAL_OPTIONS = {
-  COUNT: 10000, // Max jobs to store
-
-  SUCCESS: { // Success jobs
-    'DEFAULT': parseDurationToMs('2 days'),
-
-    'activitypub-http-broadcast-parallel': parseDurationToMs('10 minutes'),
-    'activitypub-http-unicast': parseDurationToMs('1 hour'),
-    'videos-views-stats': parseDurationToMs('3 hours'),
-    'activitypub-refresher': parseDurationToMs('10 hours')
-  },
-
-  FAILURE: { // Failed job
-    DEFAULT: parseDurationToMs('7 days')
-  }
-}
-
-const VIDEO_IMPORT_TIMEOUT = Math.floor(JOB_TTL['video-import'] * 0.9)
-
-const RUNNER_JOBS = {
-  MAX_FAILURES: 5,
-  LAST_CONTACT_UPDATE_INTERVAL: 30000
-}
-
-// ---------------------------------------------------------------------------
-
-const BROADCAST_CONCURRENCY = 30 // How many requests in parallel we do in activitypub-http-broadcast job
-const CRAWL_REQUEST_CONCURRENCY = 1 // How many requests in parallel to fetch remote data (likes, shares...)
-
-const AP_CLEANER = {
-  CONCURRENCY: 10, // How many requests in parallel we do in activitypub-cleaner job
-  UNAVAILABLE_TRESHOLD: 3, // How many attempts we do before removing an unavailable remote resource
-  PERIOD: parseDurationToMs('1 week') // /!\ Has to be sync with REPEAT_JOBS
-}
-
-const REQUEST_TIMEOUTS = {
-  DEFAULT: 7000, // 7 seconds
-  FILE: 30000, // 30 seconds
-  REDUNDANCY: JOB_TTL['video-redundancy']
-}
-
-const SCHEDULER_INTERVALS_MS = {
-  RUNNER_JOB_WATCH_DOG: Math.min(CONFIG.REMOTE_RUNNERS.STALLED_JOBS.VOD, CONFIG.REMOTE_RUNNERS.STALLED_JOBS.LIVE),
-  ACTOR_FOLLOW_SCORES: 60000 * 60, // 1 hour
-  REMOVE_OLD_JOBS: 60000 * 60, // 1 hour
-  UPDATE_VIDEOS: 60000, // 1 minute
-  YOUTUBE_DL_UPDATE: 60000 * 60 * 24, // 1 day
-  GEO_IP_UPDATE: 60000 * 60 * 24, // 1 day
-  VIDEO_VIEWS_BUFFER_UPDATE: CONFIG.VIEWS.VIDEOS.LOCAL_BUFFER_UPDATE_INTERVAL,
-  CHECK_PLUGINS: CONFIG.PLUGINS.INDEX.CHECK_LATEST_VERSIONS_INTERVAL,
-  CHECK_PEERTUBE_VERSION: 60000 * 60 * 24, // 1 day
-  AUTO_FOLLOW_INDEX_INSTANCES: 60000 * 60 * 24, // 1 day
-  REMOVE_OLD_VIEWS: 60000 * 60 * 24, // 1 day
-  REMOVE_OLD_HISTORY: 60000 * 60 * 24, // 1 day
-  UPDATE_INBOX_STATS: 1000 * 60, // 1 minute
-  REMOVE_DANGLING_RESUMABLE_UPLOADS: 60000 * 60, // 1 hour
-  CHANNEL_SYNC_CHECK_INTERVAL: CONFIG.IMPORT.VIDEO_CHANNEL_SYNCHRONIZATION.CHECK_INTERVAL
-}
-
-// ---------------------------------------------------------------------------
-
-const CONSTRAINTS_FIELDS = {
-  USERS: {
-    NAME: { min: 1, max: 120 }, // Length
-    DESCRIPTION: { min: 3, max: 1000 }, // Length
-    USERNAME: { min: 1, max: 50 }, // Length
-    PASSWORD: { min: 6, max: 255 }, // Length
-    VIDEO_QUOTA: { min: -1 },
-    VIDEO_QUOTA_DAILY: { min: -1 },
-    VIDEO_LANGUAGES: { max: 500 }, // Array length
-    BLOCKED_REASON: { min: 3, max: 250 } // Length
-  },
-  ABUSES: {
-    REASON: { min: 2, max: 3000 }, // Length
-    MODERATION_COMMENT: { min: 2, max: 3000 } // Length
-  },
-  ABUSE_MESSAGES: {
-    MESSAGE: { min: 2, max: 3000 } // Length
-  },
-  USER_REGISTRATIONS: {
-    REASON_MESSAGE: { min: 2, max: 3000 }, // Length
-    MODERATOR_MESSAGE: { min: 2, max: 3000 } // Length
-  },
-  VIDEO_BLACKLIST: {
-    REASON: { min: 2, max: 300 } // Length
-  },
-  VIDEO_CHANNELS: {
-    NAME: { min: 1, max: 120 }, // Length
-    DESCRIPTION: { min: 3, max: 1000 }, // Length
-    SUPPORT: { min: 3, max: 1000 }, // Length
-    EXTERNAL_CHANNEL_URL: { min: 3, max: 2000 }, // Length
-    URL: { min: 3, max: 2000 } // Length
-  },
-  VIDEO_CHANNEL_SYNCS: {
-    EXTERNAL_CHANNEL_URL: { min: 3, max: 2000 } // Length
-  },
-  VIDEO_CAPTIONS: {
-    CAPTION_FILE: {
-      EXTNAME: [ '.vtt', '.srt' ],
-      FILE_SIZE: {
-        max: 20 * 1024 * 1024 // 20MB
-      }
-    }
-  },
-  VIDEO_IMPORTS: {
-    URL: { min: 3, max: 2000 }, // Length
-    TORRENT_NAME: { min: 3, max: 255 }, // Length
-    TORRENT_FILE: {
-      EXTNAME: [ '.torrent' ],
-      FILE_SIZE: {
-        max: 1024 * 200 // 200 KB
-      }
-    }
-  },
-  VIDEOS_REDUNDANCY: {
-    URL: { min: 3, max: 2000 } // Length
-  },
-  VIDEO_RATES: {
-    URL: { min: 3, max: 2000 } // Length
-  },
-  VIDEOS: {
-    NAME: { min: 3, max: 120 }, // Length
-    LANGUAGE: { min: 1, max: 10 }, // Length
-    TRUNCATED_DESCRIPTION: { min: 3, max: 250 }, // Length
-    DESCRIPTION: { min: 3, max: 10000 }, // Length
-    SUPPORT: { min: 3, max: 1000 }, // Length
-    IMAGE: {
-      EXTNAME: [ '.png', '.jpg', '.jpeg', '.webp' ],
-      FILE_SIZE: {
-        max: 4 * 1024 * 1024 // 4MB
-      }
-    },
-    EXTNAME: [] as string[],
-    INFO_HASH: { min: 40, max: 40 }, // Length, info hash is 20 bytes length but we represent it in hexadecimal so 20 * 2
-    DURATION: { min: 0 }, // Number
-    TAGS: { min: 0, max: 5 }, // Number of total tags
-    TAG: { min: 2, max: 30 }, // Length
-    VIEWS: { min: 0 },
-    LIKES: { min: 0 },
-    DISLIKES: { min: 0 },
-    FILE_SIZE: { min: -1 },
-    PARTIAL_UPLOAD_SIZE: { max: 50 * 1024 * 1024 * 1024 }, // 50GB
-    URL: { min: 3, max: 2000 } // Length
-  },
-  VIDEO_PLAYLISTS: {
-    NAME: { min: 1, max: 120 }, // Length
-    DESCRIPTION: { min: 3, max: 1000 }, // Length
-    URL: { min: 3, max: 2000 }, // Length
-    IMAGE: {
-      EXTNAME: [ '.jpg', '.jpeg' ],
-      FILE_SIZE: {
-        max: 4 * 1024 * 1024 // 4MB
-      }
-    }
-  },
-  ACTORS: {
-    PUBLIC_KEY: { min: 10, max: 5000 }, // Length
-    PRIVATE_KEY: { min: 10, max: 5000 }, // Length
-    URL: { min: 3, max: 2000 }, // Length
-    IMAGE: {
-      EXTNAME: [ '.png', '.jpeg', '.jpg', '.gif', '.webp' ],
-      FILE_SIZE: {
-        max: 4 * 1024 * 1024 // 4MB
-      }
-    }
-  },
-  VIDEO_EVENTS: {
-    COUNT: { min: 0 }
-  },
-  VIDEO_COMMENTS: {
-    TEXT: { min: 1, max: 10000 }, // Length
-    URL: { min: 3, max: 2000 } // Length
-  },
-  VIDEO_SHARE: {
-    URL: { min: 3, max: 2000 } // Length
-  },
-  CONTACT_FORM: {
-    FROM_NAME: { min: 1, max: 120 }, // Length
-    BODY: { min: 3, max: 5000 } // Length
-  },
-  PLUGINS: {
-    NAME: { min: 1, max: 214 }, // Length
-    DESCRIPTION: { min: 1, max: 20000 } // Length
-  },
-  COMMONS: {
-    URL: { min: 5, max: 2000 } // Length
-  },
-  VIDEO_STUDIO: {
-    TASKS: { min: 1, max: 10 }, // Number of tasks
-    CUT_TIME: { min: 0 } // Value
-  },
-  LOGS: {
-    CLIENT_MESSAGE: { min: 1, max: 1000 }, // Length
-    CLIENT_STACK_TRACE: { min: 1, max: 15000 }, // Length
-    CLIENT_META: { min: 1, max: 5000 }, // Length
-    CLIENT_USER_AGENT: { min: 1, max: 200 } // Length
-  },
-  RUNNERS: {
-    TOKEN: { min: 1, max: 1000 }, // Length
-    NAME: { min: 1, max: 100 }, // Length
-    DESCRIPTION: { min: 1, max: 1000 } // Length
-  },
-  RUNNER_JOBS: {
-    TOKEN: { min: 1, max: 1000 }, // Length
-    REASON: { min: 1, max: 5000 }, // Length
-    ERROR_MESSAGE: { min: 1, max: 5000 }, // Length
-    PROGRESS: { min: 0, max: 100 } // Value
-  },
-  VIDEO_PASSWORD: {
-    LENGTH: { min: 2, max: 100 }
-  }
-}
-
-const VIEW_LIFETIME = {
-  VIEW: CONFIG.VIEWS.VIDEOS.IP_VIEW_EXPIRATION,
-  VIEWER_COUNTER: 60000 * 2, // 2 minutes
-  VIEWER_STATS: 60000 * 60 // 1 hour
-}
-
-const MAX_LOCAL_VIEWER_WATCH_SECTIONS = 100
-
-let CONTACT_FORM_LIFETIME = 60000 * 60 // 1 hour
-
-const VIDEO_TRANSCODING_FPS: VideoTranscodingFPS = {
-  MIN: 1,
-  STANDARD: [ 24, 25, 30 ],
-  HD_STANDARD: [ 50, 60 ],
-  AUDIO_MERGE: 25,
-  AVERAGE: 30,
-  MAX: 60,
-  KEEP_ORIGIN_FPS_RESOLUTION_MIN: 720 // We keep the original FPS on high resolutions (720 minimum)
-}
-
-const DEFAULT_AUDIO_RESOLUTION = VideoResolution.H_480P
-
-const VIDEO_RATE_TYPES: { [ id: string ]: VideoRateType } = {
-  LIKE: 'like',
-  DISLIKE: 'dislike'
-}
-
-const FFMPEG_NICE = {
-  // parent process defaults to niceness = 0
-  // reminder: lower = higher priority, max value is 19, lowest is -20
-  LIVE: 5, // prioritize over VOD and THUMBNAIL
-  THUMBNAIL: 10,
-  VOD: 15
-}
-
-const VIDEO_CATEGORIES = {
-  1: 'Music',
-  2: 'Films',
-  3: 'Vehicles',
-  4: 'Art',
-  5: 'Sports',
-  6: 'Travels',
-  7: 'Gaming',
-  8: 'People',
-  9: 'Comedy',
-  10: 'Entertainment',
-  11: 'News & Politics',
-  12: 'How To',
-  13: 'Education',
-  14: 'Activism',
-  15: 'Science & Technology',
-  16: 'Animals',
-  17: 'Kids',
-  18: 'Food'
-}
-
-// See https://creativecommons.org/licenses/?lang=en
-const VIDEO_LICENCES = {
-  1: 'Attribution',
-  2: 'Attribution - Share Alike',
-  3: 'Attribution - No Derivatives',
-  4: 'Attribution - Non Commercial',
-  5: 'Attribution - Non Commercial - Share Alike',
-  6: 'Attribution - Non Commercial - No Derivatives',
-  7: 'Public Domain Dedication'
-}
-
-const VIDEO_LANGUAGES: { [id: string]: string } = {}
-
-const VIDEO_PRIVACIES: { [ id in VideoPrivacy ]: string } = {
-  [VideoPrivacy.PUBLIC]: 'Public',
-  [VideoPrivacy.UNLISTED]: 'Unlisted',
-  [VideoPrivacy.PRIVATE]: 'Private',
-  [VideoPrivacy.INTERNAL]: 'Internal',
-  [VideoPrivacy.PASSWORD_PROTECTED]: 'Password protected'
-}
-
-const VIDEO_STATES: { [ id in VideoState ]: string } = {
-  [VideoState.PUBLISHED]: 'Published',
-  [VideoState.TO_TRANSCODE]: 'To transcode',
-  [VideoState.TO_IMPORT]: 'To import',
-  [VideoState.WAITING_FOR_LIVE]: 'Waiting for livestream',
-  [VideoState.LIVE_ENDED]: 'Livestream ended',
-  [VideoState.TO_MOVE_TO_EXTERNAL_STORAGE]: 'To move to an external storage',
-  [VideoState.TRANSCODING_FAILED]: 'Transcoding failed',
-  [VideoState.TO_MOVE_TO_EXTERNAL_STORAGE_FAILED]: 'External storage move failed',
-  [VideoState.TO_EDIT]: 'To edit*'
-}
-
-const VIDEO_IMPORT_STATES: { [ id in VideoImportState ]: string } = {
-  [VideoImportState.FAILED]: 'Failed',
-  [VideoImportState.PENDING]: 'Pending',
-  [VideoImportState.SUCCESS]: 'Success',
-  [VideoImportState.REJECTED]: 'Rejected',
-  [VideoImportState.CANCELLED]: 'Cancelled',
-  [VideoImportState.PROCESSING]: 'Processing'
-}
-
-const VIDEO_CHANNEL_SYNC_STATE: { [ id in VideoChannelSyncState ]: string } = {
-  [VideoChannelSyncState.FAILED]: 'Failed',
-  [VideoChannelSyncState.SYNCED]: 'Synchronized',
-  [VideoChannelSyncState.PROCESSING]: 'Processing',
-  [VideoChannelSyncState.WAITING_FIRST_RUN]: 'Waiting first run'
-}
-
-const ABUSE_STATES: { [ id in AbuseState ]: string } = {
-  [AbuseState.PENDING]: 'Pending',
-  [AbuseState.REJECTED]: 'Rejected',
-  [AbuseState.ACCEPTED]: 'Accepted'
-}
-
-const USER_REGISTRATION_STATES: { [ id in UserRegistrationState ]: string } = {
-  [UserRegistrationState.PENDING]: 'Pending',
-  [UserRegistrationState.REJECTED]: 'Rejected',
-  [UserRegistrationState.ACCEPTED]: 'Accepted'
-}
-
-const VIDEO_PLAYLIST_PRIVACIES: { [ id in VideoPlaylistPrivacy ]: string } = {
-  [VideoPlaylistPrivacy.PUBLIC]: 'Public',
-  [VideoPlaylistPrivacy.UNLISTED]: 'Unlisted',
-  [VideoPlaylistPrivacy.PRIVATE]: 'Private'
-}
-
-const VIDEO_PLAYLIST_TYPES: { [ id in VideoPlaylistType ]: string } = {
-  [VideoPlaylistType.REGULAR]: 'Regular',
-  [VideoPlaylistType.WATCH_LATER]: 'Watch later'
-}
-
-const RUNNER_JOB_STATES: { [ id in RunnerJobState ]: string } = {
-  [RunnerJobState.PROCESSING]: 'Processing',
-  [RunnerJobState.COMPLETED]: 'Completed',
-  [RunnerJobState.COMPLETING]: 'Completing',
-  [RunnerJobState.PENDING]: 'Pending',
-  [RunnerJobState.ERRORED]: 'Errored',
-  [RunnerJobState.WAITING_FOR_PARENT_JOB]: 'Waiting for parent job to finish',
-  [RunnerJobState.CANCELLED]: 'Cancelled',
-  [RunnerJobState.PARENT_ERRORED]: 'Parent job failed',
-  [RunnerJobState.PARENT_CANCELLED]: 'Parent job cancelled'
-}
-
-const MIMETYPES = {
-  AUDIO: {
-    MIMETYPE_EXT: {
-      'audio/mpeg': '.mp3',
-      'audio/mp3': '.mp3',
-
-      'application/ogg': '.ogg',
-      'audio/ogg': '.ogg',
-
-      'audio/x-ms-wma': '.wma',
-      'audio/wav': '.wav',
-      'audio/x-wav': '.wav',
-
-      'audio/x-flac': '.flac',
-      'audio/flac': '.flac',
-
-      'audio/vnd.dlna.adts': '.aac',
-      'audio/aac': '.aac',
-
-      'audio/m4a': '.m4a',
-      'audio/mp4': '.m4a',
-      'audio/x-m4a': '.m4a',
-
-      'audio/vnd.dolby.dd-raw': '.ac3',
-      'audio/ac3': '.ac3'
-    },
-    EXT_MIMETYPE: null as { [ id: string ]: string }
-  },
-  VIDEO: {
-    MIMETYPE_EXT: null as { [ id: string ]: string | string[] },
-    MIMETYPES_REGEX: null as string,
-    EXT_MIMETYPE: null as { [ id: string ]: string }
-  },
-  IMAGE: {
-    MIMETYPE_EXT: {
-      'image/png': '.png',
-      'image/gif': '.gif',
-      'image/webp': '.webp',
-      'image/jpg': '.jpg',
-      'image/jpeg': '.jpg'
-    },
-    EXT_MIMETYPE: null as { [ id: string ]: string }
-  },
-  VIDEO_CAPTIONS: {
-    MIMETYPE_EXT: {
-      'text/vtt': '.vtt',
-      'application/x-subrip': '.srt',
-      'text/plain': '.srt'
-    },
-    EXT_MIMETYPE: null as { [ id: string ]: string }
-  },
-  TORRENT: {
-    MIMETYPE_EXT: {
-      'application/x-bittorrent': '.torrent'
-    }
-  },
-  M3U8: {
-    MIMETYPE_EXT: {
-      'application/vnd.apple.mpegurl': '.m3u8'
-    }
-  }
-}
-MIMETYPES.AUDIO.EXT_MIMETYPE = invert(MIMETYPES.AUDIO.MIMETYPE_EXT)
-MIMETYPES.IMAGE.EXT_MIMETYPE = invert(MIMETYPES.IMAGE.MIMETYPE_EXT)
-MIMETYPES.VIDEO_CAPTIONS.EXT_MIMETYPE = invert(MIMETYPES.VIDEO_CAPTIONS.MIMETYPE_EXT)
-
-const BINARY_CONTENT_TYPES = new Set([
-  'binary/octet-stream',
-  'application/octet-stream',
-  'application/x-binary'
-])
-
-// ---------------------------------------------------------------------------
-
-const OVERVIEWS = {
-  VIDEOS: {
-    SAMPLE_THRESHOLD: 6,
-    SAMPLES_COUNT: 20
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-const SERVER_ACTOR_NAME = 'peertube'
-
-const ACTIVITY_PUB = {
-  POTENTIAL_ACCEPT_HEADERS: [
-    'application/activity+json',
-    'application/ld+json',
-    'application/ld+json; profile="https://www.w3.org/ns/activitystreams"'
-  ],
-  ACCEPT_HEADER: 'application/activity+json, application/ld+json',
-  PUBLIC: 'https://www.w3.org/ns/activitystreams#Public',
-  COLLECTION_ITEMS_PER_PAGE: 10,
-  FETCH_PAGE_LIMIT: 2000,
-  URL_MIME_TYPES: {
-    VIDEO: [] as string[],
-    TORRENT: [ 'application/x-bittorrent' ],
-    MAGNET: [ 'application/x-bittorrent;x-scheme-handler/magnet' ]
-  },
-  MAX_RECURSION_COMMENTS: 100,
-  ACTOR_REFRESH_INTERVAL: 3600 * 24 * 1000 * 2, // 2 days
-  VIDEO_REFRESH_INTERVAL: 3600 * 24 * 1000 * 2, // 2 days
-  VIDEO_PLAYLIST_REFRESH_INTERVAL: 3600 * 24 * 1000 * 2 // 2 days
-}
-
-const ACTIVITY_PUB_ACTOR_TYPES: { [ id: string ]: ActivityPubActorType } = {
-  GROUP: 'Group',
-  PERSON: 'Person',
-  APPLICATION: 'Application',
-  ORGANIZATION: 'Organization',
-  SERVICE: 'Service'
-}
-
-const HTTP_SIGNATURE = {
-  HEADER_NAME: 'signature',
-  ALGORITHM: 'rsa-sha256',
-  HEADERS_TO_SIGN_WITH_PAYLOAD: [ '(request-target)', 'host', 'date', 'digest' ],
-  HEADERS_TO_SIGN_WITHOUT_PAYLOAD: [ '(request-target)', 'host', 'date' ],
-  CLOCK_SKEW_SECONDS: 1800
-}
-
-// ---------------------------------------------------------------------------
-
-let PRIVATE_RSA_KEY_SIZE = 2048
-
-// Password encryption
-const BCRYPT_SALT_SIZE = 10
-
-const ENCRYPTION = {
-  ALGORITHM: 'aes-256-cbc',
-  IV: 16,
-  SALT: 'peertube',
-  ENCODING: 'hex' as Encoding
-}
-
-const USER_PASSWORD_RESET_LIFETIME = 60000 * 60 // 60 minutes
-const USER_PASSWORD_CREATE_LIFETIME = 60000 * 60 * 24 * 7 // 7 days
-
-const TWO_FACTOR_AUTH_REQUEST_TOKEN_LIFETIME = 60000 * 10 // 10 minutes
-
-const EMAIL_VERIFY_LIFETIME = 60000 * 60 // 60 minutes
-
-const NSFW_POLICY_TYPES: { [ id: string ]: NSFWPolicyType } = {
-  DO_NOT_LIST: 'do_not_list',
-  BLUR: 'blur',
-  DISPLAY: 'display'
-}
-
-// ---------------------------------------------------------------------------
-
-// Express static paths (router)
-const STATIC_PATHS = {
-  // TODO: deprecated in v6, to remove
-  THUMBNAILS: '/static/thumbnails/',
-
-  // Need to keep this legacy path for previously generated torrents
-  LEGACY_WEB_VIDEOS: '/static/webseed/',
-  WEB_VIDEOS: '/static/web-videos/',
-
-  // Need to keep this legacy path for previously generated torrents
-  LEGACY_PRIVATE_WEB_VIDEOS: '/static/webseed/private/',
-  PRIVATE_WEB_VIDEOS: '/static/web-videos/private/',
-
-  REDUNDANCY: '/static/redundancy/',
-
-  STREAMING_PLAYLISTS: {
-    HLS: '/static/streaming-playlists/hls',
-    PRIVATE_HLS: '/static/streaming-playlists/hls/private/'
-  }
-}
-const STATIC_DOWNLOAD_PATHS = {
-  TORRENTS: '/download/torrents/',
-  VIDEOS: '/download/videos/',
-  HLS_VIDEOS: '/download/streaming-playlists/hls/videos/'
-}
-const LAZY_STATIC_PATHS = {
-  THUMBNAILS: '/lazy-static/thumbnails/',
-  BANNERS: '/lazy-static/banners/',
-  AVATARS: '/lazy-static/avatars/',
-  PREVIEWS: '/lazy-static/previews/',
-  VIDEO_CAPTIONS: '/lazy-static/video-captions/',
-  TORRENTS: '/lazy-static/torrents/',
-  STORYBOARDS: '/lazy-static/storyboards/'
-}
-const OBJECT_STORAGE_PROXY_PATHS = {
-  // Need to keep this legacy path for previously generated torrents
-  LEGACY_PRIVATE_WEB_VIDEOS: '/object-storage-proxy/webseed/private/',
-  PRIVATE_WEB_VIDEOS: '/object-storage-proxy/web-videos/private/',
-
-  STREAMING_PLAYLISTS: {
-    PRIVATE_HLS: '/object-storage-proxy/streaming-playlists/hls/private/'
-  }
-}
-
-// Cache control
-const STATIC_MAX_AGE = {
-  SERVER: '2h',
-  LAZY_SERVER: '2d',
-  CLIENT: '30d'
-}
-
-// Videos thumbnail size
-const THUMBNAILS_SIZE = {
-  width: 280,
-  height: 157,
-  minWidth: 150
-}
-const PREVIEWS_SIZE = {
-  width: 850,
-  height: 480,
-  minWidth: 400
-}
-const ACTOR_IMAGES_SIZE: { [key in ActorImageType]: { width: number, height: number }[] } = {
-  [ActorImageType.AVATAR]: [
-    {
-      width: 120,
-      height: 120
-    },
-    {
-      width: 48,
-      height: 48
-    }
-  ],
-  [ActorImageType.BANNER]: [
-    {
-      width: 1920,
-      height: 317 // 6/1 ratio
-    }
-  ]
-}
-
-const STORYBOARD = {
-  SPRITE_SIZE: {
-    width: 192,
-    height: 108
-  },
-  SPRITES_MAX_EDGE_COUNT: 10
-}
-
-const EMBED_SIZE = {
-  width: 560,
-  height: 315
-}
-
-// Sub folders of cache directory
-const FILES_CACHE = {
-  PREVIEWS: {
-    DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'previews'),
-    MAX_AGE: 1000 * 3600 * 3 // 3 hours
-  },
-  STORYBOARDS: {
-    DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'storyboards'),
-    MAX_AGE: 1000 * 3600 * 24 // 24 hours
-  },
-  VIDEO_CAPTIONS: {
-    DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'video-captions'),
-    MAX_AGE: 1000 * 3600 * 3 // 3 hours
-  },
-  TORRENTS: {
-    DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'torrents'),
-    MAX_AGE: 1000 * 3600 * 3 // 3 hours
-  }
-}
-
-const LRU_CACHE = {
-  USER_TOKENS: {
-    MAX_SIZE: 1000
-  },
-  FILENAME_TO_PATH_PERMANENT_FILE_CACHE: {
-    MAX_SIZE: 1000
-  },
-  STATIC_VIDEO_FILES_RIGHTS_CHECK: {
-    MAX_SIZE: 5000,
-    TTL: parseDurationToMs('10 seconds')
-  },
-  VIDEO_TOKENS: {
-    MAX_SIZE: 100_000,
-    TTL: parseDurationToMs('8 hours')
-  },
-  TRACKER_IPS: {
-    MAX_SIZE: 100_000
-  }
-}
-
-const DIRECTORIES = {
-  RESUMABLE_UPLOAD: join(CONFIG.STORAGE.TMP_DIR, 'resumable-uploads'),
-
-  HLS_STREAMING_PLAYLIST: {
-    PUBLIC: join(CONFIG.STORAGE.STREAMING_PLAYLISTS_DIR, 'hls'),
-    PRIVATE: join(CONFIG.STORAGE.STREAMING_PLAYLISTS_DIR, 'hls', 'private')
-  },
-
-  VIDEOS: {
-    PUBLIC: CONFIG.STORAGE.WEB_VIDEOS_DIR,
-    PRIVATE: join(CONFIG.STORAGE.WEB_VIDEOS_DIR, 'private')
-  },
-
-  HLS_REDUNDANCY: join(CONFIG.STORAGE.REDUNDANCY_DIR, 'hls')
-}
-
-const RESUMABLE_UPLOAD_SESSION_LIFETIME = SCHEDULER_INTERVALS_MS.REMOVE_DANGLING_RESUMABLE_UPLOADS
-
-const VIDEO_LIVE = {
-  EXTENSION: '.ts',
-  CLEANUP_DELAY: 1000 * 60 * 5, // 5 minutes
-  SEGMENT_TIME_SECONDS: {
-    DEFAULT_LATENCY: 4, // 4 seconds
-    SMALL_LATENCY: 2 // 2 seconds
-  },
-  SEGMENTS_LIST_SIZE: 15, // 15 maximum segments in live playlist
-  REPLAY_DIRECTORY: 'replay',
-  EDGE_LIVE_DELAY_SEGMENTS_NOTIFICATION: 4,
-  MAX_SOCKET_WAITING_DATA: 1024 * 1000 * 100, // 100MB
-  RTMP: {
-    CHUNK_SIZE: 60000,
-    GOP_CACHE: true,
-    PING: 60,
-    PING_TIMEOUT: 30,
-    BASE_PATH: 'live'
-  }
-}
-
-const MEMOIZE_TTL = {
-  OVERVIEWS_SAMPLE: 1000 * 3600 * 4, // 4 hours
-  INFO_HASH_EXISTS: 1000 * 60, // 1 minute
-  VIDEO_DURATION: 1000 * 10, // 10 seconds
-  LIVE_ABLE_TO_UPLOAD: 1000 * 60, // 1 minute
-  LIVE_CHECK_SOCKET_HEALTH: 1000 * 60, // 1 minute
-  GET_STATS_FOR_OPEN_TELEMETRY_METRICS: 1000 * 60 // 1 minute
-}
-
-const MEMOIZE_LENGTH = {
-  INFO_HASH_EXISTS: 200,
-  VIDEO_DURATION: 200
-}
-
-const WORKER_THREADS = {
-  DOWNLOAD_IMAGE: {
-    CONCURRENCY: 3,
-    MAX_THREADS: 1
-  },
-  PROCESS_IMAGE: {
-    CONCURRENCY: 1,
-    MAX_THREADS: 5
-  }
-}
-
-const REDUNDANCY = {
-  VIDEOS: {
-    RANDOMIZED_FACTOR: 5
-  }
-}
-
-const ACCEPT_HEADERS = [ 'html', 'application/json' ].concat(ACTIVITY_PUB.POTENTIAL_ACCEPT_HEADERS)
-const OTP = {
-  HEADER_NAME: 'x-peertube-otp',
-  HEADER_REQUIRED_VALUE: 'required; app'
-}
-
-const ASSETS_PATH = {
-  DEFAULT_AUDIO_BACKGROUND: join(root(), 'dist', 'server', 'assets', 'default-audio-background.jpg'),
-  DEFAULT_LIVE_BACKGROUND: join(root(), 'dist', 'server', 'assets', 'default-live-background.jpg')
-}
-
-// ---------------------------------------------------------------------------
-
-const CUSTOM_HTML_TAG_COMMENTS = {
-  TITLE: '<!-- title tag -->',
-  DESCRIPTION: '<!-- description tag -->',
-  CUSTOM_CSS: '<!-- custom css tag -->',
-  META_TAGS: '<!-- meta tags -->',
-  SERVER_CONFIG: '<!-- server config -->'
-}
-
-const MAX_LOGS_OUTPUT_CHARACTERS = 10 * 1000 * 1000
-const LOG_FILENAME = 'peertube.log'
-const AUDIT_LOG_FILENAME = 'peertube-audit.log'
-
-// ---------------------------------------------------------------------------
-
-const TRACKER_RATE_LIMITS = {
-  INTERVAL: 60000 * 5, // 5 minutes
-  ANNOUNCES_PER_IP_PER_INFOHASH: 15, // maximum announces per torrent in the interval
-  ANNOUNCES_PER_IP: 30, // maximum announces for all our torrents in the interval
-  BLOCK_IP_LIFETIME: parseDurationToMs('3 minutes')
-}
-
-const P2P_MEDIA_LOADER_PEER_VERSION = 2
-
-// ---------------------------------------------------------------------------
-
-const PLUGIN_GLOBAL_CSS_FILE_NAME = 'plugins-global.css'
-const PLUGIN_GLOBAL_CSS_PATH = join(CONFIG.STORAGE.TMP_DIR, PLUGIN_GLOBAL_CSS_FILE_NAME)
-
-let PLUGIN_EXTERNAL_AUTH_TOKEN_LIFETIME = 1000 * 60 * 5 // 5 minutes
-
-const DEFAULT_THEME_NAME = 'default'
-const DEFAULT_USER_THEME_NAME = 'instance-default'
-
-// ---------------------------------------------------------------------------
-
-const SEARCH_INDEX = {
-  ROUTES: {
-    VIDEOS: '/api/v1/search/videos',
-    VIDEO_CHANNELS: '/api/v1/search/video-channels'
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-const STATS_TIMESERIE = {
-  MAX_DAYS: 365 * 10 // Around 10 years
-}
-
-// ---------------------------------------------------------------------------
-
-// Special constants for a test instance
-if (process.env.PRODUCTION_CONSTANTS !== 'true') {
-  if (isTestOrDevInstance()) {
-    PRIVATE_RSA_KEY_SIZE = 1024
-
-    ACTOR_FOLLOW_SCORE.BASE = 20
-
-    REMOTE_SCHEME.HTTP = 'http'
-    REMOTE_SCHEME.WS = 'ws'
-
-    STATIC_MAX_AGE.SERVER = '0'
-
-    SCHEDULER_INTERVALS_MS.ACTOR_FOLLOW_SCORES = 1000
-    SCHEDULER_INTERVALS_MS.REMOVE_OLD_JOBS = 10000
-    SCHEDULER_INTERVALS_MS.REMOVE_OLD_HISTORY = 5000
-    SCHEDULER_INTERVALS_MS.REMOVE_OLD_VIEWS = 5000
-    SCHEDULER_INTERVALS_MS.UPDATE_VIDEOS = 5000
-    SCHEDULER_INTERVALS_MS.AUTO_FOLLOW_INDEX_INSTANCES = 5000
-    SCHEDULER_INTERVALS_MS.UPDATE_INBOX_STATS = 5000
-    SCHEDULER_INTERVALS_MS.CHECK_PEERTUBE_VERSION = 2000
-
-    REPEAT_JOBS['videos-views-stats'] = { every: 5000 }
-
-    REPEAT_JOBS['activitypub-cleaner'] = { every: 5000 }
-    AP_CLEANER.PERIOD = 5000
-
-    REDUNDANCY.VIDEOS.RANDOMIZED_FACTOR = 1
-
-    CONTACT_FORM_LIFETIME = 1000 // 1 second
-
-    JOB_ATTEMPTS['email'] = 1
-
-    FILES_CACHE.VIDEO_CAPTIONS.MAX_AGE = 3000
-    MEMOIZE_TTL.OVERVIEWS_SAMPLE = 3000
-    MEMOIZE_TTL.LIVE_ABLE_TO_UPLOAD = 3000
-    OVERVIEWS.VIDEOS.SAMPLE_THRESHOLD = 2
-
-    PLUGIN_EXTERNAL_AUTH_TOKEN_LIFETIME = 5000
-
-    JOB_REMOVAL_OPTIONS.SUCCESS['videos-views-stats'] = 10000
-  }
-
-  if (isTestInstance()) {
-    ACTIVITY_PUB.COLLECTION_ITEMS_PER_PAGE = 2
-    ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL = 10 * 1000 // 10 seconds
-    ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL = 10 * 1000 // 10 seconds
-    ACTIVITY_PUB.VIDEO_PLAYLIST_REFRESH_INTERVAL = 10 * 1000 // 10 seconds
-
-    CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max = 100 * 1024 // 100KB
-    CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max = 400 * 1024 // 400KB
-
-    VIEW_LIFETIME.VIEWER_COUNTER = 1000 * 5 // 5 second
-    VIEW_LIFETIME.VIEWER_STATS = 1000 * 5 // 5 second
-
-    VIDEO_LIVE.CLEANUP_DELAY = getIntEnv('PEERTUBE_TEST_CONSTANTS_VIDEO_LIVE_CLEANUP_DELAY') ?? 5000
-    VIDEO_LIVE.SEGMENT_TIME_SECONDS.DEFAULT_LATENCY = 2
-    VIDEO_LIVE.SEGMENT_TIME_SECONDS.SMALL_LATENCY = 1
-    VIDEO_LIVE.EDGE_LIVE_DELAY_SEGMENTS_NOTIFICATION = 1
-
-    RUNNER_JOBS.LAST_CONTACT_UPDATE_INTERVAL = 2000
-  }
-}
-
-updateWebserverUrls()
-updateWebserverConfig()
-
-registerConfigChangedHandler(() => {
-  updateWebserverUrls()
-  updateWebserverConfig()
-})
-
-// ---------------------------------------------------------------------------
-
-const FILES_CONTENT_HASH = {
-  MANIFEST: generateContentHash(),
-  FAVICON: generateContentHash(),
-  LOGO: generateContentHash()
-}
-
-// ---------------------------------------------------------------------------
-
-const VIDEO_FILTERS = {
-  WATERMARK: {
-    SIZE_RATIO: 1 / 10,
-    HORIZONTAL_MARGIN_RATIO: 1 / 20,
-    VERTICAL_MARGIN_RATIO: 1 / 20
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  WEBSERVER,
-  API_VERSION,
-  ENCRYPTION,
-  VIDEO_LIVE,
-  PEERTUBE_VERSION,
-  LAZY_STATIC_PATHS,
-  OBJECT_STORAGE_PROXY_PATHS,
-  SEARCH_INDEX,
-  DIRECTORIES,
-  RESUMABLE_UPLOAD_SESSION_LIFETIME,
-  RUNNER_JOB_STATES,
-  P2P_MEDIA_LOADER_PEER_VERSION,
-  STORYBOARD,
-  ACTOR_IMAGES_SIZE,
-  ACCEPT_HEADERS,
-  BCRYPT_SALT_SIZE,
-  TRACKER_RATE_LIMITS,
-  FILES_CACHE,
-  LOG_FILENAME,
-  CONSTRAINTS_FIELDS,
-  EMBED_SIZE,
-  REDUNDANCY,
-  JOB_CONCURRENCY,
-  JOB_ATTEMPTS,
-  AP_CLEANER,
-  LAST_MIGRATION_VERSION,
-  CUSTOM_HTML_TAG_COMMENTS,
-  STATS_TIMESERIE,
-  BROADCAST_CONCURRENCY,
-  AUDIT_LOG_FILENAME,
-  PAGINATION,
-  ACTOR_FOLLOW_SCORE,
-  PREVIEWS_SIZE,
-  REMOTE_SCHEME,
-  FOLLOW_STATES,
-  DEFAULT_USER_THEME_NAME,
-  SERVER_ACTOR_NAME,
-  TWO_FACTOR_AUTH_REQUEST_TOKEN_LIFETIME,
-  PLUGIN_GLOBAL_CSS_FILE_NAME,
-  PLUGIN_GLOBAL_CSS_PATH,
-  PRIVATE_RSA_KEY_SIZE,
-  VIDEO_FILTERS,
-  ROUTE_CACHE_LIFETIME,
-  SORTABLE_COLUMNS,
-  JOB_TTL,
-  DEFAULT_THEME_NAME,
-  NSFW_POLICY_TYPES,
-  STATIC_MAX_AGE,
-  STATIC_PATHS,
-  VIDEO_IMPORT_TIMEOUT,
-  VIDEO_PLAYLIST_TYPES,
-  MAX_LOGS_OUTPUT_CHARACTERS,
-  ACTIVITY_PUB,
-  ACTIVITY_PUB_ACTOR_TYPES,
-  THUMBNAILS_SIZE,
-  VIDEO_CATEGORIES,
-  MEMOIZE_LENGTH,
-  VIDEO_LANGUAGES,
-  VIDEO_PRIVACIES,
-  VIDEO_LICENCES,
-  VIDEO_STATES,
-  WORKER_THREADS,
-  VIDEO_RATE_TYPES,
-  JOB_PRIORITY,
-  VIDEO_TRANSCODING_FPS,
-  FFMPEG_NICE,
-  ABUSE_STATES,
-  USER_REGISTRATION_STATES,
-  LRU_CACHE,
-  REQUEST_TIMEOUTS,
-  RUNNER_JOBS,
-  MAX_LOCAL_VIEWER_WATCH_SECTIONS,
-  USER_PASSWORD_RESET_LIFETIME,
-  USER_PASSWORD_CREATE_LIFETIME,
-  MEMOIZE_TTL,
-  EMAIL_VERIFY_LIFETIME,
-  OVERVIEWS,
-  SCHEDULER_INTERVALS_MS,
-  REPEAT_JOBS,
-  STATIC_DOWNLOAD_PATHS,
-  MIMETYPES,
-  CRAWL_REQUEST_CONCURRENCY,
-  DEFAULT_AUDIO_RESOLUTION,
-  BINARY_CONTENT_TYPES,
-  JOB_REMOVAL_OPTIONS,
-  HTTP_SIGNATURE,
-  VIDEO_IMPORT_STATES,
-  VIDEO_CHANNEL_SYNC_STATE,
-  VIEW_LIFETIME,
-  CONTACT_FORM_LIFETIME,
-  VIDEO_PLAYLIST_PRIVACIES,
-  PLUGIN_EXTERNAL_AUTH_TOKEN_LIFETIME,
-  ASSETS_PATH,
-  FILES_CONTENT_HASH,
-  OTP,
-  loadLanguages,
-  buildLanguages,
-  generateContentHash
-}
-
-// ---------------------------------------------------------------------------
-
-function buildVideoMimetypeExt () {
-  const data = {
-    // streamable formats that warrant cross-browser compatibility
-    'video/webm': '.webm',
-    // We'll add .ogg if additional extensions are enabled
-    // We could add .ogg here but since it could be an audio file,
-    // it would be confusing for users because PeerTube will refuse their file (based on the mimetype)
-    'video/ogg': [ '.ogv' ],
-    'video/mp4': '.mp4'
-  }
-
-  if (CONFIG.TRANSCODING.ENABLED) {
-    if (CONFIG.TRANSCODING.ALLOW_ADDITIONAL_EXTENSIONS) {
-      data['video/ogg'].push('.ogg')
-
-      Object.assign(data, {
-        'video/x-matroska': '.mkv',
-
-        // Developed by Apple
-        'video/quicktime': [ '.mov', '.qt', '.mqv' ], // often used as output format by editing software
-        'video/x-m4v': '.m4v',
-        'video/m4v': '.m4v',
-
-        // Developed by the Adobe Flash Platform
-        'video/x-flv': '.flv',
-        'video/x-f4v': '.f4v', // replacement for flv
-
-        // Developed by Microsoft
-        'video/x-ms-wmv': '.wmv',
-        'video/x-msvideo': '.avi',
-        'video/avi': '.avi',
-
-        // Developed by 3GPP
-        // common video formats for cell phones
-        'video/3gpp': [ '.3gp', '.3gpp' ],
-        'video/3gpp2': [ '.3g2', '.3gpp2' ],
-
-        // Developed by FFmpeg/Mplayer
-        'application/x-nut': '.nut',
-
-        // The standard video format used by many Sony and Panasonic HD camcorders.
-        // It is also used for storing high definition video on Blu-ray discs.
-        'video/mp2t': '.mts',
-        'video/vnd.dlna.mpeg-tts': '.mts',
-
-        'video/m2ts': '.m2ts',
-
-        // Old formats reliant on MPEG-1/MPEG-2
-        'video/mpv': '.mpv',
-        'video/mpeg2': '.m2v',
-        'video/mpeg': [ '.m1v', '.mpg', '.mpe', '.mpeg', '.vob' ],
-        'video/dvd': '.vob',
-
-        // Could be anything
-        'application/octet-stream': null,
-        'application/mxf': '.mxf' // often used as exchange format by editing software
-      })
-    }
-
-    if (CONFIG.TRANSCODING.ALLOW_AUDIO_FILES) {
-      Object.assign(data, MIMETYPES.AUDIO.MIMETYPE_EXT)
-    }
-  }
-
-  return data
-}
-
-function updateWebserverUrls () {
-  WEBSERVER.URL = sanitizeUrl(CONFIG.WEBSERVER.SCHEME + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT)
-  WEBSERVER.HOST = sanitizeHost(CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT, REMOTE_SCHEME.HTTP)
-  WEBSERVER.WS = CONFIG.WEBSERVER.WS
-
-  WEBSERVER.SCHEME = CONFIG.WEBSERVER.SCHEME
-  WEBSERVER.HOSTNAME = CONFIG.WEBSERVER.HOSTNAME
-  WEBSERVER.PORT = CONFIG.WEBSERVER.PORT
-
-  const rtmpHostname = CONFIG.LIVE.RTMP.PUBLIC_HOSTNAME || CONFIG.WEBSERVER.HOSTNAME
-  const rtmpsHostname = CONFIG.LIVE.RTMPS.PUBLIC_HOSTNAME || CONFIG.WEBSERVER.HOSTNAME
-
-  WEBSERVER.RTMP_URL = 'rtmp://' + rtmpHostname + ':' + CONFIG.LIVE.RTMP.PORT
-  WEBSERVER.RTMPS_URL = 'rtmps://' + rtmpsHostname + ':' + CONFIG.LIVE.RTMPS.PORT
-
-  WEBSERVER.RTMP_BASE_LIVE_URL = WEBSERVER.RTMP_URL + '/' + VIDEO_LIVE.RTMP.BASE_PATH
-  WEBSERVER.RTMPS_BASE_LIVE_URL = WEBSERVER.RTMPS_URL + '/' + VIDEO_LIVE.RTMP.BASE_PATH
-}
-
-function updateWebserverConfig () {
-  MIMETYPES.VIDEO.MIMETYPE_EXT = buildVideoMimetypeExt()
-  MIMETYPES.VIDEO.MIMETYPES_REGEX = buildMimetypesRegex(MIMETYPES.VIDEO.MIMETYPE_EXT)
-
-  ACTIVITY_PUB.URL_MIME_TYPES.VIDEO = Object.keys(MIMETYPES.VIDEO.MIMETYPE_EXT)
-
-  MIMETYPES.VIDEO.EXT_MIMETYPE = buildVideoExtMimetype(MIMETYPES.VIDEO.MIMETYPE_EXT)
-
-  CONSTRAINTS_FIELDS.VIDEOS.EXTNAME = Object.keys(MIMETYPES.VIDEO.EXT_MIMETYPE)
-}
-
-function buildVideoExtMimetype (obj: { [ id: string ]: string | string[] }) {
-  const result: { [id: string]: string } = {}
-
-  for (const mimetype of Object.keys(obj)) {
-    const value = obj[mimetype]
-    if (!value) continue
-
-    const extensions = Array.isArray(value) ? value : [ value ]
-
-    for (const extension of extensions) {
-      result[extension] = mimetype
-    }
-  }
-
-  return result
-}
-
-function buildMimetypesRegex (obj: { [id: string]: string | string[] }) {
-  return Object.keys(obj)
-    .map(m => `(${m})`)
-    .join('|')
-}
-
-function loadLanguages () {
-  Object.assign(VIDEO_LANGUAGES, buildLanguages())
-}
-
-function buildLanguages () {
-  const iso639 = require('iso-639-3')
-
-  const languages: { [id: string]: string } = {}
-
-  const additionalLanguages = {
-    sgn: true, // Sign languages (macro language)
-    ase: true, // American sign language
-    asq: true, // Austrian sign language
-    sdl: true, // Arabian sign language
-    bfi: true, // British sign language
-    bzs: true, // Brazilian sign language
-    csl: true, // Chinese sign language
-    cse: true, // Czech sign language
-    dsl: true, // Danish sign language
-    fsl: true, // French sign language
-    gsg: true, // German sign language
-    pks: true, // Pakistan sign language
-    jsl: true, // Japanese sign language
-    sfs: true, // South African sign language
-    swl: true, // Swedish sign language
-    rsl: true, // Russian sign language
-
-    kab: true, // Kabyle
-
-    lat: true, // Latin
-
-    epo: true, // Esperanto
-    tlh: true, // Klingon
-    jbo: true, // Lojban
-    avk: true, // Kotava
-
-    zxx: true // No linguistic content (ISO-639-2)
-  }
-
-  // Only add ISO639-1 languages and some sign languages (ISO639-3)
-  iso639
-    .filter(l => {
-      return (l.iso6391 !== undefined && l.type === 'living') ||
-        additionalLanguages[l.iso6393] === true
-    })
-    .forEach(l => { languages[l.iso6391 || l.iso6393] = l.name })
-
-  // Override Occitan label
-  languages['oc'] = 'Occitan'
-  languages['el'] = 'Greek'
-  languages['tok'] = 'Toki Pona'
-
-  // Chinese languages
-  languages['zh-Hans'] = 'Simplified Chinese'
-  languages['zh-Hant'] = 'Traditional Chinese'
-
-  return languages
-}
-
-function generateContentHash () {
-  return randomBytes(20).toString('hex')
-}
-
-function getIntEnv (path: string) {
-  if (process.env[path]) return parseInt(process.env[path])
-
-  return undefined
-}
diff --git a/server/initializers/database.ts b/server/initializers/database.ts
deleted file mode 100644
index bc120e398..000000000
--- a/server/initializers/database.ts
+++ /dev/null
@@ -1,233 +0,0 @@
-import { QueryTypes, Transaction } from 'sequelize'
-import { Sequelize as SequelizeTypescript } from 'sequelize-typescript'
-import { ActorCustomPageModel } from '@server/models/account/actor-custom-page'
-import { RunnerModel } from '@server/models/runner/runner'
-import { RunnerJobModel } from '@server/models/runner/runner-job'
-import { RunnerRegistrationTokenModel } from '@server/models/runner/runner-registration-token'
-import { TrackerModel } from '@server/models/server/tracker'
-import { VideoTrackerModel } from '@server/models/server/video-tracker'
-import { UserModel } from '@server/models/user/user'
-import { UserNotificationModel } from '@server/models/user/user-notification'
-import { UserRegistrationModel } from '@server/models/user/user-registration'
-import { UserVideoHistoryModel } from '@server/models/user/user-video-history'
-import { StoryboardModel } from '@server/models/video/storyboard'
-import { VideoChannelSyncModel } from '@server/models/video/video-channel-sync'
-import { VideoJobInfoModel } from '@server/models/video/video-job-info'
-import { VideoLiveReplaySettingModel } from '@server/models/video/video-live-replay-setting'
-import { VideoLiveSessionModel } from '@server/models/video/video-live-session'
-import { VideoSourceModel } from '@server/models/video/video-source'
-import { LocalVideoViewerModel } from '@server/models/view/local-video-viewer'
-import { LocalVideoViewerWatchSectionModel } from '@server/models/view/local-video-viewer-watch-section'
-import { isTestOrDevInstance } from '../helpers/core-utils'
-import { logger } from '../helpers/logger'
-import { AbuseModel } from '../models/abuse/abuse'
-import { AbuseMessageModel } from '../models/abuse/abuse-message'
-import { VideoAbuseModel } from '../models/abuse/video-abuse'
-import { VideoCommentAbuseModel } from '../models/abuse/video-comment-abuse'
-import { AccountModel } from '../models/account/account'
-import { AccountBlocklistModel } from '../models/account/account-blocklist'
-import { AccountVideoRateModel } from '../models/account/account-video-rate'
-import { ActorModel } from '../models/actor/actor'
-import { ActorFollowModel } from '../models/actor/actor-follow'
-import { ActorImageModel } from '../models/actor/actor-image'
-import { ApplicationModel } from '../models/application/application'
-import { OAuthClientModel } from '../models/oauth/oauth-client'
-import { OAuthTokenModel } from '../models/oauth/oauth-token'
-import { VideoRedundancyModel } from '../models/redundancy/video-redundancy'
-import { PluginModel } from '../models/server/plugin'
-import { ServerModel } from '../models/server/server'
-import { ServerBlocklistModel } from '../models/server/server-blocklist'
-import { UserNotificationSettingModel } from '../models/user/user-notification-setting'
-import { ScheduleVideoUpdateModel } from '../models/video/schedule-video-update'
-import { TagModel } from '../models/video/tag'
-import { ThumbnailModel } from '../models/video/thumbnail'
-import { VideoModel } from '../models/video/video'
-import { VideoBlacklistModel } from '../models/video/video-blacklist'
-import { VideoCaptionModel } from '../models/video/video-caption'
-import { VideoChangeOwnershipModel } from '../models/video/video-change-ownership'
-import { VideoChannelModel } from '../models/video/video-channel'
-import { VideoCommentModel } from '../models/video/video-comment'
-import { VideoFileModel } from '../models/video/video-file'
-import { VideoImportModel } from '../models/video/video-import'
-import { VideoLiveModel } from '../models/video/video-live'
-import { VideoPlaylistModel } from '../models/video/video-playlist'
-import { VideoPlaylistElementModel } from '../models/video/video-playlist-element'
-import { VideoShareModel } from '../models/video/video-share'
-import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
-import { VideoTagModel } from '../models/video/video-tag'
-import { VideoViewModel } from '../models/view/video-view'
-import { CONFIG } from './config'
-import { VideoPasswordModel } from '@server/models/video/video-password'
-
-require('pg').defaults.parseInt8 = true // Avoid BIGINT to be converted to string
-
-const dbname = CONFIG.DATABASE.DBNAME
-const username = CONFIG.DATABASE.USERNAME
-const password = CONFIG.DATABASE.PASSWORD
-const host = CONFIG.DATABASE.HOSTNAME
-const port = CONFIG.DATABASE.PORT
-const poolMax = CONFIG.DATABASE.POOL.MAX
-
-let dialectOptions: any = {}
-
-if (CONFIG.DATABASE.SSL) {
-  dialectOptions = {
-    ssl: {
-      rejectUnauthorized: false
-    }
-  }
-}
-
-const sequelizeTypescript = new SequelizeTypescript({
-  database: dbname,
-  dialect: 'postgres',
-  dialectOptions,
-  host,
-  port,
-  username,
-  password,
-  pool: {
-    max: poolMax
-  },
-  benchmark: isTestOrDevInstance(),
-  isolationLevel: Transaction.ISOLATION_LEVELS.SERIALIZABLE,
-  logging: (message: string, benchmark: number) => {
-    if (process.env.NODE_DB_LOG === 'false') return
-
-    let newMessage = 'Executed SQL request'
-    if (isTestOrDevInstance() === true && benchmark !== undefined) {
-      newMessage += ' in ' + benchmark + 'ms'
-    }
-
-    logger.debug(newMessage, { sql: message, tags: [ 'sql' ] })
-  }
-})
-
-function checkDatabaseConnectionOrDie () {
-  sequelizeTypescript.authenticate()
-    .then(() => logger.debug('Connection to PostgreSQL has been established successfully.'))
-    .catch(err => {
-
-      logger.error('Unable to connect to PostgreSQL database.', { err })
-      process.exit(-1)
-    })
-}
-
-async function initDatabaseModels (silent: boolean) {
-  sequelizeTypescript.addModels([
-    ApplicationModel,
-    ActorModel,
-    ActorFollowModel,
-    ActorImageModel,
-    AccountModel,
-    OAuthClientModel,
-    OAuthTokenModel,
-    ServerModel,
-    TagModel,
-    AccountVideoRateModel,
-    UserModel,
-    AbuseMessageModel,
-    AbuseModel,
-    VideoCommentAbuseModel,
-    VideoAbuseModel,
-    VideoModel,
-    VideoChangeOwnershipModel,
-    VideoChannelModel,
-    VideoShareModel,
-    VideoFileModel,
-    VideoSourceModel,
-    VideoCaptionModel,
-    VideoBlacklistModel,
-    VideoTagModel,
-    VideoCommentModel,
-    ScheduleVideoUpdateModel,
-    VideoImportModel,
-    VideoViewModel,
-    VideoRedundancyModel,
-    UserVideoHistoryModel,
-    VideoLiveModel,
-    VideoLiveSessionModel,
-    VideoLiveReplaySettingModel,
-    AccountBlocklistModel,
-    ServerBlocklistModel,
-    UserNotificationModel,
-    UserNotificationSettingModel,
-    VideoStreamingPlaylistModel,
-    VideoPlaylistModel,
-    VideoPlaylistElementModel,
-    LocalVideoViewerModel,
-    LocalVideoViewerWatchSectionModel,
-    ThumbnailModel,
-    TrackerModel,
-    VideoTrackerModel,
-    PluginModel,
-    ActorCustomPageModel,
-    VideoJobInfoModel,
-    VideoChannelSyncModel,
-    UserRegistrationModel,
-    VideoPasswordModel,
-    RunnerRegistrationTokenModel,
-    RunnerModel,
-    RunnerJobModel,
-    StoryboardModel
-  ])
-
-  // Check extensions exist in the database
-  await checkPostgresExtensions()
-
-  // Create custom PostgreSQL functions
-  await createFunctions()
-
-  if (!silent) logger.info('Database %s is ready.', dbname)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  initDatabaseModels,
-  checkDatabaseConnectionOrDie,
-  sequelizeTypescript
-}
-
-// ---------------------------------------------------------------------------
-
-async function checkPostgresExtensions () {
-  const promises = [
-    checkPostgresExtension('pg_trgm'),
-    checkPostgresExtension('unaccent')
-  ]
-
-  return Promise.all(promises)
-}
-
-async function checkPostgresExtension (extension: string) {
-  const query = `SELECT 1 FROM pg_available_extensions WHERE name = '${extension}' AND installed_version IS NOT NULL;`
-  const options = {
-    type: QueryTypes.SELECT as QueryTypes.SELECT,
-    raw: true
-  }
-
-  const res = await sequelizeTypescript.query<object>(query, options)
-
-  if (!res || res.length === 0) {
-    // Try to create the extension ourselves
-    try {
-      await sequelizeTypescript.query(`CREATE EXTENSION ${extension};`, { raw: true })
-
-    } catch {
-      const errorMessage = `You need to enable ${extension} extension in PostgreSQL. ` +
-        `You can do so by running 'CREATE EXTENSION ${extension};' as a PostgreSQL super user in ${CONFIG.DATABASE.DBNAME} database.`
-      throw new Error(errorMessage)
-    }
-  }
-}
-
-function createFunctions () {
-  const query = `CREATE OR REPLACE FUNCTION immutable_unaccent(text)
-  RETURNS text AS
-$func$
-SELECT public.unaccent('public.unaccent', $1::text)
-$func$  LANGUAGE sql IMMUTABLE;`
-
-  return sequelizeTypescript.query(query, { raw: true })
-}
diff --git a/server/initializers/installer.ts b/server/initializers/installer.ts
deleted file mode 100644
index 2406a5936..000000000
--- a/server/initializers/installer.ts
+++ /dev/null
@@ -1,199 +0,0 @@
-import { ensureDir, readdir, remove } from 'fs-extra'
-import passwordGenerator from 'password-generator'
-import { join } from 'path'
-import { isTestOrDevInstance } from '@server/helpers/core-utils'
-import { generateRunnerRegistrationToken } from '@server/helpers/token-generator'
-import { getNodeABIVersion } from '@server/helpers/version'
-import { RunnerRegistrationTokenModel } from '@server/models/runner/runner-registration-token'
-import { UserRole } from '@shared/models'
-import { logger } from '../helpers/logger'
-import { buildUser, createApplicationActor, createUserAccountAndChannelAndPlaylist } from '../lib/user'
-import { ApplicationModel } from '../models/application/application'
-import { OAuthClientModel } from '../models/oauth/oauth-client'
-import { applicationExist, clientsExist, usersExist } from './checker-after-init'
-import { CONFIG } from './config'
-import { DIRECTORIES, FILES_CACHE, LAST_MIGRATION_VERSION } from './constants'
-import { sequelizeTypescript } from './database'
-
-async function installApplication () {
-  try {
-    await Promise.all([
-      // Database related
-      sequelizeTypescript.sync()
-        .then(() => {
-          return Promise.all([
-            createApplicationIfNotExist(),
-            createOAuthClientIfNotExist(),
-            createOAuthAdminIfNotExist(),
-            createRunnerRegistrationTokenIfNotExist()
-          ])
-        }),
-
-      // Directories
-      removeCacheAndTmpDirectories()
-        .then(() => createDirectoriesIfNotExist())
-    ])
-  } catch (err) {
-    logger.error('Cannot install application.', { err })
-    process.exit(-1)
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  installApplication
-}
-
-// ---------------------------------------------------------------------------
-
-function removeCacheAndTmpDirectories () {
-  const cacheDirectories = Object.keys(FILES_CACHE)
-    .map(k => FILES_CACHE[k].DIRECTORY)
-
-  const tasks: Promise<any>[] = []
-
-  // Cache directories
-  for (const dir of cacheDirectories) {
-    tasks.push(removeDirectoryOrContent(dir))
-  }
-
-  tasks.push(removeDirectoryOrContent(CONFIG.STORAGE.TMP_DIR))
-
-  return Promise.all(tasks)
-}
-
-async function removeDirectoryOrContent (dir: string) {
-  try {
-    await remove(dir)
-  } catch (err) {
-    logger.debug('Cannot remove directory %s. Removing content instead.', dir, { err })
-
-    const files = await readdir(dir)
-
-    for (const file of files) {
-      await remove(join(dir, file))
-    }
-  }
-}
-
-function createDirectoriesIfNotExist () {
-  const storage = CONFIG.STORAGE
-  const cacheDirectories = Object.keys(FILES_CACHE)
-                                 .map(k => FILES_CACHE[k].DIRECTORY)
-
-  const tasks: Promise<void>[] = []
-  for (const key of Object.keys(storage)) {
-    const dir = storage[key]
-    tasks.push(ensureDir(dir))
-  }
-
-  // Cache directories
-  for (const dir of cacheDirectories) {
-    tasks.push(ensureDir(dir))
-  }
-
-  tasks.push(ensureDir(DIRECTORIES.HLS_STREAMING_PLAYLIST.PRIVATE))
-  tasks.push(ensureDir(DIRECTORIES.HLS_STREAMING_PLAYLIST.PUBLIC))
-  tasks.push(ensureDir(DIRECTORIES.VIDEOS.PUBLIC))
-  tasks.push(ensureDir(DIRECTORIES.VIDEOS.PRIVATE))
-
-  // Resumable upload directory
-  tasks.push(ensureDir(DIRECTORIES.RESUMABLE_UPLOAD))
-
-  return Promise.all(tasks)
-}
-
-async function createOAuthClientIfNotExist () {
-  const exist = await clientsExist()
-  // Nothing to do, clients already exist
-  if (exist === true) return undefined
-
-  logger.info('Creating a default OAuth Client.')
-
-  const id = passwordGenerator(32, false, /[a-z0-9]/)
-  const secret = passwordGenerator(32, false, /[a-zA-Z0-9]/)
-  const client = new OAuthClientModel({
-    clientId: id,
-    clientSecret: secret,
-    grants: [ 'password', 'refresh_token' ],
-    redirectUris: null
-  })
-
-  const createdClient = await client.save()
-  logger.info('Client id: ' + createdClient.clientId)
-  logger.info('Client secret: ' + createdClient.clientSecret)
-
-  return undefined
-}
-
-async function createOAuthAdminIfNotExist () {
-  const exist = await usersExist()
-  // Nothing to do, users already exist
-  if (exist === true) return undefined
-
-  logger.info('Creating the administrator.')
-
-  const username = 'root'
-  const role = UserRole.ADMINISTRATOR
-  const email = CONFIG.ADMIN.EMAIL
-  let validatePassword = true
-  let password = ''
-
-  // Do not generate a random password for test and dev environments
-  if (isTestOrDevInstance()) {
-    password = 'test'
-
-    if (process.env.NODE_APP_INSTANCE) {
-      password += process.env.NODE_APP_INSTANCE
-    }
-
-    // Our password is weak so do not validate it
-    validatePassword = false
-  } else if (process.env.PT_INITIAL_ROOT_PASSWORD) {
-    password = process.env.PT_INITIAL_ROOT_PASSWORD
-  } else {
-    password = passwordGenerator(16, true)
-  }
-
-  const user = buildUser({
-    username,
-    email,
-    password,
-    role,
-    emailVerified: true,
-    videoQuota: -1,
-    videoQuotaDaily: -1
-  })
-
-  await createUserAccountAndChannelAndPlaylist({ userToCreate: user, channelNames: undefined, validateUser: validatePassword })
-  logger.info('Username: ' + username)
-  logger.info('User password: ' + password)
-}
-
-async function createApplicationIfNotExist () {
-  const exist = await applicationExist()
-  // Nothing to do, application already exist
-  if (exist === true) return undefined
-
-  logger.info('Creating application account.')
-
-  const application = await ApplicationModel.create({
-    migrationVersion: LAST_MIGRATION_VERSION,
-    nodeVersion: process.version,
-    nodeABIVersion: getNodeABIVersion()
-  })
-
-  return createApplicationActor(application.id)
-}
-
-async function createRunnerRegistrationTokenIfNotExist () {
-  const total = await RunnerRegistrationTokenModel.countTotal()
-  if (total !== 0) return undefined
-
-  const token = new RunnerRegistrationTokenModel({
-    registrationToken: generateRunnerRegistrationToken()
-  })
-
-  await token.save()
-}
diff --git a/server/initializers/migrations/0505-user-last-login-date.ts b/server/initializers/migrations/0505-user-last-login-date.ts
deleted file mode 100644
index 29d970802..000000000
--- a/server/initializers/migrations/0505-user-last-login-date.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-
-  {
-    const field = {
-      type: Sequelize.DATE,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('user', 'lastLoginDate', field)
-  }
-
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0510-video-file-metadata.ts b/server/initializers/migrations/0510-video-file-metadata.ts
deleted file mode 100644
index be9feb47a..000000000
--- a/server/initializers/migrations/0510-video-file-metadata.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-
-  // We made a mistake with the migration in 2.2.0-rc.1
-  // Docker containers did not include this migration file
-  // So we check the table definition and add the column if it does not exist
-  const tableDefinition = await utils.queryInterface.describeTable('videoFile')
-
-  if (!tableDefinition['metadata']) {
-    const metadata = {
-      type: Sequelize.JSONB,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('videoFile', 'metadata', metadata)
-  }
-
-  if (!tableDefinition['metadataUrl']) {
-    const metadataUrl = {
-      type: Sequelize.STRING,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('videoFile', 'metadataUrl', metadataUrl)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0515-video-abuse-reason-timestamps.ts b/server/initializers/migrations/0515-video-abuse-reason-timestamps.ts
deleted file mode 100644
index c58335617..000000000
--- a/server/initializers/migrations/0515-video-abuse-reason-timestamps.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  await utils.queryInterface.addColumn('videoAbuse', 'predefinedReasons', {
-    type: Sequelize.ARRAY(Sequelize.INTEGER),
-    allowNull: true
-  })
-
-  await utils.queryInterface.addColumn('videoAbuse', 'startAt', {
-    type: Sequelize.INTEGER,
-    allowNull: true
-  })
-
-  await utils.queryInterface.addColumn('videoAbuse', 'endAt', {
-    type: Sequelize.INTEGER,
-    allowNull: true
-  })
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0520-abuses-split.ts b/server/initializers/migrations/0520-abuses-split.ts
deleted file mode 100644
index 136d5c2b2..000000000
--- a/server/initializers/migrations/0520-abuses-split.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  await utils.queryInterface.renameTable('videoAbuse', 'abuse')
-
-  await utils.sequelize.query(`
-    ALTER TABLE "abuse"
-    ADD COLUMN "flaggedAccountId" INTEGER REFERENCES "account" ("id") ON DELETE SET NULL ON UPDATE CASCADE
-  `)
-
-  await utils.sequelize.query(`
-    UPDATE "abuse" SET "videoId" = NULL
-    WHERE "videoId" NOT IN (SELECT "id" FROM "video")
-  `)
-
-  await utils.sequelize.query(`
-    UPDATE "abuse" SET "flaggedAccountId" = "videoChannel"."accountId"
-    FROM "video" INNER JOIN "videoChannel" ON "video"."channelId" = "videoChannel"."id"
-    WHERE "abuse"."videoId" = "video"."id"
-  `)
-
-  await utils.sequelize.query('DROP INDEX IF EXISTS video_abuse_video_id;')
-  await utils.sequelize.query('DROP INDEX IF EXISTS video_abuse_reporter_account_id;')
-
-  await utils.sequelize.query(`
-    CREATE TABLE IF NOT EXISTS "videoAbuse" (
-      "id" serial,
-      "startAt" integer DEFAULT NULL,
-      "endAt" integer DEFAULT NULL,
-      "deletedVideo" jsonb DEFAULT NULL,
-      "abuseId" integer NOT NULL REFERENCES "abuse" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "videoId" integer REFERENCES "video" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-      "createdAt" TIMESTAMP WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-  `)
-
-  await utils.sequelize.query(`
-    CREATE TABLE IF NOT EXISTS "commentAbuse" (
-      "id" serial,
-      "abuseId" integer NOT NULL REFERENCES "abuse" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "videoCommentId" integer REFERENCES "videoComment" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-      "createdAt" timestamp WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-  `)
-
-  await utils.sequelize.query(`
-      INSERT INTO "videoAbuse" ("startAt", "endAt", "deletedVideo", "abuseId", "videoId", "createdAt", "updatedAt")
-      SELECT "abuse"."startAt", "abuse"."endAt", "abuse"."deletedVideo", "abuse"."id", "abuse"."videoId",
-      "abuse"."createdAt", "abuse"."updatedAt"
-      FROM "abuse"
-  `)
-
-  await utils.queryInterface.removeColumn('abuse', 'startAt')
-  await utils.queryInterface.removeColumn('abuse', 'endAt')
-  await utils.queryInterface.removeColumn('abuse', 'deletedVideo')
-  await utils.queryInterface.removeColumn('abuse', 'videoId')
-
-  await utils.sequelize.query('DROP INDEX IF EXISTS user_notification_video_abuse_id')
-  await utils.queryInterface.renameColumn('userNotification', 'videoAbuseId', 'abuseId')
-
-  await utils.sequelize.query(
-    'ALTER INDEX IF EXISTS "videoAbuse_pkey" RENAME TO "abuse_pkey"'
-  )
-
-  await utils.queryInterface.renameColumn('userNotificationSetting', 'videoAbuseAsModerator', 'abuseAsModerator')
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0525-abuse-messages.ts b/server/initializers/migrations/0525-abuse-messages.ts
deleted file mode 100644
index c8fd7cbcf..000000000
--- a/server/initializers/migrations/0525-abuse-messages.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  await utils.sequelize.query(`
-    CREATE TABLE IF NOT EXISTS "abuseMessage" (
-      "id" serial,
-      "message" text NOT NULL,
-      "byModerator" boolean NOT NULL,
-      "accountId" integer REFERENCES "account" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-      "abuseId" integer NOT NULL REFERENCES "abuse" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-  `)
-
-  const notificationSettingColumns = [ 'abuseStateChange', 'abuseNewMessage' ]
-
-  for (const column of notificationSettingColumns) {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('userNotificationSetting', column, data)
-  }
-
-  {
-    const query = 'UPDATE "userNotificationSetting" SET "abuseStateChange" = 3, "abuseNewMessage" = 3'
-    await utils.sequelize.query(query)
-  }
-
-  for (const column of notificationSettingColumns) {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: false
-    }
-    await utils.queryInterface.changeColumn('userNotificationSetting', column, data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0530-playlist-multiple-video.ts b/server/initializers/migrations/0530-playlist-multiple-video.ts
deleted file mode 100644
index 51a8c06b0..000000000
--- a/server/initializers/migrations/0530-playlist-multiple-video.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import * as Sequelize from 'sequelize'
-import { WEBSERVER } from '../constants'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const field = {
-      type: Sequelize.STRING,
-      allowNull: true
-    }
-    await utils.queryInterface.changeColumn('videoPlaylistElement', 'url', field)
-  }
-
-  {
-    await utils.sequelize.query('DROP INDEX IF EXISTS video_playlist_element_video_playlist_id_video_id;')
-  }
-
-  {
-    const selectPlaylistUUID = 'SELECT "uuid" FROM "videoPlaylist" WHERE "id" = "videoPlaylistElement"."videoPlaylistId"'
-    const url = `'${WEBSERVER.URL}' || '/video-playlists/' || (${selectPlaylistUUID}) || '/videos/' || "videoPlaylistElement"."id"`
-
-    const query = `
-      UPDATE "videoPlaylistElement" SET "url" = ${url} WHERE id IN (
-        SELECT "videoPlaylistElement"."id" FROM "videoPlaylistElement"
-        INNER JOIN "videoPlaylist" ON "videoPlaylist".id = "videoPlaylistElement"."videoPlaylistId"
-        INNER JOIN account ON account.id = "videoPlaylist"."ownerAccountId"
-        INNER JOIN actor ON actor.id = account."actorId"
-        WHERE actor."serverId" IS NULL
-      )`
-
-    await utils.sequelize.query(query)
-  }
-
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0535-video-live.ts b/server/initializers/migrations/0535-video-live.ts
deleted file mode 100644
index 7501e080b..000000000
--- a/server/initializers/migrations/0535-video-live.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "videoLive" (
-      "id"   SERIAL ,
-      "streamKey" VARCHAR(255),
-      "videoId" INTEGER NOT NULL REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-      "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-
-    await utils.sequelize.query(query)
-  }
-
-  {
-    await utils.queryInterface.addColumn('video', 'isLive', {
-      type: Sequelize.BOOLEAN,
-      defaultValue: false,
-      allowNull: false
-    })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0540-video-file-infohash.ts b/server/initializers/migrations/0540-video-file-infohash.ts
deleted file mode 100644
index 550178dab..000000000
--- a/server/initializers/migrations/0540-video-file-infohash.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.STRING,
-      defaultValue: null,
-      allowNull: true
-    }
-
-    await utils.queryInterface.changeColumn('videoFile', 'infoHash', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0545-video-live-save-replay.ts b/server/initializers/migrations/0545-video-live-save-replay.ts
deleted file mode 100644
index b79a406a4..000000000
--- a/server/initializers/migrations/0545-video-live-save-replay.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      defaultValue: false,
-      allowNull: false
-    }
-
-    await utils.queryInterface.addColumn('videoLive', 'saveReplay', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0550-actor-follow-cleanup.ts b/server/initializers/migrations/0550-actor-follow-cleanup.ts
deleted file mode 100644
index 8ba6feec2..000000000
--- a/server/initializers/migrations/0550-actor-follow-cleanup.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  const query = `
-    WITH t AS (
-      SELECT actor.id FROM actor
-      LEFT JOIN "videoChannel" ON "videoChannel"."actorId" = actor.id
-      LEFT JOIN account ON account."actorId" = "actor"."id"
-      WHERE "videoChannel".id IS NULL and "account".id IS NULL
-    ) DELETE FROM "actorFollow" WHERE "actorId" IN (SELECT t.id FROM t) OR "targetActorId" in (SELECT t.id FROM t)
-  `
-
-  await utils.sequelize.query(query)
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0555-actor-follow-url.ts b/server/initializers/migrations/0555-actor-follow-url.ts
deleted file mode 100644
index 36431507f..000000000
--- a/server/initializers/migrations/0555-actor-follow-url.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.STRING(2000),
-      defaultValue: null,
-      allowNull: true
-    }
-
-    await utils.queryInterface.addColumn('actorFollow', 'url', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0560-user-feed-token.ts b/server/initializers/migrations/0560-user-feed-token.ts
deleted file mode 100644
index 4c85b04f7..000000000
--- a/server/initializers/migrations/0560-user-feed-token.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import * as Sequelize from 'sequelize'
-import { buildUUID } from '@shared/extra-utils'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const q = utils.queryInterface
-
-  {
-    // Create uuid column for users
-    const userFeedTokenUUID = {
-      type: Sequelize.UUID,
-      defaultValue: Sequelize.UUIDV4,
-      allowNull: true
-    }
-    await q.addColumn('user', 'feedToken', userFeedTokenUUID)
-  }
-
-  // Set UUID to previous users
-  {
-    const query = 'SELECT * FROM "user" WHERE "feedToken" IS NULL'
-    const options = { type: Sequelize.QueryTypes.SELECT as Sequelize.QueryTypes.SELECT }
-    const users = await utils.sequelize.query<any>(query, options)
-
-    for (const user of users) {
-      const queryUpdate = `UPDATE "user" SET "feedToken" = '${buildUUID()}' WHERE id = ${user.id}`
-      await utils.sequelize.query(queryUpdate)
-    }
-  }
-
-  {
-    const userFeedTokenUUID = {
-      type: Sequelize.UUID,
-      defaultValue: Sequelize.UUIDV4,
-      allowNull: false
-    }
-    await q.changeColumn('user', 'feedToken', userFeedTokenUUID)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0565-actor-follow-local-url.ts b/server/initializers/migrations/0565-actor-follow-local-url.ts
deleted file mode 100644
index 779a59475..000000000
--- a/server/initializers/migrations/0565-actor-follow-local-url.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = `
-    UPDATE "actorFollow" SET url = follower.url || '/follows/' || following.id
-    FROM actor follower, actor following
-    WHERE follower."serverId" IS NULL AND follower.id = "actorFollow"."actorId" AND following.id = "actorFollow"."targetActorId"
-    `
-
-    await utils.sequelize.query(query)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0570-permanent-live.ts b/server/initializers/migrations/0570-permanent-live.ts
deleted file mode 100644
index 9572a9b2d..000000000
--- a/server/initializers/migrations/0570-permanent-live.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      defaultValue: false,
-      allowNull: false
-    }
-
-    await utils.queryInterface.addColumn('videoLive', 'permanentLive', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0575-duplicate-thumbnail.ts b/server/initializers/migrations/0575-duplicate-thumbnail.ts
deleted file mode 100644
index 4dbbe71d4..000000000
--- a/server/initializers/migrations/0575-duplicate-thumbnail.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = 'DELETE FROM "thumbnail" s1 ' +
-      'USING (SELECT MIN(id) as id, "filename", "type" FROM "thumbnail" GROUP BY "filename", "type" HAVING COUNT(*) > 1) s2 ' +
-      'WHERE s1."filename" = s2."filename" AND s1."type" = s2."type" AND s1.id <> s2.id'
-    await utils.sequelize.query(query)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0580-caption-filename.ts b/server/initializers/migrations/0580-caption-filename.ts
deleted file mode 100644
index 5281fd0c0..000000000
--- a/server/initializers/migrations/0580-caption-filename.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.STRING,
-      allowNull: true,
-      defaultValue: null
-    }
-
-    await utils.queryInterface.addColumn('videoCaption', 'filename', data)
-  }
-
-  {
-    const query = `UPDATE "videoCaption" SET "filename" = s.uuid || '-' || s.language || '.vtt' ` +
-    `FROM (` +
-    `  SELECT "videoCaption"."id", video.uuid, "videoCaption".language ` +
-    `  FROM "videoCaption" INNER JOIN video ON video.id = "videoCaption"."videoId"` +
-    `) AS s ` +
-    `WHERE "videoCaption".id = s.id`
-
-    await utils.sequelize.query(query)
-  }
-
-  {
-    const data = {
-      type: Sequelize.STRING,
-      allowNull: false,
-      defaultValue: null
-    }
-
-    await utils.queryInterface.changeColumn('videoCaption', 'filename', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0585-video-file-names.ts b/server/initializers/migrations/0585-video-file-names.ts
deleted file mode 100644
index dd5fec3a1..000000000
--- a/server/initializers/migrations/0585-video-file-names.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  for (const column of [ 'filename', 'fileUrl', 'torrentFilename', 'torrentUrl' ]) {
-    const data = {
-      type: Sequelize.STRING,
-      allowNull: true,
-      defaultValue: null
-    }
-
-    await utils.queryInterface.addColumn('videoFile', column, data)
-  }
-
-  // Generate filenames for webtorrent files
-  {
-    const webtorrentQuery = `SELECT "videoFile".id, "video".uuid, "videoFile".resolution, "videoFile".extname ` +
-    `FROM video INNER JOIN "videoFile" ON "videoFile"."videoId" = video.id`
-
-    const query = `UPDATE "videoFile" ` +
-                  `SET filename = t.uuid || '-' || t.resolution || t.extname, ` +
-                  `"torrentFilename" = t.uuid || '-' || t.resolution || '.torrent' ` +
-                  `FROM (${webtorrentQuery}) AS t WHERE t.id = "videoFile"."id"`
-
-    await utils.sequelize.query(query)
-  }
-
-  // Generate filenames for HLS files
-  {
-    const hlsQuery = `SELECT "videoFile".id, "video".uuid, "videoFile".resolution, "videoFile".extname ` +
-                     `FROM video ` +
-                     `INNER JOIN "videoStreamingPlaylist" ON "videoStreamingPlaylist"."videoId" = video.id ` +
-                     `INNER JOIN "videoFile" ON "videoFile"."videoStreamingPlaylistId" = "videoStreamingPlaylist".id`
-
-    const query = `UPDATE "videoFile" ` +
-                  `SET filename = t.uuid || '-' || t.resolution || '-fragmented' || t.extname, ` +
-                  `"torrentFilename" = t.uuid || '-' || t.resolution || '-hls.torrent' ` +
-                  `FROM (${hlsQuery}) AS t WHERE t.id = "videoFile"."id"`
-
-    await utils.sequelize.query(query)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0590-trackers.ts b/server/initializers/migrations/0590-trackers.ts
deleted file mode 100644
index 47b9022a3..000000000
--- a/server/initializers/migrations/0590-trackers.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = `CREATE TABLE IF NOT EXISTS "tracker" (
-      "id" serial,
-      "url" varchar(255) NOT NULL,
-      "createdAt" timestamp WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );`
-
-    await utils.sequelize.query(query)
-  }
-
-  {
-    const query = `CREATE TABLE IF NOT EXISTS "videoTracker" (
-      "videoId" integer REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "trackerId" integer REFERENCES "tracker" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      UNIQUE ("videoId", "trackerId"),
-      PRIMARY KEY ("videoId", "trackerId")
-    );`
-
-    await utils.sequelize.query(query)
-  }
-
-  await utils.sequelize.query(`CREATE UNIQUE INDEX "tracker_url" ON "tracker" ("url")`)
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0595-remote-url.ts b/server/initializers/migrations/0595-remote-url.ts
deleted file mode 100644
index 85b367555..000000000
--- a/server/initializers/migrations/0595-remote-url.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  // Torrent and file URLs
-  {
-    const fromQueryWebtorrent = `SELECT 'https://' || server.host AS "serverUrl", '/static/webseed/' AS "filePath", "videoFile".id ` +
-      `FROM video ` +
-      `INNER JOIN "videoChannel" ON "videoChannel".id = video."channelId" ` +
-      `INNER JOIN actor ON actor.id = "videoChannel"."actorId" ` +
-      `INNER JOIN server ON server.id = actor."serverId" ` +
-      `INNER JOIN "videoFile" ON "videoFile"."videoId" = video.id ` +
-      `WHERE video.remote IS TRUE`
-
-    const fromQueryHLS = `SELECT 'https://' || server.host AS "serverUrl", ` +
-      `'/static/streaming-playlists/hls/' || video.uuid || '/' AS "filePath", "videoFile".id ` +
-      `FROM video ` +
-      `INNER JOIN "videoChannel" ON "videoChannel".id = video."channelId" ` +
-      `INNER JOIN actor ON actor.id = "videoChannel"."actorId" ` +
-      `INNER JOIN server ON server.id = actor."serverId" ` +
-      `INNER JOIN "videoStreamingPlaylist" ON "videoStreamingPlaylist"."videoId" = video.id ` +
-      `INNER JOIN "videoFile" ON "videoFile"."videoStreamingPlaylistId" = "videoStreamingPlaylist".id ` +
-      `WHERE video.remote IS TRUE`
-
-    for (const fromQuery of [ fromQueryWebtorrent, fromQueryHLS ]) {
-      const query = `UPDATE "videoFile" ` +
-        `SET "torrentUrl" = t."serverUrl" || '/static/torrents/' || "videoFile"."torrentFilename", ` +
-        `"fileUrl" = t."serverUrl" || t."filePath" || "videoFile"."filename" ` +
-        `FROM (${fromQuery}) AS t WHERE t.id = "videoFile"."id" AND "videoFile"."fileUrl" IS NULL`
-
-      await utils.sequelize.query(query)
-    }
-  }
-
-  // Caption URLs
-  {
-    const fromQuery = `SELECT 'https://' || server.host AS "serverUrl", "video".uuid, "videoCaption".id ` +
-      `FROM video ` +
-      `INNER JOIN "videoChannel" ON "videoChannel".id = video."channelId" ` +
-      `INNER JOIN actor ON actor.id = "videoChannel"."actorId" ` +
-      `INNER JOIN server ON server.id = actor."serverId" ` +
-      `INNER JOIN "videoCaption" ON "videoCaption"."videoId" = video.id ` +
-      `WHERE video.remote IS TRUE`
-
-    const query = `UPDATE "videoCaption" ` +
-      `SET "fileUrl" = t."serverUrl" || '/lazy-static/video-captions/' || t.uuid || '-' || "videoCaption"."language" || '.vtt' ` +
-      `FROM (${fromQuery}) AS t WHERE t.id = "videoCaption"."id" AND "videoCaption"."fileUrl" IS NULL`
-
-    await utils.sequelize.query(query)
-  }
-
-  // Thumbnail URLs
-  {
-    const fromQuery = `SELECT 'https://' || server.host AS "serverUrl", "video".uuid, "thumbnail".id ` +
-      `FROM video ` +
-      `INNER JOIN "videoChannel" ON "videoChannel".id = video."channelId" ` +
-      `INNER JOIN actor ON actor.id = "videoChannel"."actorId" ` +
-      `INNER JOIN server ON server.id = actor."serverId" ` +
-      `INNER JOIN "thumbnail" ON "thumbnail"."videoId" = video.id ` +
-      `WHERE video.remote IS TRUE`
-
-    // Thumbnails
-    {
-      const query = `UPDATE "thumbnail" ` +
-        `SET "fileUrl" = t."serverUrl" || '/static/thumbnails/' || t.uuid || '.jpg' ` +
-        `FROM (${fromQuery}) AS t WHERE t.id = "thumbnail"."id" AND "thumbnail"."fileUrl" IS NULL AND thumbnail.type = 1`
-
-      await utils.sequelize.query(query)
-    }
-
-    {
-      // Previews
-      const query = `UPDATE "thumbnail" ` +
-        `SET "fileUrl" = t."serverUrl" || '/lazy-static/previews/' || t.uuid || '.jpg' ` +
-        `FROM (${fromQuery}) AS t WHERE t.id = "thumbnail"."id" AND "thumbnail"."fileUrl" IS NULL AND thumbnail.type = 2`
-
-      await utils.sequelize.query(query)
-    }
-  }
-
-  // Trackers
-  {
-    const trackerUrls = [
-      `'https://' || server.host  || '/tracker/announce'`,
-      `'wss://' || server.host  || '/tracker/socket'`
-    ]
-
-    for (const trackerUrl of trackerUrls) {
-      {
-        const query = `INSERT INTO "tracker" ("url", "createdAt", "updatedAt") ` +
-          `SELECT ${trackerUrl} AS "url", NOW(), NOW() ` +
-          `FROM video ` +
-          `INNER JOIN "videoChannel" ON "videoChannel".id = video."channelId" ` +
-          `INNER JOIN actor ON actor.id = "videoChannel"."actorId" ` +
-          `INNER JOIN server ON server.id = actor."serverId" ` +
-          `WHERE video.remote IS TRUE ` +
-          `ON CONFLICT DO NOTHING`
-
-        await utils.sequelize.query(query)
-      }
-
-      {
-        const query = `INSERT INTO "videoTracker" ("videoId", "trackerId", "createdAt", "updatedAt") ` +
-          `SELECT video.id, (SELECT tracker.id FROM tracker WHERE url = ${trackerUrl}) AS "trackerId", NOW(), NOW()` +
-          `FROM video ` +
-          `INNER JOIN "videoChannel" ON "videoChannel".id = video."channelId" ` +
-          `INNER JOIN actor ON actor.id = "videoChannel"."actorId" ` +
-          `INNER JOIN server ON server.id = actor."serverId" ` +
-          `WHERE video.remote IS TRUE`
-
-        await utils.sequelize.query(query)
-      }
-    }
-  }
-
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0600-duplicate-video-files.ts b/server/initializers/migrations/0600-duplicate-video-files.ts
deleted file mode 100644
index 92d774a79..000000000
--- a/server/initializers/migrations/0600-duplicate-video-files.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  {
-    const query = 'DELETE FROM "videoFile" f1 ' +
-      'USING (SELECT MIN(id) as id, "torrentFilename" FROM "videoFile" GROUP BY "torrentFilename" HAVING COUNT(*) > 1) f2 ' +
-      'WHERE f1."torrentFilename" = f2."torrentFilename" AND f1.id <> f2.id'
-    await utils.sequelize.query(query)
-  }
-
-  {
-    const query = 'DELETE FROM "videoFile" f1 ' +
-      'USING (SELECT MIN(id) as id, "filename" FROM "videoFile" GROUP BY "filename" HAVING COUNT(*) > 1) f2 ' +
-      'WHERE f1."filename" = f2."filename" AND f1.id <> f2.id'
-    await utils.sequelize.query(query)
-  }
-
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0605-actor-missing-keys.ts b/server/initializers/migrations/0605-actor-missing-keys.ts
deleted file mode 100644
index aa89a500c..000000000
--- a/server/initializers/migrations/0605-actor-missing-keys.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as Sequelize from 'sequelize'
-import { generateRSAKeyPairPromise } from '../../helpers/core-utils'
-import { PRIVATE_RSA_KEY_SIZE } from '../constants'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  {
-    const query = 'SELECT * FROM "actor" WHERE "serverId" IS NULL AND "publicKey" IS NULL'
-    const options = { type: Sequelize.QueryTypes.SELECT as Sequelize.QueryTypes.SELECT }
-    const actors = await utils.sequelize.query<any>(query, options)
-
-    for (const actor of actors) {
-      const { privateKey, publicKey } = await generateRSAKeyPairPromise(PRIVATE_RSA_KEY_SIZE)
-
-      const queryUpdate = `UPDATE "actor" SET "publicKey" = '${publicKey}', "privateKey" = '${privateKey}' WHERE id = ${actor.id}`
-      await utils.sequelize.query(queryUpdate)
-    }
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0610-views-index copy.ts b/server/initializers/migrations/0610-views-index copy.ts
deleted file mode 100644
index 02ee21172..000000000
--- a/server/initializers/migrations/0610-views-index copy.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  await utils.sequelize.query('DROP INDEX IF EXISTS video_views;')
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0612-captions-unique.ts b/server/initializers/migrations/0612-captions-unique.ts
deleted file mode 100644
index 368838a2a..000000000
--- a/server/initializers/migrations/0612-captions-unique.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  await utils.sequelize.query(
-    'DELETE FROM "videoCaption" v1 USING (SELECT MIN(id) as id, "filename" FROM "videoCaption" ' +
-    'GROUP BY "filename" HAVING COUNT(*) > 1) v2 WHERE v1."filename" = v2."filename" AND v1.id <> v2.id'
-  )
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0615-latest-versions-notification-settings.ts b/server/initializers/migrations/0615-latest-versions-notification-settings.ts
deleted file mode 100644
index 86bf56009..000000000
--- a/server/initializers/migrations/0615-latest-versions-notification-settings.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const notificationSettingColumns = [ 'newPeerTubeVersion', 'newPluginVersion' ]
-
-    for (const column of notificationSettingColumns) {
-      const data = {
-        type: Sequelize.INTEGER,
-        defaultValue: null,
-        allowNull: true
-      }
-      await utils.queryInterface.addColumn('userNotificationSetting', column, data)
-    }
-
-    {
-      const query = 'UPDATE "userNotificationSetting" SET "newPeerTubeVersion" = 3, "newPluginVersion" = 1'
-      await utils.sequelize.query(query)
-    }
-
-    for (const column of notificationSettingColumns) {
-      const data = {
-        type: Sequelize.INTEGER,
-        defaultValue: null,
-        allowNull: false
-      }
-      await utils.queryInterface.changeColumn('userNotificationSetting', column, data)
-    }
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0620-latest-versions-application.ts b/server/initializers/migrations/0620-latest-versions-application.ts
deleted file mode 100644
index a689b18fc..000000000
--- a/server/initializers/migrations/0620-latest-versions-application.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  {
-    const data = {
-      type: Sequelize.STRING,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('application', 'latestPeerTubeVersion', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0625-latest-versions-notification.ts b/server/initializers/migrations/0625-latest-versions-notification.ts
deleted file mode 100644
index 77f395ce4..000000000
--- a/server/initializers/migrations/0625-latest-versions-notification.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  {
-    await utils.sequelize.query(`
-      ALTER TABLE "userNotification"
-      ADD COLUMN "applicationId" INTEGER REFERENCES "application" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-      ADD COLUMN "pluginId" INTEGER REFERENCES "plugin" ("id") ON DELETE SET NULL ON UPDATE CASCADE
-    `)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0630-banner.ts b/server/initializers/migrations/0630-banner.ts
deleted file mode 100644
index 5766bb171..000000000
--- a/server/initializers/migrations/0630-banner.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-
-  {
-    await utils.sequelize.query(`ALTER TABLE "avatar" RENAME to "actorImage"`)
-  }
-
-  {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('actorImage', 'type', data)
-  }
-
-  {
-    await utils.sequelize.query(`UPDATE "actorImage" SET "type" = 1`)
-  }
-
-  {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: false
-    }
-    await utils.queryInterface.changeColumn('actorImage', 'type', data)
-  }
-
-  {
-    await utils.sequelize.query(
-      `ALTER TABLE "actor" ADD COLUMN "bannerId" INTEGER REFERENCES "actorImage" ("id") ON DELETE SET NULL ON UPDATE CASCADE`
-    )
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0635-actor-image-size.ts b/server/initializers/migrations/0635-actor-image-size.ts
deleted file mode 100644
index d7c5da8c3..000000000
--- a/server/initializers/migrations/0635-actor-image-size.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('actorImage', 'height', data)
-  }
-
-  {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('actorImage', 'width', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0640-unique-keys.ts b/server/initializers/migrations/0640-unique-keys.ts
deleted file mode 100644
index b082accc2..000000000
--- a/server/initializers/migrations/0640-unique-keys.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    await utils.sequelize.query(
-      'DELETE FROM "actor" v1 USING (SELECT MIN(id) as id, "preferredUsername", "serverId" FROM "actor" ' +
-      'GROUP BY "preferredUsername", "serverId" HAVING COUNT(*) > 1 AND "serverId" IS NOT NULL) v2 ' +
-      'WHERE v1."preferredUsername" = v2."preferredUsername" AND v1."serverId" = v2."serverId" AND v1.id <> v2.id'
-    )
-  }
-
-  {
-    await utils.sequelize.query(
-      'DELETE FROM "actor" v1 USING (SELECT MIN(id) as id, "url" FROM "actor" GROUP BY "url" HAVING COUNT(*) > 1) v2 ' +
-      'WHERE v1."url" = v2."url" AND v1.id <> v2.id'
-    )
-  }
-
-  {
-    await utils.sequelize.query(
-      'DELETE FROM "tag" v1 USING (SELECT MIN(id) as id, "name" FROM "tag" GROUP BY "name" HAVING COUNT(*) > 1) v2 ' +
-      'WHERE v1."name" = v2."name" AND v1.id <> v2.id'
-    )
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0645-actor-remote-creation-date.ts b/server/initializers/migrations/0645-actor-remote-creation-date.ts
deleted file mode 100644
index 38b3b881c..000000000
--- a/server/initializers/migrations/0645-actor-remote-creation-date.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.DATE,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('actor', 'remoteCreatedAt', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0650-actor-custom-pages.ts b/server/initializers/migrations/0650-actor-custom-pages.ts
deleted file mode 100644
index 1338327e8..000000000
--- a/server/initializers/migrations/0650-actor-custom-pages.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "actorCustomPage" (
-      "id" serial,
-      "content" TEXT,
-      "type" varchar(255) NOT NULL,
-      "actorId" integer NOT NULL REFERENCES "actor" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-
-    await utils.sequelize.query(query)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0655-streaming-playlist-filenames.ts b/server/initializers/migrations/0655-streaming-playlist-filenames.ts
deleted file mode 100644
index 9172a22c4..000000000
--- a/server/initializers/migrations/0655-streaming-playlist-filenames.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    for (const column of [ 'playlistUrl', 'segmentsSha256Url' ]) {
-      const data = {
-        type: Sequelize.STRING,
-        allowNull: true,
-        defaultValue: null
-      }
-
-      await utils.queryInterface.changeColumn('videoStreamingPlaylist', column, data)
-    }
-  }
-
-  {
-    await utils.sequelize.query(
-      `UPDATE "videoStreamingPlaylist" SET "playlistUrl" = NULL, "segmentsSha256Url" = NULL ` +
-      `WHERE "videoId" IN (SELECT id FROM video WHERE remote IS FALSE)`
-    )
-  }
-
-  {
-    for (const column of [ 'playlistFilename', 'segmentsSha256Filename' ]) {
-      const data = {
-        type: Sequelize.STRING,
-        allowNull: true,
-        defaultValue: null
-      }
-
-      await utils.queryInterface.addColumn('videoStreamingPlaylist', column, data)
-    }
-  }
-
-  {
-    await utils.sequelize.query(
-      `UPDATE "videoStreamingPlaylist" SET "playlistFilename" = 'master.m3u8', "segmentsSha256Filename" = 'segments-sha256.json'`
-    )
-  }
-
-  {
-    for (const column of [ 'playlistFilename', 'segmentsSha256Filename' ]) {
-      const data = {
-        type: Sequelize.STRING,
-        allowNull: false,
-        defaultValue: null
-      }
-
-      await utils.queryInterface.changeColumn('videoStreamingPlaylist', column, data)
-    }
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0660-object-storage.ts b/server/initializers/migrations/0660-object-storage.ts
deleted file mode 100644
index 53cb89ce6..000000000
--- a/server/initializers/migrations/0660-object-storage.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import * as Sequelize from 'sequelize'
-import { VideoStorage } from '@shared/models'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "videoJobInfo" (
-      "id" serial,
-      "pendingMove" INTEGER NOT NULL,
-      "pendingTranscode" INTEGER NOT NULL,
-      "videoId" serial UNIQUE NOT NULL REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp WITH time zone NOT NULL,
-      "updatedAt" timestamp WITH time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-
-    await utils.sequelize.query(query)
-  }
-
-  {
-    await utils.queryInterface.addColumn('videoFile', 'storage', {
-      type: Sequelize.INTEGER,
-      allowNull: true,
-      defaultValue: VideoStorage.FILE_SYSTEM
-    })
-    await utils.queryInterface.changeColumn('videoFile', 'storage', { type: Sequelize.INTEGER, allowNull: false, defaultValue: null })
-  }
-
-  {
-    await utils.queryInterface.addColumn('videoStreamingPlaylist', 'storage', {
-      type: Sequelize.INTEGER,
-      allowNull: true,
-      defaultValue: VideoStorage.FILE_SYSTEM
-    })
-    await utils.queryInterface.changeColumn('videoStreamingPlaylist', 'storage', {
-      type: Sequelize.INTEGER,
-      allowNull: false,
-      defaultValue: null
-    })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0665-no-account-warning-modal.ts b/server/initializers/migrations/0665-no-account-warning-modal.ts
deleted file mode 100644
index 6718aed85..000000000
--- a/server/initializers/migrations/0665-no-account-warning-modal.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      allowNull: false,
-      defaultValue: false
-    }
-
-    await utils.queryInterface.addColumn('user', 'noAccountSetupWarningModal', data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0670-pending-job-default.ts b/server/initializers/migrations/0670-pending-job-default.ts
deleted file mode 100644
index 7e9def1a0..000000000
--- a/server/initializers/migrations/0670-pending-job-default.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  for (const column of [ 'pendingMove', 'pendingTranscode' ]) {
-    const data = {
-      type: Sequelize.INTEGER,
-      allowNull: false,
-      defaultValue: 0
-    }
-
-    await utils.queryInterface.changeColumn('videoJobInfo', column, data)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0675-p2p-enabled.ts b/server/initializers/migrations/0675-p2p-enabled.ts
deleted file mode 100644
index b4f53381e..000000000
--- a/server/initializers/migrations/0675-p2p-enabled.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  await utils.queryInterface.renameColumn('user', 'webTorrentEnabled', 'p2pEnabled')
-
-  await utils.sequelize.query('ALTER TABLE "user" ALTER COLUMN "p2pEnabled" DROP DEFAULT')
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0680-files-storage-default.ts b/server/initializers/migrations/0680-files-storage-default.ts
deleted file mode 100644
index 087bc8790..000000000
--- a/server/initializers/migrations/0680-files-storage-default.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  await utils.sequelize.query('ALTER TABLE "videoFile" ALTER COLUMN "storage" SET DEFAULT 0')
-  await utils.sequelize.query('ALTER TABLE "videoStreamingPlaylist" ALTER COLUMN "storage" SET DEFAULT 0')
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0685-multiple-actor-images.ts b/server/initializers/migrations/0685-multiple-actor-images.ts
deleted file mode 100644
index c656f7e28..000000000
--- a/server/initializers/migrations/0685-multiple-actor-images.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    await utils.queryInterface.addColumn('actorImage', 'actorId', {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true,
-      references: {
-        model: 'actor',
-        key: 'id'
-      },
-      onDelete: 'CASCADE'
-    }, { transaction: utils.transaction })
-
-    // Avatars
-    {
-      const query = `UPDATE "actorImage" SET "actorId" = (SELECT "id" FROM "actor" WHERE "actor"."avatarId" = "actorImage"."id") ` +
-                    `WHERE "type" = 1`
-      await utils.sequelize.query(query, { type: Sequelize.QueryTypes.UPDATE, transaction: utils.transaction })
-    }
-
-    // Banners
-    {
-      const query = `UPDATE "actorImage" SET "actorId" = (SELECT "id" FROM "actor" WHERE "actor"."bannerId" = "actorImage"."id") ` +
-                    `WHERE "type" = 2`
-      await utils.sequelize.query(query, { type: Sequelize.QueryTypes.UPDATE, transaction: utils.transaction })
-    }
-
-    // Remove orphans
-    {
-      const query = `DELETE FROM "actorImage" WHERE id NOT IN (` +
-        `SELECT "bannerId" FROM actor WHERE "bannerId" IS NOT NULL ` +
-        `UNION select "avatarId" FROM actor WHERE "avatarId" IS NOT NULL` +
-      `);`
-
-      await utils.sequelize.query(query, { type: Sequelize.QueryTypes.DELETE, transaction: utils.transaction })
-    }
-
-    await utils.queryInterface.changeColumn('actorImage', 'actorId', {
-      type: Sequelize.INTEGER,
-      allowNull: false
-    }, { transaction: utils.transaction })
-
-    await utils.queryInterface.removeColumn('actor', 'avatarId', { transaction: utils.transaction })
-    await utils.queryInterface.removeColumn('actor', 'bannerId', { transaction: utils.transaction })
-  }
-}
-
-function down () {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0690-live-latency-mode.ts b/server/initializers/migrations/0690-live-latency-mode.ts
deleted file mode 100644
index c31a61364..000000000
--- a/server/initializers/migrations/0690-live-latency-mode.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { LiveVideoLatencyMode } from '@shared/models'
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  await utils.queryInterface.addColumn('videoLive', 'latencyMode', {
-    type: Sequelize.INTEGER,
-    defaultValue: null,
-    allowNull: true
-  }, { transaction: utils.transaction })
-
-  {
-    const query = `UPDATE "videoLive" SET "latencyMode" = ${LiveVideoLatencyMode.DEFAULT}`
-    await utils.sequelize.query(query, { type: Sequelize.QueryTypes.UPDATE, transaction: utils.transaction })
-  }
-
-  await utils.queryInterface.changeColumn('videoLive', 'latencyMode', {
-    type: Sequelize.INTEGER,
-    defaultValue: null,
-    allowNull: false
-  }, { transaction: utils.transaction })
-}
-
-function down () {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0695-remove-remote-rates.ts b/server/initializers/migrations/0695-remove-remote-rates.ts
deleted file mode 100644
index f5c394bae..000000000
--- a/server/initializers/migrations/0695-remove-remote-rates.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const query = 'DELETE FROM "accountVideoRate" ' +
-    'WHERE "accountVideoRate".id IN (' +
-      'SELECT "accountVideoRate".id FROM "accountVideoRate" ' +
-      'INNER JOIN account ON account.id = "accountVideoRate"."accountId" ' +
-      'INNER JOIN actor ON actor.id = account."actorId" ' +
-      'INNER JOIN video ON video.id = "accountVideoRate"."videoId" ' +
-      'WHERE actor."serverId" IS NOT NULL AND video.remote IS TRUE' +
-    ')'
-
-  await utils.sequelize.query(query, { type: Sequelize.QueryTypes.BULKDELETE, transaction: utils.transaction })
-}
-
-function down () {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0700-edition-finished-notification.ts b/server/initializers/migrations/0700-edition-finished-notification.ts
deleted file mode 100644
index 5310eab3f..000000000
--- a/server/initializers/migrations/0700-edition-finished-notification.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('userNotificationSetting', 'myVideoStudioEditionFinished', data, { transaction })
-  }
-
-  {
-    const query = 'UPDATE "userNotificationSetting" SET "myVideoStudioEditionFinished" = 1'
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const data = {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: false
-    }
-    await utils.queryInterface.changeColumn('userNotificationSetting', 'myVideoStudioEditionFinished', data, { transaction })
-  }
-}
-
-function down () {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0705-local-video-viewers.ts b/server/initializers/migrations/0705-local-video-viewers.ts
deleted file mode 100644
index 123402641..000000000
--- a/server/initializers/migrations/0705-local-video-viewers.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "localVideoViewer" (
-      "id" serial,
-      "startDate" timestamp with time zone NOT NULL,
-      "endDate" timestamp with time zone NOT NULL,
-      "watchTime" integer NOT NULL,
-      "country" varchar(255),
-      "uuid" uuid NOT NULL,
-      "url" varchar(255) NOT NULL,
-      "videoId" integer NOT NULL REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp with time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "localVideoViewerWatchSection" (
-      "id" serial,
-      "watchStart" integer NOT NULL,
-      "watchEnd" integer NOT NULL,
-      "localVideoViewerId" integer NOT NULL REFERENCES "localVideoViewer" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp with time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-    await utils.sequelize.query(query, { transaction })
-  }
-
-}
-
-function down () {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0710-live-sessions.ts b/server/initializers/migrations/0710-live-sessions.ts
deleted file mode 100644
index aaac8d9ce..000000000
--- a/server/initializers/migrations/0710-live-sessions.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  const query = `
-  CREATE TABLE IF NOT EXISTS "videoLiveSession" (
-    "id" serial,
-    "startDate" timestamp with time zone NOT NULL,
-    "endDate" timestamp with time zone,
-    "error" integer,
-    "replayVideoId" integer REFERENCES "video" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-    "liveVideoId" integer REFERENCES "video" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-    "createdAt" timestamp with time zone NOT NULL,
-    "updatedAt" timestamp with time zone NOT NULL,
-    PRIMARY KEY ("id")
-  );
-  `
-  await utils.sequelize.query(query, { transaction })
-}
-
-function down () {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0715-video-source.ts b/server/initializers/migrations/0715-video-source.ts
deleted file mode 100644
index efcf77ebd..000000000
--- a/server/initializers/migrations/0715-video-source.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = `
-      CREATE TABLE IF NOT EXISTS "videoSource" (
-        "id"  SERIAL ,
-        "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-        "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-        "filename" VARCHAR(255) DEFAULT NULL,
-        "videoId" INTEGER
-          REFERENCES "video" ("id")
-          ON DELETE CASCADE
-          ON UPDATE CASCADE,
-        PRIMARY KEY ("id")
-      );
-    `
-    await utils.sequelize.query(query)
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0720-session-ending-processed.ts b/server/initializers/migrations/0720-session-ending-processed.ts
deleted file mode 100644
index 74ffb39a0..000000000
--- a/server/initializers/migrations/0720-session-ending-processed.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('videoLiveSession', 'endingProcessed', data, { transaction })
-    await utils.queryInterface.addColumn('videoLiveSession', 'saveReplay', data, { transaction })
-  }
-
-  {
-    const query = `UPDATE "videoLiveSession" SET "saveReplay" = (
-      SELECT "videoLive"."saveReplay" FROM "videoLive" WHERE "videoLive"."videoId" = "videoLiveSession"."liveVideoId"
-    ) WHERE "videoLiveSession"."liveVideoId" IS NOT NULL`
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const query = `UPDATE "videoLiveSession" SET "saveReplay" = FALSE WHERE "saveReplay" IS NULL`
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const query = `UPDATE "videoLiveSession" SET "endingProcessed" = TRUE`
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      defaultValue: null,
-      allowNull: false
-    }
-    await utils.queryInterface.changeColumn('videoLiveSession', 'endingProcessed', data, { transaction })
-    await utils.queryInterface.changeColumn('videoLiveSession', 'saveReplay', data, { transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0725-node-version.ts b/server/initializers/migrations/0725-node-version.ts
deleted file mode 100644
index d8b9cc750..000000000
--- a/server/initializers/migrations/0725-node-version.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    const data = {
-      type: Sequelize.STRING,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('application', 'nodeVersion', data, { transaction })
-  }
-
-  {
-    const data = {
-      type: Sequelize.STRING,
-      defaultValue: null,
-      allowNull: true
-    }
-    await utils.queryInterface.addColumn('application', 'nodeABIVersion', data, { transaction })
-  }
-
-  {
-    const query = `UPDATE "application" SET "nodeVersion" = '${process.version}'`
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const nodeABIVersion = parseInt(process.versions.modules)
-    const query = `UPDATE "application" SET "nodeABIVersion" = ${nodeABIVersion}`
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const data = {
-      type: Sequelize.STRING,
-      defaultValue: null,
-      allowNull: false
-    }
-    await utils.queryInterface.changeColumn('application', 'nodeVersion', data, { transaction })
-  }
-
-  {
-    const data = {
-      type: Sequelize.STRING,
-      defaultValue: null,
-      allowNull: false
-    }
-    await utils.queryInterface.changeColumn('application', 'nodeABIVersion', data, { transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0730-video-channel-sync.ts b/server/initializers/migrations/0730-video-channel-sync.ts
deleted file mode 100644
index a2fe8211f..000000000
--- a/server/initializers/migrations/0730-video-channel-sync.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const query = `
-    CREATE TABLE IF NOT EXISTS "videoChannelSync" (
-      "id"   SERIAL,
-      "externalChannelUrl" VARCHAR(2000) NOT NULL DEFAULT NULL,
-      "videoChannelId" INTEGER NOT NULL REFERENCES "videoChannel" ("id")
-        ON DELETE CASCADE
-        ON UPDATE CASCADE,
-      "state" INTEGER NOT NULL DEFAULT 1,
-      "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-      "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-      "lastSyncAt" TIMESTAMP WITH TIME ZONE,
-      PRIMARY KEY ("id")
-    );
-  `
-  await utils.sequelize.query(query, { transaction: utils.transaction })
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-  await utils.queryInterface.dropTable('videoChannelSync', { transaction: utils.transaction })
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0735-video-channel-sync-import-foreign-key.ts b/server/initializers/migrations/0735-video-channel-sync-import-foreign-key.ts
deleted file mode 100644
index ffe0b11ab..000000000
--- a/server/initializers/migrations/0735-video-channel-sync-import-foreign-key.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  await utils.queryInterface.addColumn('videoImport', 'videoChannelSyncId', {
-    type: Sequelize.INTEGER,
-    defaultValue: null,
-    allowNull: true,
-    references: {
-      model: 'videoChannelSync',
-      key: 'id'
-    },
-    onUpdate: 'CASCADE',
-    onDelete: 'SET NULL'
-  }, { transaction: utils.transaction })
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-  await utils.queryInterface.dropTable('videoChannelSync', { transaction: utils.transaction })
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0740-fix-old-enums.ts b/server/initializers/migrations/0740-fix-old-enums.ts
deleted file mode 100644
index 501d0ccb2..000000000
--- a/server/initializers/migrations/0740-fix-old-enums.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  try {
-    await utils.sequelize.query('drop type "enum_actorFollow_state"')
-    await utils.sequelize.query('alter type "enum_AccountFollows_state" rename to "enum_actorFollow_state";')
-  } catch {
-    // empty
-  }
-
-  try {
-    await utils.sequelize.query('drop type "enum_accountVideoRate_type"')
-    await utils.sequelize.query('alter type "enum_AccountVideoRates_type" rename to "enum_accountVideoRate_type";')
-  } catch {
-    // empty
-  }
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0745-user-otp.ts b/server/initializers/migrations/0745-user-otp.ts
deleted file mode 100644
index 157308ea1..000000000
--- a/server/initializers/migrations/0745-user-otp.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  const data = {
-    type: Sequelize.STRING,
-    defaultValue: null,
-    allowNull: true
-  }
-  await utils.queryInterface.addColumn('user', 'otpSecret', data, { transaction })
-
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0750-user-registration.ts b/server/initializers/migrations/0750-user-registration.ts
deleted file mode 100644
index 15bbfd3fd..000000000
--- a/server/initializers/migrations/0750-user-registration.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  {
-    const query = `
-      CREATE TABLE IF NOT EXISTS "userRegistration" (
-        "id" serial,
-        "state" integer NOT NULL,
-        "registrationReason" text NOT NULL,
-        "moderationResponse" text,
-        "password" varchar(255),
-        "username" varchar(255) NOT NULL,
-        "email" varchar(400) NOT NULL,
-        "emailVerified" boolean,
-        "accountDisplayName" varchar(255),
-        "channelHandle" varchar(255),
-        "channelDisplayName" varchar(255),
-        "userId" integer REFERENCES "user" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
-        "createdAt" timestamp with time zone NOT NULL,
-        "updatedAt" timestamp with time zone NOT NULL,
-        PRIMARY KEY ("id")
-      );
-    `
-    await utils.sequelize.query(query, { transaction: utils.transaction })
-  }
-
-  {
-    await utils.queryInterface.addColumn('userNotification', 'userRegistrationId', {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true,
-      references: {
-        model: 'userRegistration',
-        key: 'id'
-      },
-      onUpdate: 'CASCADE',
-      onDelete: 'SET NULL'
-    }, { transaction: utils.transaction })
-  }
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-  await utils.queryInterface.dropTable('videoChannelSync', { transaction: utils.transaction })
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0755-unique-viewer-url.ts b/server/initializers/migrations/0755-unique-viewer-url.ts
deleted file mode 100644
index b3dff9258..000000000
--- a/server/initializers/migrations/0755-unique-viewer-url.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  const query = 'DELETE FROM "localVideoViewer" t1 ' +
-  'USING (SELECT MIN(id) as id, "url" FROM "localVideoViewer" GROUP BY "url" HAVING COUNT(*) > 1) t2 ' +
-  'WHERE t1."url" = t2."url" AND t1.id <> t2.id'
-
-  await utils.sequelize.query(query, { transaction })
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0760-video-live-replay-setting.ts b/server/initializers/migrations/0760-video-live-replay-setting.ts
deleted file mode 100644
index 7878df3f7..000000000
--- a/server/initializers/migrations/0760-video-live-replay-setting.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "videoLiveReplaySetting" (
-      "id"   SERIAL ,
-      "privacy" INTEGER NOT NULL,
-      "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-      "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-      PRIMARY KEY ("id")
-      );
-    `
-
-    await utils.sequelize.query(query, { transaction : utils.transaction })
-  }
-
-  {
-    await utils.queryInterface.addColumn('videoLive', 'replaySettingId', {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true,
-      references: {
-        model: 'videoLiveReplaySetting',
-        key: 'id'
-      },
-      onDelete: 'SET NULL'
-    }, { transaction: utils.transaction })
-  }
-
-  {
-    await utils.queryInterface.addColumn('videoLiveSession', 'replaySettingId', {
-      type: Sequelize.INTEGER,
-      defaultValue: null,
-      allowNull: true,
-      references: {
-        model: 'videoLiveReplaySetting',
-        key: 'id'
-      },
-      onDelete: 'SET NULL'
-    }, { transaction: utils.transaction })
-  }
-
-  {
-    const query = `
-    SELECT live."id", v."privacy"
-    FROM "videoLive" live
-    INNER JOIN "video" v ON live."videoId" = v."id"
-    WHERE live."saveReplay" = true
-    `
-
-    const videoLives = await utils.sequelize.query<{ id: number, privacy: number }>(
-      query,
-      { type: Sequelize.QueryTypes.SELECT, transaction: utils.transaction }
-    )
-
-    for (const videoLive of videoLives) {
-      const query = `
-      WITH new_replay_setting AS (
-        INSERT INTO "videoLiveReplaySetting" ("privacy", "createdAt", "updatedAt")
-        VALUES (:privacy, NOW(), NOW())
-        RETURNING id
-        )
-      UPDATE "videoLive" SET "replaySettingId" = (SELECT id FROM new_replay_setting)
-      WHERE "id" = :id
-      `
-
-      const options = {
-        replacements: { privacy: videoLive.privacy, id: videoLive.id },
-        type: Sequelize.QueryTypes.UPDATE,
-        transaction: utils.transaction
-      }
-
-      await utils.sequelize.query(query, options)
-    }
-  }
-
-  {
-    const query = `
-    SELECT session."id", v."privacy"
-    FROM "videoLiveSession" session
-    INNER JOIN "video" v ON session."liveVideoId" = v."id"
-    WHERE session."saveReplay" = true
-      AND session."liveVideoId" IS NOT NULL;
-    `
-
-    const videoLiveSessions = await utils.sequelize.query<{ id: number, privacy: number }>(
-      query,
-      { type: Sequelize.QueryTypes.SELECT, transaction: utils.transaction }
-    )
-
-    for (const videoLive of videoLiveSessions) {
-      const query = `
-      WITH new_replay_setting AS (
-        INSERT INTO "videoLiveReplaySetting" ("privacy", "createdAt", "updatedAt")
-        VALUES (:privacy, NOW(), NOW())
-        RETURNING id
-        )
-      UPDATE "videoLiveSession" SET "replaySettingId" = (SELECT id FROM new_replay_setting)
-      WHERE "id" = :id
-      `
-
-      const options = {
-        replacements: { privacy: videoLive.privacy, id: videoLive.id },
-        type: Sequelize.QueryTypes.UPDATE,
-        transaction: utils.transaction
-      }
-
-      await utils.sequelize.query(query, options)
-    }
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0765-remote-transcoding.ts b/server/initializers/migrations/0765-remote-transcoding.ts
deleted file mode 100644
index 40cca03b4..000000000
--- a/server/initializers/migrations/0765-remote-transcoding.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "runnerRegistrationToken"(
-      "id" serial,
-      "registrationToken" varchar(255) NOT NULL,
-      "createdAt" timestamp with time zone NOT NULL,
-      "updatedAt" timestamp with time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-
-    await utils.sequelize.query(query, { transaction : utils.transaction })
-  }
-
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "runner"(
-      "id" serial,
-      "runnerToken" varchar(255) NOT NULL,
-      "name" varchar(255) NOT NULL,
-      "description" varchar(1000),
-      "lastContact" timestamp with time zone NOT NULL,
-      "ip" varchar(255) NOT NULL,
-      "runnerRegistrationTokenId" integer REFERENCES "runnerRegistrationToken"("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "createdAt" timestamp with time zone NOT NULL,
-      "updatedAt" timestamp with time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-    `
-
-    await utils.sequelize.query(query, { transaction : utils.transaction })
-  }
-
-  {
-    const query = `
-    CREATE TABLE IF NOT EXISTS "runnerJob"(
-      "id" serial,
-      "uuid" uuid NOT NULL,
-      "type" varchar(255) NOT NULL,
-      "payload" jsonb NOT NULL,
-      "privatePayload" jsonb NOT NULL,
-      "state" integer NOT NULL,
-      "failures" integer NOT NULL DEFAULT 0,
-      "error" varchar(5000),
-      "priority" integer NOT NULL,
-      "processingJobToken" varchar(255),
-      "progress" integer,
-      "startedAt" timestamp with time zone,
-      "finishedAt" timestamp with time zone,
-      "dependsOnRunnerJobId" integer REFERENCES "runnerJob"("id") ON DELETE CASCADE ON UPDATE CASCADE,
-      "runnerId" integer REFERENCES "runner"("id") ON DELETE SET NULL ON UPDATE CASCADE,
-      "createdAt" timestamp with time zone NOT NULL,
-      "updatedAt" timestamp with time zone NOT NULL,
-      PRIMARY KEY ("id")
-    );
-
-
-    `
-
-    await utils.sequelize.query(query, { transaction : utils.transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0770-actor-preferred-username.ts b/server/initializers/migrations/0770-actor-preferred-username.ts
deleted file mode 100644
index 217813f7f..000000000
--- a/server/initializers/migrations/0770-actor-preferred-username.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-  db: any
-}): Promise<void> {
-  const { transaction } = utils
-
-  await utils.sequelize.query('drop index if exists "actor_preferred_username"', { transaction })
-  await utils.sequelize.query('drop index if exists "actor_preferred_username_server_id"', { transaction })
-
-  await utils.sequelize.query(
-    'DELETE FROM "actor" v1 USING (' +
-      'SELECT MIN(id) as id, lower("preferredUsername") AS "lowerPreferredUsername", "serverId" ' +
-      'FROM "actor" ' +
-      'GROUP BY "lowerPreferredUsername", "serverId" HAVING COUNT(*) > 1 AND "serverId" IS NOT NULL' +
-    ') v2 ' +
-    'WHERE lower(v1."preferredUsername") = v2."lowerPreferredUsername" AND v1."serverId" = v2."serverId" AND v1.id <> v2.id',
-    { transaction }
-  )
-
-  await utils.sequelize.query(
-    'DELETE FROM "actor" v1 USING (' +
-      'SELECT MIN(id) as id, lower("preferredUsername") AS "lowerPreferredUsername", "serverId" ' +
-      'FROM "actor" ' +
-      'GROUP BY "lowerPreferredUsername", "serverId" HAVING COUNT(*) > 1 AND "serverId" IS NULL' +
-    ') v2 ' +
-    'WHERE lower(v1."preferredUsername") = v2."lowerPreferredUsername" AND v1."serverId" IS NULL AND v1.id <> v2.id',
-    { transaction }
-  )
-}
-
-async function down (utils: {
-  queryInterface: Sequelize.QueryInterface
-  transaction: Sequelize.Transaction
-}) {
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0775-add-user-is-email-public.ts b/server/initializers/migrations/0775-add-user-is-email-public.ts
deleted file mode 100644
index 74dee192c..000000000
--- a/server/initializers/migrations/0775-add-user-is-email-public.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-
-  const data = {
-    type: Sequelize.BOOLEAN,
-    allowNull: false,
-    defaultValue: false
-  }
-
-  await utils.queryInterface.addColumn('user', 'emailPublic', data)
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0780-notification-registration.ts b/server/initializers/migrations/0780-notification-registration.ts
deleted file mode 100644
index 5f1e0d2ea..000000000
--- a/server/initializers/migrations/0780-notification-registration.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    await utils.sequelize.query('DELETE FROM "userNotification" WHERE type = 20 AND "userRegistrationId" IS NULL', { transaction })
-  }
-
-  {
-    await utils.sequelize.query(
-      'ALTER TABLE "userNotification" DROP CONSTRAINT "userNotification_userRegistrationId_fkey", ' +
-      'ADD CONSTRAINT "userNotification_userRegistrationId_fkey" ' +
-      'FOREIGN KEY ("userRegistrationId") REFERENCES "userRegistration" ("id") ON DELETE CASCADE ON UPDATE CASCADE',
-      { transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0785-video-password-protection.ts b/server/initializers/migrations/0785-video-password-protection.ts
deleted file mode 100644
index 1d85f4489..000000000
--- a/server/initializers/migrations/0785-video-password-protection.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  {
-    const query = `
-      CREATE TABLE IF NOT EXISTS "videoPassword" (
-        "id"   SERIAL,
-        "password" VARCHAR(255) NOT NULL,
-        "videoId" INTEGER NOT NULL REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
-        "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-        "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
-        PRIMARY KEY ("id")
-      );
-    `
-
-    await utils.sequelize.query(query, { transaction : utils.transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0790-thumbnail-disk.ts b/server/initializers/migrations/0790-thumbnail-disk.ts
deleted file mode 100644
index 0824c042e..000000000
--- a/server/initializers/migrations/0790-thumbnail-disk.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      allowNull: true,
-      defaultValue: true
-    }
-
-    await utils.queryInterface.addColumn('thumbnail', 'onDisk', data, { transaction })
-  }
-
-  {
-    // Remote previews are not on the disk
-    await utils.sequelize.query(
-      'UPDATE "thumbnail" SET "onDisk" = FALSE ' +
-      'WHERE "type" = 2 AND "videoId" NOT IN (SELECT "id" FROM "video" WHERE "remote" IS FALSE)',
-      { transaction }
-    )
-  }
-
-  {
-    const data = {
-      type: Sequelize.BOOLEAN,
-      allowNull: false,
-      defaultValue: null
-    }
-
-    await utils.queryInterface.changeColumn('thumbnail', 'onDisk', data, { transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0795-duplicate-runner-name.ts b/server/initializers/migrations/0795-duplicate-runner-name.ts
deleted file mode 100644
index dd15a8157..000000000
--- a/server/initializers/migrations/0795-duplicate-runner-name.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  const { transaction } = utils
-
-  const query = 'DELETE FROM "runner" r1 ' +
-    'USING (SELECT MIN(id) as id, "name" FROM "runner" GROUP BY "name" HAVING COUNT(*) > 1) r2 ' +
-    'WHERE r1."name" = r2."name" AND r1.id <> r2.id'
-
-  await utils.sequelize.query(query, { transaction })
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrations/0800-video-replace-file.ts b/server/initializers/migrations/0800-video-replace-file.ts
deleted file mode 100644
index f924a4d92..000000000
--- a/server/initializers/migrations/0800-video-replace-file.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import * as Sequelize from 'sequelize'
-
-async function up (utils: {
-  transaction: Sequelize.Transaction
-  queryInterface: Sequelize.QueryInterface
-  sequelize: Sequelize.Sequelize
-}): Promise<void> {
-  const { transaction } = utils
-
-  {
-    const query = 'DELETE FROM "videoSource" WHERE "videoId" IS NULL'
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const query = 'ALTER TABLE "videoSource" ALTER COLUMN "videoId" SET NOT NULL'
-    await utils.sequelize.query(query, { transaction })
-  }
-
-  {
-    const data = {
-      type: Sequelize.DATE,
-      allowNull: true,
-      defaultValue: null
-    }
-
-    await utils.queryInterface.addColumn('video', 'inputFileUpdatedAt', data, { transaction })
-  }
-}
-
-function down (options) {
-  throw new Error('Not implemented.')
-}
-
-export {
-  up,
-  down
-}
diff --git a/server/initializers/migrator.ts b/server/initializers/migrator.ts
deleted file mode 100644
index 7ac20127e..000000000
--- a/server/initializers/migrator.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { readdir } from 'fs-extra'
-import { join } from 'path'
-import { QueryTypes } from 'sequelize'
-import { logger } from '../helpers/logger'
-import { LAST_MIGRATION_VERSION } from './constants'
-import { sequelizeTypescript } from './database'
-
-async function migrate () {
-  const tables = await sequelizeTypescript.getQueryInterface().showAllTables()
-
-  // No tables, we don't need to migrate anything
-  // The installer will do that
-  if (tables.length === 0) return
-
-  let actualVersion: number | null = null
-
-  const query = 'SELECT "migrationVersion" FROM "application"'
-  const options = {
-    type: QueryTypes.SELECT as QueryTypes.SELECT
-  }
-
-  const rows = await sequelizeTypescript.query<{ migrationVersion: number }>(query, options)
-  if (rows?.[0]?.migrationVersion) {
-    actualVersion = rows[0].migrationVersion
-  }
-
-  if (actualVersion === null) {
-    await sequelizeTypescript.query('INSERT INTO "application" ("migrationVersion") VALUES (0)')
-    actualVersion = 0
-  }
-
-  // No need migrations, abort
-  if (actualVersion >= LAST_MIGRATION_VERSION) return
-
-  // If there are a new migration scripts
-  logger.info('Begin migrations.')
-
-  const migrationScripts = await getMigrationScripts()
-
-  for (const migrationScript of migrationScripts) {
-    try {
-      await executeMigration(actualVersion, migrationScript)
-    } catch (err) {
-      logger.error('Cannot execute migration %s.', migrationScript.version, { err })
-      process.exit(-1)
-    }
-  }
-
-  logger.info('Migrations finished. New migration version schema: %s', LAST_MIGRATION_VERSION)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  migrate
-}
-
-// ---------------------------------------------------------------------------
-
-async function getMigrationScripts () {
-  const files = await readdir(join(__dirname, 'migrations'))
-  const filesToMigrate: {
-    version: string
-    script: string
-  }[] = []
-
-  files
-    .filter(file => file.endsWith('.js'))
-    .forEach(file => {
-      // Filename is something like 'version-blabla.js'
-      const version = file.split('-')[0]
-      filesToMigrate.push({
-        version,
-        script: file
-      })
-    })
-
-  return filesToMigrate
-}
-
-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 undefined
-
-  // Load the migration module and run it
-  const migrationScriptName = entity.script
-  logger.info('Executing %s migration script.', migrationScriptName)
-
-  const migrationScript = require(join(__dirname, 'migrations', migrationScriptName))
-
-  return sequelizeTypescript.transaction(async t => {
-    const options = {
-      transaction: t,
-      queryInterface: sequelizeTypescript.getQueryInterface(),
-      sequelize: sequelizeTypescript
-    }
-
-    await migrationScript.up(options)
-
-    // Update the new migration version
-    await sequelizeTypescript.query('UPDATE "application" SET "migrationVersion" = ' + versionScript, { transaction: t })
-  })
-}