@fastcar/core 0.2.38

package/target/constant/BootPriority.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootPriority = void 0;
+var BootPriority;
+(function (BootPriority) {
+    BootPriority[BootPriority["Base"] = 0] = "Base";
+    BootPriority[BootPriority["Sys"] = 1] = "Sys";
+    BootPriority[BootPriority["Common"] = 2] = "Common";
+    BootPriority[BootPriority["Other"] = 3] = "Other";
+    BootPriority[BootPriority["Lowest"] = 10000] = "Lowest";
+})(BootPriority = exports.BootPriority || (exports.BootPriority = {}));

package/target/constant/CommonConstant.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileResSuffix = exports.CommonConstant = void 0;
+exports.CommonConstant = {
+    Application: "application",
+    Settings: "settings",
+    Resource: "resource",
+    ENV: Symbol("env"),
+    BasePath: Symbol("basePath"),
+    BaseFileName: Symbol("baseFileName"),
+    SYSLOGGER: "sys",
+    FastcarApp: Symbol("FastcarApp"),
+    FastcarSetting: Symbol("FastcarSetting"),
+    ResourcePath: "resourcePath",
+};
+exports.FileResSuffix = ["json", "yml", "js"];

package/target/constant/ComponentKind.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentKind = void 0;
+//实例类型
+var ComponentKind;
+(function (ComponentKind) {
+    ComponentKind["Controller"] = "Controller";
+    ComponentKind["Service"] = "Service";
+    ComponentKind["Component"] = "Component";
+    ComponentKind["Repository"] = "Repository";
+})(ComponentKind = exports.ComponentKind || (exports.ComponentKind = {}));

package/target/constant/DataTypes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTypes = void 0;
+//数据类型枚举
+var DataTypes;
+(function (DataTypes) {
+    DataTypes["BOOLEAN"] = "boolean";
+    DataTypes["NUMBER"] = "number";
+    DataTypes["STRING"] = "string";
+    DataTypes["INT"] = "int";
+    DataTypes["FLOAT"] = "float";
+    DataTypes["DATE"] = "date";
+    DataTypes["Object"] = "object";
+    DataTypes["ARRAYNUMBER"] = "arraynumber";
+    DataTypes["ARRAYINT"] = "arrayint";
+    DataTypes["ARRAYFLOAT"] = "arrayfloat";
+    DataTypes["ARRAYSTRING"] = "arraystring";
+    DataTypes["ARRAYOBJECT"] = "arrayobject";
+})(DataTypes = exports.DataTypes || (exports.DataTypes = {}));

package/target/constant/FastCarMetaData.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastCarMetaData = void 0;
+//元数据加载模块
+var FastCarMetaData;
+(function (FastCarMetaData) {
+    FastCarMetaData["paramTypes"] = "design:paramtypes";
+    FastCarMetaData["returnType"] = "design:returntype";
+    FastCarMetaData["designType"] = "design:type";
+    FastCarMetaData["InjectionMap"] = "InjectionMap";
+    FastCarMetaData["IocModule"] = "IocModule";
+    FastCarMetaData["ComponentScan"] = "ComponentScan";
+    FastCarMetaData["ComponentScanExclusion"] = "ComponentScanExclusion";
+    FastCarMetaData["RouterMap"] = "RouterMap";
+    FastCarMetaData["SpecifyMap"] = "SpecifyMap";
+    FastCarMetaData["APP"] = "APP";
+    FastCarMetaData["DS"] = "dynamicDataSource";
+    FastCarMetaData["DSIndex"] = "dynamicDataSourceIndex";
+    FastCarMetaData["ValidFormRules"] = "validFormRules";
+    FastCarMetaData["ValidChildFormRules"] = "validChildFormRules";
+    FastCarMetaData["ValidSize"] = "valid:size";
+    FastCarMetaData["NotNull"] = "valid:notNull";
+    FastCarMetaData["ValidCustom"] = "valid:custom";
+    FastCarMetaData["Hotter"] = "hotter";
+    FastCarMetaData["InjectionUniqueKey"] = "injection_uniqueKey";
+    FastCarMetaData["Alias"] = "alias";
+    FastCarMetaData["LoggerModule"] = "LoggerModule";
+    FastCarMetaData["HotterSysConfig"] = "hotterSysConfig";
+})(FastCarMetaData = exports.FastCarMetaData || (exports.FastCarMetaData = {}));

