mm_os 3.3.1 → 4.0.1

package/common/middleware/web_after/index.js

@@ -0,0 +1,29 @@
+/**
+ * 中间件
+ */
+module.exports = {
+  /**
+   * 中间件初始化
+   * @param {object} apapter 适配器
+   * @param {object} eventer 事件处理器
+   */
+  async _init(apapter, eventer) {
+    var event = $.admin.event('api', 'API事件');
+    await event.call('update');
+  },
+  /**
+   * 主要逻辑
+   * @param {object} ctx Koa上下文
+   * @param {Function} next 下一个中间件
+   */
+  async main(ctx, next) {
+    await next();
+    if (ctx.path !== '/favicon.ico') {
+      var event = $.admin.event('api');
+      var ret = await event.after(ctx.path, ctx, ctx.db);
+      if (ret) {
+        ctx.body = ret;
+      }
+    }
+  }
+};

package/common/middleware/web_after/middleware.json

@@ -0,0 +1,9 @@
+{
+  "name": "web_after",
+  "title": "请求后中间件",
+  "description": "用于处理请求后逻辑",
+  "main": "index.js",
+  "type": "web",
+  "state": 1,
+  "sort": 60
+}

package/common/middleware/web_base/index.js

@@ -0,0 +1,113 @@
+const compress = require('koa-compress');
+const send = require('koa-send');
+const { koaBody } = require('koa-body');
+const xmlParser = require('mm_xml');
+const { session } = require('mm_session');
+
+/**
+ * web基础
+ * @param {object} server 服务
+ */
+module.exports = {
+  /**
+   * 初始化
+   * @param {object} adapter 适配器集合
+   */
+  init(adapter) {
+    // 参数校验
+    if (typeof adapter !== 'object') {
+      throw new TypeError('参数类型错误');
+    }
+
+    // 获取web服务
+    var web = adapter.web;
+
+    // 获取配置
+    let cg = { ...this.config, ...adapter.web.config };
+    this._setupFileSend(web);
+    this._setupSession(web, cg);
+    this._setupCompress(web, cg);
+    this._setupParsers(web, cg);
+  },
+
+  /**
+   * 设置文件发送
+   * @private
+   * @param {object} web web服务
+   */
+  _setupFileSend(web) {
+    web.use(async (ctx, next) => {
+      // 设置文件发送方法，错误由web_error中间件统一处理
+      ctx.send = async function (src) {
+        await send(ctx, src);
+      };
+
+      await next();
+    });
+  },
+
+  /**
+   * 设置会话
+   * @private
+   * @param {object} web web服务
+   * @param {object} cg 配置
+   */
+  _setupSession(web, cg) {
+    // 设置session 保存时长2小时
+    web.use(session({
+      max_age: $.login_period || cg.max_age || 7200
+    }));
+  },
+
+  /**
+   * 设置压缩
+   * @private
+   * @param {object} web web服务
+   * @param {object} cg 配置
+   */
+  _setupCompress(web, cg) {
+    if (cg.compress) {
+      web.use(compress({
+        filter: (content_type) => /text|json|javascript|css|xml/.test(content_type),
+        thresh: cg.threshold || 1024,
+        gzip: {
+          flush: require('zlib').constants.Z_SYNC_FLUSH
+        },
+        brotli: {
+          flush: require('zlib').constants.BROTLI_OPERATION_FLUSH
+        }
+      }));
+    }
+  },
+
+  /**
+   * 设置解析器
+   * @private
+   * @param {object} web web服务
+   * @param {object} cg 配置
+   */
+  _setupParsers(web, cg) {
+    // 解析 text/xml
+    web.use(xmlParser());
+    // 解析请求体
+    web.use(koaBody({
+      jsonLimit: cg.json_limit || '20mb',
+      multipart: true, // 必须开启才能解析 form-data
+      urlencoded: true, // 可选：解析 URL 编码的表单
+      text: true,
+      json: true, // 可选：解析 JSON
+      patchNode: true,
+      patchKoa: true,
+      formidable: {
+        maxFileSize: cg.max_file_size || 2000 * 1024 * 1024
+      }
+    }));
+
+    web.use(async (ctx, next) => {
+      if (!ctx.request.body) {
+        ctx.request.body = {};
+      }
+      await next();
+    });
+  }
+};

