@fastcar/core 0.2.38

package/target/utils/DataFormat.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/***
+ * @version 1.0 数据格式处理
+ */
+class DataFormat {
+    static formatNumber(value, type) {
+        if (type === "int") {
+            return parseInt(value);
+        }
+        if (type === "float" || type == "number") {
+            return parseFloat(value);
+        }
+        return null;
+    }
+    static formatString(value) {
+        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) {
+        if (typeof value == "string") {
+            if (value == "false") {
+                return false;
+            }
+        }
+        return !!value;
+    }
+    static formatArray(value, type) {
+        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) {
+        if (value instanceof Date) {
+            return value;
+        }
+        return new Date(value);
+    }
+    static formatValue(value, type) {
+        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;
+            }
+        }
+    }
+}
+exports.default = DataFormat;

package/target/utils/DateUtil.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DateUtil {
+    static twoDigits(num) {
+        return num.toString().padStart(2, "0");
+    }
+    //返回年月日时分秒
+    static toDateDesc(datetime = 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 = Date.now(), format = "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 = Date.now(), format = "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 = Date.now(), format = "YYYY-MM-DD hh:mm:ss") {
+        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 = Date.now(), format = "YYYY-MM-DD hh:mm:ss.sss") {
+        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, format = "hh:mm:ss") {
+        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) {
+        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) {
+        if (datetimeStr) {
+            let dataC = new Date(datetimeStr);
+            return dataC.getTime();
+        }
+        return Date.now();
+    }
+}
+exports.default = DateUtil;

package/target/utils/FileUtil.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const yaml = require("yaml");
+const SysConfig_1 = require("../config/SysConfig");
+const CommonConstant_1 = require("../constant/CommonConstant");
+const Mix_1 = require("./Mix");
+const fileResSuffix = ["json", "yml", "js"]; //文件资源后缀名
+const bytesUnit = ["B", "K", "M", "G"];
+class FileUtil {
+    /***
+     * @version 1.0 获取文件路径
+     *
+     */
+    static getFilePathList(filePath) {
+        let pathList = 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) {
+        let lastIndex = filePath.lastIndexOf(".") + 1;
+        if (lastIndex <= 0) {
+            return "";
+        }
+        let suffix = filePath.substring(lastIndex);
+        return suffix;
+    }
+    /***
+     * @version 1.0 获取文件的文件名
+     */
+    static getFileName(filePath) {
+        let pList = filePath.split(path.sep);
+        let lastPath = pList[pList.length - 1];
+        let lastName = lastPath.split(".");
+        return lastName[0];
+    }
+    //加载配置文件
+    static getResource(fp) {
+        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) {
+        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, configName, sysConfig = SysConfig_1.SYSDefaultConfig) {
+        const replaceSetting = (property, fileContent) => {
+            let addConfig = Reflect.get(fileContent, property);
+            if (addConfig) {
+                let currConfig = Reflect.get(sysConfig, property);
+                Reflect.deleteProperty(fileContent, property);
+                if (CommonConstant_1.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);
+                }
+            }
+        };
+        CommonConstant_1.FileResSuffix.forEach((suffix) => {
+            let fileContent = FileUtil.getResource(path.join(resPath, `${configName}.${suffix}`));
+            if (fileContent) {
+                replaceSetting(CommonConstant_1.CommonConstant.Settings, fileContent);
+                replaceSetting(CommonConstant_1.CommonConstant.Application, fileContent);
+                //将application和sesstings进行删除
+                Reflect.deleteProperty(fileContent, CommonConstant_1.CommonConstant.Application);
+                Reflect.deleteProperty(fileContent, CommonConstant_1.CommonConstant.Settings);
+                //追加自定的属性
+                Mix_1.default.copyProperties(sysConfig, fileContent);
+            }
+        });
+        return sysConfig;
+    }
+}
+exports.default = FileUtil;

package/target/utils/FormatStr.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FormatStr {
+    static formatFirstToUp(str) {
+        return str.charAt(0).toUpperCase() + str.substring(1);
+    }
+    static formatFirstToLow(str) {
+        return str.charAt(0).toLowerCase() + str.substring(1);
+    }
+    static formatFirstToUpEnd(str) {
+        return str.charAt(0).toUpperCase() + str.substring(1).toLowerCase();
+    }
+}
+exports.default = FormatStr;

package/target/utils/Mix.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ClassUtils_1 = require("./ClassUtils");
+const BASETYPE = ["constructor", "prototype", "name"];
+/***
+ * @version 1.0 混合多个类
+ *
+ */
+class MixTool {
+    static mix(...mixins) {
+        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, source) {
+        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, source) {
+        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, source) {
+        Object.assign(target, source);
+        let keys = ClassUtils_1.default.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);
+                }
+            }
+        });
+    }
+}
+exports.default = MixTool;