package/target/constant/LifeCycleModule.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifeCycleModule = void 0;
+var LifeCycleModule;
+(function (LifeCycleModule) {
+    LifeCycleModule["ApplicationStart"] = "applicationStart";
+    LifeCycleModule["ApplicationStop"] = "applicationStop";
+    LifeCycleModule["LoadConfigure"] = "loadConfigure";
+})(LifeCycleModule = exports.LifeCycleModule || (exports.LifeCycleModule = {}));

package/target/db.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesignMeta = exports.SqlError = exports.BaseMapper = exports.OrderEnum = exports.JoinEnum = exports.OperatorEnum = void 0;
+const BaseMapper_1 = require("./model/BaseMapper");
+exports.BaseMapper = BaseMapper_1.default;
+const SqlError_1 = require("./type/SqlError");
+exports.SqlError = SqlError_1.default;
+var OperatorEnum;
+(function (OperatorEnum) {
+    OperatorEnum["eq"] = "=";
+    OperatorEnum["neq"] = "!=";
+    OperatorEnum["gt"] = ">";
+    OperatorEnum["gte"] = ">=";
+    OperatorEnum["lt"] = "<";
+    OperatorEnum["lte"] = "<=";
+    OperatorEnum["like"] = "LIKE";
+    OperatorEnum["in"] = "IN";
+    OperatorEnum["isNUll"] = "ISNULL";
+    OperatorEnum["isNotNull"] = "IS NOT NULL";
+    OperatorEnum["inc"] = "+";
+    OperatorEnum["dec"] = "-";
+    OperatorEnum["multiply"] = "*";
+    OperatorEnum["division"] = "/";
+})(OperatorEnum = exports.OperatorEnum || (exports.OperatorEnum = {}));
+var JoinEnum;
+(function (JoinEnum) {
+    JoinEnum["and"] = "AND";
+    JoinEnum["or"] = "OR";
+})(JoinEnum = exports.JoinEnum || (exports.JoinEnum = {}));
+var OrderEnum;
+(function (OrderEnum) {
+    OrderEnum["asc"] = "ASC";
+    OrderEnum["desc"] = "DESC";
+})(OrderEnum = exports.OrderEnum || (exports.OrderEnum = {}));
+var DesignMeta;
+(function (DesignMeta) {
+    DesignMeta["table"] = "db:table";
+    DesignMeta["field"] = "db:field";
+    DesignMeta["fieldMap"] = "db:fieldMap";
+    DesignMeta["dbType"] = "db:dbType";
+    DesignMeta["primaryKey"] = "db:primaryKey";
+    DesignMeta["entity"] = "db:entity";
+    DesignMeta["mapping"] = "db:mapping";
+    DesignMeta["dbFields"] = "db:fields";
+    DesignMeta["sqlSession"] = "SqlSession";
+})(DesignMeta = exports.DesignMeta || (exports.DesignMeta = {}));

package/target/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonConstant = exports.Logger = exports.DataMap = exports.ValidError = exports.FastCarMetaData = exports.FastCarApplication = exports.BootPriority = exports.ComponentKind = exports.LifeCycleModule = void 0;
+const BootPriority_1 = require("./constant/BootPriority");
+Object.defineProperty(exports, "BootPriority", { enumerable: true, get: function () { return BootPriority_1.BootPriority; } });
+const CommonConstant_1 = require("./constant/CommonConstant");
+Object.defineProperty(exports, "CommonConstant", { enumerable: true, get: function () { return CommonConstant_1.CommonConstant; } });
+const ComponentKind_1 = require("./constant/ComponentKind");
+Object.defineProperty(exports, "ComponentKind", { enumerable: true, get: function () { return ComponentKind_1.ComponentKind; } });
+const FastCarMetaData_1 = require("./constant/FastCarMetaData");
+Object.defineProperty(exports, "FastCarMetaData", { enumerable: true, get: function () { return FastCarMetaData_1.FastCarMetaData; } });
+const LifeCycleModule_1 = require("./constant/LifeCycleModule");
+Object.defineProperty(exports, "LifeCycleModule", { enumerable: true, get: function () { return LifeCycleModule_1.LifeCycleModule; } });
+const FastCarApplication_1 = require("./FastCarApplication");
+exports.FastCarApplication = FastCarApplication_1.default;
+const Logger_1 = require("./interface/Logger");
+exports.Logger = Logger_1.default;
+const DataMap_1 = require("./model/DataMap");
+exports.DataMap = DataMap_1.default;
+const ValidError_1 = require("./model/ValidError");
+exports.ValidError = ValidError_1.default;