package/common/middleware/web_base/middleware.json

@@ -0,0 +1,19 @@
+{
+	"name": "web_base",
+	"title": "web基本功能",
+	"description": "用于网站常规功能",
+	"main": "index.js",
+	"type": "web",
+	"state": 1,
+	"sort": 40,
+	// 发送的JSON最大大小
+	"json_limit": "20mb",
+	// 缓存最大时长
+	"max_age": 7200,
+	// 最大文件大小
+	"max_file_fize": 2097152000,
+	// 是否brotli压缩
+	"brotli": true,
+	// 是否gzip压缩
+	"gzip": true
+}

package/common/middleware/web_before/index.js

@@ -0,0 +1,33 @@
+/**
+ * 中间件
+ */
+module.exports = {
+  /**
+   * 主要逻辑
+   * @param {object} ctx Koa上下文
+   * @param {Function} next 下一个中间件
+   */
+  async main(ctx, next) {
+    if (!ctx.db) {
+      ctx.db = {
+        ret: null
+      };
+    }
+    if (ctx.path !== '/favicon.ico') {
+      var event = $.admin.event('api');
+      var ret = await event.before(ctx.path, ctx, ctx.db);
+      if (ret) {
+        ctx.body = ret;
+        return;
+      }
+      else {
+        ret = await event.check(ctx.path, ctx, ctx.db);
+        if (ret) {
+          ctx.body = ret;
+          return;
+        }
+      }
+    }
+    await next();
+  }
+};

package/common/middleware/web_before/middleware.json

@@ -0,0 +1,9 @@
+{
+  "name": "web_before",
+  "title": "请求前中间件",
+  "description": "用于处理请求前逻辑",
+  "main": "index.js",
+  "type": "web",
+  "state": 1,
+  "sort": 70
+}

package/common/middleware/web_cors/index.js

@@ -0,0 +1,87 @@
+// 导出符合系统期望的函数
+module.exports = {
+  /**
+   * 初始化
+   * @param {object} adapter 适配器对象
+   */
+  init(adapter) {
+    // 获取web服务
+    // var web = adapter.web;
+
+    // 获取配置
+    this.config = { ...this.config, ...adapter.web.config };
+  },
+
+  /**
+   * CORS跨域中间件
+   * 处理跨域资源共享(CORS)配置
+   * @param {object} ctx Koa上下文
+   * @param {object} config CORS配置
+   */
+  _setCorsHeaders(ctx, config) {
+    // 设置Access-Control-Allow-Origin
+    if (config.origin === '*') {
+      ctx.set('Access-Control-Allow-Origin', '*');
+    } else if (Array.isArray(config.origin)) {
+      let request_origin = ctx.get('Origin');
+      if (config.origin.includes(request_origin)) {
+        ctx.set('Access-Control-Allow-Origin', request_origin);
+      }
+    } else {
+      ctx.set('Access-Control-Allow-Origin', config.origin);
+    }
+
+    // 设置Access-Control-Allow-Headers
+    if (config.headers === '*') {
+      ctx.set('Access-Control-Allow-Headers', '*');
+    } else if (Array.isArray(config.headers)) {
+      ctx.set('Access-Control-Allow-Headers', config.headers.join(', '));
+    } else {
+      ctx.set('Access-Control-Allow-Headers', config.headers);
+    }
+
+    // 设置Access-Control-Allow-Methods
+    ctx.set('Access-Control-Allow-Methods', config.methods.join(', '));
+
+    // 设置Access-Control-Allow-Credentials
+    if (config.credentials) {
+      ctx.set('Access-Control-Allow-Credentials', 'true');
+    }
+
+    // 设置Access-Control-Max-Age
+    if (config.max_age > 0) {
+      ctx.set('Access-Control-Max-Age', config.max_age.toString());
+    }
+
+    // 设置Access-Control-Expose-Headers
+    if (config.expose_headers.length > 0) {
+      ctx.set('Access-Control-Expose-Headers', config.expose_headers.join(', '));
+    }
+  },
+
+  async main(ctx, next) {
+    let config = this.config;
+
+    if (!config.enable) {
+      return await next();
+    }
+
+    // 检查是否应该忽略该路径
+    let path = ctx.path;
+    if (config.ignore_paths.some(p => path.startsWith(p))) {
+      return await next();
+    }
+
+    // 设置CORS头
+    this._setCorsHeaders(ctx, config);
+
+    // 处理预检请求
+    if (ctx.method === 'OPTIONS') {
+      ctx.status = 204;
+      return;
+    }
+
+    await next();
+  }
+};
+

