@lakutata/core/build/base/abstracts/Module.js

Lakutata Framework Core

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Module = void 0;
const BaseObject_1 = require("../BaseObject");
const Container_1 = require("../Container");
const events_1 = __importDefault(require("events"));
const DependencyInjection_1 = require("../../decorators/DependencyInjection");
const ThreadManager_1 = require("../thread/ThreadManager");
const ProcessManager_1 = require("../process/ProcessManager");
const ModuleNotFoundException_1 = require("../../exceptions/ModuleNotFoundException");
const ComponentNotFoundException_1 = require("../../exceptions/ComponentNotFoundException");
class Module extends BaseObject_1.BaseObject {
    constructor() {
        super();
        this.eventEmitter = new events_1.default();
        this.container = new Container_1.Container();
        this.threadManager = new ThreadManager_1.ThreadManager();
        this.processManager = new ProcessManager_1.ProcessManager();
        this.onComponentsLoaded = () => void (0);
        this.onModulesLoaded = () => void (0);
        this.workflows = [];
        this.plugins = [];
        this.components = {};
        this.modules = {};
        this.threads = [];
        this.processes = [];
        this.on('ready', async (module) => {
            if (this.workflows) {
                for (const workflow of this.workflows) {
                    const WorkflowConstructor = workflow;
                    let workflowFunction = null;
                    try {
                        const workflowInstance = new WorkflowConstructor(module);
                        if (workflowInstance.run) {
                            await workflowInstance.run();
                        }
                    }
                    catch (e) {
                        workflowFunction = workflow;
                    }
                    if (workflowFunction)
                        await workflowFunction(module);
                }
            }
        });
        this.container
            .on('moduleLoaded', (moduleId, moduleConstructor, loadTime, subModuleId) => {
            const moduleStringId = typeof this.id === 'function' ? this.id.name : this.id;
            this.eventEmitter.emit('loaded', subModuleId ? `${moduleStringId}/${subModuleId}` : moduleStringId, moduleId, moduleConstructor, loadTime, 'module');
        })
            .on('componentLoaded', (componentId, componentConstructor, loadTime, subModuleId) => {
            const moduleStringId = typeof this.id === 'function' ? this.id.name : this.id;
            this.eventEmitter.emit('loaded', subModuleId ? `${moduleStringId}/${subModuleId}` : moduleStringId, componentId, componentConstructor, loadTime, 'component');
        });
    }
    bindPlugins() {
        if (!this.plugins)
            return;
        const reversedPlugins = this.plugins.reverse();
        const registeredPluginSet = new Set();
        for (const pluginConstructorOrConfig of reversedPlugins) {
            let pluginConstructor;
            let pluginConfig = {};
            if (typeof pluginConstructorOrConfig === 'object') {
                pluginConstructor = pluginConstructorOrConfig.class;
                for (const configKey of Object.keys(pluginConstructorOrConfig)) {
                    const configValue = pluginConstructorOrConfig[configKey];
                    if (configValue !== pluginConstructor) {
                        pluginConfig[configKey] = configValue;
                    }
                }
            }
            else {
                pluginConstructor = pluginConstructorOrConfig;
                pluginConfig = {};
            }
            if (registeredPluginSet.has(pluginConstructor))
                continue;
            this.container.bindPlugin(pluginConstructor, pluginConstructor.name, pluginConfig);
            if (!this.hasProperty(pluginConstructor.name)) {
                this.defineProperty(pluginConstructor.name, {
                    get() {
                        return this.container.getPlugin(pluginConstructor.name);
                    }
                });
            }
            registeredPluginSet.add(pluginConstructor);
        }
    }
    bindComponents() {
        if (!this.components)
            return;
        for (const key of Object.keys(this.components)) {
            const componentIdentifier = key;
            const componentConstructorOrConfig = this.components[key];
            let componentConstructor;
            let componentConfig = {};
            if (typeof componentConstructorOrConfig === 'object') {
                componentConstructor = componentConstructorOrConfig.class;
                for (const configKey of Object.keys(componentConstructorOrConfig)) {
                    const configValue = componentConstructorOrConfig[configKey];
                    if (configValue !== componentConstructor) {
                        componentConfig[configKey] = configValue;
                    }
                }
            }
            else {
                componentConstructor = componentConstructorOrConfig;
                componentConfig = {};
            }
            this.container.bindComponent(componentConstructor, componentIdentifier, componentConfig);
        }
    }
    bindModules() {
        if (!this.modules) {
            this.emit('modulesReady', this);
            return;
        }
        const moduleSize = Object.keys(this.modules).length;
        let loadedModuleCount = 0;
        if (moduleSize === loadedModuleCount) {
            this.emit('modulesReady', this);
        }
        else {
            for (const key of Object.keys(this.modules)) {
                const moduleIdentifier = key;
                const moduleConfig = this.modules[key];
                const moduleConstructor = moduleConfig.class;
                let moduleConfigs = {};
                for (const configKey of Object.keys(moduleConfig)) {
                    const configValue = moduleConfig[configKey];
                    if (moduleConstructor !== configValue) {
                        moduleConfigs[configKey] = configValue;
                    }
                }
                this.container.bindModule(moduleConstructor, moduleConfigs, moduleIdentifier, () => {
                    loadedModuleCount += 1;
                    if (loadedModuleCount === moduleSize) {
                        this.emit('modulesReady', this);
                    }
                });
            }
        }
    }
    async bindThreads() {
        if (this.threads) {
            const threadBindPromises = [];
            this.threads.forEach(threadConstructor => {
                threadBindPromises.push(new Promise((resolve, reject) => {
                    this.threadManager.createThread(threadConstructor).then(resolve).catch(reject);
                }));
            });
            await Promise.all(threadBindPromises);
        }
    }
    async bindProcesses() {
        if (this.processes) {
            const processBindPromises = [];
            this.processes.forEach(processConstructor => {
                processBindPromises.push(new Promise((resolve, reject) => {
                    this.processManager.createProcess(processConstructor).then(resolve).catch(reject);
                }));
            });
            await Promise.all(processBindPromises);
        }
    }
    get Plugins() {
        const self = this;
        return {
            bind: function (pluginConstructor, identifier, config) {
                self.container.bindPlugin(pluginConstructor, identifier, config);
            },
            get: function (name) {
                return self.container.getPlugin(name);
            },
            has: function (name) {
                try {
                    self.container.getPlugin(name);
                    return true;
                }
                catch (e) {
                    return false;
                }
            }
        };
    }
    get Objects() {
        const self = this;
        return {
            bind: function (objectConstructor, config) {
                self.container.bindObject(objectConstructor, config);
            },
            get: function (objectConstructor) {
                return self.container.getObject(objectConstructor);
            },
            has: function (objectConstructor) {
                return self.container.hasObject(objectConstructor);
            },
            unbind: function (objectConstructor) {
                self.container.unbindObject(objectConstructor);
            }
        };
    }
    get Components() {
        const self = this;
        const baseComponents = {
            get: function (name) {
                if (baseComponents.has(name)) {
                    return self.container.getComponent(name);
                }
                else {
                    throw self.generateException(ComponentNotFoundException_1.ComponentNotFoundException, name);
                }
            },
            has: function (name) {
                try {
                    self.container.getComponent(name);
                    return true;
                }
                catch (e) {
                    return false;
                }
            }
        };
        return new Proxy(baseComponents, {
            get(target, p, receiver) {
                if (target[p]) {
                    return target[p];
                }
                else {
                    if (target.has(p)) {
                        return target.get(p);
                    }
                    else {
                        return undefined;
                    }
                }
            }
        });
    }
    get Modules() {
        const self = this;
        const baseModules = {
            get: function (name) {
                if (baseModules.has(name)) {
                    return self.container.getModule(name);
                }
                else {
                    throw self.generateException(ModuleNotFoundException_1.ModuleNotFoundException, name);
                }
            },
            has: function (name) {
                try {
                    self.container.getModule(name);
                    return true;
                }
                catch (e) {
                    return false;
                }
            }
        };
        return new Proxy(baseModules, {
            get(target, p) {
                if (target[p]) {
                    return target[p];
                }
                else {
                    if (target.has(p)) {
                        return target.get(p);
                    }
                    else {
                        return undefined;
                    }
                }
            }
        });
    }
    get Threads() {
        const self = this;
        return {
            bind: async function (threadConstructor) {
                return await self.threadManager.createThread(threadConstructor);
            },
            get: function (threadConstructor) {
                return self.threadManager.get(threadConstructor);
            },
            has: function (threadConstructor) {
                return self.threadManager.has(threadConstructor);
            },
            destroy: async function (threadConstructor) {
                return await self.threadManager.destroy(threadConstructor);
            }
        };
    }
    get Processes() {
        const self = this;
        return {
            bind: async function (processConstructor) {
                return await self.processManager.createProcess(processConstructor);
            },
            get: function (processConstructor) {
                return self.processManager.get(processConstructor);
            },
            has: function (processConstructor) {
                return self.processManager.has(processConstructor);
            },
            destroy: async function (processConstructor) {
                return await self.processManager.destroy(processConstructor);
            }
        };
    }
    on(a, b) {
        this.eventEmitter.on(a, b);
        return this;
    }
    once(a, b) {
        this.eventEmitter.once(a, b);
        return this;
    }
    off(a, b) {
        if (!b) {
            this.eventEmitter.removeAllListeners(a);
        }
        else {
            this.eventEmitter.removeListener(a, b);
        }
        return this;
    }
    emit(event, ...args) {
        return this.eventEmitter.emit.apply(this.eventEmitter, [event].concat(args));
    }
    bind(objectConstructor, config) {
        return this.Objects.bind(objectConstructor, config);
    }
    get(objectConstructor) {
        return this.Objects.get(objectConstructor);
    }
    unbind(objectConstructor) {
        return this.Objects.unbind(objectConstructor);
    }
    has(objectConstructor) {
        return this.Objects.has(objectConstructor);
    }
}
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Function)
], Module.prototype, "onComponentsLoaded", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Function)
], Module.prototype, "onModulesLoaded", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Array)
], Module.prototype, "workflows", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Array)
], Module.prototype, "plugins", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Object)
], Module.prototype, "components", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Object)
], Module.prototype, "modules", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Array)
], Module.prototype, "threads", void 0);
__decorate([
    (0, DependencyInjection_1.Configurable)(),
    __metadata("design:type", Array)
], Module.prototype, "processes", void 0);
exports.Module = Module;
//# sourceMappingURL=Module.js.map