softseti-sale-calculator-library 3.7.5 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "softseti-sale-calculator-library",
-  "version": "3.7.5",
+  "version": "4.0.0",
   "description": "Sales calculation engine by Softseti",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -28,5 +28,8 @@
     "jest-environment-jsdom": "^29.7.0",
     "jest-localstorage-mock": "^2.4.26",
     "ts-jest": "^29.4.0"
+  },
+  "dependencies": {
+    "@gorules/zen-engine": "^0.51.5"
   }
 }

package/src/{refund-calculator.js → core/refund-calculator.js}

@@ -4,7 +4,7 @@ const {
   calculatePreviousRefundsTotal,
   calculateMaxRefundableAmount,
   findProductInSale
-} = require('./helpers');
+} = require('../utils/helpers');
 
 class RefundCalculator {
   static calculateRefund(sale, returnItems, options, currentMemoId) {

package/src/core/rule-engine.js

@@ -0,0 +1,73 @@
+// src/rules/RuleEngine.js
+const { ZenEngine } = require('@gorules/zen-engine');
+
+class RuleEngine {
+  constructor() {
+    this.engine = new ZenEngine();
+    this.ruleCache = new Map();
+  }
+
+  /**
+   * Evaluates a business rule with given context
+   * @param {Object} ruleContent - GoRules JSON rule content
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Rule evaluation result
+   */
+  async evaluateRule(ruleContent, context) {
+    try {
+
+      const decision = this.engine.createDecision(ruleContent);
+      const result = await decision.safeEvaluate(context);
+
+      return result;
+
+    } catch (error) {
+      console.error('Rule evaluation error:', error);
+      throw new Error(`Rule evaluation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Executes multiple rules for a trigger event
+   * @param {Array} rules - Business rules to execute
+   * @param {Object} context - Execution context
+   * @returns {Promise<Array>} Array of rule execution results
+   */
+  async executeRules(rules, context) {
+    const results = [];
+
+    for (const rule of rules) {
+      try {
+        const result = await this.evaluateRule(rule.rule_content, context);
+        results.push(
+          result
+        );
+      } catch (error) {
+
+        results.push({
+          ruleId: rule.id,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validates rule structure
+   * @param {Object} ruleContent - Rule content to validate
+   * @returns {boolean} True if rule is valid
+   */
+  validateRule(ruleContent) {
+    if (!ruleContent || typeof ruleContent !== 'object') {
+      return false;
+    }
+
+    const requiredProperties = ['nodes', 'edges', 'contentType'];
+    return requiredProperties.every(prop => ruleContent.hasOwnProperty(prop));
+  }
+}
+
+module.exports = RuleEngine;

package/src/{SaleCalculator.js → core/sale-calculator.js}

@@ -1,3 +1,9 @@
+const RuleEngine = require('./rule-engine');
+const RuleManager = require('../rules/RuleManager');
+
+let ruleEngine = null;
+let ruleManager = null;
+
 let products = {};
 let productTaxes = {};
 let taxes = {};
@@ -6,10 +12,13 @@ let settings = {};
 let exchangeRates = {};
 let currencyConverterRates = {};
 let currencies = {};
+let businessRules = {};
 let decimalPlaces = 2;
 let roundingFactor = 100;
 let useRounding = false;
 
+let preprocessedSale = {};
+
 /**
  * Sales Calculation Engine (V1)
  * @author softseti
@@ -20,10 +29,6 @@ let useRounding = false;
  * - Deal/discount allocations
  */
 
-// ==============================================
-// INITIALIZATION
-// ==============================================
-
 /**
  * Initializes the calculator with indexed data
  * @param {Object} params - Data collections:
@@ -44,11 +49,41 @@ function init(params) {
   exchangeRates = params.exchange_rates || {};
   currencyConverterRates = params.currency_converter_rates || {};
   currencies = params.currencies || {};
+  businessRules = params.businessRules || {};
 
   decimalPlaces = params.decimal_places !== undefined ? params.decimal_places : 2;
   roundingFactor = Math.pow(10, decimalPlaces);
 
   useRounding = params.use_rounding !== undefined ? params.use_rounding : false;
+
+  // Start engine
+  initializeRuleSystem(businessRules);
+
+}
+
+// ==============================================
+// Rule engine
+// ==============================================
+
+function initializeRuleSystem(businessRules) {
+  try {
+    ruleEngine = new RuleEngine();
+    ruleManager = new RuleManager();
+
+    if (businessRules && Object.keys(businessRules).length > 0) {
+
+      ruleManager.loadRules(businessRules);
+      console.log('Sistema de reglas inicializado correctamente');
+
+    } else {
+      console.warn('No se encontraron reglas de negocio para cargar');
+    }
+  } catch (error) {
+    console.error('Error al inicializar el sistema de reglas:', error);
+    // Fallback: continuar sin reglas
+    ruleEngine = null;
+    ruleManager = null;
+  }
 }
 
 // ==============================================
@@ -71,18 +106,20 @@ function validateSaleStructure(sale) {
 // CORE CALCULATION ENGINE (V2.1 SCOPE)
 // ==============================================
 
-function calcTotal(sale) {
+async function calcTotal(sale) {
   validateSaleStructure(sale);
 
-  return roundCurrency(
-    sale.dwSaleProducts.reduce((total, product) => {
-      const productSum = calcDwSaleProductSum(product, sale);
-      const discount = calcDwSaleProductDiscount(product, sale);
-      const netAmount = roundCurrency(productSum - discount);
-      const taxes = getApplicableProductTaxes(product, netAmount, sale);
-      return total + netAmount + taxes;
-    }, 0)
-  );
+  let total = 0;
+
+  for (const product of sale.dwSaleProducts) {
+    const productSum = calcDwSaleProductSum(product, sale);
+    const discount = calcDwSaleProductDiscount(product, sale);
+    const netAmount = roundCurrency(productSum - discount);
+    const taxes = await getApplicableProductTaxes(product, netAmount, sale);
+    total += netAmount + taxes;
+  }
+
+  return roundCurrency(total);
 }
 
 function calcSubtotal(sale) {
@@ -102,7 +139,7 @@ function calcSubtotal(sale) {
  * @param {Object} params
  *   - sale:
  */
-function preprocessSale(sale) {
+async function preprocessSale(sale) {
 
   const saleCurrency = currencies[sale.currency_id];
 
@@ -125,36 +162,40 @@ function preprocessSale(sale) {
   }
 
   if (sale.payments) {
-    sale.payments = sale.payments.map(payment => {
+    const processedPayments = [];
+    for (const payment of sale.payments) {
       const originalCurrency = currencies[payment.currency_id];
 
       // If payment already has calculated fields, use them
       if (payment.amount && payment.original_amount) {
-        return {
+        processedPayments.push({
           ...payment,
           original_currency_id: payment.currency_id,
           original_currency_iso: originalCurrency?.iso,
           currency_id: sale.currency_id,
           currency_iso: sale.currency_iso,
-          change_amount: Math.max(0, payment.gived_amount - payment.amount)
-        };
-      }
-
-      // Otherwise calculate from basic payment data
-      return {
-        ...payment,
-        original_currency_id: payment.currency_id,
-        original_currency_iso: originalCurrency?.iso,
-        currency_id: sale.currency_id,
-        currency_iso: sale.currency_iso,
-        original_gived_amount: payment.gived_amount || payment.amount,
-        ...calculatePaymentDetails({
+          change_amount: 0
+        });
+      } else {
+        // Otherwise calculate from basic payment data
+        const details = await calculatePaymentDetails({
           ...payment,
           original_gived_amount: payment.gived_amount || payment.amount,
           original_currency_iso: originalCurrency?.iso
-        }, sale)
-      };
-    });
+        }, sale);
+        
+        processedPayments.push({
+          ...payment,
+          original_currency_id: payment.currency_id,
+          original_currency_iso: originalCurrency?.iso,
+          currency_id: sale.currency_id,
+          currency_iso: sale.currency_iso,
+          original_gived_amount: payment.gived_amount || payment.amount,
+          ...details
+        });
+      }
+    }
+    sale.payments = processedPayments;
   }
 
   if (sale.dwSaleProducts) {
@@ -183,6 +224,8 @@ function preprocessSale(sale) {
       }));
     });
   }
+  // Set data for preprocessedSale
+  preprocessedSale = sale;
 
   return sale;
 }
@@ -270,18 +313,93 @@ function sumProductQuantity(products, productId) {
     .reduce((sum, p) => sum + p.quantity, 0);
 }
 
-function getApplicableProductTaxes(saleProduct, productSum, sale) {
+async function getApplicableProductTaxes(saleProduct, productSum, sale) {
   // GET Taxes for specific products
   const specificTaxes = getProductSpecificTaxes(saleProduct, sale);
   // GET General Taxes
   const generalTaxes = getGeneralTaxes(sale);
 
-  const totalTax = [...specificTaxes, ...generalTaxes].reduce(
-    (total, tax) => {
-      const taxAmount = productSum * (tax.rate / 100);
-      return total + roundCurrency(taxAmount);
-    }, 0
-  );
+  // Combination for taxes
+  const taxes = [...specificTaxes, ...generalTaxes];
+
+  // Get rules for taxes
+  const convertedRuleTaxes = ruleManager.getRulesForTrigger('calculate_taxes') || [];
+
+  // If no rules or engine, calculate normally
+  if (convertedRuleTaxes.length === 0 || !ruleEngine) {
+    const totalTax = taxes.reduce(
+      (total, tax) => {
+        const taxAmount = productSum * (tax.rate / 100);
+        return total + roundCurrency(taxAmount);
+      }, 0
+    );
+    return roundCurrency(totalTax);
+  }
+
+  // Process each tax with rules
+  let totalTax = 0;
+
+  for (const tax of taxes) {
+    let adjustedRate = tax.rate;
+    let taxAmount = 0;
+
+    // Create context for each individual tax
+    const context = {
+      sale: {
+        ...preprocessedSale,
+        subtotal: preprocessedSale.subtotal || calcSubtotal(sale), 
+        customers: preprocessedSale.customers || sale.customers || []
+      },
+      tax: {
+        ...tax,
+        tax_id: tax.id,
+        dw_product_id: tax.product_id || null,
+        sale_id: null,
+        amount: 0,
+        branch_id: sale.branch_id,
+        company_id: sale.company_id
+      }
+    };
+
+    try {
+      // Execute rules for this specific tax
+      const ruleResults = await ruleEngine.executeRules(convertedRuleTaxes, context);
+
+      // Find successful rule result
+      const appliedRule = ruleResults.find(result => result.success && result.data);
+
+      if (appliedRule && appliedRule.data) {
+        const resultData = appliedRule.data;
+        
+        if (resultData.result && resultData.result.tax) {
+          const taxResult = resultData.result.tax;
+          
+          if (taxResult.rate !== undefined) {
+            adjustedRate = parseFloat(taxResult.rate);
+          }
+          
+          if (taxResult.amount !== undefined) {
+            taxAmount = parseFloat(taxResult.amount);
+          }
+        }
+        else if (resultData['tax.rate'] !== undefined) {
+          adjustedRate = parseFloat(resultData['tax.rate']);
+        } else if (resultData.rate !== undefined) {
+          adjustedRate = parseFloat(resultData.rate);
+        }
+      }
+    } catch (error) {
+      console.error(`Error applying rules for tax ${tax.abbreviation}:`, error);
+    }
+
+    // Calculate tax amount
+    if (taxAmount > 0) {
+      totalTax += roundCurrency(taxAmount);
+    } else {
+      taxAmount = productSum * (adjustedRate / 100);
+      totalTax += roundCurrency(taxAmount);
+    }
+  }
 
   return roundCurrency(totalTax);
 }
@@ -402,8 +520,8 @@ function applyExchangeStrategy(amount, exchangeRate) {
  * @param {Object} sale - Sale object containing payments and calculation context
  * @returns {number} Positive change amount if overpaid, otherwise 0
  */
-function calcChange(sale) {
-  const total = calcTotal(sale);
+async function calcChange(sale) {
+  const total = await calcTotal(sale);
   const paymentSum = sumGivedAmountPayments(sale);
   const change = paymentSum - total;
   return roundCurrency(change > 0 ? change : 0);
@@ -414,9 +532,9 @@ function calcChange(sale) {
  * @param {Object} sale - Sale object containing payments and calculation context
  * @returns {number} Remaining debt amount (0 if fully paid)
  */
-function calcDebt(sale) {
-  const total = calcTotal(sale);
-  const paymentSum = sumAmountPayments(sale);
+async function calcDebt(sale) {
+  const total = await calcTotal(sale);
+  const paymentSum = await sumAmountPayments(sale);
   const debt = total - paymentSum;
   return roundCurrency(debt > 0 ? debt : 0);
 }
@@ -426,10 +544,15 @@ function calcDebt(sale) {
  * @param {Object} sale - Sale object containing payments array
  * @returns {number} Total effective payment amount in sale currency
  */
-function sumAmountPayments(sale) {
-  return (sale.payments || []).reduce((sum, payment) => {
-    return sum + calcPaymentAmount(payment, sale);
-  }, 0);
+async function sumAmountPayments(sale) {
+  const payments = sale.payments || [];
+  let sum = 0;
+  
+  for (const payment of payments) {
+    sum += await calcPaymentAmount(payment, sale);
+  }
+  
+  return sum;
 }
 
 /**
@@ -449,8 +572,8 @@ function sumGivedAmountPayments(sale) {
  * @param {Object} sale - Parent sale object for context
  * @returns {number} Effective amount applied to sale total in sale currency
  */
-function calcPaymentAmount(payment, sale) {
-  const total = calcTotal(sale);
+async function calcPaymentAmount(payment, sale) {
+  const total = await calcTotal(sale);
   const payments = sale.payments || [];
 
   // Find current payment index
@@ -495,8 +618,8 @@ function calcPaymentAmount(payment, sale) {
  * @param {Object} sale
  * @returns {number} Amount in payment's original currency
  */
-function calcOriginalPaymentAmount(payment, sale) {
-  const effectiveAmount = calcPaymentAmount(payment, sale);
+async function calcOriginalPaymentAmount(payment, sale) {
+  const effectiveAmount = await calcPaymentAmount(payment, sale);
 
   // Convert FROM sale currency TO payment's original currency
   return exchange(
@@ -540,9 +663,9 @@ function calcGivedPaymentAmount(payment, sale) {
  *   - original_currency_iso: Payment currency ISO code
  *   - exchange_rate: Calculated exchange rate between currencies
  */
-function calculatePaymentDetails(payment, sale) {
+async function calculatePaymentDetails(payment, sale) {
   // Calculate the actual amount that can be applied to the sale (in sale currency)
-  const amount = calcPaymentAmount(payment, sale);
+  const amount = await calcPaymentAmount(payment, sale);
 
   // Calculate the given amount in sale currency (full conversion without debt cap)
   const gived_amount = exchange(
@@ -568,7 +691,7 @@ function calculatePaymentDetails(payment, sale) {
     original_amount,           // Applied amount in payment's original currency
     original_gived_amount: payment.original_gived_amount, // Original given amount unchanged
     exchange_rate,
-    change_amount: roundCurrency(payment.gived_amount - payment.amount) // Change in sale currency
+    change_amount: roundCurrency(gived_amount - amount) // Change in sale currency
   };
 }
 
@@ -620,40 +743,21 @@ function appliedWholesaleLevels(sale) {
   return result;
 }
 
-function getSeparatedTaxes(sale) {
-  const result = getApplicableDwTaxes(sale);
-
-  return {
-    sale_taxes: result.taxes.map(tax => ({
-      tax_id: tax.id,
-      abbreviation: tax.abbreviation,
-      rate: tax.rate,
-      amount: tax.amount,
-      product_id: tax.product_id // null for general taxes
-    })),
-    tax_calculation_batches: result.tax_batches.map(batch => ({
-      product_id: batch.product_id,
-      product_index: batch.product_index,
-      sum: batch.sum,
-      amount: batch.amount,
-      rate: batch.rate,
-      tax_type: batch.tax_type
-    }))
-  };
-}
-
 /**
  * Calculates all applicable taxes for the sale and returns them in API format
  * @param {Object} sale - Sale data object
  * @returns {Array} Array of tax objects with id, abbreviation, and amount
  */
-function getApplicableDwTaxes(sale) {
+async function getApplicableDwTaxes(sale) {
   validateSaleStructure(sale);
 
   const taxMap = {};
   const taxBatches = [];
 
-  sale.dwSaleProducts.forEach((product, productIndex) => {
+  // Get rules for taxes
+  const convertedRuleTaxes = ruleManager.getRulesForTrigger('calculate_taxes') || [];
+
+  for (const [productIndex, product] of sale.dwSaleProducts.entries()) {
     const productSum = calcDwSaleProductSum(product, sale);
     const discount = calcDwSaleProductDiscount(product, sale);
     const netAmount = roundCurrency(productSum - discount);
@@ -661,10 +765,69 @@ function getApplicableDwTaxes(sale) {
     // Get applicable taxes for this product
     const specificTaxes = getProductSpecificTaxes(product, sale);
     const generalTaxes = getGeneralTaxes(sale);
-    const allTaxes = [...specificTaxes, ...generalTaxes];
+    let allTaxes = [...specificTaxes, ...generalTaxes];
+
+    // Process each tax with rules
+    for (const tax of allTaxes) {
+      let adjustedRate = tax.rate;
+      let taxAmount = 0;
+
+      if (convertedRuleTaxes.length > 0 && ruleEngine) {
+        try {
+          // Context
+          const context = {
+            sale: {
+              ...preprocessedSale,
+              subtotal: preprocessedSale.subtotal || calcSubtotal(sale),
+              customers: preprocessedSale.customers || sale.customers || []
+            },
+            tax: {
+              ...tax,
+              tax_id: tax.id,
+              dw_product_id: tax.product_id || null,
+              sale_id: null,
+              amount: 0,
+              branch_id: sale.branch_id,
+              company_id: sale.company_id
+            }
+          };
+
+          const ruleResults = await ruleEngine.executeRules(convertedRuleTaxes, context);
+          const appliedRule = ruleResults.find(result => result.success && result.data);
+
+          if (appliedRule && appliedRule.data) {
+            // Result
+            const resultData = appliedRule.data;
+            
+            if (resultData.result && resultData.result.tax) {
+              const taxResult = resultData.result.tax;
+              
+              if (taxResult.rate !== undefined) {
+                adjustedRate = parseFloat(taxResult.rate);
+              }
+              
+              if (taxResult.amount !== undefined) {
+                taxAmount = parseFloat(taxResult.amount);
+              }
+            }
+
+            else if (resultData['tax.rate'] !== undefined) {
+              adjustedRate = parseFloat(resultData['tax.rate']);
+            } else if (resultData.rate !== undefined) {
+              adjustedRate = parseFloat(resultData.rate);
+            }
+          }
+        } catch (error) {
+          console.error(`Error applying rules for tax ${tax.abbreviation}:`, error);
+        }
+      }
 
-    allTaxes.forEach(tax => {
-      const taxAmount = roundCurrency(netAmount * (tax.rate / 100));
+      if (taxAmount <= 0) {
+        taxAmount = netAmount * (adjustedRate / 100);
+      }
+
+      taxAmount = roundCurrency(taxAmount);
+      
       const taxKey = getTaxProductIndex(tax, tax.product_id);
 
       const taxBatch = {
@@ -672,41 +835,40 @@ function getApplicableDwTaxes(sale) {
         product_index: productIndex,
         sum: netAmount,
         amount: taxAmount,
-        rate: tax.rate,
-        tax_type: tax.product_id ? 'specific' : 'general'
+        rate: adjustedRate, // ¡¡Usar adjustedRate, no tax.rate!!
+        original_rate: tax.rate,
+        tax_type: tax.product_id ? 'specific' : 'general',
+        adjusted_by_rule: adjustedRate !== tax.rate
       };
 
       taxBatches.push(taxBatch);
 
-      if (taxMap[taxKey]) {
-        taxMap[taxKey].amount += taxAmount;
-        taxMap[taxKey].batches.push(taxBatch);
+      // Usar adjustedRate en el mapa de impuestos
+      const mapTaxKey = `${tax.id}-${adjustedRate}-${tax.abbreviation}`;
+      
+      if (taxMap[mapTaxKey]) {
+        taxMap[mapTaxKey].amount += taxAmount;
+        taxMap[mapTaxKey].batches.push(taxBatch);
       } else {
-        taxMap[taxKey] = {
+        taxMap[mapTaxKey] = {
           id: tax.id,
           abbreviation: tax.abbreviation,
-          rate: tax.rate,
+          rate: adjustedRate, // ¡¡IMPORTANTE: Usar adjustedRate!!
+          original_rate: tax.rate,
           amount: taxAmount,
           product_id: tax.product_id || null,
-          batches: [taxBatch]
+          batches: [taxBatch],
+          adjusted_by_rule: adjustedRate !== tax.rate,
+          rule_applied: convertedRuleTaxes.length > 0 ? 'f8147b8a-ad51-46e8-884d-c3374efc9b00' : null
         };
       }
-    });
-  });
+    }
+  }
 
   return Object.values(taxMap).map(tax => ({
     ...tax,
     amount: roundCurrency(tax.amount)
   })).filter(tax => tax.amount > 0);
-
-  /*
-  return {
-    taxes: Object.values(taxMap).map(tax => ({
-      ...tax,
-      amount: roundCurrency(tax.amount)
-    })).filter(tax => tax.amount > 0),
-    tax_batches: taxBatches 
-  }; */
 }
 
 
@@ -724,12 +886,12 @@ function getApplicableDwTaxes(sale) {
  *   - original_subtotal: Optional - subtotal in original currency
  *   - original_total: Optional - total in original currency
  */
-function calculateSaleTotals(sale) {
+async function calculateSaleTotals(sale) {
   // Calculate base totals in sale currency
   const subtotal = calcSubtotal(sale);
-  const total = calcTotal(sale);
-  const change = calcChange(sale);
-  const debt = calcDebt(sale);
+  const total = await calcTotal(sale);
+  const change = await calcChange(sale);
+  const debt = await calcDebt(sale);
 
   const result = {
     subtotal, // Sum of products before taxes
@@ -893,24 +1055,24 @@ function roundCurrency(value, overrideRounding) {
 
 module.exports = {
   init,
-  preprocessSale,
-  calcTotal,
+  preprocessSale, // Async
+  calcTotal, // Async
   calcSubtotal,
-  calcDebt,
-  calcChange,
-  calcOriginalPaymentAmount,
+  calcDebt, // Async
+  calcChange, // Async
+  calcOriginalPaymentAmount, // Async
   calcGivedPaymentAmount,
   calcTaxesByAbbreviation,
-  calculateSaleTotals,
-  calculatePaymentDetails,
+  calculateSaleTotals, // Async
+  calculatePaymentDetails, // Async
   appliedWholesaleLevels,
-  getApplicableDwTaxes,
+  getApplicableDwTaxes, // Async
   getConsolidatedTaxes,
   calcDwSaleProductPrice,
   _internals: {
     calcDwSaleProductSum,
     calcDwSaleProductDiscount,
-    getApplicableProductTaxes,
+    getApplicableProductTaxes, // Async
     exchange
   }
 };

package/src/index.d.ts

@@ -3,7 +3,7 @@
  * @module softseti-sale-calculator-library
  */
 
-import { PaymentCalculation, RefundCalculation, RefundOptions, Sale, SaleItem, SaleTotals, WholesaleLevel } from "./interfaces";
+import { PaymentCalculation, RefundCalculation, RefundOptions, Sale, SaleItem, SaleTotals, WholesaleLevel } from "./models/interfaces";
 
 declare module 'softseti-sale-calculator-library' {
   /**
@@ -15,9 +15,9 @@ declare module 'softseti-sale-calculator-library' {
   /**
    * Preprocesses sale data for calculations
    * @param {Sale} sale - Sale object to preprocess
-   * @returns {Sale} Preprocessed sale object
+   * @returns {Promise<Sale>} Preprocessed sale object
    */
-  export function preprocessSale(sale: any): any;
+  export function preprocessSale(sale: any): Promise<any>;
 
   /**
    * Calculates subtotal for a sale
@@ -29,23 +29,23 @@ declare module 'softseti-sale-calculator-library' {
   /**
    * Calculates total amount for a sale
    * @param {Sale} sale - Sale object
-   * @returns {number} Total amount
+   * @returns {Promise<number>} Total amount
    */
-  export function calcTotal(sale: any): number;
+  export function calcTotal(sale: any): Promise<number>;
 
   /**
    * Calculates remaining debt for a sale
    * @param {Sale} sale - Sale object
-   * @returns {number} Debt amount
+   * @returns {Promise<number>} Debt amount
    */
-  export function calcDebt(sale: any): number;
+  export function calcDebt(sale: any): Promise<number>;
 
   /**
    * Calculates change amount for a sale
    * @param {Sale} sale - Sale object
-   * @returns {number} Change amount
+   * @returns {Promise<number>} Change amount
    */
-  export function calcChange(sale: any): number;
+  export function calcChange(sale: any): Promise<number>;
 
   /**
    * Calculates taxes by tax abbreviation
@@ -59,9 +59,9 @@ declare module 'softseti-sale-calculator-library' {
    * Calculates original payment amount
    * @param {object} payment - Payment object
    * @param {Sale} sale - Sale object
-   * @returns {number} Original payment amount
+   * @returns {Promise<number>} Original payment amount
    */
-  export function calcOriginalPaymentAmount(payment: any, sale: Sale): number;
+  export function calcOriginalPaymentAmount(payment: any, sale: Sale): Promise<number>;
 
   /**
    * Calculates given payment amount
@@ -75,9 +75,9 @@ declare module 'softseti-sale-calculator-library' {
    * Calculates detailed payment information
    * @param {object} payment - Payment object
    * @param {Sale} sale - Sale object
-   * @returns {PaymentCalculation} Payment details
+   * @returns {Promise<PaymentCalculation>} Payment details
    */
-  export function calculatePaymentDetails(payment: any, sale: Sale): PaymentCalculation;
+  export function calculatePaymentDetails(payment: any, sale: Sale): Promise<PaymentCalculation>;
 
 
   export function calcDwSaleProductPrice(saleProduct: any, sale: any): number;
@@ -91,9 +91,9 @@ declare module 'softseti-sale-calculator-library' {
   /**
    * Calculates all applicable taxes for the sale and returns them in API format
    * @param {Object} sale - Sale object
-   * @returns {Array} Array of tax objects with id, abbreviation, and amount
+   * @returns {Promise<Array>} Array of tax objects with id, abbreviation, and amount
    */
-  export function getApplicableDwTaxes(sale: any): any[];
+  export function getApplicableDwTaxes(sale: any): Promise<any[]>;
 
 
   /**
@@ -106,9 +106,9 @@ declare module 'softseti-sale-calculator-library' {
   /**
  * Calculates comprehensive sale totals
  * @param {Sale} sale - Sale object
- * @returns {SaleTotals} Sale totals
+ * @returns {Promise<SaleTotals>} Sale totals
  */
-  export function calculateSaleTotals(sale: any): SaleTotals;
+  export function calculateSaleTotals(sale: any): Promise<SaleTotals>;
 
   /**
    * Internal calculation methods (advanced use only)
@@ -130,7 +130,7 @@ declare module 'softseti-sale-calculator-library' {
      * Gets applicable product taxes
      * @internal
      */
-    getApplicableProductTaxes: (saleProduct: any, productSum: number, sale: Sale) => number;
+    getApplicableProductTaxes: (saleProduct: any, productSum: number, sale: Sale) => Promise<number>;
 
     /**
      * Currency exchange calculation

package/src/index.js

@@ -1,5 +1,5 @@
-const SaleCalculator = require('./SaleCalculator');
-const RefundCalculator = require('./refund-calculator');
+const SaleCalculator = require('./core/sale-calculator');
+const RefundCalculator = require('./core/refund-calculator');
 
 module.exports = {
   ...SaleCalculator,

package/src/models/BusinessRuleModel.js

@@ -0,0 +1,53 @@
+// src/models/BusinessRuleModel.js
+
+/**
+ * Business Rule Model for GoRules integration
+ * @class BusinessRuleModel
+ */
+class BusinessRuleModel {
+  constructor(data = {}) {
+    this.id = data.id || '';
+    this.name = data.name || '';
+    this.description = data.description || '';
+    this.entity_type = data.entity_type || '';
+    this.trigger_event = data.trigger_event || '';
+    this.type_rule = data.type_rule || '';
+    this.company_id = data.company_id || 0;
+    this.branch_id = data.branch_id || 0;
+    this.execution_order = data.execution_order || 1;
+    this.cumulative = data.cumulative || false;
+    this.valid_from = data.valid_from || null;
+    this.valid_until = data.valid_until || null;
+    this.rule_content = data.rule_content || null;
+  }
+
+  /**
+   * Check if rule is currently active
+   * @returns {boolean}
+   */
+  isActive() {
+    const now = new Date();
+    
+    if (this.valid_from && new Date(this.valid_from) > now) {
+      return false;
+    }
+    
+    if (this.valid_until && new Date(this.valid_until) < now) {
+      return false;
+    }
+    
+    return true;
+  }
+
+  /**
+   * Validate rule structure
+   * @returns {boolean}
+   */
+  isValid() {
+    return this.rule_content && 
+           this.rule_content.nodes && 
+           this.rule_content.edges;
+  }
+}
+
+module.exports = BusinessRuleModel;

package/src/rules/RuleManager.js

@@ -0,0 +1,75 @@
+// src/rules/RuleManager.js
+const BusinessRuleModel = require('../models/BusinessRuleModel');
+
+/**
+ * Rule Manager for handling business rule execution
+ * @class RuleManager
+ */
+class RuleManager {
+  constructor() {
+    this.rulesByTrigger = new Map();
+  }
+
+  /**
+   * Load rules organized by trigger event
+   * @param {Object} rules - Rules indexed by trigger event
+   */
+  loadRules(rules) {
+    this.rulesByTrigger.clear();    
+    Object.entries(rules).forEach(([trigger, ruleList]) => {
+      const ruleModels = ruleList.map(rule => new BusinessRuleModel(rule));
+      this.rulesByTrigger.set(trigger, ruleModels);
+    });
+  }
+
+  /**
+   * Get rules for a specific trigger event
+   * @param {string} triggerEvent - Trigger event name
+   * @returns {Array<BusinessRuleModel>}
+   */
+  getRulesForTrigger(triggerEvent) {
+    const rules = this.rulesByTrigger.get(triggerEvent) || [];
+    return rules.filter(rule => rule.isActive() && rule.isValid());
+  }
+
+  /**
+   * Get all trigger events with rules
+   * @returns {Array<string>}
+   */
+  getAvailableTriggers() {
+    return Array.from(this.rulesByTrigger.keys());
+  }
+
+  /**
+   * Clear all loaded rules
+   */
+  clearRules() {
+    this.rulesByTrigger.clear();
+  }
+
+  /**
+   * Get statistics about loaded rules
+   * @returns {Object}
+   */
+  getStats() {
+    const stats = {
+      totalRules: 0,
+      byTrigger: {},
+      activeRules: 0
+    };
+
+    this.rulesByTrigger.forEach((rules, trigger) => {
+      const activeRules = rules.filter(rule => rule.isActive());
+      stats.byTrigger[trigger] = {
+        total: rules.length,
+        active: activeRules.length
+      };
+      stats.totalRules += rules.length;
+      stats.activeRules += activeRules.length;
+    });
+
+    return stats;
+  }
+}
+
+module.exports = RuleManager;