@lakutata/core 1.0.28 → 1.0.29

package/src/ApplicationManagement.ts

@@ -1,3 +1,5 @@
+import momentTimezone from 'moment-timezone'
+
 require('events').captureRejections = true
 import {IApplicationConfig} from './interfaces/IApplicationConfig'
 import {Application} from './Application'
@@ -19,6 +21,7 @@ export async function createApp(config: IApplicationConfig): Promise<Application
 		process.title = config.id
 		process.env.appId = config.id
 		process.env.appName = config.name
+		process.env.TZ = config.timezone ? config.timezone : momentTimezone.tz.guess()
 		await coreContainer.initialize()
 		return coreContainer.getModule(Application)
 	} catch (e) {

package/src/base/process/Process.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata'
-import {ProcessClass} from 'ergate'
+import {ProcessClass} from '../../lib/multipleRunner/lib/cores/ProcessClass'
 
 export class Process extends ProcessClass {
 	/**

package/src/base/process/ProcessManager.ts

@@ -1,8 +1,8 @@
 import {Process} from './Process'
-import {ProxyClass} from 'ergate'
 import {IProcessConstructor} from '../../interfaces/IProcessConstructor'
-import {Process as processCreate} from 'ergate'
 import {ProcessException} from '../../exceptions/ProcessException'
+import {ProxyClass} from '../../lib/multipleRunner/definitions/interfaces/ProxyClass'
+import {Process as processCreate} from '../../lib/multipleRunner/lib/Process'
 
 export class ProcessManager<TProcess extends Process = Process> {
 	protected readonly processMap: Map<IProcessConstructor<TProcess>, TProcess & ProxyClass> = new Map()

package/src/base/thread/Thread.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata'
-import {ThreadClass} from 'ergate'
+import {ThreadClass} from '../../lib/multipleRunner/lib/cores/ThreadClass'
 
 export class Thread extends ThreadClass {
 

package/src/base/thread/ThreadManager.ts

@@ -1,8 +1,8 @@
 import {Thread} from './Thread'
 import {IThreadConstructor} from '../../interfaces/IThreadConstructor'
-import {Thread as threadCreate} from 'ergate'
 import {ThreadException} from '../../exceptions/ThreadException'
-import {ProxyClass} from 'ergate'
+import {ProxyClass} from '../../lib/multipleRunner/definitions/interfaces/ProxyClass'
+import {Thread as threadCreate} from '../../lib/multipleRunner/lib/Thread'
 
 export class ThreadManager<TThread extends Thread = Thread> {
 	protected readonly threadMap: Map<IThreadConstructor<TThread>, TThread & ProxyClass> = new Map()

package/src/interfaces/IApplicationConfig.ts

@@ -9,6 +9,7 @@ import {TProcessesConfig} from '../types/TProcessesConfig'
 export interface IApplicationConfig {
 	id: string
 	name: string
+	timezone?: string
 	plugins?: TPluginsConfig
 	components?: IComponentsConfig
 	modules?: IModulesConfig

package/src/lib/multipleRunner/constants/Channel.ts

@@ -0,0 +1,5 @@
+export const READY: string = '_____%$ready$%_____'
+export const SETUP_ERROR: string = '_____%$setup_error$%_____'
+export const INVOKE: string = '__%$invoke$%__'
+export const SET_PROPERTY: string = '_____%$set_property$%_____'
+export const PROPERTY_CHANGE: string = '_____%$property_change$%_____'

package/src/lib/multipleRunner/constants/MetadataKey.ts

@@ -0,0 +1,2 @@
+export const MULTIPLE_RUNNER_CLASS_NAME: string = 'multipleRunner::class_name'
+export const MULTIPLE_RUNNER__CLASS_PATH: string = 'multipleRunner::class_path'

package/src/lib/multipleRunner/containers/ContainerVolume.ts

@@ -0,0 +1,83 @@
+import {Volume} from 'memfs'
+
+export const BASE_RUNTIME_CONTAINER_FILE: string = '/multipleRunner/container/base/BaseRuntimeContainer.js'
+export const PROCESS_RUNTIME_CONTAINER_FILE: string = '/multipleRunner/container/ProcessRuntimeContainer.js'
+export const THREAD_RUNTIME_CONTAINER_FILE: string = '/multipleRunner/container/ThreadRuntimeContainer.js'
+
+export const ContainerVolume = Volume.fromJSON({
+	[BASE_RUNTIME_CONTAINER_FILE]: `
+    module.exports.BaseRuntimeContainer = function (bridge) {
+    bridge.on('create', (name, path) => {
+        const module = require(path)[name]
+        const moduleInstance = new module(bridge)
+        moduleInstance.setup().then(() => {
+            const properties = {}
+            const moduleInstancePropertiesObject = {}
+            for (const propertyName of Object.keys(moduleInstance)) {
+                properties[propertyName] = typeof moduleInstance[propertyName]
+                if (propertyName !== '__bridge__')
+                    moduleInstancePropertiesObject[propertyName] = moduleInstance[propertyName]
+            }
+            const moduleInstanceProxy = new Proxy(moduleInstance, {
+                set(target, p, value) {
+                    moduleInstance[p] = value
+                    bridge.propertyChange(p.toString(), value)
+                    return true
+                }
+            })
+            bridge.onSet((property, value) => {
+                moduleInstanceProxy[property] = value
+            })
+            bridge.ready(properties, JSON.parse(JSON.stringify(moduleInstancePropertiesObject)))
+            bridge.onInvoke(async (method, args) => {
+                const _args = []
+                const callbackSignature = /^__________%\\$CALLBACK\\[\\d+]\\$%__________$/
+                for (const arg of args) {
+                    if (typeof arg === 'string' && callbackSignature.test(arg)) {
+                        _args.push((...args) => {
+                            bridge.onCallback(arg, args)
+                        })
+                    } else {
+                        _args.push(arg)
+                    }
+                }
+                return await moduleInstanceProxy[method].apply(moduleInstanceProxy, _args)
+            })
+        }).catch(setupError => {
+            bridge.setupError(setupError)
+            process.exit(1)
+        })
+    })
+}
+    `,
+	[PROCESS_RUNTIME_CONTAINER_FILE]: `
+    const reversedArgvs = process.argv.reverse()
+    require(reversedArgvs[0])
+    const {ProcessBridge} = require(reversedArgvs[0])
+    const {BaseRuntimeContainer} = require(reversedArgvs[1])
+    BaseRuntimeContainer(new ProcessBridge(process))
+    `,
+	[THREAD_RUNTIME_CONTAINER_FILE]: `
+    const reversedArgvs = process.argv.reverse()
+    if(reversedArgvs[3]!=='undefined'){
+        try{require(reversedArgvs[3])}catch(e){}
+    }
+    const {parentPort} = require('worker_threads')
+    let _ThreadBridge
+    try{
+        const {ThreadBridge} = require(reversedArgvs[0])
+        _ThreadBridge = ThreadBridge
+    }catch(e){
+        const tsNodeRegExp=new RegExp("ts-node")
+        for(const reversedArgv of reversedArgvs){
+            if(tsNodeRegExp.test(reversedArgv)){
+                require(reversedArgv)
+            }
+        }
+         const {ThreadBridge} = require(reversedArgvs[0])
+        _ThreadBridge = ThreadBridge
+    }
+    const {BaseRuntimeContainer} = require(reversedArgvs[1])
+    BaseRuntimeContainer(new _ThreadBridge(parentPort))
+    `
+})

package/src/lib/multipleRunner/definitions/interfaces/ClassConstructor.ts

@@ -0,0 +1,3 @@
+export interface ClassConstructor<T> {
+    new(...args: any[]): T
+}

package/src/lib/multipleRunner/definitions/interfaces/MultipleRunnerBaseClassConstructor.ts

@@ -0,0 +1,5 @@
+import {MultipleRunnerBaseClass} from '../../lib/prototypes/MultipleRunnerBaseClass'
+
+export interface MultipleRunnerBaseClassConstructor {
+    new(...args: any[]): MultipleRunnerBaseClass
+}

package/src/lib/multipleRunner/definitions/interfaces/ProcessClassConstructor.ts

@@ -0,0 +1,10 @@
+import {ProcessClass} from '../../lib/cores/ProcessClass'
+import {ClassConstructor} from './ClassConstructor'
+
+export interface ProcessClassConstructor<T extends ProcessClass> extends ClassConstructor<T> {
+    new(...args: any[]): T
+
+    CLASS_PATH: string
+
+    CLASS_NAME: string
+}

package/src/lib/multipleRunner/definitions/interfaces/ProxyClass.ts

@@ -0,0 +1,3 @@
+export interface ProxyClass {
+    terminate(): Promise<void>
+}

package/src/lib/multipleRunner/definitions/interfaces/ThreadClassConstructor.ts

@@ -0,0 +1,10 @@
+import {ThreadClass} from '../../lib/cores/ThreadClass'
+import {ClassConstructor} from './ClassConstructor'
+
+export interface ThreadClassConstructor<T extends ThreadClass> extends ClassConstructor<T> {
+    new(...args: any[]): T
+
+    CLASS_PATH: string
+
+    CLASS_NAME: string
+}

package/src/lib/multipleRunner/lib/Process.ts

@@ -0,0 +1,44 @@
+import 'reflect-metadata'
+import {ProcessClassConstructor} from '../definitions/interfaces/ProcessClassConstructor'
+import {ChildProcess, fork} from 'child_process'
+import path from 'path'
+import {GenerateExecArgv} from './cores/GenerateExecArgv'
+import {ProcessBridge} from './bridges/ProcessBridge'
+import {ProcessClass} from './cores/ProcessClass'
+import {UniParentBridgeHandler} from './cores/UniParentBridgeHandler'
+import {ProxyClass} from '../definitions/interfaces/ProxyClass'
+import {
+    BASE_RUNTIME_CONTAINER_FILE,
+    ContainerVolume,
+    PROCESS_RUNTIME_CONTAINER_FILE
+} from '../containers/ContainerVolume'
+import fs from 'fs'
+import os from 'os'
+
+export async function Process<T extends ProcessClass>(processClassConstructor: ProcessClassConstructor<T>): Promise<T & ProxyClass> {
+    return new Promise((resolve, reject) => {
+        ProcessProxy(processClassConstructor, (setupError, instance) => {
+            if (setupError) {
+                reject(setupError)
+            } else {
+                resolve(<T & ProxyClass>instance)
+            }
+        })
+    })
+}
+
+function ProcessProxy<T extends ProcessClass>(processClassConstructor: ProcessClassConstructor<T>, callback: (setupError: Error, instance: T) => void) {
+    const className: string = processClassConstructor.CLASS_NAME
+    const classPath: string = processClassConstructor.CLASS_PATH
+    const tmpProcessRuntimeContainerFilename: string = path.resolve(os.tmpdir(), `./PRC_TMP_${Date.now()}.tmp`)
+    const tmpBaseRuntimeContainerFilename: string = path.resolve(os.tmpdir(), `./PBRC_TMP_${Date.now()}.tmp`)
+    fs.writeFileSync(tmpBaseRuntimeContainerFilename, ContainerVolume.readFileSync(BASE_RUNTIME_CONTAINER_FILE).toString())
+    fs.writeFileSync(tmpProcessRuntimeContainerFilename, ContainerVolume.readFileSync(PROCESS_RUNTIME_CONTAINER_FILE).toString())
+    const childProcess: ChildProcess = fork(tmpProcessRuntimeContainerFilename, [
+        tmpBaseRuntimeContainerFilename,
+        require.resolve(path.resolve(__dirname, './bridges/ProcessBridge'))
+    ], {
+        execArgv: GenerateExecArgv(classPath)
+    })
+    UniParentBridgeHandler(new ProcessBridge(childProcess), className, classPath, processClassConstructor, callback)
+}

package/src/lib/multipleRunner/lib/Thread.ts

@@ -0,0 +1,52 @@
+import 'reflect-metadata'
+import {ThreadClassConstructor} from '../definitions/interfaces/ThreadClassConstructor'
+import {ThreadClass} from './cores/ThreadClass'
+import {Worker} from 'worker_threads'
+import path from 'path'
+import {ThreadBridge} from './bridges/ThreadBridge'
+import {GenerateExecArgv} from './cores/GenerateExecArgv'
+import {UniParentBridgeHandler} from './cores/UniParentBridgeHandler'
+import {ProxyClass} from '../definitions/interfaces/ProxyClass'
+import os from 'os'
+import fs from 'fs'
+import {
+	BASE_RUNTIME_CONTAINER_FILE,
+	ContainerVolume,
+	THREAD_RUNTIME_CONTAINER_FILE
+} from '../containers/ContainerVolume'
+import {Process} from './Process'
+import {isElectron} from './cores/IsElectron'
+
+export async function Thread<T extends ThreadClass>(threadClassConstructor: ThreadClassConstructor<T>): Promise<T & ProxyClass> {
+	if (isElectron()) {
+		return await Process(threadClassConstructor as any) as any
+	} else {
+		return new Promise((resolve, reject) => {
+			ThreadProxy(threadClassConstructor, (setupError, instance) => {
+				if (setupError) {
+					reject(setupError)
+				} else {
+					resolve(<T & ProxyClass>instance)
+				}
+			})
+		})
+	}
+}
+
+function ThreadProxy<T extends ThreadClass>(threadClassConstructor: ThreadClassConstructor<T>, callback: (setupError: Error, instance: T) => void) {
+	const className: string = threadClassConstructor.CLASS_NAME
+	const classPath: string = threadClassConstructor.CLASS_PATH
+	const tmpBaseRuntimeContainerFilename: string = path.resolve(os.tmpdir(), `./TBRC_TMP_${Date.now()}.tmp`)
+	fs.writeFileSync(tmpBaseRuntimeContainerFilename, ContainerVolume.readFileSync(BASE_RUNTIME_CONTAINER_FILE).toString())
+	const exeArgv = GenerateExecArgv(classPath).reverse()
+	const worker: Worker = new Worker(ContainerVolume.readFileSync(THREAD_RUNTIME_CONTAINER_FILE).toString(), {
+		eval: true,
+		argv: [
+			exeArgv.length > 0 ? exeArgv[0] : 'undefined',
+			tmpBaseRuntimeContainerFilename,
+			require.resolve(path.resolve(__dirname, './bridges/ThreadBridge'))
+		]
+	})
+	// @ts-ignore
+	UniParentBridgeHandler(new ThreadBridge(worker), className, classPath, threadClassConstructor, callback)
+}

package/src/lib/multipleRunner/lib/bridges/BaseBridge.ts

@@ -0,0 +1,115 @@
+import {EventEmitter} from 'events'
+import random from 'random'
+import {INVOKE, PROPERTY_CHANGE, READY, SET_PROPERTY, SETUP_ERROR} from '../../constants/Channel'
+
+export class BaseBridge {
+    protected readonly eventEmitter: EventEmitter = new EventEmitter()
+    protected readonly bridge: any
+
+    constructor(bridgeObject: any) {
+        this.bridge = bridgeObject
+        this.bridge.on('message', data => {
+            this.eventEmitter.emit.apply(this.eventEmitter, [data.channel].concat(data.args) as any)
+        })
+    }
+
+    public off(channel: string) {
+        this.eventEmitter.removeAllListeners(channel)
+        return this
+    }
+
+    public on(channel: string, listener: (...args: any[]) => void) {
+        this.eventEmitter.on.apply(this.eventEmitter, [channel, listener])
+        return this
+    }
+
+    public once(channel: string, listener: (...args: any[]) => void) {
+        this.eventEmitter.once.apply(this.eventEmitter, [channel, listener])
+        return this
+    }
+
+    public send(channel: string, ...args: any[]) {
+        throw new Error('Method did not implemented')
+    }
+
+    public ready(properties: { [key: string]: any }, propertyValues: { [key: string]: any }) {
+        this.send(READY, properties, propertyValues)
+        return this
+    }
+
+    public onReady(callback: (properties: { [key: string]: any }, propertyValues: { [key: string]: any }) => void) {
+        this.once(READY, callback)
+        return this
+    }
+
+    public error(error: Error) {
+        this.send('error', error.message)
+    }
+
+    public setupError(error: Error) {
+        this.send(SETUP_ERROR, error.message)
+    }
+
+    public async invoke(method: string, args: Array<any>) {
+        return new Promise((resolve, reject) => {
+            const invokeId: string = `ts_${Date.now()}_rnd_${random.int(100, 999999)}`
+            const responseChannelName: string = `__%$invoke_res_${invokeId}$%__`
+            this.once(responseChannelName, (errMsg: string, result: any) => {
+                if (errMsg) {
+                    reject(new Error(errMsg))
+                } else {
+                    resolve(result)
+                }
+            })
+            this.send(INVOKE, method, args, responseChannelName)
+        })
+    }
+
+    public onInvoke(handler: (method: string, args: Array<any>) => Promise<any>): void {
+        this.on(INVOKE, (method: string, args: Array<any>, responseChannelName: string) => {
+            handler(method, args).then(result => {
+                this.send(responseChannelName, null, result)
+            }).catch(invokeError => {
+                this.send(responseChannelName, invokeError.message, undefined)
+            })
+        })
+    }
+
+    public set(property: string, value: any) {
+        this.send(SET_PROPERTY, property, value)
+        return this
+    }
+
+    public onSet(handler: (property: string, value: any) => void) {
+        this.on(SET_PROPERTY, handler)
+        return this
+    }
+
+    public propertyChange(property: string, value: any) {
+        this.send(PROPERTY_CHANGE, property, value)
+        this.send('property-changed', property, value)
+        return this
+    }
+
+    public onPropertyChanged(handler: (property: string, value: any) => void) {
+        this.on(PROPERTY_CHANGE, handler)
+        return this
+    }
+
+    public callbackHandler(thisArg: any, handler: (...args: any[]) => any): string {
+        const callbackEvtName: string = `__________%$CALLBACK[${Date.now()}]$%__________`
+        this.once(callbackEvtName, (...args: any[]) => {
+            handler.apply(thisArg, args)
+        })
+        return callbackEvtName
+    }
+
+    public onCallback(callbackEvtName: string, args: any[]) {
+        this.send.apply(this, [callbackEvtName].concat(args) as any)
+        return this
+    }
+
+    public async terminate(): Promise<void> {
+        throw new Error('Method did not implemented')
+    }
+}

package/src/lib/multipleRunner/lib/bridges/ProcessBridge.ts

@@ -0,0 +1,18 @@
+import {BaseBridge} from './BaseBridge'
+
+export class ProcessBridge extends BaseBridge {
+
+    public send(channel: string, ...args: any[]) {
+        this.bridge.send({
+            channel: channel,
+            args: args
+        })
+    }
+
+    public async terminate(): Promise<void> {
+        return new Promise(resolve => {
+            this.bridge.once('close', resolve)
+            this.bridge.kill()
+        })
+    }
+}

package/src/lib/multipleRunner/lib/bridges/ThreadBridge.ts

@@ -0,0 +1,15 @@
+import {BaseBridge} from './BaseBridge'
+
+export class ThreadBridge extends BaseBridge {
+
+    public send(channel: string, ...args: any[]) {
+        this.bridge.postMessage({
+            channel: channel,
+            args: args
+        })
+    }
+
+    public async terminate(): Promise<void> {
+        await this.bridge.terminate()
+    }
+}

package/src/lib/multipleRunner/lib/cores/GenerateExecArgv.ts

@@ -0,0 +1,28 @@
+import 'reflect-metadata'
+import path from 'path'
+
+export function GenerateExecArgv(modulePath: string): Array<string> {
+    const moduleExtName: string = path.extname(modulePath).toUpperCase()
+    switch (moduleExtName) {
+        case '.TS': {
+            require('ts-node')
+            const registerRegEx = /ts-node\/register/
+            const CMs = require('module')._cache
+            for (const cmPath of Object.keys(CMs)) {
+                if (registerRegEx.test(cmPath)) {
+                    return [
+                        '-r',
+                        cmPath
+                    ]
+                }
+            }
+            return []
+        }
+        case '.JS': {
+            return []
+        }
+        default: {
+            throw new Error('Invalid module type')
+        }
+    }
+}

package/src/lib/multipleRunner/lib/cores/IsElectron.ts

@@ -0,0 +1,3 @@
+export function isElectron() {
+    return !!(process?.versions?.electron)
+}

package/src/lib/multipleRunner/lib/cores/ProcessClass.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata'
+import {MultipleRunnerBaseClass} from '../prototypes/MultipleRunnerBaseClass'
+
+export class ProcessClass extends MultipleRunnerBaseClass {
+    protected async setup(): Promise<void> {
+        return super.setup()
+    }
+}

package/src/lib/multipleRunner/lib/cores/ThreadClass.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata'
+import {MultipleRunnerBaseClass} from '../prototypes/MultipleRunnerBaseClass'
+
+export class ThreadClass extends MultipleRunnerBaseClass {
+    protected async setup(): Promise<void> {
+        return super.setup()
+    }
+}

package/src/lib/multipleRunner/lib/cores/UniParentBridgeHandler.ts

@@ -0,0 +1,97 @@
+import {BaseBridge} from '../bridges/BaseBridge'
+import {SETUP_ERROR} from '../../constants/Channel'
+
+export function UniParentBridgeHandler<T>(bridge: BaseBridge, className: string, classPath: string, classConstructor: any, callback: (setupError: Error, proxyInstance: T) => void): void {
+    const reservedMethodNames: Array<string> = ['off', 'on', 'once', 'emit', 'terminate']
+    bridge.on(SETUP_ERROR, (setupErrorMsg => {
+        callback(new Error(setupErrorMsg), null as any)
+    })).onReady((properties: { [key: string]: any }, propertyValues: { [key: string]: any }) => {
+        bridge.onPropertyChanged((property, value) => {
+            propertyValues[property] = value
+        })
+        const proxyHandler: any = new Proxy({}, {
+            get(target: T, p: PropertyKey): any {
+                if (reservedMethodNames.indexOf(p.toString()) > -1) {
+                    switch (p.toString()) {
+                        case 'off': {
+                            return new Proxy((...args: any[]) => {
+                            }, {
+                                apply(applyTarget: (...args: any[]) => void, thisArg: any, argArray?: any): any {
+                                    bridge.off.apply(bridge, argArray)
+                                }
+                            })
+                        }
+                        case 'on': {
+                            return new Proxy((...args: any[]) => {
+                            }, {
+                                apply(applyTarget: (...args: any[]) => void, thisArg: any, argArray?: any): any {
+                                    bridge.on.apply(bridge, argArray)
+                                }
+                            })
+                        }
+                        case 'once': {
+                            return new Proxy((...args: any[]) => {
+                            }, {
+                                apply(applyTarget: (...args: any[]) => void, thisArg: any, argArray?: any): any {
+                                    bridge.once.apply(bridge, argArray)
+                                }
+                            })
+                        }
+                        case 'emit': {
+                            return new Proxy((...args: any[]) => {
+                            }, {
+                                apply(applyTarget: (...args: any[]) => void, thisArg: any, argArray?: any): any {
+                                    bridge.send.apply(bridge, argArray)
+                                }
+                            })
+                        }
+                        case 'terminate': {
+                            return new Proxy((...args: any[]) => {
+                            }, {
+                                apply(applyTarget: (...args: any[]) => void, thisArg: any, argArray?: any): any {
+                                    return new Promise((resolve, reject) => {
+                                        bridge.terminate().then(resolve).catch(reject)
+                                    })
+                                }
+                            })
+                        }
+                        default:
+                            return undefined
+                    }
+                } else {
+                    const method = classConstructor.prototype[p]
+                    const isPropertyMethod: boolean = properties[p.toString()] === 'function'
+                    if (method || isPropertyMethod) {
+                        return new Proxy(isPropertyMethod ? (...args: any[]) => {
+                        } : method, {
+                            apply(target, thisArg: any, argArray?: any): any {
+                                const _argArray: any[] = []
+                                for (const _arg of argArray) {
+                                    if (typeof _arg !== 'function') {
+                                        _argArray.push(_arg)
+                                    } else {
+                                        _argArray.push(bridge.callbackHandler(thisArg, _arg))
+                                    }
+                                }
+                                return new Promise((resolve, reject) => {
+                                    bridge.invoke(p.toString(), _argArray).then(resolve).catch(reject)
+                                })
+                            }
+                        })
+                    } else if (properties[p.toString()]) {
+                        return propertyValues[p.toString()]
+                    } else {
+                        return undefined
+                    }
+                }
+            },
+            set(target: {}, p: PropertyKey, value: any, receiver: any): boolean {
+                bridge.set(p.toString(), value)
+                return true
+            }
+        })
+        bridge.off(SETUP_ERROR)
+        callback(null as any, proxyHandler)
+    })
+    bridge.send('create', className, classPath)
+}

package/src/lib/multipleRunner/lib/prototypes/MultipleRunnerBaseClass.ts

@@ -0,0 +1,66 @@
+import 'reflect-metadata'
+import {BaseBridge} from '../bridges/BaseBridge'
+import {MULTIPLE_RUNNER_CLASS_NAME, MULTIPLE_RUNNER__CLASS_PATH} from '../../constants/MetadataKey'
+
+export class MultipleRunnerBaseClass {
+	private readonly __bridge__: BaseBridge
+
+	public static get CLASS_PATH(): string {
+		if (!Reflect.getMetadata(MULTIPLE_RUNNER__CLASS_PATH, this)) {
+			const cachedModules = require('module')._cache
+			for (const modulePath of Object.keys(cachedModules)) {
+				const cachedModule = cachedModules[modulePath]
+				if (typeof cachedModule === 'object') {
+					const exports = cachedModule.exports
+					if (exports && typeof exports === 'object') {
+						for (const exportName of Object.keys(exports)) {
+							if (typeof exports[exportName] === 'function') {
+								if (exports[exportName] === this) {
+									Reflect.defineMetadata(MULTIPLE_RUNNER__CLASS_PATH, modulePath, this)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		return Reflect.getMetadata(MULTIPLE_RUNNER__CLASS_PATH, this)
+	}
+
+	public static get CLASS_NAME(): string {
+		if (!Reflect.getMetadata(MULTIPLE_RUNNER_CLASS_NAME, this)) {
+			Reflect.defineMetadata(MULTIPLE_RUNNER_CLASS_NAME, this.name, this)
+		}
+		return Reflect.getMetadata(MULTIPLE_RUNNER_CLASS_NAME, this)
+	}
+
+	constructor(bridge: BaseBridge) {
+		this.__bridge__ = bridge
+	}
+
+	protected async setup(): Promise<void> {
+		//Empty setup method
+	}
+
+	public off(event: string): void {
+		this.__bridge__.off(event)
+	}
+
+	public on(event: 'property-changed', handler: (property: string, value: any) => void): void
+	public on(event: 'error', handler: (error: Error) => void): void
+	public on(event: string, handler: (...args: any[]) => void): void
+	public on(event: string, handler: (...args: any[]) => void): void {
+		this.__bridge__.on(event, handler)
+	}
+
+	public once(event: 'property-changed', handler: (property: string, value: any) => void): void
+	public once(event: 'error', handler: (error: Error) => void): void
+	public once(event: string, handler: (...args: any[]) => void): void
+	public once(event: string, handler: (...args: any[]) => void): void {
+		this.__bridge__.once(event, handler)
+	}
+
+	public emit(event: string, ...args: any[]): void {
+		this.__bridge__.send.apply(this.__bridge__, [event].concat(args) as any)
+	}
+}