package/target/utils/ReflectUtil.js

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

package/target/utils/TypeUtil.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FileUtil_1 = require("./FileUtil");
+const BasicTypes = ["boolean", "number", "string"];
+class TypeUtil {
+    static isFunction(f) {
+        let typeName = typeof f;
+        return typeName == "function";
+    }
+    static isClass(f) {
+        if (f.prototype === undefined) {
+            return false;
+        }
+        if (!f.prototype.constructor) {
+            return false;
+        }
+        return TypeUtil.isFunction(f);
+    }
+    static isString(str) {
+        let typeName = typeof str;
+        return typeName == "string";
+    }
+    static isObject(f) {
+        let typeName = typeof f;
+        return typeName == "object";
+    }
+    //忽略.d.ts文件
+    static isTSORJS(fp) {
+        let suffix = FileUtil_1.default.getSuffix(fp);
+        return ["ts", "js"].includes(suffix) && !fp.endsWith(".d.ts");
+    }
+    static isPromise(f) {
+        return f.constructor.name === "AsyncFunction";
+    }
+    static isArray(value) {
+        return Array.isArray(value);
+    }
+    static isDate(value) {
+        return value instanceof Date;
+    }
+    //是否为基本类型
+    static isBasic(name) {
+        let fname = name.toLowerCase();
+        return BasicTypes.includes(fname);
+    }
+}
+exports.default = TypeUtil;