package/common/middleware/web_cors/middleware.json

@@ -0,0 +1,24 @@
+{
+  "name": "web_cors",
+  "title": "CORS跨域中间件",
+  "description": "处理跨域资源共享(CORS)配置，支持灵活的跨域策略",
+  "main": "index.js",
+  "type": "web",
+  "state": 1,
+  "sort": 30,
+  "enable": true,
+  "origin": "*",
+  "headers": "*",
+  "methods": [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "HEAD"
+  ],
+  "credentials": false,
+  "max_age": 3600,
+  "expose_headers": [],
+  "ignore_paths": []
+}

package/common/middleware/web_error/index.js

@@ -0,0 +1,119 @@
+// 导出错误处理中间件
+module.exports = {
+  /**
+   * 初始化
+   * @param {object} adapter 适配器对象
+   */
+  init(adapter) {
+    // 获取配置
+    this.config = { ...this.config, ...adapter.web.config};
+  },
+
+  /**
+   * 获取错误消息
+   * @private
+   * @param {object} config 配置对象
+   * @param {number} status 状态码
+   * @returns {string} 错误消息
+   */
+  _getErrorMessage(config, status) {
+    if (config.error_codes && config.error_codes[status]) {
+      return config.error_codes[status];
+    }
+    return config.default_message || 'Internal Server Error';
+  },
+
+  /**
+   * 格式化错误信息
+   * @private
+   * @param {object} config 配置对象
+   * @param {Error} err 错误对象
+   * @returns {object} 格式化后的错误信息
+   */
+  _formatError(config, err) {
+    let errorInfo = {
+      message: err.message,
+      status: err.status || err.statusCode || config.default_status,
+      stack: err.stack
+    };
+
+    if (err.code) {
+      errorInfo.code = err.code;
+    }
+
+    if (err.details) {
+      errorInfo.details = err.details;
+    }
+
+    if (err.name) {
+      errorInfo.name = err.name;
+    }
+
+    return errorInfo;
+  },
+
+  /**
+   * 处理错误
+   * @private
+   * @param {object} ctx Koa上下文
+   * @param {Error} err 错误对象
+   */
+  async _handleError(ctx, err) {
+    // 记录错误日志到控制台
+    let error_info = this._formatError(this.config, err);
+    this.log('error', `Error occurred: ${err.message}`, error_info);
+
+    // 设置响应状态码
+    let status = err.status || err.status_code || this.config.default_status;
+    
+    // 特殊错误处理：文件不存在错误返回404
+    if (err.code === 'ENOENT') {
+      status = 404;
+    }
+    
+    ctx.status = status;
+
+    let message = err.message || this._getErrorMessage(this.config, status);
+    let error_response = $.ret.error(status, message);
+
+    // 如果配置允许，暴露堆栈信息（仅在开发环境使用）
+    if (this.config.expose_trace && err.stack) {
+      error_response.trace = err.stack;
+    }
+
+    // 添加额外的错误信息
+    if (err.code) {
+      error_response.error_code = err.code;
+    }
+
+    if (err.details) {
+      error_response.details = err.details;
+    }
+
+    // 设置响应体
+    ctx.body = error_response;
+
+    // 设置响应头
+    ctx.set('Content-Type', 'application/json');
+  },
+
+  /**
+   * 中间件主方法
+   * @param {object} ctx Koa上下文
+   * @param {Function} next 下一个中间件
+   * @returns {Promise<void>}
+   */
+  async main(ctx, next) {
+    try {
+      await next();
+
+      // 处理404错误
+      if (ctx.status === 404 && !ctx.body) {
+        ctx.status = 404;
+        ctx.body = $.ret.error(404, 'Not Found');
+      }
+    } catch (error) {
+      await this._handleError(ctx, error);
+    }
+  }
+};

