@fastcar/core 0.2.38

package/src/type/WinstonLoggerType.ts

@@ -0,0 +1,18 @@
+export type WinstonLoggerType = {
+	consoleLevel: string;
+	fileLevel: string;
+	rootPath: string; //日志路径
+	maxsize: number; //字节
+	maxFiles: number; //最大文件数
+	printConsole: boolean; //是否在控制台模式
+};
+
+export const ColorLevelType = {
+	info: [32, 39], //green
+
+	debug: [36, 39], // cyan
+
+	warn: [33, 39], //yellow
+
+	error: [91, 39], //red
+};

package/src/utils/ClassLoader.ts

@@ -0,0 +1,72 @@
+import TypeUtil from "./TypeUtil";
+import FileUtil from "./FileUtil";
+import * as fs from "fs";
+import * as path from "path";
+
+export default class ClassLoader {
+	/***
+	 * @version 1.0 加载模块
+	 * @version 1.1 新增是否强制重载模块
+	 *
+	 */
+	static loadModule(filePath: string, force: boolean = false): Map<string, any> | null {
+		//校验后缀名是否为js或者ts
+		if (!TypeUtil.isTSORJS(filePath)) {
+			return null;
+		}
+
+		//避免重复加载或者想要重新进行挂载
+		if (Reflect.has(require.cache, filePath)) {
+			if (force) {
+				Reflect.deleteProperty(require.cache, filePath);
+			}
+		}
+
+		//可能不止一个方法
+		const modulesMap = new Map<string, Object>();
+		//进行方法加载
+		let moduleClass = require(filePath);
+		let keys = Object.keys(moduleClass);
+		let fileName = FileUtil.getFileName(filePath);
+
+		keys.forEach((key) => {
+			let instance = moduleClass[key];
+
+			if (TypeUtil.isFunction(instance)) {
+				modulesMap.set(instance.name, instance);
+				return;
+			}
+
+			if (TypeUtil.isObject(instance)) {
+				modulesMap.set(fileName, instance);
+			}
+		});
+
+		return modulesMap;
+	}
+
+	/**
+	 * @version 1.0 监听某个文件或者文件夹
+	 */
+	static watchServices(fp: string, context: any, eventName: string = "reload"): boolean {
+		if (typeof context.emit != "function") {
+			return false;
+		}
+
+		const currStats = fs.statSync(fp);
+		let fileFlag = currStats.isFile();
+
+		//添加热更方法
+		fs.watch(fp, function (event, filename) {
+			if (event === "change") {
+				if (!fileFlag) {
+					context.emit(eventName, path.join(fp, filename));
+				} else {
+					context.emit(eventName, fp);
+				}
+			}
+		});
+
+		return true;
+	}
+}

package/src/utils/ClassUtils.ts

@@ -0,0 +1,38 @@
+export default class ClassUtils {
+	//获取一个类所有的proto属性 采用递归的形式
+	static getProtoType(t: any): (string | symbol)[] {
+		if (!t?.prototype) {
+			return [];
+		}
+		let keys: (string | symbol)[] = Reflect.ownKeys(t?.prototype).map((item) => {
+			return item;
+		});
+
+		let parentObj = Reflect.getPrototypeOf(t);
+		if (!parentObj || !Reflect.has(parentObj, "prototype")) {
+			return keys;
+		}
+
+		let parentKeys = ClassUtils.getProtoType(parentObj);
+		let s = new Set([...keys, ...parentKeys]);
+
+		return [...s];
+	}
+
+	static getProtoDesc(t: any, key: string | symbol): PropertyDescriptor | null {
+		if (!t?.prototype) {
+			return null;
+		}
+		let desc = Object.getOwnPropertyDescriptor(t.prototype, key);
+		if (!!desc) {
+			return desc;
+		}
+
+		let parentObj = Reflect.getPrototypeOf(t);
+		if (!parentObj || !Reflect.has(parentObj, "prototype")) {
+			return null;
+		}
+
+		return ClassUtils.getProtoDesc(parentObj, key);
+	}
+}

package/src/utils/CryptoUtil.ts

