@pisell/pisellos 0.0.569 → 0.10.2

package/lib/model/strategy/engine.js

@@ -1,52 +1,48 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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
 });
-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;
+module.exports = __toCommonJS(engine_exports);
+var import_type = require("./type");
+var StrategyEngine = class {
   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: [],
@@ -54,23 +50,23 @@ class StrategyEngine {
       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,
@@ -78,51 +74,46 @@ class StrategyEngine {
           }
         });
       }
-
-      // 根据 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 ? _type.SUCCESS_CODES.SUCCESS : _type.NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
-        message: applicable ? 'Strategy is applicable' : 'Conditions not met',
+        code: applicable ? import_type.SUCCESS_CODES.SUCCESS : import_type.NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
+        message: applicable ? "Strategy is applicable" : "Conditions not met",
         matched: {
           conditions: applicable,
           actionIds: evaluationResult.actionIds,
           details: {},
-          ...(applicable ? {} : {
-            failedField: evaluationResult.failedRules[0]?.field,
+          ...applicable ? {} : {
+            failedField: (_a = evaluationResult.failedRules[0]) == null ? void 0 : _a.field,
             failedRules: evaluationResult.failedRules
-          })
+          }
         },
         matchedActions: sortedActions,
         outputs: {},
-        config: config
+        config
       };
       trace.duration = Date.now() - startTime;
       if (this.options.enableTrace) {
@@ -130,10 +121,10 @@ class StrategyEngine {
       }
       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) {
-        trace.errors?.push({
-          step: 'evaluation',
+        (_b = trace.errors) == null ? void 0 : _b.push({
+          step: "evaluation",
           error: errorMessage,
           timestamp: Date.now()
         });
@@ -143,7 +134,7 @@ class StrategyEngine {
       return {
         success: false,
         applicable: false,
-        code: _type.ERROR_CODES.EVALUATION_ERROR,
+        code: import_type.ERROR_CODES.EVALUATION_ERROR,
         message: errorMessage,
         matched: {
           conditions: false,
@@ -152,12 +143,11 @@ class StrategyEngine {
         },
         matchedActions: [],
         outputs: {},
-        trace: this.options.enableTrace ? trace : undefined,
-        config: config
+        trace: this.options.enableTrace ? trace : void 0,
+        config
       };
     }
   }
-
   /**
    * 递归评估条件组
    *
@@ -167,16 +157,12 @@ class StrategyEngine {
    */
   evaluateConditionGroup(group, context) {
     const collectedActionIds = [];
-
-    // 评估当前层的 operator 和 rules（同时收集失败信息）
-    const {
-      satisfied,
-      failedRules
-    } = this.evaluateGroupLogicDetailed(group, context);
+    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);
@@ -190,7 +176,6 @@ class StrategyEngine {
       failedRules
     };
   }
-
   /**
    * 评估条件组的逻辑运算（带失败规则收集）
    *
@@ -200,72 +185,46 @@ class StrategyEngine {
    * - `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) {
-              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) {
+      case "and": {
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (!ruleResult.satisfied) {
             return {
               satisfied: false,
-              failedRules: []
+              failedRules: ruleResult.failedRules
             };
           }
-          const ruleResult = this.evaluateRuleDetailed(rules[0], context);
+        }
+        return { satisfied: true, failedRules: [] };
+      }
+      case "or": {
+        const aggregated = [];
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
           if (ruleResult.satisfied) {
-            // 被取反规则实际通过，导致 not 失败
-            const failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
-            return {
-              satisfied: false,
-              failedRules: failed
-            };
+            return { satisfied: true, failedRules: [] };
           }
-          return {
-            satisfied: true,
-            failedRules: []
-          };
+          aggregated.push(...ruleResult.failedRules);
+        }
+        return { satisfied: false, failedRules: aggregated };
+      }
+      case "not": {
+        if (rules.length === 0) {
+          return { satisfied: false, 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}`);
     }
   }
-
   /**
    * 评估单个规则（带失败规则收集）
    */
@@ -276,35 +235,27 @@ class StrategyEngine {
     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) {
-    // Code 模式：使用 eval 执行
-    if (conditionRule.type === 'code' && conditionRule.code) {
+    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) : undefined;
+    const actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : void 0;
     return {
       field: conditionRule.field,
       operator: conditionRule.operator,
@@ -312,169 +263,144 @@ class StrategyEngine {
       actualValue
     };
   }
-
   /**
    * 评估代码模式条件
    */
   evaluateCodeCondition(code, context) {
     try {
-      // 将 context 解构到作用域中，方便代码直接使用
-      const {
-        entities,
-        attributes,
-        metadata
-      } = context;
-
-      // 使用 Function 构造器代替 eval，更安全
-      const evalFunc = new Function('entities', 'attributes', 'metadata', `return (${code})`);
+      const { entities, attributes, metadata } = context;
+      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) {
-    // 支持点号路径，如 "order.total"
-    const path = field.split('.');
+    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 undefined;
+        return void 0;
       }
     }
     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 === 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;
+      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;
         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`);
         }
@@ -482,7 +408,6 @@ class StrategyEngine {
     }
     return matchedActions;
   }
-
   /**
    * 按 priority 排序（降序）
    */
@@ -490,43 +415,37 @@ class StrategyEngine {
     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 中实现
-    // 这里可以添加自定义的运算符处理器
   }
-
   /**
    * 评估商品匹配运算符
    *
@@ -540,49 +459,35 @@ class StrategyEngine {
    * @returns 是否匹配
    */
   evaluateProductMatch(fieldValue, configValue) {
-    // 确保 configValue 是数组
     if (!Array.isArray(configValue)) {
       return false;
     }
-
-    // 确保 fieldValue 是有效的商品对象
-    if (!fieldValue || typeof fieldValue !== 'object' || typeof fieldValue.product_id !== 'number') {
+    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);
   }
-
   /**
    * 获取调试信息
    */
@@ -593,24 +498,17 @@ class StrategyEngine {
       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
+});