@lakutata/core 1.0.60 → 3.0.0-beta.1

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

@@ -1,118 +0,0 @@
-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)
-			})
-			.on('error', bridgeError => {
-			})
-	}
-
-	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, (invokeError: Error, result: any) => {
-				if (invokeError) {
-					reject(invokeError)
-				} 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, 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

@@ -1,22 +0,0 @@
-import {BaseBridge} from './BaseBridge'
-import {ChildProcess} from 'child_process'
-
-export class ProcessBridge extends BaseBridge {
-
-	public send(channel: string, ...args: any[]) {
-		const childProcessBridge: ChildProcess = this.bridge
-		if (childProcessBridge.connected) {
-			childProcessBridge.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

@@ -1,20 +0,0 @@
-import {BaseBridge} from './BaseBridge'
-import {Worker} from 'worker_threads'
-
-export class ThreadBridge extends BaseBridge {
-
-	public send(channel: string, ...args: any[]): void {
-		try {
-			const workerThreadBridge: Worker = this.bridge
-			workerThreadBridge.postMessage({
-				channel: channel,
-				args: args
-			})
-		} catch (e) {
-		}
-	}
-
-	public async terminate(): Promise<void> {
-		await this.bridge.terminate()
-	}
-}

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

@@ -1,28 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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)) {
-							try {
-								if (typeof exports[exportName] === 'function') {
-									if (exports[exportName] === this) {
-										Reflect.defineMetadata(MULTIPLE_RUNNER__CLASS_PATH, modulePath, this)
-									}
-								}
-							} catch (e) {
-								//Do nothing, just catch error to prevent application crash
-							}
-						}
-					}
-				}
-			}
-		}
-		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

@@ -1,140 +0,0 @@
-import {Plugin} from '../base/Plugin'
-import NodeRSA, {FormatComponentsPrivate, FormatComponentsPublic} from 'node-rsa'
-import {CryptoException} from '../exceptions/CryptoException'
-import {JSON} from './JSON'
-import {Configurable, Inject} from '../decorators/DependencyInjection'
-
-declare module '../Core' {
-	interface Application {
-		Crypto: Crypto
-	}
-}
-
-export class Crypto extends Plugin {
-	@Inject('JSON')
-	private readonly JSON: JSON
-
-	/**
-	 * 密钥bits长度
-	 * @type {number}
-	 * @private
-	 */
-	@Configurable()
-	private readonly bits: number = 512
-
-	/**
-	 * 生成密钥对
-	 * @param {"PKCS8" | "PKCS1"} format
-	 * @returns {{private: string, public: string}}
-	 */
-	public generateKeyPair(format: 'PKCS8' | 'PKCS1' = 'PKCS8'): { private: string; public: string } {
-		const key = new NodeRSA({b: this.bits})
-		let publicKeyFormat: string = 'public-pem'
-		let privateKeyFormat: string = 'private-pem'
-		switch (format) {
-			case 'PKCS8': {
-				publicKeyFormat = `pkcs8-${publicKeyFormat}`
-				privateKeyFormat = `pkcs8-${privateKeyFormat}`
-			}
-				break
-			case 'PKCS1': {
-				publicKeyFormat = `pkcs1-${publicKeyFormat}`
-				privateKeyFormat = `pkcs1-${privateKeyFormat}`
-			}
-				break
-			default: {
-				publicKeyFormat = `pkcs8-${publicKeyFormat}`
-				privateKeyFormat = `pkcs8-${privateKeyFormat}`
-			}
-		}
-		return {
-			private: key.exportKey(privateKeyFormat as FormatComponentsPrivate).toString(),
-			public: key.exportKey(publicKeyFormat as FormatComponentsPublic).toString()
-		}
-	}
-
-	/**
-	 * 数据签名
-	 * @param data
-	 * @param {string} privateKey
-	 * @returns {string}
-	 */
-	public sign(data: any, privateKey: string): string {
-		const key = new NodeRSA()
-		key.importKey(privateKey)
-		if (key.isEmpty()) throw new CryptoException('Cannot sign data with empty key')
-		if (!key.isPrivate()) throw new CryptoException('Only allow private key for data signing')
-		const bufferData: Buffer = Buffer.from(typeof data === 'string' ? data : this.JSON.stringify(data))
-		return key.sign(bufferData).toString('base64')
-	}
-
-	/**
-	 * 验证数据签名
-	 * @param data
-	 * @param {string} sign
-	 * @param {string} secretKey
-	 * @returns {boolean}
-	 */
-	public verify(data: any, sign: string, secretKey: string): boolean {
-		const key = new NodeRSA()
-		key.importKey(secretKey)
-		if (key.isEmpty()) throw new CryptoException('Cannot verify data sign with empty key')
-		const bufferData: Buffer = Buffer.from(typeof data === 'string' ? data : this.JSON.stringify(data))
-		return key.verify(bufferData, Buffer.from(sign, 'base64'))
-	}
-
-	/**
-	 * 加密数据
-	 * @param data
-	 * @param {string} secretKey
-	 * @returns {string}
-	 */
-	public encrypt(data: any, secretKey: string): string {
-		const key = new NodeRSA()
-		key.importKey(secretKey)
-		if (key.isEmpty()) throw new CryptoException('Cannot encrypt data by empty key')
-		const bufferData: Buffer = Buffer.from(typeof data === 'string' ? data : this.JSON.stringify(data))
-		if (key.isPublic(true)) {
-			return key.encrypt(bufferData).toString('base64')
-		} else {
-			return key.encryptPrivate(bufferData).toString('base64')
-		}
-	}
-
-	/**
-	 * 解密数据
-	 * @param {string} encryptedData
-	 * @param {string} secretKey
-	 * @returns {any}
-	 */
-	public decrypt(encryptedData: string, secretKey: string): any {
-		const key = new NodeRSA()
-		key.importKey(secretKey)
-		if (key.isEmpty()) throw new CryptoException('Cannot decrypt data by empty key')
-		const bufferData: Buffer = Buffer.from(encryptedData, 'base64')
-		const decryptedData: string = (() => {
-			let decryptResult: string = ''
-			let decryptException: CryptoException = new CryptoException('Unknown decrypt exception')
-			try {
-				if (key.isPrivate() && !decryptResult) decryptResult = key.decrypt(bufferData).toString()
-			} catch (e) {
-				decryptException = new CryptoException((e as Error).message)
-			}
-			try {
-				if (key.isPublic() && !decryptResult) decryptResult = key.decryptPublic(bufferData).toString()
-			} catch (e) {
-				decryptException = new CryptoException((e as Error).message)
-			}
-			if (decryptResult) {
-				return decryptResult
-			} else {
-				throw decryptException
-			}
-		})()
-		try {
-			return this.JSON.parse(decryptedData)
-		} catch (e) {
-			return decryptedData
-		}
-	}
-}