@@ -0,0 +1,106 @@
+import * as crypto from "crypto";
+import { BinaryToTextEncoding } from "crypto";
+
+const enum serects {
+	aes = "aes-256-cbc",
+	sha256 = "sha256",
+}
+
+export default class CryptoUtil {
+	static aesDecode(cryptkey: string, iv: string, secretdata: string, aesType: string = serects.aes): string {
+		let decipher = crypto.createDecipheriv(aesType, cryptkey, iv);
+		let decoded = decipher.update(secretdata, "base64", "utf8");
+
+		decoded += decipher.final("utf8");
+		return decoded;
+	}
+
+	static aesEncode(cryptkey: string, iv: string, cleardata: string, aesType: string = serects.aes): string {
+		let encipher = crypto.createCipheriv(serects.aes, cryptkey, iv);
+		let encoded = encipher.update(cleardata, "utf8", "base64");
+
+		encoded += encipher.final("base64");
+		return encoded;
+	}
+
+	static shaEncode(cryptkey: string, data: string): string {
+		let hash = crypto.createHmac("sha256", cryptkey);
+		return hash.update(data).digest("base64");
+	}
+
+	static gcmEncrypt(password: string, msg: string): string | null {
+		try {
+			let pwd = Buffer.from(password, "hex");
+			let iv = crypto.randomBytes(12);
+			let cipher = crypto.createCipheriv("aes-128-gcm", pwd, iv);
+
+			//加密
+			let enc = cipher.update(msg, "utf8", "base64");
+			enc += cipher.final("base64");
+
+			//cipher.getAuthTag() 方法返回一个 Buffer，它包含已从给定数据计算后的认证标签。
+			//cipher.getAuthTag() 方法只能在使用 cipher.final() 之后调用 这里返回的是一个十六进制后的数组
+			let tags = cipher.getAuthTag();
+			let encStr = Buffer.from(enc, "base64");
+
+			//由于和java对应的AES/GCM/PKCS5Padding模式对应 所以采用这个拼接
+			let totalLength = iv.length + encStr.length + tags.length;
+			let bufferMsg = Buffer.concat([iv, encStr, tags], totalLength);
+
+			return bufferMsg.toString("base64");
+		} catch (e) {
+			console.log("Encrypt is error", e);
+			return null;
+		}
+	}
+
+	static gcmDecrypt(password: string, serect: string): string | null {
+		try {
+			let tmpSerect = Buffer.from(serect, "base64");
+			let pwd = Buffer.from(password, "hex");
+
+			//读取数组
+			let iv = tmpSerect.slice(0, 12);
+			let cipher = crypto.createDecipheriv("aes-128-gcm", pwd, iv);
+
+			//这边的数据为 去除头的iv12位和尾部的tags的16位
+			let msg = cipher.update(tmpSerect.slice(12, tmpSerect.length - 16));
+
+			return msg.toString("utf8");
+		} catch (e) {
+			console.log("Decrypt is error", e);
+			return null;
+		}
+	}
+
+	static sha256Encode(text: string, serect: string = crypto.randomBytes(32).toString("hex"), encoding: BinaryToTextEncoding = "base64"): { salt: string; msg: string } {
+		let msg = crypto
+			.createHmac("sha256", serect)
+			.update(text)
+			.digest(encoding);
+
+		return {
+			salt: serect,
+			msg: msg,
+		};
+	}
+
+	static sha256EncodeContent(str: string, encoding: BinaryToTextEncoding = "base64"): string {
+		let msg = crypto
+			.createHash("sha256")
+			.update(str)
+			.digest(encoding);
+
+		return msg;
+	}
+
+	static sha256Very(msg: string, serect: string, encodeMsg: string, encoding: BinaryToTextEncoding = "base64"): boolean {
+		let result = this.sha256Encode(msg, serect, encoding);
+
+		return result.msg === encodeMsg;
+	}
+
+	static getHashStr(num: number = 16): string {
+		return crypto.randomBytes(num).toString("hex");
+	}
+}

package/src/utils/DataFormat.ts

@@ -0,0 +1,97 @@
+/***
+ * @version 1.0 数据格式处理
+ */
+class DataFormat {
+	static formatNumber(value: any, type: string): number | null {
+		if (type === "int") {
+			return parseInt(value);
+		}
+
+		if (type === "float" || type == "number") {
+			return parseFloat(value);
+		}
+
+		return null;
+	}
+
+	static formatString(value: any): string | null {
+		if (typeof value != "string") {
+			if (typeof value == "number") {
+				return value + "";
+			}
+			if (typeof value == "object") {
+				if (Reflect.has(value, "toString")) {
+					return value.toString();
+				}
+			}
+			return null;
+		}
+
+		return value;
+	}
+
+	static formatBoolean(value: any): boolean {
+		if (typeof value == "string") {
+			if (value == "false") {
+				return false;
+			}
+		}
+
+		return !!value;
+	}
+
+	static formatArray(value: any[], type: string): any[] {
+		if (type.startsWith("array")) {
+			if (typeof value === "string") {
+				value = JSON.parse(value);
+			}
+
+			if (Array.isArray(value)) {
+				let ntype = type.replace(/array/, "");
+				value = value.map((item) => {
+					return DataFormat.formatValue(item, ntype);
+				});
+
+				return value;
+			}
+		}
+
+		return [];
+	}
+
+	static formatDate(value: any): Date {
+		if (value instanceof Date) {
+			return value;
+		}
+
+		return new Date(value);
+	}
+
+	static formatValue(value: any, type: string): any {
+		if (type.startsWith("array")) {
+			return DataFormat.formatArray(value, type);
+		}
+
+		switch (type) {
+			case "string": {
+				return DataFormat.formatString(value);
+			}
+			case "boolean": {
+				return DataFormat.formatBoolean(value);
+			}
+			case "int":
+			case "float":
+			case "number": {
+				return DataFormat.formatNumber(value, type);
+			}
+			case "date": {
+				return DataFormat.formatDate(value);
+			}
+			default: {
+				return value;
+			}
+		}
+	}
+}
+
+export default DataFormat;