package/target/interface/ApplicationHook.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/interface/ApplicationRunnerService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/interface/DataSourceManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/interface/Logger.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Logger {
+}
+exports.default = Logger;

package/target/model/BaseMapper.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DesignMeta_1 = require("../type/DesignMeta");
+const DataFormat_1 = require("../utils/DataFormat");
+class BaseMapper {
+    /***
+     * @version 1.0 对于类型做一个转换
+     */
+    constructor() {
+        let tClass = Reflect.getMetadata(DesignMeta_1.DesignMeta.entity, this);
+        this.classZ = tClass;
+        let tableName = Reflect.getMetadata(DesignMeta_1.DesignMeta.table, tClass);
+        if (!tableName) {
+            throw new Error(`This class ${tClass.name} has no annotation table name`);
+        }
+        this.tableName = tableName;
+        this.mappingMap = Reflect.getMetadata(DesignMeta_1.DesignMeta.mapping, tClass); //映射关系
+        this.dbFields = Reflect.getMetadata(DesignMeta_1.DesignMeta.dbFields, tClass); //作用的列名
+        this.mappingList = Array.of();
+        this.mappingMap.forEach(item => {
+            this.mappingList.push(item);
+        });
+    }
+    //获取数据库别名通过代码内的名称
+    getFieldName(name) {
+        let info = this.mappingMap.get(name);
+        return info ? info.field : name;
+    }
+    setRow(rowData) {
+        let t = new this.classZ();
+        this.mappingMap.forEach((item, key) => {
+            let value = Reflect.get(rowData, item.field) || Reflect.get(rowData, key);
+            if (value != null) {
+                let fvalue = DataFormat_1.default.formatValue(value, item.type);
+                Reflect.set(t, key, fvalue);
+            }
+        });
+        return t;
+    }
+    setRows(rowDataList) {
+        let list = Array.of();
+        rowDataList.forEach(item => {
+            list.push(this.setRow(item));
+        });
+        return list;
+    }
+    saveORUpdate(rows, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    saveOne(row, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    saveList(rows, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    update({ row, where, limit }, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    updateOne(sqlUpdate, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    updateByPrimaryKey(row, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    select(conditions, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    /***
+     * @version 1.0 查询单个对象
+     *
+     */
+    async selectOne(conditions, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    /***
+     * @version 1.0 通过主键查找对象
+     *
+     */
+    async selectByPrimaryKey(row, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    exist(where, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    count(where, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    delete(conditions, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    deleteOne(where, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+    deleteByPrimaryKey(row, ds, sessionId) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.default = BaseMapper;

package/target/model/DataMap.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DataMap extends Map {
+    constructor() {
+        super();
+    }
+    toValues() {
+        return [...this.values()];
+    }
+    toKeys() {
+        return [...this.keys()];
+    }
+    toObject() {
+        let o = {};
+        this.forEach((v, k) => {
+            Reflect.set(o, k, v);
+        });
+        return o;
+    }
+    //自定义排序 支持多个排序
+    sort(sorts, list) {
+        list = !list ? this.toValues() : list;
+        if (!sorts || sorts?.length == 0) {
+            return list;
+        }
+        let total = sorts.length;
+        list.sort((a, b) => {
+            let resultNum = 0;
+            sorts.some((f, index) => {
+                let field = f.field;
+                let aValue = Reflect.get(a, field);
+                let bValue = Reflect.get(b, field);
+                let flag = f.compare ? f.compare(aValue, bValue) : aValue > bValue;
+                resultNum = flag ? total - index : index - total;
+                //降序则倒着
+                if (f.order) {
+                    resultNum = -resultNum;
+                }
+                return !!flag;
+            });
+            return resultNum;
+        });
+        return list;
+    }
+    /***
+     * @version 1.0 查找属性名称
+     * @params atts代表属性键值对匹配
+     *
+     */
+    findByAtts(atts) {
+        let list = [];
+        let keys = Object.keys(atts);
+        this.forEach((item) => {
+            let flag = keys.every((key) => {
+                let v = Reflect.get(atts, key);
+                //这边判断 是不是一个复合属性
+                if (Reflect.has(item, key)) {
+                    let itemV = Reflect.get(item, key);
+                    return itemV == v;
+                }
+                else {
+                    let keyList = key.split(".");
+                    if (keyList.length > 1) {
+                        let tmpV = item;
+                        let f = keyList.every((tk) => {
+                            if (!Reflect.has(tmpV, tk)) {
+                                return false;
+                            }
+                            tmpV = Reflect.get(tmpV, tk);
+                            return true;
+                        });
+                        if (!f) {
+                            return false;
+                        }
+                        return tmpV == v;
+                    }
+                }
+                return false;
+            });
+            if (flag) {
+                list.push(item);
+            }
+        });
+        return list;
+    }
+}
+exports.default = DataMap;

package/target/model/FormRuleModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/model/ValidError.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ValidError extends Error {
+}
+exports.default = ValidError;

package/target/model/WinstonLogger.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const winston = require("winston");
+const WinstonLoggerType_1 = require("../type/WinstonLoggerType");
+const path = require("path");
+const utils_1 = require("../utils");
+const util = require("util");
+const SPLAT = Symbol.for("splat");
+class WinstonLogger {
+    constructor(config) {
+        this.config = config;
+        this.categoryMap = new Map();
+    }
+    //控制台着色
+    colorize(str, level) {
+        let colorStyle = Reflect.get(WinstonLoggerType_1.ColorLevelType, level);
+        if (!colorStyle) {
+            return str;
+        }
+        return `\x1B[${colorStyle[0]}m ${str} \x1B[${colorStyle[1]}m`;
+    }
+    //数据着色为白色
+    colorizeData(data) {
+        let msg = utils_1.ValidationUtil.isObject(data) ? JSON.stringify(data) : data;
+        return `\x1B[37m ${msg} \x1B[39m`;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    hasLogger(category) {
+        return winston.loggers.has(category);
+    }
+    getLogger(category) {
+        return this.categoryMap.get(category);
+    }
+    addLogger(category) {
+        if (this.categoryMap.has(category)) {
+            winston.loggers.close(category);
+        }
+        let newLogger = winston.loggers.add(category, {
+            format: winston.format.combine(winston.format.label({ label: category }), winston.format.printf(info => {
+                //debug模式等级时仅为控制台输出
+                let level = info.level.toUpperCase();
+                let timestamp = utils_1.DateUtil.toDateTimeMS();
+                let content = {
+                    timestamp,
+                    level,
+                    label: info.label,
+                    message: info.message,
+                };
+                if (Reflect.has(info, SPLAT)) {
+                    Reflect.set(content, "splat", JSON.stringify(Reflect.get(info, SPLAT)));
+                }
+                if (info.stack) {
+                    Reflect.set(content, "stack", info.stack);
+                }
+                Reflect.set(info, "timestamp", content.timestamp);
+                //新增打印控制台
+                if (this.config.printConsole) {
+                    let text = this.colorize(util.format("[%s] [%s] %s - ", timestamp, level, info.label), info.level);
+                    text += this.colorizeData(content.message);
+                    if (Reflect.has(info, SPLAT)) {
+                        let splatMsg = Reflect.get(info, SPLAT);
+                        splatMsg.forEach(item => {
+                            text += " " + this.colorizeData(item);
+                        });
+                    }
+                    if (info.stack) {
+                        text += this.colorizeData(`\nstatck: ${info.stack}`);
+                    }
+                    let fn = console.info;
+                    if (Reflect.has(console, info.level)) {
+                        fn = Reflect.get(console, info.level);
+                    }
+                    Reflect.apply(fn, console, [text]);
+                }
+                return util.format("%j", content);
+            })),
+            transports: [
+                new winston.transports.File({
+                    level: this.config.fileLevel,
+                    filename: path.join(this.config.rootPath, `${category}.log`),
+                    maxsize: this.config.maxsize,
+                    maxFiles: this.config.maxFiles,
+                }),
+            ],
+        });
+        this.categoryMap.set(category, newLogger);
+        return newLogger;
+    }
+    getLoggerList() {
+        return [...this.categoryMap.values()];
+    }
+}
+exports.default = WinstonLogger;

package/target/type/ComponentDesc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/type/DesignMeta.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesignMeta = void 0;
+var DesignMeta;
+(function (DesignMeta) {
+    DesignMeta["table"] = "db:table";
+    DesignMeta["field"] = "db:field";
+    DesignMeta["fieldMap"] = "db:fieldMap";
+    DesignMeta["dbType"] = "db:dbType";
+    DesignMeta["primaryKey"] = "db:primaryKey";
+    DesignMeta["entity"] = "db:entity";
+    DesignMeta["mapping"] = "db:mapping";
+    DesignMeta["dbFields"] = "db:fields";
+    DesignMeta["sqlSession"] = "SqlSession";
+})(DesignMeta = exports.DesignMeta || (exports.DesignMeta = {}));

package/target/type/FileHotterDesc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/type/MapperType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/type/ProcessType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/type/SqlError.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SqlError extends Error {
+}
+exports.default = SqlError;

package/target/type/WinstonLoggerType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorLevelType = void 0;
+exports.ColorLevelType = {
+    info: [32, 39],
+    debug: [36, 39],
+    warn: [33, 39],
+    error: [91, 39], //red
+};

package/target/utils/ClassUtils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ClassUtils {
+    //获取一个类所有的proto属性 采用递归的形式
+    static getProtoType(t) {
+        if (!t?.prototype) {
+            return [];
+        }
+        let keys = 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, key) {
+        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);
+    }
+}
+exports.default = ClassUtils;

package/target/utils/CryptoUtil.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("crypto");
+class CryptoUtil {
+    static aesDecode(cryptkey, iv, secretdata, aesType = "aes-256-cbc" /* aes */) {
+        let decipher = crypto.createDecipheriv(aesType, cryptkey, iv);
+        let decoded = decipher.update(secretdata, "base64", "utf8");
+        decoded += decipher.final("utf8");
+        return decoded;
+    }
+    static aesEncode(cryptkey, iv, cleardata, aesType = "aes-256-cbc" /* aes */) {
+        let encipher = crypto.createCipheriv("aes-256-cbc" /* aes */, cryptkey, iv);
+        let encoded = encipher.update(cleardata, "utf8", "base64");
+        encoded += encipher.final("base64");
+        return encoded;
+    }
+    static shaEncode(cryptkey, data) {
+        let hash = crypto.createHmac("sha256", cryptkey);
+        return hash.update(data).digest("base64");
+    }
+    static gcmEncrypt(password, msg) {
+        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, serect) {
+        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, serect = crypto.randomBytes(32).toString("hex"), encoding = "base64") {
+        let msg = crypto
+            .createHmac("sha256", serect)
+            .update(text)
+            .digest(encoding);
+        return {
+            salt: serect,
+            msg: msg,
+        };
+    }
+    static sha256EncodeContent(str, encoding = "base64") {
+        let msg = crypto
+            .createHash("sha256")
+            .update(str)
+            .digest(encoding);
+        return msg;
+    }
+    static sha256Very(msg, serect, encodeMsg, encoding = "base64") {
+        let result = this.sha256Encode(msg, serect, encoding);
+        return result.msg === encodeMsg;
+    }
+    static getHashStr(num = 16) {
+        return crypto.randomBytes(num).toString("hex");
+    }
+}
+exports.default = CryptoUtil;