mm_expand 2.0.1 → 2.0.2

package/lib/base.js

@@ -33,7 +33,7 @@ class Base extends Event {
 
     /**
 		 * 状态
-		 * @type {string} - 状态, 可选值: created, init, running, stopped
+		 * @type {string} - 状态, 可选值: created, initing, starting, running, stopped, destroying, destroyed
 		 */
     this.status = 'created';
 
@@ -58,39 +58,54 @@ Base.prototype.log = function (level, message, ...args) {
  * 初始化监听
  */
 Base.prototype._initListen = function () {
+  let status_last = 'created';
+  // 初始化
   this.on('init:before', (ctx) => {
     this.status = 'initing';
     this._initCore(...ctx.params);
   });
+  this.on('init:after', (ctx) => {
+    this.status = 'inited';
+  });
+  // 启动
   this.on('start:before', (ctx) => {
+    status_last = this.status;
     this.status = 'starting';
   });
-  this.on('start:after', (ctx) => {
+  this.on('start:success', (ctx) => {
     this.status = 'running';
   });
+  this.on('start:error', (ctx) => {
+    this.status = status_last;
+  });
+  // 停止
   this.on('stop:before', (ctx) => {
+    status_last = this.status;
     this.status = 'stopping';
   });
-  this.on('stop:after', (ctx) => {
+  this.on('stop:success', (ctx) => {
     this.status = 'stopped';
   });
-  this.on('restart:before', (ctx) => {
-    this.status = 'restarting';
-  });
-  this.on('restart:after', (ctx) => {
-    this.status = 'running';
+  this.on('stop:error', (ctx) => {
+    this.status = status_last;
   });
+  // 销毁
   this.on('destroy:before', (ctx) => {
+    status_last = this.status;
     this.status = 'destroying';
   });
   this.on('destroy:check', (ctx) => {
-    if (this.status !== 'stopped') {
+    if (status_last !== 'stopped') {
+      status_last = this.status;
       ctx.error = new Error('销毁前必须先停止');
     }
   });
-  this.on('destroy:after', (ctx) => {
+  this.on('destroy:success', (ctx) => {
     this.status = 'destroyed';
   });
+  this.on('destroy:error', (ctx) => {
+    this.status = status_last;
+  });
 };
 
 /**
@@ -149,8 +164,8 @@ Base.prototype.destroy = async function () {
  * 重启
  */
 Base.prototype.restart = async function () {
-  await this.stop();
-  await this.start();
+  await this.do('stop');
+  await this.do('start');
 };
 
 /**
@@ -195,43 +210,57 @@ Base.prototype.do = async function (method, ...args) {
 
   try {
     await this._doBeforeProcess(method, ctx);
-    if (ctx.error || ctx.cancelled) {
+    if (ctx.cancelled) {
       return ctx.result;
     }
 
     await this._doExecuteMethod(method, ctx);
+    
+    // 如果执行成功，进行成功处理
+    if (!ctx.error) {
+      await this._doSuccessProcess(method, ctx);
+    }
+    
+    return ctx.result;
   } catch (error) {
     ctx.error = error;
     this.log('error', `事件驱动执行异常 [${method}]`, error);
+    
+    // 执行错误处理
+    await this._doErrorProcess(method, ctx);
+    
+    // 重新抛出错误，让上层能够捕获
+    throw error;
+  } finally {
+    // 无论成功失败，都要执行后处理
+    await this._doAfterProcess(method, ctx);
   }
-
-  await this._doAfterProcess(method, ctx);
-
-  return ctx.result;
 };
 
+/**
+ * 前处理阶段
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._doBeforeProcess = async function (method, ctx) {
-  try {
-    await this.emitWait(method + ':before', ctx);
-  } catch (error) {
-    this.log('error', `前置处理失败 [${method}:before]`, error);
-    ctx.error = error;
-  }
+  await this.emitWait(method + ':before', ctx);
 };
 
+/**
+ * 执行方法
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._doExecuteMethod = async function (method, ctx) {
-  try {
-    await this._doCheckPhase(method, ctx);
-    if (ctx.error) return;
+  await this._doCheckPhase(method, ctx);
+  if (ctx.error) return;
 
-    await this._doMainMethod(method, ctx);
-    if (ctx.error) return;
+  await this._doMainMethod(method, ctx);
+  if (ctx.error) return;
 
-    await this._doRenderPhase(method, ctx);
-  } catch (error) {
-    ctx.error = error;
-    this.log('error', `执行阶段异常 [${method}]`, error);
-  }
+  await this._doRenderPhase(method, ctx);
 };
 
 /**
@@ -240,62 +269,74 @@ Base.prototype._doExecuteMethod = async function (method, ctx) {
  * @param {object} ctx 上下文对象
  */
 Base.prototype._doCheckPhase = async function (method, ctx) {
-  let check_result;
-  try {
-    check_result = await this.emitRace(method + ':check', ctx);
-  } catch (error) {
-    this.log('error', `检查阶段失败 [${method}:check]`, error);
-    ctx.error = error;
-    return;
-  }
+  let ret = await this.emitRace(method + ':check', ctx);
 
-  if (check_result) {
-    if (check_result.status === 'rejected') {
-      ctx.error = check_result.error;
-    } else if (check_result.status === 'fulfilled' && check_result.result) {
-      ctx.result = check_result.result;
+  if (ret) {
+    if (ret.status === 'rejected') {
+      ctx.error = ret.error;
+    } else if (ret.status === 'fulfilled' && ret.result) {
+      ctx.result = ret.result;
     }
   }
 };
 
+/**
+ * 主方法执行
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._doMainMethod = async function (method, ctx) {
   if (!ctx.result) {
-    try {
-      ctx.result = await this[method](...ctx.params);
-    } catch (error) {
-      ctx.error = error;
-      this.log('error', `主方法执行失败 [${method}]`, error);
-    }
+    ctx.result = await this[method](...ctx.params);
   }
 };
 
+/**
+ * 渲染阶段
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._doRenderPhase = async function (method, ctx) {
   if (ctx.result && !ctx.error) {
-    try {
-      let result = await this.emitWaterfall(method + ':render', ctx.result, ctx);
-      if (result) {
-        ctx.result = result;
-      }
-    } catch (error) {
-      this.log('error', `渲染阶段失败 [${method}:render]`, error);
+    let result = await this.emitWaterfall(method + ':render', ctx.result, ctx);
+    if (result) {
+      ctx.result = result;
     }
   }
 };
 
+/**
+ * 成功处理阶段
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ * @private
+ */
+Base.prototype._doSuccessProcess = async function (method, ctx) {
+  await this.emitWait(method + ':success', ctx);
+};
+
+/**
+ * 后处理阶段
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._doAfterProcess = async function (method, ctx) {
-  if (ctx.error) {
-    try {
-      await this.emitAsync(method + ':error', ctx);
-      this.log('error', `执行方法${method}出错：`, ctx.error);
-    } catch (error) {
-      this.log('error', `错误处理失败 [${method}:error]`, error);
-    }
-  }
+  // 异步触发after事件，不等待执行完成
+  this.emitAsync(method + ':after', ctx);
+};
 
-  try {
-    await this.emitWait(method + ':after', ctx);
-  } catch (error) {
-    this.log('error', `后置处理失败 [${method}:after]`, error);
+/**
+ * 错误处理
+ * @param {string} method 方法名称
+ * @param {object} ctx 上下文对象
+ */
+Base.prototype._doErrorProcess = async function (method, ctx) {
+  if (ctx.error) {
+    await this.emitAsync(method + ':error', ctx);
+    this.log('error', `执行方法${method}出错：`, ctx.error);
   }
 };
 
@@ -378,6 +419,16 @@ Base.prototype.run = async function (...args) {
   return await this.do('main', ...args);
 };
 
+/**
+ * 执行方法
+ * @param {string} method 方法名称
+ * @param  {...any} args 参数列表
+ * @returns 
+ */
+Base.prototype.exec = async function (method, ...args) {
+  return await this.do(method, ...args);
+};
+
 /**
  * 执行指令(主要)
  * @param {string} command 指令
@@ -415,6 +466,11 @@ Base.prototype.cmd = async function (command, ...args) {
   }
 };
 
+/**
+ * 解析指令
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._cmdParseCommand = function (ctx) {
   try {
     ctx.cmds = ctx.command.split('.');
@@ -430,6 +486,11 @@ Base.prototype._cmdParseCommand = function (ctx) {
   }
 };
 
+/**
+ * 遍历指令路径
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._cmdTraversePath = async function (ctx) {
   for (let index = 0; index < ctx.cmds.length; index++) {
     const key = ctx.cmds[index];
@@ -463,6 +524,14 @@ Base.prototype._cmdTraversePath = async function (ctx) {
   ctx.result = ctx.obj;
 };
 
+/**
+ * 处理指令对象类型
+ * @param {object} ctx 上下文对象
+ * @param {string} key 当前键名
+ * @param {boolean} is_last 是否为最后一个键名
+ * @returns {boolean} 是否停止遍历
+ * @private
+ */
 Base.prototype._cmdHandleType = async function (ctx, key, is_last) {
   const type = typeof ctx.obj;
 
@@ -478,6 +547,13 @@ Base.prototype._cmdHandleType = async function (ctx, key, is_last) {
   return false;
 };
 
+/**
+ * 处理指令对象类型：函数
+ * @param {object} ctx 上下文对象
+ * @param {boolean} is_last 是否为最后一个键名
+ * @returns {boolean} 是否停止遍历
+ * @private
+ */
 Base.prototype._cmdHandleFunction = async function (ctx, is_last) {
   if (typeof ctx.obj !== 'function') {
     this.log('error', `指令指向的对象不是函数 [${ctx.command}]`);
@@ -501,6 +577,13 @@ Base.prototype._cmdHandleFunction = async function (ctx, is_last) {
   return false;
 };
 
+/**
+ * 处理指令对象类型：数组
+ * @param {object} ctx 上下文对象
+ * @param {boolean} is_last 是否为最后一个键名
+ * @returns {boolean} 是否停止遍历
+ * @private
+ */
 Base.prototype._cmdHandleArray = function (ctx, is_last) {
   if (is_last) {
     ctx.result = ctx.obj;
@@ -513,6 +596,13 @@ Base.prototype._cmdHandleArray = function (ctx, is_last) {
   return true;
 };
 
+/**
+ * 处理指令对象类型：原始值
+ * @param {object} ctx 上下文对象
+ * @param {boolean} is_last 是否为最后一个键名
+ * @returns {boolean} 是否停止遍历
+ * @private
+ */
 Base.prototype._cmdHandlePrimitive = function (ctx, is_last) {
   if (is_last) {
     ctx.result = ctx.obj;
@@ -550,6 +640,11 @@ Base.prototype.help = async function (...args) {
   }
 };
 
+/**
+ * 处理帮助参数
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._helpProcessArgs = function (ctx) {
   if (ctx.args.length > 0) {
     ctx.param = ctx.args[0];
@@ -561,6 +656,11 @@ Base.prototype._helpProcessArgs = function (ctx) {
   }
 };
 
+/**
+ * 处理帮助内容
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._helpProcessContent = async function (ctx) {
   if (ctx.param !== null) {
     await this._helpWithParam(ctx);
@@ -569,6 +669,11 @@ Base.prototype._helpProcessContent = async function (ctx) {
   }
 };
 
+/**
+ * 处理帮助参数：有参数
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._helpWithParam = async function (ctx) {
   if (this.helper) {
     await this._helpUsingHelper(ctx);
@@ -577,6 +682,11 @@ Base.prototype._helpWithParam = async function (ctx) {
   }
 };
 
+/**
+ * 处理帮助参数：无参数
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._helpUsingHelper = async function (ctx) {
   try {
     let hp = this._helpGetHelperValue(ctx.param);
@@ -596,6 +706,12 @@ Base.prototype._helpUsingHelper = async function (ctx) {
   }
 };
 
+/**
+ * 获取帮助属性值
+ * @param {string} param 参数名
+ * @returns {object} 帮助属性值
+ * @private
+ */
 Base.prototype._helpGetHelperValue = function (param) {
   if (!param) {
     return this.helper;
@@ -609,6 +725,12 @@ Base.prototype._helpGetHelperValue = function (param) {
   return this.helper;
 };
 
+/**
+ * 处理帮助数组
+ * @param {object} array 数组对象
+ * @returns {string} 处理后的数组字符串
+ * @private
+ */
 Base.prototype._helpProcessArray = function (array) {
   let result = '';
 
@@ -624,6 +746,12 @@ Base.prototype._helpProcessArray = function (array) {
   return result;
 };
 
+/**
+ * 处理帮助对象
+ * @param {object} obj 对象对象
+ * @returns {string} 处理后的对象字符串
+ * @private
+ */
 Base.prototype._helpProcessObject = function (obj) {
   let result = '';
 
@@ -646,6 +774,11 @@ Base.prototype._helpProcessObject = function (obj) {
   return result;
 };
 
+/**
+ * 处理帮助参数：无参数
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._helpUsingObject = async function (ctx) {
   try {
     if (!ctx.param || typeof ctx.param !== 'string') {
@@ -661,6 +794,12 @@ Base.prototype._helpUsingObject = async function (ctx) {
   }
 };
 
+/**
+ * 导航帮助路径
+ * @param {string} path 路径字符串
+ * @returns {object} 目标对象
+ * @private
+ */
 Base.prototype._helpNavigatePath = function (path) {
   const keys = path.split('.');
   let obj = this;
@@ -684,6 +823,12 @@ Base.prototype._helpNavigatePath = function (path) {
   return obj;
 };
 
+/**
+ * 格式化帮助结果
+ * @param {object} target 目标对象
+ * @returns {string} 格式化后的结果字符串
+ * @private
+ */
 Base.prototype._helpFormatResult = function (target) {
   if (typeof target === 'function') {
     try {
@@ -706,6 +851,11 @@ Base.prototype._helpFormatResult = function (target) {
   }
 };
 
+/**
+ * 处理帮助参数：无参数
+ * @param {object} ctx 上下文对象
+ * @private
+ */
 Base.prototype._helpWithoutParam = async function (ctx) {
   try {
     ctx.result = this._helpProcessObject(this);