package/src/utils/DateUtil.ts

@@ -0,0 +1,85 @@
+export default class DateUtil {
+	static twoDigits(num: number): string {
+		return num.toString().padStart(2, "0");
+	}
+
+	//返回年月日时分秒
+	static toDateDesc(datetime: number | string | Date = Date.now()) {
+		let dataC = new Date(datetime);
+		return {
+			YYYY: DateUtil.twoDigits(dataC.getFullYear()),
+			MM: DateUtil.twoDigits(dataC.getMonth() + 1),
+			DD: DateUtil.twoDigits(dataC.getDate()),
+			hh: DateUtil.twoDigits(dataC.getHours()),
+			mm: DateUtil.twoDigits(dataC.getMinutes()),
+			ss: DateUtil.twoDigits(dataC.getSeconds()),
+			ms: DateUtil.twoDigits(dataC.getMilliseconds()),
+		};
+	}
+
+	static toDay(datetime: number | string | Date = Date.now(), format: string = "YYYY-MM-DD") {
+		let desc = DateUtil.toDateDesc(datetime);
+		let ymd = format.replace(/YYYY/, desc.YYYY).replace(/MM/, desc.MM).replace(/DD/, desc.DD);
+		return ymd;
+	}
+
+	static toHms(datetime: number | string | Date = Date.now(), format: string = "hh:mm:ss") {
+		let desc = DateUtil.toDateDesc(datetime);
+		let hms = format.replace(/hh/, desc.hh).replace(/mm/, desc.mm).replace(/ss/, desc.ss);
+
+		return hms;
+	}
+
+	static toDateTime(datetime: number | string | Date = Date.now(), format: string = "YYYY-MM-DD hh:mm:ss"): string {
+		let desc = DateUtil.toDateDesc(datetime);
+		let str = format.replace(/YYYY/, desc.YYYY).replace(/MM/, desc.MM).replace(/DD/, desc.DD).replace(/hh/, desc.hh).replace(/mm/, desc.mm).replace(/ss/, desc.ss);
+
+		return str;
+	}
+
+	static toDateTimeMS(datetime: number | string | Date = Date.now(), format: string = "YYYY-MM-DD hh:mm:ss.sss"): string {
+		let desc = DateUtil.toDateDesc(datetime);
+		let str = format.replace(/YYYY/, desc.YYYY).replace(/MM/, desc.MM).replace(/DD/, desc.DD).replace(/hh/, desc.hh).replace(/mm/, desc.mm).replace(/ss/, desc.ss).replace(/sss/, desc.ms);
+
+		return str;
+	}
+
+	static toCutDown(datetime: number, format: string = "hh:mm:ss"): string {
+		let hours = Math.floor(datetime / 60 / 60);
+		let minutes = Math.floor((datetime - hours * 60 * 60) / 60);
+		let seconds = datetime - (hours * 60 + minutes) * 60;
+
+		let str = format.replace(/hh/, hours.toString()).replace(/mm/, minutes.toString()).replace(/ss/, seconds.toString());
+
+		return str;
+	}
+
+	static getTimeStr(datetime: number): string {
+		let days = datetime / (1000 * 60 * 60 * 24);
+		if (days >= 1) {
+			return `${days.toFixed(2)}d`;
+		}
+
+		let hours = datetime / (1000 * 60 * 60);
+		if (hours >= 1) {
+			return `${hours.toFixed(2)}h`;
+		}
+
+		let minutes = datetime / (1000 * 60);
+		if (minutes >= 1) {
+			return `${minutes.toFixed(2)}m`;
+		}
+
+		let seconds = datetime / 1000;
+		return `${Math.floor(seconds)}s`;
+	}
+
+	static getDateTime(datetimeStr?: string | number): number {
+		if (datetimeStr) {
+			let dataC = new Date(datetimeStr);
+			return dataC.getTime();
+		}
+
+		return Date.now();
+	}
+}

