@gabliam/core/src/gabliam.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const expression_1 = require("@gabliam/expression");
const d = require("debug");
const _ = require("lodash");
const common_1 = require("./common");
const constants_1 = require("./constants");
const container_1 = require("./container");
const loaders_1 = require("./loaders");
const metadatas_1 = require("./metadatas");
const plugin_list_1 = require("./plugin-list");
const reflection_1 = require("./reflection");
const registry_1 = require("./registry");
const value_extractor_1 = require("./value-extractor");
const debug = d('Gabliam:core');
const DEFAULT_CONFIG = {
    config: process.env.GABLIAM_CONFIG_PATH,
};
/**
 * Gabliam
 */
class Gabliam {
    /**
     * Constructor
     * @param  {GabliamConfig|string} options?
     */
    constructor(options) {
        this.container = container_1.createContainer();
        /**
         * Registry
         */
        this.registry = new registry_1.Registry();
        /**
         * Module loader
         */
        this.loaderModule = new loaders_1.LoaderModule();
        /**
         * Config loader
         */
        this.loaderConfig = new loaders_1.LoaderConfig();
        /**
         * Plugin list
         */
        this.pluginList = new plugin_list_1.PluginList();
        if (options === undefined) {
            this.options = DEFAULT_CONFIG;
        }
        else {
            if (_.isString(options)) {
                this.options = Object.assign({}, DEFAULT_CONFIG, { config: options });
            }
            else {
                this.options = Object.assign({}, DEFAULT_CONFIG, options);
            }
        }
        /**
         * @TODO move in building phase
         */
        this.container.bind(constants_1.CORE_CONFIG).toConstantValue(this.options);
    }
    /**
     * Add a plugin
     * @param  {GabliamPluginConstructor} plugin
     * @returns Gabliam
     */
    addPlugin(plugin) {
        this.pluginList.add(plugin);
        return this;
    }
    /**
     * Add any plugins
     * @param  {GabliamPluginConstructor[]} ...plugins
     * @returns Gabliam
     */
    addPlugins(...plugins) {
        for (const plugin of plugins) {
            this.addPlugin(plugin);
        }
        return this;
    }
    /**
     * Build gabliam
     * @returns Promise
     */
    async build() {
        this.pluginList.sort();
        /**
         * Load config file
         */
        await this._initializeConfig();
        /**
         * Loading phase
         */
        this.registry.addRegistry(this.loaderModule.load(this.options.scanPath, this.pluginList.plugins));
        /**
         * Binding phase
         */
        await this._bind();
        /**
         * Config phase
         */
        await this._loadConfig();
        for (const plugin of this.pluginList.pluginsWithBuild) {
            await common_1.toPromise(plugin.build(this.container, this.registry));
        }
        return this;
    }
    /**
     * Build and start gabliam application
     * @returns Promise
     */
    async buildAndStart() {
        await this.build();
        await this.start();
        return this;
    }
    /**
     * Stop and destroy gabliam application
     * @returns Promise
     */
    async stopAndDestroy() {
        await this.stop();
        await this.destroy();
        return this;
    }
    /**
     * Start gabliam application
     *
     * call all plugin.start
     * @returns Promise
     */
    async start() {
        for (const plugin of this.pluginList.pluginsWithStart) {
            await common_1.toPromise(plugin.start(this.container, this.registry));
        }
        return this;
    }
    /**
     * Stop gabliam application
     * call all plugin.stop
     *
     * @returns Promise
     */
    async stop() {
        for (const plugin of this.pluginList.pluginsWithStop) {
            await common_1.toPromise(plugin.stop(this.container, this.registry));
        }
        return this;
    }
    /**
     * Destroy gabliam application
     * call all plugin.destroy
     *
     * @returns Promise
     */
    async destroy() {
        for (const plugin of this.pluginList.pluginsWithDestroy) {
            await common_1.toPromise(plugin.destroy(this.container, this.registry));
        }
        const values = this.registry.get(constants_1.TYPE.PreDestroy);
        const instanceToDestroy = async (value) => {
            if (value.options) {
                const instance = this.container.get(value.id);
                for (const preDestroy of value.options.preDestroys) {
                    await common_1.callInstance(instance, preDestroy);
                }
            }
        };
        const p = [];
        for (const value of values) {
            p.push(instanceToDestroy(value));
        }
        await Promise.all(p);
        return this;
    }
    /**
     * Load config file and bind result in APP_CONFIG
     */
    async _initializeConfig() {
        this.config = await this.loaderConfig.load(this.options.config);
        const config = this.config;
        this.container.bind(constants_1.APP_CONFIG).toConstantValue(config);
        this.container
            .bind(constants_1.VALUE_EXTRACTOR)
            .toConstantValue(value_extractor_1.configureValueExtractor(this.container));
        this.container
            .bind(expression_1.ExpressionParser)
            .toConstantValue(new expression_1.ExpressionParser(config));
    }
    /**
     * Binding phase
     * Binding of config and service classes.
     * call all plugin.bind
     */
    async _bind() {
        debug('_bind');
        this.registry.getAllAutoBind().forEach(({ id, target }) => this.container
            .bind(id)
            .to(target)
            .inSingletonScope());
        for (const plugin of this.pluginList.pluginsWithBind) {
            await common_1.toPromise(plugin.bind(this.container, this.registry));
        }
    }
    /**
     * Config phase
     */
    async _loadConfig() {
        debug('_loadConfig');
        // Get all config classes in registry
        let configsRegistry = this.registry.get(constants_1.TYPE.Config);
        debug('configsRegistry', configsRegistry);
        if (configsRegistry) {
            configsRegistry = _.sortBy(configsRegistry, 'options.order');
            for (const { id: configId } of configsRegistry) {
                // Get config instance
                const confInstance = this.container.get(configId);
                const ctor = confInstance.constructor;
                // get all bean metadata in config classes
                const beanMetadatas = reflection_1.reflection.propMetadataOfDecorator(ctor, metadatas_1.Bean);
                // get on missing bean metadata
                const onMissingBeanMetadatas = reflection_1.reflection.propMetadataOfDecorator(ctor, metadatas_1.OnMissingBean);
                const beforeCreateMetas = Object.keys(reflection_1.reflection.propMetadataOfDecorator(ctor, metadatas_1.BeforeCreate));
                const initMetadas = Object.keys(reflection_1.reflection.propMetadataOfDecorator(ctor, metadatas_1.Init));
                // call all beforeCreate method if exist
                if (Array.isArray(beforeCreateMetas)) {
                    // No promise.all and await because order of beans are important
                    for (const metada of beforeCreateMetas) {
                        await common_1.callInstance(confInstance, metada);
                    }
                }
                // If config has bean metadata
                if (Object.keys(beanMetadatas).length) {
                    // No promise.all and await because order of beans are important
                    for (const [key, beans] of Object.entries(beanMetadatas)) {
                        const onMissingBeans = onMissingBeanMetadatas[key] || [];
                        // by default all bean are missing
                        let allMissing = true;
                        // if there are onMissingBeans config, check if bean exist or no
                        for (const onMissingBean of onMissingBeans) {
                            try {
                                this.container.getAll(onMissingBean.id);
                                allMissing = false;
                            }
                            catch (_a) { }
                        }
                        // if all beans are missing, so we create all beans
                        if (allMissing) {
                            for (const { id } of beans) {
                                const bean = await common_1.callInstance(confInstance, key);
                                this.container.bind(id).toConstantValue(bean);
                                if (bean === undefined || bean.constructor === undefined) {
                                    continue;
                                }
                                const preDestroys = Object.keys(reflection_1.reflection.propMetadataOfDecorator(bean.constructor, metadatas_1.PreDestroy));
                                // bean can return undefined or can be a constant value
                                if (preDestroys.length) {
                                    this.registry.add(constants_1.TYPE.PreDestroy, {
                                        id,
                                        target: bean,
                                        options: {
                                            preDestroys,
                                        },
                                    });
                                }
                            }
                        }
                    }
                }
                if (Array.isArray(initMetadas)) {
                    // No promise.all and await because order of beans are important
                    for (const metada of initMetadas) {
                        await common_1.callInstance(confInstance, metada);
                    }
                }
                for (const plugin of this.pluginList.pluginWithConfig) {
                    await common_1.toPromise(plugin.config(this.container, this.registry, confInstance));
                }
            }
        }
        debug('_loadConfig end');
    }
}
exports.Gabliam = Gabliam;