5 files changed, 625 insertions, 180 deletions

diff --git a/server/lib/plugins/hooks.ts b/server/lib/plugins/hooks.ts
index bcc8c674e..aa92f03cc 100644
--- a/server/lib/plugins/hooks.ts
+++ b/server/lib/plugins/hooks.ts
@@ -25,7 +25,7 @@ const Hooks = {
   },
 
   runAction: <T, U extends ServerActionHookName>(hookName: U, params?: T) => {
-    PluginManager.Instance.runHook(hookName, params)
+    PluginManager.Instance.runHook(hookName, undefined, params)
       .catch(err => logger.error('Fatal hook error.', { err }))
   }
 }
diff --git a/server/lib/plugins/plugin-helpers.ts b/server/lib/plugins/plugin-helpers.ts
new file mode 100644
index 000000000..de82b4918
--- /dev/null
+++ b/server/lib/plugins/plugin-helpers.ts
@@ -0,0 +1,133 @@
+import { PeerTubeHelpers } from '@server/typings/plugins'
+import { sequelizeTypescript } from '@server/initializers/database'
+import { buildLogger } from '@server/helpers/logger'
+import { VideoModel } from '@server/models/video/video'
+import { WEBSERVER } from '@server/initializers/constants'
+import { ServerModel } from '@server/models/server/server'
+import { getServerActor } from '@server/models/application/application'
+import { addServerInBlocklist, removeServerFromBlocklist, addAccountInBlocklist, removeAccountFromBlocklist } from '../blocklist'
+import { ServerBlocklistModel } from '@server/models/server/server-blocklist'
+import { AccountModel } from '@server/models/account/account'
+import { VideoBlacklistCreate } from '@shared/models'
+import { blacklistVideo, unblacklistVideo } from '../video-blacklist'
+import { VideoBlacklistModel } from '@server/models/video/video-blacklist'
+import { AccountBlocklistModel } from '@server/models/account/account-blocklist'
+
+function buildPluginHelpers (npmName: string): PeerTubeHelpers {
+  const logger = buildPluginLogger(npmName)
+
+  const database = buildDatabaseHelpers()
+  const videos = buildVideosHelpers()
+
+  const config = buildConfigHelpers()
+
+  const server = buildServerHelpers()
+
+  const moderation = buildModerationHelpers()
+
+  return {
+    logger,
+    database,
+    videos,
+    config,
+    moderation,
+    server
+  }
+}
+
+export {
+  buildPluginHelpers
+}
+
+// ---------------------------------------------------------------------------
+
+function buildPluginLogger (npmName: string) {
+  return buildLogger(npmName)
+}
+
+function buildDatabaseHelpers () {
+  return {
+    query: sequelizeTypescript.query.bind(sequelizeTypescript)
+  }
+}
+
+function buildServerHelpers () {
+  return {
+    getServerActor: () => getServerActor()
+  }
+}
+
+function buildVideosHelpers () {
+  return {
+    loadByUrl: (url: string) => {
+      return VideoModel.loadByUrl(url)
+    },
+
+    removeVideo: (id: number) => {
+      return sequelizeTypescript.transaction(async t => {
+        const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(id, t)
+
+        await video.destroy({ transaction: t })
+      })
+    }
+  }
+}
+
+function buildModerationHelpers () {
+  return {
+    blockServer: async (options: { byAccountId: number, hostToBlock: string }) => {
+      const serverToBlock = await ServerModel.loadOrCreateByHost(options.hostToBlock)
+
+      await addServerInBlocklist(options.byAccountId, serverToBlock.id)
+    },
+
+    unblockServer: async (options: { byAccountId: number, hostToUnblock: string }) => {
+      const serverBlock = await ServerBlocklistModel.loadByAccountAndHost(options.byAccountId, options.hostToUnblock)
+      if (!serverBlock) return
+
+      await removeServerFromBlocklist(serverBlock)
+    },
+
+    blockAccount: async (options: { byAccountId: number, handleToBlock: string }) => {
+      const accountToBlock = await AccountModel.loadByNameWithHost(options.handleToBlock)
+      if (!accountToBlock) return
+
+      await addAccountInBlocklist(options.byAccountId, accountToBlock.id)
+    },
+
+    unblockAccount: async (options: { byAccountId: number, handleToUnblock: string }) => {
+      const targetAccount = await AccountModel.loadByNameWithHost(options.handleToUnblock)
+      if (!targetAccount) return
+
+      const accountBlock = await AccountBlocklistModel.loadByAccountAndTarget(options.byAccountId, targetAccount.id)
+      if (!accountBlock) return
+
+      await removeAccountFromBlocklist(accountBlock)
+    },
+
+    blacklistVideo: async (options: { videoIdOrUUID: number | string, createOptions: VideoBlacklistCreate }) => {
+      const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(options.videoIdOrUUID)
+      if (!video) return
+
+      await blacklistVideo(video, options.createOptions)
+    },
+
+    unblacklistVideo: async (options: { videoIdOrUUID: number | string }) => {
+      const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(options.videoIdOrUUID)
+      if (!video) return
+
+      const videoBlacklist = await VideoBlacklistModel.loadByVideoId(video.id)
+      if (!videoBlacklist) return
+
+      await unblacklistVideo(videoBlacklist, video)
+    }
+  }
+}
+
+function buildConfigHelpers () {
+  return {
+    getWebserverUrl () {
+      return WEBSERVER.URL
+    }
+  }
+}
diff --git a/server/lib/plugins/plugin-index.ts b/server/lib/plugins/plugin-index.ts
index 25b4f3c61..170f0c7e2 100644
--- a/server/lib/plugins/plugin-index.ts
+++ b/server/lib/plugins/plugin-index.ts
@@ -27,11 +27,11 @@ async function listAvailablePluginsFromIndex (options: PeertubePluginIndexList)
   const uri = CONFIG.PLUGINS.INDEX.URL + '/api/v1/plugins'
 
   try {
-    const { body } = await doRequest({ uri, qs, json: true })
+    const { body } = await doRequest<any>({ uri, qs, json: true })
 
     logger.debug('Got result from PeerTube index.', { body })
 
-    await addInstanceInformation(body)
+    addInstanceInformation(body)
 
     return body as ResultList<PeerTubePluginIndex>
   } catch (err) {
@@ -40,7 +40,7 @@ async function listAvailablePluginsFromIndex (options: PeertubePluginIndexList)
   }
 }
 