package/src/utils/FileUtil.ts

@@ -0,0 +1,172 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+import { SYSConfig, SYSDefaultConfig } from "../config/SysConfig";
+import { CommonConstant, FileResSuffix } from "../constant/CommonConstant";
+import MixTool from "./Mix";
+
+const fileResSuffix = ["json", "yml", "js"]; //文件资源后缀名
+const bytesUnit = ["B", "K", "M", "G"];
+
+export default class FileUtil {
+	/***
+	 * @version 1.0 获取文件路径
+	 *
+	 */
+	static getFilePathList(filePath: string): string[] {
+		let pathList: string[] = Array.of();
+
+		let existFlag = fs.existsSync(filePath);
+		if (!existFlag) {
+			return pathList;
+		}
+
+		let currStats = fs.statSync(filePath);
+		let cfile = currStats.isFile();
+		let cdir = currStats.isDirectory();
+
+		if (!cdir && !cfile) {
+			return pathList;
+		}
+
+		if (cfile) {
+			pathList.push(filePath);
+			return pathList;
+		}
+
+		let childPaths = fs.readdirSync(filePath);
+		for (let c of childPaths) {
+			let fullPath = path.join(filePath, c);
+			let tmpStats = fs.statSync(fullPath);
+
+			if (tmpStats.isDirectory()) {
+				let childPaths = FileUtil.getFilePathList(fullPath);
+				if (childPaths.length > 0) {
+					pathList = [...pathList, ...childPaths];
+				}
+			} else if (tmpStats.isFile()) {
+				pathList.push(fullPath);
+			}
+		}
+
+		return pathList;
+	}
+
+	/***
+	 * @version 1.0 获取后缀名
+	 *
+	 */
+	static getSuffix(filePath: string): string {
+		let lastIndex = filePath.lastIndexOf(".") + 1;
+		if (lastIndex <= 0) {
+			return "";
+		}
+		let suffix = filePath.substring(lastIndex);
+		return suffix;
+	}
+
+	/***
+	 * @version 1.0 获取文件的文件名
+	 */
+	static getFileName(filePath: string): string {
+		let pList = filePath.split(path.sep);
+		let lastPath = pList[pList.length - 1];
+		let lastName = lastPath.split(".");
+
+		return lastName[0];
+	}
+
+	//加载配置文件
+	static getResource(fp: string): object | null {
+		let currSuffix = FileUtil.getSuffix(fp);
+		if (!fileResSuffix.includes(currSuffix)) {
+			return null;
+		}
+
+		if (fs.existsSync(fp)) {
+			let currStats = fs.statSync(fp);
+			if (currStats.isFile()) {
+				//进行解析
+				let content = fs.readFileSync(fp, "utf-8");
+				switch (currSuffix) {
+					case "yml": {
+						return yaml.parse(content);
+					}
+					case "json": {
+						return JSON.parse(content);
+					}
+					case "js":
+					case "ts": {
+						if (Reflect.has(require.cache, fp)) {
+							Reflect.deleteProperty(require.cache, fp);
+						}
+
+						return require(fp);
+					}
+					default: {
+						return null;
+					}
+				}
+			}
+		}
+
+		return null;
+	}
+
+	//格式化字节大小
+	static formatBytes(n: number): string {
+		for (let i = 0; i < bytesUnit.length; i++) {
+			let nn = n / Math.pow(1024, i);
+			if (nn <= 1024) {
+				return `${nn.toFixed(2)}(${bytesUnit[i]})`;
+			}
+		}
+
+		let maxL = bytesUnit.length - 1;
+		return `${(n / Math.pow(1024, maxL)).toFixed(2)}(${bytesUnit[maxL]})`;
+	}
+
+	//获取加载配置项
+	static getApplicationConfig(resPath: string, configName: string, sysConfig: SYSConfig = SYSDefaultConfig): SYSConfig {
+		const replaceSetting = (property: string, fileContent: object) => {
+			let addConfig = Reflect.get(fileContent, property);
+			if (addConfig) {
+				let currConfig = Reflect.get(sysConfig, property);
+				Reflect.deleteProperty(fileContent, property);
+				if (CommonConstant.Settings == property) {
+					Object.keys(addConfig).forEach((key) => {
+						let afterConfig = addConfig[key];
+						let beforeConfig = sysConfig.settings.get(key);
+						if (beforeConfig) {
+							//对settings的属性进行覆盖
+							if (typeof beforeConfig == "object") {
+								afterConfig = Object.assign(beforeConfig, afterConfig);
+							}
+						}
+						sysConfig.settings.set(key, afterConfig);
+					});
+				} else {
+					Object.assign(currConfig, addConfig);
+				}
+			}
+		};
+
+		FileResSuffix.forEach((suffix) => {
+			let fileContent = FileUtil.getResource(path.join(resPath, `${configName}.${suffix}`));
+			if (fileContent) {
+				replaceSetting(CommonConstant.Settings, fileContent);
+
+				replaceSetting(CommonConstant.Application, fileContent);
+
+				//将application和sesstings进行删除
+				Reflect.deleteProperty(fileContent, CommonConstant.Application);
+				Reflect.deleteProperty(fileContent, CommonConstant.Settings);
+
+				//追加自定的属性
+				MixTool.copyProperties(sysConfig, fileContent);
+			}
+		});
+
+		return sysConfig;
+	}
+}