package/common/middleware/web_error/middleware.json

@@ -0,0 +1,18 @@
+{
+	"name": "web_error",
+	"description": "错误处理中间件",
+	"main": "index.js",
+	"type": "web",
+	"state": 1,
+	"sort": 10,
+	"expose_stacktrace": false,
+	"default_status": 500,
+	"default_message": "Internal Server Error",
+	"error_codes": {
+		"400": "Bad Request",
+		"401": "Unauthorized",
+		"403": "Forbidden",
+		"404": "Not Found",
+		"500": "Internal Server Error"
+	}
+}

package/common/middleware/web_ip/index.js

@@ -0,0 +1,15 @@
+// 导出中间件主方法
+module.exports = {
+  _getClientIp(ctx) {
+    return ctx.headers['x-forwarded-for']?.split(',')[0]?.trim() ||
+      ctx.headers['x-real-ip'] ||
+      ctx.ip ||
+      'unknown';
+  },
+  async main(ctx, next) {
+    if (ctx.ip === undefined) {
+      ctx.ip = this._getClientIp(ctx);
+    }
+    await next();
+  }
+};

package/common/middleware/web_ip/middleware.json

@@ -0,0 +1,14 @@
+{
+  "name": "web_ip",
+  "title": "HTTP请求IP中间件",
+  "description": "用于记录HTTP请求IP地址",
+  "main": "index.js",
+  "type": "web",
+  "state": 1,
+  "sort": 11,
+  "level": "info",
+  "format": "default",
+  "request": true,
+  "response": true,
+  "duration": true
+}

package/common/middleware/web_logger/index.js

