@lakutata/core 1.0.59 → 3.0.0-beta.0

package/src/plugins/HttpRequest.ts

@@ -1,241 +0,0 @@
-import {Plugin} from '../base/Plugin'
-import {
-	get as needleGet,
-	post as needlePost,
-	put as needlePut,
-	patch as needlePatch,
-	head as needleHead,
-	delete as needleDelete,
-	request as needleRequest, ReadableStream
-} from 'needle'
-import {URL} from 'url'
-import {NeedleOptions as HttpRequestOptions} from 'needle'
-import {HttpRequestException} from '../exceptions/HttpRequestException'
-import fs from 'fs'
-
-declare module '../Core' {
-	interface Application {
-		HttpRequest: HttpRequest
-	}
-}
-
-export class HttpRequest extends Plugin {
-	/**
-	 * Multipart上传
-	 * @param {{method?: "post" | "put", url: string | URL, filename?: string, file: string, contentType?: string, field?: string, options?: HttpRequestOptions}} setting
-	 * @returns {Promise<T>}
-	 */
-	public async multipartUpload<T = any>(setting: {
-		method?: 'post' | 'put',
-		url: string | URL,
-		filename?: string,
-		file: string,
-		contentType?: string,
-		field?: string,
-		options?: HttpRequestOptions
-	}): Promise<T> {
-		return new Promise((resolve, reject) => {
-			const method: 'post' | 'put' = setting.method ? setting.method : 'put'
-			const url: string = setting.url.toString()
-			const filename: string | undefined = setting.filename
-			const file: string = setting.file
-			const contentType: string = setting.contentType ? setting.contentType : 'application/octet-stream'
-			const field: string = setting.field ? setting.field : 'file'
-			const uploadDataObject = {
-				[field]: {
-					filename: filename,
-					content_type: contentType,
-					file: file
-				}
-			}
-			if (!fs.existsSync(file)) return reject(new HttpRequestException([`File [${file}] does not exist`, method.toUpperCase(), url]))
-			const fileStat: fs.Stats = fs.statSync(file)
-			if (!fileStat.isFile()) return reject(new HttpRequestException([`[${file}] is not file`, method.toUpperCase(), url]))
-			needleRequest(method, url, uploadDataObject, Object.assign(setting.options ? setting.options : {}, {multipart: true}), (error, response) => {
-				if (error) {
-					reject(new HttpRequestException([error.message, method.toUpperCase(), url.toString()]))
-				} else {
-					resolve(response.body)
-				}
-			})
-		})
-	}
-
-	/**
-	 * 文件下载
-	 * @param setting
-	 * @param {(exception: (HttpRequestException | null), isDone: boolean, progress: number) => void} progressCallback
-	 * @returns {Promise<void>}
-	 */
-	public async download(setting: {
-		                      method?: 'get' | 'post',
-		                      url: string | URL,
-		                      filename: string,
-		                      params?: { [key: string]: any } | string | null,
-		                      options?: HttpRequestOptions
-	                      },
-	                      progressCallback?: (exception: HttpRequestException | null, isDone: boolean, progress: number) => void): Promise<void> {
-		return new Promise((resolve, reject) => {
-			const method: 'get' | 'post' = setting.method ? setting.method : 'get'
-			const filename: string = setting.filename
-			const url: string = setting.url.toString()
-			const params: { [key: string]: any } | string | null = setting.params ? setting.params : null
-			const options: HttpRequestOptions = Object.assign(setting.options ? setting.options : {}, {output: filename})
-			const stream: ReadableStream = needleRequest(method, url, params, options)
-			let dataSize: number = 0
-			let receivedDataSize: number = 0
-			let progress: number = 0
-			const internalProgressCallback = (exception: HttpRequestException | null, isDone: boolean, progress: number) => {
-				if (progressCallback) progressCallback(exception, isDone, progress)
-				if (exception) {
-					reject(exception)
-				}
-				if (isDone) {
-					resolve()
-				}
-			}
-			stream
-				.on('header', (statusCode, headers) => {
-					dataSize = headers['content-length'] ? parseInt(headers['content-length']) : 0
-					internalProgressCallback(null, false, progress)
-				})
-				.on('readable', () => {
-					let chunk: Buffer | string
-					while (chunk = stream.read()) {
-						receivedDataSize += chunk.length
-						if (dataSize > 0) {
-							progress = (receivedDataSize / dataSize) * 100
-						} else {
-							progress = 0
-						}
-						fs.appendFileSync(filename, chunk)
-						internalProgressCallback(null, false, progress)
-					}
-				})
-				.on('done', (downloadError => {
-					let downloadException: HttpRequestException | null = null
-					if (downloadError) {
-						downloadException = new HttpRequestException([downloadError.message, method.toUpperCase(), url.toString()])
-					} else if (dataSize === 0) {
-						downloadException = new HttpRequestException(['Received 0 length data from server', method.toUpperCase(), url.toString()])
-					}
-					internalProgressCallback(downloadException, true, progress)
-				}))
-				.once('error', error => {
-					internalProgressCallback(new HttpRequestException([error.message, method.toUpperCase(), url.toString()]), false, progress)
-				})
-		})
-	}
-
-	/**
-	 * Get请求
-	 * @param {string | URL} url
-	 * @param {HttpRequestOptions} options
-	 * @returns {Promise<T>}
-	 */
-	public async get<T = any>(url: string | URL, options?: HttpRequestOptions): Promise<T> {
-		return new Promise((resolve, reject) => {
-			needleGet(url.toString(), options, (error, response) => {
-				if (error) {
-					reject(new HttpRequestException([error.message, 'GET', url.toString()]))
-				} else {
-					resolve(response.body)
-				}
-			})
-		})
-	}
-
-	/**
-	 * Post请求
-	 * @param {string | URL} url
-	 * @param body
-	 * @param {HttpRequestOptions} options
-	 * @returns {Promise<T>}
-	 */
-	public async post<T = any>(url: string | URL, body: { [key: string]: any } | string | Buffer | null, options?: HttpRequestOptions): Promise<T> {
-		return new Promise((resolve, reject) => {
-			needlePost(url.toString(), body, options, (error, response) => {
-				if (error) {
-					reject(new HttpRequestException([error.message, 'POST', url.toString()]))
-				} else {
-					resolve(response.body)
-				}
-			})
-		})
-	}
-
-	/**
-	 * Put请求
-	 * @param {string | URL} url
-	 * @param body
-	 * @param {HttpRequestOptions} options
-	 * @returns {Promise<T>}
-	 */
-	public async put<T = any>(url: string | URL, body: { [key: string]: any } | string | Buffer | null, options?: HttpRequestOptions): Promise<T> {
-		return new Promise((resolve, reject) => {
-			needlePut(url.toString(), body, options, (error, response) => {
-				if (error) {
-					reject(new HttpRequestException([error.message, 'PUT', url.toString()]))
-				} else {
-					resolve(response.body)
-				}
-			})
-		})
-	}
-
-	/**
-	 * Patch请求
-	 * @param {string | URL} url
-	 * @param body
-	 * @param {HttpRequestOptions} options
-	 * @returns {Promise<T>}
-	 */
-	public async patch<T = any>(url: string | URL, body: { [key: string]: any } | string | Buffer | null, options?: HttpRequestOptions): Promise<T> {
-		return new Promise((resolve, reject) => {
-			needlePatch(url.toString(), body, options, (error, response) => {
-				if (error) {
-					reject(new HttpRequestException([error.message, 'PATCH', url.toString()]))
-				} else {
-					resolve(response.body)
-				}
-			})
-		})
-	}
-
-	/**
-	 * Delete请求
-	 * @param {string | URL} url
-	 * @param body
-	 * @param {HttpRequestOptions} options
-	 * @returns {Promise<T>}
-	 */
-	public async delete<T = any>(url: string | URL, body: { [key: string]: any } | string | Buffer | null, options?: HttpRequestOptions): Promise<T> {
-		return new Promise((resolve, reject) => {
-			needleDelete(url.toString(), body, options, (error, response) => {
-				if (error) {
-					reject(new HttpRequestException([error.message, 'DELETE', url.toString()]))
-				} else {
-					resolve(response.body)
-				}
-			})
-		})
-	}
-
-	/**
-	 * Head请求
-	 * @param {string | URL} url
-	 * @param {HttpRequestOptions} options
-	 * @returns {Promise<boolean>}
-	 */
-	public async head(url: string | URL, options?: HttpRequestOptions): Promise<boolean> {
-		return new Promise((resolve) => {
-			needleHead(url.toString(), options, (error) => {
-				if (error) {
-					resolve(false)
-				} else {
-					resolve(true)
-				}
-			})
-		})
-	}
-}

