1 /* eslint-disable @typescript-eslint/no-implied-eval */
2 import * as debug from 'debug'
3 import { firstValueFrom, ReplaySubject } from 'rxjs'
4 import { first, shareReplay } from 'rxjs/operators'
5 import { RegisterClientHelpers } from 'src/types/register-client-option.model'
6 import { getExternalAuthHref, getHookType, internalRunHook } from '@shared/core-utils/plugins/hooks'
14 RegisterClientFormFieldOptions,
15 RegisterClientHookOptions,
16 RegisterClientRouteOptions,
17 RegisterClientSettingsScriptOptions,
18 RegisterClientVideoFieldOptions,
20 } from '@shared/models'
21 import { environment } from '../environments/environment'
22 import { ClientScript } from '../types'
23 import { logger } from './logger'
25 interface HookStructValue extends RegisterClientHookOptions {
26 plugin: ServerConfigPlugin
27 clientScript: ClientScriptJSON
30 type Hooks = { [ name: string ]: HookStructValue[] }
33 plugin: ServerConfigPlugin
34 clientScript: ClientScriptJSON
35 pluginType: PluginType
39 type PeertubeHelpersFactory = (pluginInfo: PluginInfo) => RegisterClientHelpers
42 pluginInfo: PluginInfo,
43 options: RegisterClientFormFieldOptions,
44 videoFormOptions: RegisterClientVideoFieldOptions
47 type OnSettingsScripts = (pluginInfo: PluginInfo, options: RegisterClientSettingsScriptOptions) => void
49 type OnClientRoute = (options: RegisterClientRouteOptions) => void
51 const debugLogger = debug('peertube:plugins')
53 class PluginsManager {
54 private hooks: Hooks = {}
56 private scopes: { [ scopeName: string ]: PluginInfo[] } = {}
58 private loadedScripts: { [ script: string ]: boolean } = {}
59 private loadedScopes: PluginClientScope[] = []
60 private loadingScopes: { [id in PluginClientScope]?: boolean } = {}
62 private pluginsLoaded: { [ scope in PluginClientScope ]: ReplaySubject<boolean> } = {
63 common: new ReplaySubject<boolean>(1),
64 'admin-plugin': new ReplaySubject<boolean>(1),
65 search: new ReplaySubject<boolean>(1),
66 'video-watch': new ReplaySubject<boolean>(1),
67 signup: new ReplaySubject<boolean>(1),
68 login: new ReplaySubject<boolean>(1),
69 'video-edit': new ReplaySubject<boolean>(1),
70 embed: new ReplaySubject<boolean>(1),
71 'my-library': new ReplaySubject<boolean>(1),
72 'video-channel': new ReplaySubject<boolean>(1)
75 private readonly peertubeHelpersFactory: PeertubeHelpersFactory
76 private readonly onFormFields: OnFormFields
77 private readonly onSettingsScripts: OnSettingsScripts
78 private readonly onClientRoute: OnClientRoute
80 constructor (options: {
81 peertubeHelpersFactory: PeertubeHelpersFactory
82 onFormFields?: OnFormFields
83 onSettingsScripts?: OnSettingsScripts
84 onClientRoute?: OnClientRoute
86 this.peertubeHelpersFactory = options.peertubeHelpersFactory
87 this.onFormFields = options.onFormFields
88 this.onSettingsScripts = options.onSettingsScripts
89 this.onClientRoute = options.onClientRoute
92 static getPluginPathPrefix (isTheme: boolean) {
93 return isTheme ? '/themes' : '/plugins'
96 static getDefaultLoginHref (apiUrl: string, serverConfig: HTMLServerConfig) {
97 if (!serverConfig || serverConfig.client.menu.login.redirectOnSingleExternalAuth !== true) return undefined
99 const externalAuths = serverConfig.plugin.registeredExternalAuths
100 if (externalAuths.length !== 1) return undefined
102 return getExternalAuthHref(apiUrl, externalAuths[0])
105 loadPluginsList (config: HTMLServerConfig) {
106 for (const plugin of config.plugin.registered) {
107 this.addPlugin(plugin)
111 async runHook<T> (hookName: ClientHookName, resultArg?: T | Promise<T>, params?: any) {
112 if (!this.hooks[hookName]) {
113 // eslint-disable-next-line no-return-await
114 return await resultArg
117 const hookType = getHookType(hookName)
119 let result = await resultArg
121 for (const hook of this.hooks[hookName]) {
122 logger.info(`Running hook ${hookName} of plugin ${hook.plugin.name}`)
124 result = await internalRunHook({
125 handler: hook.handler,
130 logger.error(`Cannot run hook ${hookName} of script ${hook.clientScript.script} of plugin ${hook.plugin.name}`, err)
138 ensurePluginsAreLoaded (scope: PluginClientScope) {
139 this.loadPluginsByScope(scope)
141 const obs = this.pluginsLoaded[scope].asObservable()
142 .pipe(first(), shareReplay())
144 return firstValueFrom(obs)
147 async reloadLoadedScopes () {
148 for (const scope of this.loadedScopes) {
149 await this.loadPluginsByScope(scope, true)
153 addPlugin (plugin: ServerConfigPlugin, isTheme = false) {
154 const pathPrefix = PluginsManager.getPluginPathPrefix(isTheme)
156 for (const key of Object.keys(plugin.clientScripts)) {
157 const clientScript = plugin.clientScripts[key]
159 for (const scope of clientScript.scopes) {
160 if (!this.scopes[scope]) this.scopes[scope] = []
162 this.scopes[scope].push({
165 script: `${pathPrefix}/${plugin.name}/${plugin.version}/client-scripts/${clientScript.script}`,
166 scopes: clientScript.scopes
168 pluginType: isTheme ? PluginType.THEME : PluginType.PLUGIN,
172 this.loadedScripts[clientScript.script] = false
177 removePlugin (plugin: ServerConfigPlugin) {
178 for (const key of Object.keys(this.scopes)) {
179 this.scopes[key] = this.scopes[key].filter(o => o.plugin.name !== plugin.name)
183 async loadPluginsByScope (scope: PluginClientScope, isReload = false) {
184 if (this.loadingScopes[scope]) return
185 if (!isReload && this.loadedScopes.includes(scope)) return
187 this.loadingScopes[scope] = true
189 debugLogger('Loading scope %s', scope)
192 if (!isReload) this.loadedScopes.push(scope)
194 const toLoad = this.scopes[scope]
195 if (!Array.isArray(toLoad)) {
196 this.loadingScopes[scope] = false
197 this.pluginsLoaded[scope].next(true)
199 debugLogger('Nothing to load for scope %s', scope)
203 const promises: Promise<any>[] = []
204 for (const pluginInfo of toLoad) {
205 const clientScript = pluginInfo.clientScript
207 if (this.loadedScripts[clientScript.script]) continue
209 promises.push(this.loadPlugin(pluginInfo))
211 this.loadedScripts[clientScript.script] = true
214 await Promise.all(promises)
216 this.pluginsLoaded[scope].next(true)
217 this.loadingScopes[scope] = false
219 debugLogger('Scope %s loaded', scope)
221 logger.error(`Cannot load plugins by scope ${scope}`, err)
225 private loadPlugin (pluginInfo: PluginInfo) {
226 const { plugin, clientScript } = pluginInfo
228 const registerHook = (options: RegisterClientHookOptions) => {
229 if (clientHookObject[options.target] !== true) {
230 logger.error(`Unknown hook ${options.target} of plugin ${plugin.name}. Skipping.`)
234 if (!this.hooks[options.target]) this.hooks[options.target] = []
236 this.hooks[options.target].push({
239 target: options.target,
240 handler: options.handler,
241 priority: options.priority || 0
245 const registerVideoField = (commonOptions: RegisterClientFormFieldOptions, videoFormOptions: RegisterClientVideoFieldOptions) => {
246 if (!this.onFormFields) {
247 throw new Error('Video field registration is not supported')
250 return this.onFormFields(pluginInfo, commonOptions, videoFormOptions)
253 const registerSettingsScript = (options: RegisterClientSettingsScriptOptions) => {
254 if (!this.onSettingsScripts) {
255 throw new Error('Registering settings script is not supported')
258 return this.onSettingsScripts(pluginInfo, options)
261 const registerClientRoute = (options: RegisterClientRouteOptions) => {
262 if (!this.onClientRoute) {
263 throw new Error('Registering client route is not supported')
266 return this.onClientRoute(options)
269 const peertubeHelpers = this.peertubeHelpersFactory(pluginInfo)
271 logger.info(`Loading script ${clientScript.script} of plugin ${plugin.name}`)
273 const absURL = (environment.apiUrl || window.location.origin) + clientScript.script
274 return dynamicImport(absURL)
275 .then((script: ClientScript) => {
276 return script.register({
279 registerSettingsScript,
284 .then(() => this.sortHooksByPriority())
285 .catch(err => logger.error(`Cannot import or register plugin ${pluginInfo.plugin.name}`, err))
288 private sortHooksByPriority () {
289 for (const hookName of Object.keys(this.hooks)) {
290 this.hooks[hookName].sort((a, b) => {
291 return b.priority - a.priority
301 PeertubeHelpersFactory,
306 // ---------------------------------------------------------------------------
308 async function dynamicImport (url: string) {
310 // eslint-disable-next-line no-new-func
311 return new Function(`return import('${url}')`)()
313 logger.info('Fallback to import polyfill')
315 return new Promise((resolve, reject) => {
316 const vector = '$importModule$' + Math.random().toString(32).slice(2)
317 const script = document.createElement('script')
319 const destructor = () => {
320 delete window[vector]
321 script.onerror = null
324 URL.revokeObjectURL(script.src)
329 script.type = 'module'
331 script.onerror = () => {
332 reject(new Error(`Failed to import: ${url}`))
335 script.onload = () => {
336 resolve(window[vector])
339 const loader = `import * as m from "${url}"; window.${vector} = m;` // export Module
340 const blob = new Blob([ loader ], { type: 'text/javascript' })
341 script.src = URL.createObjectURL(blob)
343 document.head.appendChild(script)