@pisell/pisellos 2.3.73 → 2.3.75

package/lib/model/strategy/engine.js

@@ -1,48 +1,52 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/model/strategy/engine.ts
-var engine_exports = {};
-__export(engine_exports, {
-  StrategyEngine: () => StrategyEngine,
-  createStrategyEngine: () => createStrategyEngine,
-  evaluate: () => evaluate
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(engine_exports);
-var import_type = require("./type");
-var StrategyEngine = class {
+exports.StrategyEngine = void 0;
+exports.createStrategyEngine = createStrategyEngine;
+exports.evaluate = evaluate;
+var _type = require("./type");
+/**
+ * 策略模型 - 核心实现
+ *
+ * 完全业务无关的通用策略引擎
+ * 支持条件评估、动作匹配、结果返回
+ */
+
+// ============================================
+// 策略引擎实现
+// ============================================
+
+/**
+ * 策略引擎
+ *
+ * 核心职责：
+ * 1. 递归评估条件组
+ * 2. 收集满足条件的 actionIds
+ * 3. 根据 actionIds 获取 ActionEffect 对象
+ * 4. 按 priority 排序返回
+ */
+class StrategyEngine {
+  options;
+  operatorHandlers;
   constructor(options = {}) {
     this.options = {
       debug: options.debug ?? false,
       enableTrace: options.enableTrace ?? false,
       operatorHandlers: options.operatorHandlers ?? {},
-      errorHandler: options.errorHandler ?? ((error) => console.error(error))
+      errorHandler: options.errorHandler ?? (error => console.error(error))
     };
-    this.operatorHandlers = new Map(
-      Object.entries(this.options.operatorHandlers)
-    );
+
+    // 初始化内置运算符处理器
+    this.operatorHandlers = new Map(Object.entries(this.options.operatorHandlers));
     this.initializeBuiltInOperators();
   }
+
   /**
    * 评估策略
    */
   evaluate(config, context) {
-    var _a, _b;
     const startTime = Date.now();
     const trace = {
       steps: [],
@@ -50,23 +54,23 @@ var StrategyEngine = class {
       errors: []
     };
     try {
+      // 验证配置
       this.validateConfig(config);
       if (this.options.enableTrace) {
         trace.steps.push({
-          step: "validate_config",
-          status: "success",
+          step: 'validate_config',
+          status: 'success',
           duration: Date.now() - startTime
         });
       }
+
+      // 递归评估条件组，收集 actionIds
       const evaluateStart = Date.now();
-      const evaluationResult = this.evaluateConditionGroup(
-        config.conditions,
-        context
-      );
+      const evaluationResult = this.evaluateConditionGroup(config.conditions, context);
       if (this.options.enableTrace) {
         trace.steps.push({
-          step: "evaluate_conditions",
-          status: "success",
+          step: 'evaluate_conditions',
+          status: 'success',
           duration: Date.now() - evaluateStart,
           details: {
             satisfied: evaluationResult.satisfied,
@@ -74,46 +78,51 @@ var StrategyEngine = class {
           }
         });
       }
+
+      // 根据 actionIds 获取 ActionEffect 对象
       const actionStart = Date.now();
-      const matchedActions = this.getActionsByIds(
-        evaluationResult.actionIds,
-        config.actions
-      );
+      const matchedActions = this.getActionsByIds(evaluationResult.actionIds, config.actions);
       if (this.options.enableTrace) {
         trace.steps.push({
-          step: "get_actions",
-          status: "success",
+          step: 'get_actions',
+          status: 'success',
           duration: Date.now() - actionStart,
-          details: { matchedCount: matchedActions.length }
+          details: {
+            matchedCount: matchedActions.length
+          }
         });
       }
+
+      // 按 priority 排序（降序）
       const sortStart = Date.now();
       const sortedActions = this.sortActionsByPriority(matchedActions);
       if (this.options.enableTrace) {
         trace.steps.push({
-          step: "sort_actions",
-          status: "success",
+          step: 'sort_actions',
+          status: 'success',
           duration: Date.now() - sortStart
         });
       }
+
+      // 构建结果 - applicable 基于条件是否满足，而不是 actionIds 数量
       const applicable = evaluationResult.satisfied;
       const result = {
         success: true,
         applicable,
-        code: applicable ? import_type.SUCCESS_CODES.SUCCESS : import_type.NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
-        message: applicable ? "Strategy is applicable" : "Conditions not met",
+        code: applicable ? _type.SUCCESS_CODES.SUCCESS : _type.NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
+        message: applicable ? 'Strategy is applicable' : 'Conditions not met',
         matched: {
           conditions: applicable,
           actionIds: evaluationResult.actionIds,
           details: {},
-          ...applicable ? {} : {
-            failedField: (_a = evaluationResult.failedRules[0]) == null ? void 0 : _a.field,
+          ...(applicable ? {} : {
+            failedField: evaluationResult.failedRules[0]?.field,
             failedRules: evaluationResult.failedRules
-          }
+          })
         },
         matchedActions: sortedActions,
         outputs: {},
-        config
+        config: config
       };
       trace.duration = Date.now() - startTime;
       if (this.options.enableTrace) {
@@ -121,10 +130,10 @@ var StrategyEngine = class {
       }
       return result;
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
       if (this.options.enableTrace) {
-        (_b = trace.errors) == null ? void 0 : _b.push({
-          step: "evaluation",
+        trace.errors?.push({
+          step: 'evaluation',
           error: errorMessage,
           timestamp: Date.now()
         });
@@ -134,7 +143,7 @@ var StrategyEngine = class {
       return {
         success: false,
         applicable: false,
-        code: import_type.ERROR_CODES.EVALUATION_ERROR,
+        code: _type.ERROR_CODES.EVALUATION_ERROR,
         message: errorMessage,
         matched: {
           conditions: false,
@@ -143,11 +152,12 @@ var StrategyEngine = class {
         },
         matchedActions: [],
         outputs: {},
-        trace: this.options.enableTrace ? trace : void 0,
-        config
+        trace: this.options.enableTrace ? trace : undefined,
+        config: config
       };
     }
   }
+
   /**
    * 递归评估条件组
    *
@@ -157,12 +167,16 @@ var StrategyEngine = class {
    */
   evaluateConditionGroup(group, context) {
     const collectedActionIds = [];
-    const { satisfied, failedRules } = this.evaluateGroupLogicDetailed(
-      group,
-      context
-    );
+
+    // 评估当前层的 operator 和 rules（同时收集失败信息）
+    const {
+      satisfied,
+      failedRules
+    } = this.evaluateGroupLogicDetailed(group, context);
     if (satisfied) {
       collectedActionIds.push(...group.actionIds);
+
+      // 递归评估嵌套的 ConditionGroup，收集嵌套层的 actionIds
       for (const rule of group.rules) {
         if (this.isConditionGroup(rule)) {
           const nestedResult = this.evaluateConditionGroup(rule, context);
@@ -176,6 +190,7 @@ var StrategyEngine = class {
       failedRules
     };
   }
+
   /**
    * 评估条件组的逻辑运算（带失败规则收集）
    *
@@ -185,46 +200,72 @@ var StrategyEngine = class {
    * - `not`：被取反规则实际通过时，记录该规则
    */
   evaluateGroupLogicDetailed(group, context) {
-    const { operator, rules } = group;
+    const {
+      operator,
+      rules
+    } = group;
     switch (operator) {
-      case "and": {
-        for (const rule of rules) {
-          const ruleResult = this.evaluateRuleDetailed(rule, context);
-          if (!ruleResult.satisfied) {
+      case 'and':
+        {
+          for (const rule of rules) {
+            const ruleResult = this.evaluateRuleDetailed(rule, context);
+            if (!ruleResult.satisfied) {
+              return {
+                satisfied: false,
+                failedRules: ruleResult.failedRules
+              };
+            }
+          }
+          return {
+            satisfied: true,
+            failedRules: []
+          };
+        }
+      case 'or':
+        {
+          const aggregated = [];
+          for (const rule of rules) {
+            const ruleResult = this.evaluateRuleDetailed(rule, context);
+            if (ruleResult.satisfied) {
+              return {
+                satisfied: true,
+                failedRules: []
+              };
+            }
+            aggregated.push(...ruleResult.failedRules);
+          }
+          return {
+            satisfied: false,
+            failedRules: aggregated
+          };
+        }
+      case 'not':
+        {
+          if (rules.length === 0) {
             return {
               satisfied: false,
-              failedRules: ruleResult.failedRules
+              failedRules: []
             };
           }
-        }
-        return { satisfied: true, failedRules: [] };
-      }
-      case "or": {
-        const aggregated = [];
-        for (const rule of rules) {
-          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          const ruleResult = this.evaluateRuleDetailed(rules[0], context);
           if (ruleResult.satisfied) {
-            return { satisfied: true, failedRules: [] };
+            // 被取反规则实际通过，导致 not 失败
+            const failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
+            return {
+              satisfied: false,
+              failedRules: failed
+            };
           }
-          aggregated.push(...ruleResult.failedRules);
-        }
-        return { satisfied: false, failedRules: aggregated };
-      }
-      case "not": {
-        if (rules.length === 0) {
-          return { satisfied: false, failedRules: [] };
+          return {
+            satisfied: true,
+            failedRules: []
+          };
         }
-        const ruleResult = this.evaluateRuleDetailed(rules[0], context);
-        if (ruleResult.satisfied) {
-          const failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
-          return { satisfied: false, failedRules: failed };
-        }
-        return { satisfied: true, failedRules: [] };
-      }
       default:
         throw new Error(`Unknown operator: ${operator}`);
     }
   }
+
   /**
    * 评估单个规则（带失败规则收集）
    */
@@ -235,27 +276,35 @@ var StrategyEngine = class {
     const conditionRule = rule;
     const satisfied = this.evaluateAtomicRule(conditionRule, context);
     if (satisfied) {
-      return { satisfied: true, failedRules: [] };
+      return {
+        satisfied: true,
+        failedRules: []
+      };
     }
     return {
       satisfied: false,
       failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
     };
   }
+
   /**
    * 评估原子规则（不收集失败信息，仅返回布尔结果）
    */
   evaluateAtomicRule(conditionRule, context) {
-    if (conditionRule.type === "code" && conditionRule.code) {
+    // Code 模式：使用 eval 执行
+    if (conditionRule.type === 'code' && conditionRule.code) {
       return this.evaluateCodeCondition(conditionRule.code, context);
     }
+
+    // Operator 模式：标准运算符判断
     return this.evaluateOperatorCondition(conditionRule, context);
   }
+
   /**
    * 构建失败规则信息
    */
   buildFailedRuleInfo(conditionRule, context) {
-    const actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : void 0;
+    const actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : undefined;
     return {
       field: conditionRule.field,
       operator: conditionRule.operator,
@@ -263,144 +312,169 @@ var StrategyEngine = class {
       actualValue
     };
   }
+
   /**
    * 评估代码模式条件
    */
   evaluateCodeCondition(code, context) {
     try {
-      const { entities, attributes, metadata } = context;
-      const evalFunc = new Function(
-        "entities",
-        "attributes",
-        "metadata",
-        `return (${code})`
-      );
+      // 将 context 解构到作用域中，方便代码直接使用
+      const {
+        entities,
+        attributes,
+        metadata
+      } = context;
+
+      // 使用 Function 构造器代替 eval，更安全
+      const evalFunc = new Function('entities', 'attributes', 'metadata', `return (${code})`);
       const result = evalFunc(entities, attributes, metadata);
       return Boolean(result);
     } catch (error) {
       if (this.options.debug) {
-        console.error("Code evaluation error:", error);
+        console.error('Code evaluation error:', error);
       }
       return false;
     }
   }
+
   /**
    * 评估运算符模式条件
    */
   evaluateOperatorCondition(rule, context) {
-    const { field, operator, value } = rule;
+    const {
+      field,
+      operator,
+      value
+    } = rule;
     if (!field || !operator) {
       return false;
     }
+
+    // 从 context.attributes 中获取字段值
     const fieldValue = this.getFieldValue(field, context);
+
+    // 使用运算符处理器
     const handler = this.operatorHandlers.get(operator);
     if (handler) {
       return handler(fieldValue, value, rule);
     }
+
+    // 回退到内置运算符
     return this.evaluateBuiltInOperator(fieldValue, operator, value);
   }
+
   /**
    * 获取字段值
    */
   getFieldValue(field, context) {
-    const path = field.split(".");
+    // 支持点号路径，如 "order.total"
+    const path = field.split('.');
     let value = context.attributes;
     for (const key of path) {
-      if (value && typeof value === "object" && key in value) {
+      if (value && typeof value === 'object' && key in value) {
         value = value[key];
       } else {
-        return void 0;
+        return undefined;
       }
     }
     return value;
   }
+
   /**
    * 评估内置运算符
    */
   evaluateBuiltInOperator(fieldValue, operator, compareValue) {
     switch (operator) {
-      case "=":
-      case "==":
+      // 比较运算符
+      case '=':
+      case '==':
         return fieldValue == compareValue;
-      case "!=":
+      case '!=':
         return fieldValue != compareValue;
-      case ">":
+      case '>':
         return fieldValue > compareValue;
-      case ">=":
+      case '>=':
         return fieldValue >= compareValue;
-      case "<":
+      case '<':
         return fieldValue < compareValue;
-      case "<=":
+      case '<=':
         return fieldValue <= compareValue;
-      case "in":
+
+      // 集合运算符
+      case 'in':
         return Array.isArray(compareValue) && compareValue.includes(fieldValue);
-      case "not_in":
+      case 'not_in':
         return Array.isArray(compareValue) && !compareValue.includes(fieldValue);
-      case "contains":
+      case 'contains':
         if (Array.isArray(fieldValue)) {
           return fieldValue.includes(compareValue);
         }
-        if (typeof fieldValue === "string") {
+        if (typeof fieldValue === 'string') {
           return fieldValue.includes(compareValue);
         }
         return false;
-      case "not_contains":
+      case 'not_contains':
         if (Array.isArray(fieldValue)) {
           return !fieldValue.includes(compareValue);
         }
-        if (typeof fieldValue === "string") {
+        if (typeof fieldValue === 'string') {
           return !fieldValue.includes(compareValue);
         }
         return true;
-      case "starts_with":
-        return typeof fieldValue === "string" && fieldValue.startsWith(compareValue);
-      case "ends_with":
-        return typeof fieldValue === "string" && fieldValue.endsWith(compareValue);
-      case "regex":
-        return typeof fieldValue === "string" && new RegExp(compareValue).test(fieldValue);
-      case "between":
-        if (!Array.isArray(compareValue) || compareValue.length !== 2)
-          return false;
+
+      // 字符串运算符
+      case 'starts_with':
+        return typeof fieldValue === 'string' && fieldValue.startsWith(compareValue);
+      case 'ends_with':
+        return typeof fieldValue === 'string' && fieldValue.endsWith(compareValue);
+      case 'regex':
+        return typeof fieldValue === 'string' && new RegExp(compareValue).test(fieldValue);
+
+      // 范围运算符
+      case 'between':
+        if (!Array.isArray(compareValue) || compareValue.length !== 2) return false;
         return fieldValue >= compareValue[0] && fieldValue <= compareValue[1];
-      case "is_null":
-        return fieldValue === null || fieldValue === void 0;
-      case "is_not_null":
-        return fieldValue !== null && fieldValue !== void 0;
-      case "is_empty":
-        if (Array.isArray(fieldValue))
-          return fieldValue.length === 0;
-        if (typeof fieldValue === "string")
-          return fieldValue.length === 0;
-        if (typeof fieldValue === "object")
-          return Object.keys(fieldValue).length === 0;
+
+      // 逻辑运算符
+      case 'is_null':
+        return fieldValue === null || fieldValue === undefined;
+      case 'is_not_null':
+        return fieldValue !== null && fieldValue !== undefined;
+      case 'is_empty':
+        if (Array.isArray(fieldValue)) return fieldValue.length === 0;
+        if (typeof fieldValue === 'string') return fieldValue.length === 0;
+        if (typeof fieldValue === 'object') return Object.keys(fieldValue).length === 0;
         return !fieldValue;
-      case "is_not_empty":
-        if (Array.isArray(fieldValue))
-          return fieldValue.length > 0;
-        if (typeof fieldValue === "string")
-          return fieldValue.length > 0;
-        if (typeof fieldValue === "object")
-          return Object.keys(fieldValue).length > 0;
+      case 'is_not_empty':
+        if (Array.isArray(fieldValue)) return fieldValue.length > 0;
+        if (typeof fieldValue === 'string') return fieldValue.length > 0;
+        if (typeof fieldValue === 'object') return Object.keys(fieldValue).length > 0;
         return Boolean(fieldValue);
-      case "product_match":
+
+      // 商品匹配运算符
+      case 'product_match':
         return this.evaluateProductMatch(fieldValue, compareValue);
-      case "object_in":
+
+      // 对象包含运算符（兼容旧配置）
+      case 'object_in':
         return this.evaluateProductMatch(fieldValue, compareValue);
       default:
         throw new Error(`Unsupported operator: ${operator}`);
     }
   }
+
   /**
    * 根据 actionIds 获取 ActionEffect 对象
    */
   getActionsByIds(actionIds, actions) {
     const matchedActions = [];
-    const actionMap = new Map(actions.map((action) => [action.id, action]));
+    const actionMap = new Map(actions.map(action => [action.id, action]));
     for (const id of actionIds) {
       const action = actionMap.get(id);
       if (action) {
         matchedActions.push(action);
       } else {
+        // 找不到的 ID 记录警告
         if (this.options.debug) {
           console.warn(`Action with id "${id}" not found in actions array`);
         }
@@ -408,6 +482,7 @@ var StrategyEngine = class {
     }
     return matchedActions;
   }
+
   /**
    * 按 priority 排序（降序）
    */
@@ -415,37 +490,43 @@ var StrategyEngine = class {
     return [...actions].sort((a, b) => {
       const priorityA = a.priority ?? 0;
       const priorityB = b.priority ?? 0;
-      return priorityB - priorityA;
+      return priorityB - priorityA; // 降序
     });
   }
+
   /**
    * 判断是否为条件组
    */
   isConditionGroup(rule) {
-    return "operator" in rule && "rules" in rule && Array.isArray(rule.rules);
+    return 'operator' in rule && 'rules' in rule && Array.isArray(rule.rules);
   }
+
   /**
    * 验证配置
    */
   validateConfig(config) {
     if (!config) {
-      throw new Error("Strategy config is required");
+      throw new Error('Strategy config is required');
     }
     if (!config.metadata || !config.metadata.id) {
-      throw new Error("Strategy metadata.id is required");
+      throw new Error('Strategy metadata.id is required');
     }
     if (!config.conditions) {
-      throw new Error("Strategy conditions is required");
+      throw new Error('Strategy conditions is required');
     }
     if (!Array.isArray(config.actions)) {
-      throw new Error("Strategy actions must be an array");
+      throw new Error('Strategy actions must be an array');
     }
   }
+
   /**
    * 初始化内置运算符处理器
    */
   initializeBuiltInOperators() {
+    // 内置运算符已经在 evaluateBuiltInOperator 中实现
+    // 这里可以添加自定义的运算符处理器
   }
+
   /**
    * 评估商品匹配运算符
    *
@@ -459,35 +540,49 @@ var StrategyEngine = class {
    * @returns 是否匹配
    */
   evaluateProductMatch(fieldValue, configValue) {
+    // 确保 configValue 是数组
     if (!Array.isArray(configValue)) {
       return false;
     }
-    if (!fieldValue || typeof fieldValue !== "object" || typeof fieldValue.product_id !== "number") {
+
+    // 确保 fieldValue 是有效的商品对象
+    if (!fieldValue || typeof fieldValue !== 'object' || typeof fieldValue.product_id !== 'number') {
       return false;
     }
     const actualProductId = fieldValue.product_id;
     const actualVariantId = fieldValue.product_variant_id ?? 0;
-    return configValue.some((item) => {
-      if (!item || typeof item.product_id !== "number") {
+
+    // 遍历配置的商品列表，检查是否有匹配
+    return configValue.some(item => {
+      // 验证配置项格式
+      if (!item || typeof item.product_id !== 'number') {
         return false;
       }
       const configProductId = item.product_id;
       const configVariantId = item.product_variant_id ?? 0;
+
+      // 首先检查 product_id 是否匹配
       if (configProductId !== actualProductId) {
         return false;
       }
+
+      // 如果配置的 product_variant_id = 0，只需要 product_id 匹配
       if (configVariantId === 0) {
         return true;
       }
+
+      // 否则需要 product_variant_id 精确匹配
       return configVariantId === actualVariantId;
     });
   }
+
   /**
    * 注册自定义运算符
    */
   registerOperator(operator, handler) {
     this.operatorHandlers.set(operator, handler);
   }
+
   /**
    * 获取调试信息
    */
@@ -498,17 +593,24 @@ var StrategyEngine = class {
       registeredOperators: Array.from(this.operatorHandlers.keys())
     };
   }
-};
+}
+
+// ============================================
+// 导出工具函数
+// ============================================
+
+/**
+ * 创建策略引擎实例
+ */
+exports.StrategyEngine = StrategyEngine;
 function createStrategyEngine(options) {
   return new StrategyEngine(options);
 }
+
+/**
+ * 快速评估（使用默认引擎配置）
+ */
 function evaluate(config, context) {
   const engine = new StrategyEngine();
   return engine.evaluate(config, context);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  StrategyEngine,
-  createStrategyEngine,
-  evaluate
-});
+}