package/src/plugins/Formatter.ts

@@ -1,83 +0,0 @@
-import {Plugin} from '../base/Plugin'
-import momentTimezone from 'moment-timezone'
-import {Configurable} from '../decorators/DependencyInjection'
-import sortKeys from 'sort-keys'
-
-declare module '../Core' {
-	interface Application {
-		Formatter: Formatter
-	}
-}
-
-export class Formatter extends Plugin {
-
-	protected get timezone(): string {
-		return <string>process.env.TZ
-	}
-
-	/**
-	 * 默认时间格式
-	 * @type {string}
-	 * @protected
-	 */
-	@Configurable()
-	protected readonly dateFormat: string = 'YYYY-MM-DD HH:mm:ss'
-
-	/**
-	 * 格式化为秒时间戳
-	 * @param {string | number | Date} inp
-	 * @returns {number}
-	 */
-	public asTimestamp(inp: string | number | Date = new Date()): number {
-		return momentTimezone.tz(inp, this.timezone).unix()
-	}
-
-	/**
-	 * 格式化为毫秒时间戳
-	 * @param {string | number | Date} inp
-	 * @returns {number}
-	 */
-	public asMillisecondTimestamp(inp: string | number | Date = new Date()): number {
-		return momentTimezone.tz(inp, this.timezone).valueOf()
-	}
-
-	/**
-	 * 格式化为Date对象
-	 * @param {string | number | Date} inp
-	 * @returns {Date}
-	 */
-	public asDate(inp: string | number | Date): Date {
-		return momentTimezone.tz(inp, this.timezone).toDate()
-	}
-
-	/**
-	 * 格式化时间
-	 * @param {Date | string | number} inp
-	 * @param {string} format
-	 * @returns {string}
-	 */
-	public asDateText(inp: Date | string | number = new Date(), format?: string): string {
-		return momentTimezone.tz(inp, this.timezone).format(format ? format : this.dateFormat)
-	}
-
-	/**
-	 * 百分比格式化
-	 * @param {number} value
-	 * @param {number} decimals
-	 * @returns {string}
-	 */
-	public asPercent(value: number, decimals: number = 2): string {
-		const val: number = +((value * 100).toFixed(decimals))
-		return `${val}%`
-	}
-
-	/**
-	 * 对象内容排序（Object或Array均可）
-	 * @param {T} obj
-	 * @param {{deep?: boolean, compare?: (left: string, right: string) => number}} options
-	 * @returns {T}
-	 */
-	public sortObject<T = any>(obj: T, options?: { deep?: boolean; compare?: (left: string, right: string) => number }): T {
-		return sortKeys(obj, options ? options : {deep: true})
-	}
-}