@@ -0,0 +1,156 @@
+// 导出中间件主方法
+module.exports = {
+  /**
+   * 初始化
+   * @param {object} adapter 适配器集合
+   */
+  init(adapter) {
+    // 获取web服务
+    var web = adapter.web;
+
+    // 注册中间件
+    web.use(async (ctx, next) => {
+      if (ctx.path === '/favicon.ico') {
+        await next();
+      } else {
+        ctx.ip = this._getClientIp(ctx);
+        ctx.start_time = Date.now();
+        let log = {
+          method: ctx.method,
+          path: ctx.path,
+          ip: ctx.ip || this._getClientIp(ctx),
+          request: this._format(ctx),
+          user_agent: this._getUserAgent(ctx)
+        };
+        try {
+          await next();
+
+          // 请求后置处理
+          log.duration = Date.now() - ctx.start_time;
+          log.response = this._sanitizeBody(ctx.body) || {};
+          log.status = ctx.status;
+          // 请求前置处理
+          this._record(log);
+        } catch (err) {
+          // 记录错误日志
+          log.duration = Date.now() - ctx.start_time;
+          log.status = 500;
+          log.response = {
+            error: {
+              message: err.message,
+              stack: err.stack
+            }
+          };
+          this._record(log);
+          
+          // 重新抛出错误，由web_error中间件统一处理
+          throw err;
+        }
+      }
+    });
+  },
+  _getClientIp(ctx) {
+    return ctx.headers['x-forwarded-for']?.split(',')[0]?.trim() ||
+      ctx.headers['x-real-ip'] || 
+      'unknown';
+  },
+  
+  /**
+   * 获取用户代理信息
+   * @private
+   * @param {object} ctx Koa上下文
+   * @returns {string} 用户代理信息
+   */
+  _getUserAgent(ctx) {
+    let ua = ctx.headers['user-agent'] || '';
+
+    // 简化的 UA 解析，只提取浏览器和 OS
+    if (ua.includes('Chrome')) return 'Chrome';
+    if (ua.includes('Firefox')) return 'Firefox';
+    if (ua.includes('Safari')) return 'Safari';
+    if (ua.includes('Postman')) return 'Postman';
+    if (ua.includes('curl')) return 'curl';
+
+    return ua.length > 20 ? ua.substring(0, 20) + '...' : ua;
+  },
+  /**
+   * 格式化请求信息
+   * @private
+   * @param {object} ctx Koa上下文
+   * @returns {object} 格式化后的请求数据
+   */
+  _format(ctx) {
+    // const headers = this._sanitizeHeaders(ctx.headers);
+    let body = ctx.request.body ? this._sanitizeBody(ctx.request.body) : undefined;
+
+    return {
+      query: ctx.query,
+      body: body
+    };
+  },
+
+  /**
+   * 清理敏感头信息
+   * @private
+   * @param {object} headers 请求头
+   * @returns {object} 清理后的请求头
+   */
+  _sanitizeHeaders(headers) {
+    const SENS_HEADERS = ['authorization', 'cookie', 'x-api-key'];
+    const SAN_VAL = {};
+
+    for (var k in headers) {
+      if (SENS_HEADERS.includes(k.toLowerCase())) {
+        SAN_VAL[k] = '[REDACTED]';
+      } else {
+        SAN_VAL[k] = headers[k];
+      }
+    }
+
+    return SAN_VAL;
+  },
+
+  /**
+   * 清理敏感请求体信息
+   * @private
+   * @param {object} body 请求体
+   * @returns {object} 清理后的请求体
+   */
+  _sanitizeBody(body) {
+    const SENS_KEYS = ['password', 'token', 'secret', 'key', 'credit_card'];
+    let by = {};
+    if (typeof(body) === 'object') {
+      for (var k in body) {
+        if (SENS_KEYS.some(field => k.toLowerCase().includes(field))) {
+          by[k] = '[REDACTED]';
+        } else {
+          by[k] = body[k];
+        }
+      }
+    }
+    return by;
+  },
+
+  /**
+   * 记录请求日志
+   * @private
+   * @param {object} log 日志对象
+   */
+  _record(log) {
+    var status = log.status;
+    this.log('http', `[${log.ip}] [${log.method}] ${log.path} ${status} ${log.duration}ms`,
+      log.request, log.response);
+    // 时间 time '2022-11-11 12:00:00'
+    // 信息级别 level 'warn'
+    // 来源IP ip '127.0.0.1'
+    // 浏览器 user_agent 'Chrome' X
+    // 查询条件 query '{'id':1}' X
+    // 提交内容 body '{'name':'test'}' X
+    // 错误信息 error 'Error: test' X
+    // 请求方法 method 'GET'
+    // 请求路径 path '/test'
+    // 响应时长 duration '38ms'
+    // 响应状态 status 200
+    // 用户ID user_id 1
+  }
+};

package/common/middleware/web_logger/middleware.json

@@ -0,0 +1,14 @@
+{
+  "name": "web_logger",
+  "title": "HTTP请求日志中间件",
+  "description": "用于记录HTTP请求日志，包括请求方法、URL、状态码、响应时间等",
+  "main": "index.js",
+  "type": "web",
+  "state": 1,
+  "sort": 20,
+  "level": "info",
+  "format": "default",
+  "request": true,
+  "response": true,
+  "duration": true
+}

package/common/middleware/web_main/index.js

@@ -0,0 +1,24 @@
+/**
+ * 中间件
+ */
+module.exports = {
+  /**
+   * 主要逻辑
+   * @param {object} ctx Koa上下文
+   * @param {Function} next 下一个中间件
+   */
+  async main(ctx, next) {
+    if (ctx.path !== '/favicon.ico') {
+      var event = $.admin.event('api');
+      var ret = await event.main(ctx.path, ctx, ctx.db);
+      if (ret) {
+        ctx.body = ret;
+        ret = await event.render(ctx.path, ctx, ctx.db);
+        if (ret) {
+          ctx.body = ret;
+        }
+      }
+    }
+    await next();
+  }
+};