mm_statics 1.9.0 → 1.9.2

package/lib/manager.js

@@ -0,0 +1,285 @@
+const Manager = require("mm_machine").Manager;
+const Static = require("./static");
+const { URLSearchParams } = require('url');
+
+/**
+ * 静态文件管理类
+ * @augments {Manager}
+ * @class
+ */
+class StaticManager extends Manager {
+  /**
+   * 配置参数
+   * @type {object}
+   */
+  static config = {
+    /**
+     * 标题
+     * @type {string}
+     */
+    title: "静态文件管理",
+    /**
+     * 描述
+     * @type {string}
+     */
+    description: "这是静态文件管理器",
+    /**
+     * 运行根路径（驱动计算物理根目录的回退值，为空时取 process.cwd()）
+     * @type {string}
+     */
+    run_path: "",
+    /**
+     * 最大深度
+     * @type {number}
+     */
+    max_depth: 6,
+    /**
+     * 资源清单文件名（update 扫描目录时使用）
+     * @type {string}
+     */
+    filename: "static.json"
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父级模块
+   */
+  constructor(config, parent) {
+    super({ ...StaticManager.config, ...config }, parent);
+  }
+
+  /**
+   * 处理请求
+   * @param {object} ctx Http请求上下文
+   * @param {object} next 跳过函数
+   */
+  async _handleRequest(ctx, next) {
+    var md = ctx.method || (ctx.params && ctx.params.method) || '';
+    var path = ctx.path || (ctx.params && ctx.params.path) || '';
+    if (md === "GET" || md === "HEAD") {
+      await this._handleGetRequest(ctx, next, path);
+    } else {
+      await next();
+    }
+  }
+
+  /**
+   * 处理GET请求
+   * @param {object} ctx Http请求上下文
+   * @param {object} next 跳过函数
+   */
+  async run(ctx, next) {
+    var done;
+    var infos = this.configs;
+    var len = infos.length;
+    let path = ctx.path || (ctx.params && ctx.params.path) || '';
+    if (path.indexOf(".") !== -1) {
+      done = await this._tryServeFile(ctx, infos, len, async () => {});
+      if (!done) {
+        await next();
+      }
+    } else {
+      await next();
+      await this._handleDirReq(ctx, infos, len, path);
+    }
+  }
+
+  /**
+   * 尝试提供文件服务
+   * @param {object} ctx Http请求上下文
+   * @param {Array} infos 驱动信息列表
+   * @param {number} len 列表长度
+   * @param {object} next 跳过函数
+   * @returns {boolean} 是否成功
+   */
+  async _tryServeFile(ctx, infos, len, next) {
+    for (var i = 0; i < len; i++) {
+      var info = infos[i];
+      let is_running = await this.isRunning(info.name);
+      if (is_running) {
+        let mod = this.get(info.name);
+        if (mod) {
+          await this._initDrive(mod);
+          var done = await mod.run(ctx, next);
+          if (done) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * 处理目录请求
+   * @param {object} ctx Http请求上下文
+   * @param {Array} infos 驱动信息列表
+   * @param {number} len 列表长度
+   * @param {string} path 请求路径
+   */
+  async _handleDirReq(ctx, infos, len, path) {
+    var q = this._getQueryString(ctx);
+    for (var i = 0; i < len; i++) {
+      var info = infos[i];
+      let is_running = await this.isRunning(info.name);
+      if (is_running) {
+        let mod = this.get(info.name);
+        if (mod) {
+          var p = mod.config.path;
+          if (path === p) {
+            this._handleExactMatch(ctx, q, p);
+            break;
+          } else {
+            await this._initDrive(mod);
+            var done = await mod.run(ctx, () => {});
+            if (done) {
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * 获取查询字符串
+   * 兼容 Koa 的 ctx.request.querystring 与 mm_web_server 的 ctx.params.query
+   * @param {object} ctx Http请求上下文
+   * @returns {string} 查询字符串
+   */
+  _getQueryString(ctx) {
+    if (ctx.request && ctx.request.querystring !== undefined) {
+      return ctx.request.querystring;
+    }
+    var query = ctx.params && ctx.params.query;
+    if (query && typeof query === 'object') {
+      return new URLSearchParams(query).toString();
+    }
+    return '';
+  }
+
+  /**
+   * 处理精确匹配
+   * @param {object} ctx Http请求上下文
+   * @param {string} q 查询字符串
+   * @param {string} p 路径
+   */
+  _handleExactMatch(ctx, q, p) {
+    // mm_web_server 原生 ctx 无 status 字段，未设置时视为 404 以兼容旧逻辑
+    var status = ctx.status === undefined ? 404 : ctx.status;
+    if (status === 404 && typeof ctx.redirect === 'function') {
+      // 驱动路径可能已带尾部斜杠，避免拼接出双斜杠
+      var target = p.endsWith('/') ? p : p + '/';
+      if (q) {
+        ctx.redirect(target + "?" + q);
+      } else {
+        ctx.redirect(target);
+      }
+    }
+  }
+}
+
+/**
+ * 静态文件驱动类
+ * @type {Drive}
+ */
+StaticManager.prototype.Drive = Static;
+
+/**
+ * 注册一个静态资源驱动（方案B：手动注册，不扫描目录）
+ * @param {object} config 驱动配置（必须包含 name）
+ * @returns {object} 驱动实例
+ */
+StaticManager.prototype.add = function (config) {
+  var drive = new this.Drive({ run_path: this.config.run_path, ...config }, this);
+  this.set(drive.config.name, drive);
+  return drive;
+};
+
+/**
+ * 注销一个静态资源驱动（先停止再删除注册表项）
+ * @param {string} name 驱动名称
+ * @returns {Promise<boolean>} 是否删除成功
+ */
+StaticManager.prototype.del = async function (name) {
+  var drive = this.get(name);
+  if (drive) {
+    await drive.stop();
+  }
+  return await Manager.prototype.del.call(this, name);
+};
+
+/**
+ * 重启一个静态资源驱动（stop 后重新 init/start）
+ * 注意：生命周期状态机不支持 stopped 后再次 start，失败时需 del 后重新 add 实现手动重启
+ * @param {string} name 驱动名称
+ * @returns {Promise<boolean>} 是否执行成功
+ */
+StaticManager.prototype.reload = async function (name) {
+  var drive = this.get(name);
+  if (!drive) {
+    this.log("warn", "驱动不存在，无法重启", name);
+    return false;
+  }
+  try {
+    await drive.stop();
+    await this._initDrive(drive);
+    await drive.start();
+    return true;
+  } catch (err) {
+    this.log("warn", "驱动重启失败（生命周期不支持停止后重启，请 del 后重新 add）", name, err);
+    return false;
+  }
+};
+
+/**
+ * 获取所有驱动配置列表（方案B：来自注册表，替代旧基类 getInfos）
+ * @returns {Array} 驱动配置数组
+ * @private
+ */
+StaticManager.prototype._getInfos = function () {
+  return this.values().map((d) => d.config);
+};
+
+/**
+ * 初始化驱动实例（重复调用安全由驱动自身保证）
+ * @param {object} drive 驱动实例
+ * @returns {Promise<void>} 初始化完成
+ * @private
+ */
+StaticManager.prototype._initDrive = async function (drive) {
+  await drive.init();
+};
+
+/**
+ * 初始化桥接（生命周期汇聚点：init() 与 do('init') 均调用，触发 onInit）
+ * @returns {Promise<void>} 初始化完成
+ * @private
+ */
+StaticManager.prototype._init = async function () {
+  await this.onInit();
+};
+
+/**
+ * 启动桥接（生命周期汇聚点，触发 onStart）
+ * @returns {Promise<void>} 启动完成
+ * @private
+ */
+StaticManager.prototype._start = async function () {
+  await this.onStart();
+};
+
+/**
+ * 停止桥接（生命周期汇聚点，触发 onStop）
+ * @returns {Promise<void>} 停止完成
+ * @private
+ */
+StaticManager.prototype._stop = async function () {
+  await this.onStop();
+};
+
+/**
+ * @module 导出静态文件管理器类
+ */
+module.exports = StaticManager;

package/lib/static.js

@@ -0,0 +1,237 @@
+const path = require('path');
+const Item = require('mm_machine').Mod;
+const { string } = require('mm_helper');
+
+/**
+ * 静态文件驱动类
+ * @augments {Item}
+ * @class
+ */
+class Static extends Item {
+  static config = {
+    // 应用名
+    'app': 'server',
+    // 插件名
+    'plugin': 'sys',
+    // 物理根目录
+    'root': '',
+    // 路由根路径
+    'path': '',
+    // 首页
+    'index': 'index.html',
+    // 重定向
+    'redirect': true,
+    // 缓存保留10分钟
+    'max_age': 60 * 10,
+    // 是否保持不变
+    'immutable': true,
+    // 是否启用brotli压缩
+    'brotli': true,
+    // 是否启用gizp压缩
+    'gzip': true,
+    // 允许访问的拓展名
+    'extensions': null,
+    // 是否将ES6转换AMD
+    'convert_amd': true,
+    // 主程序文件 - 默认为空
+    'main': '',
+    // 状态 0未启用，1启用
+    'state': 1,
+    // 驱动目录（方案B：手动配置，替代目录扫描）
+    'dir': '',
+    // 运行根路径（计算物理根目录的回退值，为空时取父级配置或 process.cwd()）
+    'run_path': ''
+  };
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象
+   * @class
+   */
+  constructor(config, parent) {
+    super({ ...Static.config, ...config });
+    // 父级管理器引用（用于默认配置回退与插件查找）
+    this.parent = parent || null;
+  }
+}
+
+/**
+ * 发送文件函数（复用 Static 实例的原生文件发送，不依赖 koa-send）
+ * @param {object} ctx Http请求上下文
+ * @param {string} file_path 文件路径
+ * @param {object} config 发送配置（保留参数，兼容旧调用）
+ * @returns {Promise<string>} 发送成功返回物理文件路径
+ */
+Static.prototype.send = async function (ctx, file_path, config) {
+  if (!this.static) {
+    this._preset();
+  }
+  return await this.static._sendFile(ctx, file_path);
+};
+
+/**
+ * 生命周期初始化钩子：规范化配置并创建静态文件处理器
+ * @returns {Promise<void>} 初始化完成
+ */
+Static.prototype.onInit = async function () {
+  this._preset();
+};
+
+/**
+ * 更新配置对象前
+ */
+Static.prototype._preset = function () {
+  var cg = this.config;
+  if (cg.maxAge) {
+    cg.max_age = cg.maxAge * 1000;
+    delete cg.maxAge;
+  }
+  if (!cg.app) {
+    cg.app = this.getAppName(cg.dir);
+  }
+  if (!cg.plugin) {
+    cg.plugin = this.getPluginName(cg.dir);
+  }
+  if (!cg.path) {
+    let app = cg.app || this.getAppName(cg.dir);
+    let plugin = cg.plugin || this.getPluginName(cg.dir);
+    if (plugin) {
+      cg.path = `/${app}/${plugin}/`;
+    }
+    else {
+      cg.path = `/${app}/`;
+    }
+  }
+  else if (!cg.path.endsWith('/')) {
+    cg.path += '/';
+  }
+  if (!cg.root) {
+    cg.root = this._getRoot(cg.dir);
+  }
+  const Static = require('./static_handle');
+  this.static = new Static(cg);
+};
+
+/**
+ * 获取应用名
+ * @param {string} file 文件路径
+ * @returns {string} 应用名
+ */
+Static.prototype.getAppName = function (file) {
+  if (!file || typeof file !== 'string') {
+    return '';
+  }
+  return string.between(file, 'app/', '/') || '';
+};
+
+/**
+ * 获取插件名
+ * @param {string} file 文件路径
+ * @returns {string} 插件名
+ */
+Static.prototype.getPluginName = function (file) {
+  if (!file || typeof file !== 'string') {
+    return '';
+  }
+  return string.between(file, 'plugin/', '/') || '';
+};
+
+/**
+ * 获取物理根目录
+ * @param {string} file 文件路径
+ * @returns {string} 物理根目录
+ */
+Static.prototype._getRoot = function (file) {
+  if (!file || typeof file !== 'string') {
+    return '';
+  }
+  let f = file.replace(/\\/g, '/');
+  let dir = path.dirname(f).replace(/\\/g, '/').toLowerCase();
+  let run_path = (this.config.run_path || (this.parent && this.parent.config.run_path) || process.cwd()).replace(/\\/g, '/').toLowerCase();
+  return dir.replace(run_path, '.');
+};
+
+/**
+ * 执行前
+ * @param {object} ctx http请求上下文
+ * @param {object} path 文件路径
+ */
+Static.prototype.before = async function (ctx, path) { };
+
+/**
+ * 执行
+ * 兼容两种调用方式：
+ *  - 中间件方式：main(ctx, next)，文件路径取自 ctx.path / ctx.params.path
+ *  - 显式路径方式：main(ctx, file_path)，直接发送指定文件
+ * @param {object} ctx http请求上下文
+ * @param {object|Function} path 文件路径或下一个中间件
+ * @returns {Promise<string>} 发送成功返回物理文件路径，未命中返回空字符串
+ */
+Static.prototype.main = async function (ctx, path) {
+  if (typeof path === 'function') {
+    return await this.run(ctx, path);
+  }
+  return await this.send(ctx, path, this.config);
+};
+
+/**
+ * 执行后
+ * @param {object} ctx http请求上下文
+ * @param {object} path 文件路径
+ */
+Static.prototype.after = async function (ctx, path) { };
+
+/**
+ * 执行静态文件
+ * @param {object} ctx Http请求上下文
+ * @param {object} next 跳过当前函数
+ * @returns {string} 执行成功返回文件路径
+ */
+Static.prototype.run = async function (ctx, next) {
+  if (!this.static) {
+    this._preset();
+  }
+  return await this.static.main(ctx, next);
+};
+
+/**
+ * 删除静态文件缓存
+ * @param {string} url 请求路径（含查询参数），如 /src/test.js
+ * @returns {Promise<void>} 删除完成
+ */
+Static.prototype._delCache = async function (url) {
+  if (!this.static) {
+    this._preset();
+  }
+  await this.static._delCache(url);
+};
+
+/**
+ * 获取名称
+ * @param {string} file 文件路径
+ * @returns {string} 名称
+ */
+Static.prototype._getName = function (file) {
+  return path.basename(path.dirname(path.dirname(file)));
+};
+
+/**
+ * 获取模型
+ * @param {string} type 模型类型
+ * @returns {object} 返回获取到的模型
+ */
+Static.prototype.getModel = function (type) {
+  let model = { ...this.config };
+  let dir = this.config.dir || '';
+  let l = path.sep;
+  let app_name = string.between(dir, 'app' + l, l);
+  let plugin_name = string.between(dir, 'plugin' + l, l);
+  let name = path.basename(dir);
+  model.app = app_name;
+  model.plugin = plugin_name;
+  model.name = model.name || (plugin_name ? plugin_name + '_' + name : app_name + '_' + name);
+  model.path = model.path || (plugin_name ? `/${app_name}/${plugin_name}/` : `/${app_name}/`);
+  return model;
+};
+
+module.exports = Static;