package/src/plugins/JSON.ts

@@ -1,77 +0,0 @@
-import {Plugin} from '../base/Plugin'
-import {JSONParserV2} from 'json-helpers'
-import {Exception} from '../base/abstracts/Exception'
-
-declare module '../Core' {
-	interface Application {
-		JSON: JSON
-	}
-}
-
-class ParseException extends Exception {
-	constructor() {
-		super('')
-	}
-
-	public district: string
-	public errno: number
-}
-
-JSONParserV2.formatter<Exception | Error>({
-	objectType: 'Error',
-	objectConstructor: (Error as unknown) as ObjectConstructor,
-	serialize: (t: Exception | Error) => {
-		if (t instanceof Exception) {
-			return {
-				isException: true,
-				appId: t.appId,
-				appName: t.appName,
-				errMsg: t.errMsg,
-				err: t.err,
-				errno: t.errno,
-				stack: Buffer.from(t.stack ? t.stack : '').toString('base64')
-			}
-		} else {
-			return {
-				isException: false,
-				name: t.name,
-				message: t.message,
-				stack: Buffer.from(t.stack ? t.stack : '').toString('base64')
-			}
-		}
-	},
-	unserialize: (parsedErrorObject: any) => {
-		if (parsedErrorObject.isException) {
-			const unSerializeException = class extends ParseException {
-				public get name(): string {
-					return parsedErrorObject.err
-				}
-			}
-			return Object.assign(new unSerializeException(), {
-				message: parsedErrorObject.errMsg,
-				appId: parsedErrorObject.appId,
-				appName: parsedErrorObject.appName,
-				errMsg: parsedErrorObject.errMsg,
-				err: parsedErrorObject.err,
-				errno: parsedErrorObject.errno,
-				stack: Buffer.from(parsedErrorObject.stack, 'base64').toString()
-			})
-		} else {
-			const unSerializeError = new Error()
-			unSerializeError.name = parsedErrorObject.name
-			unSerializeError.message = parsedErrorObject.message
-			unSerializeError.stack = Buffer.from(parsedErrorObject.stack, 'base64').toString()
-			return unSerializeError
-		}
-	}
-})
-
-export class JSON extends Plugin {
-	public stringify<T = any>(value: T, replacer?: (key: string, value: any) => any, space?: string | number): string {
-		return JSONParserV2.stringify(value, replacer, space)
-	}
-
-	public parse<T = any>(text: string, reviver?: (key: string, value: any) => any): T {
-		return JSONParserV2.parse(text, reviver)
-	}
-}

