trifid-core/dist/lib/plugins/apply.js

Trifid Core

import merge from 'lodash/merge.js';
import { initQuery } from "../sparql.js";
/**
 *
 * @param server Fastify server instance.
 * @param globals Global settings.
 * @param plugins Plugins to apply.
 * @param logger Logger instance.
 * @param templateEngine Template engine instance.
 * @param instanceHostname Instance hostname.
 * @param trifidEvents Trifid events emitter.
 */
const apply = async (server, globals, plugins, logger, templateEngine, instanceHostname, trifidEvents, notFound) => {
    const { query: querySparql } = initQuery(logger, globals.endpoints, instanceHostname);
    for (const [name, plugin] of plugins) {
        const { paths, hosts, methods, module, config } = plugin;
        const pluginLogger = logger.child({ name });
        const query = querySparql(logger.child({ name: `${name}:query` }));
        const pluginConfig = {
            paths,
            hosts,
            methods,
            config: merge({}, globals, config),
        };
        const { render, registerHelper } = templateEngine;
        const loadedPlugin = await module({
            ...pluginConfig,
            server,
            logger: pluginLogger,
            render,
            query,
            notFound,
            registerTemplateHelper: registerHelper,
            trifidEvents,
        });
        let routeHandler;
        if (loadedPlugin) {
            if (loadedPlugin.defaultConfiguration) {
                const defaultConfiguration = await loadedPlugin.defaultConfiguration();
                if (defaultConfiguration) {
                    if (defaultConfiguration.paths && pluginConfig.paths.length === 0) {
                        pluginConfig.paths = defaultConfiguration.paths;
                    }
                    if (defaultConfiguration.hosts && pluginConfig.hosts.length === 0) {
                        pluginConfig.hosts = defaultConfiguration.hosts;
                    }
                    if (defaultConfiguration.methods && pluginConfig.methods.length === 0) {
                        pluginConfig.methods = defaultConfiguration.methods;
                    }
                }
            }
            if (loadedPlugin.routeHandler) {
                routeHandler = await loadedPlugin.routeHandler();
            }
        }
        if (!routeHandler) {
            continue;
        }
        const { hosts: pluginHosts, methods: pluginMethods, paths: pluginPaths } = pluginConfig;
        const baseRouteOptions = {
            method: pluginMethods,
            handler: routeHandler,
        };
        if (pluginHosts.length === 0) {
            for (const path of pluginPaths) {
                logger.debug(`mount '${name}' plugin (methods=${baseRouteOptions.method}, path=${path})`);
                server.route({
                    ...baseRouteOptions,
                    url: path,
                });
            }
        }
        else {
            for (const host of pluginHosts) {
                for (const path of pluginPaths) {
                    logger.debug(`mount '${name}' plugin (methods=${baseRouteOptions.method}, path=${path}, host=${host})`);
                    server.route({
                        ...baseRouteOptions,
                        url: path,
                        constraints: {
                            host,
                        },
                    });
                }
            }
        }
    }
};
export default apply;