nope/lib/module/BaseModule.ts

/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 * @create date 2020-10-12 17:54:08
 * @modify date 2020-11-23 08:11:41
 * @desc [description]
 */

import { inject, injectable } from "inversify";
import { getMethodPath, getPropertyPath, isMethodPathCorrect, isPropertyPathCorrect } from "../helpers/dispatcherPathes";
import { deepClone } from "../helpers/objectMethods";
import { DISPATCHER_INSTANCE } from "../symbols/identifiers";
import { INopeDispatcher } from "../types/nope/nopeDispatcher.interface";
import { IAuthor, IFunctionOptions, INopeModule, INopeModuleDescription, IPropertyOptions, IVersion } from "../types/nope/nopeModule.interface";
import { INopeObservable } from "../types/nope/nopeObservable.interface";

/**
 * Base Implementation of a Module.
 * 
 * The Module is used to share information and data. Although it implements the 
 * the Basic behavior to fullfill a given traget.
 *
 * @export
 * @class BaseModule
 * @implements {INopeModule}
 */
@injectable()
export class NopeBaseModule implements INopeModule {

    /**
     * Return the Class Identifier.
     */
    public get type(): string {
        return Object.getPrototypeOf(this).constructor.name;
    }   

    /**
     * A Description of the Module. This is used to Describe roughly
     * what the module is capable of 
     * doing.
     *
     * @type {string}
     * @memberof BaseModule
     */
    public description: string;

    /**
     * A Description of the Author. Use to Mail etc.
     *
     * @type {IAuthor}
     * @memberof BaseModule
     */
    public author: IAuthor;

    /**
     * Description of the provided Version of the Module.
     *
     * @type {IVersion}
     * @memberof BaseModule
     */
    public version: IVersion;

    protected _registeredFunctions: Map<string, {
        func: (...args: any[]) => Promise<any>,
        options: IFunctionOptions
    }>

    protected _registeredProperties: Map<string, {
        observable: INopeObservable<any>
        options: IPropertyOptions
    }>

    /**
     * Public getter for the functions
     *
     * @readonly
     * @memberof BaseModule
     */
    public get functions() {
        const ret:  { [index: string]: IFunctionOptions; } = {};

        for (const [name, funcs] of this._registeredFunctions.entries()){
            ret[name] = funcs.options;
        }

        return ret;
    }

    /**
     * Public get to receive a Description of the Properties
     *
     * @readonly
     * @memberof BaseModule
     */
    public get properties() {
        const ret:  { [index: string]: IPropertyOptions<any>; } = {};

        for (const [name, funcs] of this._registeredProperties.entries()){
            ret[name] = funcs.options;
        }

        return ret;
    }
    
    /**
     * The Identifier of the Module.
     *
     * @type {string}
     * @memberof BaseModule
     */
    public identifier: string;

    public _markedElements: Array<{accessor: string, options:IPropertyOptions | IFunctionOptions, type: "method" | "prop"}>;
  
    /**
     * Creates an instance of BaseModule.
     * @memberof BaseModule
     */
    constructor(@inject(DISPATCHER_INSTANCE) protected _dispatcher: INopeDispatcher) {
        this.description = null;
        this.author = null;
        this.version = null;
        this.identifier = null;
        this._registeredFunctions = new Map();
        this._registeredProperties = new Map();
    }

    /**
     * Helper Function to register an Observable (a Property.)
     *
     * @template T Type of the Property
     * @template K Additional Pipe Options
     * @template S Setter Type of the Property
     * @template G Getter Type of the Property
     * @param {string} name Name, which should be used to register the element. The Name will ALLWAYS (automatically) be assembled using the modules identifier an then the name.
     * @param {INopeObservable<T, S, G>} observable The Observable representing the Property
     * @param {IPropertyOptions<K>} options The Options used to define the registration.
     * @return {*}  {Promise<void>}
     * @memberof NopeBaseModule
     */
    public async registerProperty<T, K = any, S = T, G = T>(name: string, observable: INopeObservable<T, S, G>, options: IPropertyOptions<K>): Promise<void> {
        // Unregister the Function
        await this.unregisterProperty(name);

        // Adapt the Topics
        if (typeof options.topic === "string" && !isPropertyPathCorrect(this.identifier, options.topic as string)){
            options.topic = getPropertyPath(this.identifier, options.topic);
        } else if (typeof options.topic === "object"){
            if (options.topic.subscribe && !isPropertyPathCorrect(this.identifier, options.topic.subscribe)){
                options.topic.subscribe = getPropertyPath(this.identifier, options.topic.subscribe);
            }
            if (options.topic.publish && !isPropertyPathCorrect(this.identifier, options.topic.publish)){
                options.topic.publish = getPropertyPath(this.identifier, options.topic.publish);
            }
        }
        const _observable = await this._dispatcher.registerObservable(observable, options);

        // Register the new Property.
        this._registeredProperties.set(name, {
            observable: _observable,
            options
        });
    }