package/src/plugins/Logger.ts

@@ -1,154 +0,0 @@
-import {Plugin} from '../base/Plugin'
-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 {
-		Logger: Logger
-	}
-}
-
-export class Logger extends Plugin {
-	private logger: WinstonLogger
-
-	@Configurable()
-	protected readonly level: 'emerg' | 'alert' | 'crit' | 'error' | 'warning' | 'notice' | 'info' | 'debug' = 'debug'
-
-	@Configurable()
-	protected readonly meta: object
-
-	@Configurable()
-	protected readonly transports: Transport[] | Transport = []
-
-	@Configurable()
-	protected readonly console: ConsoleTransportOptions = {
-		silent: false,
-		format: format.combine(
-			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}`
-			})
-		)
-	}
-
-	protected onActivation() {
-		const loggerTransports = this.transports ? (Array.isArray(this.transports) ? this.transports : [this.transports]) : []
-		let hasConsole: boolean = false
-		for (const loggerTransport of loggerTransports) {
-			if (loggerTransport instanceof transports.Console) {
-				hasConsole = true
-				break
-			}
-		}
-		if (!hasConsole) {
-			loggerTransports.unshift(new transports.Console(this.console))
-		}
-		this.logger = createLogger({
-			level: this.level,
-			defaultMeta: this.meta,
-			levels: {
-				emerg: 0,
-				alert: 1,
-				crit: 2,
-				error: 3,
-				warning: 4,
-				notice: 5,
-				info: 6,
-				debug: 7
-			},
-			transports: loggerTransports
-		})
-	}
-
-	/**
-	 * 格式化日志输入参数
-	 * @param {any[]} args
-	 * @returns {string}
-	 * @protected
-	 */
-	protected formatArguments(args: any[]): string {
-		return utilFormat.apply(utilFormat, args)
-	}
-
-	/**
-	 * 紧急
-	 * @param args
-	 * @description 系统不可用
-	 */
-	public emerg(...args: any[]): void {
-		this.logger.emerg(this.formatArguments(args))
-	}
-
-	/**
-	 * 报警
-	 * @param args
-	 * @description 必须马上采取行动的事件
-	 */
-	public alert(...args: any[]) {
-		this.logger.alert(this.formatArguments(args))
-	}
-
-	/**
-	 * 关键
-	 * @param args
-	 * @description 关键的事件
-	 */
-	public crit(...args: any[]) {
-		this.logger.crit(this.formatArguments(args))
-	}
-
-	/**
-	 * 错误
-	 * @param args
-	 * @description 错误事件
-	 */
-	public error(...args: any[]) {
-		this.logger.error(this.formatArguments(args))
-	}
-
-	/**
-	 * 警告
-	 * @param args
-	 * @description 警告事件
-	 */
-	public warning(...args: any[]) {
-		this.logger.warning(this.formatArguments(args))
-	}
-
-	/**
-	 * 通知
-	 * @param args
-	 * @description 普通但重要的事件
-	 */
-	public notice(...args: any[]) {
-		this.logger.notice(this.formatArguments(args))
-	}
-
-	/**
-	 * 消息
-	 * @param args
-	 * @description 有用的信息
-	 */
-	public info(...args: any[]) {
-		this.logger.info(this.formatArguments(args))
-	}
-
-	/**
-	 * 调试
-	 * @param args
-	 * @description 调试信息
-	 */
-	public debug(...args: any[]) {
-		this.logger.debug(this.formatArguments(args))
-	}
-}

package/src/plugins/MessagePack.ts

@@ -1,30 +0,0 @@
-import {Plugin} from '../base/Plugin'
-import msgpack from 'msgpack5'
-import {Buffer} from 'buffer'
-
-declare module '../Core' {
-	interface Application {
-		MessagePack: MessagePack
-	}
-}
-
-export class MessagePack extends Plugin {
-	/**
-	 * 编码数据
-	 * @param {T} inp
-	 * @returns {Buffer}
-	 */
-	public encode<T = any>(inp: T): Buffer {
-		const hexData = msgpack().encode(inp).toString('hex')
-		return Buffer.from(hexData, 'hex')
-	}
-
-	/**
-	 * 解码数据
-	 * @param {Buffer} data
-	 * @returns {T}
-	 */
-	public decode<T = any>(data: Buffer): T {
-		return msgpack().decode(data)
-	}
-}