mm_os 3.3.1 → 4.0.1

package/core/controller/index.js

@@ -0,0 +1,373 @@
+const {
+  Drive
+} = require('mm_machine');
+const { idGen } = require('../../ulits/id_gen.js');
+
+/**
+ * 控制器基类
+ * 负责处理请求和响应
+ */
+class Controller extends Drive {
+  static config = {
+    name: 'default',
+    // 依赖的处理器
+    ctrl_list: [],
+    timeout: 30000,
+    perf_log: false, // 是否记录性能日志
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象
+   */
+  constructor(config, parent) {
+    super({ ...Controller.config, ...config || {} }, parent);
+    // 模型实例集合
+    this._model = {};
+    // 服务实例集合
+    this._service = {};
+    // 视图实例集合
+    this._view = {};
+  }
+}
+
+/**
+ * 预设
+ */
+Controller.prototype._preset = function () {
+  // 响应格式缓存对象
+  this._response_cache = {
+    error: {
+      code: 0,
+      message: '',
+    },
+    result: null
+  };
+  // 统计信息
+  this._stats = {
+    request_count: 0,
+    all_time: 0
+  };
+};
+
+/**
+ * 获取模板目录
+ * @returns {string} 模板目录
+ */
+Controller.prototype.getTplDir = function () {
+  return __dirname;
+};
+
+/**
+ * 初始化核心
+ * @param {object} model 模型实例集合
+ * @param {object} service 服务实例集合
+ * @param {object} view 视图实例集合
+ * @param {object} eventer 事件总线
+ * @param {object} logger 日志管理器
+ */
+Controller.prototype._initCore = async function (model, service, view, eventer, logger) {
+  // 初始化依赖项
+  if (logger) {
+    this.setLogger(logger);
+  }
+  if (eventer) {
+    this.getEventer = function () {
+      return eventer;
+    };
+  }
+  if (model) this._model = model;
+  if (service) this._service = service;
+  if (view) this._view = view;
+
+  // 验证依赖项
+  this._checkDeps();
+};
+
+/**
+ * 验证依赖项
+ */
+Controller.prototype._checkDeps = function () {
+  var { models, services, views } = this.config;
+
+  for (let name of models) {
+    if (!this._model[name]) {
+      this.log('error', `model ${name} not found`);
+    }
+  }
+
+  for (let name of services) {
+    if (!this._service[name]) {
+      this.log('error', `service ${name} not found`);
+    }
+  }
+
+  for (let name of views) {
+    if (!this._view[name]) {
+      this.log('error', `view ${name} not found`);
+    }
+  }
+};
+
+
+/**
+ * 启动处理器
+ * @returns {Promise<void>}
+ * @throws {Error} 启动失败时抛出异常
+ */
+Controller.prototype._start = async function () {
+  // 记录启动日志
+  this.log('info', 'started');
+};
+
+/**
+ * 停止处理器
+ * @returns {Promise<void>}
+ * @throws {Error} 停止失败时抛出异常
+ */
+Controller.prototype._stop = async function () {
+  // 记录停止日志
+  this.log('info', 'stopped');
+};
+
+/**
+ * 销毁处理器
+ * @returns {Promise<void>}
+ * @throws {Error} 销毁失败时抛出异常
+ */
+Controller.prototype._destroy = async function () {
+  this._stats = {
+    request_count: 0,
+    all_time: 0
+  };
+
+  // 移除所有监听器
+  this.removeAllListeners();
+};
+
+/**
+ * 创建处理Promise
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @param {object} event_context 事件上下文
+ * @returns {Promise<object>} 处理结果Promise
+ */
+Controller.prototype._createRun = async function (req, res, event_context) {
+  // 请求预处理
+  await this._before(req, res);
+
+  // 触发主处理开始事件
+  this.emitEvent('request:before', event_context);
+
+  // 请求主处理逻辑
+  let result = await this.main(req, res);
+  const UPDATED_CONTEXT = {
+    ...event_context,
+    result
+  };
+
+  // 触发主处理完成事件
+  this.emitEvent('request:after', UPDATED_CONTEXT);
+
+  // 请求后处理
+  await this._after(req, res, result);
+
+  return result;
+};
+
+/**
+ * 创建超时Promise
+ * @param {number} timeout 超时时间
+ * @returns {Promise<object>} 超时Promise
+ */
+Controller.prototype._createTimeout = function (timeout) {
+  return new Promise((resolve, reject) => {
+    this.log('debug', '创建超时控制Promise', { timeout, resolve, reject });
+    let timer = setTimeout(() => {
+      const timeoutError = new Error(`Request timeout after ${timeout}ms`);
+      timeoutError.code = 408;
+      reject(timeoutError);
+    }, timeout);
+    timer.unref(); // 防止定时器阻止进程退出
+  });
+};
+
+/**
+ * 处理性能统计
+ * @param {Array} start_time 开始时间
+ * @param {object} event_context 事件上下文
+ * @returns {object} 更新后的事件上下文
+ */
+Controller.prototype._runPerfStats = function (start_time, event_context) {
+  // 性能统计结束
+  let diff = process.hrtime(start_time);
+  const TIME_MS = diff[0] * 1000 + diff[1] / 1e6;
+  this._stats.all_time += TIME_MS;
+
+  // 创建更新的事件上下文
+  const UPDATED_CONTEXT = {
+    ...event_context,
+    process_time: TIME_MS
+  };
+
+  // 记录性能日志（如果开启）
+  if (this.config.perf_log) {
+    this.log('info',
+      `request processed in ${TIME_MS.toFixed(2)}ms`
+    );
+  }
+
+  return UPDATED_CONTEXT;
+};
+
+/**
+ * 验证请求参数
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ */
+Controller.prototype._validateReq = function (req, res) {
+  if (!req || typeof req !== 'object') {
+    throw new TypeError('请求对象不能为空且必须是对象');
+  }
+  if (!res || typeof res !== 'object') {
+    throw new TypeError('响应对象不能为空且必须是对象');
+  }
+};
+
+/**
+ * 创建事件上下文
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @returns {object} 事件上下文
+ */
+Controller.prototype._createEventContext = function (req, res) {
+  return {
+    request_id: req.id || idGen.genId('req'),
+    hdl_name: this.config.name,
+    req,
+    res
+  };
+};
+
+/**
+ * 处理请求主方法
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @returns {Promise<object>} 处理结果
+ */
+Controller.prototype.run = async function (req, res) {
+  this._validateReq(req, res);
+  var event_context = this._createEventContext(req, res);
+  this.emitEvent('request:before', event_context);
+  var start_time = process.hrtime();
+  this._stats.request_count++;
+
+  try {
+    var result = await this._execWithTimeout(req, res, event_context);
+    var response = this._formatResponse(result);
+    event_context.response = response;
+    this.emitEvent('request:success', event_context);
+    return response;
+  } catch (error) {
+    event_context.error = error;
+    this.emitEvent('request:error', event_context);
+    this.log('error', 'handle error:', error);
+    return this._formatError(error);
+  } finally {
+    var final_context = this._runPerfStats(start_time, event_context);
+    this.emitEvent('request:after', final_context);
+  }
+};
+
+/**
+ * 执行带超时的处理
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @param {object} event_context 事件上下文
+ * @returns {Promise<object>} 处理结果
+ */
+Controller.prototype._execWithTimeout = async function (req, res, event_context) {
+  var timeout = this.config.timeout;
+  var hdl_promise = this._createRun(req, res, event_context);
+  if (timeout > 0) {
+    var timeout_promise = this._createTimeout(timeout);
+    return await Promise.race([hdl_promise, timeout_promise]);
+  }
+  return await hdl_promise;
+};
+
+/**
+ * 请求预处理方法
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @returns {Promise<void>}
+ */
+Controller.prototype._before = async function (req, res) {
+  this.log('debug', '请求预处理', { req, res });
+};
+
+/**
+ * 请求主处理逻辑
+ * 核心业务逻辑应该在此方法中实现
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @returns {Promise<object>} 处理结果
+ */
+Controller.prototype.main = async function (req, res) {
+  this.log('debug', '默认请求处理，子类应重写此方法', { req, res });
+  // 默认实现，子类必须重写
+  throw new Error('main method must be overridden');
+};
+
+/**
+ * 请求后处理方法
+ * @param {object} req 请求对象
+ * @param {object} res 响应对象
+ * @param {object} result 处理结果
+ * @returns {Promise<void>}
+ */
+Controller.prototype._after = async function (req, res, result) {
+  this.log('debug', '请求后处理', { req, res, result });
+  // 后处理请求，不触发额外事件
+};
+
+/**
+ * 格式化响应
+ * 优化：复用响应对象，减少GC压力
+ * @param {number} code 响应码
+ * @param {string} message 响应消息
+ * @param {object} data 响应数据
+ * @returns {object} 格式化后的响应对象
+ */
+Controller.prototype._formatResponse = function (result) {
+  // 返回新对象，避免外部修改影响缓存
+  return $.ret.ret(result);
+};
+
+/**
+ * 格式化错误响应
+ * @param {object} error 错误对象
+ * @returns {object} 格式化后的错误响应
+ */
+Controller.prototype._formatError = function (error) {
+  // 快速错误处理，减少属性访问
+  let code = error && error.code || 500;
+  let message = error && error.message || 'Internal Server Error';
+  return $.ret.error(code, message);
+};
+
+/**
+ * 获取性能统计信息
+ * @returns {object} 性能统计数据
+ */
+Controller.prototype.getStats = function () {
+  return {
+    request_count: this._stats.request_count,
+    all_time: this._stats.all_time,
+    average_time: this._stats.request_count > 0 ?
+      this._stats.all_time / this._stats.request_count : 0
+  };
+};
+
+exports.Controller = Controller;

package/core/controller/script.tpl.js

@@ -0,0 +1,27 @@
+/**
+ * 控制器，主要用于处理请求和响应
+ */
+module.exports = {
+  /**
+   * 初始化
+   * @param {object} model 模型
+   * @param {object} service 服务
+   * @param {object} view 视图
+   * @param {object} eventer 事件总线
+   */
+  async _init(model, service, view, eventer) {
+    this.log('debug', '控制器初始化');
+    // 初始化代码写在这
+  },
+  /**
+   * 主要逻辑
+   * @param {object} ctx 上下文
+   * @param {object} db 数据库
+   * @returns {Promise} 返回一个Promise对象
+   */
+  async main(ctx, db) {
+    this.log('debug', '控制器主要逻辑', { ctx, db });
+    // 主要代码写在这
+    return 'Hello world!';
+  }
+};

package/core/factory/config.tpl.json

@@ -0,0 +1,14 @@
+{
+  // 名称
+  "name": "${name}",
+  // 标题
+  "title": "${title || '角色工厂'}",
+  // 描述
+  "description": "${description || '用于创建和管理角色的工厂'}",
+  // 主文件
+  "main": "${main || 'index.js'}",
+  // 状态 0：禁用 1：启用
+  "state": 1,
+  // 排序，越小越靠前
+  "sort": 100
+}

package/core/factory/entity.js

@@ -0,0 +1,275 @@
+/**
+ * 实体类
+ * 纯粹的实体标识符，不包含任何业务逻辑
+ * 只负责管理组件引用和实体生命周期
+ */
+const { idGen } = require('../../ulits/id_gen.js');
+class Entity {
+  #is_dirty = false;
+
+  /**
+   * 构造函数
+   * @param {string} entity_id 实体ID
+   * @param {string} player_id 玩家ID
+   * @param {string} type 实体类型, 例如：玩家player、怪物monster、道具prop等
+   */
+  constructor(entity_id, player_id, type) {
+    // 实体名称
+    this.name = '';
+    // 实体ID
+    this.entity_id = entity_id || this.genId();
+    // 实体类型
+    this.type = type || '';
+    // 玩家ID - 如果是玩家就有此ID
+    this.player_id = player_id || '';
+    // 是否活跃
+    this.is_active = true;
+    // 实体组件
+    this._component = new Map();
+
+    // 创建属性代理
+    this._createProperty();
+  }
+
+  /**
+   * 检查实体是否脏数据
+   * @param {boolean} is_dirty 是否脏数据
+   * @returns {boolean} 是否脏数据
+   */
+  isDirty(is_dirty) {
+    if (is_dirty !== undefined) {
+      this.#is_dirty = is_dirty;
+    }
+    return this.#is_dirty;
+  };
+}
+
+/**
+ * 创建属性代理
+ * 使组件属性可以通过点语法直接访问
+ * 例如：entity.attr.hp 可以访问 attr 组件中的 hp 属性
+ */
+Entity.prototype._createProperty = function () {
+  var self = this;
+
+  // 为每个已存在的组件创建属性访问器
+  var keys = Array.from(self._component.keys());
+  for (var i = 0; i < keys.length; i++) {
+    (function (name) {
+      Object.defineProperty(self, name, {
+        get: function () {
+          return self._component.get(name);
+        },
+        set: function (value) {
+          if (typeof value === 'object' && value !== null) {
+            self._component.set(name, value);
+            // 标记为脏数据
+            self.isDirty(true);
+          }
+        },
+        enumerable: true,
+        configurable: true
+      });
+    })(keys[i]);
+  }
+
+  // 重写 addComponent 方法，使其在添加组件时自动创建属性访问器
+  let comp = self.addComponent;
+  self.addComponent = function (name, component) {
+    // 调用原始方法
+    comp.call(self, name, component);
+
+    // 创建属性访问器
+    Object.defineProperty(self, name, {
+      get: function () {
+        return self._component.get(name);
+      },
+      set: function (value) {
+        if (typeof value === 'object' && value !== null) {
+          self._component.set(name, value);
+          // 标记为脏数据
+          self.isDirty(true);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+  };
+};
+
+/**
+ * 获取实体ID
+ * @returns {string} 实体ID
+ */
+Entity.prototype.getId = function () {
+  return this.entity_id;
+};
+
+/**
+ * 检查实体是否活跃
+ * @returns {boolean} 是否活跃
+ */
+Entity.prototype.isActive = function () {
+  return this.is_active;
+};
+
+/**
+ * 激活实体
+ */
+Entity.prototype.activate = function () {
+  this.is_active = true;
+};
+
+/**
+ * 停用实体
+ */
+Entity.prototype.deactivate = function () {
+  this.is_active = false;
+};
+
+/**
+ * 添加组件
+ * @param {string} name 组件类型
+ * @param {object} component 组件数据
+ */
+Entity.prototype.addComponent = function (name, component) {
+  // 参数校验
+  if (typeof name !== 'string') {
+    throw new TypeError('组件类型必须是字符串');
+  }
+
+  if (typeof component !== 'object') {
+    throw new TypeError('组件数据必须是对象');
+  }
+  this._component.set(name, component);
+};
+
+/**
+ * 获取组件
+ * @param {string} name 组件类型
+ * @returns {object|null} 组件数据
+ */
+Entity.prototype.getComponent = function (name) {
+  // 参数校验
+  if (typeof name !== 'string') {
+    throw new TypeError('组件类型必须是字符串');
+  }
+  return this._component.get(name) || null;
+};
+
+/**
+ * 检查是否包含组件
+ * @param {string} name 组件类型
+ * @returns {boolean} 是否包含组件
+ */
+Entity.prototype.hasComponent = function (name) {
+  // 参数校验
+  if (typeof name !== 'string') {
+    throw new TypeError('组件类型必须是字符串');
+  }
+  return this._component.has(name);
+};
+
+/**
+ * 移除组件
+ * @param {string} name 组件类型
+ * @returns {boolean} 是否移除成功
+ */
+Entity.prototype.delComponent = function (name) {
+  // 参数校验
+  if (typeof name !== 'string') {
+    throw new TypeError('组件类型必须是字符串');
+  }
+  return this._component.delete(name);
+};
+
+/**
+ * 获取所有组件类型
+ * @returns {Array} 组件类型数组
+ */
+Entity.prototype.getComponentTypes = function () {
+  return Array.from(this._component.keys());
+};
+
+/**
+ * 转换为JSON字符串
+ * @returns {string} JSON字符串
+ */
+Entity.prototype.toJson = function () {
+  let data = {
+    entity_id: this.entity_id,
+    player_id: this.player_id,
+    is_active: this.is_active,
+    name: this.name,
+    type: this.type,
+    components: Object.fromEntries(this._component)
+  };
+  return JSON.stringify(data);
+};
+
+/**
+ * 从JSON字符串解析实体
+ * @param {string} json_str JSON字符串
+ * @returns {Entity} 实体对象
+ */
+Entity.prototype.fromJson = function (json_str) {
+  // 参数校验
+  if (typeof json_str !== 'string') {
+    throw new TypeError('JSON字符串必须是字符串');
+  }
+  let data = JSON.parse(json_str);
+
+  if (!data.entity_id) {
+    throw new Error('JSON字符串缺少实体ID');
+  }
+
+  // 设置基本属性
+  this.entity_id = data.entity_id;
+  this.player_id = data.player_id || '';
+  this.is_active = data.is_active !== undefined ? data.is_active : true;
+  this.name = data.name || '';
+  this.type = data.type || '';
+
+  // 恢复组件
+  if (data.components && typeof data.components === 'object') {
+    for (var k in data.components) {
+      this.addComponent(k, data.components[k]);
+    }
+    // 创建属性访问器
+    this._createProperty();
+  }
+
+  return this;
+};
+
+/**
+ * 生成唯一实体ID
+ * @returns {string} 唯一实体ID
+ */
+Entity.prototype.genId = function () {
+  return idGen.genId('entity');
+};
+
+/**
+ * 设置实体模型
+ * @param {object} model 实体模型
+ */
+Entity.prototype.setModel = function (model) {
+  for (var k in model) {
+    let value = model[k];
+    if (typeof value === 'object') {
+      var component = this.getComponent(k);
+      if (component) {
+        $.push(component, value);
+        this.addComponent(k, component);
+      }
+    }
+    else if (this.hasOwnProperty(k)) {
+      this[k] = value;
+    }
+  }
+};
+
+module.exports = {
+  Entity
+};