    /**
     * Function used to register a Method. This Method will be available in the shared network. 
     *
     * @param {string} name Name of the Method, which is used during registration at the dispatcher
     * @param {(...args: any[]) => Promise<any>} func The function itself. It must be async.
     * @param {IFunctionOptions} options The Options, used for registering. 
     * @return {*}  {Promise<void>}
     * @memberof NopeBaseModule
     */
    public async registerMethod(name: string, func: (...args: any[]) => Promise<any>, options: IFunctionOptions): Promise<void> {
        // Unregister the Function
        await this.unregisterFunction(name);

        // Adapt the Method ID
        if (options.id){
            if (!isMethodPathCorrect(this.identifier, options.id)){
                options.id = getMethodPath(this.identifier,options.id);
            }
        } else {
            options.id = getMethodPath(this.identifier,name);
        }

        const _func = await this._dispatcher.registerFunction(func, options);

        // Register the new Function.
        this._registeredFunctions.set(name, {
            func: _func,
            options
        });
    }

    /**
     * Unregister a Function
     *
     * @param {string} name Name of the function used during registering.
     * @return {*}  {Promise<void>}
     * @memberof NopeBaseModule
     */
    public async unregisterFunction(name: string): Promise<void> {
        // Test if the Method is already registerd,
        // If so => unregister it first.
        if (this._registeredFunctions.has(name)) {
            this._dispatcher.unregisterFunction(this._registeredFunctions.get(name).func, {
                preventSendingToRegistery: true
            });
        }
    }

    /**
     * Helper Function to unregister an Observable (a Property.)
     * 
     * @param {string} name Name of the Property, that has been used to register.
     * @return {*}  {Promise<void>}
     * @memberof NopeBaseModule
     */
    public async unregisterProperty(name: string): Promise<void> {
        // Test if the Property is already registerd,
        // If so => unregister it first.
        if (this._registeredProperties.has(name)) {
            this._dispatcher.unregisterObservable(this._registeredProperties.get(name).observable, {
                preventSendingToRegistery: true
            });
        }
    }

    /**
     * Function to return all available Methods.
     *
     * @return {*}  {Promise<{ func: (...args: any[]) => Promise<any>; options: IFunctionOptions; }[]>}
     * @memberof NopeBaseModule
     */
    public async listFunctions(): Promise<{ func: (...args: any[]) => Promise<any>; options: IFunctionOptions; }[]> {
        return Array.from(this._registeredFunctions.values());
    }

    /**
     * Function used to list all available Properties.
     *
     * @return {*}  {Promise<Array<{ observable: INopeObservable<any>, options: IPropertyOptions }>>}
     * @memberof NopeBaseModule
     */
    public async listProperties(): Promise<Array<{ observable: INopeObservable<any>, options: IPropertyOptions }>> {
        return Array.from(this._registeredProperties.values());
    }

    /**
     * An init Function. Used to initialize the Element.
     *
     * @return {*}  {Promise<void>}
     * @memberof NopeBaseModule
     */
    public async init(...args): Promise<void> {      
        // In this base Implementation, check if every requried property is set
        // correctly. If not => raise an error.
    
        if (this.type === null){
            throw Error("Please Provide a Name for the Module before initializing");
        }

        if (this.description === null){
            throw Error("Please Provide a Description for the Module before initializing");
        }

        if (this.author === null){
            throw Error("Please Provide an Author for the Module before initializing");
        }

        if (this.version === null){
            throw Error("Please Provide a Version for the Module before initializing");
        }

        if (this.identifier === null){
            throw Error("Please Provide an Identifier for the Module before initializing");
        }

        if (this._markedElements){
            const _this = this;
            for (const entry of deepClone(this._markedElements)){
                switch(entry.type){
                    case "method":
                        await this.registerMethod(entry.accessor, (...args) => {
                            return _this[entry.accessor](...args);
                        }, entry.options as IFunctionOptions);
                        break;
                    case "prop":
                        await this.registerProperty(entry.accessor, _this[entry.accessor], entry.options as IPropertyOptions);
                        break;
                }
            }
        }
    }

    /**
     * Function, which is used to unregister the element.
     *
     * @memberof NopeBaseModule
     */
    public async dispose(){
        // Unregister all Methods and Functions
        for (const name of this._registeredFunctions.keys()){
            await this.unregisterFunction(name);
        }

        // Remove all known Functions
        this._registeredFunctions.clear();

        // Unregister all Properties.
        for (const name of this._registeredProperties.keys()){
            await this.unregisterProperty(name);
        }
        
        // Remove all known Properties.
        this._registeredProperties.clear();
    }
    
    /**
     * Helper function to extract an description of the Module.
     *
     * @return {INopeModuleDescription} a parsed description
     * @memberof NopeBaseModule
     */
    public toDescription(): INopeModuleDescription {
        const ret: INopeModuleDescription = {
            author: this.author,
            description: this.description,
            functions: this.functions,
            identifier: this.identifier,
            properties: this.properties, 
            type: this.type,
            version: this.version    
        };

        return ret;
    }
}