mas-server 1.0.3 → 2.0.0

package/.temp/a.ts

@@ -0,0 +1,4 @@
+import * as fs from "fs";
+import path from "path";
+fs.writeFileSync(path.join(__dirname, "as.ts"), `export default{name:"test"}`);
+export {};

package/.temp/as.ts

@@ -0,0 +1 @@
+export default{name:"test"}

package/.temp/b.ts

@@ -0,0 +1,3 @@
+import test from "./as";
+console.log(test);
+export {};

package/{src/index.js → .temp/i.js}

@@ -24,7 +24,7 @@ const createCode = (dirname) => {
 const createApis = (dirname) => {
   createApiFile(dirname);
 };
-let token=null
+let token = null;
 const getApp = (dirname) => {
   const app = express();
   const config = require(path.join(dirname, "/config", "config.js"));
@@ -86,8 +86,8 @@ const getApp = (dirname) => {
  * @param {number} time token过期时间，设置此项传入数据必须为json数据，单位为s，默认为0，不过期
  * @return {*}
  */
-function createToken(data,permission,time) {
-  return token.createToken(data,time,permission,state.config)
+function createToken(data, permission, time) {
+  return token.createToken(data, time, permission, state.config);
 }
 module.exports = {
   getApp,

package/.temp/test.ts

@@ -0,0 +1,2 @@
+import "./a";
+import "./b";

package/.temp/validType copy.ts

@@ -0,0 +1,149 @@
+type BasicTypeDescriptor =
+  | StringConstructor
+  | NumberConstructor
+  | BooleanConstructor
+  | ObjectConstructor;
+type TypeDescriptor = BasicTypeDescriptor | Array<any>;
+
+interface TypeMapping {
+  [key: string]:
+    | TypeDescriptor
+    | TypeMapping
+    | Array<TypeDescriptor | TypeMapping>;
+}
+import { getType } from "../src/utils/masUtils";
+function getTypeName(descriptor: TypeDescriptor): string {
+  if (Array.isArray(descriptor)) {
+    return "array";
+  } else {
+    return (descriptor as BasicTypeDescriptor).name.toLowerCase();
+  }
+}
+
+function validTypeObj(obj: any, typeMapping: TypeMapping): boolean {
+  for (const key in typeMapping) {
+    if (!obj.hasOwnProperty(key)) {
+      return false;
+    }
+
+    const targetType = typeMapping[key];
+
+    const objValue = obj[key];
+    if (Array.isArray(targetType)) {
+      if (!Array.isArray(objValue)) {
+        return false;
+      }
+
+      const arrayElementType = targetType[0];
+
+      for (const element of objValue) {
+        if (typeof arrayElementType === "object") {
+          if (!validType(element, arrayElementType as TypeMapping)) {
+            return false;
+          }
+        } else {
+          if (
+            typeof element !== getTypeName(arrayElementType as TypeDescriptor)
+          ) {
+            return false;
+          }
+        }
+      }
+    } else if (typeof targetType === "object") {
+      if (
+        typeof objValue !== "object" ||
+        Array.isArray(objValue) ||
+        !validType(objValue, targetType as TypeMapping)
+      ) {
+        return false;
+      }
+    } else {
+      if (typeof objValue !== getTypeName(targetType as TypeDescriptor)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+function validTypeObjStrict(obj: any, typeMapping: TypeMapping): boolean {
+  if (getType(typeMapping) == "object") {
+    if (getType(obj) != "object") return false;
+    if (Object.keys(obj).length != Object.keys(typeMapping).length) {
+      return false;
+    }
+  }
+
+  for (const key in typeMapping) {
+    if (!obj?.hasOwnProperty(key)) {
+      return false;
+    }
+
+    const targetType = typeMapping[key];
+    const objValue = obj[key];
+
+    if (Array.isArray(targetType)) {
+      if (!Array.isArray(objValue)) {
+        return false;
+      }
+
+      const arrayElementType = targetType[0];
+
+      for (const element of objValue) {
+        if (typeof arrayElementType === "object") {
+          if (
+            !validType(element, arrayElementType as TypeMapping) ||
+            Object.keys(element).length !==
+              Object.keys(arrayElementType as TypeMapping).length
+          ) {
+            return false;
+          }
+        } else {
+          if (
+            typeof element !== getTypeName(arrayElementType as TypeDescriptor)
+          ) {
+            return false;
+          }
+        }
+      }
+    } else if (typeof targetType === "object") {
+      if (
+        typeof objValue !== "object" ||
+        Array.isArray(objValue) ||
+        !validType(objValue, targetType as TypeMapping) ||
+        Object.keys(objValue).length !==
+          Object.keys(targetType as TypeMapping).length
+      ) {
+        return false;
+      }
+    } else {
+      if (typeof objValue !== getTypeName(targetType as TypeDescriptor)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+export default function validType(
+  obj: any,
+  typeMapping: TypeMapping | TypeDescriptor,
+  strict: boolean = false
+): boolean {
+  if (getType(typeMapping) == "function") {
+    const typeT = typeMapping.toString().split(" ")[1].trimEnd();
+    if (typeT == "Boolean()") {
+      return getType(obj) == "boolean";
+    } else if (typeT == "Number()") {
+      return getType(obj) == "number";
+    } else if (typeT == "String()") {
+      return getType(obj) == "string";
+    }
+  } else {
+    return strict
+      ? validTypeObjStrict(obj, typeMapping as any)
+      : validTypeObj(obj, typeMapping as any);
+  }
+  return false;
+}

package/.temp/validType.ts

@@ -0,0 +1,96 @@
+type BasicTypeDescriptor =
+  | StringConstructor
+  | NumberConstructor
+  | BooleanConstructor
+  | ObjectConstructor;
+type TypeDescriptor = BasicTypeDescriptor | Array<any>;
+
+interface TypeMapping {
+  [key: string]:
+    | TypeDescriptor
+    | TypeMapping
+    | Array<TypeDescriptor | TypeMapping>;
+}
+
+function getTypeName(descriptor: TypeDescriptor): string {
+  if (Array.isArray(descriptor)) {
+    return "array";
+  } else {
+    return (descriptor as BasicTypeDescriptor).name.toLowerCase();
+  }
+}
+
+function validType(obj: any, typeMapping: TypeMapping): boolean {
+  for (const key in typeMapping) {
+    if (!obj.hasOwnProperty(key)) {
+      return false;
+    }
+
+    const targetType = typeMapping[key];
+    const objValue = obj[key];
+
+    if (Array.isArray(targetType)) {
+      if (!Array.isArray(objValue)) {
+        return false;
+      }
+
+      const arrayElementType = targetType[0];
+
+      for (const element of objValue) {
+        if (typeof arrayElementType === "object") {
+          if (
+            !validType(element, arrayElementType as TypeMapping) ||
+            Object.keys(element).length !==
+              Object.keys(arrayElementType as TypeMapping).length
+          ) {
+            return false;
+          }
+        } else {
+          if (
+            typeof element !== getTypeName(arrayElementType as TypeDescriptor)
+          ) {
+            return false;
+          }
+        }
+      }
+    } else if (typeof targetType === "object") {
+      if (
+        typeof objValue !== "object" ||
+        Array.isArray(objValue) ||
+        !validType(objValue, targetType as TypeMapping) ||
+        Object.keys(objValue).length !==
+          Object.keys(targetType as TypeMapping).length
+      ) {
+        return false;
+      }
+    } else {
+      if (typeof objValue !== getTypeName(targetType as TypeDescriptor)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+// 示例
+console.log(validType({ a: 1, b: "s" }, { a: Number, b: String })); // 返回true
+console.log(validType({ a: [1, 2, 3], b: "s" }, { a: [Number], b: String })); // 返回true
+console.log(
+  validType(
+    { a: [{ a: 1 }, { a: 1 }, { a: 1 }], b: "s" },
+    { a: [{ b: Number }], b: String }
+  )
+); // 返回true
+console.log(
+  validType(
+    {
+      a: [
+        { a: "1", b: 22 },
+        { a: "1", b: 1 },
+      ],
+    },
+    { a: [{ a: String, b: Number, c: Number }] }
+  )
+); // 返回false
+export {};

package/.temp/validTypeOptimize.ts

@@ -0,0 +1,98 @@
+type BasicTypeDescriptor =
+  | typeof String
+  | typeof Number
+  | typeof Boolean
+  | typeof Object;
+type TypeDescriptor = BasicTypeDescriptor | Array<TypeDescriptor>;
+
+interface TypeMapping {
+  [key: string]: TypeDescriptor | TypeMapping;
+}
+
+function getTypeName(descriptor: TypeDescriptor): string {
+  if (Array.isArray(descriptor)) {
+    return "array";
+  } else {
+    return descriptor.name.toLowerCase();
+  }
+}
+
+function validType(obj: any, typeMapping: TypeMapping): boolean {
+  for (const key in typeMapping) {
+    if (!(key in obj)) {
+      return false;
+    }
+
+    const targetType = typeMapping[key];
+    const objValue = obj[key];
+
+    if (Array.isArray(targetType)) {
+      if (!Array.isArray(objValue)) {
+        return false;
+      }
+
+      const arrayElementType = targetType[0];
+
+      for (const element of objValue) {
+        if (typeof arrayElementType === "object") {
+          if (
+            !validType(element, arrayElementType as unknown as TypeMapping) ||
+            Object.keys(element).length !==
+              Object.keys(arrayElementType as unknown as TypeMapping).length
+          ) {
+            return false;
+          }
+        } else {
+          if (
+            typeof element !== getTypeName(arrayElementType as TypeDescriptor)
+          ) {
+            return false;
+          }
+        }
+      }
+    } else if (typeof targetType === "object") {
+      if (
+        typeof objValue !== "object" ||
+        Array.isArray(objValue) ||
+        !validType(objValue, targetType as TypeMapping) ||
+        Object.keys(objValue).length !==
+          Object.keys(targetType as TypeMapping).length
+      ) {
+        return false;
+      }
+    } else {
+      if (typeof objValue !== getTypeName(targetType as TypeDescriptor)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+// 检查基本类型
+console.log(
+  validType({ name: "Alice", age: 30 }, { name: String, age: Number })
+); // 输出 true
+console.log(
+  validType({ name: "Alice", age: 30 }, { name: String, age: String })
+); // 输出 false
+
+// 检查数组类型
+console.log(validType({ values: [1, 2, 3] }, { values: [Number] })); // 输出 true
+console.log(validType({ values: [1, "2", 3] }, { values: [Number] })); // 输出 false
+
+// 检查嵌套类型
+console.log(
+  validType(
+    { person: { name: "Alice", age: 30 } },
+    { person: { name: String, age: Number } }
+  )
+); // 输出 true
+console.log(
+  validType(
+    { person: { name: "Alice", age: 30 } },
+    { person: { name: String, age: String } }
+  )
+); // 输出
+
+export {};

package/.vscode/settings.json

@@ -1,112 +1,3 @@
 {
-  "json.schemas": [
-    // 接口配置规范
-    {
-      "fileMatch": ["api.config.json"],
-      "schema": {
-        "type": "object",
-        "patternProperties": {
-          "^[a-zA-Z1-9/]+$": {
-            "type": "object",
-            "properties": {
-              "name": {
-                "type": "string",
-                "description": "接口名称"
-              },
-              "des": {
-                "type": "string",
-                "description": "接口描述"
-              },
-              "methods": {
-                "type": "string",
-                "enum": ["GET", "POST", "ALL"],
-                "description": "请求方法"
-              },
-              "header": {
-                "type": "array",
-                "description": "请求头参数",
-                "items": {
-                  "type": "object",
-                  "properties": {
-                    "name": {
-                      "type": "string",
-                      "description": "参数名称"
-                    },
-                    "type": {
-                      "type": "string",
-                      "description": "参数类型",
-                      "enum": ["string", "number", "Array", "object"]
-                    },
-                    "optional": {
-                      "type": "boolean",
-                      "description": "参数是否可空，默认不能空"
-                    },
-                    "des": {
-                      "type": "string",
-                      "description": "参数描述"
-                    }
-                  }
-                }
-              },
-              "token": {
-                "type": "boolean",
-                "description": "是否启用token，默认关闭"
-              },
-              "permission": {
-                "type": "array",
-                "description": "该接口需要的权限",
-                "items": {
-                  "type": "string"
-                }
-              },
-              "Content-Type": {
-                "type": "string",
-                "description": "请求体类型"
-              },
-              "example": {
-                "type": "object",
-                "description": "请求示例"
-              },
-              "checkData": {
-                "type": "array",
-                "description": "数据效验，可直接写字段名，也可描述字段名",
-                "items": {
-                  "anyOf": [
-                    {
-                      "type": "string"
-                    },
-                    {
-                      "type": "object",
-                      "required": ["name"],
-                      "properties": {
-                        "name": {
-                          "type": "string",
-                          "description": "参数名称"
-                        },
-                        "type": {
-                          "type": "string",
-                          "description": "参数类型",
-                          "enum": ["string", "number", "Array", "object"]
-                        },
-                        "optional": {
-                          "type": "boolean",
-                          "description": "参数是否可空，默认不能空"
-                        },
-                        "des": {
-                          "type": "string",
-                          "description": "参数描述"
-                        }
-                      }
-                    }
-                  ]
-                }
-              }
-            }
-          }
-        },
-        "additionalProperties": false
-      }
-    }
-  ],
   "javascript.format.semicolons": "insert"
 }

package/dist/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToken = exports.validToken = exports.massql = exports.getsqlFormDataType = exports.getsqlFormData = exports.createSqlForm = exports.checkSqlKey = exports.sqlQuery = exports.sqlInit = exports.sqlEnd = exports.sqlState = exports.moment = exports.getRouteByApiSrc = exports.readApi = exports.getApp = void 0;
+require("module-alias/register");
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs"));
+const state_1 = require("@/state");
+const getLog_1 = __importDefault(require("@/utils/getLog"));
+const quickSend_1 = __importDefault(require("@/utils/quickSend"));
+const readApi_1 = __importDefault(require("@/utils/readApi"));
+exports.readApi = readApi_1.default;
+const validRouteData_1 = __importDefault(require("@/utils/validRouteData"));
+const getRouteByApiSrc_1 = __importDefault(require("@/utils/getRouteByApiSrc"));
+exports.getRouteByApiSrc = getRouteByApiSrc_1.default;
+const validToken_1 = __importDefault(require("@/utils/validToken"));
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const moment_1 = __importDefault(require("moment"));
+exports.moment = moment_1.default;
+require("moment/locale/zh-cn");
+moment_1.default.locale("zh-cn");
+// 数据库
+const masmysql_1 = require("masmysql");
+Object.defineProperty(exports, "sqlEnd", { enumerable: true, get: function () { return masmysql_1.sqlEnd; } });
+Object.defineProperty(exports, "sqlInit", { enumerable: true, get: function () { return masmysql_1.sqlInit; } });
+Object.defineProperty(exports, "sqlQuery", { enumerable: true, get: function () { return masmysql_1.sqlQuery; } });
+Object.defineProperty(exports, "checkSqlKey", { enumerable: true, get: function () { return masmysql_1.checkSqlKey; } });
+Object.defineProperty(exports, "createSqlForm", { enumerable: true, get: function () { return masmysql_1.createSqlForm; } });
+Object.defineProperty(exports, "massql", { enumerable: true, get: function () { return masmysql_1.massql; } });
+Object.defineProperty(exports, "sqlState", { enumerable: true, get: function () { return masmysql_1.state; } });
+Object.defineProperty(exports, "getsqlFormDataType", { enumerable: true, get: function () { return masmysql_1.getsqlFormDataType; } });
+Object.defineProperty(exports, "getsqlFormData", { enumerable: true, get: function () { return masmysql_1.getsqlFormData; } });
+const apiDoc_1 = __importDefault(require("./utils/apiDoc"));
+const meaToken_1 = require("./utils/meaToken");
+Object.defineProperty(exports, "createToken", { enumerable: true, get: function () { return meaToken_1.createToken; } });
+Object.defineProperty(exports, "validToken", { enumerable: true, get: function () { return meaToken_1.validToken; } });
+// =================================================================
+function getApp(DIRNAME, beforeMounted) {
+    // 路径和配置放入state
+    state_1.state.DIRNAME = DIRNAME;
+    const config = require(path_1.default.join(DIRNAME, "/config/config.ts")).default;
+    const Router = require(path_1.default.join(DIRNAME, "/config/api.config.ts")).default;
+    const apiCN = require(path_1.default.join(DIRNAME, "/config/api.key.ts")).default;
+    state_1.state.config = config;
+    state_1.state.Router = Router;
+    state_1.state.apiCN = apiCN;
+    // new express
+    const app = (0, express_1.default)();
+    // 是否允许跨域
+    config.cors && app.use((0, cors_1.default)());
+    if (beforeMounted) {
+        beforeMounted(app);
+    }
+    // 初始化app
+    app.use(express_1.default.urlencoded({ extended: true }));
+    app.use(express_1.default.json());
+    // 自定义中间件来处理纯文本和JSON数据
+    // 错误处理中间件
+    app.use((err, req, res, next) => {
+        if (err.type == "entity.parse.failed") {
+            req.body._str = err.body;
+        }
+        next();
+    });
+    //快速return
+    app.use(quickSend_1.default);
+    // 日志
+    if (config.logs.open) {
+        app.use(require("express-ip")().getIpInfoMiddleware);
+        app.use(getLog_1.default);
+    }
+    // 权限管理
+    if (config.token.open) {
+        app.use(validToken_1.default);
+    }
+    // 数据效验
+    app.use(validRouteData_1.default);
+    if (config.apidoc) {
+        app.use("/apidoc", express_1.default.static(path_1.default.join(__dirname, "/apiDoc")));
+        (0, apiDoc_1.default)(app);
+    }
+    // 遍历api路由
+    for (const item in Router) {
+        let isExist = fs.existsSync(path_1.default.join(DIRNAME, "src", item) + ".ts");
+        if (!isExist) {
+            console.info(ansi_colors_1.default.red(`${item} not found`));
+            continue;
+        }
+        const apiFunc = require(path_1.default.join(DIRNAME, "src", item)).default;
+        if (!apiFunc) {
+            console.info(ansi_colors_1.default.yellow(`${item} 没有导出函数，已跳过..`));
+        }
+        else {
+            apiFunc && app[Router[item].methods](item, apiFunc);
+        }
+    }
+    // 运行debug
+    setTimeout(() => {
+        try {
+            require(path_1.default.join(DIRNAME + "/src/debug"));
+        }
+        catch (error) {
+            console.info(ansi_colors_1.default.red("debug.js报错！！！"));
+            console.info(error);
+        }
+    }, config.debugTime || 1000);
+    return app;
+}
+exports.getApp = getApp;