package/target/utils/ValidationUtil.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TypeUtil_1 = require("./TypeUtil");
+//类型校验器
+class ValidationUtil {
+    //是否为空
+    static isNotNull(param) {
+        if (param != undefined && param != null) {
+            if (TypeUtil_1.default.isString(param)) {
+                return param.length > 0;
+            }
+            if (TypeUtil_1.default.isObject(param)) {
+                if (TypeUtil_1.default.isDate(param)) {
+                    return true;
+                }
+                return Reflect.ownKeys(param).length > 0;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    static isNull(param) {
+        return !ValidationUtil.isNotNull(param);
+    }
+    static isNumber(param) {
+        return typeof param === "number" && !isNaN(param);
+    }
+    static isString(param) {
+        return typeof param === "string";
+    }
+    static isBoolean(param) {
+        return typeof param === "boolean";
+    }
+    static isDate(param) {
+        return param instanceof Date;
+    }
+    static isObject(param) {
+        return typeof param == "object";
+    }
+    // poaram >= value
+    static isNotMinSize(param, value) {
+        if (ValidationUtil.isString(param)) {
+            return param.length >= value;
+        }
+        if (ValidationUtil.isNumber(param)) {
+            return param >= value;
+        }
+        if (ValidationUtil.isBoolean(param)) {
+            return true;
+        }
+        let v = ValidationUtil.isNotNull(param) ? param.toString() : "";
+        return v.length >= value;
+    }
+    static isNotMaxSize(param, value) {
+        return !ValidationUtil.isNotMinSize(param, value + 1);
+    }
+    static isArray(param, type) {
+        if (!Array.isArray(param)) {
+            return false;
+        }
+        //修正校验数组的错误
+        if (type.startsWith("array")) {
+            type = type.replace(/array/, "");
+        }
+        let checkFun = this.getCheckFun(type);
+        if (checkFun) {
+            return param.every((item) => {
+                return Reflect.apply(checkFun, ValidationUtil, [item]);
+            });
+        }
+        return true;
+    }
+    static getCheckFun(type) {
+        //判定类型
+        if (type.startsWith("array")) {
+            return ValidationUtil.isArray;
+        }
+        let formatFun = null;
+        switch (type) {
+            case "string": {
+                formatFun = ValidationUtil.isString;
+                break;
+            }
+            case "boolean": {
+                formatFun = ValidationUtil.isBoolean;
+                break;
+            }
+            case "object": {
+                formatFun = ValidationUtil.isObject;
+                break;
+            }
+            case "int":
+            case "float":
+            case "number": {
+                formatFun = ValidationUtil.isNumber;
+                break;
+            }
+            case "date": {
+                formatFun = ValidationUtil.isDate;
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        return formatFun;
+    }
+    static checkType(param, type) {
+        let formatFun = ValidationUtil.getCheckFun(type);
+        if (!formatFun) {
+            return false;
+        }
+        return Reflect.apply(formatFun, ValidationUtil, [param, type]);
+    }
+}
+exports.default = ValidationUtil;

package/target/utils/classLoader.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TypeUtil_1 = require("./TypeUtil");
+const FileUtil_1 = require("./FileUtil");
+const fs = require("fs");
+const path = require("path");
+class ClassLoader {
+    /***
+     * @version 1.0 加载模块
+     * @version 1.1 新增是否强制重载模块
+     *
+     */
+    static loadModule(filePath, force = false) {
+        //校验后缀名是否为js或者ts
+        if (!TypeUtil_1.default.isTSORJS(filePath)) {
+            return null;
+        }
+        //避免重复加载或者想要重新进行挂载
+        if (Reflect.has(require.cache, filePath)) {
+            if (force) {
+                Reflect.deleteProperty(require.cache, filePath);
+            }
+        }
+        //可能不止一个方法
+        const modulesMap = new Map();
+        //进行方法加载
+        let moduleClass = require(filePath);
+        let keys = Object.keys(moduleClass);
+        let fileName = FileUtil_1.default.getFileName(filePath);
+        keys.forEach((key) => {
+            let instance = moduleClass[key];
+            if (TypeUtil_1.default.isFunction(instance)) {
+                modulesMap.set(instance.name, instance);
+                return;
+            }
+            if (TypeUtil_1.default.isObject(instance)) {
+                modulesMap.set(fileName, instance);
+            }
+        });
+        return modulesMap;
+    }
+    /**
+     * @version 1.0 监听某个文件或者文件夹
+     */
+    static watchServices(fp, context, eventName = "reload") {
+        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;
+    }
+}
+exports.default = ClassLoader;

package/target/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixTool = exports.ClassLoader = exports.ClassUtils = exports.FormatStr = exports.ValidationUtil = exports.TypeUtil = exports.FileUtil = exports.CryptoUtil = exports.DataFormat = exports.DateUtil = void 0;
+const classLoader_1 = require("./utils/classLoader");
+exports.ClassLoader = classLoader_1.default;
+const ClassUtils_1 = require("./utils/ClassUtils");
+exports.ClassUtils = ClassUtils_1.default;
+const CryptoUtil_1 = require("./utils/CryptoUtil");
+exports.CryptoUtil = CryptoUtil_1.default;
+const DataFormat_1 = require("./utils/DataFormat");
+exports.DataFormat = DataFormat_1.default;
+const DateUtil_1 = require("./utils/DateUtil");
+exports.DateUtil = DateUtil_1.default;
+const FileUtil_1 = require("./utils/FileUtil");
+exports.FileUtil = FileUtil_1.default;
+const FormatStr_1 = require("./utils/FormatStr");
+exports.FormatStr = FormatStr_1.default;
+const Mix_1 = require("./utils/Mix");
+exports.MixTool = Mix_1.default;
+const TypeUtil_1 = require("./utils/TypeUtil");
+exports.TypeUtil = TypeUtil_1.default;
+const ValidationUtil_1 = require("./utils/ValidationUtil");
+exports.ValidationUtil = ValidationUtil_1.default;

package/test/example/logs/logger.log

@@ -0,0 +1,12 @@
+{"timestamp":"2022-08-26 18:04:16.808","level":"INFO","label":"logger","message":"自定义的日志输出"}
+{"timestamp":"2022-08-26 18:04:16.809","level":"WARN","label":"logger","message":"自定义警告"}
+{"timestamp":"2022-08-26 18:04:16.810","level":"ERROR","label":"logger","message":"自定义报错"}
+{"timestamp":"2022-08-26 18:05:14.219","level":"INFO","label":"logger","message":"自定义的日志输出"}
+{"timestamp":"2022-08-26 18:05:14.221","level":"WARN","label":"logger","message":"自定义警告"}
+{"timestamp":"2022-08-26 18:05:14.221","level":"ERROR","label":"logger","message":"自定义报错"}
+{"timestamp":"2022-08-26 18:07:32.805","level":"INFO","label":"logger","message":"自定义的日志输出"}
+{"timestamp":"2022-08-26 18:07:32.806","level":"WARN","label":"logger","message":"自定义警告"}
+{"timestamp":"2022-08-26 18:07:32.807","level":"ERROR","label":"logger","message":"自定义报错"}
+{"timestamp":"2022-09-02 14:17:35.618","level":"INFO","label":"logger","message":"自定义的日志输出"}
+{"timestamp":"2022-09-02 14:17:35.619","level":"WARN","label":"logger","message":"自定义警告"}
+{"timestamp":"2022-09-02 14:17:35.619","level":"ERROR","label":"logger","message":"自定义报错"}