@lakutata/core 1.0.28 → 1.0.32

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)
+	}
+}

package/src/plugins/Crypto.ts

@@ -118,12 +118,12 @@ export class Crypto extends Plugin {
 			try {
 				if (key.isPrivate() && !decryptResult) decryptResult = key.decrypt(bufferData).toString()
 			} catch (e) {
-				decryptException = new CryptoException(e.message)
+				decryptException = new CryptoException((e as Error).message)
 			}
 			try {
 				if (key.isPublic() && !decryptResult) decryptResult = key.decryptPublic(bufferData).toString()
 			} catch (e) {
-				decryptException = new CryptoException(e.message)
+				decryptException = new CryptoException((e as Error).message)
 			}
 			if (decryptResult) {
 				return decryptResult
@@ -137,4 +137,4 @@ export class Crypto extends Plugin {
 			return decryptedData
 		}
 	}
-}
+}

package/src/plugins/Formatter.ts

@@ -1,5 +1,5 @@
 import {Plugin} from '../base/Plugin'
-import moment from 'moment'
+import momentTimezone from 'moment-timezone'
 import {Configurable} from '../decorators/DependencyInjection'
 
 declare module '../Core' {
@@ -9,6 +9,11 @@ declare module '../Core' {
 }
 
 export class Formatter extends Plugin {
+
+	protected get timezone(): string {
+		return <string>process.env.TZ
+	}
+
 	/**
 	 * 默认时间格式
 	 * @type {string}
@@ -23,7 +28,7 @@ export class Formatter extends Plugin {
 	 * @returns {number}
 	 */
 	public asTimestamp(inp: string | number | Date = new Date()): number {
-		return moment(inp).unix()
+		return momentTimezone.tz(inp, this.timezone).unix()
 	}
 
 	/**
@@ -32,7 +37,7 @@ export class Formatter extends Plugin {
 	 * @returns {number}
 	 */
 	public asMillisecondTimestamp(inp: string | number | Date = new Date()): number {
-		return moment(inp).valueOf()
+		return momentTimezone.tz(inp, this.timezone).valueOf()
 	}
 
 	/**
@@ -41,7 +46,7 @@ export class Formatter extends Plugin {
 	 * @returns {Date}
 	 */
 	public asDate(inp: string | number | Date): Date {
-		return moment(inp).toDate()
+		return momentTimezone.tz(inp, this.timezone).toDate()
 	}
 
 	/**
@@ -51,7 +56,7 @@ export class Formatter extends Plugin {
 	 * @returns {string}
 	 */
 	public asDateText(inp: Date | string | number = new Date(), format?: string): string {
-		return moment(inp).format(format ? format : this.dateFormat)
+		return momentTimezone.tz(inp, this.timezone).format(format ? format : this.dateFormat)
 	}
 
 	/**

package/src/plugins/Logger.ts

@@ -1,9 +1,11 @@
 import {Plugin} from '../base/Plugin'
-import {createLogger, Logger as WinstonLogger, transports, format} from 'winston'
+import {createLogger, Logger as WinstonLogger, transports} from 'winston'
 import {Configurable} from '../decorators/DependencyInjection'
 import * as Transport from 'winston-transport'
 import {format as utilFormat} from 'util'
 import {ConsoleTransportOptions} from 'winston/lib/winston/transports'
+import momentTimezone from 'moment-timezone'
+import {TimestampOptions, format} from 'logform'
 
 declare module '../Core' {
 	interface Application {
@@ -27,7 +29,11 @@ export class Logger extends Plugin {
 	protected readonly console: ConsoleTransportOptions = {
 		silent: false,
 		format: format.combine(
-			format.timestamp({format: 'YYYY-MM-DD HH:mm:ss'}),
+			format.timestamp({
+				format: () => {
+					return momentTimezone.tz(Date.now(), <string>process.env.TZ).format('YYYY-MM-DD HH:mm:ss')
+				}
+			}),
 			format.colorize(),
 			format.printf(packet => {
 				return `${packet.timestamp} ${packet.level}: ${packet.message}`