package/src/utils/FormatStr.ts

@@ -0,0 +1,13 @@
+export default class FormatStr {
+	static formatFirstToUp(str: string) {
+		return str.charAt(0).toUpperCase() + str.substring(1);
+	}
+
+	static formatFirstToLow(str: string) {
+		return str.charAt(0).toLowerCase() + str.substring(1);
+	}
+
+	static formatFirstToUpEnd(str: string) {
+		return str.charAt(0).toUpperCase() + str.substring(1).toLowerCase();
+	}
+}

package/src/utils/Mix.ts

@@ -0,0 +1,69 @@
+import ClassUtils from "./ClassUtils";
+
+const BASETYPE = ["constructor", "prototype", "name"];
+
+/***
+ * @version 1.0 混合多个类
+ *
+ */
+export default class MixTool {
+	static mix(...mixins: any[]) {
+		class Mix {
+			constructor() {
+				for (let mixin of mixins) {
+					MixTool.copyProperties(this, new mixin()); // 拷贝实例属性
+				}
+			}
+		}
+
+		for (let mixin of mixins) {
+			MixTool.copyProperties(Mix, mixin); // 拷贝静态属性
+			MixTool.copyProperties(Mix.prototype, mixin.prototype); // 拷贝原型属性
+		}
+
+		return Mix;
+	}
+
+	static copyProperties(target: any, source: any) {
+		let keys = Reflect.ownKeys(source);
+
+		for (let key of keys) {
+			if (!BASETYPE.includes(key.toString())) {
+				let desc = Object.getOwnPropertyDescriptor(source, key);
+				if (desc) {
+					Object.defineProperty(target, key, desc);
+				}
+			}
+		}
+	}
+
+	//仅仅改变属性的值
+	static copPropertyValue(target: any, source: any) {
+		let keys = Reflect.ownKeys(source);
+
+		for (let key of keys) {
+			if (!BASETYPE.includes(key.toString())) {
+				let desc = Reflect.getOwnPropertyDescriptor(source, key);
+				if (!!desc) {
+					Reflect.defineProperty(target, key, desc);
+				}
+			}
+		}
+	}
+
+	//多个对象赋值
+	static assign(target: any, source: any) {
+		Object.assign(target, source);
+		let keys = ClassUtils.getProtoType(source);
+
+		keys.forEach((key) => {
+			let keyStr = key.toString();
+			if (!BASETYPE.includes(keyStr)) {
+				let desc = Object.getOwnPropertyDescriptor(source?.prototype, key);
+				if (desc) {
+					Reflect.defineProperty(target, key, desc);
+				}
+			}
+		});
+	}
+}

package/src/utils/ReflectUtil.ts

@@ -0,0 +1,22 @@
+import { FastCarMetaData } from "../constant/FastCarMetaData";
+import FormatStr from "./FormatStr";
+
+const SpecWords = ["Boolean", "Number", "String", "Object"];
+
+export default class ReflectUtil {
+	static getNameByPropertyKey(target: any, propertyKey: string): string {
+		const designType = Reflect.getMetadata(FastCarMetaData.designType, target, propertyKey);
+		let key = "";
+		let name = "";
+		if (designType) {
+			name = designType.name;
+			key = Reflect.getMetadata(FastCarMetaData.InjectionUniqueKey, designType); //放入至原型中
+		}
+		//获取不到注入的值时默认为别名的值
+		if (!name || SpecWords.includes(name)) {
+			key = FormatStr.formatFirstToUp(propertyKey);
+		}
+
+		return key;
+	}
+}