-async function addInstanceInformation (result: ResultList<PeerTubePluginIndex>) {
+function addInstanceInformation (result: ResultList<PeerTubePluginIndex>) {
   for (const d of result.data) {
     d.installed = PluginManager.Instance.isRegistered(d.npmName)
     d.name = PluginModel.normalizePluginName(d.npmName)
@@ -57,7 +57,7 @@ async function getLatestPluginsVersion (npmNames: string[]): Promise<PeertubePlu
 
   const uri = CONFIG.PLUGINS.INDEX.URL + '/api/v1/plugins/latest-version'
 
-  const { body } = await doRequest({ uri, body: bodyRequest, json: true, method: 'POST' })
+  const { body } = await doRequest<any>({ uri, body: bodyRequest, json: true, method: 'POST' })
 
   return body
 }
diff --git a/server/lib/plugins/plugin-manager.ts b/server/lib/plugins/plugin-manager.ts
index 7ebdabd34..950acf7ad 100644
--- a/server/lib/plugins/plugin-manager.ts
+++ b/server/lib/plugins/plugin-manager.ts
@@ -9,23 +9,20 @@ import {
   PluginTranslationPaths as PackagePluginTranslations
 } from '../../../shared/models/plugins/plugin-package-json.model'
 import { createReadStream, createWriteStream } from 'fs'
-import { PLUGIN_GLOBAL_CSS_PATH, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES } from '../../initializers/constants'
+import { PLUGIN_GLOBAL_CSS_PATH } from '../../initializers/constants'
 import { PluginType } from '../../../shared/models/plugins/plugin.type'
 import { installNpmPlugin, installNpmPluginFromDisk, removeNpmPlugin } from './yarn'
 import { outputFile, readJSON } from 'fs-extra'
-import { PluginSettingsManager } from '../../../shared/models/plugins/plugin-settings-manager.model'
-import { PluginStorageManager } from '../../../shared/models/plugins/plugin-storage-manager.model'
-import { ServerHook, ServerHookName, serverHookObject } from '../../../shared/models/plugins/server-hook.model'
+import { ServerHook, ServerHookName } from '../../../shared/models/plugins/server-hook.model'
 import { getHookType, internalRunHook } from '../../../shared/core-utils/plugins/hooks'
 import { RegisterServerOptions } from '../../typings/plugins/register-server-option.model'
 import { PluginLibrary } from '../../typings/plugins'
 import { ClientHtml } from '../client-html'
-import { RegisterServerHookOptions } from '../../../shared/models/plugins/register-server-hook.model'
-import { RegisterServerSettingOptions } from '../../../shared/models/plugins/register-server-setting.model'
-import { PluginVideoLanguageManager } from '../../../shared/models/plugins/plugin-video-language-manager.model'
-import { PluginVideoCategoryManager } from '../../../shared/models/plugins/plugin-video-category-manager.model'
-import { PluginVideoLicenceManager } from '../../../shared/models/plugins/plugin-video-licence-manager.model'
 import { PluginTranslation } from '../../../shared/models/plugins/plugin-translation.model'
+import { RegisterHelpersStore } from './register-helpers-store'
+import { RegisterServerHookOptions } from '@shared/models/plugins/register-server-hook.model'
+import { MOAuthTokenUser, MUser } from '@server/typings/models'
+import { RegisterServerAuthPassOptions, RegisterServerAuthExternalOptions } from '@shared/models/plugins/register-server-auth.model'
 
 export interface RegisteredPlugin {
   npmName: string
@@ -44,6 +41,7 @@ export interface RegisteredPlugin {
   css: string[]
 
   // Only if this is a plugin
+  registerHelpersStore?: RegisterHelpersStore
   unregister?: Function
 }
 
@@ -54,35 +52,18 @@ export interface HookInformationValue {
   priority: number
 }
 
-type AlterableVideoConstant = 'language' | 'licence' | 'category'
-type VideoConstant = { [ key in number | string ]: string }
-type UpdatedVideoConstant = {
-  [ name in AlterableVideoConstant ]: {
-    [ npmName: string ]: {
-      added: { key: number | string, label: string }[],
-      deleted: { key: number | string, label: string }[]
-    }
-  }
-}
-
 type PluginLocalesTranslations = {
-  [ locale: string ]: PluginTranslation
+  [locale: string]: PluginTranslation
 }
 
 export class PluginManager implements ServerHook {
 
   private static instance: PluginManager
 
-  private registeredPlugins: { [ name: string ]: RegisteredPlugin } = {}
-  private settings: { [ name: string ]: RegisterServerSettingOptions[] } = {}
-  private hooks: { [ name: string ]: HookInformationValue[] } = {}
-  private translations: PluginLocalesTranslations = {}
+  private registeredPlugins: { [name: string]: RegisteredPlugin } = {}
 
-  private updatedVideoConstants: UpdatedVideoConstant = {
-    language: {},
-    licence: {},
-    category: {}
-  }
+  private hooks: { [name: string]: HookInformationValue[] } = {}
+  private translations: PluginLocalesTranslations = {}
 
   private constructor () {
   }
@@ -97,7 +78,7 @@ export class PluginManager implements ServerHook {
     return this.registeredPlugins[npmName]
   }
 
-  getRegisteredPlugin (name: string) {
+  getRegisteredPluginByShortName (name: string) {
     const npmName = PluginModel.buildNpmName(name, PluginType.PLUGIN)
     const registered = this.getRegisteredPluginOrTheme(npmName)
 
@@ -106,7 +87,7 @@ export class PluginManager implements ServerHook {
     return registered
   }
 
-  getRegisteredTheme (name: string) {
+  getRegisteredThemeByShortName (name: string) {
     const npmName = PluginModel.buildNpmName(name, PluginType.THEME)
     const registered = this.getRegisteredPluginOrTheme(npmName)
 
@@ -123,17 +104,102 @@ export class PluginManager implements ServerHook {
     return this.getRegisteredPluginsOrThemes(PluginType.THEME)
   }
 
+  getIdAndPassAuths () {
+    return this.getRegisteredPlugins()
+      .map(p => ({
+        npmName: p.npmName,
+        name: p.name,
+        version: p.version,
+        idAndPassAuths: p.registerHelpersStore.getIdAndPassAuths()
+      }))
+      .filter(v => v.idAndPassAuths.length !== 0)
+  }
+
+  getExternalAuths () {
+    return this.getRegisteredPlugins()
+      .map(p => ({
+        npmName: p.npmName,
+        name: p.name,
+        version: p.version,
+        externalAuths: p.registerHelpersStore.getExternalAuths()
+      }))
+      .filter(v => v.externalAuths.length !== 0)
+  }
+
   getRegisteredSettings (npmName: string) {
-    return this.settings[npmName] || []
+    const result = this.getRegisteredPluginOrTheme(npmName)
+    if (!result || result.type !== PluginType.PLUGIN) return []
+
+    return result.registerHelpersStore.getSettings()
+  }
+
+  getRouter (npmName: string) {
+    const result = this.getRegisteredPluginOrTheme(npmName)
+    if (!result || result.type !== PluginType.PLUGIN) return null
+
+    return result.registerHelpersStore.getRouter()
   }
 
   getTranslations (locale: string) {
     return this.translations[locale] || {}
   }
 
+  async isTokenValid (token: MOAuthTokenUser, type: 'access' | 'refresh') {
+    const auth = this.getAuth(token.User.pluginAuth, token.authName)
+    if (!auth) return true
+
+    if (auth.hookTokenValidity) {
+      try {
+        const { valid } = await auth.hookTokenValidity({ token, type })
+
+        if (valid === false) {
+          logger.info('Rejecting %s token validity from auth %s of plugin %s', type, token.authName, token.User.pluginAuth)
+        }
+
+        return valid
+      } catch (err) {
+        logger.warn('Cannot run check token validity from auth %s of plugin %s.', token.authName, token.User.pluginAuth, { err })
+        return true
+      }
+    }
+
+    return true
+  }
+
+  // ###################### External events ######################
+
+  onLogout (npmName: string, authName: string, user: MUser) {
+    const auth = this.getAuth(npmName, authName)
+
+    if (auth?.onLogout) {
+      logger.info('Running onLogout function from auth %s of plugin %s', authName, npmName)
+
+      try {
+        auth.onLogout(user)
+      } catch (err) {
+        logger.warn('Cannot run onLogout function from auth %s of plugin %s.', authName, npmName, { err })
+      }
+    }
+  }
+
+  onSettingsChanged (name: string, settings: any) {
+    const registered = this.getRegisteredPluginByShortName(name)
+    if (!registered) {
+      logger.error('Cannot find plugin %s to call on settings changed.', name)
+    }
+
+    for (const cb of registered.registerHelpersStore.getOnSettingsChangedCallbacks()) {
+      try {
+        cb(settings)
+      } catch (err) {
+        logger.error('Cannot run on settings changed callback for %s.', registered.npmName, { err })
+      }
+    }
+  }
+
   // ###################### Hooks ######################
 
-  async runHook <T> (hookName: ServerHookName, result?: T, params?: any): Promise<T> {
+  async runHook<T> (hookName: ServerHookName, result?: T, params?: any): Promise<T> {
     if (!this.hooks[hookName]) return Promise.resolve(result)
 
     const hookType = getHookType(hookName)
@@ -185,7 +251,6 @@ export class PluginManager implements ServerHook {
     }
 
     delete this.registeredPlugins[plugin.npmName]
-    delete this.settings[plugin.npmName]
 
     this.deleteTranslations(plugin.npmName)
 
@@ -197,7 +262,8 @@ export class PluginManager implements ServerHook {
         this.hooks[key] = this.hooks[key].filter(h => h.npmName !== npmName)
       }
 
-      this.reinitVideoConstants(plugin.npmName)
+      const store = plugin.registerHelpersStore
+      store.reinitVideoConstants(plugin.npmName)
 
       logger.info('Regenerating registered plugin CSS to global file.')
       await this.regeneratePluginGlobalCSS()
@@ -303,8 +369,11 @@ export class PluginManager implements ServerHook {
     this.sanitizeAndCheckPackageJSONOrThrow(packageJSON, plugin.type)
 
     let library: PluginLibrary
+    let registerHelpersStore: RegisterHelpersStore
     if (plugin.type === PluginType.PLUGIN) {
-      library = await this.registerPlugin(plugin, pluginPath, packageJSON)
+      const result = await this.registerPlugin(plugin, pluginPath, packageJSON)
+      library = result.library
+      registerHelpersStore = result.registerStore
     }
 
     const clientScripts: { [id: string]: ClientScript } = {}
@@ -312,7 +381,7 @@ export class PluginManager implements ServerHook {
       clientScripts[c.script] = c
     }
 
-    this.registeredPlugins[ npmName ] = {
+    this.registeredPlugins[npmName] = {
       npmName,
       name: plugin.name,
       type: plugin.type,
@@ -323,6 +392,7 @@ export class PluginManager implements ServerHook {
       staticDirs: packageJSON.staticDirs,
       clientScripts,
       css: packageJSON.css,
+      registerHelpersStore: registerHelpersStore || undefined,
       unregister: library ? library.unregister : undefined
     }
 
@@ -341,15 +411,15 @@ export class PluginManager implements ServerHook {
       throw new Error('Library code is not valid (miss register or unregister function)')
     }
 
-    const registerHelpers = this.getRegisterHelpers(npmName, plugin)
-    library.register(registerHelpers)
+    const { registerOptions, registerStore } = this.getRegisterHelpers(npmName, plugin)
+    library.register(registerOptions)
            .catch(err => logger.error('Cannot register plugin %s.', npmName, { err }))
 
     logger.info('Add plugin %s CSS to global file.', npmName)
 
     await this.addCSSToGlobalFile(pluginPath, packageJSON.css)
 
-    return library
+    return { library, registerStore }
   }
 
   // ###################### Translations ######################
@@ -432,13 +502,23 @@ export class PluginManager implements ServerHook {
     return join(CONFIG.STORAGE.PLUGINS_DIR, 'node_modules', npmName)
   }
 
+  private getAuth (npmName: string, authName: string) {
+    const plugin = this.getRegisteredPluginOrTheme(npmName)
+    if (!plugin || plugin.type !== PluginType.PLUGIN) return null
+
+    let auths: (RegisterServerAuthPassOptions | RegisterServerAuthExternalOptions)[] = plugin.registerHelpersStore.getIdAndPassAuths()
+    auths = auths.concat(plugin.registerHelpersStore.getExternalAuths())
+
+    return auths.find(a => a.authName === authName)
+  }
+
   // ###################### Private getters ######################
 
   private getRegisteredPluginsOrThemes (type: PluginType) {
     const plugins: RegisteredPlugin[] = []
 
     for (const npmName of Object.keys(this.registeredPlugins)) {
-      const plugin = this.registeredPlugins[ npmName ]
+      const plugin = this.registeredPlugins[npmName]
       if (plugin.type !== type) continue
 
       plugins.push(plugin)
@@ -449,149 +529,26 @@ export class PluginManager implements ServerHook {
 
   // ###################### Generate register helpers ######################
 
-  private getRegisterHelpers (npmName: string, plugin: PluginModel): RegisterServerOptions {
-    const registerHook = (options: RegisterServerHookOptions) => {
-      if (serverHookObject[options.target] !== true) {
-        logger.warn('Unknown hook %s of plugin %s. Skipping.', options.target, npmName)
-        return
-      }
-
+  private getRegisterHelpers (
+    npmName: string,
+    plugin: PluginModel
+  ): { registerStore: RegisterHelpersStore, registerOptions: RegisterServerOptions } {
+    const onHookAdded = (options: RegisterServerHookOptions) => {
       if (!this.hooks[options.target]) this.hooks[options.target] = []
 
       this.hooks[options.target].push({
-        npmName,
+        npmName: npmName,
         pluginName: plugin.name,
         handler: options.handler,
         priority: options.priority || 0
       })
     }
 
-    const registerSetting = (options: RegisterServerSettingOptions) => {
-      if (!this.settings[npmName]) this.settings[npmName] = []
-
-      this.settings[npmName].push(options)
-    }
-
-    const settingsManager: PluginSettingsManager = {
-      getSetting: (name: string) => PluginModel.getSetting(plugin.name, plugin.type, name),
-
-      setSetting: (name: string, value: string) => PluginModel.setSetting(plugin.name, plugin.type, name, value)
-    }
-
-    const storageManager: PluginStorageManager = {
-      getData: (key: string) => PluginModel.getData(plugin.name, plugin.type, key),
-
-      storeData: (key: string, data: any) => PluginModel.storeData(plugin.name, plugin.type, key, data)
-    }
-
-    const videoLanguageManager: PluginVideoLanguageManager = {
-      addLanguage: (key: string, label: string) => this.addConstant({ npmName, type: 'language', obj: VIDEO_LANGUAGES, key, label }),
-
-      deleteLanguage: (key: string) => this.deleteConstant({ npmName, type: 'language', obj: VIDEO_LANGUAGES, key })
-    }
-
-    const videoCategoryManager: PluginVideoCategoryManager = {
-      addCategory: (key: number, label: string) => this.addConstant({ npmName, type: 'category', obj: VIDEO_CATEGORIES, key, label }),
-
-      deleteCategory: (key: number) => this.deleteConstant({ npmName, type: 'category', obj: VIDEO_CATEGORIES, key })
-    }
-
-    const videoLicenceManager: PluginVideoLicenceManager = {
-      addLicence: (key: number, label: string) => this.addConstant({ npmName, type: 'licence', obj: VIDEO_LICENCES, key, label }),
-
-      deleteLicence: (key: number) => this.deleteConstant({ npmName, type: 'licence', obj: VIDEO_LICENCES, key })
-    }
-
-    const peertubeHelpers = {
-      logger
-    }
+    const registerHelpersStore = new RegisterHelpersStore(npmName, plugin, onHookAdded.bind(this))
 
     return {
-      registerHook,
-      registerSetting,
-      settingsManager,
-      storageManager,
-      videoLanguageManager,
-      videoCategoryManager,
-      videoLicenceManager,
-      peertubeHelpers
-    }
-  }
-
-  private addConstant <T extends string | number> (parameters: {
-    npmName: string,
-    type: AlterableVideoConstant,
-    obj: VideoConstant,
-    key: T,
-    label: string
-  }) {
-    const { npmName, type, obj, key, label } = parameters
-
-    if (obj[key]) {
-      logger.warn('Cannot add %s %s by plugin %s: key already exists.', type, npmName, key)
-      return false
-    }
-
-    if (!this.updatedVideoConstants[type][npmName]) {
-      this.updatedVideoConstants[type][npmName] = {
-        added: [],
-        deleted: []
-      }
-    }
-
-    this.updatedVideoConstants[type][npmName].added.push({ key, label })
-    obj[key] = label
-
-    return true
-  }
-
-  private deleteConstant <T extends string | number> (parameters: {
-    npmName: string,
-    type: AlterableVideoConstant,
-    obj: VideoConstant,
-    key: T
-  }) {
-    const { npmName, type, obj, key } = parameters
-
-    if (!obj[key]) {
-      logger.warn('Cannot delete %s %s by plugin %s: key does not exist.', type, npmName, key)
-      return false
-    }
-
-    if (!this.updatedVideoConstants[type][npmName]) {
-      this.updatedVideoConstants[type][npmName] = {
-        added: [],
-        deleted: []
-      }
-    }
-
-    this.updatedVideoConstants[type][npmName].deleted.push({ key, label: obj[key] })
-    delete obj[key]
-
-    return true
-  }
-
-  private reinitVideoConstants (npmName: string) {
-    const hash = {
-      language: VIDEO_LANGUAGES,
-      licence: VIDEO_LICENCES,
-      category: VIDEO_CATEGORIES
-    }
-    const types: AlterableVideoConstant[] = [ 'language', 'licence', 'category' ]
-
-    for (const type of types) {
-      const updatedConstants = this.updatedVideoConstants[type][npmName]
-      if (!updatedConstants) continue
-
-      for (const added of updatedConstants.added) {
-        delete hash[type][added.key]
-      }
-
-      for (const deleted of updatedConstants.deleted) {
-        hash[type][deleted.key] = deleted.label
-      }
-
-      delete this.updatedVideoConstants[type][npmName]
+      registerStore: registerHelpersStore,
+      registerOptions: registerHelpersStore.buildRegisterHelpers()
     }
   }
 
@@ -604,7 +561,7 @@ export class PluginManager implements ServerHook {
     const { result: packageJSONValid, badFields } = isPackageJSONValid(packageJSON, pluginType)
     if (!packageJSONValid) {
       const formattedFields = badFields.map(f => `"${f}"`)
-                              .join(', ')
+                                       .join(', ')
 
       throw new Error(`PackageJSON is invalid (invalid fields: ${formattedFields}).`)
     }
diff --git a/server/lib/plugins/register-helpers-store.ts b/server/lib/plugins/register-helpers-store.ts
new file mode 100644
index 000000000..e337b1cb0
--- /dev/null
+++ b/server/lib/plugins/register-helpers-store.ts
@@ -0,0 +1,355 @@
+import * as express from 'express'
+import { logger } from '@server/helpers/logger'
+import {
+  VIDEO_CATEGORIES,
+  VIDEO_LANGUAGES,
+  VIDEO_LICENCES,
+  VIDEO_PLAYLIST_PRIVACIES,
+  VIDEO_PRIVACIES
+} from '@server/initializers/constants'
+import { onExternalUserAuthenticated } from '@server/lib/auth'
+import { PluginModel } from '@server/models/server/plugin'
+import { RegisterServerOptions } from '@server/typings/plugins'
+import { PluginPlaylistPrivacyManager } from '@shared/models/plugins/plugin-playlist-privacy-manager.model'
+import { PluginSettingsManager } from '@shared/models/plugins/plugin-settings-manager.model'
+import { PluginStorageManager } from '@shared/models/plugins/plugin-storage-manager.model'
+import { PluginVideoCategoryManager } from '@shared/models/plugins/plugin-video-category-manager.model'
+import { PluginVideoLanguageManager } from '@shared/models/plugins/plugin-video-language-manager.model'
+import { PluginVideoLicenceManager } from '@shared/models/plugins/plugin-video-licence-manager.model'
+import { PluginVideoPrivacyManager } from '@shared/models/plugins/plugin-video-privacy-manager.model'
+import {
+  RegisterServerAuthExternalOptions,
+  RegisterServerAuthExternalResult,
+  RegisterServerAuthPassOptions,
+  RegisterServerExternalAuthenticatedResult
+} from '@shared/models/plugins/register-server-auth.model'
+import { RegisterServerHookOptions } from '@shared/models/plugins/register-server-hook.model'
+import { RegisterServerSettingOptions } from '@shared/models/plugins/register-server-setting.model'
+import { serverHookObject } from '@shared/models/plugins/server-hook.model'
+import { buildPluginHelpers } from './plugin-helpers'
+
+type AlterableVideoConstant = 'language' | 'licence' | 'category' | 'privacy' | 'playlistPrivacy'
+type VideoConstant = { [key in number | string]: string }
+
+type UpdatedVideoConstant = {
+  [name in AlterableVideoConstant]: {
+    added: { key: number | string, label: string }[]
+    deleted: { key: number | string, label: string }[]
+  }
+}
+
+export class RegisterHelpersStore {
+  private readonly updatedVideoConstants: UpdatedVideoConstant = {
+    playlistPrivacy: { added: [], deleted: [] },
+    privacy: { added: [], deleted: [] },
+    language: { added: [], deleted: [] },
+    licence: { added: [], deleted: [] },
+    category: { added: [], deleted: [] }
+  }
+
+  private readonly settings: RegisterServerSettingOptions[] = []
+
+  private idAndPassAuths: RegisterServerAuthPassOptions[] = []
+  private externalAuths: RegisterServerAuthExternalOptions[] = []
+
+  private readonly onSettingsChangeCallbacks: ((settings: any) => void)[] = []
+
+  private readonly router: express.Router
+
+  constructor (
+    private readonly npmName: string,
+    private readonly plugin: PluginModel,
+    private readonly onHookAdded: (options: RegisterServerHookOptions) => void
+  ) {
+    this.router = express.Router()
+  }
+
+  buildRegisterHelpers (): RegisterServerOptions {
+    const registerHook = this.buildRegisterHook()
+    const registerSetting = this.buildRegisterSetting()
+
+    const getRouter = this.buildGetRouter()
+
+    const settingsManager = this.buildSettingsManager()
+    const storageManager = this.buildStorageManager()
+
+    const videoLanguageManager = this.buildVideoLanguageManager()
+
+    const videoLicenceManager = this.buildVideoLicenceManager()
+    const videoCategoryManager = this.buildVideoCategoryManager()
+
+    const videoPrivacyManager = this.buildVideoPrivacyManager()
+    const playlistPrivacyManager = this.buildPlaylistPrivacyManager()
+
+    const registerIdAndPassAuth = this.buildRegisterIdAndPassAuth()
+    const registerExternalAuth = this.buildRegisterExternalAuth()
+    const unregisterIdAndPassAuth = this.buildUnregisterIdAndPassAuth()
+    const unregisterExternalAuth = this.buildUnregisterExternalAuth()
+
+    const peertubeHelpers = buildPluginHelpers(this.npmName)
+
+    return {
+      registerHook,
+      registerSetting,
+
+      getRouter,
+
+      settingsManager,
+      storageManager,
+
+      videoLanguageManager,
+      videoCategoryManager,
+      videoLicenceManager,
+
+      videoPrivacyManager,
+      playlistPrivacyManager,
+
+      registerIdAndPassAuth,
+      registerExternalAuth,
+      unregisterIdAndPassAuth,
+      unregisterExternalAuth,
+
+      peertubeHelpers
+    }
+  }
+
+  reinitVideoConstants (npmName: string) {
+    const hash = {
+      language: VIDEO_LANGUAGES,
+      licence: VIDEO_LICENCES,
+      category: VIDEO_CATEGORIES,
+      privacy: VIDEO_PRIVACIES,
+      playlistPrivacy: VIDEO_PLAYLIST_PRIVACIES
+    }
+    const types: AlterableVideoConstant[] = [ 'language', 'licence', 'category', 'privacy', 'playlistPrivacy' ]
+
+    for (const type of types) {
+      const updatedConstants = this.updatedVideoConstants[type][npmName]
+      if (!updatedConstants) continue
+
+      for (const added of updatedConstants.added) {
+        delete hash[type][added.key]
+      }
+
+      for (const deleted of updatedConstants.deleted) {
+        hash[type][deleted.key] = deleted.label
+      }
+
+      delete this.updatedVideoConstants[type][npmName]
+    }
+  }
+
+  getSettings () {
+    return this.settings
+  }
+
+  getRouter () {
+    return this.router
+  }
+
+  getIdAndPassAuths () {
+    return this.idAndPassAuths
+  }
+
+  getExternalAuths () {
+    return this.externalAuths
+  }
+
+  getOnSettingsChangedCallbacks () {
+    return this.onSettingsChangeCallbacks
+  }
+
+  private buildGetRouter () {
+    return () => this.router
+  }
+
+  private buildRegisterSetting () {
+    return (options: RegisterServerSettingOptions) => {
+      this.settings.push(options)
+    }
+  }
+
+  private buildRegisterHook () {
+    return (options: RegisterServerHookOptions) => {
+      if (serverHookObject[options.target] !== true) {
+        logger.warn('Unknown hook %s of plugin %s. Skipping.', options.target, this.npmName)
+        return
+      }
+
+      return this.onHookAdded(options)
+    }
+  }
+
+  private buildRegisterIdAndPassAuth () {
+    return (options: RegisterServerAuthPassOptions) => {
+      if (!options.authName || typeof options.getWeight !== 'function' || typeof options.login !== 'function') {
+        logger.error('Cannot register auth plugin %s: authName, getWeight or login are not valid.', this.npmName, { options })
+        return
+      }
+
+      this.idAndPassAuths.push(options)
+    }
+  }
+
+  private buildRegisterExternalAuth () {
+    const self = this
+
+    return (options: RegisterServerAuthExternalOptions) => {
+      if (!options.authName || typeof options.authDisplayName !== 'function' || typeof options.onAuthRequest !== 'function') {
+        logger.error('Cannot register auth plugin %s: authName, authDisplayName or onAuthRequest are not valid.', this.npmName, { options })
+        return
+      }
+
+      this.externalAuths.push(options)
+
+      return {
+        userAuthenticated (result: RegisterServerExternalAuthenticatedResult): void {
+          onExternalUserAuthenticated({
+            npmName: self.npmName,
+            authName: options.authName,
+            authResult: result
+          }).catch(err => {
+            logger.error('Cannot execute onExternalUserAuthenticated.', { npmName: self.npmName, authName: options.authName, err })
+          })
+        }
+      } as RegisterServerAuthExternalResult
+    }
+  }
+
+  private buildUnregisterExternalAuth () {
+    return (authName: string) => {
+      this.externalAuths = this.externalAuths.filter(a => a.authName !== authName)
+    }
+  }
+
+  private buildUnregisterIdAndPassAuth () {
+    return (authName: string) => {
+      this.idAndPassAuths = this.idAndPassAuths.filter(a => a.authName !== authName)
+    }
+  }
+
+  private buildSettingsManager (): PluginSettingsManager {
+    return {
+      getSetting: (name: string) => PluginModel.getSetting(this.plugin.name, this.plugin.type, name, this.settings),
+
+      getSettings: (names: string[]) => PluginModel.getSettings(this.plugin.name, this.plugin.type, names, this.settings),
+
+      setSetting: (name: string, value: string) => PluginModel.setSetting(this.plugin.name, this.plugin.type, name, value),
+
+      onSettingsChange: (cb: (settings: any) => void) => this.onSettingsChangeCallbacks.push(cb)
+    }
+  }
+
+  private buildStorageManager (): PluginStorageManager {
+    return {
+      getData: (key: string) => PluginModel.getData(this.plugin.name, this.plugin.type, key),
+
+      storeData: (key: string, data: any) => PluginModel.storeData(this.plugin.name, this.plugin.type, key, data)
+    }
+  }
+
+  private buildVideoLanguageManager (): PluginVideoLanguageManager {
+    return {
+      addLanguage: (key: string, label: string) => {
+        return this.addConstant({ npmName: this.npmName, type: 'language', obj: VIDEO_LANGUAGES, key, label })
+      },
+
+      deleteLanguage: (key: string) => {
+        return this.deleteConstant({ npmName: this.npmName, type: 'language', obj: VIDEO_LANGUAGES, key })
+      }
+    }
+  }
+
+  private buildVideoCategoryManager (): PluginVideoCategoryManager {
+    return {
+      addCategory: (key: number, label: string) => {
+        return this.addConstant({ npmName: this.npmName, type: 'category', obj: VIDEO_CATEGORIES, key, label })
+      },
+
+      deleteCategory: (key: number) => {
+        return this.deleteConstant({ npmName: this.npmName, type: 'category', obj: VIDEO_CATEGORIES, key })
+      }
+    }
+  }
+
+  private buildVideoPrivacyManager (): PluginVideoPrivacyManager {
+    return {
+      deletePrivacy: (key: number) => {
+        return this.deleteConstant({ npmName: this.npmName, type: 'privacy', obj: VIDEO_PRIVACIES, key })
+      }
+    }
+  }
+
+  private buildPlaylistPrivacyManager (): PluginPlaylistPrivacyManager {
+    return {
+      deletePlaylistPrivacy: (key: number) => {
+        return this.deleteConstant({ npmName: this.npmName, type: 'playlistPrivacy', obj: VIDEO_PLAYLIST_PRIVACIES, key })
+      }
+    }
+  }
+
+  private buildVideoLicenceManager (): PluginVideoLicenceManager {
+    return {
+      addLicence: (key: number, label: string) => {
+        return this.addConstant({ npmName: this.npmName, type: 'licence', obj: VIDEO_LICENCES, key, label })
+      },
+
+      deleteLicence: (key: number) => {
+        return this.deleteConstant({ npmName: this.npmName, type: 'licence', obj: VIDEO_LICENCES, key })
+      }
+    }
+  }
+
+  private addConstant<T extends string | number> (parameters: {
+    npmName: string
+    type: AlterableVideoConstant
+    obj: VideoConstant
+    key: T
+    label: string
+  }) {
+    const { npmName, type, obj, key, label } = parameters
+
+    if (obj[key]) {
+      logger.warn('Cannot add %s %s by plugin %s: key already exists.', type, npmName, key)
+      return false
+    }
+
+    if (!this.updatedVideoConstants[type][npmName]) {
+      this.updatedVideoConstants[type][npmName] = {
+        added: [],
+        deleted: []
+      }
+    }
+
+    this.updatedVideoConstants[type][npmName].added.push({ key, label })
+    obj[key] = label
+
+    return true
+  }
+
+  private deleteConstant<T extends string | number> (parameters: {
+    npmName: string
+    type: AlterableVideoConstant
+    obj: VideoConstant
+    key: T
+  }) {
+    const { npmName, type, obj, key } = parameters
+
+    if (!obj[key]) {
+      logger.warn('Cannot delete %s %s by plugin %s: key does not exist.', type, npmName, key)
+      return false
+    }
+
+    if (!this.updatedVideoConstants[type][npmName]) {
+      this.updatedVideoConstants[type][npmName] = {
+        added: [],
+        deleted: []
+      }
+    }
+
+    this.updatedVideoConstants[type][npmName].deleted.push({ key, label: obj[key] })
+    delete obj[key]
+
+    return true
+  }
+}