diff --git a/README.md b/README.md index be24aa0..ccf7efc 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ [![Java](https://img.shields.io/badge/Java-21%2B-orange.svg)](https://openjdk.org) [![Spring Boot](https://img.shields.io/badge/Spring%20Boot-3.x-green.svg)](https://spring.io/projects/spring-boot) -> YAML DSL-based rule engine with AST processing, Python compilation, audit trails, and reactive APIs for dynamic business rule evaluation. +> YAML DSL-based rule engine with AST processing, audit trails, and reactive APIs for dynamic business rule evaluation. --- @@ -16,6 +16,8 @@ - [Requirements](#requirements) - [Installation](#installation) - [Quick Start](#quick-start) +- [Custom Functions](#custom-functions) +- [Error Contract](#error-contract) - [Configuration](#configuration) - [Documentation](#documentation) - [Contributing](#contributing) @@ -23,27 +25,36 @@ ## Overview -Firefly Framework Rule Engine provides a powerful business rule evaluation system based on a custom YAML DSL. Rules are defined in YAML format and parsed into an Abstract Syntax Tree (AST) for efficient evaluation. The engine supports complex conditions, arithmetic operations, loop constructs, function calls, REST API calls, and JsonPath expressions. +Firefly Framework Rule Engine provides a business rule evaluation system based on a custom YAML DSL. Rules are defined in YAML and parsed into an Abstract Syntax Tree (AST) for efficient evaluation. The engine supports rich conditions, arithmetic, loop constructs, function calls, REST API calls, JsonPath expressions, **decision tables (DMN-style)**, **rule composition (`invoke_rule`)**, and a pluggable function-registry extension point. -The project is structured as a multi-module build with five sub-modules: interfaces (DTOs and validation), models (database entities and repositories), core (DSL parser, evaluator, and services), SDK (client library), and web (REST controllers). It features Python code generation for rule compilation, batch evaluation, audit trail tracking, and caching for rule definitions. +The project is structured as a multi-module Maven build with five sub-modules: `interfaces` (DTOs and validation), `models` (R2DBC entities and repositories), `core` (DSL parser, evaluator, services, function registry), `web` (Spring WebFlux REST controllers), and `sdk` (generated client). The engine provides batch evaluation, audit-trail tracking, and a dedicated cache layer. -The YAML DSL supports variables, conditionals, loops (while, do-while, for-each), list operations, circuit breaker actions, and nested rule invocations, making it suitable for complex business rule scenarios such as credit scoring, eligibility checks, and pricing calculations. +The YAML DSL supports input/computed/constant variable tiers (with declared **input defaults**), 30+ comparison operators, logical composition (and/or/not), loops (`forEach`, `while`, `do-while`), inline conditionals (`if/then/else`), 80+ built-in functions (math, finance, date, string, list, validation, REST, JSON, type-conversion, statistics, advanced math, hashing, logging), **per-rule timeout**, **drools-style sub-rule priority**, and circuit-breaker actions for early termination. ## Features -- Custom YAML DSL with lexer, parser, and AST-based evaluation -- Condition types: comparison, logical (AND/OR), expression-based -- Action types: set, calculate, conditional, loops (while, do-while, for-each), function calls -- Expression types: arithmetic, binary, unary, literals, variables, JsonPath, REST calls -- Python code generation and compilation for rule optimization -- Batch rule evaluation for processing multiple inputs -- Rule definition CRUD with database persistence via R2DBC -- Constants management for shared rule variables -- Audit trail tracking for all rule evaluations -- YAML DSL validation with syntax and naming convention checks -- Caching for rule definitions and evaluation results -- REST API controllers for evaluation, definitions, constants, audit, and validation -- Reactive APIs using Project Reactor +- Custom YAML DSL with dedicated lexer + recursive-descent parser + visitor-based evaluator +- 30+ comparison operators including `between`, `in_list`, `matches`, `is_email`, `is_credit_score`, etc. +- Logical composition (`and`, `or`, `not`) with short-circuit evaluation +- Action types: `set`, `calculate`, `run`, `call`, arithmetic (`add`/`subtract`/`multiply`/`divide`), list ops (`append`/`prepend`/`remove`), `forEach`, `while`, `do-while`, `if/then/else`, `circuit_breaker` +- 80+ built-in functions covering math, advanced math (`exp`, `ln`, `sin`, `cos`, `tan`, `atan2`), hashing (`hash`), string, date, list, statistical (`median`, `stddev`, `variance`, `percentile`), financial, validation, REST, JSON path, type conversion, and structured logging +- **Decision Tables (DMN-style)**: tabular `decision_table:` block with `FIRST`, `COLLECT`, `ANY`, and `UNIQUE` hit policies; `=` prefix marks expression outputs +- **Rule Composition**: `invoke_rule(code, "key1", v1, "key2", v2, ...)` calls a stored rule by code and returns its outputs as a Map for chaining +- **Sub-rule Priority (drools-style salience)**: `priority: N` on each sub-rule; higher priority evaluates first, stable on ties +- **Input Defaults**: declare `default:` per input in the `inputs:` block; caller-omitted variables are filled in automatically +- **Per-Rule Timeout**: declare `timeout: 5s` (or `500ms`/raw ms) to bound wall-clock runtime via Reactor `Mono.timeout()` +- Pre-parse YAML lint catches the most common authoring trap (unquoted `:` inside action lines) before SnakeYAML throws a confusing error +- Strict naming validation: input variables (`camelCase`), constants (`UPPER_CASE`), and computed variables (`snake_case`) are validation errors when violated +- Pluggable function registry (`CustomFunctionRegistry`) — register your own `RuleFunction` beans and call them from rules +- Constants tier loaded from the database with TTL caching; auto-detection of `UPPER_CASE` references in the AST +- Reactive evaluation API on Project Reactor; synchronous visitor scheduled on `Schedulers.boundedElastic()` so it never blocks the Netty event loop +- Batch evaluation with bounded concurrency and per-request timeouts +- Rule-definition CRUD with R2DBC persistence and a cached AST +- Audit-trail tracking for every evaluation (correlated, PII-masked) +- YAML DSL validation: syntax, naming-convention, dependency, function-existence +- RFC 7807 problem-detail error responses; correlation IDs propagated across the chain +- Fail-loud error contract: malformed rules, unknown functions, type-coercion errors, and bad regexes surface as `success=false` with precise diagnostics rather than silently flipping to the else branch +- Spring WebFlux controllers; OpenAPI 3 / Swagger UI ## Requirements @@ -61,70 +72,196 @@ The rule engine is a multi-module project. Include the modules you need: org.fireflyframework fireflyframework-rule-engine-core - 26.02.07 + 26.05.07 org.fireflyframework fireflyframework-rule-engine-interfaces - 26.02.07 + 26.05.07 org.fireflyframework fireflyframework-rule-engine-sdk - 26.02.07 + 26.05.07 ``` ## Quick Start +### Naming conventions +The DSL is strict about variable naming so the engine can resolve names without ambiguity: + +| Tier | Convention | Example | +| ---------------- | ------------ | ------------------------------------ | +| Input variables | `camelCase` | `creditScore`, `annualIncome` | +| Computed values | `snake_case` | `debt_to_income`, `risk_tier` | +| Database constants | `UPPER_CASE` | `MIN_CREDIT_SCORE`, `MAX_DTI` | + +### Example rule (YAML DSL) + ```yaml -# Example rule definition (YAML DSL) -name: credit-score-check -version: 1 +name: "Credit Eligibility" +description: "Two-stage credit and income gate" +version: "1.0.0" + inputs: - - name: creditScore - type: number - - name: income - type: number - -rules: - - name: evaluate-eligibility - conditions: - - field: creditScore - operator: ">=" - value: 700 - - field: income - operator: ">=" - value: 50000 - actions: - - set: - eligible: true - tier: "premium" - else: - - set: - eligible: false - tier: "standard" + creditScore: "number" + annualIncome: "number" + +constants: + - code: MIN_CREDIT_SCORE + defaultValue: 700 + - code: MIN_INCOME + defaultValue: 50000 + +when: + - creditScore at_least MIN_CREDIT_SCORE + - annualIncome at_least MIN_INCOME + +then: + - calculate debt_to_income as 0 # placeholder; real rules would compute this + - set tier to if_else(creditScore at_least 800, "PRIME", "PREFERRED") + - set eligible to true + +else: + - set tier to "STANDARD" + - set eligible to false + +output: + eligible: eligible + tier: tier ``` +### Decision Table example (DMN-style) + +```yaml +name: "Auto Insurance Premium Table" + +inputs: + creditScore: number + age: number + +decision_table: + inputs: [creditScore, age] + outputs: [tier, rate] + hit_policy: FIRST + rules: + - when: + - creditScore at_least 750 + - age between 25 and 65 + then: + tier: "PRIME" + rate: 3.0 + - when: + - creditScore at_least 650 + then: + tier: "PREFERRED" + rate: 5.0 + - otherwise: true + then: + tier: "STANDARD" + rate: 9.0 + +output: + tier: tier + rate: rate +``` + +### Rule Composition example (`invoke_rule`) + +```yaml +name: "Underwriting Orchestrator" + +inputs: + creditScore: number + annualIncome: number + existingDebt: number + +then: + - run scoring as invoke_rule("composite_underwriting", + "creditScore", creditScore, + "annualIncome", annualIncome, + "existingDebt", existingDebt) + - set tier to scoring.tier + - set approved to scoring.approved + +output: + tier: tier + approved: approved +``` + +### Calling the engine from Java + ```java @Service public class CreditCheckService { private final RulesEvaluationService evaluationService; - public Mono evaluate(Map inputs) { - RulesEvaluationRequestDTO request = new RulesEvaluationRequestDTO(); - request.setRuleCode("credit-score-check"); - request.setInputs(inputs); - return evaluationService.evaluate(request); + public Mono evaluate(Map inputData) { + RuleEvaluationByCodeRequestDTO request = RuleEvaluationByCodeRequestDTO.builder() + .ruleDefinitionCode("credit_eligibility_v1") + .inputData(inputData) + .build(); + return evaluationService.evaluateRuleByCode(request, exchange); } } ``` +The same evaluation is also reachable via REST: `POST /api/v1/rules/evaluate/direct` (Base64-encoded YAML), `/evaluate/plain` (raw YAML), or `/evaluate/by-code` (stored rule code). + +## Custom Functions + +You can extend the DSL with your own functions without modifying the engine: + +```java +@Configuration +class MyRulesConfig { + + @Bean + CommandLineRunner registerCustomFunctions(CustomFunctionRegistry registry) { + return args -> { + registry.register("regional_risk", a -> + Set.of("CA", "NY").contains(a[0]) ? 10 : 0); + registry.register("fraud_score", a -> + fraudService.score(String.valueOf(a[0]))); + }; + } +} +``` + +Then in a rule: + +```yaml +then: + - run risk_bump as regional_risk(region) + - run fraud as fraud_score(applicantId) +``` + +Custom functions are checked **before** the built-in catalog (so they can shadow a built-in if you choose). Names are matched case-insensitively. The same function is callable from both expression contexts (`run`/`calculate`) and `call`-action contexts. + +## Error Contract + +The engine fails loud by design — errors are never silently swallowed: + +| Situation | Result | +| -------------------------------------------- | --------------------------------------------------------------------------- | +| Unknown function name | `IllegalArgumentException` -> rule reports `success=false` with the name | +| Non-numeric string in arithmetic | `IllegalArgumentException` naming the operand | +| Bad regex pattern in `matches` | `IllegalArgumentException` naming the pattern | +| Missing bean property | `IllegalArgumentException` naming the class + property | +| Unknown `is_valid` validation type | `IllegalArgumentException` listing supported types | +| Action throws during execution | Rule reports `success=false` with action index + debug string + cause | +| Condition throws during evaluation | Rule reports `success=false` (does not silently flip to the else branch) | +| `circuit_breaker` action triggered | Rule reports `success=true` with `circuitBreakerTriggered=true` + message | +| REST function HTTP failure | Returns a structured `{success:false, error:true, message}` map (chain-friendly) | +| `getCachedAST` / cache read failure | Treated as cache miss (parse path); logged via `doOnError` | +| `set computed_var to null` (e.g., `json_get` missing path) | Variable is stored as null; the rule succeeds | + ## Configuration ```yaml @@ -135,8 +272,6 @@ firefly: ttl: 10m audit: enabled: true - python-compilation: - enabled: false spring: r2dbc: @@ -150,12 +285,12 @@ Additional documentation is available in the [docs/](docs/) directory: - [Quick Start Guide](docs/quick-start-guide.md) - [Architecture](docs/architecture.md) - [Yaml Dsl Reference](docs/yaml-dsl-reference.md) +- [Migration Guide](docs/migration-guide.md) -- mapping from Drools / Easy Rules / hand-rolled if/else services - [Api Documentation](docs/api-documentation.md) - [Developer Guide](docs/developer-guide.md) - [Configuration Examples](docs/configuration-examples.md) - [Common Patterns Guide](docs/common-patterns-guide.md) - [Inputs Section Guide](docs/inputs-section-guide.md) -- [Python Compilation Complete Guide](docs/python-compilation-complete-guide.md) - [Performance Optimization](docs/performance-optimization.md) - [Governance Guidelines](docs/governance-guidelines.md) - [B2B Credit Scoring Tutorial](docs/b2b-credit-scoring-tutorial.md) diff --git a/docs/architecture.md b/docs/architecture.md index 6adaa22..ea32ad9 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1141,7 +1141,6 @@ GET /api/v1/audit/trails/entity/{entityId}?limit=10 - YAML DSL validation during parsing - DTO validation with Bean Validation - SQL injection prevention with parameterized queries -- Variable name and comment sanitization in Python code generation to prevent code injection - Regex pattern caching with LRU eviction (64 entries) to prevent ReDoS via unbounded compilation ### 2. SSRF Protection @@ -1151,34 +1150,48 @@ The `RestCallServiceImpl` includes comprehensive URL validation before executing - **Cloud metadata blocking**: Requests to `169.254.169.254` (cloud metadata endpoint) are blocked - **Host validation**: URLs without a valid host are rejected -### 3. Cryptographic Security (Python Runtime) -- **No hardcoded keys**: Encryption functions require explicit key configuration; no fallback to default keys -- **Strong key derivation**: PBKDF2 with random salt (`os.urandom(16)`) and 480,000 iterations -- **No weak algorithms**: MD5 hashing is explicitly rejected; only SHA-256 and SHA-512 are supported -- **Timing-safe comparison**: Hash verification uses `hmac.compare_digest()` to prevent timing attacks - -### 4. Safe Code Evaluation -- **No unsafe reflection**: `ExpressionEvaluator.getPropertyValue()` uses public getter methods only; `field.setAccessible(true)` is not used -- **Division/modulo by zero**: `ExpressionEvaluator` and `ActionExecutor` throw `ArithmeticException` instead of returning null or silently failing -- **Short-circuit evaluation**: AND/OR operators use lazy evaluation to prevent unnecessary side effects -- **Thread-safe code generation**: `PythonCodeGenerator` uses `ThreadLocal` for mutable state to ensure safe concurrent compilation - -### 5. Error Handling -- Graceful degradation for missing constants -- Circuit breaker pattern for external dependencies -- Comprehensive logging for audit trails -- Null-safe audit context extraction (defaults to "system" when no web exchange is available) - -### 6. Cache Integrity +### 3. Safe Code Evaluation +- **No unsafe reflection**: `ExpressionEvaluator.getPropertyValue()` uses public getter methods only (`getX` / `isX`); `field.setAccessible(true)` is never called. A missing getter throws `IllegalArgumentException` with the class + property name rather than silently returning null. +- **Division/modulo by zero**: `ExpressionEvaluator` and `ActionExecutor` throw `ArithmeticException` rather than returning null or silently failing. +- **Short-circuit evaluation**: AND/OR operators use lazy evaluation to prevent unnecessary side effects. + +### 4. Error Handling (Fail-Loud Contract) + +The engine is intentionally non-silent. Errors propagate to the rule's `success=false` +result with a precise diagnostic message rather than being swallowed and producing a +plausible-but-wrong output. + +| Source of failure | Behaviour | +| ------------------------------------------ | ------------------------------------------------------------------------ | +| Unknown function name | `IllegalArgumentException` -> `success=false` | +| Non-numeric string in arithmetic | `IllegalArgumentException` naming the operand | +| Bad regex pattern in `matches` | `IllegalArgumentException` naming the pattern | +| Missing bean property | `IllegalArgumentException` naming class + property | +| Unknown `is_valid` validation type | `IllegalArgumentException` listing supported types | +| Unknown `dateadd`/`datediff` unit | `IllegalArgumentException` listing supported units | +| Action throws mid-execution | Rule reports `success=false` with action index + debug string + cause | +| Condition throws mid-evaluation | Rule reports `success=false` (does not silently flip to the else branch) | +| `circuit_breaker` action triggered | Rule reports `success=true` with `circuitBreakerTriggered=true` | +| Required constant missing in database | `success=false` listing the missing codes | +| REST function HTTP failure | Structured error map `{success:false, error:true, message:...}` (intentional chain-friendly contract; rules can branch on `response.success`) | +| Cache read failure | Treated as cache miss; logged via `doOnError` | + +Surrounding mechanisms: +- Graceful degradation for missing **optional** constants (with explicit `defaultValue`). +- Circuit breaker pattern for external dependencies. +- Comprehensive audit trail (every evaluation logged with correlation ID). +- Null-safe audit context extraction (defaults to "system" when no web exchange is available). + +### 5. Cache Integrity - Cache invalidation on all CRUD operations (create, update, delete) for rule definitions - Reactive cache access uses `subscribeOn(Schedulers.boundedElastic())` to prevent blocking the Netty event loop -### 7. Database Security +### 6. Database Security - R2DBC with prepared statements - Connection encryption with SSL - Database user with minimal privileges -### 8. API Security (Future) +### 7. API Security (Future) - JWT token authentication - Rate limiting per client - Request/response encryption diff --git a/docs/b2b-credit-scoring-tutorial.md b/docs/b2b-credit-scoring-tutorial.md index cb2e664..e2ffe66 100644 --- a/docs/b2b-credit-scoring-tutorial.md +++ b/docs/b2b-credit-scoring-tutorial.md @@ -35,6 +35,7 @@ By the end of this tutorial, you'll understand: Every Firefly rule follows a consistent structure. Let's start with the basic template: + ```yaml # Required metadata name: "Rule Name" @@ -236,6 +237,7 @@ constants: Our B2B credit scoring will use multiple sequential rules to build a comprehensive assessment. This approach mirrors real-world credit evaluation processes where different aspects are analyzed in stages. + ```yaml # Multi-stage evaluation using sequential rules rules: @@ -276,8 +278,8 @@ rules: ) # Calculate data quality indicators - - calculate revenue_variance as abs(annualRevenue - verifiedAnnualRevenue) / verifiedAnnualRevenue - - calculate deposit_variance as abs(avgMonthlyDeposits - monthlyRevenue) / monthlyRevenue + - run revenue_variance as abs(annualRevenue - verifiedAnnualRevenue) / verifiedAnnualRevenue + - run deposit_variance as abs(avgMonthlyDeposits - monthlyRevenue) / monthlyRevenue # Overall data completeness and quality check - set data_validation_complete to ( @@ -451,8 +453,11 @@ rules: - if NOT meets_financial_requirements then set rejection_reason to "Debt service capacity insufficient" - if NOT meets_business_requirements then set rejection_reason to "Business does not meet minimum operating requirements" - # Generate recommendation summary - - calculate recommendation_summary as "Credit Score: " + final_credit_score + ", Risk Level: " + risk_level + ", DTI: " + (debt_to_income_ratio * 100) + "%" + # Generate recommendation summary. Uses `run` because the expression mixes strings + # with numbers (string concatenation via `+`). Wrap in YAML single-quotes because + # the message contains `:` followed by a space, which YAML would otherwise treat + # as a key/value separator. + - 'run recommendation_summary as "Credit Score - " + tostring(final_credit_score) + ", Risk - " + risk_level + ", DTI - " + tostring(debt_to_income_ratio * 100) + "%"' - set final_decision_complete to true diff --git a/docs/common-patterns-guide.md b/docs/common-patterns-guide.md index 7c88c80..0fca4e3 100644 --- a/docs/common-patterns-guide.md +++ b/docs/common-patterns-guide.md @@ -122,19 +122,21 @@ then: - set errors to [] - set valid to true - # Individual field validation + # Individual field validation (each branch is a separate action so the YAML + # never has a colon-followed-by-space inside an unquoted action string). - if not email is_email then append "Invalid email format" to errors - if not phone is_phone then append "Invalid phone number" to errors - if not ssn is_ssn then append "Invalid SSN format" to errors - if not birthDate is_date then append "Invalid birth date" to errors - # Update validity based on errors - - calculate error_count as size(errors) + # Tally errors. `size()` is a function call, so use `run` (not `calculate`). + - run error_count as size(errors) - if error_count greater_than 0 then set valid to false else: - set valid to false - - set errors to ["Missing required fields: email, phone"] + # Wrap the action in YAML single-quotes because the message contains a `:`. + - 'set errors to ["Missing required fields - email, phone"]' output: valid: boolean @@ -435,7 +437,7 @@ then: - if annualIncome at_least 60000 and annualIncome less_than 100000 then set incomeComponent to 20 - if annualIncome at_least 40000 and annualIncome less_than 60000 then set incomeComponent to 15 - if annualIncome less_than 40000 then set incomeComponent to 5 - + # Debt ratio component (20% weight) - calculate debt_ratio as existingDebt / annualIncome - if debt_ratio at_most 0.2 then set debtComponent to 20 @@ -449,7 +451,7 @@ then: - if employmentYears at_least 1 and employmentYears less_than 2 then set employmentComponent to 5 - if employmentYears less_than 1 then set employmentComponent to 2 - # Calculate final score + # Aggregate score (pure arithmetic, so `calculate` is fine here) - calculate risk_score as creditComponent + incomeComponent + debtComponent + employmentComponent # Determine risk level @@ -458,11 +460,12 @@ then: - if risk_score at_least 40 and risk_score less_than 60 then set risk_level to "HIGH" - if risk_score less_than 40 then set risk_level to "VERY_HIGH" - # Document contributing factors - - calculate credit_factor as "Credit Score: " + tostring(creditScore) + " (Weight: " + tostring(creditComponent) + ")" - - calculate income_factor as "Annual Income: " + tostring(annualIncome) + " (Weight: " + tostring(incomeComponent) + ")" - - calculate debt_factor as "Debt Ratio: " + tostring(debt_ratio) + " (Weight: " + tostring(debtComponent) + ")" - - calculate employment_factor as "Employment Years: " + tostring(employmentYears) + " (Weight: " + tostring(employmentComponent) + ")" + # Document contributing factors. These build strings via `tostring()` (a function + # call) and contain colons, so they use `run` and are wrapped in YAML quotes. + - 'run credit_factor as "Credit Score - " + tostring(creditScore) + " (Weight - " + tostring(creditComponent) + ")"' + - 'run income_factor as "Annual Income - " + tostring(annualIncome) + " (Weight - " + tostring(incomeComponent) + ")"' + - 'run debt_factor as "Debt Ratio - " + tostring(debt_ratio) + " (Weight - " + tostring(debtComponent) + ")"' + - 'run employment_factor as "Employment Years - " + tostring(employmentYears) + " (Weight - " + tostring(employmentComponent) + ")"' - append credit_factor to factors - append income_factor to factors @@ -550,7 +553,7 @@ rules: - set stage to "COMPLETED" - set final_decision_value to decision - - calculate processed_at as now() + - run processed_at as now() - set processing_complete to true else: - set decision to "REJECTED" @@ -630,7 +633,7 @@ then: # Store metadata - set enrichment_sources to sources - set enrichment_quality to data_quality - - calculate enrichment_timestamp as now() + - run enrichment_timestamp as now() - set enrichment_customer_id to customerId else: diff --git a/docs/developer-guide.md b/docs/developer-guide.md index 8e82c5f..c0637ef 100644 --- a/docs/developer-guide.md +++ b/docs/developer-guide.md @@ -207,34 +207,36 @@ org.fireflyframework.rules.core.dsl.ast/ │ └── BaseParser.java # Common parsing utilities ├── expression/ # Expression AST nodes │ ├── Expression.java # Base expression class -│ ├── BinaryExpression.java # Binary operations (+, -, *, /, etc.) +│ ├── BinaryExpression.java # Binary operations (+, -, *, /, %, **, comparisons) │ ├── UnaryExpression.java # Unary operations (-, !, validation ops) -│ ├── LiteralExpression.java # Literal values (numbers, strings, booleans) -│ ├── VariableExpression.java # Variable references +│ ├── LiteralExpression.java # Literal values (numbers, strings, booleans, arrays) +│ ├── VariableExpression.java # Variable references with property/index access │ ├── FunctionCallExpression.java # Function calls with parameters -│ ├── ArithmeticExpression.java # Complex arithmetic expressions -│ ├── JsonPathExpression.java # JSON path queries -│ ├── RestCallExpression.java # REST API calls │ ├── BinaryOperator.java # Binary operator enumeration │ ├── UnaryOperator.java # Unary operator enumeration │ └── ExpressionType.java # Expression type enumeration ├── condition/ # Condition AST nodes │ ├── Condition.java # Base condition class -│ ├── ComparisonCondition.java # Comparison operations (>, <, ==, etc.) +│ ├── ComparisonCondition.java # Comparison operations (>, <, ==, between, in_list, etc.) │ ├── LogicalCondition.java # Logical operations (AND, OR, NOT) │ ├── ExpressionCondition.java # Expression-based conditions │ └── ComparisonOperator.java # Comparison operator enumeration ├── action/ # Action AST nodes │ ├── Action.java # Base action class -│ ├── SetAction.java # Variable assignment (set var to value) -│ ├── CalculateAction.java # Arithmetic calculations -│ ├── AssignmentAction.java # Assignment operations (=, +=, etc.) -│ ├── FunctionCallAction.java # Function execution -│ ├── ConditionalAction.java # If-then-else actions -│ ├── ArithmeticAction.java # Arithmetic actions -│ ├── ListAction.java # List operations (append, prepend, etc.) -│ ├── CircuitBreakerAction.java # Execution control -│ └── AssignmentOperator.java # Assignment operator enumeration +│ ├── SetAction.java # Variable assignment (`set var to value`) +│ ├── CalculateAction.java # Pure-math arithmetic (`calculate var as expr`) +│ ├── RunAction.java # Function-call assignment (`run var as fn(...)`) +│ ├── FunctionCallAction.java # Standalone function execution (`call fn with [...]`) +│ ├── ConditionalAction.java # Inline if-then-else as an action +│ ├── ArithmeticAction.java # `add`/`subtract`/`multiply`/`divide` X to/from/by var +│ ├── ListAction.java # List operations (append, prepend, remove) +│ ├── CircuitBreakerAction.java # Early termination with a structured message +│ ├── ForEachAction.java # `forEach item in items: ...` +│ ├── WhileAction.java # `while condition: ...` +│ └── DoWhileAction.java # `do: ... while condition` +├── function/ # Extension point for user-defined functions +│ ├── RuleFunction.java # Functional interface: `Object apply(Object[] args)` +│ └── CustomFunctionRegistry.java # @Component holding registered functions ├── visitor/ # Visitor pattern implementations │ ├── EvaluationContext.java # Execution context and state │ ├── ExpressionEvaluator.java # Expression evaluation visitor @@ -663,64 +665,31 @@ public abstract class ASTNode { ``` ASTNode (abstract base) ├── Expression (abstract) -│ ├── LiteralExpression -│ │ ├── NumberLiteral (integers, decimals) -│ │ ├── StringLiteral (quoted strings) -│ │ ├── BooleanLiteral (true/false) -│ │ └── NullLiteral (null values) -│ ├── VariableExpression (variable references) -│ ├── BinaryExpression -│ │ ├── ArithmeticExpression (+, -, *, /, %, **) -│ │ ├── ComparisonExpression (>, <, ==, !=, >=, <=) -│ │ ├── LogicalExpression (AND, OR) -│ │ ├── StringExpression (contains, starts_with, ends_with) -│ │ └── ListExpression (in, not_in) -│ ├── UnaryExpression -│ │ ├── ArithmeticUnary (-, +) -│ │ ├── LogicalUnary (NOT, !) -│ │ └── ValidationUnary (is_positive, is_email, is_phone, etc.) -│ ├── FunctionCallExpression -│ │ ├── MathFunctions (abs, round, ceil, floor, etc.) -│ │ ├── StringFunctions (length, substring, upper, lower, etc.) -│ │ ├── DateFunctions (now, date_add, date_diff, etc.) -│ │ └── CustomFunctions (user-defined functions) -│ ├── ArithmeticExpression (complex multi-operand arithmetic) -│ ├── JsonPathExpression (JSON path queries) -│ └── RestCallExpression (REST API calls) +│ ├── LiteralExpression # numbers, strings, booleans, null, array literals +│ ├── VariableExpression # variable refs with optional property path / index access +│ ├── BinaryExpression # +, -, *, /, %, **, comparisons, and/or, contains, starts_with, etc. +│ ├── UnaryExpression # -, +, NOT, EXISTS, IS_NULL, IS_EMAIL, IS_POSITIVE, etc. +│ └── FunctionCallExpression # math, string, date, list, financial, validation, REST, JSON funcs ├── Condition (abstract) -│ ├── ComparisonCondition -│ │ ├── SimpleComparison (var > value) -│ │ ├── BetweenCondition (var between min and max) -│ │ ├── InCondition (var in [list]) -│ │ └── ValidationCondition (var is_positive) -│ ├── LogicalCondition -│ │ ├── AndCondition (condition1 AND condition2) -│ │ ├── OrCondition (condition1 OR condition2) -│ │ └── NotCondition (NOT condition) -│ └── ExpressionCondition (expression-based conditions) +│ ├── ComparisonCondition # `>=`, `at_least`, `between ... and ...`, `in_list [...]`, `is_email`, etc. +│ ├── LogicalCondition # AND / OR / NOT composition +│ └── ExpressionCondition # wraps any boolean-valued Expression └── Action (abstract) - ├── SetAction (set variable to value) - ├── CalculateAction (calculate variable as expression) - ├── AssignmentAction - │ ├── SimpleAssignment (var = value) - │ ├── AddAssignment (var += value) - │ ├── SubtractAssignment (var -= value) - │ ├── MultiplyAssignment (var *= value) - │ └── DivideAssignment (var /= value) - ├── FunctionCallAction (call function with parameters) - ├── ConditionalAction - │ ├── IfAction (if condition then actions) - │ ├── IfElseAction (if condition then actions else actions) - │ └── SwitchAction (switch-case logic) - ├── ArithmeticAction (arithmetic operations as actions) - ├── ListAction - │ ├── AppendAction (append to list) - │ ├── PrependAction (prepend to list) - │ ├── RemoveAction (remove from list) - │ └── ClearAction (clear list) - └── CircuitBreakerAction (execution control and error handling) + ├── SetAction # `set var to value` + ├── CalculateAction # `calculate var as ` + ├── RunAction # `run var as ` + ├── FunctionCallAction # `call fn with [args]` + ├── ConditionalAction # `if cond then actions [else actions]` + ├── ArithmeticAction # `add X to var`, `subtract X from var`, `multiply var by X`, `divide var by X` + ├── ListAction # `append X to list`, `prepend X to list`, `remove X from list` + ├── ForEachAction # `forEach item[, index] in items: actions` + ├── WhileAction # `while cond: actions` + ├── DoWhileAction # `do: actions while cond` + └── CircuitBreakerAction # `circuit_breaker "MESSAGE"` -- early termination ``` +> **Note:** The DSL was simplified in 2026-05 to remove orphan AST classes that were never produced by the parser. The compound-assignment family (`+=`, `-=`, etc.) and the multi-operand `ArithmeticExpression` n-ary form are no longer present. Use `add`/`subtract`/`multiply`/`divide` arithmetic actions or `calculate`/`run` with `+`/`-`/`*`/`/` for the same outcomes. + ### 🔢 **Expression Nodes: Representing Computable Values** **What is an Expression?** @@ -1316,11 +1285,9 @@ public class ActionParser extends BaseParser { return parseConditionalAction(); } - // Handle arithmetic actions (var += value) - if (check(TokenType.IDENTIFIER) && checkNext(TokenType.ASSIGN, TokenType.PLUS_ASSIGN, - TokenType.MINUS_ASSIGN, TokenType.MULTIPLY_ASSIGN)) { - return parseAssignmentAction(); - } + // Arithmetic actions are emitted by `add`/`subtract`/`multiply`/`divide` keywords + // (parseArithmeticAction), not by `=` / `+=` operators -- the latter are not part + // of the action DSL. throw error("Expected action statement"); } @@ -1400,29 +1367,29 @@ The `ASTVisitor` interface is the heart of the visitor pattern implementation: public interface ASTVisitor { // Expression visitors - handle value computation - T visitBinaryExpression(BinaryExpression node); // a + b, a > b, etc. - T visitUnaryExpression(UnaryExpression node); // -a, !a, is_positive(a) - T visitVariableExpression(VariableExpression node); // creditScore, income - T visitLiteralExpression(LiteralExpression node); // 42, "hello", true - T visitFunctionCallExpression(FunctionCallExpression node); // max(a, b) - T visitArithmeticExpression(ArithmeticExpression node); // Complex arithmetic - T visitJsonPathExpression(JsonPathExpression node); // $.user.name - T visitRestCallExpression(RestCallExpression node); // REST API calls + T visitBinaryExpression(BinaryExpression node); // a + b, a > b, a and b, etc. + T visitUnaryExpression(UnaryExpression node); // -a, !a, is_positive(a) + T visitVariableExpression(VariableExpression node); // creditScore, user.profile.name + T visitLiteralExpression(LiteralExpression node); // 42, "hello", true, [1,2,3] + T visitFunctionCallExpression(FunctionCallExpression node); // max(a, b), if_else(...), coalesce(...), rest_get(...), json_get(...) // Condition visitors - handle boolean logic - T visitComparisonCondition(ComparisonCondition node); // a > b - T visitLogicalCondition(LogicalCondition node); // a AND b - T visitExpressionCondition(ExpressionCondition node); // Expression as condition + T visitComparisonCondition(ComparisonCondition node); // a > b, a between x and y, etc. + T visitLogicalCondition(LogicalCondition node); // a AND b, a OR b, NOT a + T visitExpressionCondition(ExpressionCondition node); // any Expression as a condition // Action visitors - handle state changes T visitSetAction(SetAction node); // set var to value - T visitCalculateAction(CalculateAction node); // calculate var as expr - T visitAssignmentAction(AssignmentAction node); // var = value, var += value - T visitFunctionCallAction(FunctionCallAction node); // call function() - T visitConditionalAction(ConditionalAction node); // if-then-else - T visitArithmeticAction(ArithmeticAction node); // Arithmetic as action - T visitListAction(ListAction node); // List operations - T visitCircuitBreakerAction(CircuitBreakerAction node); // Error handling + T visitCalculateAction(CalculateAction node); // calculate var as expr (pure-math only) + T visitRunAction(RunAction node); // run var as fn(...) / json_get(...) / rest_*(...) + T visitFunctionCallAction(FunctionCallAction node); // call fn with [args] + T visitConditionalAction(ConditionalAction node); // if cond then ... else ... + T visitArithmeticAction(ArithmeticAction node); // add/subtract/multiply/divide ... to/from/by var + T visitListAction(ListAction node); // append/prepend/remove ... to/from list + T visitCircuitBreakerAction(CircuitBreakerAction node); // circuit_breaker "MESSAGE" + T visitForEachAction(ForEachAction node); // forEach item[, index] in items: actions + T visitWhileAction(WhileAction node); // while cond: actions + T visitDoWhileAction(DoWhileAction node); // do: actions while cond } ``` @@ -1578,44 +1545,33 @@ public class ActionExecutor implements ASTVisitor { } @Override - public Void visitAssignmentAction(AssignmentAction node) { - // Step 1: Evaluate the new value + public Void visitArithmeticAction(ArithmeticAction node) { + // Equivalent of an "in-place" compound assignment, expressed via dedicated keywords + // in the DSL (`add X to var`, `subtract X from var`, etc.). Both operands must be + // numeric; non-numeric operands raise IllegalArgumentException so authoring bugs + // surface immediately rather than silently no-op'ing. Object value = node.getValue().accept(expressionEvaluator); + Object current = context.getVariable(node.getVariableName()); - // Step 2: Apply the assignment operator - switch (node.getOperator()) { - case ASSIGN -> { - // Simple assignment: var = value - context.setComputedVariable(node.getVariableName(), value); - } - case ADD_ASSIGN -> { - // Addition assignment: var += value - Object currentValue = context.getVariable(node.getVariableName()); - if (currentValue instanceof Number && value instanceof Number) { - // Numeric addition - BigDecimal current = toBigDecimal(currentValue); - BigDecimal addValue = toBigDecimal(value); - context.setComputedVariable(node.getVariableName(), current.add(addValue)); - } else { - // String concatenation - context.setComputedVariable(node.getVariableName(), - currentValue.toString() + value.toString()); - } - } - case SUBTRACT_ASSIGN -> { - // Subtraction assignment: var -= value - Object currentValue = context.getVariable(node.getVariableName()); - if (currentValue instanceof Number && value instanceof Number) { - BigDecimal current = toBigDecimal(currentValue); - BigDecimal subValue = toBigDecimal(value); - context.setComputedVariable(node.getVariableName(), current.subtract(subValue)); - } else { - throw new ASTException("Cannot subtract non-numeric values"); - } - } - // ... other assignment operators + if (!(current instanceof Number) || !(value instanceof Number)) { + throw new IllegalArgumentException( + "Arithmetic action requires numeric operands"); } + BigDecimal currentNum = toBigDecimal(current); + BigDecimal valueNum = toBigDecimal(value); + BigDecimal result = switch (node.getOperation()) { + case ADD -> currentNum.add(valueNum); + case SUBTRACT -> currentNum.subtract(valueNum); + case MULTIPLY -> currentNum.multiply(valueNum); + case DIVIDE -> { + if (valueNum.signum() == 0) { + throw new ArithmeticException("Division by zero in arithmetic action"); + } + yield currentNum.divide(valueNum, 10, RoundingMode.HALF_UP); + } + }; + context.setComputedVariable(node.getVariableName(), result); return null; } diff --git a/docs/governance-guidelines.md b/docs/governance-guidelines.md index 9a7e783..2ff1684 100644 --- a/docs/governance-guidelines.md +++ b/docs/governance-guidelines.md @@ -243,12 +243,14 @@ else: ``` **For Intermediate and Advanced:** + +Use the `circuit_breaker` *action* inside `then:` to short-circuit a rule when a +downstream dependency or risk signal trips: + + ```yaml -# Add circuit breakers for external dependencies -circuit_breaker: - enabled: true - failure_threshold: 3 - timeout_duration: "10s" +then: + - if downstream_failure_count at_least 3 then circuit_breaker "DOWNSTREAM_UNAVAILABLE" ``` --- diff --git a/docs/migration-guide.md b/docs/migration-guide.md new file mode 100644 index 0000000..867bb07 --- /dev/null +++ b/docs/migration-guide.md @@ -0,0 +1,257 @@ +# Migration Guide + +A practical mapping from common rule-engine concepts to the Firefly Rule Engine DSL. The goal is to give you the **shortest path from a rule you've written in another engine to its Firefly equivalent**, and to make the trade-offs explicit so you know whether this engine is the right fit. + +## Table of Contents + +- [Where Firefly sits in the landscape](#where-firefly-sits-in-the-landscape) +- [Migrating from Drools (DRL)](#migrating-from-drools-drl) +- [Migrating from Easy Rules](#migrating-from-easy-rules) +- [Migrating from a hand-rolled if/else service](#migrating-from-a-hand-rolled-ifelse-service) +- [When Firefly is the wrong tool](#when-firefly-is-the-wrong-tool) + +--- + +## Where Firefly sits in the landscape + +Firefly Rule Engine is a **stateless expression-evaluation engine over a single +input map**. Each evaluation is an independent function call: parse a YAML rule, +feed it inputs, get outputs. + +This is intentionally a smaller, more focused model than full-blown rule engines: + +| Concept | Firefly | Drools (KIE) | Easy Rules | +| ------------------------------------ | ---------------------- | -------------------------- | --------------------- | +| Rule format | YAML DSL | DRL (Java-like) | Java annotations / MVEL | +| State model | Stateless per eval | Stateful KieSession + Working Memory | Stateless `Facts` | +| Rule chaining | Sub-rules within one eval + `invoke_rule` for cross-rule composition | Full forward-chaining inference | Priority-ordered list | +| Rule priority / salience | Per sub-rule `priority: N` (drools-style) | `salience N` | `@Priority(N)` | +| Multi-fact joins | Not supported | Native (LHS pattern matching) | Not directly | +| Decision tables | DMN-style `decision_table:` block with FIRST / COLLECT / ANY / UNIQUE | Native (DRT, spreadsheets) | Not directly | +| Per-rule timeout | Declarative `timeout: 5s` (Reactor `Mono.timeout()`) | KieSession-wide | Not directly | +| Input defaults | Declared in `inputs:` block | Not directly | Not directly | +| Persistent fact base | Not supported | KIE working memory | Not supported | +| External calls (REST/JSON) in rules | Built-in (`rest_get`, `json_get`, etc.) | Plugin-based | Custom actions | +| Custom function extensions | Spring `@Bean` registration | Imports + globals | `RuleListener` | +| Audit trail | Built-in | Plugin | Listener interface | +| Hot reload | DB-backed; replace rule definition | KieScanner | App reload | + +If your rules are **"score / decide / classify based on this one payload"**, Firefly +is purpose-built. If your rules are **"find applications where the spouse's credit +history triggers something on the primary applicant's file"**, you want Drools. + +--- + +## Migrating from Drools (DRL) + +### Side-by-side: a credit-score-driven approval + +**Drools (DRL):** + +```drl +rule "Approve high credit" +when + $a : Application(creditScore >= 700, annualIncome >= 50000) +then + $a.setApprovalStatus("APPROVED"); + $a.setTier("STANDARD"); + update($a); +end + +rule "Premium tier" +when + $a : Application(creditScore >= 800, annualIncome >= 100000) +then + $a.setTier("PRIME"); + update($a); +end +``` + +**Firefly (YAML):** + +```yaml +name: "Application Approval" +inputs: + creditScore: "number" + annualIncome: "number" + +when: + - creditScore at_least 700 + - annualIncome at_least 50000 + +then: + - set approval_status to "APPROVED" + - run tier as if_else(creditScore at_least 800 and annualIncome at_least 100000, "PRIME", "STANDARD") + +else: + - set approval_status to "DECLINED" + +output: + approval_status: text + tier: text +``` + +### Conceptual mapping + +| Drools | Firefly | +| ------------------------------------- | ------------------------------------------------------ | +| `KieSession` + `insert(fact)` | Pass a `Map` of inputs | +| `rule "X" when ... then ... end` | A `rules:` entry, or a top-level `when/then/else` | +| LHS pattern matching `$a : Application(field op value)` | `when:` list of conditions on input variables | +| `update($a)` | Implicit -- variables in `EvaluationContext` are mutable for the rest of this evaluation | +| Salience / priority | Order of entries in the `rules:` list | +| `agendaGroup`, `ruleflow-group` | Sub-rules within one evaluation; chained by output → input | +| Forward chaining (a `then` triggers another rule's `when`) | **Not supported** -- run multiple evaluations or use sub-rules with explicit variables | +| `accumulate` over multiple facts | **Not supported** -- pass an already-aggregated value as an input | +| `query` / backward chaining | **Not supported** | +| Decision tables (DRT) | Express as `if/then/else` chains or many `rules:` | +| Globals (`global Logger logger`) | Constants (`UPPER_CASE`, loaded from DB) | +| Imports / `function` blocks | Spring beans implementing `RuleFunction` and registered with `CustomFunctionRegistry` | +| `kmodule.xml` | YAML rule stored as a `RuleDefinition` row in the database | + +### Patterns that map cleanly + +- **Single-fact decisions** -- direct translation. +- **Tiered scoring** with `if/then/else` chains -- direct translation. +- **Decision tables** -- DRL `RuleTable` blocks map to Firefly `decision_table:` with `FIRST`, `COLLECT`, `ANY`, or `UNIQUE` hit policies. See [yaml-dsl-reference.md](yaml-dsl-reference.md#decision-tables-dmn-style). +- **Salience / priority** -- DRL `salience` corresponds to Firefly's per-sub-rule `priority: N`. Higher priority evaluates first; ties preserve declaration order. +- **Rule composition** -- DRL `rule "X" extends "Y"` and modify-then-fire chains map to `invoke_rule("other_rule", "k1", v1, "k2", v2)` which returns the nested rule's output map. +- **External data calls** -- Drools requires plugin work; Firefly has `rest_get`, `json_get`, etc. built-in. +- **Per-rule budgets** -- where DRL relies on `KieSession`-level timeouts, Firefly accepts a `timeout: 5s` directive on each rule. + +### Patterns that don't map + +- **Cross-fact joins** -- no equivalent. Pre-compute the join into a single input. +- **Truth maintenance / retraction** -- no equivalent. Re-run with new inputs. +- **Backward chaining** -- no equivalent. + +--- + +## Migrating from Easy Rules + +Easy Rules is closer to Firefly in spirit (stateless, single-fact). The migration is +usually mechanical. + +**Easy Rules (annotated Java):** + +```java +@Rule(name = "Approve high credit", priority = 1) +public class ApproveHighCreditRule { + + @Condition + public boolean when(@Fact("creditScore") int score, + @Fact("annualIncome") double income) { + return score >= 700 && income >= 50000; + } + + @Action + public void then(Facts facts) { + facts.put("approvalStatus", "APPROVED"); + } +} +``` + +**Firefly (YAML):** + +```yaml +name: "Approve high credit" +inputs: + creditScore: "number" + annualIncome: "number" +when: + - creditScore at_least 700 + - annualIncome at_least 50000 +then: + - set approval_status to "APPROVED" +else: + - set approval_status to "DECLINED" +output: + approval_status: text +``` + +### Conceptual mapping + +| Easy Rules | Firefly | +| ------------------------------------- | ------------------------------------------------------ | +| `Facts facts = new Facts(); facts.put(...)` | `Map` input map | +| `Rules` collection | A single multi-rule YAML or many YAML rule definitions | +| `@Rule(priority = N)` | Order in `rules:` list | +| `RulesEngine` (e.g., `DefaultRulesEngine`) | `ASTRulesEvaluationEngine` | +| `RuleListener` | Built-in audit trail + `CustomFunctionRegistry` | +| MVEL expression `creditScore > 700` | `creditScore greater_than 700` (or `creditScore > 700`) | +| `@Action` method body | `then:` action list | +| Composite rules | Sub-rules in the `rules:` block | + +### What you gain + +- No Java compilation step to deploy a new rule. +- Database-backed rule definitions with hot-replace. +- Built-in REST / JSON / cache layers. +- Build-time validation of every rule example in your docs. + +### What you give up + +- MVEL / arbitrary Java expression power -- the Firefly DSL is intentionally narrower + to keep rules reviewable. +- Direct access to your domain objects from inside a rule -- the engine sees only + the input map. + +--- + +## Migrating from a hand-rolled if/else service + +This is the most common starting point. You have a Java service like: + +```java +public DecisionResult decide(Customer c) { + DecisionResult r = new DecisionResult(); + if (c.getCreditScore() >= 700 && c.getAnnualIncome() >= 50000) { + r.setApproved(true); + if (c.getCreditScore() >= 800) { + r.setTier("PRIME"); + } else { + r.setTier("STANDARD"); + } + } else { + r.setApproved(false); + r.setReason("Insufficient credit or income"); + } + return r; +} +``` + +The Firefly equivalent is the YAML rule shown in the [Drools section above](#migrating-from-drools-drl). +The translation pattern: + +1. **Inputs**: every method parameter / accessed bean field → an entry in `inputs:` +2. **Top-level `if` test**: → `when:` conditions +3. **Inside `if` body**: → `then:` actions +4. **Inside `else` body**: → `else:` actions +5. **Nested `if/else`**: → `if cond then ... else ...` action, or a sub-rule +6. **Result builder**: → `output:` mapping + +### Why move from hand-rolled to Firefly + +- Rules become editable artefacts rather than code deployments. +- A non-engineer can read, review, and propose changes to the YAML. +- The audit trail and validation come for free. + +--- + +## When Firefly is the wrong tool + +Be honest about the model. Choose a different engine if you need any of: + +- **Inference / forward chaining**: facts in working memory triggering more rules as + they're derived. Use Drools. +- **Backward chaining / goal-driven reasoning**: e.g., "find a configuration that + satisfies these constraints". Use Drools or a CLP solver. +- **Decision tables in Excel format** consumed directly. Use Drools DRT, OpenL Tablets, + or a DMN engine. +- **Multi-fact joins**: rules that match across pairs/groups of facts. +- **Truth maintenance**: retracting a fact and having dependent conclusions roll back. +- **Workflow / BPMN** orchestration with long-running state. + +For everything that's expressible as "given this payload, compute / decide / classify +the outcome", Firefly's narrower model is the right tool and will be faster to onramp, +easier to review, and harder to misuse than a full-blown rule engine. diff --git a/docs/python-compilation-complete-guide.md b/docs/python-compilation-complete-guide.md deleted file mode 100644 index 8b79636..0000000 --- a/docs/python-compilation-complete-guide.md +++ /dev/null @@ -1,641 +0,0 @@ -# Python Compilation - Complete Guide - -## 🐍 Overview - -The Firefly Framework Rule Engine supports compiling YAML DSL rules to executable Python code, enabling rule execution without the Java runtime. This comprehensive guide covers all aspects of Python compilation, from basic usage to advanced features. - -## 🚀 Key Features - -- **100% DSL Support**: All YAML DSL features are supported in Python compilation -- **Standalone Execution**: Generated Python code runs independently without Java dependencies -- **Database Integration**: Seamless integration with ConstantService for dynamic constants -- **Interactive Mode**: Built-in CLI interface for testing and debugging -- **Professional Quality**: Complete license headers, documentation, and error handling -- **Runtime Library**: Comprehensive Python library with 103+ built-in functions - -## 🏗️ Architecture - -### Core Components - -1. **PythonCodeGenerator**: AST visitor that generates Python code from parsed DSL -2. **PythonCompilationService**: Service layer managing compilation, caching, and statistics -3. **PythonCompiledRule**: Model representing compiled Python rule with metadata -4. **Python Runtime Library**: Complete Python library with all built-in functions -5. **REST API**: Endpoints for compilation, cache management, and statistics - -### Compilation Pipeline - -```mermaid -graph TD - A[YAML DSL] --> B[AST Parser] - B --> C[DSL Validation] - C --> D[PythonCodeGenerator] - D --> E[Constants Integration] - E --> F[Python Code] - F --> G[PythonCompiledRule] - G --> H[Cache Storage] - G --> I[API Response] -``` - -## 🎯 Quick Start - -### 1. Compile a Rule from YAML - -```bash -curl -X POST http://localhost:8080/api/v1/python/compile \ - -H "Content-Type: text/plain" \ - -d 'name: "credit_check" -description: "Simple credit score validation" -version: "1.0.0" - -input: - creditScore: "number" - -output: - approved: "boolean" - -when: creditScore >= 650 -then: - - set approved = true -else: - - set approved = false' -``` - -### 2. Compile a Rule from Database - -If you have rules already stored in the database, you can compile them directly: - -**By Rule ID:** -```bash -# Get the rule ID from the database first -curl "http://localhost:8080/api/v1/rules/definitions" | jq '.content[0].id' - -# Compile using the ID -curl -X POST "http://localhost:8080/api/v1/python/compile/rule/123e4567-e89b-12d3-a456-426614174000" -``` - -**By Rule Code:** -```bash -# Compile using the rule's unique code (easier to remember) -curl -X POST "http://localhost:8080/api/v1/python/compile/rule/code/credit_scoring_v1" -``` - -**Advantages of Database Compilation:** -- ✅ **No YAML needed** - Rules are already validated and stored -- ✅ **Version control** - Compile specific versions by ID -- ✅ **Production ready** - Use rules that passed all validations -- ✅ **Audit trail** - Full traceability of compiled rules - -### 3. Install Python Runtime - -```bash -# Install globally (macOS) -cd python-runtime -pip3 install --break-system-packages -e . - -# Verify installation -python3 -c "import firefly_runtime; print('Runtime installed successfully!')" -``` - -### 4. Execute Generated Code - -```python -# The generated Python file includes interactive execution -python3 compiled-rule.py - -# Or import and use programmatically -from compiled_rule import credit_check -result = credit_check({'creditScore': 720}) -print(result) # {'approved': True} -``` - -## 📋 Generated Python Code Structure - -### Complete Example - -```python -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# -# Copyright 2024-2026 Firefly Software Foundation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Generated by Firefly Framework Rule Engine Python Compiler -# Made with ❤️ by Firefly Software Foundation -# Compilation Date: 2025-09-15T13:46:07.887874+02:00 - -from firefly_runtime import * - -def credit_check(context): - """ - Rule: credit_check - Simple credit score validation - - Args: - context (dict): Execution context with input variables - - Returns: - dict: Output variables - """ - - # Initialize constants from database or default values - constants = {} - constants['MIN_CREDIT_SCORE'] = 650 # Default value - - # Rule logic - if context.get('creditScore', 0) >= constants['MIN_CREDIT_SCORE']: - context['approved'] = True - else: - context['approved'] = False - - # Return output variables - return { - 'approved': context.get('approved') - } - -if __name__ == "__main__": - print_firefly_header("credit_check", "Simple credit score validation", "1.0.0") - - # Configure constants interactively if needed - constants_need_config = [] - configure_constants_interactively(constants_need_config) - - # Collect input values - context = collect_inputs({'creditScore': 'number'}) - - # Execute rule - print_execution_results(credit_check(context)) - - print_firefly_footer() -``` - -## 🔧 Constants Integration - -### Database vs Default Values - -The compiler handles three scenarios for constants: - -1. **Database Override**: Constants from database override default values -2. **Default Fallback**: Use default values when not in database -3. **Missing Constants**: Set to `None` with warnings - -```python -# Initialize constants from database or default values -constants['EXISTING_CONSTANT'] = 999 # From database -constants['DEFAULT_ONLY_CONSTANT'] = 500 # Default value -constants['MISSING_CONSTANT'] = None # WARNING: Not found -``` - -### Interactive Configuration - -Generated code includes interactive constant configuration: - -```python -if constants_need_config: - print("⚠️ WARNING: The following constants are not configured:") - for const in constants_need_config: - print(f" - {const}") - - configure = input("\n🔧 Would you like to configure them now? (y/n): ").lower() - if configure == 'y': - for const in constants_need_config: - value = get_user_input(f"{const}: ", "auto") - if value is not None: - constants[const] = value -``` - -## 📚 Python Runtime Library - -### Complete Function Coverage (103 Functions) - -#### Core Functions -- `firefly_get_nested_value()`, `firefly_get_indexed_value()` -- `firefly_is_empty()`, `firefly_is_not_empty()` -- `firefly_size()`, `firefly_count()`, `firefly_first()`, `firefly_last()` -- `firefly_average()`, `firefly_between()`, `firefly_exists()` - -#### Financial Functions -- `firefly_calculate_loan_payment()`, `firefly_calculate_compound_interest()` -- `firefly_calculate_credit_score()`, `firefly_debt_to_income_ratio()` -- `firefly_credit_utilization()`, `firefly_loan_to_value()` -- `firefly_calculate_debt_ratio()`, `firefly_calculate_ltv()` - -#### Validation Functions -- `firefly_validate_ssn()`, `firefly_validate_email()`, `firefly_validate_phone()` -- `firefly_is_positive()`, `firefly_is_negative()`, `firefly_is_zero()` -- `firefly_is_null()`, `firefly_is_not_null()`, `firefly_is_numeric()` - -#### String Functions -- `firefly_upper()`, `firefly_lower()`, `firefly_trim()` -- `firefly_contains()`, `firefly_startswith()`, `firefly_endswith()` -- `firefly_replace()`, `firefly_matches()`, `firefly_length()` - -#### Date/Time Functions -- `firefly_now()`, `firefly_today()`, `firefly_dateadd()`, `firefly_datediff()` -- `firefly_time_hour()`, `firefly_time_minute()`, `firefly_time_second()` - -#### REST Client Functions -- `firefly_rest_get()`, `firefly_rest_post()`, `firefly_rest_put()` -- `firefly_rest_delete()`, `firefly_rest_patch()`, `firefly_rest_call()` - -#### JSON Functions -- `firefly_json_extract()`, `firefly_json_exists()`, `firefly_json_size()` -- `firefly_json_keys()`, `firefly_json_values()`, `firefly_json_merge()` - -#### Security Functions -- `firefly_encrypt()`, `firefly_decrypt()`, `firefly_hash()` -- `firefly_mask_data()`, `firefly_generate_uuid()` - -#### Interactive Functions -- `get_user_input()`, `collect_inputs()`, `configure_constants_interactively()` -- `print_firefly_header()`, `print_execution_results()`, `print_firefly_footer()` - -### HTTP Best Practices - -The runtime includes validation for HTTP methods: - -```python -# DELETE and GET requests should not have bodies -if method == 'DELETE' and body is not None: - warnings.warn( - "DELETE requests should not include a request body according to HTTP standards. " - "The body parameter will be ignored.", - UserWarning - ) -``` - -## 🌐 REST API Reference - -### Compile Single Rule from YAML - -**POST** `/api/v1/python/compile` - -**Parameters:** -- `ruleName` (optional): Name for the rule -- `useCache` (default: true): Whether to use compilation cache - -**Request Body:** YAML DSL rule definition (text/plain) - -**Response:** PythonCompiledRule object - -### Compile Rule from Database by ID - -**POST** `/api/v1/python/compile/rule/{ruleId}` - -Compiles a rule definition stored in the database using the rule's UUID. - -**Path Parameters:** -- `ruleId` (required): UUID of the rule definition in the database - -**Query Parameters:** -- `useCache` (default: true): Whether to use compilation cache - -**Response:** PythonCompiledRule object - -**Example:** -```bash -curl -X POST "http://localhost:8080/api/v1/python/compile/rule/123e4567-e89b-12d3-a456-426614174000?useCache=true" -``` - -### Compile Rule from Database by Code - -**POST** `/api/v1/python/compile/rule/code/{ruleCode}` - -Compiles a rule definition stored in the database using the rule's unique code identifier. - -**Path Parameters:** -- `ruleCode` (required): Unique code of the rule definition (e.g., "credit_scoring_v1") - -**Query Parameters:** -- `useCache` (default: true): Whether to use compilation cache - -**Response:** PythonCompiledRule object - -**Example:** -```bash -curl -X POST "http://localhost:8080/api/v1/python/compile/rule/code/credit_scoring_v1?useCache=true" -``` - -### Batch Compile Rules - -**POST** `/api/v1/python/compile/batch` - -**Request Body:** Map of rule names to YAML DSL definitions - -### Cache Management - -- **GET** `/api/v1/python/stats` - Get compilation statistics -- **DELETE** `/api/v1/python/cache` - Clear compilation cache -- **POST** `/api/v1/python/cache/check` - Check if rule is cached -- **POST** `/api/v1/python/cache/get` - Get cached compiled rule -- **DELETE** `/api/v1/python/cache/rule?ruleName=name` - Remove specific rule from cache - -**Note**: The DELETE endpoint uses query parameters instead of request body to follow HTTP best practices. - -### API Response Format - -All compilation endpoints return a `PythonCompiledRule` object: - -```json -{ - "ruleName": "credit_scoring_v1", - "description": "Advanced credit scoring rule", - "version": "1.0.0", - "pythonCode": "#!/usr/bin/env python3\n# Generated Python code...", - "functionName": "credit_scoring_v1", - "inputVariables": ["creditScore", "income", "debtRatio"], - "outputVariables": { - "approved": "boolean", - "maxLoanAmount": "number", - "interestRate": "number" - }, - "compiledAt": "2025-09-15T14:30:00Z", - "sourceHash": "abc123def456" -} -``` - -### Error Responses - -**404 Not Found** - Rule not found in database: -```json -{ - "error": "Rule definition not found", - "message": "No rule definition found with ID: 123e4567-e89b-12d3-a456-426614174000", - "ruleId": "123e4567-e89b-12d3-a456-426614174000" -} -``` - -**400 Bad Request** - Compilation error: -```json -{ - "error": "Compilation failed", - "message": "Invalid DSL syntax: Missing 'when' clause", - "ruleId": "123e4567-e89b-12d3-a456-426614174000", - "ruleName": "credit_scoring_v1" -} -``` - -### Use Cases for Database Compilation - -**1. Production Deployment** -- Compile rules that are already validated and stored in production database -- Ensure consistency between stored rules and compiled Python code -- Leverage existing rule management workflows - -**2. CI/CD Integration** -```bash -# Compile all active rules for deployment -curl -X POST "http://localhost:8080/api/v1/python/compile/rule/code/credit_scoring_v1" \ - -o credit_scoring_v1.py - -# Deploy compiled Python files to production environment -``` - -**3. Rule Versioning** -- Compile specific versions of rules by ID -- Maintain multiple compiled versions for A/B testing -- Rollback to previous rule versions quickly - -**4. Automated Workflows** -```bash -# Get all rule definitions and compile them -rules=$(curl "http://localhost:8080/api/v1/rules/definitions") -for rule_id in $(echo $rules | jq -r '.content[].id'); do - curl -X POST "http://localhost:8080/api/v1/python/compile/rule/$rule_id" \ - -o "compiled_rule_$rule_id.py" -done -``` - -## 🧪 Testing - -### Comprehensive Test Suite - -- **52 Python Runtime Tests**: All runtime functions tested -- **17 Java Compiler Tests**: Complete compilation pipeline tested -- **HTTP Validation Tests**: REST client best practices validated -- **Integration Tests**: End-to-end compilation and execution - -### Test Results - -``` -Python Runtime Tests: 52 passed, 0 failed -Java Compiler Tests: 17 passed, 0 failed -Total Coverage: 100% DSL feature support -``` - -## 🎯 Advanced Features - -### Complex DSL Support - -The compiler supports all DSL features: - -- **Multiple Rules**: Sequential rule execution -- **Conditional Blocks**: Nested if-then-else logic -- **Function Calls**: All 103+ built-in functions -- **Arithmetic Operations**: Mathematical expressions -- **JSON Path**: Data extraction from complex objects -- **REST Calls**: External API integration with proper HTTP validation - -### Performance Optimization - -- **AST Caching**: Parsed AST structures cached for reuse -- **Compilation Caching**: Compiled Python code cached by DSL hash -- **Parallel Processing**: Batch compilation uses parallel execution -- **Memory Management**: Efficient memory usage with configurable cache sizes - -### Error Handling - -- **Validation Errors**: DSL syntax and semantic validation -- **Compilation Errors**: Python code generation issues -- **Runtime Errors**: Execution-time error handling with detailed diagnostics -- **HTTP Validation**: Warnings for improper HTTP method usage - -## 📖 Best Practices - -### 1. Rule Design -- Use descriptive rule names for better Python function names -- Include comprehensive input/output type definitions -- Add meaningful descriptions for generated documentation - -### 2. Compilation Strategy -- **Use database compilation** for production deployments -- **Use YAML compilation** for development and testing -- **Enable caching** for frequently compiled rules -- **Use rule codes** instead of IDs for better readability - -### 3. Database Integration -- Store rules in database after thorough validation -- Use semantic versioning for rule versions -- Maintain active/inactive status for rule lifecycle management -- Tag rules appropriately for easy discovery - -### 4. Performance -- Enable caching for frequently compiled rules -- Use batch compilation for multiple rules -- Monitor compilation statistics for optimization -- Compile rules during deployment, not at runtime - -### 5. Testing -- Test both Java and Python execution for equivalence -- Validate edge cases and error conditions -- Use comprehensive test data sets -- Test compilation from both YAML and database sources - -### 6. Deployment -- Install Python runtime dependencies in target environment -- Use virtual environments for isolation -- Monitor Python execution performance -- Automate rule compilation in CI/CD pipelines - -### 7. API Usage -```bash -# Good: Use rule codes for readability -curl -X POST "/api/v1/python/compile/rule/code/credit_scoring_v1" - -# Good: Enable caching for production -curl -X POST "/api/v1/python/compile/rule/code/credit_scoring_v1?useCache=true" - -# Good: Handle errors gracefully -response=$(curl -s -w "%{http_code}" -X POST "/api/v1/python/compile/rule/code/invalid_rule") -if [[ "${response: -3}" != "200" ]]; then - echo "Compilation failed" -fi -``` - -## 🔗 Integration with Existing Systems - -### Rule Management Workflow - -```mermaid -graph TD - A[Create Rule in UI] --> B[Store in Database] - B --> C[Validate DSL] - C --> D[Activate Rule] - D --> E[Compile to Python] - E --> F[Deploy to Production] - F --> G[Monitor Execution] - G --> H[Update if Needed] - H --> B -``` - -### CI/CD Pipeline Integration - -```yaml -# .github/workflows/compile-rules.yml -name: Compile Rules to Python -on: - push: - branches: [main] - -jobs: - compile-rules: - runs-on: ubuntu-latest - steps: - - name: Get Active Rules - run: | - curl "${{ secrets.RULE_ENGINE_URL }}/api/v1/rules/definitions?isActive=true" \ - -H "Authorization: Bearer ${{ secrets.API_TOKEN }}" \ - -o rules.json - - - name: Compile Rules - run: | - for rule_code in $(jq -r '.content[].code' rules.json); do - curl -X POST "${{ secrets.RULE_ENGINE_URL }}/api/v1/python/compile/rule/code/$rule_code" \ - -H "Authorization: Bearer ${{ secrets.API_TOKEN }}" \ - -o "compiled_rules/${rule_code}.py" - done - - - name: Deploy to Production - run: | - # Deploy compiled Python files to your production environment - rsync -av compiled_rules/ production:/opt/rules/ -``` - -### Microservices Architecture - -```python -# rule_compiler_service.py -import requests -import os - -class RuleCompilerService: - def __init__(self, rule_engine_url, api_token): - self.base_url = rule_engine_url - self.headers = {"Authorization": f"Bearer {api_token}"} - - def compile_rule_by_code(self, rule_code, use_cache=True): - """Compile a rule from database by code""" - url = f"{self.base_url}/api/v1/python/compile/rule/code/{rule_code}" - params = {"useCache": use_cache} - - response = requests.post(url, headers=self.headers, params=params) - response.raise_for_status() - - return response.json() - - def deploy_compiled_rule(self, rule_code, target_dir="/opt/rules"): - """Compile and deploy a rule""" - compiled_rule = self.compile_rule_by_code(rule_code) - - # Save compiled Python code - file_path = os.path.join(target_dir, f"{rule_code}.py") - with open(file_path, 'w') as f: - f.write(compiled_rule['pythonCode']) - - return file_path - -# Usage -compiler = RuleCompilerService("http://rule-engine:8080", "your-api-token") -compiler.deploy_compiled_rule("credit_scoring_v1") -``` - -## 🔮 Migration Guide - -### From Java Execution to Python - -1. **Identify rules** to migrate using the database endpoints -2. **Compile existing rules** using `/api/v1/python/compile/rule/code/{code}` -3. **Test equivalence** between Java and Python execution -4. **Deploy Python runtime** in target environment -5. **Update applications** to use compiled Python functions -6. **Monitor performance** and optimize as needed - -### From YAML to Database Compilation - -1. **Store rules** in database using `/api/v1/rules/definitions` -2. **Validate rules** using the validation endpoint -3. **Switch compilation** from YAML endpoints to database endpoints -4. **Update CI/CD** to use rule codes instead of YAML files -5. **Leverage rule management** features (versioning, activation, tags) - -### Compatibility - -- All DSL features are supported in Python compilation -- Function behavior is identical between Java and Python -- Error handling maintains the same semantics -- Performance characteristics may vary between platforms -- Database compilation provides additional metadata and traceability - -## 📞 Support - -For questions and support: - -- Check the [API Documentation](api-documentation.md) -- Review [YAML DSL Reference](yaml-dsl-reference.md) -- See [Developer Guide](developer-guide.md) for advanced topics -- Report issues in the project repository - ---- - -*Made with ❤️ by Firefly Software Foundation* diff --git a/docs/quick-start-guide.md b/docs/quick-start-guide.md index 2481ddb..dcafe30 100644 --- a/docs/quick-start-guide.md +++ b/docs/quick-start-guide.md @@ -290,8 +290,10 @@ then: - set current to startValue - set count to 0 - # Always executes at least once - - do: multiply current by 2; add 1 to count while current less_than maxValue + # Always executes at least once. + # Grammar reminder: arithmetic actions are ` `, + # so "multiply current by 2" is written `multiply 2 by current`. + - do: multiply 2 by current; add 1 to count while current less_than maxValue output: current: number @@ -385,6 +387,7 @@ if condition then action ``` ### Basic Structure Template + ```yaml name: "Your Rule Name" description: "What this rule does" diff --git a/docs/yaml-dsl-reference.md b/docs/yaml-dsl-reference.md index e7da86b..c084ef6 100644 --- a/docs/yaml-dsl-reference.md +++ b/docs/yaml-dsl-reference.md @@ -49,10 +49,49 @@ The Firefly Framework Rule Engine uses a powerful YAML-based Domain Specific Lan ### How to Use This Reference - **🔍 Find Specific Syntax**: Use the table of contents or search for keywords -- **📋 Copy Examples**: All code examples are tested and ready to use +- **📋 Copy Examples**: All complete-rule code examples in this file are parsed by the `DocExamplesValidationTest` at every build -- if you see one fail in your fork, the doc is out of sync with the implementation. - **🎯 Choose Complexity**: See [Governance Guidelines](governance-guidelines.md) for feature selection advice - **🚀 Get Started**: Try examples from [Quick Start Guide](quick-start-guide.md) first +### Mental Model -- What This Engine Is (and Isn't) + +**What it is.** A stateless **expression-evaluation engine** over a single input map. +You hand it a parsed YAML rule and a `Map` of inputs; it returns a +result with computed outputs, a condition outcome, and timing/audit metadata. + +**What it is NOT.** This is not Drools-style rule-based reasoning. There is no +working memory, no fact base, no inference, no rule-chaining triggered by data +changes. Each evaluation is an independent function call. + +| Capability | Supported by Firefly Rule Engine | +| --------------------------------------- | ---------------------------------------------------------------------- | +| Rule definitions in YAML | ✅ | +| 30+ comparison and validation operators | ✅ | +| Constants from DB (auto-detected by `UPPER_CASE`) | ✅ | +| `forEach` / `while` / `do-while` loops | ✅ | +| Sub-rules (`rules:` block) with shared state across rules in one eval | ✅ | +| **Sub-rule priority** (drools-style salience via `priority: N`) | ✅ | +| Inline conditional expression (`if_else(cond, then, else)`) | ✅ | +| **Decision tables (DMN-style)** -- `decision_table:` block with FIRST / COLLECT / ANY / UNIQUE hit policies | ✅ | +| **Rule composition** -- `invoke_rule(code, ...)` evaluates a stored rule and returns its outputs | ✅ | +| **Per-rule timeout** -- `timeout: 5s` declarative budget enforced via Reactor `Mono.timeout()` | ✅ | +| **Input defaults** -- declare `default:` per input; caller-omitted values are filled in | ✅ | +| Custom function registry (Spring `@Component`) | ✅ | +| REST / JSON path built-ins | ✅ | +| Circuit breaker action (early termination) | ✅ | +| **Rule chaining across separate evaluations** -- output of one eval automatically firing another | ❌ | +| **Persistent working memory / fact base** like Drools `KIE` | ❌ | +| **Inference / forward-chaining** -- deriving new facts that fire more rules | ❌ | +| **Backward chaining** (goal-driven reasoning) | ❌ | +| **Cross-input joins** -- finding pairs/groups of inputs that satisfy a constraint | ❌ | +| **Short-circuit evaluation in function calls** -- `if_else(cond, X, Y)` evaluates *both* branches | ❌ | +| **Truth maintenance** / retraction | ❌ -- variables are write-once-per-eval and never retracted | + +If you need any of the "❌" capabilities, this engine is the wrong tool. For those +use cases consider Drools / OpenL Tablets / DMN engines. For everything else -- +deterministic rule evaluation over an input payload -- this engine is purpose-built +to be smaller, faster to onramp, and clearer to reason about. + --- ## DSL Structure Overview @@ -79,15 +118,50 @@ constants: # Optional: Constants with defaults - code: CONSTANT_NAME defaultValue: value -circuit_breaker: # Optional: Resilience configuration - enabled: true - failure_threshold: 5 - timeout_duration: "30s" +timeout: 5s # Optional: per-rule wall-clock budget + # Accepts "5s", "500ms", or raw milliseconds. + # Exceeding it fails the rule with a clean message. +``` + +### Input Declarations with Defaults + +`inputs:` accepts three shapes: + +```yaml +# 1. Flat list -- type defaults to Object +inputs: [creditScore, annualIncome, age] + +# 2. Name -> type +inputs: + creditScore: number + annualIncome: number + age: number + +# 3. Name -> {type, default} -- default is injected when caller omits the variable +inputs: + creditScore: + type: number + default: 0 + annualIncome: + type: number + default: 0 + region: + type: string + default: "UNKNOWN" ``` +Caller-supplied values always override declared defaults. This makes rules safer to evaluate from partial inputs without sprinkling `coalesce(...)` calls through every action. + +> Note: early versions accepted a top-level `circuit_breaker:` configuration block +> (`enabled`, `failure_threshold`, `timeout_duration`, `recovery_timeout`). It was parsed +> but never enforced at runtime and is no longer accepted. Use the +> `circuit_breaker "MESSAGE"` *action* (described under "Action Syntax") for controlled +> early termination within a rule. + ### Logic Sections (Choose One) **Simple Syntax:** + ```yaml when: [conditions] # Simple condition list then: [actions] # Actions when true @@ -95,6 +169,7 @@ else: [actions] # Actions when false (optional) ``` **Complex Syntax:** + ```yaml conditions: # Structured condition blocks if: {condition_structure} @@ -103,19 +178,115 @@ conditions: # Structured condition blocks ``` **Multiple Rules:** + ```yaml rules: # Array of sub-rules - name: "Sub-rule 1" + priority: 10 # Optional: higher salience runs first (default 0) + when: [conditions] + then: [actions] + - name: "Sub-rule 2" + priority: 1 # Lower priority -- evaluates after Sub-rule 1 when: [conditions] then: [actions] ``` +Sub-rule priority is drools-style salience: higher `priority:` evaluates first; ties preserve YAML declaration order via a stable sort. Omitted priorities default to 0. + +**Decision Table (DMN-style):** + +```yaml +decision_table: + inputs: [col1, col2] # Optional: input column names (for documentation) + outputs: [col_a, col_b] # Optional: output column names + hit_policy: FIRST # FIRST | COLLECT | ANY | UNIQUE (default FIRST) + rules: + - when: [predicate, predicate] # Each row is a list of `when:` predicates + then: { col_a: value, col_b: value } + - otherwise: true # Fallback row -- matches when no others did + then: { col_a: default_value, col_b: default_value } +``` + +See the [Decision Tables](#decision-tables-dmn-style) section below for the full syntax, hit-policy semantics, and the `=` prefix for expression outputs. + --- ## Reserved Keywords The DSL uses specific reserved keywords that have special meaning in the parser. These are organized by category for easy reference: +### Synonyms and Canonical Forms + +Several keywords have multiple accepted spellings -- a deliberate flexibility so the +DSL reads naturally in different contexts. The **canonical** form is the one we +recommend in new code; aliases remain accepted for compatibility. All synonyms below +are matched case-insensitively where indicated. + +#### Comparison operators + +| Canonical | Aliases (also accepted) | Notes | +| --------- | ------------------------------- | ---------------------------------------------------------- | +| `equals` | `==` | Prefer `equals` in prose-style conditions, `==` in expressions | +| `not_equals` | `!=` | Same convention | +| `greater_than` | `>` | Use the symbol in expressions, the keyword in conditions | +| `less_than` | `<` | Same | +| `at_least` | `greater_than_or_equal`, `>=` | `at_least` reads most naturally in financial rules | +| `at_most` | `less_than_or_equal`, `<=` | Same | +| `in_list` | `in` | `in_list` makes membership intent explicit | +| `not_in_list` | `not_in` | Same | +| `is_not_null` | (no alias) | Use this rather than `not is_null` -- the negated form is one operator | +| `not_contains` | (no alias) | Same -- one operator, not `not contains` | + +#### Logical operators + +| Canonical | Aliases | Notes | +| --------- | -------------------- | -------------------------------------------------------------------- | +| `and` | `AND`, `&&` | Lower-case in YAML by convention; upper-case is also matched | +| `or` | `OR`, `\|\|` | Same | +| `not` | `NOT`, `!` | Unary; prefer `not x is_email` over `not_email` | + +#### Action verbs + +| Canonical | Aliases | Notes | +| --------- | -------- | --------------------------------------------------------------------------- | +| `forEach` | `for` | Both reach the same parser path; `forEach` reads better in mixed-case YAML | + +#### Built-in function aliases + +These are exact synonyms within the function-call layer -- pick one and stick with it +inside a rule for readability: + +| Canonical | Aliases | What it does | +| ------------ | ------------------------- | ------------------------------------------- | +| `length` | `len` | String / list length | +| `count` | `size` | Collection size | +| `avg` | `average` | Mean of a list | +| `uppercase` | `upper` | String → uppercase | +| `lowercase` | `lower` | String → lowercase | +| `substring` | `substr` | Extract substring | +| `tonumber` | `number` | Coerce to number | +| `tostring` | `string` | Coerce to string | +| `toboolean` | `boolean` | Coerce to boolean | +| `json_get` | `json_path` | Extract value from JSON via path | +| `is_in_range` | `in_range` | Inclusive bounded check | +| `if_else` | `ifelse` | Inline conditional value | + +#### YAML top-level keys (parser accepts both, but use the canonical form) + +| Canonical | Also accepted | Notes | +| --------- | -------------- | ---------------------------------------------------------------------- | +| `inputs` | `input` | The parser merges both into the same model field; prefer `inputs` | +| `outputs` | `output` | Same | + +> **Removed in 26.05.08:** the top-level `circuit_breaker:` *configuration block* (with +> `enabled`, `failure_threshold`, `timeout_duration`, `recovery_timeout` sub-keys) was +> parsed but never enforced at runtime. The action-form `circuit_breaker "MESSAGE"` +> (described in [Action Syntax](#action-syntax)) is the only circuit-breaker surface +> and is unchanged. + +--- + +
🏗️ Structural Keywords - Define the rule structure and metadata @@ -133,7 +304,6 @@ The DSL uses specific reserved keywords that have special meaning in the parser. | | `conditions` | ❌* | Complex condition blocks | `conditions: {if: {...}, then: {...}}` | | | `rules` | ❌* | Multiple sequential rules | `rules: [{name: "Rule 1", when: [...]}]` | | **Advanced Features** | `metadata` | ❌ | Additional metadata | `metadata: {tags: ["credit"], author: "Team"}` | -| | `circuit_breaker` | ❌ | Resilience configuration | `circuit_breaker: {enabled: true}` | *One of `when`/`then`, `conditions`, or `rules` is required for logic definition. @@ -201,6 +371,9 @@ The DSL uses specific reserved keywords that have special meaning in the parser. | | `ends_with` | - | String suffix | `email ends_with ".com"` | | | `matches` | - | Regex match | `ssn matches "^\\d{3}-\\d{2}-\\d{4}$"` | | | `not_matches` | - | Regex not match | `phone not_matches "^\\+1"` | +| **Length** | `length_equals` | - | Length-of-string equality | `code length_equals 4` | +| | `length_greater_than` | - | Length-of-string `>` | `password length_greater_than 7` | +| | `length_less_than` | - | Length-of-string `<` | `nickname length_less_than 20` | | **List** | `in_list` | `in` | List membership | `status in_list ["ACTIVE", "PENDING"]` | | | `not_in_list` | `not_in` | List non-membership | `type not_in_list ["SUSPENDED", "CLOSED"]` | | **Existence** | `exists` | - | Variable existence | `exists guarantorInfo` | @@ -276,29 +449,29 @@ when: - (monthlyIncome is_positive AND annualIncome is_positive) ``` -**NEW: Validation Operators in Expressions** +**Validation Operators in Expressions** -Validation operators can now be used in complex expressions, not just simple conditions: +Validation operators can be used in any expression context, not just `when:` clauses: + ```yaml then: - # Set variables using validation operators in expressions - - set has_valid_contact to (email is_email AND phone is_phone) - - set financial_data_complete to ( - monthlyRevenue is_positive AND - monthlyExpenses is_positive AND - annualIncome is_not_null - ) - - # Calculate boolean results with validation operators - - calculate data_quality_score as ( - (customerName is_not_empty ? 25 : 0) + - (email is_email ? 25 : 0) + - (phone is_phone ? 25 : 0) + - (ssn is_ssn ? 25 : 0) - ) + # Validation operators inside `set`-to-boolean expressions + - set has_valid_contact to (email is_email and phone is_phone) + - set financial_data_complete to (monthlyRevenue is_positive and monthlyExpenses is_positive and annualIncome is_not_null) + + # Score each field independently with the inline `if_else` function, then sum + - run name_score as if_else(customerName is_not_empty, 25, 0) + - run email_score as if_else(email is_email, 25, 0) + - run phone_score as if_else(phone is_phone, 25, 0) + - run ssn_score as if_else(ssn is_ssn, 25, 0) + - calculate data_quality_score as name_score + email_score + phone_score + ssn_score ``` +> **Note:** The engine does not have a C-style ternary `? :` operator; use the +> `if_else(condition, then_value, else_value)` built-in function instead. Both arguments +> are evaluated eagerly (no short-circuit). +
@@ -312,18 +485,23 @@ then: | | `/` | `/` | Division | `expression / expression` | `monthlyDebt / annualIncome` | | | `%` | `%` | Modulo (remainder) | `expression % expression` | `amount % 100` | | | `**` | `**` | Power/Exponentiation | `base ** exponent` | `(1 + rate) ** years` | -| **Arithmetic Actions** | `add` | - | Add to variable | `add value to variable` | `add 10 to base_score` | -| | `subtract` | - | Subtract from variable | `subtract value from variable` | `subtract penalty from total_score` | -| | `multiply` | - | Multiply variable | `multiply variable by value` | `multiply risk_factor by 1.5` | -| | `divide` | - | Divide variable | `divide variable by value` | `divide monthly_payment by 2` | -| **Helper Keywords** | `to` | - | Assignment target | `set variable to value` | `set approval_status to "APPROVED"` | -| | `as` | - | Calculation target | `calculate variable as expression` | `calculate debt_ratio as monthlyDebt / annualIncome` | -| | `with` | - | Function parameters | `call function with [args]` | `call log with ["Message", "INFO"]` | -| | `from` | - | Subtraction source | `subtract value from variable` | `subtract penalty from total_score` | -| | `by` | - | Factor for multiply/divide | `multiply/divide variable by value` | `multiply risk_factor by 1.5` | -| | `and` | - | Range separator | `value between min and max` | `age between 18 and 65` | +| **Arithmetic Actions** | `add` | - | Add value to variable | `add VALUE to VARIABLE` | `add 10 to base_score` | +| | `subtract` | - | Subtract value from variable | `subtract VALUE from VARIABLE` | `subtract penalty from total_score` | +| | `multiply` | - | Multiply target variable by factor | `multiply VALUE by VARIABLE` | `multiply 1.5 by risk_factor` | +| | `divide` | - | Divide target variable by divisor | `divide VALUE by VARIABLE` | `divide 2 by monthly_payment` | +| **Helper Keywords** | `to` | - | Assignment target | `set VARIABLE to VALUE` | `set approval_status to "APPROVED"` | +| | `as` | - | Calculation target | `calculate VARIABLE as EXPRESSION` | `calculate debt_ratio as monthlyDebt / annualIncome` | +| | `with` | - | Function parameters | `call FUNCTION with [args]` | `call log with ["Message", "INFO"]` | +| | `from` | - | Subtraction source | `subtract VALUE from VARIABLE` | `subtract penalty from total_score` | +| | `by` | - | Factor for multiply/divide | `multiply VALUE by VARIABLE` | `multiply 1.5 by risk_factor` | +| | `and` | - | Range separator | `VALUE between MIN and MAX` | `age between 18 and 65` | + +> **Grammar peculiarity for `multiply` / `divide`:** the value comes *first*, then the variable. +> All four arithmetic actions follow the same shape: ` `. +> Read `multiply 1.5 by risk_factor` as "apply ×1.5 to `risk_factor`". **Arithmetic Expression Examples:** + ```yaml then: # Basic arithmetic in expressions @@ -333,10 +511,11 @@ then: - calculate remainder as loanAmount % 1000 # Arithmetic actions (modify existing variables) + # Grammar: - add 50 to credit_score - subtract late_fee from account_balance - - multiply risk_score by 1.2 - - divide monthly_payment by 2 + - multiply 1.2 by risk_score + - divide 2 by monthly_payment # Complex expressions - calculate debt_to_income as (monthlyDebt + proposedPayment) / (annualIncome / 12) @@ -1017,19 +1196,35 @@ conditions: - run uppercase as upper(name) - run lowercase as lower(email) - run trimmed as trim(input_text) -- calculate length as length(description) +- run name_length as length(description) # Date/time functions -- calculate current_date as now() -- calculate formatted_date as format_date(date_value, "yyyy-MM-dd") -- calculate age_years as calculate_age(birth_date) - -# Validation functions -- calculate is_valid_email as validate_email(email_address) -- calculate is_valid_phone as validate_phone(phone_number) -- calculate is_business_day as is_business_day(date_value) +- run current_date as now() +- run today_date as today() +- run formatted_date as format_date(date_value, "yyyy-MM-dd") +- run pretty_date as format_date(date_value, "dd MMM yyyy") +- run age_years as calculate_age(birth_date) # from today +- run age_at_event as calculate_age(birth_date, event_date) +- run plus_thirty as dateadd(today_date, 30, "days") +- run days_between as datediff(start_date, end_date, "days") + +# Validation functions (function-call form complements the `is_email`/`is_phone` operators) +- run email_ok as validate_email(email_address) +- run phone_ok as validate_phone(phone_number) +- run is_business_day_today as is_business_day(today_date) +- run any_check as is_valid(value, "email") # 12 known types; unknown -> error + +# Null-handling & conditional helpers (DSL primitives) +- run preferred_name as coalesce(nickname, full_name, "Anonymous") # first non-null wins +- run tier as if_else(creditScore at_least 750, "PRIME", "STANDARD") # inline ternary +- run within_window as is_in_range(score, 600, 850) # function form of `between` ``` +> **Important:** Function calls and REST/JSON expressions are only legal in `run` actions and in +> expression contexts (function arguments, conditions, output mappings). The `calculate` action +> is restricted to pure mathematical expressions (`+ - * / % **`) on numeric inputs -- +> attempting to use a function call inside `calculate` raises a clean validation error. + ### REST Call Expressions ```yaml @@ -1042,12 +1237,18 @@ conditions: - run validation_result as rest_post("https://validator.com/check", {"email": email, "phone": phone}) # PUT requests with headers -- calculate update_result as rest_put("https://api.example.com/users/123", user_data, {"Authorization": "Bearer " + token}) +- run update_result as rest_put("https://api.example.com/users/123", user_data, {"Authorization": "Bearer " + token}) # DELETE requests -- calculate delete_result as rest_delete("https://api.example.com/records/" + record_id) +- run delete_result as rest_delete("https://api.example.com/records/" + record_id) ``` +> **REST error contract:** On HTTP failure (non-2xx, network error, DNS, timeout), the REST +> functions return a structured map: `{success: false, error: true, message: "
"}`. +> Rules can branch on `response.success` to handle errors gracefully. This is intentional +> "chain-friendly" behaviour and is the only place in the engine where a failure does not +> raise an exception; everywhere else, errors propagate as `success=false` on the rule result. + ### JSON Path Expressions ```yaml @@ -1092,6 +1293,19 @@ conditions: - run power as pow(base, exponent) - run square_root as sqrt(16) +# Advanced math (added 26.05.08) +- run e_value as exp(1) # e^x +- run ln_value as ln(2.718) # natural log +- run log10_value as log10(1000) # base-10 log +- run sin_value as sin(0) # radians +- run cos_value as cos(0) +- run tan_value as tan(0) +- run angle as atan2(1, 1) # two-argument arc tangent + +# Hashing (cryptographic digests) +- run sig as hash("payload") # SHA-256, hex-encoded +- run md5 as hash("payload", "MD5") # also SHA-1, SHA-512 + # Statistical functions - run average as avg(score1, score2, score3) # Also: average - run sum as sum(amount1, amount2, amount3) @@ -1106,91 +1320,150 @@ conditions: # String manipulation - run trimmed as trim(" hello ") -- calculate length as length("hello") # Also: len -- calculate substring as substring("hello", 1, 3) # Also: substr -- calculate contains_check as contains("hello", "ell") -- calculate starts_check as startswith("hello", "he") -- calculate ends_check as endswith("hello", "lo") -- calculate replaced as replace("hello", "l", "x") +- run name_length as length("hello") # Also: len +- run substring as substring("hello", 1, 3) # Also: substr +- run contains_check as contains("hello", "ell") +- run starts_check as startswith("hello", "he") +- run ends_check as endswith("hello", "lo") +- run replaced as replace("hello", "l", "x") + +# Templated formatting: {0}, {1}, ... substitute extra args by index. +# Wrap the whole action in YAML quotes if the template contains `: ` (colon-space). +- run greeting as format("Hello, {0}!", customerName) +- 'run msg as format("Score {0} / {1} (decision {2})", score, maxScore, decision)' + +# String concatenation of N args (returns the joined string) +- run id as concat(prefix, "-", customerId, "-", suffix) ``` ### Financial Functions ```yaml # Loan and interest calculations -- calculate monthly_payment as calculate_loan_payment(principal, annual_rate, term_months) -- calculate compound_interest as calculate_compound_interest(principal, rate, time) -- calculate amortization as calculate_amortization(principal, rate, term) -- calculate apr as calculate_apr(loan_amount, fees, monthly_payment, term) +- run monthly_payment as calculate_loan_payment(principal, annual_rate, term_months) +- run compound_interest as calculate_compound_interest(principal, rate, time) +- run amortization as calculate_amortization(principal, rate, term) +- run apr as calculate_apr(loan_amount, fees, monthly_payment, term) # Financial ratios and metrics -- calculate debt_ratio as debt_to_income_ratio(monthly_debt, monthly_income) -- calculate credit_util as credit_utilization(used_credit, total_credit) -- calculate ltv as loan_to_value(loan_amount, property_value) -- calculate debt_ratio_alt as calculate_debt_ratio(total_debt, total_income) -- calculate ltv_alt as calculate_ltv(loan_amount, property_value) +- run debt_ratio as debt_to_income_ratio(monthly_debt, monthly_income) +- run credit_util as credit_utilization(used_credit, total_credit) +- run ltv as loan_to_value(loan_amount, property_value) +- run debt_ratio_alt as calculate_debt_ratio(total_debt, total_income) +- run ltv_alt as calculate_ltv(loan_amount, property_value) # Credit and risk scoring -- calculate credit_score as calculate_credit_score(payment_history, utilization, length, types, inquiries) -- calculate risk_score as calculate_risk_score(credit_score, income, debt_ratio) -- calculate payment_score as payment_history_score(payment_data) +- run credit_score as calculate_credit_score(payment_history, utilization, length, types, inquiries) +- run risk_score as calculate_risk_score(credit_score, income, debt_ratio) +- run payment_score as payment_history_score(payment_data) # Utility functions - run formatted_amount as format_currency(1234.56) -- calculate formatted_percent as format_percentage(0.15) -- calculate account_num as generate_account_number() -- calculate transaction_id as generate_transaction_id() +- run formatted_percent as format_percentage(0.15) +- run account_num as generate_account_number() +- run transaction_id as generate_transaction_id() ``` ### Date/Time Functions ```yaml # Current date/time -- calculate current_timestamp as now() -- calculate current_date as today() - -# Date calculations -- calculate date_plus as dateadd(date_value, amount, "days") # Also supports "months", "years" -- calculate date_difference as datediff(start_date, end_date, "days") -- calculate hour_value as time_hour(timestamp) - -# Date validation -- calculate is_business_day as is_business_day(date_value) -- calculate age_check as age_meets_requirement(birth_date, min_age) +- run current_timestamp as now() +- run current_date as today() +- run iso_now as current_iso() # Also: now_iso() -- ISO-8601 with offset + +# Date arithmetic +- run date_plus as dateadd(date_value, amount, "days") # Also: "months", "years", "weeks" +- run date_difference as datediff(start_date, end_date, "days") +- run hour_value as time_hour(timestamp) + +# Date field extractors (numeric output) +- run year_num as year_of(date_value) # e.g. 2026 +- run month_num as month_of(date_value) # 1..12 +- run dom as day_of_month(date_value) # 1..31 +- run dow as day_of_week(date_value) # ISO: Monday=1 ... Sunday=7 + +# Date validation / age +- run is_business_day_check as is_business_day(date_value) +- run age_check as age_meets_requirement(birth_date, min_age) +- run formatted as format_date(date_value, "yyyy-MM-dd") ``` ### List Functions ```yaml -# List operations -- calculate list_size as size(my_list) # Also: count +# Basic aggregates +- run list_size as size(my_list) # Also: count - run list_sum as sum(number_list) -- run list_average as avg(number_list) # Also: average -- calculate first_item as first(my_list) -- calculate last_item as last(my_list) +- run list_average as avg(number_list) # Also: average +- run first_item as first(my_list) +- run last_item as last(my_list) + +# Ordering / dedup +- run sorted_nums as sort(my_list) # ascending; numeric or Comparable items +- run reversed_nums as reverse(my_list) +- run unique_items as distinct(my_list) # de-dupe, preserving insertion order +``` + +### Higher-Order List Functions (by named function) + +The DSL has no inline-lambda syntax; `filter` / `map` / `reduce` / `find` take the +predicate or transformer as a **string function name**. The named function is resolved +through the same lookup the evaluator uses for any function call -- +[`CustomFunctionRegistry`](#custom-functions-extension-point) first, then the built-in +catalogue -- so both engine built-ins and user-registered Spring beans work +identically. + +```yaml +# filter(list, function_name): keep items where the named predicate is truthy +- run large_txns as filter(transactions, "is_above_threshold") + +# map(list, function_name): transform every item +- run with_fees as map(transactions, "add_fee") + +# reduce(list, initial, function_name): accumulate left-to-right +# The reducer is called as fn(accumulator, item) for each item. +- run total as reduce(transactions, 0, "add_two") + +# find(list, function_name): first matching item, or null if none +- run first_negative as find(balances, "is_negative_value") +``` + +> **Tip:** Register a one-arg `RuleFunction` from Java to act as the predicate / +> transformer. For numeric predicates the engine already has `is_positive`, +> `is_negative`, `is_zero`, `is_email`, `is_phone`, etc. -- those are reachable by +> name too. + +### Statistical Aggregates + +```yaml +- run mid as median(values) # numeric median (mean of middle two on even length) +- run spread as stddev(values) # sample standard deviation (n-1 denominator) +- run var as variance(values) # sample variance +- run p95 as percentile(values, 95) # linear-interpolation percentile (p in [0,100]) ``` ### Type Conversion Functions ```yaml # Type conversions -- calculate as_number as tonumber("123.45") # Also: number -- calculate as_string as tostring(123) # Also: string -- calculate as_boolean as toboolean("true") # Also: boolean +- run as_number as tonumber("123.45") # Also: number +- run as_string as tostring(123) # Also: string +- run as_boolean as toboolean("true") # Also: boolean ``` ### Validation Functions ```yaml # Financial validation -- calculate is_valid_score as is_valid_credit_score(750) -- calculate is_valid_ssn as is_valid_ssn("123-45-6789") -- calculate is_valid_account as is_valid_account("1234567890") -- calculate is_valid_routing as is_valid_routing("021000021") +- run is_valid_score as is_valid_credit_score(750) +- run is_valid_ssn as is_valid_ssn("123-45-6789") +- run is_valid_account as is_valid_account("1234567890") +- run is_valid_routing as is_valid_routing("021000021") # General validation -- calculate is_valid_data as is_valid(value, criteria) -- calculate in_range_check as in_range(value, min, max) +- run is_valid_data as is_valid(value, "email") +- run in_range_check as in_range(value, min, max) ``` ### REST API Functions @@ -1199,10 +1472,10 @@ conditions: # HTTP methods (all actually implemented) - run get_response as rest_get(url) - run post_response as rest_post(url, body) -- calculate put_response as rest_put(url, body, headers) -- calculate delete_response as rest_delete(url, headers) -- calculate patch_response as rest_patch(url, body, headers) -- calculate api_response as rest_call(method, url, body, headers) +- run put_response as rest_put(url, body, headers) +- run delete_response as rest_delete(url, headers) +- run patch_response as rest_patch(url, body, headers) +- run api_response as rest_call(method, url, body, headers) ``` ### JSON Functions @@ -1211,23 +1484,37 @@ conditions: # JSON path operations (all actually implemented) - run value as json_get(json_object, "path.to.property") # Also: json_path - run exists as json_exists(json_object, "optional.property") -- calculate size as json_size(json_object, "array_property") -- calculate type as json_type(json_object, "property") +- run size as json_size(json_object, "array_property") +- run type as json_type(json_object, "property") ``` ### Utility Functions ```yaml # Distance and location -- calculate distance as distance_between(lat1, lon1, lat2, lon2) +- run distance as distance_between(lat1, lon1, lat2, lon2) # Data security -- calculate encrypted as encrypt(data, key) -- calculate decrypted as decrypt(encrypted_data, key) -- calculate masked as mask_data(sensitive_data, mask_pattern) +- run encrypted as encrypt(data, key) +- run decrypted as decrypt(encrypted_data, key) +- run masked as mask_data(sensitive_data, mask_pattern) # Advanced financial calculations -- calculate payment_schedule as calculate_payment_schedule(principal, rate, term) +- run payment_schedule as calculate_payment_schedule(principal, rate, term) +``` + +### Null-handling, Conditional, and Range Helpers + +```yaml +# coalesce: first non-null wins (NULL-coalescing default) +- run preferred_name as coalesce(nickname, full_name, "Anonymous") + +# if_else: inline ternary expression (avoids a full `if/then/else` action block) +- run tier as if_else(creditScore at_least 750, "PRIME", "STANDARD") +- run discount as if_else(membership equals "GOLD", 0.20, 0.05) + +# is_in_range: function form of the `between` operator (inclusive both ends) +- run score_band_ok as is_in_range(score, 600, 850) ``` ### Logging and Audit Functions @@ -1237,22 +1524,176 @@ conditions: - call audit with ["Decision made", "AUDIT"] - call audit_log with ["Rule executed", "TRACE"] - call send_notification with ["recipient", "message"] + +# First-class logging action -- routes through SLF4J at the named level +- run echoed as log("Rule fired for applicant " + applicantId, "INFO") +- call log with ["debug snapshot", "DEBUG"] # action-context invocation ``` +Supported levels (case-insensitive): `TRACE`, `DEBUG`, `INFO` (default), `WARN`, `ERROR`. The function returns its message so it can be chained inside expressions. + +### Rule Composition -- the `invoke_rule` Function + +`invoke_rule(code, ...)` evaluates another stored rule by code and returns its output map. Inputs are passed as **alternating "key", value pairs** trailing the rule code -- this avoids the YAML/JSON `{}` flow-mapping ambiguity that bites authors who try to write inline maps in action lines. + +```yaml +then: + # No inputs + - run health as invoke_rule("system_health_check") + + # Two-argument form (only when the second argument is already a Map in context) + - run score as invoke_rule("scoring_rule", existing_input_map) + + # Alternating-pairs form (recommended for inline literals) + - run underwriting as invoke_rule("composite_underwriting", + "creditScore", creditScore, + "annualIncome", annualIncome, + "existingDebt", existingDebt) + - set tier to underwriting.tier + - set approved to underwriting.approved +``` + +The nested rule evaluation is synchronous (blocking on the engine's `boundedElastic` worker). If the invoked rule fails to parse, the rule code does not exist, or the nested evaluation reports `success=false`, `invoke_rule` raises an error that propagates as a failed result of the outer rule -- consistent with the fail-loud contract. + +> ⚠️ `invoke_rule` requires a `RuleInvoker` bean. The default Spring auto-configuration wires `RuleInvokerImpl` (backed by `RuleDefinitionService`) automatically; outside Spring you can supply your own implementation. + +### Custom Functions (Extension Point) + +Register your own functions in a Spring `@Bean` and call them from any rule: + +```java +@Configuration +class MyRulesConfig { + @Bean + CommandLineRunner registerCustomFunctions(CustomFunctionRegistry registry) { + return args -> { + registry.register("regional_risk", a -> + Set.of("CA", "NY").contains(a[0]) ? 10 : 0); + registry.register("fraud_score", a -> + fraudService.score(String.valueOf(a[0]))); + }; + } +} +``` + +```yaml +# Then use them like any built-in function: +when: + - fraud_score(applicantId) at_most MAX_FRAUD_SCORE +then: + - run risk_bump as regional_risk(region) + - run is_clean as fraud_score(applicantId) less_than 50 +``` + +**Resolution order:** Custom functions are checked **before** the built-in catalog -- if you +register a function with the same name as a built-in (e.g., `max`), your function wins. +Names are matched case-insensitively. The same registered function is reachable from both +expression contexts (`run` / `calculate` arg / condition) and action contexts (`call`). + --- ## Advanced Features -### Circuit Breaker Configuration +### Circuit Breaker -- the `circuit_breaker` Action + +The DSL has no top-level `circuit_breaker:` config block. Resilience and early +termination are expressed as an **action** inside a rule's `then:` block: + ```yaml -circuit_breaker: - enabled: true - failure_threshold: 5 - timeout_duration: "30s" - recovery_timeout: "60s" +then: + - if risk_score at_least 90 then circuit_breaker "HIGH_RISK_DETECTED" + - set processing_status to "OK" # never executes if the previous action triggered ``` +When the action fires, the engine stops the rule cleanly. The result reports +`success=true` with `circuitBreakerTriggered=true` and the message above; any +already-set variables remain in the output, but no subsequent actions run. + +### Decision Tables (DMN-style) + +A `decision_table:` block expresses a multi-row decision as a table of input +predicates and output assignments. This is the most concise way to encode rules +that boil down to "look at columns X, Y, Z; return outputs A, B" -- the same shape +that drools/DMN solve. + + +```yaml +name: "Auto Insurance Premium Table" +description: "Tier and rate by credit and age" + +inputs: + creditScore: number + age: number + +decision_table: + inputs: [creditScore, age] + outputs: [tier, rate] + hit_policy: FIRST + rules: + - when: + - creditScore at_least 750 + - age between 25 and 65 + then: + tier: "PRIME" + rate: 3.0 + - when: + - creditScore at_least 650 + then: + tier: "PREFERRED" + rate: 5.0 + - otherwise: true + then: + tier: "STANDARD" + rate: 9.0 + +output: + tier: tier + rate: rate +``` + +**Hit policies** -- how the engine picks which rows contribute: + +| Policy | Behavior | +|----------|-------------------------------------------------------------------------------------| +| `FIRST` | First matching row wins. Default. | +| `ANY` | Any matching row's outputs apply; the engine uses the first match. | +| `UNIQUE` | Exactly one row must match. Multiple matches -> rule fails with a clean diagnostic. | +| `COLLECT`| Each output column is collected into a list of values from every matching row. | + +**Output values**: numbers, booleans, lists, and maps pass through unchanged. Strings are taken as literals by default. Prefix a string with `=` to mark it as a DSL expression evaluated against the current context: + + +```yaml +then: + tier: "PRIME" # literal string + rate: 3.0 # literal number + computed_premium: "= basePremium * 1.5" # expression -- result of basePremium * 1.5 + band: "= if_else(score at_least 700, \"HIGH\", \"LOW\")" +``` + +This rule shape is mutually exclusive with `when:/then:`, `conditions:`, and `rules:` at the same level. If `decision_table:` is present it takes precedence. + +### Per-Rule Timeout + +Declare an upper bound on a rule's wall-clock runtime to protect callers from +runaway loops, slow REST calls, or pathological data: + + +```yaml +name: "Risk Assessment" +timeout: 5s # also accepts "500ms" or a raw number of milliseconds +when: + - creditScore at_least 600 +then: + - run report as rest_get("https://slow.example.com/risk") + - set assessed to true +``` + +Exceeding the timeout fails the rule cleanly: `success=false` with an error like +`Rule 'Risk Assessment' exceeded its declared timeout of 5000ms`. No partial outputs +escape; the engine relies on Reactor's `Mono.timeout()` to cancel the work. + ### Metadata and Versioning ```yaml @@ -1432,12 +1873,12 @@ then: - if has_address equals true then run zip_code as json_get(customer_data, "addressInfo.zipCode") # Validation if required - - if requiresValidation equals true then calculate email_valid as validate_email(customer_email) - - if requiresValidation equals true then calculate phone_valid as validate_phone(customer_phone) + - if requiresValidation equals true then run email_valid as validate_email(customer_email) + - if requiresValidation equals true then run phone_valid as validate_phone(customer_phone) # Set processing status - set data_enrichment_complete to true - - calculate processing_timestamp as now() + - run processing_timestamp as now() else: - set data_enrichment_complete to false @@ -1502,7 +1943,7 @@ rules: - loan_to_income_ratio less_than 5.0 then: - set risk_assessment to "LOW" - - calculate estimated_monthly_payment as calculate_loan_payment(loanAmount, 0.05, loanTerm) + - run estimated_monthly_payment as calculate_loan_payment(loanAmount, 0.05, loanTerm) - set pre_approval_status to "APPROVED" else: - set risk_assessment to "HIGH" @@ -1513,11 +1954,11 @@ rules: - pre_approval_status equals "APPROVED" then: - set final_status to "APPROVED" - - calculate approval_timestamp as now() - - call log with ["Loan approved for amount: " + loanAmount, "INFO"] + - run approval_timestamp as now() + - 'call log with ["Loan approved for amount: " + loanAmount, "INFO"]' else: - set final_status to "DECLINED" - - call log with ["Loan declined - " + rejection_reason, "INFO"] + - 'call log with ["Loan declined - " + rejection_reason, "INFO"]' output: validation_stage_1: text @@ -1533,11 +1974,18 @@ output: rejection_reason: text ``` -### Example 4: Advanced Validation with Complex Boolean Expressions (NEW) +### Example 4: Advanced Validation with Complex Boolean Expressions + +This example exercises: + +- **Validation operators in `set ... to (...)` expressions** (`is_email`, `is_phone`, `is_credit_score`, `is_positive`, `is_not_null`, `is_not_empty`) +- **Multi-line boolean composition** with `and`/`or` (lower-case keywords are canonical; `AND`/`OR` are accepted as case-insensitive aliases) +- **`if_else(condition, then, else)`** as the inline-ternary replacement -- the DSL does **not** support C-style `? :` +- **Sub-rules with shared state** -- variables set in earlier rules are visible to later ones ```yaml name: "B2B Credit Scoring with Enhanced Validation" -description: "Demonstrates new validation operators in complex expressions" +description: "Demonstrates validation operators in complex expressions" version: "2.1.0" inputs: @@ -1564,42 +2012,18 @@ rules: - exists monthlyRevenue - exists creditScore then: - # Complex boolean expressions with validation operators - - set has_complete_financial_data to ( - monthlyRevenue is_positive AND - monthlyExpenses is_positive AND - existingDebt is_not_null AND - monthlyDebtPayments is_positive AND - verifiedAnnualRevenue is_positive - ) - - - set has_valid_contact_info to ( - customerName is_not_empty AND - email is_email AND - phone is_phone AND - ssn is_ssn - ) - - - set has_valid_credit_data to ( - creditScore is_credit_score AND - creditScore >= MIN_BUSINESS_CREDIT_SCORE - ) + - set has_complete_financial_data to (monthlyRevenue is_positive and monthlyExpenses is_positive and existingDebt is_not_null and monthlyDebtPayments is_positive and verifiedAnnualRevenue is_positive) + - set has_valid_contact_info to (customerName is_not_empty and email is_email and phone is_phone and ssn is_ssn) + - set has_valid_credit_data to (creditScore is_credit_score and creditScore >= MIN_BUSINESS_CREDIT_SCORE) - name: "Financial Analysis" when: - has_complete_financial_data equals true - has_valid_credit_data equals true then: - # Multi-line validation expressions - - set meets_credit_requirements to ( - creditScore is_credit_score AND - creditScore >= MIN_BUSINESS_CREDIT_SCORE AND - (creditScore >= EXCELLENT_CREDIT_THRESHOLD OR verifiedAnnualRevenue >= 500000) - ) - + - set meets_credit_requirements to (creditScore is_credit_score and creditScore >= MIN_BUSINESS_CREDIT_SCORE and (creditScore >= EXCELLENT_CREDIT_THRESHOLD or verifiedAnnualRevenue >= 500000)) - calculate debt_to_income_ratio as existingDebt / verifiedAnnualRevenue - calculate monthly_cash_flow as monthlyRevenue - monthlyExpenses - monthlyDebtPayments - - set has_positive_cash_flow to (monthly_cash_flow is_positive) - name: "Final Decision" @@ -1609,11 +2033,11 @@ rules: - has_positive_cash_flow equals true then: - set final_decision to "APPROVED" - - calculate approval_score as ( - (creditScore >= EXCELLENT_CREDIT_THRESHOLD ? 40 : 20) + - (monthly_cash_flow >= 10000 ? 30 : 15) + - (debt_to_income_ratio <= 0.3 ? 30 : 10) - ) + # Score each factor with if_else() (no C-style ternary), then sum. + - run credit_score_pts as if_else(creditScore >= EXCELLENT_CREDIT_THRESHOLD, 40, 20) + - run cash_flow_pts as if_else(monthly_cash_flow >= 10000, 30, 15) + - run dti_pts as if_else(debt_to_income_ratio <= 0.3, 30, 10) + - calculate approval_score as credit_score_pts + cash_flow_pts + dti_pts else: - set final_decision to "DECLINED" - set decline_reasons to [] @@ -1682,6 +2106,30 @@ output: - Validation operators in conditional expressions - Mixed validation and comparison operators in complex conditions +### Version 26.05 - Fail-Loud Error Contract & New Primitives + +- **New primitives:** `coalesce(...)`, `if_else(cond, then, else)`, `is_in_range(value, low, high)`. +- **New built-ins:** `calculate_age(birth[, asOf])`, `format_date(date[, pattern])`, `validate_email(value)`, `validate_phone(value)` (function-call form complements existing `is_email`/`is_phone` operators). +- **Extension point:** `CustomFunctionRegistry` Spring bean lets applications register their own `RuleFunction` implementations callable from rules. +- **Error contract:** the engine now fails loud by design rather than silently swallowing errors. See the table below. +- **Sub-rule action parity:** sub-rules under `rules:` now accept the same map-shaped actions as the top level (e.g., YAML-collapsed `- forEach x in xs: ...`). + +#### Error Behavior Reference + +| Situation | Old (pre-26.05) | New | +| -------------------------------------------- | ------------------------------ | -------------------------------------------------------------------- | +| Unknown function name | `log.warn` + null | `IllegalArgumentException` -> rule reports `success=false` | +| Non-numeric string in arithmetic | silently coerced to ZERO | `IllegalArgumentException` naming the operand | +| Bad regex pattern in `matches` | `false` | `IllegalArgumentException` naming the pattern | +| Missing bean property | `log.warn` + null | `IllegalArgumentException` naming class + property (maps still get null on missing key) | +| Unknown `is_valid(value, type)` type | `false` | `IllegalArgumentException` listing supported types | +| Unknown `dateadd`/`datediff` unit | `log.warn` + null | `IllegalArgumentException` listing supported units | +| Action throws during execution | logged + next action runs | Rule reports `success=false` with action index + cause | +| Condition throws during evaluation | silently flips to else branch | Rule reports `success=false` with the real cause | +| `circuit_breaker` action triggered | (unchanged) | Rule reports `success=true` with `circuitBreakerTriggered=true` | +| REST function HTTP failure | structured error map (unchanged) | Structured error map (unchanged -- intentional chain-friendly form) | +| `set var to null` (e.g., `json_get` missing) | NPE caught silently | Variable stored as null; rule succeeds | + --- --- diff --git a/fireflyframework-rule-engine-core/pom.xml b/fireflyframework-rule-engine-core/pom.xml index 190664d..3eb2063 100644 --- a/fireflyframework-rule-engine-core/pom.xml +++ b/fireflyframework-rule-engine-core/pom.xml @@ -63,12 +63,6 @@ provided - - - org.apache.commons - commons-math3 - - org.threeten diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/config/DatabaseConfig.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/config/DatabaseConfig.java index 09abda5..4704468 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/config/DatabaseConfig.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/config/DatabaseConfig.java @@ -136,29 +136,6 @@ public ConnectionFactory connectionFactory() { return connectionPool; } - // Health indicator removed - requires actuator dependency - // TODO: Add back when actuator is available - /* - @Bean - public HealthIndicator connectionPoolHealthIndicator() { - return () -> { - try { - return Health.up() - .withDetail("pool.initialSize", initialSize) - .withDetail("pool.maxSize", maxSize) - .withDetail("pool.minIdle", minIdle) - .withDetail("pool.maxIdleTime", maxIdleTime.toString()) - .withDetail("pool.maxAcquireTime", maxAcquireTime.toString()) - .build(); - } catch (Exception e) { - return Health.down() - .withDetail("error", e.getMessage()) - .build(); - } - }; - } - */ - /** * Scheduled task to log connection pool statistics. * Helps monitor pool performance and identify potential issues. diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/ASTVisitor.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/ASTVisitor.java index 9a0a2fc..199f083 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/ASTVisitor.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/ASTVisitor.java @@ -39,17 +39,13 @@ public interface ASTVisitor { T visitVariableExpression(VariableExpression node); T visitLiteralExpression(LiteralExpression node); T visitFunctionCallExpression(FunctionCallExpression node); - T visitArithmeticExpression(ArithmeticExpression node); - T visitJsonPathExpression(JsonPathExpression node); - T visitRestCallExpression(RestCallExpression node); - + // Condition visitors T visitComparisonCondition(ComparisonCondition node); T visitLogicalCondition(LogicalCondition node); T visitExpressionCondition(ExpressionCondition node); - + // Action visitors - T visitAssignmentAction(AssignmentAction node); T visitFunctionCallAction(FunctionCallAction node); T visitConditionalAction(ConditionalAction node); T visitCalculateAction(CalculateAction node); diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/action/AssignmentAction.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/action/AssignmentAction.java deleted file mode 100644 index 502688a..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/action/AssignmentAction.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.action; - -import org.fireflyframework.rules.core.dsl.ASTVisitor; -import org.fireflyframework.rules.core.dsl.SourceLocation; -import org.fireflyframework.rules.core.dsl.expression.Expression; -import lombok.Data; -import lombok.EqualsAndHashCode; - -/** - * Represents a variable assignment action. - * Examples: set result to "approved", assign score to calculateScore(customer) - */ -@Data -@EqualsAndHashCode(callSuper = true) -public class AssignmentAction extends Action { - - /** - * Name of the variable to assign to - */ - private String variableName; - - /** - * Expression to evaluate and assign to the variable - */ - private Expression value; - - /** - * Assignment operator type - */ - private AssignmentOperator operator; - - public AssignmentAction(SourceLocation location, String variableName, Expression value) { - super(location); - this.variableName = variableName; - this.value = value; - this.operator = AssignmentOperator.ASSIGN; - } - - public AssignmentAction(SourceLocation location, String variableName, Expression value, AssignmentOperator operator) { - super(location); - this.variableName = variableName; - this.value = value; - this.operator = operator; - } - - @Override - public T accept(ASTVisitor visitor) { - return visitor.visitAssignmentAction(this); - } - - @Override - public boolean hasVariableReferences() { - return value.hasVariableReferences(); - } - - @Override - public String toDebugString() { - return String.format("%s %s %s", variableName, operator.getSymbol(), value.toDebugString()); - } -} - - - diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/action/AssignmentOperator.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/action/AssignmentOperator.java deleted file mode 100644 index 17ca124..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/action/AssignmentOperator.java +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.action; - -/** - * Enumeration of assignment operators. - */ -public enum AssignmentOperator { - ASSIGN("to", "="), - ADD_ASSIGN("add", "+="), - SUBTRACT_ASSIGN("subtract", "-="), - MULTIPLY_ASSIGN("multiply", "*="), - DIVIDE_ASSIGN("divide", "/="); - - private final String keyword; - private final String symbol; - - AssignmentOperator(String keyword, String symbol) { - this.keyword = keyword; - this.symbol = symbol; - } - - public String getKeyword() { - return keyword; - } - - public String getSymbol() { - return symbol; - } - - public static AssignmentOperator fromKeyword(String keyword) { - for (AssignmentOperator op : values()) { - if (op.keyword.equals(keyword)) { - return op; - } - } - throw new IllegalArgumentException("Unknown assignment operator: " + keyword); - } - - public static AssignmentOperator fromSymbol(String symbol) { - for (AssignmentOperator op : values()) { - if (symbol.equals(op.symbol)) { - return op; - } - } - throw new IllegalArgumentException("Unknown assignment operator symbol: " + symbol); - } -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCodeGenerator.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCodeGenerator.java deleted file mode 100644 index b801255..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCodeGenerator.java +++ /dev/null @@ -1,1335 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.compiler; - -import org.fireflyframework.rules.core.dsl.ASTVisitor; -import org.fireflyframework.rules.core.dsl.action.*; -import org.fireflyframework.rules.core.dsl.condition.*; -import org.fireflyframework.rules.core.dsl.expression.*; -import org.fireflyframework.rules.core.dsl.model.ASTRulesDSL; -import org.fireflyframework.rules.core.services.ConstantService; -import org.fireflyframework.rules.interfaces.dtos.crud.ConstantDTO; -import org.fireflyframework.rules.interfaces.enums.ValueType; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; - -import java.time.OffsetDateTime; -import java.time.format.DateTimeFormatter; -import java.util.List; -import java.util.Map; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Set; -import java.util.HashSet; -import java.util.stream.Collectors; - -/** - * Complete Python code generator that compiles AST nodes to executable Python code. - * This visitor traverses the entire AST and generates equivalent Python functions - * that can be executed independently of the Java runtime. - */ -@Component -@Slf4j -public class PythonCodeGenerator implements ASTVisitor { - - @Autowired - private ConstantService constantService; - - private static final String PYTHON_RUNTIME_IMPORT = "from firefly_runtime import *"; - - // Setter for testing purposes - public void setConstantService(ConstantService constantService) { - this.constantService = constantService; - } - private static final String CONTEXT_VAR = "context"; - private static final ThreadLocal indentLevel = ThreadLocal.withInitial(() -> 0); - - /** - * Generate complete Python code for a rule DSL - */ - public String generatePythonFunction(ASTRulesDSL rule) { - return generatePythonFunction(rule, null); - } - - /** - * Generate complete Python code for a rule DSL with custom function name - */ - public String generatePythonFunction(ASTRulesDSL rule, String functionName) { - log.info("Generating Python code for rule '{}'", rule.getName()); - - // Reset indent level for thread safety - indentLevel.set(0); - - StringBuilder code = new StringBuilder(); - - // Add imports and setup - code.append(generateHeader(rule)); - code.append("\n\n"); - - // Generate main function - code.append(generateMainFunction(rule, functionName)); - - // Generate helper functions if needed - code.append(generateHelperFunctions(rule)); - - // Generate interactive main section - code.append(generateInteractiveMain(rule, functionName)); - - String pythonCode = code.toString(); - log.debug("Generated Python code:\n{}", pythonCode); - - return pythonCode; - } - - private String generateHeader(ASTRulesDSL rule) { - StringBuilder header = new StringBuilder(); - header.append("#!/usr/bin/env python3\n"); - header.append("# -*- coding: utf-8 -*-\n"); - header.append("#\n"); - header.append("# Copyright 2024-2026 Firefly Software Foundation\n"); - header.append("#\n"); - header.append("# Licensed under the Apache License, Version 2.0 (the \"License\");\n"); - header.append("# you may not use this file except in compliance with the License.\n"); - header.append("# You may obtain a copy of the License at\n"); - header.append("#\n"); - header.append("# http://www.apache.org/licenses/LICENSE-2.0\n"); - header.append("#\n"); - header.append("# Unless required by applicable law or agreed to in writing, software\n"); - header.append("# distributed under the License is distributed on an \"AS IS\" BASIS,\n"); - header.append("# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"); - header.append("# See the License for the specific language governing permissions and\n"); - header.append("# limitations under the License.\n"); - header.append("#\n"); - header.append("# Generated by Firefly Rule Engine Python Compiler\n"); - header.append("# Made with ❤️ by Firefly Software Foundation\n"); - header.append("# Compilation Date: ").append(OffsetDateTime.now().format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)).append("\n"); - header.append("#\n"); - header.append("# Rule: ").append(sanitizeComment(rule.getName())).append("\n"); - if (rule.getDescription() != null) { - header.append("# Description: ").append(sanitizeComment(rule.getDescription())).append("\n"); - } - if (rule.getVersion() != null) { - header.append("# Version: ").append(rule.getVersion()).append("\n"); - } - header.append("#\n"); - header.append("\n"); - header.append(PYTHON_RUNTIME_IMPORT).append("\n"); - return header.toString(); - } - - private String generateMainFunction(ASTRulesDSL rule) { - return generateMainFunction(rule, null); - } - - private String generateMainFunction(ASTRulesDSL rule, String functionName) { - StringBuilder func = new StringBuilder(); - - // Function signature - String finalFunctionName = functionName != null ? - sanitizeFunctionName(functionName) : - sanitizeFunctionName(rule.getName()); - func.append("def ").append(finalFunctionName).append("("); - func.append(CONTEXT_VAR).append("):\n"); - - incrementIndent(); - - // Function docstring - func.append(indent()).append('\"').append('\"').append('\"').append("\n"); - func.append(indent()).append("Rule: ").append(rule.getName()).append("\n"); - if (rule.getDescription() != null) { - func.append(indent()).append(rule.getDescription()).append("\n"); - } - func.append(indent()).append("\n"); - func.append(indent()).append("Args:\n"); - func.append(indent()).append(" context (dict): Execution context with input variables\n"); - func.append(indent()).append("\n"); - func.append(indent()).append("Returns:\n"); - func.append(indent()).append(" dict: Output variables\n"); - func.append(indent()).append('\"').append('\"').append('\"').append("\n"); - - // Initialize constants if any - if (rule.getConstants() != null && !rule.getConstants().isEmpty()) { - func.append(generateConstantsInitialization(rule.getConstants())); - } - - // Generate rule logic - if (rule.isSimpleSyntax()) { - func.append(generateSimpleSyntaxLogic(rule)); - } else if (rule.getRules() != null && !rule.getRules().isEmpty()) { - func.append(generateComplexRulesLogic(rule.getRules())); - } else if (rule.getConditions() != null) { - func.append(generateConditionalBlockLogic(rule.getConditions())); - } - - // Return output - func.append(generateReturnStatement(rule)); - - decrementIndent(); - - return func.toString(); - } - - private String generateSimpleSyntaxLogic(ASTRulesDSL rule) { - StringBuilder logic = new StringBuilder(); - - // Generate condition evaluation - if (rule.getWhenConditions() != null && !rule.getWhenConditions().isEmpty()) { - logic.append(indent()).append("# Evaluate conditions\n"); - logic.append(indent()).append("if "); - - String conditions = rule.getWhenConditions().stream() - .map(condition -> condition.accept(this)) - .collect(Collectors.joining(" and ")); - - logic.append(conditions).append(":\n"); - - incrementIndent(); - - // Generate then actions - if (rule.getThenActions() != null && !rule.getThenActions().isEmpty()) { - logic.append(indent()).append("# Then actions\n"); - for (Action action : rule.getThenActions()) { - logic.append(indent()).append(action.accept(this)).append("\n"); - } - } - - decrementIndent(); - - // Generate else actions if any - if (rule.getElseActions() != null && !rule.getElseActions().isEmpty()) { - logic.append(indent()).append("else:\n"); - incrementIndent(); - logic.append(indent()).append("# Else actions\n"); - for (Action action : rule.getElseActions()) { - logic.append(indent()).append(action.accept(this)).append("\n"); - } - decrementIndent(); - } - } - - return logic.toString(); - } - - private String generateComplexRulesLogic(List rules) { - StringBuilder logic = new StringBuilder(); - - for (int i = 0; i < rules.size(); i++) { - ASTRulesDSL.ASTSubRule subRule = rules.get(i); - logic.append(indent()).append("# Sub-rule: ").append(subRule.getName() != null ? subRule.getName() : "Rule " + (i + 1)).append("\n"); - - if (subRule.getWhenConditions() != null && !subRule.getWhenConditions().isEmpty()) { - // Simple syntax sub-rule - logic.append(generateSubRuleSimpleSyntax(subRule)); - } else if (subRule.getConditions() != null) { - // Complex syntax sub-rule - logic.append(generateSubRuleComplexSyntax(subRule)); - } - - if (i < rules.size() - 1) { - logic.append("\n"); - } - } - - return logic.toString(); - } - - private String generateSubRuleSimpleSyntax(ASTRulesDSL.ASTSubRule subRule) { - StringBuilder logic = new StringBuilder(); - - logic.append(indent()).append("if "); - String conditions = subRule.getWhenConditions().stream() - .map(condition -> condition.accept(this)) - .collect(Collectors.joining(" and ")); - logic.append(conditions).append(":\n"); - - incrementIndent(); - if (subRule.getThenActions() != null && !subRule.getThenActions().isEmpty()) { - for (Action action : subRule.getThenActions()) { - logic.append(indent()).append(action.accept(this)).append("\n"); - } - } - decrementIndent(); - - if (subRule.getElseActions() != null && !subRule.getElseActions().isEmpty()) { - logic.append(indent()).append("else:\n"); - incrementIndent(); - for (Action action : subRule.getElseActions()) { - logic.append(indent()).append(action.accept(this)).append("\n"); - } - decrementIndent(); - } - - return logic.toString(); - } - - private String generateSubRuleComplexSyntax(ASTRulesDSL.ASTSubRule subRule) { - return generateConditionalBlockLogic(subRule.getConditions()); - } - - private String generateConditionalBlockLogic(ASTRulesDSL.ASTConditionalBlock conditionalBlock) { - StringBuilder logic = new StringBuilder(); - - logic.append(indent()).append("if ").append(conditionalBlock.getIfCondition().accept(this)).append(":\n"); - - incrementIndent(); - if (conditionalBlock.getThenBlock() != null) { - logic.append(generateActionBlock(conditionalBlock.getThenBlock())); - } - decrementIndent(); - - if (conditionalBlock.getElseBlock() != null) { - logic.append(indent()).append("else:\n"); - incrementIndent(); - logic.append(generateActionBlock(conditionalBlock.getElseBlock())); - decrementIndent(); - } - - return logic.toString(); - } - - private String generateActionBlock(ASTRulesDSL.ASTActionBlock actionBlock) { - StringBuilder block = new StringBuilder(); - - if (actionBlock.getActions() != null && !actionBlock.getActions().isEmpty()) { - for (Action action : actionBlock.getActions()) { - block.append(indent()).append(action.accept(this)).append("\n"); - } - } - - if (actionBlock.getNestedConditions() != null) { - block.append(generateConditionalBlockLogic(actionBlock.getNestedConditions())); - } - - return block.toString(); - } - - private String generateConstantsInitialization(List constants) { - StringBuilder init = new StringBuilder(); - - init.append(indent()).append("# Initialize constants from database or default values\n"); - init.append(indent()).append("# NOTE: Constants marked as 'None' need to be configured in the database\n"); - init.append(indent()).append("# or updated manually before execution\n"); - init.append(indent()).append("constants = {}\n"); - - // Get constants from database - Map databaseConstants = new HashMap<>(); - if (constantService != null) { - try { - List constantCodes = constants.stream() - .map(ASTRulesDSL.ASTConstantDefinition::getCode) - .collect(Collectors.toList()); - - constantService.getConstantsByCodes(constantCodes) - .collectList() - .subscribeOn(reactor.core.scheduler.Schedulers.boundedElastic()) - .block() - .forEach(dto -> databaseConstants.put(dto.getCode(), dto)); - } catch (Exception e) { - log.warn("Failed to load constants from database: {}", e.getMessage()); - } - } - - for (ASTRulesDSL.ASTConstantDefinition constant : constants) { - init.append(indent()).append("constants['").append(constant.getCode()).append("'] = "); - - // Check if constant exists in database - ConstantDTO dbConstant = databaseConstants.get(constant.getCode()); - if (dbConstant != null && dbConstant.getCurrentValue() != null) { - // Use database value - init.append(formatPythonValue(dbConstant.getCurrentValue())); - init.append(" # From database"); - } else if (constant.getDefaultValue() != null) { - // Use default value from DSL - init.append(formatPythonValue(constant.getDefaultValue())); - init.append(" # Default value"); - } else { - // No value available - set to None with warning - init.append("None"); - init.append(" # WARNING: Constant not found in database and no default value provided"); - } - init.append("\n"); - } - init.append("\n"); - - return init.toString(); - } - - private String generateReturnStatement(ASTRulesDSL rule) { - StringBuilder returnStmt = new StringBuilder(); - - returnStmt.append("\n").append(indent()).append("# Return output variables\n"); - returnStmt.append(indent()).append("return {\n"); - - incrementIndent(); - - // Include explicitly defined outputs - if (rule.getOutput() != null && !rule.getOutput().isEmpty()) { - for (Map.Entry output : rule.getOutput().entrySet()) { - returnStmt.append(indent()).append("'").append(output.getKey()).append("': "); - returnStmt.append(CONTEXT_VAR).append(".get('").append(output.getKey()).append("'),\n"); - } - } else { - // If no explicit outputs, include variables that are set in actions - Set setVariables = extractSetVariables(rule); - for (String variable : setVariables) { - returnStmt.append(indent()).append("'").append(variable).append("': "); - returnStmt.append(CONTEXT_VAR).append(".get('").append(variable).append("'),\n"); - } - } - - decrementIndent(); - - returnStmt.append(indent()).append("}\n"); - - return returnStmt.toString(); - } - - private String generateHelperFunctions(ASTRulesDSL rule) { - // For now, return empty string. Helper functions can be added later if needed - return ""; - } - - // Expression visitors - @Override - public String visitBinaryExpression(BinaryExpression node) { - String left = node.getLeft().accept(this); - String right = node.getRight().accept(this); - String operator = mapBinaryOperatorToPython(node.getOperator()); - return String.format("(%s %s %s)", left, operator, right); - } - - @Override - public String visitUnaryExpression(UnaryExpression node) { - String operand = node.getOperand().accept(this); - String operator = mapUnaryOperatorToPython(node.getOperator()); - - // Check if this is a function call (validation operators) - if (operator.startsWith("firefly_")) { - return String.format("%s(%s)", operator, operand); - } else { - return String.format("(%s %s)", operator, operand); - } - } - - @Override - public String visitVariableExpression(VariableExpression node) { - if (node.hasPropertyAccess()) { - return String.format("get_nested_value(%s, '%s')", CONTEXT_VAR, node.getFullPath()); - } else if (node.hasIndexAccess()) { - String indexExpr = node.getIndexExpression().accept(this); - return String.format("get_indexed_value(%s, '%s', %s)", CONTEXT_VAR, node.getVariableName(), indexExpr); - } else { - // Check if this is a constant (UPPER_CASE_WITH_UNDERSCORES pattern) - if (isConstantName(node.getVariableName())) { - // Constants are accessed from the constants dictionary - return String.format("constants.get('%s', None)", node.getVariableName()); - } else { - // Regular variables are accessed from context - String defaultValue = getDefaultValueForVariable(node.getVariableName()); - return String.format("%s.get('%s', %s)", CONTEXT_VAR, node.getVariableName(), defaultValue); - } - } - } - - /** - * Check if a variable name follows the constant naming convention (UPPER_CASE_WITH_UNDERSCORES) - */ - private boolean isConstantName(String name) { - return name != null && name.matches("^[A-Z][A-Z0-9_]*$"); - } - - private String getDefaultValueForVariable(String variableName) { - // Common numeric variables get 0 as default - if (variableName.toLowerCase().contains("score") || - variableName.toLowerCase().contains("amount") || - variableName.toLowerCase().contains("value") || - variableName.toLowerCase().contains("count") || - variableName.toLowerCase().contains("number") || - variableName.toLowerCase().contains("income") || - variableName.toLowerCase().contains("debt") || - variableName.toLowerCase().contains("age") || - variableName.toLowerCase().contains("price") || - variableName.toLowerCase().contains("cost") || - variableName.toLowerCase().contains("rate") || - variableName.toLowerCase().contains("percent")) { - return "0"; - } - // String variables get empty string - return "''"; - } - - @Override - public String visitLiteralExpression(LiteralExpression node) { - return formatPythonValue(node.getValue()); - } - - @Override - public String visitFunctionCallExpression(FunctionCallExpression node) { - String functionName = mapFunctionToPython(node.getFunctionName()); - - if (node.hasArguments()) { - String args = node.getArguments().stream() - .map(arg -> arg.accept(this)) - .collect(Collectors.joining(", ")); - return String.format("%s(%s)", functionName, args); - } else { - return String.format("%s()", functionName); - } - } - - @Override - public String visitArithmeticExpression(ArithmeticExpression node) { - // ArithmeticExpression is a complex expression with multiple operands - String operation = node.getOperation().getName(); - List operands = node.getOperands().stream() - .map(operand -> operand.accept(this)) - .collect(Collectors.toList()); - - return switch (operation.toLowerCase()) { - case "sum" -> String.format("sum([%s])", String.join(", ", operands)); - case "average", "avg" -> String.format("statistics.mean([%s])", String.join(", ", operands)); - case "max" -> String.format("max(%s)", String.join(", ", operands)); - case "min" -> String.format("min(%s)", String.join(", ", operands)); - default -> String.format("firefly_%s(%s)", operation, String.join(", ", operands)); - }; - } - - @Override - public String visitJsonPathExpression(JsonPathExpression node) { - String sourceExpression = node.getSourceExpression().accept(this); - String jsonPath = "\"" + node.getJsonPath() + "\""; - return String.format("json_path_get(%s, %s)", sourceExpression, jsonPath); - } - - @Override - public String visitRestCallExpression(RestCallExpression node) { - String method = "\"" + node.getHttpMethod() + "\""; - String url = node.getUrlExpression().accept(this); - - StringBuilder restCall = new StringBuilder(); - restCall.append("rest_call(").append(method).append(", ").append(url); - - if (node.getBodyExpression() != null) { - restCall.append(", ").append(node.getBodyExpression().accept(this)); - } else { - restCall.append(", None"); - } - - if (node.getHeadersExpression() != null) { - restCall.append(", ").append(node.getHeadersExpression().accept(this)); - } else { - restCall.append(", None"); - } - - if (node.getTimeoutExpression() != null) { - restCall.append(", ").append(node.getTimeoutExpression().accept(this)); - } - - restCall.append(")"); - return restCall.toString(); - } - - // Condition visitors - @Override - public String visitComparisonCondition(ComparisonCondition node) { - String left = node.getLeft().accept(this); - String operator = mapComparisonOperatorToPython(node.getOperator()); - String right = node.getRight().accept(this); - - // Handle special operators - return switch (node.getOperator()) { - case BETWEEN -> { - String rangeEnd = node.getRangeEnd().accept(this); - yield String.format("(%s <= %s <= %s)", right, left, rangeEnd); - } - case NOT_BETWEEN -> { - String rangeEnd = node.getRangeEnd().accept(this); - yield String.format("not (%s <= %s <= %s)", right, left, rangeEnd); - } - case IN, IN_LIST -> String.format("(%s in %s)", left, right); - case NOT_IN, NOT_IN_LIST -> String.format("(%s not in %s)", left, right); - case CONTAINS -> String.format("(%s in %s)", right, left); - case NOT_CONTAINS -> String.format("(%s not in %s)", right, left); - case STARTS_WITH -> String.format("%s.startswith(%s)", left, right); - case ENDS_WITH -> String.format("%s.endswith(%s)", left, right); - case MATCHES -> String.format("re.match(%s, %s) is not None", right, left); - case NOT_MATCHES -> String.format("re.match(%s, %s) is None", right, left); - case IS_NULL -> String.format("(%s is None)", left); - case IS_NOT_NULL -> String.format("(%s is not None)", left); - case IS_EMPTY -> String.format("firefly_is_empty(%s)", left); - case IS_NOT_EMPTY -> String.format("firefly_is_not_empty(%s)", left); - // Validation operators that are function calls - case IS_POSITIVE -> String.format("firefly_is_positive(%s)", left); - case IS_NEGATIVE -> String.format("firefly_is_negative(%s)", left); - case IS_ZERO -> String.format("firefly_is_zero(%s)", left); - case IS_NON_ZERO -> String.format("firefly_is_non_zero(%s)", left); - case IS_NUMERIC -> String.format("firefly_is_numeric(%s)", left); - case IS_NOT_NUMERIC -> String.format("firefly_is_not_numeric(%s)", left); - case IS_EMAIL -> String.format("firefly_is_email(%s)", left); - case IS_PHONE -> String.format("firefly_is_phone(%s)", left); - case IS_DATE -> String.format("firefly_is_date(%s)", left); - case IS_PERCENTAGE -> String.format("firefly_is_percentage(%s)", left); - case IS_CURRENCY -> String.format("firefly_is_currency(%s)", left); - case IS_CREDIT_SCORE -> String.format("firefly_is_valid_credit_score(%s)", left); - case IS_SSN -> String.format("firefly_is_ssn(%s)", left); - case IS_ACCOUNT_NUMBER -> String.format("firefly_is_account_number(%s)", left); - case IS_ROUTING_NUMBER -> String.format("firefly_is_routing_number(%s)", left); - case IS_BUSINESS_DAY -> String.format("firefly_is_business_day(%s)", left); - case IS_WEEKEND -> String.format("firefly_is_weekend(%s)", left); - default -> String.format("(%s %s %s)", left, operator, right); - }; - } - - @Override - public String visitLogicalCondition(LogicalCondition node) { - List operands = node.getOperands().stream() - .map(operand -> operand.accept(this)) - .collect(Collectors.toList()); - - return switch (node.getOperator()) { - case AND -> String.format("(%s)", String.join(" and ", operands)); - case OR -> String.format("(%s)", String.join(" or ", operands)); - case NOT -> String.format("(not %s)", operands.get(0)); - }; - } - - @Override - public String visitExpressionCondition(ExpressionCondition node) { - return String.format("bool(%s)", node.getExpression().accept(this)); - } - - // Action visitors - @Override - public String visitAssignmentAction(AssignmentAction node) { - String value = node.getValue().accept(this); - String varName = sanitizeVariableName(node.getVariableName()); - - return switch (node.getOperator()) { - case ASSIGN -> String.format("%s['%s'] = %s", CONTEXT_VAR, varName, value); - case ADD_ASSIGN -> String.format("%s['%s'] = %s.get('%s', 0) + %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - case SUBTRACT_ASSIGN -> String.format("%s['%s'] = %s.get('%s', 0) - %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - case MULTIPLY_ASSIGN -> String.format("%s['%s'] = %s.get('%s', 1) * %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - case DIVIDE_ASSIGN -> String.format("%s['%s'] = %s.get('%s', 1) / %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - }; - } - - @Override - public String visitFunctionCallAction(FunctionCallAction node) { - String functionName = mapFunctionToPython(node.getFunctionName()); - - StringBuilder call = new StringBuilder(); - - if (node.hasResultVariable()) { - call.append(String.format("%s['%s'] = ", CONTEXT_VAR, node.getResultVariable())); - } - - call.append(functionName).append("("); - - if (node.hasArguments()) { - String args = node.getArguments().stream() - .map(arg -> arg.accept(this)) - .collect(Collectors.joining(", ")); - call.append(args); - } - - call.append(")"); - - return call.toString(); - } - - @Override - public String visitConditionalAction(ConditionalAction node) { - StringBuilder conditional = new StringBuilder(); - - conditional.append("if ").append(node.getCondition().accept(this)).append(":\n"); - - incrementIndent(); - if (node.getThenActions() != null && !node.getThenActions().isEmpty()) { - for (Action action : node.getThenActions()) { - conditional.append(indent()).append(action.accept(this)).append("\n"); - } - } - decrementIndent(); - - if (node.hasElseActions()) { - conditional.append(indent()).append("else:\n"); - incrementIndent(); - for (Action action : node.getElseActions()) { - conditional.append(indent()).append(action.accept(this)).append("\n"); - } - decrementIndent(); - } - - return conditional.toString().trim(); - } - - @Override - public String visitCalculateAction(CalculateAction node) { - String expression = node.getExpression().accept(this); - String resultVar = node.getResultVariable(); - return String.format("%s['%s'] = %s", CONTEXT_VAR, resultVar, expression); - } - - @Override - public String visitRunAction(RunAction node) { - String expression = node.getExpression().accept(this); - String resultVar = node.getResultVariable(); - return String.format("%s['%s'] = %s", CONTEXT_VAR, resultVar, expression); - } - - @Override - public String visitSetAction(SetAction node) { - String value = node.getValue().accept(this); - String varName = sanitizeVariableName(node.getVariableName()); - return String.format("%s['%s'] = %s", CONTEXT_VAR, varName, value); - } - - @Override - public String visitArithmeticAction(ArithmeticAction node) { - String value = node.getValue().accept(this); - String varName = node.getVariableName(); - - return switch (node.getOperation()) { - case ADD -> String.format("%s['%s'] = %s.get('%s', 0) + %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - case SUBTRACT -> String.format("%s['%s'] = %s.get('%s', 0) - %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - case MULTIPLY -> String.format("%s['%s'] = %s.get('%s', 1) * %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - case DIVIDE -> String.format("%s['%s'] = %s.get('%s', 1) / %s", - CONTEXT_VAR, varName, CONTEXT_VAR, varName, value); - default -> String.format("# Unsupported arithmetic operation: %s", node.getOperation()); - }; - } - - @Override - public String visitListAction(ListAction node) { - String value = node.getValue().accept(this); - String listVar = node.getListVariable(); - - return switch (node.getOperation()) { - case APPEND -> String.format("%s.setdefault('%s', []).append(%s)", - CONTEXT_VAR, listVar, value); - case PREPEND -> String.format("%s.setdefault('%s', []).insert(0, %s)", - CONTEXT_VAR, listVar, value); - case REMOVE -> String.format("list_remove(%s.get('%s', []), %s)", - CONTEXT_VAR, listVar, value); - }; - } - - @Override - public String visitCircuitBreakerAction(CircuitBreakerAction node) { - String message = "\"" + node.getMessage() + "\""; - String errorCode = node.getErrorCode() != null ? "\"" + node.getErrorCode() + "\"" : "None"; - return String.format("raise CircuitBreakerException(%s, %s)", - message, errorCode); - } - - @Override - public String visitForEachAction(ForEachAction node) { - StringBuilder code = new StringBuilder(); - String listExpr = node.getListExpression().accept(this); - String iterVar = node.getIterationVariable(); - - // Generate for loop - if (node.hasIndexVariable()) { - String indexVar = node.getIndexVariable(); - code.append(String.format("for %s, %s in enumerate(%s):\n", indexVar, iterVar, listExpr)); - } else { - code.append(String.format("for %s in %s:\n", iterVar, listExpr)); - } - - // Indent and generate body actions - incrementIndent(); - for (Action bodyAction : node.getBodyActions()) { - code.append(indent()).append(bodyAction.accept(this)).append("\n"); - } - decrementIndent(); - - return code.toString(); - } - - @Override - public String visitWhileAction(WhileAction node) { - StringBuilder code = new StringBuilder(); - String condition = node.getCondition().accept(this); - - // Generate while loop with iteration limit - code.append(String.format("_while_iterations = 0\n")); - code.append(indent()).append(String.format("while %s and _while_iterations < %d:\n", condition, node.getMaxIterations())); - - // Indent and generate body actions - incrementIndent(); - for (Action bodyAction : node.getBodyActions()) { - code.append(indent()).append(bodyAction.accept(this)).append("\n"); - } - code.append(indent()).append("_while_iterations += 1\n"); - decrementIndent(); - - return code.toString(); - } - - @Override - public String visitDoWhileAction(DoWhileAction node) { - StringBuilder code = new StringBuilder(); - String condition = node.getCondition().accept(this); - - // Generate do-while loop (Python doesn't have do-while, so we use while True with break) - code.append("_dowhile_iterations = 0\n"); - code.append(indent()).append("while True:\n"); - - // Indent and generate body actions - incrementIndent(); - for (Action bodyAction : node.getBodyActions()) { - code.append(indent()).append(bodyAction.accept(this)).append("\n"); - } - code.append(indent()).append("_dowhile_iterations += 1\n"); - code.append(indent()).append(String.format("if not (%s) or _dowhile_iterations >= %d:\n", condition, node.getMaxIterations())); - incrementIndent(); - code.append(indent()).append("break\n"); - decrementIndent(); - decrementIndent(); - - return code.toString(); - } - - // Utility methods - private String indent() { - return " ".repeat(indentLevel.get()); - } - - private void incrementIndent() { - indentLevel.set(indentLevel.get() + 1); - } - - private void decrementIndent() { - indentLevel.set(indentLevel.get() - 1); - } - - private String sanitizeComment(String text) { - if (text == null) return ""; - return text.replace("\n", " ").replace("\r", " "); - } - - private String sanitizeVariableName(String name) { - if (name == null || !name.matches("^[a-zA-Z_][a-zA-Z0-9_.]*$")) { - throw new IllegalArgumentException("Invalid variable name for Python code generation: " + name); - } - return name; - } - - public String sanitizeFunctionName(String name) { - if (name == null) return "unnamed_rule"; - - String sanitized = name.toLowerCase() - .replaceAll("[^a-zA-Z0-9_]", "_") - .replaceAll("_{2,}", "_") - .replaceAll("^_|_$", ""); - - // Add underscore prefix if starts with number - if (sanitized.matches("^[0-9].*")) { - sanitized = "_" + sanitized; - } - - return sanitized; - } - - private String formatPythonValue(Object value) { - if (value == null) { - return "None"; - } else if (value instanceof String) { - String escaped = value.toString() - .replace("\\", "\\\\") - .replace("\"", "\\\"") - .replace("\n", "\\n") - .replace("\r", "\\r") - .replace("\t", "\\t") - .replace("\0", "\\0"); - return "\"" + escaped + "\""; - } else if (value instanceof Boolean) { - return ((Boolean) value) ? "True" : "False"; - } else if (value instanceof List) { - List list = (List) value; - String elements = list.stream() - .map(this::formatPythonValue) - .collect(Collectors.joining(", ")); - return "[" + elements + "]"; - } else if (value instanceof Map) { - Map map = (Map) value; - String entries = map.entrySet().stream() - .map(entry -> formatPythonValue(entry.getKey()) + ": " + formatPythonValue(entry.getValue())) - .collect(Collectors.joining(", ")); - return "{" + entries + "}"; - } else { - return value.toString(); - } - } - - - - - - public List extractInputVariables(ASTRulesDSL rule) { - if (rule.getInput() != null) { - return new ArrayList<>(rule.getInput().keySet()); - } - return new ArrayList<>(); - } - - public Map extractOutputVariables(ASTRulesDSL rule) { - if (rule.getOutput() != null) { - return rule.getOutput(); - } - return new HashMap<>(); - } - - - /** - * Extract variables that are set in actions throughout the rule - */ - private Set extractSetVariables(ASTRulesDSL rule) { - Set setVariables = new HashSet<>(); - - // Check simple syntax actions - if (rule.getThenActions() != null) { - setVariables.addAll(extractSetVariablesFromActions(rule.getThenActions())); - } - if (rule.getElseActions() != null) { - setVariables.addAll(extractSetVariablesFromActions(rule.getElseActions())); - } - - // Check complex syntax rules - if (rule.getRules() != null) { - for (ASTRulesDSL.ASTSubRule astRule : rule.getRules()) { - if (astRule.getThenActions() != null) { - setVariables.addAll(extractSetVariablesFromActions(astRule.getThenActions())); - } - if (astRule.getElseActions() != null) { - setVariables.addAll(extractSetVariablesFromActions(astRule.getElseActions())); - } - } - } - - return setVariables; - } - - private Set extractSetVariablesFromActions(List actions) { - Set setVariables = new HashSet<>(); - - for (Action action : actions) { - if (action instanceof SetAction) { - SetAction setAction = (SetAction) action; - setVariables.add(setAction.getVariableName()); - } else if (action instanceof CalculateAction) { - CalculateAction calcAction = (CalculateAction) action; - setVariables.add(calcAction.getResultVariable()); - } else if (action instanceof AssignmentAction) { - AssignmentAction assignAction = (AssignmentAction) action; - setVariables.add(assignAction.getVariableName()); - } - } - - return setVariables; - } - private String mapBinaryOperatorToPython(BinaryOperator operator) { - return switch (operator) { - // Arithmetic operators - case ADD -> "+"; - case SUBTRACT -> "-"; - case MULTIPLY -> "*"; - case DIVIDE -> "/"; - case MODULO -> "%"; - case POWER -> "**"; - - // Comparison operators - case EQUALS -> "=="; - case NOT_EQUALS -> "!="; - case GREATER_THAN -> ">"; - case LESS_THAN -> "<"; - case GREATER_THAN_OR_EQUAL -> ">="; - case LESS_THAN_OR_EQUAL -> "<="; - case GREATER_EQUAL -> ">="; // Alias - case LESS_EQUAL -> "<="; // Alias - - // String operators - case CONTAINS -> " in "; - case NOT_CONTAINS -> " not in "; - case STARTS_WITH -> ".startswith"; - case ENDS_WITH -> ".endswith"; - case MATCHES -> "firefly_matches"; - case NOT_MATCHES -> "firefly_not_matches"; - - // Logical operators - case AND -> " and "; - case OR -> " or "; - - // Special operators - case BETWEEN -> "firefly_between"; - case NOT_BETWEEN -> "firefly_not_between"; - case IN -> " in "; - case IN_LIST -> " in "; // Alias - case NOT_IN_LIST -> " not in "; - - // Age validation operators - case AGE_AT_LEAST -> "firefly_age_at_least"; - case AGE_LESS_THAN -> "firefly_age_less_than"; - - default -> throw new UnsupportedOperationException("Unsupported binary operator: " + operator); - }; - } - - private String mapUnaryOperatorToPython(UnaryOperator operator) { - return switch (operator) { - // Arithmetic operators - case NEGATE, MINUS -> "-"; - case POSITIVE, PLUS -> "+"; - - // Logical operators - case NOT -> "not "; - - // Existence operators - case EXISTS -> "firefly_exists"; - case IS_NULL -> "firefly_is_null"; - case IS_NOT_NULL -> "firefly_is_not_null"; - - // Type checking operators - case IS_NUMBER -> "firefly_is_number"; - case IS_STRING -> "firefly_is_string"; - case IS_BOOLEAN -> "firefly_is_boolean"; - case IS_LIST -> "firefly_is_list"; - - // String operators - case TO_UPPER -> ".upper()"; - case TO_LOWER -> ".lower()"; - case TRIM -> ".strip()"; - case LENGTH -> "len"; - - // Validation operators - case IS_POSITIVE -> "firefly_is_positive"; - case IS_NEGATIVE -> "firefly_is_negative"; - case IS_ZERO -> "firefly_is_zero"; - case IS_EMPTY -> "firefly_is_empty"; - case IS_NOT_EMPTY -> "firefly_is_not_empty"; - case IS_NUMERIC -> "firefly_is_numeric"; - case IS_NOT_NUMERIC -> "firefly_is_not_numeric"; - case IS_EMAIL -> "firefly_is_email"; - case IS_PHONE -> "firefly_is_phone"; - case IS_DATE -> "firefly_is_date"; - case IS_PERCENTAGE -> "firefly_is_percentage"; - case IS_CURRENCY -> "firefly_is_currency"; - case IS_CREDIT_SCORE -> "firefly_is_valid_credit_score"; - case IS_SSN -> "firefly_is_ssn"; - case IS_ACCOUNT_NUMBER -> "firefly_is_account_number"; - case IS_ROUTING_NUMBER -> "firefly_is_routing_number"; - case IS_BUSINESS_DAY -> "firefly_is_business_day"; - case IS_WEEKEND -> "firefly_is_weekend"; - - default -> throw new UnsupportedOperationException("Unsupported unary operator: " + operator); - }; - } - - private String mapComparisonOperatorToPython(ComparisonOperator operator) { - return switch (operator) { - // Basic comparison operators - case EQUALS -> "=="; - case NOT_EQUALS -> "!="; - case LESS_THAN -> "<"; - case LESS_THAN_OR_EQUAL, LESS_EQUAL -> "<="; - case GREATER_THAN -> ">"; - case GREATER_THAN_OR_EQUAL, GREATER_EQUAL -> ">="; - - // String operators - case CONTAINS -> " in "; - case NOT_CONTAINS -> " not in "; - case STARTS_WITH -> ".startswith"; - case ENDS_WITH -> ".endswith"; - case MATCHES -> "firefly_matches"; - case NOT_MATCHES -> "firefly_not_matches"; - - // Special operators - case BETWEEN -> "firefly_between"; - case NOT_BETWEEN -> "firefly_not_between"; - case IN, IN_LIST -> " in "; - case NOT_IN, NOT_IN_LIST -> " not in "; - case EXISTS -> "firefly_exists"; - case NOT_EXISTS -> "firefly_not_exists"; - case IS_NULL -> "firefly_is_null"; - case IS_NOT_NULL -> "firefly_is_not_null"; - - // Basic validation operators - case IS_EMPTY -> "firefly_is_empty"; - case IS_NOT_EMPTY -> "firefly_is_not_empty"; - case IS_NUMERIC -> "firefly_is_numeric"; - case IS_NOT_NUMERIC -> "firefly_is_not_numeric"; - case IS_EMAIL -> "firefly_is_email"; - case IS_PHONE -> "firefly_is_phone"; - case IS_DATE -> "firefly_is_date"; - - // Financial validation operators - case IS_POSITIVE -> "firefly_is_positive"; - case IS_NEGATIVE -> "firefly_is_negative"; - case IS_ZERO -> "firefly_is_zero"; - case IS_NON_ZERO -> "firefly_is_non_zero"; - case IS_PERCENTAGE -> "firefly_is_percentage"; - case IS_CURRENCY -> "firefly_is_currency"; - case IS_CREDIT_SCORE -> "firefly_is_valid_credit_score"; - case IS_SSN -> "firefly_is_ssn"; - case IS_ACCOUNT_NUMBER -> "firefly_is_account_number"; - case IS_ROUTING_NUMBER -> "firefly_is_routing_number"; - - // Date/time validation operators - case IS_BUSINESS_DAY -> "firefly_is_business_day"; - case IS_WEEKEND -> "firefly_is_weekend"; - case AGE_AT_LEAST -> "firefly_age_at_least"; - case AGE_LESS_THAN -> "firefly_age_less_than"; - - // Length operators - case LENGTH_EQUALS -> "firefly_length_equals"; - case LENGTH_GREATER_THAN -> "firefly_length_greater_than"; - case LENGTH_LESS_THAN -> "firefly_length_less_than"; - - default -> throw new UnsupportedOperationException("Unsupported comparison operator: " + operator); - }; - } - - private String mapArithmeticOperationToPython(ArithmeticOperation operation) { - return switch (operation) { - // Basic arithmetic - case ADD -> "+"; - case SUBTRACT -> "-"; - case MULTIPLY -> "*"; - case DIVIDE -> "/"; - case MODULO -> "%"; - case POWER -> "**"; - - // Mathematical functions - case ABS -> "abs"; - case MIN -> "min"; - case MAX -> "max"; - case ROUND -> "round"; - case FLOOR -> "math.floor"; - case CEIL -> "math.ceil"; - case SQRT -> "math.sqrt"; - case SUM -> "sum"; - case AVERAGE -> "firefly_average"; - - default -> throw new UnsupportedOperationException("Unsupported arithmetic operation: " + operation); - }; - } - - private String mapFunctionToPython(String functionName) { - return switch (functionName.toLowerCase()) { - // Built-in Python functions - case "max" -> "max"; - case "min" -> "min"; - case "abs" -> "abs"; - case "round" -> "round"; - case "sum" -> "sum"; - case "len" -> "len"; - - // Math functions - case "ceil" -> "math.ceil"; - case "floor" -> "math.floor"; - case "sqrt" -> "math.sqrt"; - case "pow" -> "pow"; - - // String functions - case "upper" -> "str.upper"; - case "lower" -> "str.lower"; - case "substring" -> "firefly_substring"; - case "length" -> "len"; - case "trim" -> "str.strip"; - - // Date functions - case "now" -> "datetime.now"; - case "format_date" -> "firefly_format_date"; - case "calculate_age" -> "firefly_calculate_age"; - - // Financial functions - case "calculate_loan_payment" -> "firefly_calculate_loan_payment"; - case "calculate_compound_interest" -> "firefly_calculate_compound_interest"; - case "calculate_amortization" -> "firefly_calculate_amortization"; - case "debt_to_income_ratio" -> "firefly_debt_to_income_ratio"; - case "credit_utilization" -> "firefly_credit_utilization"; - case "loan_to_value" -> "firefly_loan_to_value"; - case "calculate_apr" -> "firefly_calculate_apr"; - case "calculate_credit_score" -> "firefly_calculate_credit_score"; - case "calculate_risk_score" -> "firefly_calculate_risk_score"; - case "payment_history_score" -> "firefly_payment_history_score"; - - // Validation functions - case "is_valid_credit_score" -> "firefly_is_valid_credit_score"; - case "is_valid_ssn" -> "firefly_is_valid_ssn"; - case "is_valid_account" -> "firefly_is_valid_account"; - case "is_valid_routing" -> "firefly_is_valid_routing"; - case "is_business_day" -> "firefly_is_business_day"; - case "age_meets_requirement" -> "firefly_age_meets_requirement"; - case "validate_email" -> "firefly_validate_email"; - case "validate_phone" -> "firefly_validate_phone"; - - // Utility functions - case "format_currency" -> "firefly_format_currency"; - case "format_percentage" -> "firefly_format_percentage"; - case "generate_account_number" -> "firefly_generate_account_number"; - case "generate_transaction_id" -> "firefly_generate_transaction_id"; - case "distance_between" -> "firefly_distance_between"; - case "is_valid" -> "firefly_is_valid"; - case "in_range" -> "firefly_in_range"; - - // Logging/Auditing functions - case "audit" -> "firefly_audit"; - case "audit_log" -> "firefly_audit_log"; - case "send_notification" -> "firefly_send_notification"; - case "log" -> "firefly_log"; - - // Data Security functions - case "encrypt" -> "firefly_encrypt"; - case "decrypt" -> "firefly_decrypt"; - case "mask_data" -> "firefly_mask_data"; - - // REST API functions - case "rest_get" -> "firefly_rest_get"; - case "rest_post" -> "firefly_rest_post"; - case "rest_put" -> "firefly_rest_put"; - case "rest_delete" -> "firefly_rest_delete"; - case "rest_patch" -> "firefly_rest_patch"; - case "rest_call" -> "firefly_rest_call"; - - // JSON functions - case "json_get", "json_path" -> "firefly_json_get"; - case "json_exists" -> "firefly_json_exists"; - case "json_size" -> "firefly_json_size"; - case "json_type" -> "firefly_json_type"; - - // Default: prefix with firefly_ - default -> "firefly_" + functionName.toLowerCase(); - }; - } - - private String generateInteractiveMain(ASTRulesDSL rule, String functionName) { - StringBuilder main = new StringBuilder(); - - String finalFunctionName = functionName != null ? - sanitizeFunctionName(functionName) : - sanitizeFunctionName(rule.getName()); - - main.append("\n\n"); - main.append("if __name__ == \"__main__\":\n"); - main.append(" \"\"\"\n"); - main.append(" Interactive execution mode for testing the compiled rule.\n"); - main.append(" \n"); - main.append(" Copyright 2024-2026 Firefly Software Foundation\n"); - main.append(" Licensed under the Apache License, Version 2.0\n"); - main.append(" Made with ❤️ by Firefly Software Foundation\n"); - main.append(" \"\"\"\n"); - main.append(" import sys\n"); - main.append(" import json\n"); - main.append(" \n"); - // Print header using runtime function - main.append(" print_firefly_header(\"").append(rule.getName()).append("\""); - if (rule.getDescription() != null) { - main.append(", \"").append(rule.getDescription()).append("\""); - } else { - main.append(", None"); - } - if (rule.getVersion() != null) { - main.append(", \"").append(rule.getVersion()).append("\""); - } else { - main.append(", None"); - } - main.append(")\n"); - main.append(" \n"); - - // Check for constants that need configuration - if (rule.getConstants() != null && !rule.getConstants().isEmpty()) { - main.append(" # Check for constants that need configuration\n"); - main.append(" constants_need_config = []\n"); - for (ASTRulesDSL.ASTConstantDefinition constant : rule.getConstants()) { - main.append(" if constants.get('").append(constant.getCode()).append("') is None:\n"); - main.append(" constants_need_config.append('").append(constant.getCode()).append("')\n"); - } - main.append(" \n"); - main.append(" # Configure constants using runtime function\n"); - main.append(" constants_values = configure_constants_interactively(constants_need_config)\n"); - main.append(" constants.update(constants_values)\n"); - main.append(" \n"); - } - - // Interactive input collection - main.append(" # Collect input variables\n"); - main.append(" context = {}\n"); - main.append(" \n"); - - // Generate input definitions for the runtime - if (rule.getInput() != null && !rule.getInput().isEmpty()) { - main.append(" input_definitions = {\n"); - for (Map.Entry input : rule.getInput().entrySet()) { - String inputType = mapInputType(input.getValue()); - main.append(" '").append(input.getKey()).append("': '").append(inputType).append("',\n"); - } - main.append(" }\n"); - main.append(" context = collect_inputs(input_definitions)\n"); - } else { - main.append(" context = {}\n"); - main.append(" print(\"ℹ️ No input variables required for this rule.\")\n"); - } - - main.append(" \n"); - main.append(" print(\"\\n🚀 Executing rule...\")\n"); - main.append(" print(\"-\" * 40)\n"); - main.append(" \n"); - main.append(" try:\n"); - main.append(" # Execute the rule\n"); - main.append(" result = ").append(finalFunctionName).append("(context)\n"); - main.append(" print_execution_results(result)\n"); - main.append(" except Exception as e:\n"); - main.append(" print(f\"❌ Error executing rule: {e}\")\n"); - main.append(" import traceback\n"); - main.append(" traceback.print_exc()\n"); - main.append(" sys.exit(1)\n"); - main.append(" \n"); - main.append(" print_firefly_footer()\n"); - - return main.toString(); - } - - - - /** - * Map input type from DSL to Python helper function type - */ - private String mapInputType(String dslType) { - if (dslType == null) return "text"; - - String lowerType = dslType.toLowerCase(); - if (lowerType.contains("number") || lowerType.contains("int") || - lowerType.contains("float") || lowerType.contains("decimal")) { - return "number"; - } else if (lowerType.contains("bool")) { - return "boolean"; - } else { - return "text"; - } - } - - -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilationService.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilationService.java deleted file mode 100644 index a8211cc..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilationService.java +++ /dev/null @@ -1,293 +0,0 @@ -package org.fireflyframework.rules.core.dsl.compiler; - -import org.fireflyframework.rules.core.dsl.model.ASTRulesDSL; -import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; -import org.fireflyframework.rules.core.validation.YamlDslValidator; -import org.fireflyframework.rules.interfaces.dtos.validation.ValidationResult; -import org.fireflyframework.kernel.exception.FireflyException; -import lombok.RequiredArgsConstructor; -import lombok.extern.slf4j.Slf4j; -import org.springframework.stereotype.Service; - -import java.time.LocalDateTime; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; - -/** - * Service for compiling YAML DSL rules to Python code. - * - * This service provides functionality to: - * - Parse YAML DSL to AST - * - Validate the AST - * - Compile AST to Python code - * - Cache compiled rules - * - Manage compilation metadata - * - * @author Firefly Software Foundation - * @since 1.0.0 - */ -@Service -@RequiredArgsConstructor -@Slf4j -public class PythonCompilationService { - - private final ASTRulesDSLParser astRulesDSLParser; - private final YamlDslValidator yamlDslValidator; - private final PythonCodeGenerator pythonCodeGenerator; - - // Cache for compiled rules - private final Map compilationCache = new ConcurrentHashMap<>(); - - // Compilation statistics - private long totalCompilations = 0; - private long successfulCompilations = 0; - private long failedCompilations = 0; - private long cacheHits = 0; - - /** - * Compile a YAML DSL rule to Python code. - * - * @param yamlDsl The YAML DSL rule definition - * @param ruleName Optional rule name (will be extracted from DSL if not provided) - * @param useCache Whether to use compilation cache - * @return Compiled Python rule - * @throws PythonCompilationException if compilation fails - */ - public PythonCompiledRule compileRule(String yamlDsl, String ruleName, boolean useCache) { - log.debug("Starting Python compilation for rule: {}", ruleName); - - totalCompilations++; - - try { - // Generate cache key - String cacheKey = generateCacheKey(yamlDsl, ruleName); - - // Check cache if enabled - if (useCache && compilationCache.containsKey(cacheKey)) { - log.debug("Cache hit for rule: {}", ruleName); - cacheHits++; - return compilationCache.get(cacheKey); - } - - // Parse YAML DSL to AST - @SuppressWarnings("deprecation") - ASTRulesDSL astRule = astRulesDSLParser.parseRules(yamlDsl); - - // Validate the AST - ValidationResult validationResult = yamlDslValidator.validate(yamlDsl); - if (!validationResult.isValid()) { - throw new PythonCompilationException( - "DSL validation failed: " + validationResult.getErrors() - ); - } - - // Generate Python code - String finalRuleName = ruleName != null ? ruleName : - (astRule.getName() != null ? astRule.getName() : "unnamed_rule"); - String pythonCode = pythonCodeGenerator.generatePythonFunction(astRule, finalRuleName); - - // Create compiled rule - PythonCompiledRule compiledRule = createCompiledRule(astRule, pythonCode, ruleName); - - // Cache the result if enabled - if (useCache) { - compilationCache.put(cacheKey, compiledRule); - } - - successfulCompilations++; - log.info("Successfully compiled rule '{}' to Python", compiledRule.getRuleName()); - - return compiledRule; - - } catch (Exception e) { - failedCompilations++; - log.error("Failed to compile rule '{}' to Python: {}", ruleName, e.getMessage(), e); - throw new PythonCompilationException("Compilation failed: " + e.getMessage(), e); - } - } - - /** - * Compile a YAML DSL rule to Python code with default settings. - * - * @param yamlDsl The YAML DSL rule definition - * @return Compiled Python rule - */ - public PythonCompiledRule compileRule(String yamlDsl) { - return compileRule(yamlDsl, null, true); - } - - /** - * Compile a YAML DSL rule to Python code with specified rule name. - * - * @param yamlDsl The YAML DSL rule definition - * @param ruleName The rule name - * @return Compiled Python rule - */ - public PythonCompiledRule compileRule(String yamlDsl, String ruleName) { - return compileRule(yamlDsl, ruleName, true); - } - - /** - * Batch compile multiple YAML DSL rules to Python code. - * - * @param rules Map of rule names to YAML DSL definitions - * @param useCache Whether to use compilation cache - * @return Map of rule names to compiled Python rules - */ - public Map compileRules(Map rules, boolean useCache) { - log.info("Starting batch compilation of {} rules", rules.size()); - - Map compiledRules = new ConcurrentHashMap<>(); - - rules.entrySet().parallelStream().forEach(entry -> { - try { - PythonCompiledRule compiledRule = compileRule(entry.getValue(), entry.getKey(), useCache); - compiledRules.put(entry.getKey(), compiledRule); - } catch (Exception e) { - log.error("Failed to compile rule '{}': {}", entry.getKey(), e.getMessage()); - // Continue with other rules - } - }); - - log.info("Batch compilation completed. Successfully compiled {}/{} rules", - compiledRules.size(), rules.size()); - - return compiledRules; - } - - /** - * Clear the compilation cache. - */ - public void clearCache() { - compilationCache.clear(); - log.info("Compilation cache cleared"); - } - - /** - * Get compilation statistics. - * - * @return Map containing compilation statistics - */ - public Map getCompilationStats() { - return Map.of( - "totalCompilations", totalCompilations, - "successfulCompilations", successfulCompilations, - "failedCompilations", failedCompilations, - "cacheHits", cacheHits, - "cacheSize", compilationCache.size(), - "successRate", totalCompilations > 0 ? (double) successfulCompilations / totalCompilations : 0.0, - "cacheHitRate", totalCompilations > 0 ? (double) cacheHits / totalCompilations : 0.0 - ); - } - - /** - * Get cached rule by cache key. - * - * @param yamlDsl The YAML DSL - * @param ruleName The rule name - * @return Cached compiled rule or null if not found - */ - public PythonCompiledRule getCachedRule(String yamlDsl, String ruleName) { - String cacheKey = generateCacheKey(yamlDsl, ruleName); - return compilationCache.get(cacheKey); - } - - /** - * Check if a rule is cached. - * - * @param yamlDsl The YAML DSL - * @param ruleName The rule name - * @return True if the rule is cached - */ - public boolean isRuleCached(String yamlDsl, String ruleName) { - String cacheKey = generateCacheKey(yamlDsl, ruleName); - return compilationCache.containsKey(cacheKey); - } - - /** - * Remove a specific rule from cache. - * - * @param yamlDsl The YAML DSL - * @param ruleName The rule name - * @return True if the rule was removed from cache - */ - public boolean removeCachedRule(String yamlDsl, String ruleName) { - String cacheKey = generateCacheKey(yamlDsl, ruleName); - return compilationCache.remove(cacheKey) != null; - } - - /** - * Remove cached rules by rule name pattern. - * This method removes all cached rules that match the given rule name. - * Useful for DELETE endpoints that should not have request bodies. - * - * @param ruleName The rule name to remove from cache - * @return True if at least one rule was removed from cache - */ - public boolean removeCachedRuleByName(String ruleName) { - boolean removed = false; - - // Find all cache keys that start with the rule name - for (String cacheKey : compilationCache.keySet()) { - if (cacheKey.startsWith(ruleName + "_")) { - if (compilationCache.remove(cacheKey) != null) { - removed = true; - log.debug("Removed cached rule with key: {}", cacheKey); - } - } - } - - if (removed) { - log.info("Removed cached rules for rule name: {}", ruleName); - } else { - log.debug("No cached rules found for rule name: {}", ruleName); - } - - return removed; - } - - // Private helper methods - - private String generateCacheKey(String yamlDsl, String ruleName) { - // Use a combination of rule name and DSL hash for cache key - int dslHash = yamlDsl.hashCode(); - String name = ruleName != null ? ruleName : "unnamed"; - return name + "_" + dslHash; - } - - private PythonCompiledRule createCompiledRule(ASTRulesDSL astRule, String pythonCode, String ruleName) { - String finalRuleName = ruleName != null ? ruleName : - (astRule.getName() != null ? astRule.getName() : "unnamed_rule"); - - // Use description if available, otherwise use name - String description = astRule.getDescription() != null && !astRule.getDescription().trim().isEmpty() - ? astRule.getDescription() - : astRule.getName(); - - return PythonCompiledRule.builder() - .ruleName(finalRuleName) - .description(description) - .version(astRule.getVersion() != null ? astRule.getVersion() : "1.0.0") - .pythonCode(pythonCode) - .functionName(pythonCodeGenerator.sanitizeFunctionName(finalRuleName)) - .inputVariables(pythonCodeGenerator.extractInputVariables(astRule)) - .outputVariables(pythonCodeGenerator.extractOutputVariables(astRule)) - .compiledAt(LocalDateTime.now()) - .sourceHash(String.valueOf(astRule.hashCode())) - .build(); - } - - /** - * Exception thrown when Python compilation fails. - */ - public static class PythonCompilationException extends FireflyException { - public PythonCompilationException(String message) { - super(message); - } - - public PythonCompilationException(String message, Throwable cause) { - super(message, cause); - } - } -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompiledRule.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompiledRule.java deleted file mode 100644 index eef00c6..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompiledRule.java +++ /dev/null @@ -1,161 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.compiler; - -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Data; -import lombok.NoArgsConstructor; - -import java.time.LocalDateTime; -import java.util.List; -import java.util.Map; - -/** - * Represents a compiled Python rule with all necessary metadata and code. - * This is the result of compiling a DSL rule to executable Python code. - */ -@Data -@Builder -@AllArgsConstructor -@NoArgsConstructor -public class PythonCompiledRule { - - /** - * Name of the original rule - */ - private String ruleName; - - /** - * Description of the rule - */ - private String description; - - /** - * Version of the rule - */ - private String version; - - /** - * Generated Python code - */ - private String pythonCode; - - /** - * List of input variable names expected by the rule - */ - private List inputVariables; - - /** - * Map of output variable names to their types - */ - private Map outputVariables; - - /** - * Timestamp when the rule was compiled - */ - private LocalDateTime compiledAt; - - /** - * Hash of the original DSL for cache invalidation - */ - private String sourceHash; - - /** - * Python function name (sanitized version of rule name) - */ - private String functionName; - - /** - * Required Python runtime dependencies - */ - private List dependencies; - - /** - * Compilation metadata - */ - private CompilationMetadata metadata; - - public PythonCompiledRule(String ruleName, String description, String version, - String pythonCode, List inputVariables, - Map outputVariables) { - this.ruleName = ruleName; - this.description = description; - this.version = version; - this.pythonCode = pythonCode; - this.inputVariables = inputVariables; - this.outputVariables = outputVariables; - this.compiledAt = LocalDateTime.now(); - this.functionName = sanitizeFunctionName(ruleName); - this.dependencies = List.of("firefly_runtime"); - } - - /** - * Get the main function name for this compiled rule - */ - public String getMainFunctionName() { - return functionName != null ? functionName : sanitizeFunctionName(ruleName); - } - - /** - * Check if the compiled rule is valid and executable - */ - public boolean isValid() { - return pythonCode != null && !pythonCode.trim().isEmpty() && - ruleName != null && !ruleName.trim().isEmpty(); - } - - /** - * Get the size of the generated Python code in bytes - */ - public int getCodeSize() { - return pythonCode != null ? pythonCode.getBytes().length : 0; - } - - /** - * Sanitize rule name to create a valid Python function name - */ - private String sanitizeFunctionName(String name) { - if (name == null) return "unnamed_rule"; - - String sanitized = name.toLowerCase() - .replaceAll("[^a-zA-Z0-9_]", "_") - .replaceAll("_{2,}", "_") - .replaceAll("^_|_$", ""); - - // Add underscore prefix if starts with number - if (sanitized.matches("^[0-9].*")) { - sanitized = "_" + sanitized; - } - - return sanitized; - } - - /** - * Compilation metadata for tracking and debugging - */ - @Data - @AllArgsConstructor - @NoArgsConstructor - public static class CompilationMetadata { - private String compilerVersion; - private long compilationTimeMs; - private int astNodeCount; - private List warnings; - private Map optimizations; - } -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/ASTRulesEvaluationEngine.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/ASTRulesEvaluationEngine.java index 43be71b..4ac0fed 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/ASTRulesEvaluationEngine.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/ASTRulesEvaluationEngine.java @@ -23,11 +23,13 @@ import org.fireflyframework.rules.core.dsl.condition.ExpressionCondition; import org.fireflyframework.rules.core.dsl.condition.LogicalCondition; import org.fireflyframework.rules.core.dsl.expression.*; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; import org.fireflyframework.rules.core.dsl.model.ASTRulesDSL; import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; import org.fireflyframework.rules.core.dsl.visitor.ActionExecutor; import org.fireflyframework.rules.core.dsl.visitor.EvaluationContext; import org.fireflyframework.rules.core.dsl.visitor.ExpressionEvaluator; +import org.fireflyframework.rules.core.observability.RuleEngineMetrics; import org.fireflyframework.rules.core.services.ConstantService; import org.fireflyframework.rules.core.services.JsonPathService; import org.fireflyframework.rules.core.services.RestCallService; @@ -39,6 +41,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import reactor.core.publisher.Mono; +import reactor.core.scheduler.Schedulers; import java.util.*; import java.util.stream.Collectors; @@ -55,40 +58,101 @@ public class ASTRulesEvaluationEngine { private final ConstantService constantService; private final RestCallService restCallService; private final JsonPathService jsonPathService; + private final CustomFunctionRegistry customFunctions; + private final RuleEngineMetrics metrics; + private final org.fireflyframework.rules.core.dsl.function.RuleInvoker ruleInvoker; /** - * Primary constructor for Spring dependency injection - * RestCallService and JsonPathService are optional and will use defaults if not provided + * Primary constructor for Spring dependency injection. + *

+ * {@code restCallService}, {@code jsonPathService}, {@code customFunctions}, and + * {@code metrics} are optional. When absent, REST/JSON built-ins fall back to internal + * default implementations, no user-registered functions are available, and no metrics + * are recorded. */ @Autowired public ASTRulesEvaluationEngine(ASTRulesDSLParser parser, ConstantService constantService, @Autowired(required = false) RestCallService restCallService, - @Autowired(required = false) JsonPathService jsonPathService) { + @Autowired(required = false) JsonPathService jsonPathService, + @Autowired(required = false) CustomFunctionRegistry customFunctions, + @Autowired(required = false) RuleEngineMetrics metrics, + @Autowired(required = false) org.fireflyframework.rules.core.dsl.function.RuleInvoker ruleInvoker) { this.parser = Objects.requireNonNull(parser, "ASTRulesDSLParser cannot be null"); this.constantService = Objects.requireNonNull(constantService, "ConstantService cannot be null"); this.restCallService = restCallService != null ? restCallService : new RestCallServiceImpl(); this.jsonPathService = jsonPathService != null ? jsonPathService : new JsonPathServiceImpl(); + this.customFunctions = customFunctions; + this.metrics = metrics; + this.ruleInvoker = ruleInvoker; } /** - * Constructor with default REST and JSON services (for testing) + * Test-friendly constructor with default REST/JSON services and no custom function registry. */ public ASTRulesEvaluationEngine(ASTRulesDSLParser parser, ConstantService constantService) { this.parser = Objects.requireNonNull(parser, "ASTRulesDSLParser cannot be null"); this.constantService = Objects.requireNonNull(constantService, "ConstantService cannot be null"); this.restCallService = new RestCallServiceImpl(); this.jsonPathService = new JsonPathServiceImpl(); + this.customFunctions = null; + this.metrics = null; + this.ruleInvoker = null; + } + + /** + * Test-friendly 4-arg constructor (parser, constantService, restCallService, jsonPathService) + * preserved for backward compatibility with existing tests. Delegates to the wider form with + * {@code null} for the optional collaborators. + */ + public ASTRulesEvaluationEngine(ASTRulesDSLParser parser, + ConstantService constantService, + RestCallService restCallService, + JsonPathService jsonPathService) { + this(parser, constantService, restCallService, jsonPathService, null, null, null); + } + + /** + * Test-friendly 5-arg constructor (parser, constantService, restCallService, jsonPathService, + * customFunctions) preserved for backward compatibility with existing tests. + */ + public ASTRulesEvaluationEngine(ASTRulesDSLParser parser, + ConstantService constantService, + RestCallService restCallService, + JsonPathService jsonPathService, + CustomFunctionRegistry customFunctions) { + this(parser, constantService, restCallService, jsonPathService, customFunctions, null, null); + } + + /** + * Test-friendly 6-arg constructor preserved for backward compatibility. + */ + public ASTRulesEvaluationEngine(ASTRulesDSLParser parser, + ConstantService constantService, + RestCallService restCallService, + JsonPathService jsonPathService, + CustomFunctionRegistry customFunctions, + RuleEngineMetrics metrics) { + this(parser, constantService, restCallService, jsonPathService, customFunctions, metrics, null); } /** - * Evaluate rules against the provided input data + * Evaluate rules against the provided input data. + *

+ * The visitor-based evaluator is synchronous and may transitively block (e.g., built-in + * REST/JSON functions). To avoid stalling the Netty event loop, the evaluation step is + * scheduled on {@code Schedulers.boundedElastic()} which is designed for blocking work. */ public Mono evaluateRulesReactive(String rulesDefinition, Map inputData) { long startTime = System.currentTimeMillis(); - return parser.parseRulesReactive(rulesDefinition) + Mono pipeline = parser.parseRulesReactive(rulesDefinition) + .doOnSuccess(dsl -> { if (metrics != null) metrics.recordCompilation(true); }) + .doOnError(e -> { if (metrics != null) metrics.recordCompilation(false); }) .flatMap(rulesDSL -> createEvaluationContextReactive(rulesDSL, inputData) - .map(context -> evaluateRules(rulesDSL, context))) + .flatMap(context -> applyTimeout(rulesDSL, + Mono.fromCallable(() -> evaluateRules(rulesDSL, context)) + .subscribeOn(Schedulers.boundedElastic()))) + .doOnSuccess(result -> recordEvaluationOutcome(rulesDSL, result))) .onErrorResume(error -> { long executionTime = System.currentTimeMillis() - startTime; JsonLogger.error(log, "Rules evaluation failed", error); @@ -103,6 +167,42 @@ public Mono evaluateRulesReactive(String rulesDefiniti .executionTimeMs(executionTime) .build()); }); + return pipeline; + } + + /** + * Wrap evaluation in a Reactor timeout if the rule declared one. Timeout failures map + * to a clean fail-loud result rather than an uncaught TimeoutException. + */ + private Mono applyTimeout(ASTRulesDSL rulesDSL, Mono mono) { + if (rulesDSL.getTimeoutMs() == null || rulesDSL.getTimeoutMs() <= 0) return mono; + java.time.Duration limit = java.time.Duration.ofMillis(rulesDSL.getTimeoutMs()); + return mono.timeout(limit, Mono.just(ASTRulesEvaluationResult.builder() + .success(false) + .error("Rule '" + (rulesDSL.getName() != null ? rulesDSL.getName() : "anonymous") + + "' exceeded its declared timeout of " + rulesDSL.getTimeoutMs() + "ms") + .build())); + } + + /** + * Record per-rule metrics for a completed evaluation. The rule id is taken from the + * rule's {@code name} (or {@code "anonymous"} if not declared). No-op if no + * {@link RuleEngineMetrics} bean is wired in. + */ + private void recordEvaluationOutcome(ASTRulesDSL rulesDSL, ASTRulesEvaluationResult result) { + if (metrics == null) return; + String ruleId = rulesDSL.getName() != null && !rulesDSL.getName().isBlank() + ? rulesDSL.getName() : "anonymous"; + if (!result.isSuccess()) { + metrics.recordUnmatched(ruleId); + } else if (result.isCircuitBreakerTriggered()) { + metrics.recordUnmatched(ruleId); + } else if (!result.isConditionResult()) { + metrics.recordUnmatched(ruleId); + } + // Note: matched/error metrics for the success path are recorded by the timer wrapper + // when the engine is invoked via timedEvaluation. For direct evaluateRulesReactive + // callers we record only the unmatched case here to avoid double-counting. } /** @@ -113,12 +213,14 @@ public ASTRulesEvaluationResult evaluateRules(String rulesDefinition, Map evaluateRulesReactive(ASTRulesDSL rulesDSL, Map inputData) { long startTime = System.currentTimeMillis(); return createEvaluationContextReactive(rulesDSL, inputData) - .map(context -> evaluateRules(rulesDSL, context)) + .flatMap(context -> Mono.fromCallable(() -> evaluateRules(rulesDSL, context)) + .subscribeOn(Schedulers.boundedElastic())) .onErrorResume(error -> { long executionTime = System.currentTimeMillis() - startTime; JsonLogger.error(log, "Rules evaluation failed", error); @@ -154,9 +256,13 @@ private ASTRulesEvaluationResult evaluateRules(ASTRulesDSL rulesDSL, EvaluationC boolean conditionResult = false; // Declare outside try block for circuit breaker catch try { - + + // DMN-style decision table takes precedence when present. + if (rulesDSL.isDecisionTable()) { + conditionResult = evaluateDecisionTable(rulesDSL.getDecisionTable(), context); + } // Handle simplified syntax (when/then/else) - if (rulesDSL.isSimpleSyntax()) { + else if (rulesDSL.isSimpleSyntax()) { conditionResult = evaluateConditions(rulesDSL.getWhenConditions(), context); if (conditionResult && rulesDSL.getThenActions() != null) { @@ -239,21 +345,25 @@ private boolean evaluateConditions(List conditions, EvaluationContext for (int i = 0; i < conditions.size(); i++) { Condition condition = conditions.get(i); + ExpressionEvaluator evaluator = new ExpressionEvaluator(context, restCallService, jsonPathService, customFunctions, ruleInvoker); + Object result; try { - ExpressionEvaluator evaluator = new ExpressionEvaluator(context, restCallService, jsonPathService); - Object result = condition.accept(evaluator); - boolean boolResult = toBoolean(result); - - JsonLogger.info(log, context.getOperationId(), - String.format("Condition %d evaluation: %s = %s", i + 1, condition.toDebugString(), boolResult)); - - if (!boolResult) { - JsonLogger.info(log, context.getOperationId(), "Condition failed - short-circuiting evaluation"); - return false; - } - } catch (Exception e) { - String operationId = context.getOperationId(); - JsonLogger.error(log, operationId, "Error evaluating condition: " + condition.toDebugString(), e); + result = condition.accept(evaluator); + } catch (RuntimeException e) { + // Propagate so the outer evaluateRules() handler reports success=false + // with the real cause; swallowing here would silently flip rules to the + // else branch and mask authoring or data bugs. + throw new RuleEvaluationException( + "Failed to evaluate condition " + (i + 1) + " (" + condition.toDebugString() + "): " + + e.getMessage(), e); + } + + boolean boolResult = toBoolean(result); + JsonLogger.info(log, context.getOperationId(), + String.format("Condition %d evaluation: %s = %s", i + 1, condition.toDebugString(), boolResult)); + + if (!boolResult) { + JsonLogger.info(log, context.getOperationId(), "Condition failed - short-circuiting evaluation"); return false; } } @@ -278,25 +388,100 @@ private void executeActions(List actions, EvaluationContext context) { JsonLogger.info(log, context.getOperationId(), String.format("Executing action %d: %s", i + 1, action.toDebugString())); - ActionExecutor executor = new ActionExecutor(context, restCallService, jsonPathService); + ActionExecutor executor = new ActionExecutor(context, restCallService, jsonPathService, customFunctions, ruleInvoker); action.accept(executor); JsonLogger.info(log, context.getOperationId(), String.format("Action %d completed successfully", i + 1)); } catch (org.fireflyframework.rules.core.dsl.exception.CircuitBreakerException e) { - // Circuit breaker is a controlled stop, not an error JsonLogger.info(log, context.getOperationId(), "Circuit breaker triggered: " + e.getCircuitBreakerMessage() + " - stopping execution"); - // Re-throw to stop execution immediately throw e; - } catch (Exception e) { - String operationId = context.getOperationId(); - JsonLogger.error(log, operationId, "Error executing action: " + action.toDebugString(), e); + } catch (RuntimeException e) { + // Fail-fast: the previous swallow-and-continue policy let later actions + // read variables that the failing action never set, masking the real cause. + // The outer evaluateRules() catch converts this into success=false with the + // original message preserved. + throw new RuleEvaluationException( + "Failed to execute action " + (i + 1) + " (" + action.toDebugString() + "): " + + e.getMessage(), e); } } JsonLogger.info(log, context.getOperationId(), "All actions completed"); } + /** + * Evaluate a DMN-style decision table. Walks each row, tests the row's `when` predicates, + * and -- depending on the hit policy -- collects, picks first, or enforces uniqueness of + * matching rows' outputs. The resulting outputs are written into the context's computed + * variables and become part of the rule's output map. + */ + private boolean evaluateDecisionTable(ASTRulesDSL.ASTDecisionTable table, EvaluationContext context) { + if (table == null || table.getRows() == null || table.getRows().isEmpty()) { + return false; + } + java.util.List matches = new java.util.ArrayList<>(); + ASTRulesDSL.ASTDecisionRow fallback = null; + for (ASTRulesDSL.ASTDecisionRow row : table.getRows()) { + if (row.isOtherwise()) { fallback = row; continue; } + boolean ok = row.getWhen() == null || row.getWhen().isEmpty() + || evaluateConditions(row.getWhen(), context); + if (ok) matches.add(row); + } + if (matches.isEmpty() && fallback != null) matches.add(fallback); + if (matches.isEmpty()) return false; + + ASTRulesDSL.HitPolicy policy = table.getHitPolicy() != null ? table.getHitPolicy() : ASTRulesDSL.HitPolicy.FIRST; + ExpressionEvaluator evaluator = new ExpressionEvaluator(context, restCallService, jsonPathService, customFunctions, ruleInvoker); + switch (policy) { + case FIRST, ANY -> applyDecisionRow(matches.get(0), evaluator, context); + case UNIQUE -> { + if (matches.size() > 1) { + throw new RuleEvaluationException( + "Decision table hit_policy=UNIQUE expects exactly one matching row but " + matches.size() + " matched"); + } + applyDecisionRow(matches.get(0), evaluator, context); + } + case COLLECT -> { + java.util.Map> grouped = new java.util.LinkedHashMap<>(); + for (ASTRulesDSL.ASTDecisionRow row : matches) { + if (row.getOutputs() == null) continue; + for (var e : row.getOutputs().entrySet()) { + Object val = evaluateOutputCell(e.getValue(), evaluator); + grouped.computeIfAbsent(e.getKey(), k -> new java.util.ArrayList<>()).add(val); + } + } + grouped.forEach(context::setComputedVariable); + } + } + return true; + } + + private void applyDecisionRow(ASTRulesDSL.ASTDecisionRow row, ExpressionEvaluator evaluator, EvaluationContext context) { + if (row.getOutputs() == null) return; + for (var e : row.getOutputs().entrySet()) { + context.setComputedVariable(e.getKey(), evaluateOutputCell(e.getValue(), evaluator)); + } + } + + private Object evaluateOutputCell(Object raw, ExpressionEvaluator evaluator) { + // Numbers, booleans, lists, maps pass through unchanged. + // Strings default to literals (DMN-style); prefix with '=' to mark an expression + // that should be parsed and evaluated against the current context. + if (!(raw instanceof String s)) return raw; + String trimmed = s.trim(); + if (trimmed.startsWith("=")) { + String expr = trimmed.substring(1).trim(); + try { + return parser.getDslParser().parseExpression(expr).accept(evaluator); + } catch (RuntimeException ex) { + throw new RuleEvaluationException( + "Decision table: failed to evaluate expression '" + expr + "': " + ex.getMessage(), ex); + } + } + return s; + } + /** * Evaluate multiple rules using AST */ @@ -354,29 +539,28 @@ private boolean evaluateConditionalBlock(ASTRulesDSL.ASTConditionalBlock conditi if (conditionalBlock == null || conditionalBlock.getIfCondition() == null) { return false; } - + + ExpressionEvaluator evaluator = new ExpressionEvaluator(context, restCallService, jsonPathService, customFunctions, ruleInvoker); + Object result; try { - // Evaluate the condition using AST - ExpressionEvaluator evaluator = new ExpressionEvaluator(context, restCallService, jsonPathService); - Object result = conditionalBlock.getIfCondition().accept(evaluator); - boolean conditionResult = toBoolean(result); - - // Execute appropriate action block - ASTRulesDSL.ASTActionBlock actionBlock = conditionResult ? - conditionalBlock.getThenBlock() : - conditionalBlock.getElseBlock(); - - if (actionBlock != null) { - executeActionBlock(actionBlock, context); - } - - return conditionResult; - - } catch (Exception e) { - String operationId = context.getOperationId(); - JsonLogger.error(log, operationId, "Error evaluating conditional block", e); - return false; + result = conditionalBlock.getIfCondition().accept(evaluator); + } catch (RuntimeException e) { + // Propagate so the rule reports the real cause instead of silently falling + // through to the else branch. + throw new RuleEvaluationException( + "Failed to evaluate conditional block 'if' clause: " + e.getMessage(), e); + } + boolean conditionResult = toBoolean(result); + + ASTRulesDSL.ASTActionBlock actionBlock = conditionResult ? + conditionalBlock.getThenBlock() : + conditionalBlock.getElseBlock(); + + if (actionBlock != null) { + executeActionBlock(actionBlock, context); } + + return conditionResult; } /** @@ -395,7 +579,6 @@ private void executeActionBlock(ASTRulesDSL.ASTActionBlock actionBlock, Evaluati executeActions(actionBlock.getActions(), context); } - // Handle nested conditional blocks - this was the TODO that's now implemented! if (actionBlock.getNestedConditions() != null) { evaluateConditionalBlock(actionBlock.getNestedConditions(), context); } @@ -407,7 +590,13 @@ private void executeActionBlock(ASTRulesDSL.ASTActionBlock actionBlock, Evaluati private Mono createEvaluationContextReactive(ASTRulesDSL rulesDSL, Map inputData) { JsonLogger.info(log, "createEvaluationContextReactive called for rule: " + rulesDSL.getName()); String operationId = UUID.randomUUID().toString(); - EvaluationContext context = new EvaluationContext(operationId, inputData != null ? inputData : new HashMap<>()); + // Apply declared input defaults for any variable the caller omitted. Caller-provided + // values always win; this only fills the gaps so rule authors can rely on the + // declared default appearing in the context. + Map effectiveInputs = new HashMap<>(); + if (rulesDSL.getInputDefaults() != null) effectiveInputs.putAll(rulesDSL.getInputDefaults()); + if (inputData != null) effectiveInputs.putAll(inputData); + EvaluationContext context = new EvaluationContext(operationId, effectiveInputs); // Log the start of rule evaluation early so it appears even if constants loading fails JsonLogger.info(log, operationId, "Starting AST-based rule evaluation: " + rulesDSL.getName()); @@ -666,12 +855,6 @@ public Void visitExpressionCondition(ExpressionCondition node) { return null; } - @Override - public Void visitAssignmentAction(AssignmentAction node) { - node.getValue().accept(this); - return null; - } - @Override public Void visitCalculateAction(CalculateAction node) { node.getExpression().accept(this); @@ -737,16 +920,6 @@ public Void visitFunctionCallExpression(FunctionCallExpression node) { return null; } - @Override - public Void visitArithmeticExpression(ArithmeticExpression node) { - if (node.getOperands() != null) { - node.getOperands().forEach(operand -> operand.accept(this)); - } - return null; - } - - - @Override public Void visitArithmeticAction(ArithmeticAction node) { if (node.getValue() != null) { @@ -819,32 +992,5 @@ public Void visitDoWhileAction(DoWhileAction node) { return null; } - - @Override - public Void visitJsonPathExpression(JsonPathExpression node) { - // Visit the source expression to collect any variable references - if (node.getSourceExpression() != null) { - node.getSourceExpression().accept(this); - } - return null; - } - - @Override - public Void visitRestCallExpression(RestCallExpression node) { - // Visit all expressions to collect any variable references - if (node.getUrlExpression() != null) { - node.getUrlExpression().accept(this); - } - if (node.getBodyExpression() != null) { - node.getBodyExpression().accept(this); - } - if (node.getHeadersExpression() != null) { - node.getHeadersExpression().accept(this); - } - if (node.getTimeoutExpression() != null) { - node.getTimeoutExpression().accept(this); - } - return null; - } } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/RuleEvaluationException.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/RuleEvaluationException.java new file mode 100644 index 0000000..dd6310a --- /dev/null +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/evaluation/RuleEvaluationException.java @@ -0,0 +1,36 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl.evaluation; + +/** + * Raised when an action or condition fails during rule evaluation. + *

+ * The engine wraps the underlying failure (e.g. unknown function, type-coercion error, + * division by zero, missing variable) with the index of the offending action or condition + * and its source debug string so the outer evaluator can report a precise + * {@code success=false} result instead of silently flipping to the else branch. + */ +public class RuleEvaluationException extends RuntimeException { + + public RuleEvaluationException(String message) { + super(message); + } + + public RuleEvaluationException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/exception/ASTException.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/exception/ASTException.java index 38f38ec..55bc374 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/exception/ASTException.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/exception/ASTException.java @@ -55,6 +55,10 @@ public ASTException(String message, SourceLocation location) { public ASTException(String message) { this(message, null, "AST_GENERIC", List.of(), null); } + + public ASTException(String message, Throwable cause) { + this(message, null, "AST_GENERIC", List.of(), cause); + } /** * Get a detailed error message with location and suggestions diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/ArithmeticExpression.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/ArithmeticExpression.java deleted file mode 100644 index 591b3b0..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/ArithmeticExpression.java +++ /dev/null @@ -1,103 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.expression; - -import org.fireflyframework.rules.core.dsl.ASTVisitor; -import org.fireflyframework.rules.core.dsl.SourceLocation; -import lombok.Data; -import lombok.EqualsAndHashCode; - -import java.util.List; -import java.util.stream.Collectors; - -/** - * Represents an arithmetic expression with multiple operands. - * Examples: add(a, b, c), multiply(x, y), max(values...) - */ -@Data -@EqualsAndHashCode(callSuper = true) -public class ArithmeticExpression extends Expression { - - /** - * The arithmetic operation to perform - */ - private ArithmeticOperation operation; - - /** - * Operands for the arithmetic operation - */ - private List operands; - - public ArithmeticExpression(SourceLocation location, ArithmeticOperation operation, List operands) { - super(location); - this.operation = operation; - this.operands = operands; - } - - @Override - public T accept(ASTVisitor visitor) { - return visitor.visitArithmeticExpression(this); - } - - @Override - public ExpressionType getExpressionType() { - return ExpressionType.NUMBER; - } - - @Override - public boolean isConstant() { - return operands != null && operands.stream().allMatch(Expression::isConstant); - } - - @Override - public boolean hasVariableReferences() { - return operands != null && operands.stream().anyMatch(Expression::hasVariableReferences); - } - - @Override - public String toDebugString() { - if (operands == null || operands.isEmpty()) { - return operation.getSymbol() + "()"; - } - - String args = operands.stream() - .map(Expression::toDebugString) - .collect(Collectors.joining(", ")); - - return operation.getSymbol() + "(" + args + ")"; - } - - /** - * Get the number of operands - */ - public int getOperandCount() { - return operands != null ? operands.size() : 0; - } - - /** - * Get a specific operand by index - */ - public Expression getOperand(int index) { - if (operands == null || index < 0 || index >= operands.size()) { - throw new IndexOutOfBoundsException("Operand index out of bounds: " + index); - } - return operands.get(index); - } -} - - - diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/ArithmeticOperation.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/ArithmeticOperation.java deleted file mode 100644 index ec1ecb9..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/ArithmeticOperation.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.expression; - -/** - * Enumeration of arithmetic operations. - */ -public enum ArithmeticOperation { - // Basic arithmetic - ADD("add", "+", 6), - SUBTRACT("subtract", "-", 6), - MULTIPLY("multiply", "*", 7), - DIVIDE("divide", "/", 7), - MODULO("modulo", "%", 7), - POWER("power", "^", 8), - - // Mathematical functions - ABS("abs", "abs", 9), - MIN("min", "min", 9), - MAX("max", "max", 9), - ROUND("round", "round", 9), - FLOOR("floor", "floor", 9), - CEIL("ceil", "ceil", 9), - SQRT("sqrt", "sqrt", 9), - SUM("sum", "sum", 9), - AVERAGE("average", "avg", 9); - - private final String name; - private final String symbol; - private final int precedence; - - ArithmeticOperation(String name, String symbol, int precedence) { - this.name = name; - this.symbol = symbol; - this.precedence = precedence; - } - - public String getName() { - return name; - } - - public String getSymbol() { - return symbol; - } - - public int getPrecedence() { - return precedence; - } - - public int getMinOperands() { - return switch (this) { - case ABS, ROUND, FLOOR, CEIL, SQRT -> 1; - case MIN, MAX -> 2; - case SUM, AVERAGE -> 1; // Can take 1 or more - default -> 2; // Binary operations - }; - } - - public int getMaxOperands() { - return switch (this) { - case ABS, ROUND, FLOOR, CEIL, SQRT -> 1; - case SUM, AVERAGE -> Integer.MAX_VALUE; // Can take any number - default -> 2; // Binary operations - }; - } - - public static ArithmeticOperation fromSymbol(String symbol) { - for (ArithmeticOperation op : values()) { - if (op.symbol.equals(symbol)) { - return op; - } - } - throw new IllegalArgumentException("Unknown arithmetic operation: " + symbol); - } -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/JsonPathExpression.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/JsonPathExpression.java deleted file mode 100644 index c3779c1..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/JsonPathExpression.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.expression; - -import org.fireflyframework.rules.core.dsl.ASTVisitor; -import org.fireflyframework.rules.core.dsl.SourceLocation; -import lombok.Data; -import lombok.EqualsAndHashCode; - -/** - * Represents a JSON path expression for accessing nested JSON values. - * Examples: - * - user.name (access name property of user object) - * - users[0].email (access email of first user in array) - * - response.data.items[2].price (deep nested access) - * - todos.length (get array length) - */ -@Data -@EqualsAndHashCode(callSuper = true) -public class JsonPathExpression extends Expression { - - /** - * The source expression that contains the JSON data - */ - private Expression sourceExpression; - - /** - * The JSON path to access (e.g., "user.name", "items[0].price") - */ - private String jsonPath; - - public JsonPathExpression(SourceLocation location, Expression sourceExpression, String jsonPath) { - super(location); - this.sourceExpression = sourceExpression; - this.jsonPath = jsonPath; - } - - @Override - public T accept(ASTVisitor visitor) { - return visitor.visitJsonPathExpression(this); - } - - @Override - public ExpressionType getExpressionType() { - // JSON path can return any type depending on the path - return ExpressionType.ANY; - } - - @Override - public boolean isConstant() { - // JSON path expressions are not constant since they depend on runtime data - return false; - } - - @Override - public boolean hasVariableReferences() { - return sourceExpression != null && sourceExpression.hasVariableReferences(); - } - - @Override - public String toDebugString() { - return String.format("JsonPath(%s.%s)", - sourceExpression != null ? sourceExpression.toDebugString() : "null", - jsonPath); - } -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/RestCallExpression.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/RestCallExpression.java deleted file mode 100644 index 0873ac1..0000000 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/expression/RestCallExpression.java +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.expression; - -import org.fireflyframework.rules.core.dsl.ASTVisitor; -import org.fireflyframework.rules.core.dsl.SourceLocation; -import lombok.Data; -import lombok.EqualsAndHashCode; - -/** - * Represents a REST API call expression. - * Examples: - * - rest_get("https://api.example.com/users/123") - * - rest_post("https://api.example.com/users", {"name": "John", "email": "john@example.com"}) - * - rest_put("https://api.example.com/users/123", userData, {"Authorization": "Bearer token"}) - */ -@Data -@EqualsAndHashCode(callSuper = true) -public class RestCallExpression extends Expression { - - /** - * HTTP method (GET, POST, PUT, DELETE, etc.) - */ - private String httpMethod; - - /** - * URL expression for the REST endpoint - */ - private Expression urlExpression; - - /** - * Optional request body expression (for POST, PUT, etc.) - */ - private Expression bodyExpression; - - /** - * Optional headers expression (Map) - */ - private Expression headersExpression; - - /** - * Optional timeout in milliseconds - */ - private Expression timeoutExpression; - - public RestCallExpression(SourceLocation location, String httpMethod, Expression urlExpression) { - super(location); - this.httpMethod = httpMethod.toUpperCase(); - this.urlExpression = urlExpression; - } - - public RestCallExpression(SourceLocation location, String httpMethod, Expression urlExpression, - Expression bodyExpression, Expression headersExpression, Expression timeoutExpression) { - super(location); - this.httpMethod = httpMethod.toUpperCase(); - this.urlExpression = urlExpression; - this.bodyExpression = bodyExpression; - this.headersExpression = headersExpression; - this.timeoutExpression = timeoutExpression; - } - - @Override - public T accept(ASTVisitor visitor) { - return visitor.visitRestCallExpression(this); - } - - @Override - public ExpressionType getExpressionType() { - // REST calls return JSON objects/arrays - return ExpressionType.ANY; - } - - @Override - public boolean isConstant() { - // REST calls are never constant since they involve external API calls - return false; - } - - @Override - public boolean hasVariableReferences() { - return (urlExpression != null && urlExpression.hasVariableReferences()) || - (bodyExpression != null && bodyExpression.hasVariableReferences()) || - (headersExpression != null && headersExpression.hasVariableReferences()) || - (timeoutExpression != null && timeoutExpression.hasVariableReferences()); - } - - @Override - public String toDebugString() { - StringBuilder sb = new StringBuilder(); - sb.append("RestCall(").append(httpMethod).append(" "); - sb.append(urlExpression != null ? urlExpression.toDebugString() : "null"); - - if (bodyExpression != null) { - sb.append(", body=").append(bodyExpression.toDebugString()); - } - if (headersExpression != null) { - sb.append(", headers=").append(headersExpression.toDebugString()); - } - if (timeoutExpression != null) { - sb.append(", timeout=").append(timeoutExpression.toDebugString()); - } - - sb.append(")"); - return sb.toString(); - } -} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/CustomFunctionRegistry.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/CustomFunctionRegistry.java new file mode 100644 index 0000000..337fd1d --- /dev/null +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/CustomFunctionRegistry.java @@ -0,0 +1,102 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl.function; + +import org.springframework.stereotype.Component; + +import java.util.Collections; +import java.util.Locale; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +/** + * Registry of user-defined {@link RuleFunction} implementations available to the rule DSL. + *

+ * The registry is consulted before the built-in function catalog, allowing applications to + * extend or override the engine without modifying its source. + * + *

Registration

+ * 
{@code
+ * @Configuration
+ * class MyRulesConfig {
+ *     @Bean
+ *     CommandLineRunner registerCustomFunctions(CustomFunctionRegistry registry) {
+ *         return args -> registry.register("my_score", a -> myScoring((Number) a[0]));
+ *     }
+ * }
+ * }
+ * + *

Lookups are case-insensitive. The registry is thread-safe. + */ +@Component +public class CustomFunctionRegistry { + + private final Map functions = new ConcurrentHashMap<>(); + + /** + * Register a function under the given name. If a function with the same name (ignoring case) + * is already registered, it is replaced. + * + * @param name the function name as referenced from the DSL; must not be {@code null} or blank + * @param function the function implementation; must not be {@code null} + * @throws IllegalArgumentException if {@code name} is blank or {@code function} is {@code null} + */ + public void register(String name, RuleFunction function) { + if (name == null || name.isBlank()) { + throw new IllegalArgumentException("Function name must not be blank"); + } + if (function == null) { + throw new IllegalArgumentException("Function must not be null"); + } + functions.put(name.toLowerCase(Locale.ROOT), function); + } + + /** + * Remove a registered function by name. No-op if the name is not registered. + * + * @return {@code true} if the function existed and was removed + */ + public boolean unregister(String name) { + if (name == null) return false; + return functions.remove(name.toLowerCase(Locale.ROOT)) != null; + } + + /** + * Look up a registered function by name (case-insensitive). + */ + public Optional lookup(String name) { + if (name == null) return Optional.empty(); + return Optional.ofNullable(functions.get(name.toLowerCase(Locale.ROOT))); + } + + /** + * Return the names of all currently registered functions (case folded to lower-case). + * The returned set is an immutable snapshot. + */ + public Set registeredNames() { + return Collections.unmodifiableSet(Set.copyOf(functions.keySet())); + } + + /** + * Whether a function with the given name (case-insensitive) is registered. + */ + public boolean contains(String name) { + return lookup(name).isPresent(); + } +} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/RuleFunction.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/RuleFunction.java new file mode 100644 index 0000000..6a0f99d --- /dev/null +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/RuleFunction.java @@ -0,0 +1,48 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl.function; + +/** + * Pluggable function callable from the rule DSL via the {@code call} action or as part of an + * expression (e.g., {@code calculate result as my_function(amount, rate)}). + *

+ * Implementations are registered with {@link CustomFunctionRegistry}. Custom functions are + * looked up before the built-in catalog, so a registration with the same name as a + * built-in (e.g., {@code "max"}) deliberately shadows the built-in. Names are matched + * case-insensitively. + * + *

Contract

+ *
    + *
  • Arguments arrive as evaluated values (literals, resolved variables, or nested + * function results) -- not as AST nodes.
    • + *
  • Implementations should throw {@link IllegalArgumentException} for invalid argument + * counts or types; the evaluator surfaces these to the caller.
    • + *
  • Implementations must be thread-safe; the same instance can be invoked concurrently + * across rule evaluations.
    • + *
+ */ +@FunctionalInterface +public interface RuleFunction { + + /** + * Apply this function to the evaluated argument list. + * + * @param args evaluated argument values (may be empty, never {@code null}) + * @return the function result; may be {@code null} if the function legitimately returns a null value + */ + Object apply(Object[] args); +} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/RuleInvoker.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/RuleInvoker.java new file mode 100644 index 0000000..20fc5ce --- /dev/null +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/function/RuleInvoker.java @@ -0,0 +1,39 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + */ +package org.fireflyframework.rules.core.dsl.function; + +import java.util.Map; + +/** + * Cross-rule composition hook. Implementations resolve a stored rule by its + * {@code code} and evaluate it against the supplied inputs, returning the + * resulting output map. Used by the {@code invoke_rule(code, inputs)} built-in + * so rules can call other rules without coupling the evaluator directly to the + * services layer. + * + *

Implementations must be safe to call from a {@code Schedulers.boundedElastic()} + * worker (the synchronous visitor's host thread). They are expected to block + * until the invoked rule completes -- nested invocations cost a thread but keep + * the visitor model simple and avoid threading a Mono through the AST. + */ +public interface RuleInvoker { + + /** + * Synchronously evaluate the rule with the given code against the given inputs. + * + * @param code the stored rule's code (matches RuleDefinition.code) + * @param inputData the inputs passed to the nested rule + * @return the output map produced by the nested rule (never {@code null}; + * empty if the nested rule succeeded but produced no outputs) + * @throws RuntimeException if the rule does not exist, fails to parse, or the nested + * evaluation reports {@code success=false} + */ + Map invokeBlocking(String code, Map inputData); +} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/model/ASTRulesDSL.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/model/ASTRulesDSL.java index f733b72..d898074 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/model/ASTRulesDSL.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/model/ASTRulesDSL.java @@ -46,24 +46,30 @@ public class ASTRulesDSL { // Input/Output definitions private Map input; private Map output; - + + // Per-input default values (applied when caller omits the variable) + private Map inputDefaults; + // Constants private List constants; - + // Simple syntax support (when/then/else) private List whenConditions; private List thenActions; private List elseActions; - + // Complex syntax support (multiple rules) private List rules; - + // Complex conditions block private ASTConditionalBlock conditions; - // Circuit breaker configuration - private ASTCircuitBreakerConfig circuitBreaker; - + // DMN-style decision table block (mutually exclusive with the syntaxes above) + private ASTDecisionTable decisionTable; + + // Per-rule wall-clock timeout in milliseconds; 0 / null means no timeout. + private Long timeoutMs; + /** * AST-based sub-rule definition */ @@ -74,15 +80,65 @@ public class ASTRulesDSL { public static class ASTSubRule { private String name; private String description; - + + // Drools-style salience: higher priority sub-rules evaluate first. + // Default (when unspecified) is 0; sub-rules with equal priority preserve YAML order. + @Builder.Default + private int priority = 0; + // Simple syntax private List whenConditions; private List thenActions; private List elseActions; - + // Complex syntax private ASTConditionalBlock conditions; } + + /** + * DMN-style decision table. Each row is a list of input conditions plus a list + * of output assignments. The hit policy controls which matching rows contribute + * to the output. + */ + @Data + @Builder + @AllArgsConstructor + @NoArgsConstructor + public static class ASTDecisionTable { + private List inputs; + private List outputs; + @Builder.Default + private HitPolicy hitPolicy = HitPolicy.FIRST; + private List rows; + } + + @Data + @Builder + @AllArgsConstructor + @NoArgsConstructor + public static class ASTDecisionRow { + // Optional row label (for diagnostics) + private String name; + // Input conditions; each entry mirrors a normal `when:` predicate (string form). + // The evaluator parses them into ComparisonCondition at evaluation time. + private List when; + // Output assignments: column name -> value expression + private Map outputs; + // Optional fallback row -- if true, this row matches when no others did (DMN "else"). + @Builder.Default + private boolean otherwise = false; + } + + public enum HitPolicy { + /** First matching row wins. */ + FIRST, + /** Collect outputs from every matching row into a list per output column. */ + COLLECT, + /** Any matching row's outputs apply; rows must produce identical outputs. */ + ANY, + /** Exactly one row must match; otherwise the rule fails loudly. */ + UNIQUE + } /** * AST-based conditional block @@ -143,6 +199,13 @@ public boolean isMultipleRulesSyntax() { public boolean isComplexConditionsSyntax() { return conditions != null; } + + /** + * Check if this rule is a decision table. + */ + public boolean isDecisionTable() { + return decisionTable != null; + } /** * Get all conditions from this rule (regardless of syntax) @@ -208,17 +271,4 @@ public List getAllActions() { return List.of(); } - /** - * AST-based circuit breaker configuration - */ - @Data - @Builder - @AllArgsConstructor - @NoArgsConstructor - public static class ASTCircuitBreakerConfig { - private boolean enabled; - private int failureThreshold; - private String timeoutDuration; - private String recoveryTimeout; - } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ASTRulesDSLParser.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ASTRulesDSLParser.java index 5105dcd..0f68948 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ASTRulesDSLParser.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ASTRulesDSLParser.java @@ -33,8 +33,6 @@ import java.util.List; import java.util.Map; -import java.util.Objects; -import java.util.Optional; import java.util.stream.Collectors; /** @@ -46,6 +44,7 @@ @Slf4j public class ASTRulesDSLParser { + @lombok.Getter private final DSLParser dslParser; private final ObjectMapper yamlMapper = new ObjectMapper(new YAMLFactory()); private final ComplexConditionsParser complexConditionsParser; @@ -110,12 +109,11 @@ public Mono parseRulesReactive(String rulesDefinition) { } /** - * Parse rules definition from YAML string to AST model (synchronous) - * Uses caching to avoid re-parsing identical YAML content. - * - * @deprecated Use parseRulesReactive() instead for reactive contexts + * Parse rules definition from YAML to AST -- synchronous convenience wrapper around + * {@link #parseRulesReactive(String)}. Intended for non-reactive callers (tests, + * code generation, validation tools); reactive callers should subscribe to the Mono + * directly. Internally blocks; safe to call from non-event-loop threads. */ - @Deprecated public ASTRulesDSL parseRules(String rulesDefinition) { return parseRulesReactive(rulesDefinition).block(); } @@ -124,7 +122,11 @@ public ASTRulesDSL parseRules(String rulesDefinition) { * Internal method to parse rules definition without caching logic */ private ASTRulesDSL parseRulesInternal(String rulesDefinition) throws Exception { - // Parse YAML to Map first + // Pre-flight lint: catch the most common authoring trap (unquoted colon in action + // strings) and surface a clean error pointing to the offending line, instead of + // letting SnakeYAML throw a confusing parse error about an unexpected map. + lintYaml(rulesDefinition); + @SuppressWarnings("unchecked") Map yamlMap = yamlMapper.readValue(rulesDefinition, Map.class); @@ -132,6 +134,63 @@ private ASTRulesDSL parseRulesInternal(String rulesDefinition) throws Exception return convertToASTModel(yamlMap); } + /** + * Pre-parse lint pass. Scans for action-list entries containing an unquoted ':' + * (a string with a colon must be YAML-quoted, otherwise SnakeYAML interprets it as + * a sub-map). Throws ASTException with a precise line number when found. + */ + private static final java.util.regex.Pattern ACTION_VERB_LINE = java.util.regex.Pattern.compile( + "^\\s*-\\s+(set|calculate|run|call|add|subtract|multiply|divide|append|prepend|remove|log|print|invoke_rule|stop)\\b.*"); + + private void lintYaml(String yaml) { + String[] lines = yaml.split("\\r?\\n", -1); + for (int i = 0; i < lines.length; i++) { + String raw = lines[i]; + String body = raw; + // ignore comments + int hash = body.indexOf('#'); + if (hash >= 0) body = body.substring(0, hash); + if (!ACTION_VERB_LINE.matcher(body).matches()) continue; + // Strip enclosing single or double quotes on the value (lazy detection: look for + // matching quote starting after the verb) + String trimmed = body.trim(); + // Strip "- " prefix + String afterDash = trimmed.startsWith("- ") ? trimmed.substring(2).trim() : trimmed; + if (afterDash.startsWith("'") || afterDash.startsWith("\"")) continue; + // Look for an unquoted ': ' (colon followed by space) which YAML will interpret as map syntax + if (containsUnquotedColonSpace(afterDash)) { + throw new ASTException( + "YAML lint: line " + (i + 1) + " contains an unquoted ': ' inside an action -- " + + "wrap the action in single quotes. Offending line: '" + raw.trim() + "'"); + } + } + } + + private boolean containsUnquotedColonSpace(String s) { + boolean inSingle = false, inDouble = false; + int parenDepth = 0, braceDepth = 0, bracketDepth = 0; + for (int i = 0; i < s.length() - 1; i++) { + char c = s.charAt(i); + if (c == '\'' && !inDouble) inSingle = !inSingle; + else if (c == '"' && !inSingle) inDouble = !inDouble; + else if (!inSingle && !inDouble) { + switch (c) { + case '(' -> parenDepth++; + case ')' -> parenDepth = Math.max(0, parenDepth - 1); + case '{' -> braceDepth++; + case '}' -> braceDepth = Math.max(0, braceDepth - 1); + case '[' -> bracketDepth++; + case ']' -> bracketDepth = Math.max(0, bracketDepth - 1); + case ':' -> { + if (parenDepth == 0 && braceDepth == 0 && bracketDepth == 0 + && s.charAt(i + 1) == ' ') return true; + } + } + } + } + return false; + } + /** * Invalidate cached AST for specific YAML content. * Useful when rule definitions are updated. @@ -174,26 +233,33 @@ private ASTRulesDSL convertToASTModel(Map yamlMap) { builder.metadata(metadata); } - // Input/Output definitions - // Handle both 'input' and 'inputs' (both can be map format) - if (yamlMap.containsKey("input")) { - builder.input((Map) yamlMap.get("input")); - } else if (yamlMap.containsKey("inputs")) { - Object inputsObj = yamlMap.get("inputs"); - if (inputsObj instanceof Map) { - // inputs is a map format: inputs: {income: "number", debt: "number"} - builder.input((Map) inputsObj); - } else { - // inputs is a list format: inputs: [income, debt, age] - List inputsList = convertToStringList(inputsObj); - Map inputsMap = inputsList.stream() - .collect(Collectors.toMap( - inputName -> inputName, - inputName -> "Object" // Default type since inputs list doesn't specify types - )); - builder.input(inputsMap); + // Input definitions. Accepts three shapes: + // inputs: [creditScore, age] -- list of names (type = Object) + // inputs: {creditScore: "number", age: "number"} -- name -> type + // inputs: {creditScore: {type: "number", default: 0}} -- name -> {type, default} + // The richer form lets callers omit the variable; the declared default is then injected. + Map resolvedInputs = new java.util.LinkedHashMap<>(); + Map resolvedDefaults = new java.util.LinkedHashMap<>(); + Object inputsObj = yamlMap.containsKey("input") ? yamlMap.get("input") : yamlMap.get("inputs"); + if (inputsObj instanceof Map rawMap) { + for (Map.Entry e : rawMap.entrySet()) { + String name = String.valueOf(e.getKey()); + Object value = e.getValue(); + if (value instanceof Map spec) { + Object type = spec.get("type"); + resolvedInputs.put(name, type == null ? "Object" : type.toString()); + if (spec.containsKey("default")) { + resolvedDefaults.put(name, spec.get("default")); + } + } else { + resolvedInputs.put(name, value == null ? "Object" : value.toString()); + } } + } else if (inputsObj instanceof List rawList) { + for (Object item : rawList) resolvedInputs.put(String.valueOf(item), "Object"); } + if (!resolvedInputs.isEmpty()) builder.input(resolvedInputs); + if (!resolvedDefaults.isEmpty()) builder.inputDefaults(resolvedDefaults); // Handle both 'output' and 'outputs' (both can be map format) if (yamlMap.containsKey("output")) { @@ -243,15 +309,18 @@ private ASTRulesDSL convertToASTModel(Map yamlMap) { builder.elseActions(elseActions); } - // Multiple rules syntax + // Multiple rules syntax. Sub-rules are sorted by descending priority so a + // higher-`priority:` sub-rule evaluates first (DRL-style salience). Ties preserve + // YAML declaration order via a stable sort. if (yamlMap.containsKey("rules")) { List> rulesList = (List>) yamlMap.get("rules"); List rules = rulesList.stream() .map(this::convertToSubRule) .collect(Collectors.toList()); + rules.sort((a, b) -> Integer.compare(b.getPriority(), a.getPriority())); builder.rules(rules); } - + // Complex conditions syntax if (yamlMap.containsKey("conditions")) { Map conditionsMap = (Map) yamlMap.get("conditions"); @@ -259,15 +328,74 @@ private ASTRulesDSL convertToASTModel(Map yamlMap) { builder.conditions(conditions); } - // Circuit breaker configuration - if (yamlMap.containsKey("circuit_breaker")) { - Map circuitBreakerMap = (Map) yamlMap.get("circuit_breaker"); - ASTRulesDSL.ASTCircuitBreakerConfig circuitBreaker = convertToCircuitBreakerConfig(circuitBreakerMap); - builder.circuitBreaker(circuitBreaker); + // Decision-table (DMN-style) syntax. Mutually exclusive with the other top-level + // syntaxes; if both are present the explicit table takes precedence and the others + // are ignored. + if (yamlMap.containsKey("decision_table") || yamlMap.containsKey("decisionTable")) { + Object dt = yamlMap.containsKey("decision_table") ? yamlMap.get("decision_table") : yamlMap.get("decisionTable"); + if (dt instanceof Map dtMap) { + builder.decisionTable(convertToDecisionTable((Map) dtMap)); + } + } + + // Per-rule wall-clock timeout: accepts "5s", "500ms", or a raw number of milliseconds. + if (yamlMap.containsKey("timeout")) { + Long ms = parseTimeoutMs(yamlMap.get("timeout")); + if (ms != null && ms > 0) builder.timeoutMs(ms); } return builder.build(); } + + private Long parseTimeoutMs(Object raw) { + if (raw == null) return null; + if (raw instanceof Number n) return n.longValue(); + String s = raw.toString().trim().toLowerCase(); + try { + if (s.endsWith("ms")) return Long.parseLong(s.substring(0, s.length() - 2).trim()); + if (s.endsWith("s")) return (long) (Double.parseDouble(s.substring(0, s.length() - 1).trim()) * 1000L); + return Long.parseLong(s); + } catch (NumberFormatException e) { + throw new ASTException("Invalid timeout value '" + raw + "'. Expected number, '5s', or '500ms'."); + } + } + + @SuppressWarnings("unchecked") + private ASTRulesDSL.ASTDecisionTable convertToDecisionTable(Map dtMap) { + ASTRulesDSL.ASTDecisionTable.ASTDecisionTableBuilder b = ASTRulesDSL.ASTDecisionTable.builder(); + if (dtMap.containsKey("inputs")) b.inputs(convertToStringList(dtMap.get("inputs"))); + if (dtMap.containsKey("outputs")) b.outputs(convertToStringList(dtMap.get("outputs"))); + if (dtMap.containsKey("hit_policy") || dtMap.containsKey("hitPolicy")) { + String hp = String.valueOf(dtMap.containsKey("hit_policy") ? dtMap.get("hit_policy") : dtMap.get("hitPolicy")); + b.hitPolicy(ASTRulesDSL.HitPolicy.valueOf(hp.toUpperCase())); + } + List rows = new java.util.ArrayList<>(); + Object rawRows = dtMap.get("rules"); + if (rawRows == null) rawRows = dtMap.get("rows"); + if (rawRows instanceof List list) { + for (Object item : list) { + if (!(item instanceof Map rowMap)) continue; + ASTRulesDSL.ASTDecisionRow.ASTDecisionRowBuilder rb = ASTRulesDSL.ASTDecisionRow.builder(); + if (rowMap.get("name") instanceof String s) rb.name(s); + if (rowMap.get("otherwise") instanceof Boolean ow) rb.otherwise(ow); + Object whenObj = rowMap.get("when"); + if (whenObj != null) { + List whenStrings = convertToStringList(whenObj); + rb.when(whenStrings.stream().map(dslParser::parseCondition).collect(Collectors.toList())); + } + Object outObj = rowMap.get("then"); + if (outObj == null) outObj = rowMap.get("outputs"); + if (outObj instanceof Map outMap) { + Map outs = new java.util.LinkedHashMap<>(); + for (Map.Entry e : outMap.entrySet()) outs.put(String.valueOf(e.getKey()), e.getValue()); + rb.outputs(outs); + } + rows.add(rb.build()); + } + } + b.rows(rows); + return b.build(); + } /** * Convert to constant definition @@ -290,7 +418,8 @@ private ASTRulesDSL.ASTSubRule convertToSubRule(Map ruleMap) { builder.name((String) ruleMap.get("name")); builder.description((String) ruleMap.get("description")); - + if (ruleMap.get("priority") instanceof Number n) builder.priority(n.intValue()); + // Simple syntax if (ruleMap.containsKey("when")) { List whenStrings = convertToStringList(ruleMap.get("when")); @@ -300,22 +429,18 @@ private ASTRulesDSL.ASTSubRule convertToSubRule(Map ruleMap) { builder.whenConditions(whenConditions); } + // Sub-rules use the same action-parsing path as the top-level when/then/else so + // YAML-collapsed map-syntax actions (e.g. `- forEach x in xs: action`) work in + // both contexts. Routing through parseActionList preserves Map entries instead of + // calling toString() on them. if (ruleMap.containsKey("then")) { - List thenStrings = convertToStringList(ruleMap.get("then")); - List thenActions = thenStrings.stream() - .map(dslParser::parseAction) - .collect(Collectors.toList()); - builder.thenActions(thenActions); + builder.thenActions(parseActionList(ruleMap.get("then"))); } - + if (ruleMap.containsKey("else")) { - List elseStrings = convertToStringList(ruleMap.get("else")); - List elseActions = elseStrings.stream() - .map(dslParser::parseAction) - .collect(Collectors.toList()); - builder.elseActions(elseActions); + builder.elseActions(parseActionList(ruleMap.get("else"))); } - + // Complex syntax if (ruleMap.containsKey("conditions")) { Map conditionsMap = (Map) ruleMap.get("conditions"); @@ -373,7 +498,6 @@ private ASTRulesDSL.ASTActionBlock convertToActionBlock(Map acti builder.actions(actions); } - // Parse nested conditions - this was the TODO that's now implemented! if (actionMap.containsKey("conditions")) { Map nestedConditionsMap = (Map) actionMap.get("conditions"); ASTRulesDSL.ASTConditionalBlock nestedConditions = convertToConditionalBlock(nestedConditionsMap); @@ -384,7 +508,8 @@ private ASTRulesDSL.ASTActionBlock convertToActionBlock(Map acti } /** - * Parse actions list that can contain either simple syntax strings or complex syntax maps + * Parse actions list that can contain either simple syntax strings or complex syntax maps. + * Throws ASTException on any parse failure rather than silently dropping malformed actions. */ @SuppressWarnings("unchecked") private List parseActionsList(Object actionsObj) { @@ -392,7 +517,6 @@ private List parseActionsList(Object actionsObj) { List actionsList = (List) actionsObj; return actionsList.stream() .map(this::parseActionItem) - .filter(Objects::nonNull) .collect(Collectors.toList()); } else if (actionsObj instanceof String) { return List.of(dslParser.parseAction((String) actionsObj)); @@ -402,43 +526,42 @@ private List parseActionsList(Object actionsObj) { } /** - * Parse a single action item (either string or map) + * Parse a single action item (either string or map). + * Throws ASTException on unknown types or malformed action structures so that + * malformed rules surface immediately instead of silently losing actions. */ @SuppressWarnings("unchecked") private Action parseActionItem(Object actionObj) { + if (actionObj == null) { + throw new ASTException("Action entry cannot be null"); + } if (actionObj instanceof String) { return dslParser.parseAction((String) actionObj); } else if (actionObj instanceof Map) { Map actionMap = (Map) actionObj; - // Check if this is a single-entry map that might be a forEach/while/do-while action - // YAML interprets "forEach item in items: action" as {"forEach item in items": "action"} - // Same for "while condition: action" as {"while condition": "action"} - // Same for "do: action while condition" as {"do": "action while condition"} + // Single-entry maps like {"forEach item in items": "action"} originate from YAML + // collapsing simple loop syntax. Try the literal reconstruction first; if that + // does not match the lexer expectations, fall through to the structured-map path. if (actionMap.size() == 1) { Map.Entry entry = actionMap.entrySet().iterator().next(); String key = entry.getKey(); Object value = entry.getValue(); - // Check if key starts with forEach, while, or do if (key.startsWith("forEach ") || key.startsWith("while ") || key.equals("do")) { - // Reconstruct the action string String actionString = key + ": " + formatActionValue(value); try { - Action action = dslParser.parseAction(actionString); - return action; + return dslParser.parseAction(actionString); } catch (Exception e) { - log.warn("Failed to parse reconstructed loop action: {}", actionString, e); - // Fall through to complex action parsing + log.debug("Reconstructed loop parse failed for '{}', retrying as structured map", actionString); + // Fall through to complex action parsing. } } } - // Complex syntax: { set: { variable: "name", value: "value" } } return parseComplexAction(actionMap); } else { - log.warn("Unexpected action object type: {}", actionObj.getClass()); - return null; + throw new ASTException("Unsupported action entry type: " + actionObj.getClass().getName()); } } @@ -460,191 +583,115 @@ private String formatActionValue(Object value) { } /** - * Parse complex syntax action from map + * Parse complex map-shaped action and re-emit as the simple-syntax string the lexer expects. + * Throws ASTException on any parse failure so malformed entries never silently disappear. */ @SuppressWarnings("unchecked") private Action parseComplexAction(Map actionMap) { - // Handle different action types if (actionMap.containsKey("set")) { Map setMap = (Map) actionMap.get("set"); String variable = (String) setMap.get("variable"); Object value = setMap.get("value"); - - // Convert to simple syntax and parse - String simpleSyntax = "set " + variable + " to " + formatValue(value); - try { - return dslParser.parseAction(simpleSyntax); - } catch (Exception e) { - log.warn("Failed to parse complex set action: {}", actionMap, e); - return null; - } - } else if (actionMap.containsKey("calculate")) { + return parseReconstructed("set " + variable + " to " + formatValue(value), "set", actionMap); + } + if (actionMap.containsKey("calculate")) { Map calcMap = (Map) actionMap.get("calculate"); String variable = (String) calcMap.get("variable"); String expression = (String) calcMap.get("expression"); - - // Convert to simple syntax and parse - String simpleSyntax = "calculate " + variable + " as " + expression; - try { - return dslParser.parseAction(simpleSyntax); - } catch (Exception e) { - log.warn("Failed to parse complex calculate action: {}", actionMap, e); - return null; - } - } else if (actionMap.containsKey("run")) { + return parseReconstructed("calculate " + variable + " as " + expression, "calculate", actionMap); + } + if (actionMap.containsKey("run")) { Map runMap = (Map) actionMap.get("run"); String variable = (String) runMap.get("variable"); String expression = (String) runMap.get("expression"); - - // Convert to simple syntax and parse - String simpleSyntax = "run " + variable + " as " + expression; - try { - return dslParser.parseAction(simpleSyntax); - } catch (Exception e) { - log.warn("Failed to parse complex run action: {}", actionMap, e); - return null; - } - } else if (actionMap.containsKey("call")) { + return parseReconstructed("run " + variable + " as " + expression, "run", actionMap); + } + if (actionMap.containsKey("call")) { Map callMap = (Map) actionMap.get("call"); String function = (String) callMap.get("function"); List parameters = (List) callMap.get("parameters"); - - // Convert to simple syntax and parse String paramStr = parameters.stream() .map(this::formatValue) .collect(Collectors.joining(", ")); - String simpleSyntax = "call " + function + " with [" + paramStr + "]"; - try { - return dslParser.parseAction(simpleSyntax); - } catch (Exception e) { - log.warn("Failed to parse complex call action: {}", actionMap, e); - return null; - } - } else if (actionMap.containsKey("forEach")) { + return parseReconstructed("call " + function + " with [" + paramStr + "]", "call", actionMap); + } + if (actionMap.containsKey("forEach")) { Map forEachMap = (Map) actionMap.get("forEach"); String variable = (String) forEachMap.get("variable"); - String index = (String) forEachMap.get("index"); // optional + String index = (String) forEachMap.get("index"); Object inValue = forEachMap.get("in"); Object doValue = forEachMap.get("do"); - // Build simple syntax - StringBuilder simpleSyntax = new StringBuilder("forEach "); - simpleSyntax.append(variable); - + StringBuilder simpleSyntax = new StringBuilder("forEach ").append(variable); if (index != null && !index.trim().isEmpty()) { simpleSyntax.append(", ").append(index); } - - simpleSyntax.append(" in ").append(formatValue(inValue)); - simpleSyntax.append(": "); - - // Parse body actions - if (doValue instanceof List) { - List doList = (List) doValue; - List bodyActionStrings = new ArrayList<>(); - - for (Object actionObj : doList) { - if (actionObj instanceof String) { - bodyActionStrings.add((String) actionObj); - } else if (actionObj instanceof Map) { - // Recursively parse complex action and convert to string - Action bodyAction = parseComplexAction((Map) actionObj); - if (bodyAction != null) { - bodyActionStrings.add(bodyAction.toDebugString()); - } - } - } - - simpleSyntax.append(String.join("; ", bodyActionStrings)); - } else if (doValue instanceof String) { - simpleSyntax.append((String) doValue); - } - - try { - return dslParser.parseAction(simpleSyntax.toString()); - } catch (Exception e) { - log.warn("Failed to parse complex forEach action: {}", actionMap, e); - return null; - } - } else if (actionMap.containsKey("while")) { + simpleSyntax.append(" in ").append(formatValue(inValue)).append(": "); + appendLoopBody(doValue, simpleSyntax); + return parseReconstructed(simpleSyntax.toString(), "forEach", actionMap); + } + if (actionMap.containsKey("while")) { Map whileMap = (Map) actionMap.get("while"); String condition = (String) whileMap.get("condition"); Object doValue = whileMap.get("do"); - // Build simple syntax - StringBuilder simpleSyntax = new StringBuilder("while "); - simpleSyntax.append(condition); - simpleSyntax.append(": "); - - // Parse body actions - if (doValue instanceof List) { - List doList = (List) doValue; - List bodyActionStrings = new ArrayList<>(); - - for (Object actionObj : doList) { - if (actionObj instanceof String) { - bodyActionStrings.add((String) actionObj); - } else if (actionObj instanceof Map) { - // Recursively parse complex action and convert to string - Action bodyAction = parseComplexAction((Map) actionObj); - if (bodyAction != null) { - bodyActionStrings.add(bodyAction.toDebugString()); - } - } - } - - simpleSyntax.append(String.join("; ", bodyActionStrings)); - } else if (doValue instanceof String) { - simpleSyntax.append((String) doValue); - } - - try { - return dslParser.parseAction(simpleSyntax.toString()); - } catch (Exception e) { - log.warn("Failed to parse complex while action: {}", actionMap, e); - return null; - } - } else if (actionMap.containsKey("do")) { + StringBuilder simpleSyntax = new StringBuilder("while ").append(condition).append(": "); + appendLoopBody(doValue, simpleSyntax); + return parseReconstructed(simpleSyntax.toString(), "while", actionMap); + } + if (actionMap.containsKey("do")) { Map doWhileMap = (Map) actionMap.get("do"); Object doValue = doWhileMap.get("actions"); String condition = (String) doWhileMap.get("while"); - // Build simple syntax StringBuilder simpleSyntax = new StringBuilder("do: "); + appendLoopBody(doValue, simpleSyntax); + simpleSyntax.append(" while ").append(condition); + return parseReconstructed(simpleSyntax.toString(), "do-while", actionMap); + } + throw new ASTException("Unknown complex action type. Keys present: " + actionMap.keySet()); + } - // Parse body actions - if (doValue instanceof List) { - List doList = (List) doValue; - List bodyActionStrings = new ArrayList<>(); - - for (Object actionObj : doList) { - if (actionObj instanceof String) { - bodyActionStrings.add((String) actionObj); - } else if (actionObj instanceof Map) { - // Recursively parse complex action and convert to string - Action bodyAction = parseComplexAction((Map) actionObj); - if (bodyAction != null) { - bodyActionStrings.add(bodyAction.toDebugString()); - } - } + /** + * Reconstruct a loop body from a List of action entries or a single String into the + * semicolon-joined form the ActionParser consumes. + */ + @SuppressWarnings("unchecked") + private void appendLoopBody(Object doValue, StringBuilder out) { + if (doValue instanceof List) { + List doList = (List) doValue; + List bodyActionStrings = new ArrayList<>(); + for (Object actionObj : doList) { + if (actionObj instanceof String) { + bodyActionStrings.add((String) actionObj); + } else if (actionObj instanceof Map) { + Action bodyAction = parseComplexAction((Map) actionObj); + bodyActionStrings.add(bodyAction.toDebugString()); + } else { + throw new ASTException("Unsupported loop body entry type: " + + (actionObj == null ? "null" : actionObj.getClass().getName())); } - - simpleSyntax.append(String.join("; ", bodyActionStrings)); - } else if (doValue instanceof String) { - simpleSyntax.append((String) doValue); } + out.append(String.join("; ", bodyActionStrings)); + } else if (doValue instanceof String) { + out.append((String) doValue); + } else if (doValue != null) { + throw new ASTException("Unsupported loop body type: " + doValue.getClass().getName()); + } + } - simpleSyntax.append(" while ").append(condition); - - try { - return dslParser.parseAction(simpleSyntax.toString()); - } catch (Exception e) { - log.warn("Failed to parse complex do-while action: {}", actionMap, e); - return null; - } - } else { - log.warn("Unknown complex action type: {}", actionMap.keySet()); - return null; + /** + * Parse a reconstructed simple-syntax string, wrapping any lexer/parser failure in an + * ASTException tagged with the original complex-form context for easier diagnostics. + */ + private Action parseReconstructed(String simpleSyntax, String actionKind, Map originalMap) { + try { + return dslParser.parseAction(simpleSyntax); + } catch (Exception e) { + throw new ASTException( + "Failed to parse complex " + actionKind + " action " + originalMap + + " (reconstructed: " + simpleSyntax + "): " + e.getMessage(), + e); } } @@ -703,7 +750,6 @@ private List parseActionList(Object obj) { throw e; } }) - .filter(action -> action != null) .collect(Collectors.toList()); } else if (obj instanceof String) { return List.of(dslParser.parseAction((String) obj)); @@ -728,33 +774,4 @@ private List convertToStringList(Object obj) { } } - /** - * Convert to circuit breaker configuration - */ - @SuppressWarnings("unchecked") - private ASTRulesDSL.ASTCircuitBreakerConfig convertToCircuitBreakerConfig(Map circuitBreakerMap) { - ASTRulesDSL.ASTCircuitBreakerConfig.ASTCircuitBreakerConfigBuilder builder = - ASTRulesDSL.ASTCircuitBreakerConfig.builder(); - - if (circuitBreakerMap.containsKey("enabled")) { - builder.enabled((Boolean) circuitBreakerMap.get("enabled")); - } - - if (circuitBreakerMap.containsKey("failure_threshold")) { - Object threshold = circuitBreakerMap.get("failure_threshold"); - if (threshold instanceof Number) { - builder.failureThreshold(((Number) threshold).intValue()); - } - } - - if (circuitBreakerMap.containsKey("timeout_duration")) { - builder.timeoutDuration((String) circuitBreakerMap.get("timeout_duration")); - } - - if (circuitBreakerMap.containsKey("recovery_timeout")) { - builder.recoveryTimeout((String) circuitBreakerMap.get("recovery_timeout")); - } - - return builder.build(); - } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ActionParser.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ActionParser.java index d67c25b..659dcd5 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ActionParser.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ActionParser.java @@ -19,6 +19,7 @@ import org.fireflyframework.rules.core.dsl.action.*; import org.fireflyframework.rules.core.dsl.condition.Condition; import org.fireflyframework.rules.core.dsl.expression.Expression; +import org.fireflyframework.rules.core.dsl.expression.VariableExpression; import org.fireflyframework.rules.core.dsl.lexer.Token; import org.fireflyframework.rules.core.dsl.lexer.TokenType; import lombok.extern.slf4j.Slf4j; @@ -289,17 +290,27 @@ private Action parseConditionalAction() { } /** - * Parse arithmetic action: "add value to variable", "subtract value from variable", etc. + * Parse an arithmetic action. + * + *

{@code add} and {@code subtract} use English-natural order: + * 

add VALUE to TARGET
+ * 
subtract VALUE from TARGET
+ * + *

{@code multiply} and {@code divide} accept both orderings -- the parser + * disambiguates by which operand is a bare identifier (the target must be a writable + * variable name): + * 

multiply 1.5 by risk_factor   -- value then target (canonical)
+ * 
multiply risk_factor by 1.5   -- target then value (English-natural)
+ * Both produce the same {@code ArithmeticAction(MULTIPLY, "risk_factor", LiteralExpression(1.5))}. */ private Action parseArithmeticAction(ArithmeticAction.ArithmeticOperationType operation) { Token operationToken = previous(); - // Parse the value expression + // Parse the first expression after the action keyword. this.expressionParser.setCurrentPosition(this.current); - Expression value = this.expressionParser.parseExpression(); + Expression first = this.expressionParser.parseExpression(); this.current = this.expressionParser.getCurrentPosition(); - // Expect the preposition (to/from/by) String expectedPreposition = operation.getPreposition(); if (!check(TokenType.TO) && !check(TokenType.FROM) && !check(TokenType.BY)) { throw error( @@ -308,20 +319,34 @@ private Action parseArithmeticAction(ArithmeticAction.ArithmeticOperationType op List.of("Add '" + expectedPreposition + "' after the value") ); } - advance(); // consume the preposition - if (!check(TokenType.IDENTIFIER)) { - throw error( - "Expected variable name after '" + expectedPreposition + "'", - "PARSE_007", - List.of("Add a variable name after '" + expectedPreposition + "'") - ); + // Two patterns are accepted: + // 1) VALUE IDENTIFIER -- current canonical order, used by add/subtract/multiply/divide + // 2) IDENTIFIER VALUE -- English-natural order for multiply/divide + // If the next token is a bare IDENTIFIER, fall into pattern 1. + // Otherwise (number, paren, etc.) and the first expression was itself a bare variable, + // fall into pattern 2. + if (check(TokenType.IDENTIFIER)) { + Token variable = advance(); + return new ArithmeticAction(operationToken.getLocation(), operation, variable.getLexeme(), first); } - Token variable = advance(); + boolean swappedAllowed = operation == ArithmeticAction.ArithmeticOperationType.MULTIPLY + || operation == ArithmeticAction.ArithmeticOperationType.DIVIDE; + if (swappedAllowed && first instanceof VariableExpression firstVar && firstVar.isSimpleVariable()) { + // Pattern 2: first was the target, what follows the preposition is the value expression. + this.expressionParser.setCurrentPosition(this.current); + Expression valueExpr = this.expressionParser.parseExpression(); + this.current = this.expressionParser.getCurrentPosition(); + return new ArithmeticAction(operationToken.getLocation(), operation, firstVar.getVariableName(), valueExpr); + } - return new ArithmeticAction(operationToken.getLocation(), operation, variable.getLexeme(), value); + throw error( + "Expected variable name after '" + expectedPreposition + "'", + "PARSE_007", + List.of("Add a variable name after '" + expectedPreposition + "'") + ); } /** diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/DSLParser.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/DSLParser.java index b66e0c2..9b5ee90 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/DSLParser.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/DSLParser.java @@ -187,22 +187,4 @@ private List tokenize(String source) { return lexer.tokenize(); } - /** - * Validate that a parsed AST node is well-formed - */ - public void validateAST(Object astNode) { - if (astNode == null) { - throw new ParseException( - "AST node cannot be null", - null, - "PARSE_VALIDATION_001" - ); - } - - // Additional validation logic can be added here - // For example, checking that all required fields are present, - // that variable references are valid, etc. - - log.debug("AST validation passed for node type: {}", astNode.getClass().getSimpleName()); - } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ExpressionParser.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ExpressionParser.java index e776e0f..5aaf92a 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ExpressionParser.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/parser/ExpressionParser.java @@ -291,8 +291,15 @@ private Expression primary() { indexExpression = parseExpression(); consume(TokenType.RBRACKET, "Expected ']' after array index"); } - - return new VariableExpression(identifier.getLocation(), identifier.getLexeme(), propertyPath.isEmpty() ? null : propertyPath); + + VariableExpression variable = new VariableExpression( + identifier.getLocation(), + identifier.getLexeme(), + propertyPath.isEmpty() ? null : propertyPath); + if (indexExpression != null) { + variable.setIndexExpression(indexExpression); + } + return variable; } if (match(TokenType.LPAREN)) { diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ActionExecutor.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ActionExecutor.java index 16a393d..1018bec 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ActionExecutor.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ActionExecutor.java @@ -22,6 +22,7 @@ import org.fireflyframework.rules.core.dsl.condition.ExpressionCondition; import org.fireflyframework.rules.core.dsl.condition.LogicalCondition; import org.fireflyframework.rules.core.dsl.expression.*; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; import org.fireflyframework.rules.core.services.JsonPathService; import org.fireflyframework.rules.core.services.RestCallService; import lombok.extern.slf4j.Slf4j; @@ -37,70 +38,31 @@ public class ActionExecutor implements ASTVisitor { private final ExpressionEvaluator expressionEvaluator; public ActionExecutor(EvaluationContext context) { - this.context = context; - this.expressionEvaluator = new ExpressionEvaluator(context); + this(context, null, null, null, null); } public ActionExecutor(EvaluationContext context, RestCallService restCallService, JsonPathService jsonPathService) { + this(context, restCallService, jsonPathService, null, null); + } + + public ActionExecutor(EvaluationContext context, + RestCallService restCallService, + JsonPathService jsonPathService, + CustomFunctionRegistry customFunctions) { + this(context, restCallService, jsonPathService, customFunctions, null); + } + + public ActionExecutor(EvaluationContext context, + RestCallService restCallService, + JsonPathService jsonPathService, + CustomFunctionRegistry customFunctions, + org.fireflyframework.rules.core.dsl.function.RuleInvoker ruleInvoker) { this.context = context; - this.expressionEvaluator = new ExpressionEvaluator(context, restCallService, jsonPathService); + this.expressionEvaluator = new ExpressionEvaluator(context, restCallService, jsonPathService, customFunctions, ruleInvoker); } // Action visitors - @Override - public Void visitAssignmentAction(AssignmentAction node) { - Object value = node.getValue().accept(expressionEvaluator); - - switch (node.getOperator()) { - case ASSIGN -> context.setComputedVariable(node.getVariableName(), value); - case ADD_ASSIGN -> { - Object currentValue = context.getVariable(node.getVariableName()); - if (currentValue instanceof Number && value instanceof Number) { - java.math.BigDecimal current = toBigDecimal(currentValue); - java.math.BigDecimal addValue = toBigDecimal(value); - context.setComputedVariable(node.getVariableName(), current.add(addValue)); - } else { - String currentStr = currentValue != null ? currentValue.toString() : ""; - String valueStr = value != null ? value.toString() : ""; - context.setComputedVariable(node.getVariableName(), currentStr + valueStr); - } - } - case SUBTRACT_ASSIGN -> { - Object currentValue = context.getVariable(node.getVariableName()); - if (currentValue instanceof Number && value instanceof Number) { - java.math.BigDecimal current = toBigDecimal(currentValue); - java.math.BigDecimal subtractValue = toBigDecimal(value); - context.setComputedVariable(node.getVariableName(), current.subtract(subtractValue)); - } - } - case MULTIPLY_ASSIGN -> { - Object currentValue = context.getVariable(node.getVariableName()); - if (currentValue instanceof Number && value instanceof Number) { - java.math.BigDecimal current = toBigDecimal(currentValue); - java.math.BigDecimal multiplyValue = toBigDecimal(value); - context.setComputedVariable(node.getVariableName(), current.multiply(multiplyValue)); - } - } - case DIVIDE_ASSIGN -> { - Object currentValue = context.getVariable(node.getVariableName()); - if (currentValue instanceof Number && value instanceof Number) { - java.math.BigDecimal current = toBigDecimal(currentValue); - java.math.BigDecimal divisor = toBigDecimal(value); - if (divisor.compareTo(java.math.BigDecimal.ZERO) == 0) { - throw new ArithmeticException("Division by zero in /= assignment"); - } - context.setComputedVariable(node.getVariableName(), - current.divide(divisor, 10, java.math.RoundingMode.HALF_UP)); - } - } - } - - log.debug("Executed assignment: {} {} {}", - node.getVariableName(), node.getOperator().getSymbol(), value); - return null; - } - @Override public Void visitFunctionCallAction(FunctionCallAction node) { // Evaluate arguments @@ -173,12 +135,6 @@ private boolean containsNonMathematicalOperation(Expression expression) { if (expression instanceof FunctionCallExpression) { return true; } - if (expression instanceof RestCallExpression) { - return true; - } - if (expression instanceof JsonPathExpression) { - return true; - } if (expression instanceof BinaryExpression binaryExpr) { return containsNonMathematicalOperation(binaryExpr.getLeft()) || containsNonMathematicalOperation(binaryExpr.getRight()); @@ -186,17 +142,6 @@ private boolean containsNonMathematicalOperation(Expression expression) { if (expression instanceof UnaryExpression unaryExpr) { return containsNonMathematicalOperation(unaryExpr.getOperand()); } - if (expression instanceof ArithmeticExpression arithmeticExpr) { - // Check all operands in the arithmetic expression - if (arithmeticExpr.getOperands() != null) { - for (Expression operand : arithmeticExpr.getOperands()) { - if (containsNonMathematicalOperation(operand)) { - return true; - } - } - } - return false; - } // LiteralExpression and VariableExpression are allowed return false; } @@ -246,11 +191,6 @@ public Void visitFunctionCallExpression(FunctionCallExpression node) { throw new UnsupportedOperationException("Expressions cannot be executed as actions"); } - @Override - public Void visitArithmeticExpression(ArithmeticExpression node) { - throw new UnsupportedOperationException("Expressions cannot be executed as actions"); - } - // Condition visitors (not used in action execution) @Override @@ -294,8 +234,14 @@ private Object executeFunction(String functionName, Object[] args) { return switch (functionName.toLowerCase()) { case "log", "print" -> { String message = args.length > 0 ? args[0].toString() : ""; - String level = args.length > 1 ? args[1].toString() : "INFO"; - log.info("[{}] {}", level, message); + String level = args.length > 1 ? args[1].toString().toUpperCase() : "INFO"; + switch (level) { + case "TRACE" -> log.trace("[rule-log] {}", message); + case "DEBUG" -> log.debug("[rule-log] {}", message); + case "WARN", "WARNING" -> log.warn("[rule-log] {}", message); + case "ERROR" -> log.error("[rule-log] {}", message); + default -> log.info("[rule-log] {}", message); + } yield null; } case "validate", "check" -> { @@ -350,10 +296,16 @@ private Object executeFunction(String functionName, Object[] args) { ) ); } - default -> { - log.warn("Unknown function: {}", functionName); - yield null; - } + // Any other name -- custom-registered or any expression-tier built-in -- delegates + // to the expression evaluator, which checks the custom registry first and throws + // IllegalArgumentException with the registry-aware diagnostic if still unknown. + default -> expressionEvaluator.visitFunctionCallExpression( + new FunctionCallExpression( + null, functionName, + java.util.Arrays.stream(args) + .map(arg -> new LiteralExpression(null, arg)) + .collect(java.util.stream.Collectors.toList()) + )); }; } @@ -366,37 +318,36 @@ public Void visitArithmeticAction(ArithmeticAction node) { Object value = node.getValue().accept(expressionEvaluator); Object current = context.getVariable(node.getVariableName()); - if (current instanceof Number && value instanceof Number) { - java.math.BigDecimal currentNum = toBigDecimal(current); - java.math.BigDecimal valueNum = toBigDecimal(value); - java.math.BigDecimal result; - - switch (node.getOperation()) { - case ADD -> result = currentNum.add(valueNum); - case SUBTRACT -> result = currentNum.subtract(valueNum); - case MULTIPLY -> result = currentNum.multiply(valueNum); - case DIVIDE -> { - if (valueNum.compareTo(java.math.BigDecimal.ZERO) == 0) { - throw new ArithmeticException("Division by zero in arithmetic action"); - } - result = currentNum.divide(valueNum, 10, java.math.RoundingMode.HALF_UP); - } - default -> { - log.warn("Unknown arithmetic operation: {}", node.getOperation()); - result = current instanceof java.math.BigDecimal ? (java.math.BigDecimal) current : toBigDecimal(current); - } - } - - context.setComputedVariable(node.getVariableName(), result); - } else { - log.warn("Arithmetic action requires numeric operands: {} ({}), {} ({})", - current, current != null ? current.getClass().getSimpleName() : "null", - value, value != null ? value.getClass().getSimpleName() : "null"); + if (!(current instanceof Number) || !(value instanceof Number)) { + throw new IllegalArgumentException( + "Arithmetic action '" + node.getOperation().getKeyword() + "' on '" + + node.getVariableName() + "' requires numeric operands. Got current=" + + describeType(current) + ", value=" + describeType(value)); } + java.math.BigDecimal currentNum = toBigDecimal(current); + java.math.BigDecimal valueNum = toBigDecimal(value); + java.math.BigDecimal result = switch (node.getOperation()) { + case ADD -> currentNum.add(valueNum); + case SUBTRACT -> currentNum.subtract(valueNum); + case MULTIPLY -> currentNum.multiply(valueNum); + case DIVIDE -> { + if (valueNum.compareTo(java.math.BigDecimal.ZERO) == 0) { + throw new ArithmeticException("Division by zero in arithmetic action on '" + + node.getVariableName() + "'"); + } + yield currentNum.divide(valueNum, 10, java.math.RoundingMode.HALF_UP); + } + }; + context.setComputedVariable(node.getVariableName(), result); return null; } + private static String describeType(Object o) { + if (o == null) return "null"; + return o + " (" + o.getClass().getSimpleName() + ")"; + } + @Override public Void visitListAction(ListAction node) { log.debug("Executing list action: {} {} {} {}", @@ -565,15 +516,4 @@ public Void visitDoWhileAction(DoWhileAction node) { return null; } - @Override - public Void visitJsonPathExpression(JsonPathExpression node) { - // Expressions don't execute actions, so return null - return null; - } - - @Override - public Void visitRestCallExpression(RestCallExpression node) { - // Expressions don't execute actions, so return null - return null; - } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/EvaluationContext.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/EvaluationContext.java index 5737204..328d7f8 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/EvaluationContext.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/EvaluationContext.java @@ -16,61 +16,57 @@ package org.fireflyframework.rules.core.dsl.visitor; -import lombok.Data; +import lombok.Getter; import lombok.NoArgsConstructor; +import lombok.Setter; +import java.util.Collections; +import java.util.LinkedHashMap; import java.util.Map; import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; /** * Consolidated context object that holds the state during AST-based rule evaluation. - * Contains variables, constants, and execution state with full feature support. - * This replaces both the legacy and AST-specific EvaluationContext classes. + *

+ * The three variable maps ({@code inputVariables}, {@code systemConstants}, + * {@code computedVariables}) are intentionally exposed only through the typed setter + * methods on this class -- which validate names -- and getters that return defensive + * copies. There are no bulk setters; that prevents callers from substituting an + * unvalidated map and silently bypassing the naming-convention guard rails. + *

+ * The maps use {@link Collections#synchronizedMap synchronized {@link LinkedHashMap}s} + * rather than {@link java.util.concurrent.ConcurrentHashMap} because rule outputs + * legitimately include nulls (e.g., {@code json_get} on a missing path); ConcurrentHashMap + * rejects null values with an NPE and would mask the assignment as an unrelated runtime + * error. Each evaluation owns its own context so the sync overhead is negligible. */ -@Data +@Getter @NoArgsConstructor public class EvaluationContext { - /** - * Name of the rule being evaluated - */ - private String ruleName; + /** Name of the rule being evaluated. */ + @Setter private String ruleName; - /** - * Operation ID for tracing and logging - */ - private String operationId; + /** Operation ID for tracing and logging. */ + @Setter private String operationId; - /** - * Start time of evaluation (for performance tracking) - */ - private long startTime; + /** Start time of evaluation (for performance tracking). */ + @Setter private long startTime; - /** - * Input variables provided by the controller (runtime values like annualIncome, creditScore) - */ - private Map inputVariables = new ConcurrentHashMap<>(); + /** Input variables provided by the controller (e.g., {@code annualIncome}, {@code creditScore}). */ + private final Map inputVariables = Collections.synchronizedMap(new LinkedHashMap<>()); - /** - * System constants loaded from database (system-wide values like MINIMUM_CREDIT_SCORE, MAX_LOAN_AMOUNT) - */ - private Map systemConstants = new ConcurrentHashMap<>(); + /** System constants loaded from database (e.g., {@code MIN_CREDIT_SCORE}, {@code MAX_LOAN_AMOUNT}). */ + private final Map systemConstants = Collections.synchronizedMap(new LinkedHashMap<>()); - /** - * Computed variables created during rule evaluation (like loan_to_income_ratio, final_score) - */ - private Map computedVariables = new ConcurrentHashMap<>(); + /** Computed variables created during rule evaluation (e.g., {@code debt_to_income}, {@code final_score}). */ + private final Map computedVariables = Collections.synchronizedMap(new LinkedHashMap<>()); - /** - * Whether the circuit breaker has been triggered - */ - private boolean circuitBreakerTriggered = false; + /** Whether the circuit breaker has been triggered. */ + @Setter private boolean circuitBreakerTriggered = false; - /** - * Message associated with circuit breaker trigger - */ - private String circuitBreakerMessage; + /** Message associated with circuit breaker trigger. */ + @Setter private String circuitBreakerMessage; /** * Constructor with operation ID @@ -205,7 +201,7 @@ public boolean hasVariable(String name) { * @return map of input variables */ public Map getInputVariables() { - return new ConcurrentHashMap<>(inputVariables); + synchronized (inputVariables) { return new LinkedHashMap<>(inputVariables); } } /** @@ -214,7 +210,7 @@ public Map getInputVariables() { * @return map of computed variables */ public Map getComputedVariables() { - return new ConcurrentHashMap<>(computedVariables); + synchronized (computedVariables) { return new LinkedHashMap<>(computedVariables); } } /** @@ -223,7 +219,7 @@ public Map getComputedVariables() { * @return map of system constants */ public Map getSystemConstants() { - return new ConcurrentHashMap<>(systemConstants); + synchronized (systemConstants) { return new LinkedHashMap<>(systemConstants); } } /** @@ -239,7 +235,7 @@ public Map getConstants() { * Get all variables (including computed ones) for AST compatibility */ public Map getAllVariables() { - Map all = new ConcurrentHashMap<>(); + Map all = new LinkedHashMap<>(); all.putAll(systemConstants); all.putAll(inputVariables); all.putAll(computedVariables); diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ExpressionEvaluator.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ExpressionEvaluator.java index d6695da..b4f1a97 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ExpressionEvaluator.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ExpressionEvaluator.java @@ -22,6 +22,8 @@ import org.fireflyframework.rules.core.dsl.condition.ExpressionCondition; import org.fireflyframework.rules.core.dsl.condition.LogicalCondition; import org.fireflyframework.rules.core.dsl.expression.*; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.function.RuleFunction; import org.fireflyframework.rules.core.services.JsonPathService; import org.fireflyframework.rules.core.services.RestCallService; import org.fireflyframework.rules.core.utils.JsonLogger; @@ -44,6 +46,8 @@ public class ExpressionEvaluator implements ASTVisitor { private final EvaluationContext context; private final RestCallService restCallService; private final JsonPathService jsonPathService; + private final CustomFunctionRegistry customFunctions; + private final org.fireflyframework.rules.core.dsl.function.RuleInvoker ruleInvoker; private static final int REGEX_CACHE_SIZE = 64; @SuppressWarnings("serial") @@ -55,15 +59,30 @@ protected boolean removeEldestEntry(Map.Entry eldest) { }; public ExpressionEvaluator(EvaluationContext context) { - this.context = context; - this.restCallService = null; // Will be injected when needed - this.jsonPathService = null; // Will be injected when needed + this(context, null, null, null, null); } public ExpressionEvaluator(EvaluationContext context, RestCallService restCallService, JsonPathService jsonPathService) { + this(context, restCallService, jsonPathService, null, null); + } + + public ExpressionEvaluator(EvaluationContext context, + RestCallService restCallService, + JsonPathService jsonPathService, + CustomFunctionRegistry customFunctions) { + this(context, restCallService, jsonPathService, customFunctions, null); + } + + public ExpressionEvaluator(EvaluationContext context, + RestCallService restCallService, + JsonPathService jsonPathService, + CustomFunctionRegistry customFunctions, + org.fireflyframework.rules.core.dsl.function.RuleInvoker ruleInvoker) { this.context = context; this.restCallService = restCallService; this.jsonPathService = jsonPathService; + this.customFunctions = customFunctions; + this.ruleInvoker = ruleInvoker; } // Expression visitors @@ -197,7 +216,16 @@ public Object visitFunctionCallExpression(FunctionCallExpression node) { node.getArguments().stream().map(arg -> arg.accept(this)).toArray() : new Object[0]; - // Built-in mathematical functions + // User-registered functions are checked first so they may extend or override built-ins. + if (customFunctions != null) { + RuleFunction custom = customFunctions.lookup(functionName).orElse(null); + if (custom != null) { + return custom.apply(args); + } + } + + // Built-in catalog. Unknown names throw rather than silently returning null -- + // the user almost certainly typo'd a function name and silent null masks that. return switch (functionName.toLowerCase()) { case "max" -> evaluateMax(args); case "min" -> evaluateMin(args); @@ -207,6 +235,15 @@ public Object visitFunctionCallExpression(FunctionCallExpression node) { case "floor" -> evaluateFloor(args); case "sqrt" -> evaluateSqrt(args); case "pow" -> evaluatePow(args); + case "exp" -> evaluateUnaryMath(args, "exp", Math::exp); + case "ln" -> evaluateUnaryMath(args, "ln", Math::log); + case "log10" -> evaluateUnaryMath(args, "log10", Math::log10); + case "sin" -> evaluateUnaryMath(args, "sin", Math::sin); + case "cos" -> evaluateUnaryMath(args, "cos", Math::cos); + case "tan" -> evaluateUnaryMath(args, "tan", Math::tan); + case "atan2" -> evaluateBinaryMath(args, "atan2", Math::atan2); + case "hash" -> evaluateHash(args); + case "log" -> evaluateLog(args); // String functions case "length", "len" -> evaluateLength(args); @@ -224,6 +261,17 @@ public Object visitFunctionCallExpression(FunctionCallExpression node) { case "today" -> evaluateToday(args); case "dateadd" -> evaluateDateAdd(args); case "datediff" -> evaluateDateDiff(args); + case "calculate_age" -> evaluateCalculateAge(args); + case "format_date" -> evaluateFormatDate(args); + case "current_iso", "now_iso" -> java.time.OffsetDateTime.now().toString(); + case "year_of" -> evaluateDatePart(args, "year_of", java.time.LocalDate::getYear); + case "month_of" -> evaluateDatePart(args, "month_of", d -> d.getMonthValue()); + case "day_of_month" -> evaluateDatePart(args, "day_of_month", java.time.LocalDate::getDayOfMonth); + case "day_of_week" -> evaluateDatePart(args, "day_of_week", d -> d.getDayOfWeek().getValue()); + + // Validation functions (function-call form complements the `is_email`/`is_phone` operators) + case "validate_email" -> isEmail(args.length > 0 ? args[0] : null); + case "validate_phone" -> isPhone(args.length > 0 ? args[0] : null); // List functions case "size", "count" -> evaluateSize(args); @@ -231,12 +279,34 @@ public Object visitFunctionCallExpression(FunctionCallExpression node) { case "avg", "average" -> evaluateAverage(args); case "first" -> evaluateFirst(args); case "last" -> evaluateLast(args); + case "filter" -> evaluateFilter(args); + case "map" -> evaluateMap(args); + case "reduce" -> evaluateReduce(args); + case "find" -> evaluateFind(args); + case "sort" -> evaluateSort(args); + case "reverse" -> evaluateReverse(args); + case "distinct" -> evaluateDistinct(args); + + // Statistical functions + case "median" -> evaluateMedian(args); + case "stddev" -> evaluateStddev(args); + case "variance" -> evaluateVariance(args); + case "percentile" -> evaluatePercentile(args); + + // String formatting + case "format" -> evaluateStringFormat(args); + case "concat" -> evaluateConcat(args); // Type conversion functions case "tonumber", "number" -> evaluateToNumber(args); case "tostring", "string" -> evaluateToString(args); case "toboolean", "boolean" -> evaluateToBoolean(args); + // Null-handling / conditional helpers + case "coalesce" -> evaluateCoalesce(args); + case "if_else", "ifelse" -> evaluateIfElse(args); + case "is_in_range" -> inRange(args); + // Financial calculation functions case "calculate_loan_payment" -> calculateLoanPayment(args); case "calculate_compound_interest" -> calculateCompoundInterest(args); @@ -290,87 +360,21 @@ public Object visitFunctionCallExpression(FunctionCallExpression node) { case "rest_patch" -> restPatch(args); case "rest_call" -> restCall(args); + // Rule composition -- delegate to a stored rule by code + case "invoke_rule" -> evaluateInvokeRule(args); + // JSON path functions case "json_get", "json_path" -> jsonGet(args); case "json_exists" -> jsonExists(args); case "json_size" -> jsonSize(args); case "json_type" -> jsonType(args); - default -> { - log.warn("Unknown function: {}", functionName); - yield null; - } + default -> throw new IllegalArgumentException( + "Unknown function '" + functionName + "'. Register it via CustomFunctionRegistry or " + + "check spelling against the built-in catalog."); }; } - - @Override - public Object visitArithmeticExpression(ArithmeticExpression node) { - List operandValues = node.getOperands().stream() - .map(operand -> operand.accept(this)) - .toList(); - - return switch (node.getOperation()) { - case ADD -> operandValues.stream() - .map(this::toNumber) - .reduce(BigDecimal.ZERO, BigDecimal::add); - case MULTIPLY -> operandValues.stream() - .map(this::toNumber) - .reduce(BigDecimal.ONE, BigDecimal::multiply); - case MIN -> operandValues.stream() - .map(this::toNumber) - .min(BigDecimal::compareTo) - .orElse(BigDecimal.ZERO); - case MAX -> operandValues.stream() - .map(this::toNumber) - .max(BigDecimal::compareTo) - .orElse(BigDecimal.ZERO); - case SUM -> operandValues.stream() - .map(this::toNumber) - .reduce(BigDecimal.ZERO, BigDecimal::add); - case AVERAGE -> { - BigDecimal sum = operandValues.stream() - .map(this::toNumber) - .reduce(BigDecimal.ZERO, BigDecimal::add); - yield sum.divide(BigDecimal.valueOf(operandValues.size()), 10, RoundingMode.HALF_UP); - } - default -> { - if (operandValues.size() >= 2) { - BigDecimal first = toNumber(operandValues.get(0)); - BigDecimal second = toNumber(operandValues.get(1)); - yield switch (node.getOperation()) { - case SUBTRACT -> first.subtract(second); - case DIVIDE -> { - if (second.compareTo(BigDecimal.ZERO) == 0) { - throw new ArithmeticException("Division by zero"); - } - yield first.divide(second, 10, RoundingMode.HALF_UP); - } - case MODULO -> { - if (second.compareTo(BigDecimal.ZERO) == 0) { - throw new ArithmeticException("Modulo by zero"); - } - yield first.remainder(second); - } - case POWER -> BigDecimal.valueOf(Math.pow(first.doubleValue(), second.doubleValue())); - default -> first; - }; - } else if (operandValues.size() == 1) { - BigDecimal value = toNumber(operandValues.get(0)); - yield switch (node.getOperation()) { - case ABS -> value.abs(); - case ROUND -> BigDecimal.valueOf(Math.round(value.doubleValue())); - case FLOOR -> BigDecimal.valueOf(Math.floor(value.doubleValue())); - case CEIL -> BigDecimal.valueOf(Math.ceil(value.doubleValue())); - case SQRT -> BigDecimal.valueOf(Math.sqrt(value.doubleValue())); - default -> value; - }; - } else { - yield BigDecimal.ZERO; - } - } - }; - } - + // Condition visitors (return Boolean) @Override @@ -460,12 +464,7 @@ public Object visitExpressionCondition(ExpressionCondition node) { } // Action visitors (not used in expression evaluation) - - @Override - public Object visitAssignmentAction(AssignmentAction node) { - throw new UnsupportedOperationException("Actions cannot be evaluated as expressions"); - } - + @Override public Object visitFunctionCallAction(FunctionCallAction node) { throw new UnsupportedOperationException("Actions cannot be evaluated as expressions"); @@ -614,15 +613,16 @@ private boolean endsWith(Object left, Object right) { } private boolean matches(Object left, Object right) { + String leftStr = toString(left); + String rightStr = toString(right); try { - String leftStr = toString(left); - String rightStr = toString(right); - Pattern pattern = REGEX_CACHE.computeIfAbsent(rightStr, Pattern::compile); return pattern.matcher(leftStr).find(); - } catch (Exception e) { - log.warn("Invalid regex pattern: {}", right); - return false; + } catch (java.util.regex.PatternSyntaxException e) { + // Treat a broken pattern as an authoring bug rather than "no match" -- the + // latter silently flips rules to the wrong branch. + throw new IllegalArgumentException( + "Invalid regex pattern '" + rightStr + "': " + e.getDescription(), e); } } @@ -655,7 +655,27 @@ private BigDecimal toNumber(Object value) { } /** - * Safe number conversion that treats null as zero (for arithmetic operations) + * Wrap an exception thrown from a built-in function in an {@link IllegalArgumentException} + * tagged with the function name -- unless the exception already carries good diagnostic + * context, in which case it is rethrown unchanged. Used by the financial / formatting / + * date built-ins to give consistent error messages and avoid the previous catch-and-null + * silent-failure pattern. + */ + private static IllegalArgumentException wrapFunctionError(String functionName, RuntimeException cause) { + if (cause instanceof IllegalArgumentException && cause.getMessage() != null + && cause.getMessage().startsWith(functionName)) { + return (IllegalArgumentException) cause; + } + return new IllegalArgumentException( + functionName + ": " + (cause.getMessage() != null ? cause.getMessage() + : cause.getClass().getSimpleName()), + cause); + } + + /** + * Number conversion that treats null as zero (matching null-as-no-value semantics + * common in financial and SQL contexts), but raises IllegalArgumentException for + * non-numeric strings so type bugs surface instead of silently producing zero. */ private BigDecimal toNumberSafe(Object value) { if (value == null) return BigDecimal.ZERO; @@ -664,7 +684,9 @@ private BigDecimal toNumberSafe(Object value) { try { return new BigDecimal(value.toString()); } catch (NumberFormatException e) { - return BigDecimal.ZERO; + throw new IllegalArgumentException( + "Cannot convert '" + value + "' (type " + value.getClass().getSimpleName() + + ") to a number for arithmetic; check that the operand is numeric"); } } @@ -682,15 +704,17 @@ private String toString(Object value) { return value != null ? value.toString() : ""; } + /** + * Numeric coercion shared by all built-in functions (sum, max, financial calcs, etc). + *

+ * Delegates to {@link #toNumberSafe(Object)} so the entire engine has one consistent + * coercion contract: null treated as zero (matches SQL/financial semantics for missing + * values in aggregations), but any non-numeric string raises + * {@link IllegalArgumentException} so type bugs in rule authoring surface immediately + * rather than being silently zeroed. + */ private BigDecimal toBigDecimal(Object value) { - if (value == null) return BigDecimal.ZERO; - if (value instanceof BigDecimal) return (BigDecimal) value; - if (value instanceof Number) return BigDecimal.valueOf(((Number) value).doubleValue()); - try { - return new BigDecimal(value.toString()); - } catch (NumberFormatException e) { - return BigDecimal.ZERO; - } + return toNumberSafe(value); } // Built-in function implementations @@ -761,6 +785,104 @@ private Object evaluatePow(Object[] args) { return BigDecimal.valueOf(Math.pow(base.doubleValue(), exponent.doubleValue())); } + private Object evaluateUnaryMath(Object[] args, String name, java.util.function.DoubleUnaryOperator op) { + if (args.length != 1) { + throw new IllegalArgumentException(name + "() requires exactly 1 argument"); + } + BigDecimal v = toBigDecimal(args[0]); + if (v == null) return null; + double result = op.applyAsDouble(v.doubleValue()); + if (Double.isNaN(result) || Double.isInfinite(result)) { + throw new IllegalArgumentException(name + "() produced a non-finite result for input " + v); + } + return BigDecimal.valueOf(result); + } + + private Object evaluateBinaryMath(Object[] args, String name, java.util.function.DoubleBinaryOperator op) { + if (args.length != 2) { + throw new IllegalArgumentException(name + "() requires exactly 2 arguments"); + } + BigDecimal a = toBigDecimal(args[0]); + BigDecimal b = toBigDecimal(args[1]); + if (a == null || b == null) return null; + double result = op.applyAsDouble(a.doubleValue(), b.doubleValue()); + if (Double.isNaN(result) || Double.isInfinite(result)) { + throw new IllegalArgumentException(name + "() produced a non-finite result"); + } + return BigDecimal.valueOf(result); + } + + private Object evaluateHash(Object[] args) { + if (args.length < 1 || args.length > 2) { + throw new IllegalArgumentException("hash(value [, algorithm]) requires 1 or 2 arguments"); + } + String input = args[0] == null ? "" : args[0].toString(); + String algorithm = args.length == 2 && args[1] != null ? args[1].toString() : "SHA-256"; + try { + java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm); + byte[] digest = md.digest(input.getBytes(java.nio.charset.StandardCharsets.UTF_8)); + StringBuilder sb = new StringBuilder(digest.length * 2); + for (byte b : digest) sb.append(String.format("%02x", b)); + return sb.toString(); + } catch (java.security.NoSuchAlgorithmException e) { + throw new IllegalArgumentException("hash() unknown algorithm '" + algorithm + "'. Supported: MD5, SHA-1, SHA-256, SHA-512"); + } + } + + @SuppressWarnings("unchecked") + private Object evaluateInvokeRule(Object[] args) { + if (args.length < 1) { + throw new IllegalArgumentException( + "invoke_rule(code [, inputs | key, value, ...]) requires at least the rule code argument"); + } + if (ruleInvoker == null) { + throw new IllegalStateException( + "invoke_rule() requires a RuleInvoker bean. Wire RuleInvokerImpl into the application context " + + "or evaluate via the full Spring-managed engine."); + } + String code = args[0] == null ? null : args[0].toString(); + if (code == null || code.isBlank()) { + throw new IllegalArgumentException("invoke_rule(code, ...): first argument must be a non-empty rule code"); + } + java.util.Map inputs; + if (args.length == 1) { + inputs = java.util.Collections.emptyMap(); + } else if (args.length == 2 && args[1] instanceof java.util.Map m) { + inputs = (java.util.Map) m; + } else { + // Alternating-key/value form: invoke_rule("code", "k1", v1, "k2", v2, ...) + if ((args.length - 1) % 2 != 0) { + throw new IllegalArgumentException( + "invoke_rule: trailing arguments must be alternating key/value pairs (odd count)"); + } + java.util.Map built = new java.util.LinkedHashMap<>(); + for (int i = 1; i < args.length; i += 2) { + if (args[i] == null) { + throw new IllegalArgumentException("invoke_rule: input key at position " + i + " is null"); + } + built.put(args[i].toString(), args[i + 1]); + } + inputs = built; + } + return ruleInvoker.invokeBlocking(code, inputs); + } + + private Object evaluateLog(Object[] args) { + if (args.length < 1 || args.length > 2) { + throw new IllegalArgumentException("log(message [, level]) requires 1 or 2 arguments"); + } + String message = args[0] == null ? "null" : args[0].toString(); + String level = args.length == 2 && args[1] != null ? args[1].toString().toUpperCase() : "INFO"; + switch (level) { + case "TRACE" -> log.trace("[rule-log] {}", message); + case "DEBUG" -> log.debug("[rule-log] {}", message); + case "WARN", "WARNING" -> log.warn("[rule-log] {}", message); + case "ERROR" -> log.error("[rule-log] {}", message); + default -> log.info("[rule-log] {}", message); + } + return message; + } + // String functions private Object evaluateLength(Object[] args) { @@ -838,79 +960,92 @@ private Object evaluateToday(Object[] args) { private Object evaluateDateAdd(Object[] args) { if (args.length != 3) { - log.warn("DateAdd function requires 3 arguments: date, amount, unit"); - return null; - } - - try { - // Parse the date - java.time.LocalDate date = parseDate(args[0]); - if (date == null) { - log.warn("Invalid date format in dateadd: {}", args[0]); - return null; - } - - // Parse the amount - int amount = toNumber(args[1]).intValue(); - - // Parse the unit - String unit = toString(args[2]).toLowerCase(); - - java.time.LocalDate result = switch (unit) { - case "days", "day", "d" -> date.plusDays(amount); - case "weeks", "week", "w" -> date.plusWeeks(amount); - case "months", "month", "m" -> date.plusMonths(amount); - case "years", "year", "y" -> date.plusYears(amount); - default -> { - log.warn("Unsupported date unit in dateadd: {}. Supported units: days, weeks, months, years", unit); - yield null; - } - }; - - return result != null ? result.toString() : null; - - } catch (Exception e) { - log.warn("Error in dateadd function: {}", e.getMessage()); - return null; - } + throw new IllegalArgumentException( + "dateadd(date, amount, unit) requires exactly 3 arguments; got " + args.length); + } + java.time.LocalDate date = parseDate(args[0]); + if (date == null) { + throw new IllegalArgumentException("dateadd: unparseable date '" + args[0] + "'"); + } + int amount = toNumber(args[1]).intValue(); + String unit = toString(args[2]).toLowerCase(); + java.time.LocalDate result = switch (unit) { + case "days", "day", "d" -> date.plusDays(amount); + case "weeks", "week", "w" -> date.plusWeeks(amount); + case "months", "month", "m" -> date.plusMonths(amount); + case "years", "year", "y" -> date.plusYears(amount); + default -> throw new IllegalArgumentException( + "dateadd: unsupported unit '" + unit + "'. Supported: days, weeks, months, years (and short forms d/w/m/y)."); + }; + return result.toString(); } private Object evaluateDateDiff(Object[] args) { if (args.length < 2 || args.length > 3) { - log.warn("DateDiff function requires 2 or 3 arguments: date1, date2, [unit]"); - return null; + throw new IllegalArgumentException( + "datediff(date1, date2[, unit]) requires 2 or 3 arguments; got " + args.length); + } + java.time.LocalDate date1 = parseDate(args[0]); + if (date1 == null) { + throw new IllegalArgumentException("datediff: unparseable date1 '" + args[0] + "'"); + } + java.time.LocalDate date2 = parseDate(args[1]); + if (date2 == null) { + throw new IllegalArgumentException("datediff: unparseable date2 '" + args[1] + "'"); + } + String unit = args.length > 2 ? toString(args[2]).toLowerCase() : "days"; + java.time.Period period = java.time.Period.between(date1, date2); + long daysDiff = java.time.temporal.ChronoUnit.DAYS.between(date1, date2); + return switch (unit) { + case "days", "day", "d" -> BigDecimal.valueOf(daysDiff); + case "weeks", "week", "w" -> BigDecimal.valueOf(daysDiff / 7); + case "months", "month", "m" -> BigDecimal.valueOf(period.toTotalMonths()); + case "years", "year", "y" -> BigDecimal.valueOf(period.getYears()); + default -> throw new IllegalArgumentException( + "datediff: unsupported unit '" + unit + "'. Supported: days, weeks, months, years (and short forms d/w/m/y)."); + }; + } + + /** + * Compute age in years from a birth date. Accepts ISO {@code yyyy-MM-dd} or any string the + * shared {@link #parseDate(Object)} helper recognises. With one argument, the reference date + * is "today"; with two, the caller supplies the reference date (useful for "age at policy + * inception"). + */ + private Object evaluateCalculateAge(Object[] args) { + if (args.length < 1 || args.length > 2) { + throw new IllegalArgumentException( + "calculate_age(birthDate[, asOfDate]) takes 1 or 2 arguments, got " + args.length); } + java.time.LocalDate birth = parseDate(args[0]); + if (birth == null) { + throw new IllegalArgumentException("calculate_age: unparseable birth date '" + args[0] + "'"); + } + java.time.LocalDate asOf = args.length == 2 ? parseDate(args[1]) : java.time.LocalDate.now(); + if (asOf == null) { + throw new IllegalArgumentException("calculate_age: unparseable reference date '" + args[1] + "'"); + } + return BigDecimal.valueOf(java.time.Period.between(birth, asOf).getYears()); + } + /** + * Format a date using a {@link java.time.format.DateTimeFormatter} pattern. + * Default pattern is ISO {@code yyyy-MM-dd}. + */ + private Object evaluateFormatDate(Object[] args) { + if (args.length < 1 || args.length > 2) { + throw new IllegalArgumentException( + "format_date(date[, pattern]) takes 1 or 2 arguments, got " + args.length); + } + java.time.LocalDate date = parseDate(args[0]); + if (date == null) { + throw new IllegalArgumentException("format_date: unparseable date '" + args[0] + "'"); + } + String pattern = args.length == 2 ? toString(args[1]) : "yyyy-MM-dd"; try { - // Parse the dates - java.time.LocalDate date1 = parseDate(args[0]); - java.time.LocalDate date2 = parseDate(args[1]); - - if (date1 == null || date2 == null) { - log.warn("Invalid date format in datediff: {} or {}", args[0], args[1]); - return null; - } - - // Parse the unit (default to days) - String unit = args.length > 2 ? toString(args[2]).toLowerCase() : "days"; - - java.time.Period period = java.time.Period.between(date1, date2); - long daysDiff = java.time.temporal.ChronoUnit.DAYS.between(date1, date2); - - return switch (unit) { - case "days", "day", "d" -> BigDecimal.valueOf(daysDiff); - case "weeks", "week", "w" -> BigDecimal.valueOf(daysDiff / 7); - case "months", "month", "m" -> BigDecimal.valueOf(period.toTotalMonths()); - case "years", "year", "y" -> BigDecimal.valueOf(period.getYears()); - default -> { - log.warn("Unsupported date unit in datediff: {}. Supported units: days, weeks, months, years", unit); - yield null; - } - }; - - } catch (Exception e) { - log.warn("Error in datediff function: {}", e.getMessage()); - return null; + return date.format(java.time.format.DateTimeFormatter.ofPattern(pattern)); + } catch (IllegalArgumentException e) { + throw new IllegalArgumentException("format_date: invalid pattern '" + pattern + "': " + e.getMessage(), e); } } @@ -1003,6 +1138,300 @@ private Object evaluateToBoolean(Object[] args) { return toBoolean(args[0]); } + /** + * Return the first non-null argument. Common pattern for default values: + * {@code coalesce(user.preferred_name, user.legal_name, "Unknown")}. + *

+ * Note: arguments are evaluated eagerly (the parser already resolved them before + * the function was called); this differs from short-circuit semantics in some other + * DSLs but matches the rest of this engine's function-call evaluation model. + */ + private Object evaluateCoalesce(Object[] args) { + if (args.length == 0) { + throw new IllegalArgumentException("coalesce(...) requires at least one argument"); + } + for (Object arg : args) { + if (arg != null) { + return arg; + } + } + return null; + } + + /** + * Inline conditional expression: {@code if_else(condition, thenValue, elseValue)}. + *

+ * Equivalent to a ternary operator inside an expression context (such as a + * {@code calculate} or {@code run} action), avoiding a full {@code if/then/else} + * action block when you only need to pick between two values. + *

+ * Note: both branches are evaluated up-front, matching the eager-argument contract + * of the rest of the function-call layer. + */ + private Object evaluateIfElse(Object[] args) { + if (args.length != 3) { + throw new IllegalArgumentException( + "if_else(condition, then, else) requires exactly 3 arguments; got " + args.length); + } + return toBoolean(args[0]) ? args[1] : args[2]; + } + + // --------------------------------------------------------------------------------- + // Date field extractors + // --------------------------------------------------------------------------------- + + /** + * Generic date-field extractor: parses arg[0] as a date and runs the given accessor. + * Used for {@code year_of}, {@code month_of}, {@code day_of_month}, {@code day_of_week}. + */ + private Object evaluateDatePart(Object[] args, String fnName, java.util.function.ToIntFunction accessor) { + if (args.length != 1) { + throw new IllegalArgumentException(fnName + "(date) requires exactly 1 argument; got " + args.length); + } + java.time.LocalDate date = parseDate(args[0]); + if (date == null) { + throw new IllegalArgumentException(fnName + ": unparseable date '" + args[0] + "'"); + } + return java.math.BigDecimal.valueOf(accessor.applyAsInt(date)); + } + + // --------------------------------------------------------------------------------- + // Functional list operations -- filter/map/reduce/find by named function + // + // The DSL doesn't (yet) have an inline-lambda syntax, so these higher-order helpers + // take the predicate / transformer as a STRING function name. The named function is + // resolved through the same lookup ExpressionEvaluator uses for any other function + // call -- {@link CustomFunctionRegistry} first, then the built-in catalog -- so + // user-registered Spring beans and engine built-ins work identically. + // --------------------------------------------------------------------------------- + + private Object callFunctionByName(String name, Object[] args) { + java.util.List argExprs = new java.util.ArrayList<>(args.length); + for (Object a : args) argExprs.add(new LiteralExpression(null, a)); + FunctionCallExpression call = new FunctionCallExpression(null, name, argExprs); + return visitFunctionCallExpression(call); + } + + private static List requireList(String fnName, Object value) { + if (!(value instanceof List)) { + throw new IllegalArgumentException(fnName + ": first argument must be a list, got " + + (value == null ? "null" : value.getClass().getSimpleName())); + } + return (List) value; + } + + private static String requireFunctionName(String fnName, Object value) { + if (!(value instanceof String)) { + throw new IllegalArgumentException(fnName + ": function name must be a string, got " + + (value == null ? "null" : value.getClass().getSimpleName())); + } + return (String) value; + } + + private Object evaluateFilter(Object[] args) { + if (args.length != 2) { + throw new IllegalArgumentException("filter(list, function_name) requires 2 arguments; got " + args.length); + } + List input = requireList("filter", args[0]); + String fn = requireFunctionName("filter", args[1]); + List result = new java.util.ArrayList<>(); + for (Object item : input) { + if (toBoolean(callFunctionByName(fn, new Object[]{item}))) { + result.add(item); + } + } + return result; + } + + private Object evaluateMap(Object[] args) { + if (args.length != 2) { + throw new IllegalArgumentException("map(list, function_name) requires 2 arguments; got " + args.length); + } + List input = requireList("map", args[0]); + String fn = requireFunctionName("map", args[1]); + List result = new java.util.ArrayList<>(input.size()); + for (Object item : input) { + result.add(callFunctionByName(fn, new Object[]{item})); + } + return result; + } + + private Object evaluateReduce(Object[] args) { + if (args.length != 3) { + throw new IllegalArgumentException("reduce(list, initial, function_name) requires 3 arguments; got " + args.length); + } + List input = requireList("reduce", args[0]); + Object acc = args[1]; + String fn = requireFunctionName("reduce", args[2]); + for (Object item : input) { + acc = callFunctionByName(fn, new Object[]{acc, item}); + } + return acc; + } + + private Object evaluateFind(Object[] args) { + if (args.length != 2) { + throw new IllegalArgumentException("find(list, function_name) requires 2 arguments; got " + args.length); + } + List input = requireList("find", args[0]); + String fn = requireFunctionName("find", args[1]); + for (Object item : input) { + if (toBoolean(callFunctionByName(fn, new Object[]{item}))) return item; + } + return null; + } + + private Object evaluateSort(Object[] args) { + if (args.length != 1) { + throw new IllegalArgumentException("sort(list) requires exactly 1 argument; got " + args.length); + } + List input = requireList("sort", args[0]); + List copy = new java.util.ArrayList<>(input); + @SuppressWarnings({"unchecked", "rawtypes"}) + java.util.Comparator cmp = (a, b) -> { + if (a instanceof Number && b instanceof Number) { + return toNumberSafe(a).compareTo(toNumberSafe(b)); + } + return ((Comparable) a).compareTo(b); + }; + copy.sort(cmp); + return copy; + } + + private Object evaluateReverse(Object[] args) { + if (args.length != 1) { + throw new IllegalArgumentException("reverse(list) requires exactly 1 argument; got " + args.length); + } + List input = requireList("reverse", args[0]); + List copy = new java.util.ArrayList<>(input); + java.util.Collections.reverse(copy); + return copy; + } + + private Object evaluateDistinct(Object[] args) { + if (args.length != 1) { + throw new IllegalArgumentException("distinct(list) requires exactly 1 argument; got " + args.length); + } + List input = requireList("distinct", args[0]); + // LinkedHashSet preserves insertion order while deduplicating. + return new java.util.ArrayList<>(new java.util.LinkedHashSet<>(input)); + } + + // --------------------------------------------------------------------------------- + // Statistical aggregates -- median, stddev, variance + // --------------------------------------------------------------------------------- + + private List asNumericList(String fnName, Object[] args) { + if (args.length != 1) { + throw new IllegalArgumentException(fnName + "(list) requires exactly 1 argument; got " + args.length); + } + List input = requireList(fnName, args[0]); + List nums = new java.util.ArrayList<>(input.size()); + for (Object o : input) nums.add(toNumberSafe(o)); + return nums; + } + + private Object evaluateMedian(Object[] args) { + List nums = asNumericList("median", args); + if (nums.isEmpty()) return java.math.BigDecimal.ZERO; + nums.sort(java.math.BigDecimal::compareTo); + int mid = nums.size() / 2; + if (nums.size() % 2 == 1) return nums.get(mid); + return nums.get(mid - 1).add(nums.get(mid)) + .divide(java.math.BigDecimal.valueOf(2), 10, java.math.RoundingMode.HALF_UP); + } + + private Object evaluateVariance(Object[] args) { + List nums = asNumericList("variance", args); + if (nums.size() < 2) return java.math.BigDecimal.ZERO; + // Sample variance: sum((x - mean)^2) / (n - 1) + java.math.BigDecimal mean = nums.stream().reduce(java.math.BigDecimal.ZERO, java.math.BigDecimal::add) + .divide(java.math.BigDecimal.valueOf(nums.size()), 10, java.math.RoundingMode.HALF_UP); + java.math.BigDecimal sqSum = nums.stream() + .map(x -> x.subtract(mean).pow(2)) + .reduce(java.math.BigDecimal.ZERO, java.math.BigDecimal::add); + return sqSum.divide(java.math.BigDecimal.valueOf(nums.size() - 1L), 10, java.math.RoundingMode.HALF_UP); + } + + private Object evaluateStddev(Object[] args) { + java.math.BigDecimal variance = (java.math.BigDecimal) evaluateVariance(args); + return java.math.BigDecimal.valueOf(Math.sqrt(variance.doubleValue())); + } + + private Object evaluatePercentile(Object[] args) { + if (args.length != 2) { + throw new IllegalArgumentException("percentile(list, p) requires 2 arguments where p is in [0, 100]"); + } + if (!(args[0] instanceof List list) || list.isEmpty()) { + throw new IllegalArgumentException("percentile(list, p): first argument must be a non-empty list"); + } + java.math.BigDecimal p = toBigDecimal(args[1]); + if (p == null || p.compareTo(java.math.BigDecimal.ZERO) < 0 || p.compareTo(java.math.BigDecimal.valueOf(100)) > 0) { + throw new IllegalArgumentException("percentile(list, p): p must be in [0, 100], got " + p); + } + List nums = new java.util.ArrayList<>(list.size()); + for (Object item : list) { + java.math.BigDecimal n = toBigDecimal(item); + if (n == null) throw new IllegalArgumentException("percentile: list contains non-numeric value " + item); + nums.add(n); + } + java.util.Collections.sort(nums); + // Linear interpolation, NIST/Excel definition + double rank = p.doubleValue() / 100.0 * (nums.size() - 1); + int lo = (int) Math.floor(rank); + int hi = (int) Math.ceil(rank); + if (lo == hi) return nums.get(lo); + double frac = rank - lo; + return nums.get(lo).multiply(java.math.BigDecimal.valueOf(1 - frac)) + .add(nums.get(hi).multiply(java.math.BigDecimal.valueOf(frac))); + } + + // --------------------------------------------------------------------------------- + // String formatting -- format(template, args...) + concat(...) + // --------------------------------------------------------------------------------- + + private Object evaluateStringFormat(Object[] args) { + if (args.length < 1) { + throw new IllegalArgumentException("format(template, args...) requires a template argument"); + } + if (!(args[0] instanceof String)) { + throw new IllegalArgumentException("format: first argument must be a template string"); + } + String template = (String) args[0]; + StringBuilder out = new StringBuilder(template.length()); + for (int i = 0; i < template.length(); i++) { + char c = template.charAt(i); + if (c == '{' && i + 1 < template.length()) { + // Find closing brace + int end = template.indexOf('}', i + 1); + if (end > i) { + String indexStr = template.substring(i + 1, end); + try { + int idx = Integer.parseInt(indexStr); + if (idx + 1 < args.length) { + out.append(args[idx + 1]); + } else { + throw new IllegalArgumentException("format: template references {" + idx + + "} but only " + (args.length - 1) + " arguments were supplied"); + } + i = end; + continue; + } catch (NumberFormatException nfe) { + // not a numeric placeholder; emit verbatim + } + } + } + out.append(c); + } + return out.toString(); + } + + private Object evaluateConcat(Object[] args) { + StringBuilder out = new StringBuilder(); + for (Object a : args) out.append(a == null ? "" : a.toString()); + return out.toString(); + } + // Property access implementation private Object evaluatePropertyAccess(Object object, String propertyPath) { @@ -1034,21 +1463,41 @@ else if (current instanceof List && part.matches("\\d+")) { } private Object getPropertyValue(Object object, String propertyName) { + // Map-valued objects: property access is a key lookup. Missing key -> null + // (legitimate "missing value" semantics, mirrored by json_get). + if (object instanceof java.util.Map) { + return ((java.util.Map) object).get(propertyName); + } + // Bean access via reflection: try get then is; throw if neither exists. + // A missing getter is almost always a typo in the rule, not a legitimate runtime + // nullable, so surface it rather than masking it as a null value. + String suffix = Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1); + Class cls = object.getClass(); + java.lang.reflect.Method accessor = findAccessor(cls, "get" + suffix); + if (accessor == null) { + accessor = findAccessor(cls, "is" + suffix); + } + if (accessor == null) { + throw new IllegalArgumentException( + "No accessor 'get" + suffix + "' or 'is" + suffix + "' on " + cls.getName() + + "; check that property '" + propertyName + "' exists on the bean"); + } try { - // Try getter method first - String getterName = "get" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1); - java.lang.reflect.Method getter = object.getClass().getMethod(getterName); - return getter.invoke(object); - } catch (Exception e) { - try { - // Try boolean getter - String booleanGetterName = "is" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1); - java.lang.reflect.Method booleanGetter = object.getClass().getMethod(booleanGetterName); - return booleanGetter.invoke(object); - } catch (Exception e2) { - log.warn("Could not access property '{}' on object of type {}", propertyName, object.getClass().getSimpleName()); - return null; - } + return accessor.invoke(object); + } catch (ReflectiveOperationException e) { + Throwable cause = e.getCause() != null ? e.getCause() : e; + throw new IllegalArgumentException( + "Failed to read property '" + propertyName + "' on " + cls.getName() + + ": " + cause.getMessage(), cause); + } + } + + private static java.lang.reflect.Method findAccessor(Class cls, String name) { + try { + java.lang.reflect.Method m = cls.getMethod(name); + return m.getParameterCount() == 0 ? m : null; + } catch (NoSuchMethodException e) { + return null; } } @@ -1377,9 +1826,8 @@ private Object calculateLoanPayment(Object[] args) { } return result; - } catch (Exception e) { - log.warn("Error calculating loan payment: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_loan_payment", e); } } @@ -1398,9 +1846,8 @@ private Object calculateCompoundInterest(Object[] args) { BigDecimal compoundFactor = onePlusRate.pow(totalPeriods); return principal.multiply(compoundFactor); - } catch (Exception e) { - log.warn("Error calculating compound interest: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_compound_interest", e); } } @@ -1424,9 +1871,8 @@ private Object calculateAmortization(Object[] args) { result.put("principal", principal); return result; - } catch (Exception e) { - log.warn("Error calculating amortization: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_amortization", e); } } @@ -1440,9 +1886,8 @@ private Object debtToIncomeRatio(Object[] args) { // Return as decimal ratio (0.333), not percentage (33.33) return monthlyDebt.divide(monthlyIncome, 4, RoundingMode.HALF_UP); - } catch (Exception e) { - log.warn("Error calculating debt-to-income ratio: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("debt_to_income_ratio", e); } } @@ -1456,9 +1901,8 @@ private Object creditUtilization(Object[] args) { return currentBalance.divide(creditLimit, 4, RoundingMode.HALF_UP) .multiply(BigDecimal.valueOf(100)); - } catch (Exception e) { - log.warn("Error calculating credit utilization: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("credit_utilization", e); } } @@ -1472,9 +1916,8 @@ private Object loanToValue(Object[] args) { return loanAmount.divide(propertyValue, 4, RoundingMode.HALF_UP) .multiply(BigDecimal.valueOf(100)); - } catch (Exception e) { - log.warn("Error calculating loan-to-value ratio: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("loan_to_value", e); } } @@ -1496,9 +1939,8 @@ private Object calculateAPR(Object[] args) { return annualInterest.divide(avgBalance, 4, RoundingMode.HALF_UP) .multiply(BigDecimal.valueOf(100)); - } catch (Exception e) { - log.warn("Error calculating APR: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_apr", e); } } @@ -1528,9 +1970,8 @@ private Object calculateCreditScore(Object[] args) { if (scaledScore.compareTo(BigDecimal.valueOf(850)) > 0) return 850; return scaledScore.intValue(); - } catch (Exception e) { - log.warn("Error calculating credit score: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_credit_score", e); } } @@ -1570,9 +2011,8 @@ private Object calculateRiskScore(Object[] args) { } return riskScore; - } catch (Exception e) { - log.warn("Error calculating risk score: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_risk_score", e); } } @@ -1601,9 +2041,8 @@ private Object paymentHistoryScore(Object[] args) { if (score.compareTo(BigDecimal.valueOf(100)) > 0) return 100; return score; - } catch (Exception e) { - log.warn("Error calculating payment history score: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("payment_history_score", e); } } @@ -1653,9 +2092,8 @@ private Object formatCurrency(Object[] args) { } return formatter.format(amount); - } catch (Exception e) { - log.warn("Error formatting currency: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("format_currency", e); } } @@ -1670,9 +2108,8 @@ private Object formatPercentage(Object[] args) { formatter.setMinimumFractionDigits(decimals); return formatter.format(value.divide(BigDecimal.valueOf(100), 10, RoundingMode.HALF_UP)); - } catch (Exception e) { - log.warn("Error formatting percentage: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("format_percentage", e); } } @@ -1715,9 +2152,8 @@ private Object distanceBetween(Object[] args) { double distance = R * c; return BigDecimal.valueOf(distance); - } catch (Exception e) { - log.warn("Error calculating distance: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("distance_between", e); } } @@ -1739,50 +2175,50 @@ private Object timeHour(Object[] args) { } return null; - } catch (Exception e) { - log.warn("Error extracting hour from timestamp: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("time_hour", e); } } private Object isValid(Object[] args) { - if (args.length < 2) return false; - try { - Object value = args[0]; - String validationType = toString(args[1]); - - return switch (validationType.toLowerCase()) { - case "email", "email_format" -> isEmail(value); - case "phone", "phone_format" -> isPhone(value); - case "ssn", "ssn_format" -> isSSN(value); - case "credit_score" -> isCreditScore(value); - case "account_number" -> isAccountNumber(value); - case "routing_number" -> isRoutingNumber(value); - case "numeric" -> isNumeric(value); - case "date" -> isDate(value); - case "positive" -> isPositive(value); - case "negative" -> isNegative(value); - case "currency" -> isCurrency(value); - case "percentage" -> isPercentage(value); - default -> false; - }; - } catch (Exception e) { - log.warn("Error in validation: {}", e.getMessage()); - return false; + if (args.length < 2) { + throw new IllegalArgumentException( + "is_valid(value, type) requires 2 arguments (value, type); got " + args.length); } + Object value = args[0]; + String validationType = toString(args[1]); + return switch (validationType.toLowerCase()) { + case "email", "email_format" -> isEmail(value); + case "phone", "phone_format" -> isPhone(value); + case "ssn", "ssn_format" -> isSSN(value); + case "credit_score" -> isCreditScore(value); + case "account_number" -> isAccountNumber(value); + case "routing_number" -> isRoutingNumber(value); + case "numeric" -> isNumeric(value); + case "date" -> isDate(value); + case "positive" -> isPositive(value); + case "negative" -> isNegative(value); + case "currency" -> isCurrency(value); + case "percentage" -> isPercentage(value); + default -> throw new IllegalArgumentException( + "is_valid: unknown validation type '" + validationType + "'. " + + "Known types: email, phone, ssn, credit_score, account_number, " + + "routing_number, numeric, date, positive, negative, currency, percentage."); + }; } private Object inRange(Object[] args) { - if (args.length < 3) return false; + if (args.length < 3) { + throw new IllegalArgumentException( + "is_in_range(value, low, high) / in_range(...) requires 3 arguments; got " + args.length); + } try { BigDecimal value = toNumber(args[0]); BigDecimal min = toNumber(args[1]); BigDecimal max = toNumber(args[2]); - return value.compareTo(min) >= 0 && value.compareTo(max) <= 0; - } catch (Exception e) { - log.warn("Error checking range: {}", e.getMessage()); - return false; + } catch (RuntimeException e) { + throw wrapFunctionError("in_range", e); } } @@ -1896,9 +2332,8 @@ private Object calculateDebtRatio(Object[] args) { BigDecimal ratio = totalDebt.divide(totalIncome, 4, RoundingMode.HALF_UP); return ratio.multiply(BigDecimal.valueOf(100)); // Return as percentage - } catch (Exception e) { - log.warn("Error calculating debt ratio: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_debt_ratio", e); } } @@ -1915,9 +2350,8 @@ private Object calculateLTV(Object[] args) { BigDecimal ltv = loanAmount.divide(propertyValue, 4, RoundingMode.HALF_UP); return ltv.multiply(BigDecimal.valueOf(100)); // Return as percentage - } catch (Exception e) { - log.warn("Error calculating LTV: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_ltv", e); } } @@ -1956,9 +2390,8 @@ private Object calculatePaymentSchedule(Object[] args) { } return schedule; - } catch (Exception e) { - log.warn("Error calculating payment schedule: {}", e.getMessage()); - return null; + } catch (RuntimeException e) { + throw wrapFunctionError("calculate_payment_schedule", e); } } @@ -2200,87 +2633,6 @@ private Map createErrorResponse(String message) { return errorResponse; } - @Override - public Object visitJsonPathExpression(JsonPathExpression node) { - if (jsonPathService == null) { - log.warn("JsonPathService not available for JSON path expression"); - return null; - } - - try { - Object sourceValue = node.getSourceExpression().accept(this); - if (sourceValue == null) { - return null; - } - - String jsonPath = node.getJsonPath(); - Object result = jsonPathService.extractValue(sourceValue, jsonPath); - - JsonLogger.info(log, context.getOperationId(), - String.format("JSON path extraction: %s -> %s", jsonPath, result)); - - return result; - } catch (Exception e) { - JsonLogger.error(log, context.getOperationId(), - "Error evaluating JSON path expression: " + node.toDebugString(), e); - return null; - } - } - - @Override - public Object visitRestCallExpression(RestCallExpression node) { - if (restCallService == null) { - log.warn("RestCallService not available for REST call expression"); - return null; - } - - try { - // Evaluate URL - String url = (String) node.getUrlExpression().accept(this); - if (url == null || url.trim().isEmpty()) { - throw new IllegalArgumentException("URL cannot be null or empty"); - } - - // Evaluate optional parameters - Object body = node.getBodyExpression() != null ? - node.getBodyExpression().accept(this) : null; - - @SuppressWarnings("unchecked") - Map headers = node.getHeadersExpression() != null ? - (Map) node.getHeadersExpression().accept(this) : null; - - Long timeout = node.getTimeoutExpression() != null ? - toLong(node.getTimeoutExpression().accept(this)) : null; - - // Make the REST call - String method = node.getHttpMethod(); - JsonLogger.info(log, context.getOperationId(), - String.format("Making REST call: %s %s", method, url)); - - // Since we're in a synchronous context, we need to block on the reactive call - Map result = restCallService.request(method, url, body, headers, timeout) - .block(); // This blocks the current thread - in production, consider async handling - - JsonLogger.info(log, context.getOperationId(), - String.format("REST call completed: %s %s", method, url)); - - return result; - - } catch (Exception e) { - JsonLogger.error(log, context.getOperationId(), - "Error evaluating REST call expression: " + node.toDebugString(), e); - - // Return error response instead of null - Map errorResponse = new java.util.HashMap<>(); - errorResponse.put("success", false); - errorResponse.put("error", true); - errorResponse.put("message", e.getMessage()); - return errorResponse; - } - } - - - /** * Convert an object to Long */ @@ -2291,7 +2643,8 @@ private Long toLong(Object value) { try { return Long.parseLong(value.toString()); } catch (NumberFormatException e) { - return null; + throw new IllegalArgumentException( + "Cannot convert '" + value + "' to a long; expected integer-like input", e); } } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ValidationVisitor.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ValidationVisitor.java index 04a4ac8..c84fb72 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ValidationVisitor.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/dsl/visitor/ValidationVisitor.java @@ -188,50 +188,6 @@ public List visitFunctionCallExpression(FunctionCallExpression return errors; } - @Override - public List visitArithmeticExpression(ArithmeticExpression node) { - List errors = new ArrayList<>(); - - // Validate operands - for (Expression operand : node.getOperands()) { - errors.addAll(operand.accept(this)); - - // Only flag as error if we have definite non-numeric types - if (isDefinitelyNonNumeric(operand.getExpressionType())) { - errors.add(new ValidationError( - "Arithmetic operations require numeric operands", - node.getLocation(), - "VAL_009" - )); - } - } - - // Validate operand count - int operandCount = node.getOperandCount(); - int minOperands = node.getOperation().getMinOperands(); - int maxOperands = node.getOperation().getMaxOperands(); - - if (operandCount < minOperands) { - errors.add(new ValidationError( - String.format("Operation %s requires at least %d operands, got %d", - node.getOperation().getSymbol(), minOperands, operandCount), - node.getLocation(), - "VAL_010" - )); - } - - if (operandCount > maxOperands) { - errors.add(new ValidationError( - String.format("Operation %s allows at most %d operands, got %d", - node.getOperation().getSymbol(), maxOperands, operandCount), - node.getLocation(), - "VAL_011" - )); - } - - return errors; - } - // Condition visitors @Override @@ -303,25 +259,6 @@ public List visitExpressionCondition(ExpressionCondition node) // Action visitors - @Override - public List visitAssignmentAction(AssignmentAction node) { - List errors = new ArrayList<>(); - - // Validate value expression - errors.addAll(node.getValue().accept(this)); - - // Variable name validation (basic check) - if (node.getVariableName() == null || node.getVariableName().trim().isEmpty()) { - errors.add(new ValidationError( - "Assignment action requires a variable name", - node.getLocation(), - "VAL_015" - )); - } - - return errors; - } - @Override public List visitFunctionCallAction(FunctionCallAction node) { List errors = new ArrayList<>(); @@ -405,12 +342,6 @@ private boolean containsNonMathematicalOperation(Expression expression) { if (expression instanceof FunctionCallExpression) { return true; } - if (expression instanceof RestCallExpression) { - return true; - } - if (expression instanceof JsonPathExpression) { - return true; - } if (expression instanceof BinaryExpression binaryExpr) { return containsNonMathematicalOperation(binaryExpr.getLeft()) || containsNonMathematicalOperation(binaryExpr.getRight()); @@ -418,17 +349,6 @@ private boolean containsNonMathematicalOperation(Expression expression) { if (expression instanceof UnaryExpression unaryExpr) { return containsNonMathematicalOperation(unaryExpr.getOperand()); } - if (expression instanceof ArithmeticExpression arithmeticExpr) { - // Check all operands in the arithmetic expression - if (arithmeticExpr.getOperands() != null) { - for (Expression operand : arithmeticExpr.getOperands()) { - if (containsNonMathematicalOperation(operand)) { - return true; - } - } - } - return false; - } // LiteralExpression and VariableExpression are allowed return false; } @@ -685,52 +605,4 @@ public List visitDoWhileAction(DoWhileAction node) { return errors; } - @Override - public List visitJsonPathExpression(JsonPathExpression node) { - List errors = new ArrayList<>(); - - // Validate source expression - errors.addAll(node.getSourceExpression().accept(this)); - - // Validate JSON path syntax - if (node.getJsonPath() == null || node.getJsonPath().trim().isEmpty()) { - errors.add(new ValidationError( - "JSON path cannot be empty", - node.getLocation(), - "VAL_019" - )); - } - - return errors; - } - - @Override - public List visitRestCallExpression(RestCallExpression node) { - List errors = new ArrayList<>(); - - // Validate URL expression - errors.addAll(node.getUrlExpression().accept(this)); - - // Validate HTTP method - if (node.getHttpMethod() == null || node.getHttpMethod().trim().isEmpty()) { - errors.add(new ValidationError( - "HTTP method cannot be empty", - node.getLocation(), - "VAL_020" - )); - } - - // Validate optional expressions - if (node.getBodyExpression() != null) { - errors.addAll(node.getBodyExpression().accept(this)); - } - if (node.getHeadersExpression() != null) { - errors.addAll(node.getHeadersExpression().accept(this)); - } - if (node.getTimeoutExpression() != null) { - errors.addAll(node.getTimeoutExpression().accept(this)); - } - - return errors; - } } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/CacheServiceImpl.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/CacheServiceImpl.java index bdcfd58..4ea548f 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/CacheServiceImpl.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/CacheServiceImpl.java @@ -150,7 +150,8 @@ public void cacheConstant(String code, ConstantDTO constant) { String fullKey = CONSTANT_PREFIX + code; cacheManager.put(fullKey, constant) .doOnError(e -> log.warn("Cache write failed for constant {}: {}", code, e.getMessage())) - .subscribe(); + .onErrorComplete() + .subscribe(); log.debug("Cached constant with code: {}", code); } catch (Exception e) { log.warn("Error caching constant for code: {}", code, e); @@ -178,6 +179,7 @@ public void invalidateConstant(String code) { String fullKey = CONSTANT_PREFIX + code; cacheManager.evict(fullKey) .doOnError(e -> log.warn("Cache evict failed for constant {}: {}", code, e.getMessage())) + .onErrorComplete() .subscribe(); log.debug("Invalidated constants cache entry for code: {}", code); } @@ -186,6 +188,7 @@ public void invalidateConstant(String code) { public void clearConstantsCache() { cacheManager.clear() .doOnError(e -> log.warn("Cache clear failed for constants: {}", e.getMessage())) + .onErrorComplete() .subscribe(); log.info("Cleared all constants cache entries"); } @@ -212,7 +215,8 @@ public void cacheRuleDefinition(String code, RuleDefinitionDTO ruleDefinition) { String fullKey = RULE_DEF_PREFIX + code; cacheManager.put(fullKey, ruleDefinition) .doOnError(e -> log.warn("Cache write failed for rule definition {}: {}", code, e.getMessage())) - .subscribe(); + .onErrorComplete() + .subscribe(); log.debug("Cached rule definition with code: {}", code); } catch (Exception e) { log.warn("Error caching rule definition for code: {}", code, e); @@ -224,6 +228,7 @@ public void invalidateRuleDefinition(String code) { String fullKey = RULE_DEF_PREFIX + code; cacheManager.evict(fullKey) .doOnError(e -> log.warn("Cache evict failed for rule definition {}: {}", code, e.getMessage())) + .onErrorComplete() .subscribe(); log.debug("Invalidated rule definitions cache entry for code: {}", code); } @@ -232,6 +237,7 @@ public void invalidateRuleDefinition(String code) { public void clearRuleDefinitionsCache() { cacheManager.clear() .doOnError(e -> log.warn("Cache clear failed for rule definitions: {}", e.getMessage())) + .onErrorComplete() .subscribe(); log.info("Cleared all rule definitions cache entries"); } @@ -258,7 +264,8 @@ public void cacheValidationResult(String cacheKey, ValidationResult validationRe String fullKey = VALIDATION_PREFIX + cacheKey; cacheManager.put(fullKey, validationResult) .doOnError(e -> log.warn("Cache write failed for validation result {}: {}", cacheKey, e.getMessage())) - .subscribe(); + .onErrorComplete() + .subscribe(); log.debug("Cached validation result with key: {}", cacheKey); } catch (Exception e) { log.warn("Error caching validation result for key: {}", cacheKey, e); @@ -270,6 +277,7 @@ public void invalidateValidationResult(String cacheKey) { String fullKey = VALIDATION_PREFIX + cacheKey; cacheManager.evict(fullKey) .doOnError(e -> log.warn("Cache evict failed for validation result {}: {}", cacheKey, e.getMessage())) + .onErrorComplete() .subscribe(); log.debug("Invalidated validation cache entry for key: {}", cacheKey); } @@ -278,6 +286,7 @@ public void invalidateValidationResult(String cacheKey) { public void clearValidationCache() { cacheManager.clear() .doOnError(e -> log.warn("Cache clear failed for validation cache: {}", e.getMessage())) + .onErrorComplete() .subscribe(); log.info("Cleared all validation cache entries"); } @@ -324,6 +333,7 @@ public CacheProviderInfo getCacheProviderInfo() { public void clearAllCaches() { cacheManager.clear() .doOnError(e -> log.warn("Cache clear failed: {}", e.getMessage())) + .onErrorComplete() .subscribe(); log.info("Cleared all caches"); } diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/RuleInvokerImpl.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/RuleInvokerImpl.java new file mode 100644 index 0000000..2091796 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/services/impl/RuleInvokerImpl.java @@ -0,0 +1,59 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + */ +package org.fireflyframework.rules.core.services.impl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.RuleInvoker; +import org.fireflyframework.rules.core.services.RuleDefinitionService; +import org.springframework.beans.factory.ObjectProvider; +import org.springframework.stereotype.Component; + +import java.util.Collections; +import java.util.Map; + +/** + * Default {@link RuleInvoker} backed by {@link RuleDefinitionService}. Resolves the + * stored rule by code, evaluates it synchronously (via {@code Mono.block()}), and + * returns its output map. Nested invocations are intentionally blocking -- this + * keeps the synchronous visitor model intact and runs entirely on the + * {@code boundedElastic} worker the engine schedules itself onto. + * + *

The dependency on {@code RuleDefinitionService} is wired lazily via + * {@link ObjectProvider} so we don't create a hard cycle between the evaluation + * engine and the service that depends on it. + */ +@Component +public class RuleInvokerImpl implements RuleInvoker { + + private final ObjectProvider ruleDefinitionServiceProvider; + + public RuleInvokerImpl(ObjectProvider ruleDefinitionServiceProvider) { + this.ruleDefinitionServiceProvider = ruleDefinitionServiceProvider; + } + + @Override + public Map invokeBlocking(String code, Map inputData) { + RuleDefinitionService service = ruleDefinitionServiceProvider.getIfAvailable(); + if (service == null) { + throw new IllegalStateException( + "invoke_rule() requires RuleDefinitionService on the classpath. Include the " + + "rule-engine-models module and provide an R2DBC datasource."); + } + ASTRulesEvaluationResult nested = service.evaluateRuleByCode(code, inputData == null ? Collections.emptyMap() : inputData) + .blockOptional() + .orElseThrow(() -> new IllegalStateException( + "invoke_rule('" + code + "') returned no result")); + if (!nested.isSuccess()) { + throw new IllegalStateException( + "invoke_rule('" + code + "') failed: " + nested.getError()); + } + return nested.getOutputData() != null ? nested.getOutputData() : Collections.emptyMap(); + } +} diff --git a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/validation/YamlDslValidator.java b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/validation/YamlDslValidator.java index c13a787..0e4231b 100644 --- a/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/validation/YamlDslValidator.java +++ b/fireflyframework-rule-engine-core/src/main/java/org/fireflyframework/rules/core/validation/YamlDslValidator.java @@ -203,10 +203,10 @@ private List performNamingValidation(ASTRulesD if (rulesDSL.getInput() != null) { for (String inputName : rulesDSL.getInput().keySet()) { if (!namingValidator.isValidInputVariableName(inputName)) { - issues.add(createIssue("NAMING_001", ValidationResult.ValidationSeverity.WARNING, - "Invalid input variable name", - "Input variable '" + inputName + "' should use camelCase (e.g., creditScore)", - "input." + inputName, "Use camelCase naming")); + issues.add(createIssue("NAMING_001", ValidationResult.ValidationSeverity.ERROR, + "Invalid input variable name", + "Input variable '" + inputName + "' must use camelCase (e.g., creditScore)", + "input." + inputName, "Rename to camelCase")); } } } @@ -215,10 +215,10 @@ private List performNamingValidation(ASTRulesD if (rulesDSL.getConstants() != null) { for (var constant : rulesDSL.getConstants()) { if (constant.getCode() != null && !namingValidator.isValidConstantName(constant.getCode())) { - issues.add(createIssue("NAMING_002", ValidationResult.ValidationSeverity.WARNING, + issues.add(createIssue("NAMING_002", ValidationResult.ValidationSeverity.ERROR, "Invalid constant name", - "Constant '" + constant.getCode() + "' should use UPPER_CASE_WITH_UNDERSCORES", - "constants." + constant.getCode(), "Use UPPER_CASE naming")); + "Constant '" + constant.getCode() + "' must use UPPER_CASE_WITH_UNDERSCORES", + "constants." + constant.getCode(), "Rename to UPPER_CASE")); } } } @@ -658,14 +658,6 @@ public Void visitFunctionCallExpression(FunctionCallExpression node) { return null; } - @Override - public Void visitArithmeticExpression(ArithmeticExpression node) { - if (node.getOperands() != null) { - node.getOperands().forEach(operand -> operand.accept(this)); - } - return null; - } - @Override public Void visitComparisonCondition(ComparisonCondition node) { if (node.getLeft() != null) node.getLeft().accept(this); @@ -687,12 +679,6 @@ public Void visitExpressionCondition(ExpressionCondition node) { return null; } - @Override - public Void visitAssignmentAction(AssignmentAction node) { - if (node.getValue() != null) node.getValue().accept(this); - return null; - } - @Override public Void visitFunctionCallAction(FunctionCallAction node) { if (node.getArguments() != null) { @@ -802,32 +788,6 @@ public Void visitDoWhileAction(DoWhileAction node) { return null; } - @Override - public Void visitJsonPathExpression(JsonPathExpression node) { - // Visit the source expression to collect any variable references - if (node.getSourceExpression() != null) { - node.getSourceExpression().accept(this); - } - return null; - } - - @Override - public Void visitRestCallExpression(RestCallExpression node) { - // Visit all expressions to collect any variable references - if (node.getUrlExpression() != null) { - node.getUrlExpression().accept(this); - } - if (node.getBodyExpression() != null) { - node.getBodyExpression().accept(this); - } - if (node.getHeadersExpression() != null) { - node.getHeadersExpression().accept(this); - } - if (node.getTimeoutExpression() != null) { - node.getTimeoutExpression().accept(this); - } - return null; - } } /** @@ -1064,11 +1024,6 @@ private List performDSLReferenceValidation(AST issues.addAll(validateMetadataSection(rulesDSL.getMetadata())); } - // Validate circuit breaker configuration if present - if (rulesDSL.getCircuitBreaker() != null) { - issues.addAll(validateCircuitBreakerConfig(rulesDSL.getCircuitBreaker())); - } - // Validate when/then structure if (rulesDSL.getWhenConditions() != null && !rulesDSL.getWhenConditions().isEmpty()) { if (rulesDSL.getThenActions() == null || rulesDSL.getThenActions().isEmpty()) { @@ -1187,20 +1142,6 @@ private List validateMetadataSection(Map validateCircuitBreakerConfig(ASTRulesDSL.ASTCircuitBreakerConfig circuitBreaker) { - List issues = new ArrayList<>(); - - // Note: ASTCircuitBreakerConfig is referenced but may not be fully implemented yet - // This is a placeholder for when the circuit breaker configuration is fully implemented - - log.debug("Circuit breaker configuration validation - implementation pending"); - - return issues; - } - /** * Perform operator and function validation */ diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/audit/AuditTrailIntegrationTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/audit/AuditTrailIntegrationTest.java deleted file mode 100644 index 32f97ae..0000000 --- a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/audit/AuditTrailIntegrationTest.java +++ /dev/null @@ -1,307 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.audit; - -import org.fireflyframework.rules.core.services.AuditTrailService; -import org.fireflyframework.rules.core.services.impl.AuditTrailServiceImpl; -import org.fireflyframework.rules.interfaces.dtos.audit.AuditEventType; -import org.fireflyframework.rules.interfaces.dtos.audit.AuditTrailDTO; -import org.fireflyframework.rules.interfaces.dtos.audit.AuditTrailFilterDTO; -import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.ActiveProfiles; -import reactor.test.StepVerifier; - -import java.time.OffsetDateTime; -import java.util.HashMap; -import java.util.Map; -import java.util.UUID; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * Integration tests for the audit trail system. - * Tests the complete audit trail functionality including service and repository layers. - */ -@Disabled("Requires full Spring Boot context - enable for integration testing") -@SpringBootTest(classes = { - AuditTrailService.class, - AuditTrailServiceImpl.class, - AuditHelper.class -}) -@ActiveProfiles("test") -class AuditTrailIntegrationTest { - - @Autowired - private AuditTrailService auditTrailService; - - @Test - void auditTrailLifecycle_ShouldWorkEndToEnd() { - // Given - UUID entityId = UUID.randomUUID(); - String ruleCode = "integration_test_rule_v1"; - String userId = "integration.test@company.com"; - - // When - Record audit event - StepVerifier.create(auditTrailService.recordAuditEvent( - AuditEventType.RULE_DEFINITION_CREATE, - entityId, - ruleCode, - userId, - "POST", - "/api/v1/rules/definitions", - "{\"code\":\"integration_test_rule\"}", - "{\"id\":\"" + entityId + "\"}", - 201, - true, - 250L - )) - .assertNext(auditTrailDTO -> { - assertThat(auditTrailDTO).isNotNull(); - assertThat(auditTrailDTO.getOperationType()).isEqualTo("RULE_DEFINITION_CREATE"); - assertThat(auditTrailDTO.getEntityType()).isEqualTo("RULE_DEFINITION"); - assertThat(auditTrailDTO.getEntityId()).isEqualTo(entityId); - assertThat(auditTrailDTO.getRuleCode()).isEqualTo(ruleCode); - assertThat(auditTrailDTO.getUserId()).isEqualTo(userId); - assertThat(auditTrailDTO.getSuccess()).isTrue(); - assertThat(auditTrailDTO.getExecutionTimeMs()).isEqualTo(250L); - }) - .verifyComplete(); - - // Then - Retrieve audit trails with filter - AuditTrailFilterDTO filterDTO = AuditTrailFilterDTO.builder() - .operationType("RULE_DEFINITION_CREATE") - .userId(userId) - .page(0) - .size(10) - .build(); - - StepVerifier.create(auditTrailService.getAuditTrails(filterDTO)) - .assertNext(response -> { - assertThat(response).isNotNull(); - assertThat(response.getContent()).isNotEmpty(); - assertThat(response.getContent().get(0).getRuleCode()).isEqualTo(ruleCode); - assertThat(response.getContent().get(0).getUserId()).isEqualTo(userId); - }) - .verifyComplete(); - - // And - Get recent audit trails for entity - StepVerifier.create(auditTrailService.getRecentAuditTrailsForEntity(entityId, 5)) - .assertNext(auditTrails -> { - assertThat(auditTrails).isNotEmpty(); - assertThat(auditTrails.get(0).getEntityId()).isEqualTo(entityId); - assertThat(auditTrails.get(0).getRuleCode()).isEqualTo(ruleCode); - }) - .verifyComplete(); - } - - @Test - void recordAuditEventWithMetadata_ShouldStoreMetadata() { - // Given - Map metadata = new HashMap<>(); - metadata.put("evaluationType", "DIRECT"); - metadata.put("inputDataSize", 5); - metadata.put("conditionResult", true); - metadata.put("circuitBreakerTriggered", false); - - // When - StepVerifier.create(auditTrailService.recordAuditEventWithMetadata( - AuditEventType.RULE_EVALUATION_DIRECT, - null, // entityId - null, // ruleCode - "test.user@company.com", - "POST", - "/api/v1/rules/evaluate/direct", - "{\"inputData\":{\"creditScore\":750}}", - "{\"success\":true,\"conditionResult\":true}", - 200, - true, - 180L, - metadata - )) - .assertNext(auditTrailDTO -> { - assertThat(auditTrailDTO).isNotNull(); - assertThat(auditTrailDTO.getOperationType()).isEqualTo("RULE_EVALUATION_DIRECT"); - assertThat(auditTrailDTO.getEntityType()).isEqualTo("RULE_EVALUATION"); - assertThat(auditTrailDTO.getMetadata()).isNotNull(); - assertThat(auditTrailDTO.getMetadata()).contains("evaluationType"); - assertThat(auditTrailDTO.getMetadata()).contains("DIRECT"); - }) - .verifyComplete(); - } - - @Test - void getAuditTrailStatistics_ShouldReturnCorrectStatistics() { - // Given - Record some audit events first - String userId = "stats.test@company.com"; - - // Record successful operation - auditTrailService.recordAuditEvent( - AuditEventType.RULE_DEFINITION_CREATE, - UUID.randomUUID(), - "stats_test_rule_1", - userId, - "POST", - "/api/v1/rules/definitions", - "{}", - "{}", - 201, - true, - 100L - ).block(); - - // Record failed operation - auditTrailService.recordAuditEvent( - AuditEventType.RULE_DEFINITION_UPDATE, - UUID.randomUUID(), - "stats_test_rule_2", - userId, - "PUT", - "/api/v1/rules/definitions/123", - "{}", - null, - 400, - false, - 50L - ).block(); - - // When - StepVerifier.create(auditTrailService.getAuditTrailStatistics()) - .assertNext(stats -> { - assertThat(stats).isNotNull(); - assertThat(stats.get("totalCount")).isNotNull(); - assertThat(stats.get("successCount")).isNotNull(); - assertThat(stats.get("failureCount")).isNotNull(); - assertThat(stats.get("successRate")).isNotNull(); - assertThat(stats.get("operationCounts")).isNotNull(); - - // Verify that our test data is included - Long totalCount = (Long) stats.get("totalCount"); - assertThat(totalCount).isGreaterThanOrEqualTo(2L); - }) - .verifyComplete(); - } - - @Test - void filterAuditTrailsByDateRange_ShouldReturnCorrectResults() { - // Given - String userId = "daterange.test@company.com"; - OffsetDateTime now = OffsetDateTime.now(); - OffsetDateTime startDate = now.minusHours(1); - OffsetDateTime endDate = now.plusHours(1); - - // Record an audit event - auditTrailService.recordAuditEvent( - AuditEventType.RULE_EVALUATION_BY_CODE, - null, - "daterange_test_rule", - userId, - "POST", - "/api/v1/rules/evaluate/by-code", - "{}", - "{}", - 200, - true, - 120L - ).block(); - - // When - AuditTrailFilterDTO filterDTO = AuditTrailFilterDTO.builder() - .userId(userId) - .startDate(startDate) - .endDate(endDate) - .page(0) - .size(10) - .build(); - - StepVerifier.create(auditTrailService.getAuditTrails(filterDTO)) - .assertNext(response -> { - assertThat(response).isNotNull(); - assertThat(response.getContent()).isNotEmpty(); - - // Verify the audit trail is within the date range - AuditTrailDTO auditTrail = response.getContent().get(0); - assertThat(auditTrail.getUserId()).isEqualTo(userId); - assertThat(auditTrail.getCreatedAt()).isAfter(startDate); - assertThat(auditTrail.getCreatedAt()).isBefore(endDate); - }) - .verifyComplete(); - } - - @Test - void filterAuditTrailsByMultipleCriteria_ShouldReturnFilteredResults() { - // Given - String userId = "multicriteria.test@company.com"; - String ruleCode = "multicriteria_test_rule"; - - // Record audit events with different criteria - auditTrailService.recordAuditEvent( - AuditEventType.RULE_DEFINITION_CREATE, - UUID.randomUUID(), - ruleCode, - userId, - "POST", - "/api/v1/rules/definitions", - "{}", - "{}", - 201, - true, - 150L - ).block(); - - auditTrailService.recordAuditEvent( - AuditEventType.RULE_DEFINITION_UPDATE, - UUID.randomUUID(), - "different_rule", - userId, - "PUT", - "/api/v1/rules/definitions/123", - "{}", - "{}", - 200, - true, - 100L - ).block(); - - // When - Filter by operation type and rule code - AuditTrailFilterDTO filterDTO = AuditTrailFilterDTO.builder() - .operationType("RULE_DEFINITION_CREATE") - .ruleCode(ruleCode) - .userId(userId) - .success(true) - .page(0) - .size(10) - .build(); - - StepVerifier.create(auditTrailService.getAuditTrails(filterDTO)) - .assertNext(response -> { - assertThat(response).isNotNull(); - assertThat(response.getContent()).isNotEmpty(); - - // Verify all results match the filter criteria - response.getContent().forEach(auditTrail -> { - assertThat(auditTrail.getOperationType()).isEqualTo("RULE_DEFINITION_CREATE"); - assertThat(auditTrail.getRuleCode()).isEqualTo(ruleCode); - assertThat(auditTrail.getUserId()).isEqualTo(userId); - assertThat(auditTrail.getSuccess()).isTrue(); - }); - }) - .verifyComplete(); - } -} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ASTParserIntegrationTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ASTParserIntegrationTest.java index 63dd5c1..049b49c 100644 --- a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ASTParserIntegrationTest.java +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ASTParserIntegrationTest.java @@ -238,14 +238,27 @@ void testConditionalAction() { } @Test - @DisplayName("Should parse and execute CALL actions") - void testCallAction() { + @DisplayName("Should parse and execute CALL actions for known built-in functions") + void testCallActionWithBuiltin() { + // `log` is a built-in action function; `validateCredit` (the previous test's name) + // does not exist, and after the silent-null-on-unknown-function fix the executor + // now throws -- intentional behaviour to surface typos. assertThatCode(() -> { - Action action = dslParser.parseAction("call validateCredit with [score, income]"); + Action action = dslParser.parseAction("call log with [\"score check\", \"INFO\"]"); ActionExecutor executor = new ActionExecutor(context); action.accept(executor); }).doesNotThrowAnyException(); } + + @Test + @DisplayName("CALL action with unknown function name surfaces a typed error") + void testCallActionUnknownFunctionThrows() { + Action action = dslParser.parseAction("call validateCredit with [score, income]"); + ActionExecutor executor = new ActionExecutor(context); + assertThatThrownBy(() -> action.accept(executor)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("validateCredit"); + } } @Nested diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/AdvancedDSLFeaturesTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/AdvancedDSLFeaturesTest.java index 235f9ab..b36ec42 100644 --- a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/AdvancedDSLFeaturesTest.java +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/AdvancedDSLFeaturesTest.java @@ -30,6 +30,7 @@ import java.util.Map; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.*; /** @@ -499,49 +500,75 @@ void testDateFunctionsWithDifferentFormats() { } @Test - @DisplayName("Test date functions error handling") - void testDateFunctionsErrorHandling() { + @DisplayName("dateadd succeeds for valid dates") + void testDateAddValid() { String yamlRule = """ - name: "Date Error Handling Test" - description: "Test date functions with invalid inputs" - + name: "Date Add Happy Path" inputs: - validDate - - invalidDate - - when: - - validDate is_not_null then: - run validResult as dateadd(validDate, 1, "days") - - run invalidResult as dateadd(invalidDate, 1, "days") - - run invalidUnit as dateadd(validDate, 1, "invalid_unit") - - run diffResult as datediff(validDate, invalidDate, "days") - set result to "COMPLETED" output: validResult: text - invalidResult: text - invalidUnit: text - diffResult: number result: text """; - Map inputData = Map.of( - "validDate", "2024-01-01", - "invalidDate", "not-a-date" - ); - - ASTRulesEvaluationResult result = evaluationEngine.evaluateRules(yamlRule, inputData); + ASTRulesEvaluationResult result = evaluationEngine.evaluateRules( + yamlRule, Map.of("validDate", "2024-01-01")); assertTrue(result.isSuccess()); assertEquals("2024-01-02", result.getOutputData().get("validResult")); - assertNull(result.getOutputData().get("invalidResult")); - assertNull(result.getOutputData().get("invalidUnit")); - assertNull(result.getOutputData().get("diffResult")); assertEquals("COMPLETED", result.getOutputData().get("result")); } + @Test + @DisplayName("dateadd surfaces unparseable dates as a clean rule failure") + void testDateAddInvalidDateFailsLoud() { + String yamlRule = """ + name: "Date Add Invalid" + inputs: + - badDate + + then: + - run result as dateadd(badDate, 1, "days") + + output: + result: text + """; + + ASTRulesEvaluationResult result = evaluationEngine.evaluateRules( + yamlRule, Map.of("badDate", "not-a-date")); + + assertFalse(result.isSuccess()); + assertThat(result.getError()).contains("dateadd"); + } + + @Test + @DisplayName("dateadd surfaces unknown units as a clean rule failure") + void testDateAddInvalidUnitFailsLoud() { + String yamlRule = """ + name: "Date Add Invalid Unit" + inputs: + - validDate + + then: + - run result as dateadd(validDate, 1, "invalid_unit") + + output: + result: text + """; + + ASTRulesEvaluationResult result = evaluationEngine.evaluateRules( + yamlRule, Map.of("validDate", "2024-01-01")); + + assertFalse(result.isSuccess()); + assertThat(result.getError()).contains("dateadd"); + assertThat(result.getError()).contains("invalid_unit"); + } + @Test @DisplayName("Test operator aliases recognition") void testOperatorAliases() { diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ArithmeticActionSymmetryTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ArithmeticActionSymmetryTest.java new file mode 100644 index 0000000..4f243cd --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ArithmeticActionSymmetryTest.java @@ -0,0 +1,162 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Verifies that {@code multiply} and {@code divide} arithmetic actions accept both + * canonical ({@code multiply VALUE by VARIABLE}) and English-natural + * ({@code multiply VARIABLE by VALUE}) orderings, producing identical results. + * + *

{@code add} and {@code subtract} are already English-natural in the value-first + * form ({@code add 5 to score}, {@code subtract penalty from total}) and are not part + * of this symmetry contract. + */ +class ArithmeticActionSymmetryTest { + + private ASTRulesEvaluationEngine engine; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + engine = new ASTRulesEvaluationEngine(parser, constantService); + } + + @Test + @DisplayName("multiply VALUE by VARIABLE (canonical form) -- value first, target second") + void multiplyCanonicalForm() { + String yaml = """ + then: + - set risk_factor to 10 + - multiply 1.5 by risk_factor + output: + risk_factor: number + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("risk_factor").toString())) + .isEqualByComparingTo(new BigDecimal("15.0")); + } + + @Test + @DisplayName("multiply VARIABLE by VALUE (English-natural form) -- target first, value second") + void multiplyEnglishNaturalForm() { + String yaml = """ + then: + - set risk_factor to 10 + - multiply risk_factor by 1.5 + output: + risk_factor: number + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("risk_factor").toString())) + .isEqualByComparingTo(new BigDecimal("15.0")); + } + + @Test + @DisplayName("divide accepts both orderings symmetrically") + void divideBothOrderings() { + String yamlCanonical = """ + then: + - set monthly to 1200 + - divide 12 by monthly + output: + monthly: number + """; + String yamlNatural = """ + then: + - set monthly to 1200 + - divide monthly by 12 + output: + monthly: number + """; + + // Both forms compute monthly = monthly / 12 = 100 + for (String yaml : new String[]{yamlCanonical, yamlNatural}) { + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + assertThat(result.isSuccess()) + .as("yaml: %s", yaml) + .isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("monthly").toString())) + .as("yaml: %s", yaml) + .isEqualByComparingTo(new BigDecimal("100")); + } + } + + @Test + @DisplayName("add and subtract retain English-natural value-first grammar (no symmetry needed)") + void addAndSubtractEnglishNatural() { + String yaml = """ + then: + - set score to 100 + - add 5 to score # score += 5 + - subtract 2 from score # score -= 2 + output: + score: number + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("score").toString())) + .isEqualByComparingTo(new BigDecimal("103")); + } + + @Test + @DisplayName("Complex value expression in either position parses correctly") + void complexValueExpression() { + String yaml = """ + inputs: + baseAmount: "number" + rate: "number" + then: + - set total to baseAmount + - multiply total by (1 + rate) + output: + total: number + """; + + ASTRulesEvaluationResult result = engine.evaluateRules( + yaml, Map.of("baseAmount", new BigDecimal("100"), "rate", new BigDecimal("0.25"))); + + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("total").toString())) + .isEqualByComparingTo(new BigDecimal("125.00")); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ConcurrentEvaluationTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ConcurrentEvaluationTest.java new file mode 100644 index 0000000..c5f848c --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/ConcurrentEvaluationTest.java @@ -0,0 +1,170 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.IntStream; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Verifies that the engine is safe under concurrent evaluation of the same rule against + * different inputs. Each evaluation owns its own {@link org.fireflyframework.rules.core.dsl.visitor.EvaluationContext}, + * the parser caches a shared (immutable) AST, and custom functions are stateless lookups + * -- but the property is only meaningful if exercised, so this test fires hundreds of + * concurrent evaluations and asserts no cross-talk. + */ +class ConcurrentEvaluationTest { + + private ASTRulesEvaluationEngine engine; + private CustomFunctionRegistry registry; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + registry = new CustomFunctionRegistry(); + engine = new ASTRulesEvaluationEngine(parser, constantService, null, null, registry); + } + + /** A non-trivial rule that mutates several local variables in a loop. */ + private static final String LOOP_RULE = """ + inputs: + factor: "number" + count: "number" + then: + - set accumulator to 0 + - set iterations to 0 + - forEach _, idx in [1,2,3,4,5,6,7,8,9,10]: + add factor to accumulator + - set iterations to count + output: + accumulator: accumulator + iterations: iterations + """; + + @Test + @DisplayName("Hundreds of concurrent evaluations of the same rule produce independent, correct results") + void concurrentEvaluationProducesIndependentResults() throws InterruptedException, ExecutionException { + int evaluations = 500; + ExecutorService pool = Executors.newFixedThreadPool(16); + try { + List> futures = new ArrayList<>(evaluations); + for (int i = 0; i < evaluations; i++) { + final int factor = i; + futures.add(CompletableFuture.supplyAsync( + () -> engine.evaluateRules(LOOP_RULE, Map.of("factor", factor, "count", factor)), + pool)); + } + + for (int i = 0; i < evaluations; i++) { + ASTRulesEvaluationResult result = futures.get(i).get(30, TimeUnit.SECONDS); + assertThat(result.isSuccess()) + .as("Evaluation #%d should succeed", i) + .isTrue(); + BigDecimal accumulator = new BigDecimal(result.getOutputData().get("accumulator").toString()); + BigDecimal iterations = new BigDecimal(result.getOutputData().get("iterations").toString()); + + // Each evaluation accumulates factor 10 times, so accumulator = factor * 10 + assertThat(accumulator) + .as("Evaluation #%d: accumulator should equal factor*10", i) + .isEqualByComparingTo(BigDecimal.valueOf(i * 10L)); + // iterations is set to the count input, which is the iteration index + assertThat(iterations) + .as("Evaluation #%d: iterations should equal count input", i) + .isEqualByComparingTo(BigDecimal.valueOf(i)); + } + } catch (java.util.concurrent.TimeoutException e) { + throw new RuntimeException("Evaluation timed out -- possible deadlock under concurrency", e); + } finally { + pool.shutdown(); + assertThat(pool.awaitTermination(10, TimeUnit.SECONDS)) + .as("Thread pool should terminate cleanly") + .isTrue(); + } + } + + @Test + @DisplayName("Custom function called concurrently from many evaluations sees independent argument lists") + void customFunctionConcurrencyIsolation() throws Exception { + // The custom function records every argument list it sees in a thread-safe counter. + // We assert that every recorded argument matches a real evaluation -- i.e. there's + // no torn-read across evaluations sharing state. + AtomicInteger callCount = new AtomicInteger(); + registry.register("score_input", args -> { + callCount.incrementAndGet(); + // Each call receives the integer passed in; doubling it lets us correlate + // input -> output across the concurrent fan-out. + return ((Number) args[0]).intValue() * 2; + }); + + String yaml = """ + inputs: + payload: "number" + then: + - run scored as score_input(payload) + output: + scored: scored + """; + + int evaluations = 200; + ExecutorService pool = Executors.newFixedThreadPool(8); + try { + List> futures = IntStream.range(0, evaluations) + .mapToObj(i -> CompletableFuture.supplyAsync(() -> { + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("payload", i)); + assertThat(result.isSuccess()).isTrue(); + return ((Number) result.getOutputData().get("scored")).intValue(); + }, pool)) + .toList(); + + for (int i = 0; i < evaluations; i++) { + int actual = futures.get(i).get(15, TimeUnit.SECONDS); + assertThat(actual) + .as("Eval #%d should see its own argument (no cross-talk)", i) + .isEqualTo(i * 2); + } + assertThat(callCount.get()).isEqualTo(evaluations); + } finally { + pool.shutdown(); + assertThat(pool.awaitTermination(10, TimeUnit.SECONDS)).isTrue(); + } + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DoWhileAndConditionFunctionTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DoWhileAndConditionFunctionTest.java new file mode 100644 index 0000000..f08a124 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DoWhileAndConditionFunctionTest.java @@ -0,0 +1,132 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Closes two specific test gaps identified by the phase-4 DSL gap audit: + * + *

    + *
  1. {@code do-while} loop semantics (the existing test suite covered {@code forEach} + * and {@code while} but not {@code do-while}).
    2. + *
  2. {@code CustomFunctionRegistry} usage from condition expressions, not + * just actions -- to confirm extension functions are reachable through the + * evaluator from both code paths.
    3. + *
+ */ +class DoWhileAndConditionFunctionTest { + + private ASTRulesEvaluationEngine engine; + private CustomFunctionRegistry registry; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constants = Mockito.mock(ConstantService.class); + Mockito.when(constants.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + registry = new CustomFunctionRegistry(); + engine = new ASTRulesEvaluationEngine(parser, constants, null, null, registry); + } + + @Test + @DisplayName("do-while executes body once then re-checks the condition each iteration") + void doWhileExecutesAtLeastOnce() { + String yaml = """ + inputs: + startValue: "number" + then: + - set counter to startValue + - do: add 1 to counter while counter < 5 + output: + counter: counter + """; + + // Start below cap: should loop until counter == 5 + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("startValue", 2)); + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("counter").toString())) + .isEqualByComparingTo(new BigDecimal("5")); + } + + @Test + @DisplayName("do-while runs the body at least once even when the condition is already false") + void doWhileRunsBodyAtLeastOnceWhenConditionInitiallyFalse() { + String yaml = """ + inputs: + startValue: "number" + then: + - set counter to startValue + - do: add 1 to counter while counter < 5 + output: + counter: counter + """; + + // Start at 5: condition is false from the start, but do-while always runs the body once + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("startValue", 5)); + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("counter").toString())) + .isEqualByComparingTo(new BigDecimal("6")); + } + + @Test + @DisplayName("Custom functions are callable from condition expressions, not just from actions") + void customFunctionReachableFromCondition() { + // Register a custom function that flags VIP customers + registry.register("is_vip", args -> { + String id = String.valueOf(args[0]); + return id.startsWith("VIP-"); + }); + + String yaml = """ + inputs: + customerId: "string" + when: + - is_vip(customerId) equals true + then: + - set tier to "PREMIUM" + else: + - set tier to "STANDARD" + output: + tier: tier + """; + + ASTRulesEvaluationResult vipResult = engine.evaluateRules(yaml, Map.of("customerId", "VIP-001")); + assertThat(vipResult.isSuccess()).isTrue(); + assertThat(vipResult.getOutputData()).containsEntry("tier", "PREMIUM"); + + ASTRulesEvaluationResult standardResult = engine.evaluateRules(yaml, Map.of("customerId", "STD-001")); + assertThat(standardResult.isSuccess()).isTrue(); + assertThat(standardResult.getOutputData()).containsEntry("tier", "STANDARD"); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DocExamplesValidationTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DocExamplesValidationTest.java new file mode 100644 index 0000000..2ac842b --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DocExamplesValidationTest.java @@ -0,0 +1,180 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThatCode; + +/** + * Doc-example guard: extracts every fenced YAML block from the user-facing markdown + * docs and parses each one through the real {@link ASTRulesDSLParser}. If any documented + * example stops being parseable -- because of a code change, a typo introduced during + * editing, or a deliberate breaking change that wasn't reflected in the docs -- this + * test fails at build time with a precise file:line reference, so the docs and the + * implementation cannot silently drift. + * + *

Only blocks that look like complete top-level rules are validated: + * a block must contain at least one of {@code name:}, {@code when:}, {@code rules:}, + * {@code conditions:}, or {@code then:} as a top-level key. Pure snippets (e.g., a + * lone list of {@code - set ...} action items pulled out for illustration) are + * skipped -- they aren't meant to stand on their own.

+ * + *

The set of docs scanned: {@code docs/yaml-dsl-reference.md}, + * {@code docs/quick-start-guide.md}, {@code docs/common-patterns-guide.md}, + * {@code docs/b2b-credit-scoring-tutorial.md}, {@code README.md}.

+ */ +class DocExamplesValidationTest { + + private static final Pattern YAML_FENCE = + Pattern.compile("(?m)^```ya?ml\\s*\\n(.*?)\\n```", Pattern.DOTALL); + + /** + * Skip marker: any fenced YAML block immediately preceded (allowing only whitespace + * lines between) by an HTML comment containing {@code doc-test:skip} is treated as a + * schema illustration or partial snippet and not validated. Authors may include a + * trailing rationale (e.g., {@code }). + */ + private static final String SKIP_MARKER = "doc-test:skip"; + + /** + * Heuristic: a block is "full enough to parse" if it declares one of these at the + * top of the YAML (i.e., as an unindented key on its own line). + */ + private static final Pattern TOP_LEVEL_RULE_KEY = + Pattern.compile("(?m)^(name|when|then|else|rules|conditions|inputs?|outputs?|constants|circuit_breaker|metadata|version|description):"); + + private static final List DOC_FILES = List.of( + "docs/yaml-dsl-reference.md", + "docs/quick-start-guide.md", + "docs/common-patterns-guide.md", + "docs/b2b-credit-scoring-tutorial.md", + "docs/migration-guide.md", + "README.md" + ); + + /** + * Produce one parameterised test case per parseable YAML block. Each {@link Arguments} + * carries a human-readable label (file + first line of block) and the raw YAML. + */ + static Stream docYamlBlocks() throws IOException { + Path repoRoot = locateRepoRoot(); + List blocks = new ArrayList<>(); + for (String relPath : DOC_FILES) { + Path path = repoRoot.resolve(relPath); + if (!Files.exists(path)) continue; + + String content = Files.readString(path); + String[] allLines = content.split("\n", -1); + + Matcher m = YAML_FENCE.matcher(content); + while (m.find()) { + String yaml = m.group(1); + if (!looksLikeFullRule(yaml)) continue; + if (precededBySkipMarker(content, m.start())) continue; + + int charIndex = m.start(); + int line = 1; + for (int i = 0; i < charIndex && i < content.length(); i++) { + if (content.charAt(i) == '\n') line++; + } + String firstNonEmptyLine = Arrays.stream(yaml.split("\n")) + .map(String::trim) + .filter(s -> !s.isEmpty()) + .findFirst().orElse("(empty)"); + String label = relPath + ":" + line + " -- " + truncate(firstNonEmptyLine, 60); + + blocks.add(Arguments.of(label, yaml)); + } + // Suppress unused warning -- allLines kept for potential future use. + if (allLines.length < 0) throw new IllegalStateException(); + } + return blocks.stream(); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("docYamlBlocks") + void everyDocumentedRuleParses(String label, String yaml) { + ASTRulesDSLParser parser = new ASTRulesDSLParser(new DSLParser()); + + assertThatCode(() -> parser.parseRulesReactive(yaml).block()) + .as("Doc example must parse: %s%n--- YAML ---%n%s%n--- end ---", label, yaml) + .doesNotThrowAnyException(); + } + + private static boolean looksLikeFullRule(String yaml) { + return TOP_LEVEL_RULE_KEY.matcher(yaml).find(); + } + + /** + * Look backwards from the start of the fence for the most recent non-blank line; if + * it contains the {@link #SKIP_MARKER}, treat this block as opt-out from validation. + */ + private static boolean precededBySkipMarker(String content, int fenceStart) { + int probe = fenceStart - 1; + // Walk back over any whitespace-only lines. + while (probe >= 0) { + // Find start of the line that ends at `probe`. + int lineEnd = probe; + while (probe >= 0 && content.charAt(probe) != '\n') probe--; + String line = content.substring(probe + 1, lineEnd + 1).trim(); + if (!line.isEmpty()) { + return line.contains(SKIP_MARKER); + } + probe--; // skip the newline character itself + } + return false; + } + + private static String truncate(String s, int n) { + return s.length() <= n ? s : s.substring(0, n - 1) + "…"; + } + + /** + * Walks up from the test working directory until it finds the multi-module repo root + * (identified by the presence of the top-level {@code docs/} directory next to a + * {@code pom.xml}). Surefire runs in the module directory by default. + */ + private static Path locateRepoRoot() { + Path cursor = Paths.get("").toAbsolutePath(); + for (int i = 0; i < 6 && cursor != null; i++) { + if (Files.isDirectory(cursor.resolve("docs")) + && Files.isRegularFile(cursor.resolve("pom.xml")) + && Files.isRegularFile(cursor.resolve("README.md"))) { + return cursor; + } + cursor = cursor.getParent(); + } + throw new IllegalStateException( + "Could not locate repo root from " + Paths.get("").toAbsolutePath()); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DroolsDmnParityFeaturesTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DroolsDmnParityFeaturesTest.java new file mode 100644 index 0000000..b78eb00 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DroolsDmnParityFeaturesTest.java @@ -0,0 +1,506 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + */ +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.function.RuleInvoker; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Coverage for the drools/DMN parity features added in 26.05.08: + * sub-rule priority (salience), input defaults, per-rule timeout, log/percentile/hash/math + * built-ins, rule composition via invoke_rule, and DMN-style decision tables. + */ +class DroolsDmnParityFeaturesTest { + + private ASTRulesEvaluationEngine engine; + private ASTRulesEvaluationEngine engineWithInvoker; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + engine = new ASTRulesEvaluationEngine(parser, constantService, null, null, new CustomFunctionRegistry()); + + RuleInvoker stubInvoker = (code, inputs) -> { + if ("score_rule".equals(code)) { + int amount = ((Number) inputs.get("amount")).intValue(); + return Map.of("score", amount > 1000 ? "HIGH" : "LOW"); + } + if ("composite_underwrite".equals(code)) { + int credit = ((Number) inputs.get("creditScore")).intValue(); + int income = ((Number) inputs.get("annualIncome")).intValue(); + int debt = ((Number) inputs.get("existingDebt")).intValue(); + boolean approved = credit >= 700 && income >= 50000 && debt < income / 2; + return Map.of("approved", approved, "tier", approved ? "PREFERRED" : "STANDARD"); + } + throw new IllegalArgumentException("unknown rule: " + code); + }; + engineWithInvoker = new ASTRulesEvaluationEngine(parser, constantService, null, null, + new CustomFunctionRegistry(), null, stubInvoker); + } + + // -------- New built-ins -------- + + @Test + @DisplayName("percentile() interpolates between sorted samples") + void percentile() { + String yaml = """ + name: pct + then: + - run p50 as percentile([1,2,3,4,5,6,7,8,9,10], 50) + - run p90 as percentile([1,2,3,4,5,6,7,8,9,10], 90) + output: + p50: p50 + p90: p90 + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + // p50 of 1..10 -> 5.5 ; p90 -> 9.1 + assertThat(((BigDecimal) r.getOutputData().get("p50")).doubleValue()).isEqualTo(5.5); + assertThat(((BigDecimal) r.getOutputData().get("p90")).doubleValue()).isEqualTo(9.1); + } + + @Test + @DisplayName("hash() produces a hex digest of the input") + void hash() { + String yaml = """ + name: hash + then: + - run h as hash("hello") + output: + h: h + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + // SHA-256("hello") + assertThat(r.getOutputData().get("h")).isEqualTo("2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"); + } + + @Test + @DisplayName("log() built-in returns the message and routes through SLF4J") + void logFunction() { + String yaml = """ + name: logtest + then: + - run echoed as log("rule fired", "INFO") + output: + echoed: echoed + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("echoed")).isEqualTo("rule fired"); + } + + @Test + @DisplayName("Advanced math: exp, ln, sin all available") + void advancedMath() { + String yaml = """ + name: math + then: + - run e as exp(1) + - run ln2 as ln(2) + - run zero as sin(0) + output: + e: e + ln2: ln2 + zero: zero + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + assertThat(((BigDecimal) r.getOutputData().get("e")).doubleValue()).isCloseTo(Math.E, org.assertj.core.data.Offset.offset(1e-12)); + assertThat(((BigDecimal) r.getOutputData().get("ln2")).doubleValue()).isCloseTo(Math.log(2), org.assertj.core.data.Offset.offset(1e-12)); + assertThat(((BigDecimal) r.getOutputData().get("zero")).doubleValue()).isCloseTo(0.0, org.assertj.core.data.Offset.offset(1e-12)); + } + + // -------- Sub-rule priority -------- + + @Test + @DisplayName("Sub-rules with higher priority evaluate first; ties preserve YAML order") + void subRulePriority() { + // The "low" sub-rule writes tier=LOW unconditionally; the "high" sub-rule overwrites + // tier=HIGH. With higher priority on "high", the LOW write happens after HIGH and + // takes the final slot. To make order observable, we use side-effect collisions. + String yaml = """ + name: priority test + rules: + - name: low rule + priority: 1 + then: + - set tier to "LOW" + - name: high rule + priority: 10 + then: + - set tier to "HIGH" + output: + tier: tier + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + // Higher-priority sub-rule runs FIRST; its value is then overwritten by the + // lower-priority sub-rule which runs second. Final value == LOW confirms ordering. + assertThat(r.getOutputData().get("tier")).isEqualTo("LOW"); + } + + // -------- Input defaults -------- + + @Test + @DisplayName("Input defaults fill in variables the caller omitted") + void inputDefaults() { + String yaml = """ + name: defaults + inputs: + threshold: + type: number + default: 100 + when: + - threshold at_least 50 + then: + - set verdict to "OK" + else: + - set verdict to "FAIL" + output: + verdict: verdict + threshold: threshold + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("verdict")).isEqualTo("OK"); + assertThat(r.getOutputData().get("threshold")).isEqualTo(100); + } + + @Test + @DisplayName("Caller-provided values override declared defaults") + void callerOverridesDefault() { + String yaml = """ + name: defaults + inputs: + threshold: + type: number + default: 100 + when: + - threshold at_least 50 + then: + - set verdict to "OK" + else: + - set verdict to "FAIL" + output: + verdict: verdict + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of("threshold", 10)); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("verdict")).isEqualTo("FAIL"); + } + + // -------- Per-rule timeout -------- + + @Test + @DisplayName("Per-rule timeout config is accepted and applied via Reactor") + void perRuleTimeoutAccepted() { + // 60 seconds: not going to trigger, but verifies the timeout config parses cleanly + // and the wrapped pipeline still produces a successful result. + String yaml = """ + name: timeout + timeout: 60s + then: + - set ok to true + output: + ok: ok + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("ok")).isEqualTo(true); + } + + // -------- invoke_rule -------- + + @Test + @DisplayName("invoke_rule delegates to a stored rule and returns its outputs") + void invokeRule() { + // Inputs are passed as alternating "key", value pairs trailing the rule code -- + // this avoids the YAML/JSON `{}` flow-mapping ambiguity inside action lines. + String yaml = """ + name: composer + then: + - run result as invoke_rule("score_rule", "amount", 1500) + output: + result: result + """; + ASTRulesEvaluationResult r = engineWithInvoker.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).as("error was: %s", r.getError()).isTrue(); + @SuppressWarnings("unchecked") + Map nested = (Map) r.getOutputData().get("result"); + assertThat(nested).containsEntry("score", "HIGH"); + } + + @Test + @DisplayName("invoke_rule with multiple input variables routes each pair correctly") + void invokeRuleMultipleInputs() { + String yaml = """ + name: composer + inputs: + creditScore: number + annualIncome: number + existingDebt: number + then: + - run underwriting as invoke_rule("composite_underwrite", + "creditScore", creditScore, + "annualIncome", annualIncome, + "existingDebt", existingDebt) + output: + underwriting: underwriting + """; + ASTRulesEvaluationResult r = engineWithInvoker.evaluateRules(yaml, + Map.of("creditScore", 750, "annualIncome", 80000, "existingDebt", 20000)); + assertThat(r.isSuccess()).as("error was: %s", r.getError()).isTrue(); + @SuppressWarnings("unchecked") + Map nested = (Map) r.getOutputData().get("underwriting"); + assertThat(nested).containsEntry("approved", true).containsEntry("tier", "PREFERRED"); + } + + @Test + @DisplayName("invoke_rule odd-count trailing args fails loud") + void invokeRuleOddArgs() { + String yaml = """ + name: composer + then: + - run r as invoke_rule("score_rule", "amount") + output: + r: r + """; + ASTRulesEvaluationResult r = engineWithInvoker.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isFalse(); + assertThat(r.getError()).contains("alternating key/value"); + } + + @Test + @DisplayName("Decision tables support multiple input columns referenced in conditions") + void decisionTableMultipleInputs() { + String yaml = """ + name: multi-input pricing + inputs: + creditScore: number + annualIncome: number + age: number + decision_table: + inputs: [creditScore, annualIncome, age] + outputs: [tier, multiplier] + hit_policy: FIRST + rules: + - when: + - creditScore at_least 750 + - annualIncome at_least 100000 + - age between 25 and 65 + then: + tier: "PRIME" + multiplier: 1.0 + - when: + - creditScore at_least 700 + - annualIncome at_least 60000 + then: + tier: "PREFERRED" + multiplier: 1.2 + - otherwise: true + then: + tier: "STANDARD" + multiplier: 1.5 + output: + tier: tier + multiplier: multiplier + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, + Map.of("creditScore", 760, "annualIncome", 120000, "age", 40)); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("tier")).isEqualTo("PRIME"); + assertThat(((Number) r.getOutputData().get("multiplier")).doubleValue()).isEqualTo(1.0); + } + + @Test + @DisplayName("invoke_rule without a configured invoker fails loud") + void invokeRuleNoInvoker() { + String yaml = """ + name: composer + then: + - run result as invoke_rule("score_rule", "amount", 1500) + output: + result: result + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isFalse(); + assertThat(r.getError()).contains("invoke_rule"); + } + + // -------- Decision tables -------- + + @Test + @DisplayName("Decision table with hit_policy=FIRST picks the first matching row") + void decisionTableFirst() { + String yaml = """ + name: pricing table + decision_table: + inputs: [creditScore] + outputs: [tier, rate] + hit_policy: FIRST + rules: + - when: + - creditScore at_least 750 + then: + tier: "PRIME" + rate: 3.0 + - when: + - creditScore at_least 650 + then: + tier: "PREFERRED" + rate: 5.0 + - otherwise: true + then: + tier: "STANDARD" + rate: 9.0 + output: + tier: tier + rate: rate + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of("creditScore", 700)); + assertThat(r.isSuccess()).as("error was: %s", r.getError()).isTrue(); + assertThat(r.getOutputData().get("tier")).isEqualTo("PREFERRED"); + } + + @Test + @DisplayName("Decision table OTHERWISE row triggers when no row matches") + void decisionTableOtherwise() { + String yaml = """ + name: pricing fallback + decision_table: + inputs: [creditScore] + outputs: [tier] + hit_policy: FIRST + rules: + - when: + - creditScore at_least 750 + then: + tier: "PRIME" + - otherwise: true + then: + tier: "STANDARD" + output: + tier: tier + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of("creditScore", 500)); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("tier")).isEqualTo("STANDARD"); + } + + @Test + @DisplayName("Decision table hit_policy=COLLECT groups matching outputs into lists") + void decisionTableCollect() { + String yaml = """ + name: tags table + decision_table: + inputs: [age, creditScore] + outputs: [tag] + hit_policy: COLLECT + rules: + - when: + - age at_least 18 + then: + tag: "adult" + - when: + - creditScore at_least 700 + then: + tag: "good_credit" + - when: + - age at_least 65 + then: + tag: "senior" + output: + tag: tag + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of("age", 70, "creditScore", 750)); + assertThat(r.isSuccess()).isTrue(); + @SuppressWarnings("unchecked") + List tags = (List) r.getOutputData().get("tag"); + assertThat(tags).containsExactly("adult", "good_credit", "senior"); + } + + @Test + @DisplayName("Decision table hit_policy=UNIQUE fails loudly if more than one row matches") + void decisionTableUniqueAmbiguous() { + String yaml = """ + name: unique check + decision_table: + inputs: [n] + outputs: [tier] + hit_policy: UNIQUE + rules: + - when: + - n at_least 10 + then: + tier: "A" + - when: + - n at_least 5 + then: + tier: "B" + output: + tier: tier + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of("n", 50)); + assertThat(r.isSuccess()).isFalse(); + assertThat(r.getError()).contains("UNIQUE"); + } + + // -------- YAML lint -------- + + @Test + @DisplayName("Pre-parse YAML lint flags unquoted ': ' inside action lines with the line number") + void yamlLintTrapsUnquotedColon() { + String yaml = """ + name: bad yaml + then: + - set msg to Status: 200 + output: + msg: msg + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isFalse(); + assertThat(r.getError()).contains("YAML lint"); + } + + @Test + @DisplayName("Properly quoted action with embedded colon parses cleanly") + void yamlLintAcceptsQuotedColon() { + String yaml = """ + name: good yaml + then: + - 'set msg to "Status: 200"' + output: + msg: msg + """; + ASTRulesEvaluationResult r = engine.evaluateRules(yaml, Map.of()); + assertThat(r.isSuccess()).isTrue(); + assertThat(r.getOutputData().get("msg")).isEqualTo("Status: 200"); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DslPrimitivesTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DslPrimitivesTest.java new file mode 100644 index 0000000..c786a25 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/DslPrimitivesTest.java @@ -0,0 +1,223 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Tests for new DSL function primitives added to round out the built-in catalog: + * {@code coalesce}, {@code if_else}, {@code is_in_range}, plus the documented-but- + * previously-missing {@code calculate_age}, {@code format_date}, {@code validate_email}, + * {@code validate_phone}. + */ +class DslPrimitivesTest { + + private ASTRulesEvaluationEngine engine; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + engine = new ASTRulesEvaluationEngine(parser, constantService); + } + + @Test + @DisplayName("coalesce returns the first non-null argument") + void coalesceReturnsFirstNonNull() { + String yaml = """ + then: + - run preferred as coalesce(nickname, full_name, "Anonymous") + output: + preferred: preferred + """; + Map input = new HashMap<>(); + input.put("nickname", null); + input.put("full_name", "Jane Doe"); + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, input); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("preferred", "Jane Doe"); + } + + @Test + @DisplayName("coalesce falls all the way through to a literal default") + void coalesceFallsThroughToDefault() { + String yaml = """ + then: + - run preferred as coalesce(nickname, full_name, "Anonymous") + output: + preferred: preferred + """; + Map input = new HashMap<>(); + input.put("nickname", null); + input.put("full_name", null); + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, input); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("preferred", "Anonymous"); + } + + @Test + @DisplayName("if_else picks the then-branch when the condition is truthy") + void ifElseTruthyPicksThen() { + String yaml = """ + then: + - run category as if_else(age >= 18, "adult", "minor") + output: + category: category + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("age", 21)); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("category", "adult"); + } + + @Test + @DisplayName("if_else picks the else-branch when the condition is falsey") + void ifElseFalseyPicksElse() { + String yaml = """ + then: + - run category as if_else(age >= 18, "adult", "minor") + output: + category: category + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("age", 12)); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("category", "minor"); + } + + @Test + @DisplayName("is_in_range returns true within bounds, false outside (inclusive on both ends)") + void isInRangeBoundary() { + String yaml = """ + then: + - run lowOk as is_in_range(50, 50, 100) + - run highOk as is_in_range(100, 50, 100) + - run below as is_in_range(49, 50, 100) + - run above as is_in_range(101, 50, 100) + output: + lowOk: lowOk + highOk: highOk + below: below + above: above + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("lowOk", true); + assertThat(result.getOutputData()).containsEntry("highOk", true); + assertThat(result.getOutputData()).containsEntry("below", false); + assertThat(result.getOutputData()).containsEntry("above", false); + } + + @Test + @DisplayName("calculate_age returns whole years between birth date and reference date") + void calculateAgeWithExplicitReferenceDate() { + String yaml = """ + then: + - run age as calculate_age("1990-06-15", "2024-06-14") + - run ageAtBirthday as calculate_age("1990-06-15", "2024-06-15") + output: + age: age + ageAtBirthday: ageAtBirthday + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("age", new BigDecimal("33")); + assertThat(result.getOutputData()).containsEntry("ageAtBirthday", new BigDecimal("34")); + } + + @Test + @DisplayName("format_date applies a DateTimeFormatter pattern") + void formatDateWithPattern() { + String yaml = """ + then: + - run iso as format_date("2024-06-15") + - run pretty as format_date("2024-06-15", "dd MMM yyyy") + output: + iso: iso + pretty: pretty + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("iso", "2024-06-15"); + // Locale-dependent month abbreviation; just check the structure + assertThat((String) result.getOutputData().get("pretty")).matches("15 \\w{3} 2024"); + } + + @Test + @DisplayName("validate_email function form matches the is_email operator") + void validateEmailFunctionForm() { + String yaml = """ + then: + - run good as validate_email("alice@example.com") + - run bad as validate_email("not-an-email") + output: + good: good + bad: bad + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("good", true); + assertThat(result.getOutputData()).containsEntry("bad", false); + } + + @Test + @DisplayName("is_valid with unknown validation type surfaces a clear error") + void isValidUnknownTypeThrows() { + String yaml = """ + then: + - run check as is_valid(value, "no_such_type") + output: + check: check + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("value", "x")); + + assertThat(result.isSuccess()).isFalse(); + assertThat(result.getError()).contains("no_such_type"); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/E2EDomainScenariosTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/E2EDomainScenariosTest.java new file mode 100644 index 0000000..f57d4a0 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/E2EDomainScenariosTest.java @@ -0,0 +1,333 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * End-to-end domain scenario tests covering rule shapes that the loan-eligibility + * {@code EndToEndScenarioTest} doesn't exercise. The point of having these alongside + * the loan test is breadth -- each domain stresses a different combination of DSL + * features and operator types, so a regression that breaks one shape but not another + * still surfaces at build time. + */ +class E2EDomainScenariosTest { + + private ASTRulesEvaluationEngine engine; + private CustomFunctionRegistry registry; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + registry = new CustomFunctionRegistry(); + engine = new ASTRulesEvaluationEngine(parser, constantService, null, null, registry); + } + + // --------------------------------------------------------------------------------- + // Insurance pricing: exercises tiered conditionals, multiplicative arithmetic, + // mixed input-types (numeric + categorical), and the symmetric arithmetic grammar. + // --------------------------------------------------------------------------------- + + private static final String INSURANCE_PRICING_RULE = """ + name: "Auto Insurance Premium" + description: "Computes annual premium from driver and vehicle attributes" + + inputs: + driverAge: "number" + yearsLicensed: "number" + vehicleValue: "number" + accidentsInLastFiveYears: "number" + region: "string" + + then: + # Base premium: 4% of vehicle value + - calculate base_premium as vehicleValue * 0.04 + + # Age band multiplier + - run age_multiplier as if_else(driverAge less_than 25, 1.6, if_else(driverAge at_least 65, 1.3, 1.0)) + + # Experience discount: cap at 20% off for >= 10 years licensed + - run experience_discount as if_else(yearsLicensed at_least 10, 0.2, yearsLicensed * 0.02) + + # Accident surcharge: 15% per incident, max 90% + - run accident_surcharge as if_else(accidentsInLastFiveYears at_least 6, 0.9, accidentsInLastFiveYears * 0.15) + + # Region adjustment: high-risk urban areas pay more + - set region_factor to 1.0 + - if region in_list ["NYC", "LA", "Chicago"] then set region_factor to 1.25 + + # Final premium: base × age × region × (1 - discount + surcharge) + - calculate final_premium as base_premium * age_multiplier * region_factor * (1 - experience_discount + accident_surcharge) + + # Banding for the rate card + - run rate_tier as if_else(final_premium at_least 3000, "HIGH", + if_else(final_premium at_least 1500, "STANDARD", "PREFERRED")) + + output: + base_premium: number + final_premium: number + rate_tier: text + age_multiplier: number + region_factor: number + """; + + @Test + @DisplayName("Insurance pricing: young driver in NYC with one accident pays high tier") + void insurancePricingYoungDriverWithAccident() { + Map input = new HashMap<>(); + input.put("driverAge", 22); + input.put("yearsLicensed", 4); + input.put("vehicleValue", new BigDecimal("45000")); + input.put("accidentsInLastFiveYears", 1); + input.put("region", "NYC"); + + ASTRulesEvaluationResult result = engine.evaluateRules(INSURANCE_PRICING_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + // base_premium = 45000 * 0.04 = 1800 + // age_multiplier 1.6 (young) × region 1.25 (NYC) × (1 - 0.08 discount + 0.15 surcharge) = 1.07 + // final_premium = 1800 * 1.6 * 1.25 * 1.07 = 3852 → HIGH tier (≥ 3000) + assertThat(new BigDecimal(out.get("base_premium").toString())) + .isEqualByComparingTo(new BigDecimal("1800.00")); + assertThat(new BigDecimal(out.get("age_multiplier").toString())).isEqualByComparingTo("1.6"); + assertThat(new BigDecimal(out.get("region_factor").toString())).isEqualByComparingTo("1.25"); + assertThat((String) out.get("rate_tier")).isEqualTo("HIGH"); + } + + @Test + @DisplayName("Insurance pricing: experienced suburban driver with clean record lands in preferred tier") + void insurancePricingExperiencedCleanRecord() { + Map input = new HashMap<>(); + input.put("driverAge", 42); + input.put("yearsLicensed", 20); + input.put("vehicleValue", new BigDecimal("18000")); + input.put("accidentsInLastFiveYears", 0); + input.put("region", "Suburb"); + + ASTRulesEvaluationResult result = engine.evaluateRules(INSURANCE_PRICING_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + // age 42: multiplier 1.0; suburb: region 1.0; 20 years licensed: 20% discount; 0 accidents: 0 surcharge + // base = 18000 * 0.04 = 720; final = 720 * 1.0 * 1.0 * (1 - 0.2 + 0) = 576 + assertThat(new BigDecimal(out.get("final_premium").toString())) + .isEqualByComparingTo("576.00000"); + assertThat((String) out.get("rate_tier")).isEqualTo("PREFERRED"); + } + + // --------------------------------------------------------------------------------- + // Fraud-risk scoring with a custom function (exercises the CustomFunctionRegistry + // path end-to-end alongside the built-in operators). + // --------------------------------------------------------------------------------- + + private static final String FRAUD_RISK_RULE = """ + name: "Card Transaction Fraud Risk" + description: "Scores a card-not-present transaction for fraud risk" + + inputs: + amount: "number" + hoursSinceLastTx: "number" + merchantCategory: "string" + countryDistanceKm: "number" + isVerifiedDevice: "boolean" + + when: + - amount at_least 0 + + then: + - set risk_score to 0 + + # Amount band + - if amount at_least 5000 then add 35 to risk_score + - if amount at_least 1000 and amount less_than 5000 then add 15 to risk_score + - if amount less_than 1000 then add 5 to risk_score + + # Velocity (transactions clustered in time look suspicious) + - if hoursSinceLastTx less_than 1 then add 20 to risk_score + + # Geographic anomaly via a custom merchant_country_risk function + - run country_risk as merchant_country_risk(countryDistanceKm) + - add country_risk to risk_score + + # High-risk merchant categories + - if merchantCategory in_list ["gambling", "crypto-exchange", "wire-transfer"] then add 25 to risk_score + + # Device verification: significant discount + - if isVerifiedDevice equals true then subtract 20 from risk_score + - if risk_score less_than 0 then set risk_score to 0 + + # Decision banding + - run decision as if_else(risk_score at_least 70, "BLOCK", + if_else(risk_score at_least 40, "STEP_UP_AUTH", "ALLOW")) + + output: + risk_score: number + country_risk: number + decision: text + """; + + @Test + @DisplayName("Fraud: large cross-border crypto purchase from unverified device → BLOCK") + void fraudHighRiskBlocks() { + // Custom risk function: ramps from 0 at 0km to 30 at 5000km + registry.register("merchant_country_risk", args -> { + double km = ((Number) args[0]).doubleValue(); + return BigDecimal.valueOf(Math.min(30, km / 5000.0 * 30)); + }); + + Map input = new HashMap<>(); + input.put("amount", new BigDecimal("7500")); + input.put("hoursSinceLastTx", new BigDecimal("0.5")); + input.put("merchantCategory", "crypto-exchange"); + input.put("countryDistanceKm", new BigDecimal("4500")); + input.put("isVerifiedDevice", false); + + ASTRulesEvaluationResult result = engine.evaluateRules(FRAUD_RISK_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + // 35 (amount) + 20 (velocity) + ~27 (country risk 4500/5000*30) + 25 (category) = ~107 + assertThat(new BigDecimal(result.getOutputData().get("risk_score").toString())) + .isGreaterThan(BigDecimal.valueOf(70)); + assertThat((String) result.getOutputData().get("decision")).isEqualTo("BLOCK"); + } + + @Test + @DisplayName("Fraud: small local purchase from verified device → ALLOW") + void fraudLowRiskAllows() { + registry.register("merchant_country_risk", args -> { + double km = ((Number) args[0]).doubleValue(); + return BigDecimal.valueOf(Math.min(30, km / 5000.0 * 30)); + }); + + Map input = new HashMap<>(); + input.put("amount", new BigDecimal("45")); + input.put("hoursSinceLastTx", new BigDecimal("8")); + input.put("merchantCategory", "grocery"); + input.put("countryDistanceKm", new BigDecimal("3")); + input.put("isVerifiedDevice", true); + + ASTRulesEvaluationResult result = engine.evaluateRules(FRAUD_RISK_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + // 5 (amount) + 0 (velocity) + ~0 (country) + 0 (category) - 20 (verified) = clamped to 0 + assertThat(new BigDecimal(result.getOutputData().get("risk_score").toString())) + .isEqualByComparingTo(BigDecimal.ZERO); + assertThat((String) result.getOutputData().get("decision")).isEqualTo("ALLOW"); + } + + // --------------------------------------------------------------------------------- + // Compliance gate: exercises `else` actions, validation operators in conditions, + // and list-aggregation of reasons. + // --------------------------------------------------------------------------------- + + private static final String COMPLIANCE_GATE_RULE = """ + name: "KYC / Compliance Gate" + description: "Pre-onboarding compliance check" + + inputs: + applicantEmail: "string" + applicantPhone: "string" + applicantAge: "number" + countryOfResidence: "string" + hasGovernmentId: "boolean" + + when: + - applicantEmail is_email + - applicantPhone is_phone + - applicantAge at_least 18 + - hasGovernmentId equals true + - countryOfResidence not_in_list ["KP", "IR", "SY", "CU"] + + then: + - set kyc_status to "PASS" + - set rejection_reasons to [] + + else: + - set kyc_status to "FAIL" + - set rejection_reasons to [] + - if not applicantEmail is_email then append "INVALID_EMAIL" to rejection_reasons + - if not applicantPhone is_phone then append "INVALID_PHONE" to rejection_reasons + - if applicantAge less_than 18 then append "UNDERAGE" to rejection_reasons + - if not hasGovernmentId equals true then append "MISSING_GOVERNMENT_ID" to rejection_reasons + - if countryOfResidence in_list ["KP", "IR", "SY", "CU"] then append "SANCTIONED_COUNTRY" to rejection_reasons + + output: + kyc_status: text + rejection_reasons: list + """; + + @Test + @DisplayName("Compliance gate: well-formed applicant passes KYC") + void compliancePass() { + Map input = new HashMap<>(); + input.put("applicantEmail", "alice@example.com"); + input.put("applicantPhone", "+1-555-123-4567"); + input.put("applicantAge", 30); + input.put("countryOfResidence", "GB"); + input.put("hasGovernmentId", true); + + ASTRulesEvaluationResult result = engine.evaluateRules(COMPLIANCE_GATE_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("kyc_status", "PASS"); + @SuppressWarnings("unchecked") + List reasons = (List) result.getOutputData().get("rejection_reasons"); + assertThat(reasons).isEmpty(); + } + + @Test + @DisplayName("Compliance gate: multiple violations are all collected in rejection_reasons") + void complianceMultipleFailures() { + Map input = new HashMap<>(); + input.put("applicantEmail", "not-an-email"); + input.put("applicantPhone", "garbage"); + input.put("applicantAge", 15); // underage + input.put("countryOfResidence", "KP"); // sanctioned + input.put("hasGovernmentId", false); + + ASTRulesEvaluationResult result = engine.evaluateRules(COMPLIANCE_GATE_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("kyc_status", "FAIL"); + + @SuppressWarnings("unchecked") + List reasons = (List) result.getOutputData().get("rejection_reasons"); + assertThat(reasons).containsExactlyInAnyOrder( + "INVALID_EMAIL", "INVALID_PHONE", "UNDERAGE", "MISSING_GOVERNMENT_ID", "SANCTIONED_COUNTRY"); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/EndToEndScenarioTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/EndToEndScenarioTest.java new file mode 100644 index 0000000..a75ea86 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/EndToEndScenarioTest.java @@ -0,0 +1,249 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.fireflyframework.rules.interfaces.dtos.crud.ConstantDTO; +import org.fireflyframework.rules.interfaces.enums.ValueType; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyList; + +/** + * End-to-end DSL integration test that exercises the full evaluation pipeline against a + * realistic, multi-step rule. Single failures here usually indicate a regression in one + * of: parser, AST cache, constant resolution, condition evaluation, action execution, + * arithmetic coercion, loops, sub-rules, circuit breaker, custom-function registry, or + * error propagation. + * + *

The scenario models a simplified loan-eligibility pipeline. It is wide rather than + * deep on purpose -- a "smoke test" that catches integration regressions a single-purpose + * unit test would miss.

+ */ +class EndToEndScenarioTest { + + private ASTRulesEvaluationEngine engine; + private CustomFunctionRegistry registry; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + + ConstantService constants = Mockito.mock(ConstantService.class); + Mockito.when(constants.getConstantsByCodes(anyList())).thenReturn(Flux.just( + ConstantDTO.builder().code("MIN_CREDIT_SCORE").valueType(ValueType.NUMBER) + .currentValue(new BigDecimal("650")).build(), + ConstantDTO.builder().code("MIN_ANNUAL_INCOME").valueType(ValueType.NUMBER) + .currentValue(new BigDecimal("50000")).build(), + ConstantDTO.builder().code("MAX_DTI").valueType(ValueType.NUMBER) + .currentValue(new BigDecimal("0.4")).build() + )); + + registry = new CustomFunctionRegistry(); + registry.register("regional_risk_score", + args -> ("CA".equals(args[0]) || "NY".equals(args[0])) ? 10 : 0); + + engine = new ASTRulesEvaluationEngine(parser, constants, null, null, registry); + } + + /** Multi-stage loan-eligibility rule covering most DSL surface area. */ + private static final String LOAN_RULE = """ + name: "Loan Eligibility End-to-End" + description: "Exercises constants, sub-rules, loops, conditionals, and custom functions" + + inputs: + creditScore: "number" + annualIncome: "number" + existingDebtPayments: "list" + region: "string" + applicant_email: "string" + + rules: + - name: "Financial Validation" + when: + - creditScore at_least MIN_CREDIT_SCORE + - annualIncome at_least MIN_ANNUAL_INCOME + then: + - set financial_check to "PASSED" + - calculate monthly_income as annualIncome / 12 + else: + - set financial_check to "FAILED" + + - name: "Debt Aggregation" + then: + - set total_debt to 0 + - forEach payment in existingDebtPayments: add payment to total_debt + + - name: "DTI Computation" + then: + - calculate debt_to_income as total_debt / annualIncome + + - name: "Final Decision" + when: + - financial_check equals "PASSED" + - debt_to_income at_most MAX_DTI + then: + - run risk_adjustment as regional_risk_score(region) + - run validated_email as validate_email(applicant_email) + - run tier as if_else(creditScore at_least 750, "PRIME", "STANDARD") + - run display_name as coalesce(applicant_email, "anonymous") + - set decision to "APPROVED" + else: + - set decision to "DECLINED" + + output: + decision: decision + tier: tier + monthly_income: monthly_income + total_debt: total_debt + debt_to_income: debt_to_income + risk_adjustment: risk_adjustment + validated_email: validated_email + display_name: display_name + """; + + @Test + @DisplayName("Approves an applicant who satisfies every rule and computes all derived values") + void approvedApplicantEndToEnd() { + Map input = new HashMap<>(); + input.put("creditScore", 760); + input.put("annualIncome", new BigDecimal("120000")); + input.put("existingDebtPayments", List.of(new BigDecimal("400"), new BigDecimal("250"), new BigDecimal("150"))); + input.put("region", "CA"); + input.put("applicant_email", "alice@example.com"); + + ASTRulesEvaluationResult result = engine.evaluateRules(LOAN_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + assertThat(out).containsEntry("decision", "APPROVED"); + assertThat(out).containsEntry("tier", "PRIME"); + assertThat(out).containsEntry("validated_email", true); + assertThat(out).containsEntry("display_name", "alice@example.com"); + assertThat(out).containsEntry("risk_adjustment", 10); + // monthly_income = 120000 / 12 = 10000 (BigDecimal with 10-scale division) + assertThat(new BigDecimal(out.get("monthly_income").toString())) + .isEqualByComparingTo(new BigDecimal("10000")); + // total_debt = 400 + 250 + 150 = 800 + assertThat(new BigDecimal(out.get("total_debt").toString())) + .isEqualByComparingTo(new BigDecimal("800")); + // debt_to_income = 800 / 120000 ≈ 0.0067 (well under MAX_DTI 0.4) + BigDecimal dti = new BigDecimal(out.get("debt_to_income").toString()); + assertThat(dti).isLessThan(new BigDecimal("0.4")); + } + + @Test + @DisplayName("Declines an applicant who fails the financial-validation gate") + void declinedOnLowCreditScore() { + Map input = new HashMap<>(); + input.put("creditScore", 600); // < MIN_CREDIT_SCORE + input.put("annualIncome", new BigDecimal("120000")); + input.put("existingDebtPayments", List.of(new BigDecimal("400"))); + input.put("region", "TX"); + input.put("applicant_email", "bob@example.com"); + + ASTRulesEvaluationResult result = engine.evaluateRules(LOAN_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + assertThat(out).containsEntry("decision", "DECLINED"); + assertThat(out).containsEntry("financial_check", "FAILED"); + } + + @Test + @DisplayName("Picks STANDARD tier when credit score is below the PRIME cutoff") + void standardTierBelowPrimeCutoff() { + Map input = new HashMap<>(); + input.put("creditScore", 700); // qualifies but < 750 + input.put("annualIncome", new BigDecimal("80000")); + input.put("existingDebtPayments", List.of(new BigDecimal("500"))); + input.put("region", "TX"); + input.put("applicant_email", "carol@example.com"); + + ASTRulesEvaluationResult result = engine.evaluateRules(LOAN_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + assertThat(out).containsEntry("decision", "APPROVED"); + assertThat(out).containsEntry("tier", "STANDARD"); + assertThat(out).containsEntry("risk_adjustment", 0); // non-CA/NY region + } + + @Test + @DisplayName("Handles an empty debt list without arithmetic errors") + void zeroDebtScenarioComputesZeroDti() { + Map input = new HashMap<>(); + input.put("creditScore", 800); + input.put("annualIncome", new BigDecimal("100000")); + input.put("existingDebtPayments", List.of()); // no debt + input.put("region", "NY"); + input.put("applicant_email", "dave@example.com"); + + ASTRulesEvaluationResult result = engine.evaluateRules(LOAN_RULE, input); + + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + assertThat(out).containsEntry("decision", "APPROVED"); + assertThat(new BigDecimal(out.get("total_debt").toString())) + .isEqualByComparingTo(BigDecimal.ZERO); + assertThat(new BigDecimal(out.get("debt_to_income").toString())) + .isEqualByComparingTo(BigDecimal.ZERO); + } + + @Test + @DisplayName("Circuit-breaker action stops evaluation cleanly with structured metadata") + void circuitBreakerStopsEvaluation() { + String yaml = """ + inputs: + riskScore: "number" + when: + - riskScore at_least 0 + then: + - set started to true + - if riskScore at_least 90 then circuit_breaker "HIGH_RISK" + - set finished to true + output: + started: started + finished: finished + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("riskScore", 95)); + + assertThat(result.isSuccess()).isTrue(); // circuit breaker is a controlled stop + assertThat(result.isCircuitBreakerTriggered()).isTrue(); + assertThat(result.getCircuitBreakerMessage()).contains("HIGH_RISK"); + // started was set before the break; finished should NOT be set + assertThat(result.getOutputData()).containsEntry("started", true); + assertThat(result.getOutputData()).doesNotContainKey("finished"); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/NewBuiltinFunctionsTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/NewBuiltinFunctionsTest.java new file mode 100644 index 0000000..0c9b067 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/NewBuiltinFunctionsTest.java @@ -0,0 +1,374 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.function.CustomFunctionRegistry; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Coverage for the function primitives added in 26.05.08 to round out the built-in + * catalog: list operations (filter/map/reduce/find/sort/reverse/distinct), + * statistical aggregates (median/stddev/variance), date field extractors + * (year_of/month_of/day_of_month/day_of_week/current_iso), and string formatting + * (format with {0}-style placeholders, concat). + */ +class NewBuiltinFunctionsTest { + + private ASTRulesEvaluationEngine engine; + private CustomFunctionRegistry registry; + + @BeforeEach + void setUp() { + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + registry = new CustomFunctionRegistry(); + engine = new ASTRulesEvaluationEngine(parser, constantService, null, null, registry); + } + + // --------------------------------------------------------------------------------- + // Functional list operations + // --------------------------------------------------------------------------------- + + @Test + @DisplayName("filter(list, function_name) keeps only items where the named predicate is truthy") + void filterKeepsTruthy() { + registry.register("greater_than_50", args -> ((Number) args[0]).intValue() > 50); + + String yaml = """ + inputs: + numbers: "list" + then: + - run filtered as filter(numbers, "greater_than_50") + output: + filtered: list + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, + Map.of("numbers", List.of(10, 60, 30, 80, 20, 100))); + + assertThat(result.isSuccess()).isTrue(); + @SuppressWarnings("unchecked") + List filtered = (List) result.getOutputData().get("filtered"); + assertThat(filtered).containsExactly(60, 80, 100); + } + + @Test + @DisplayName("map(list, function_name) transforms every item via the named function") + void mapTransformsAllItems() { + registry.register("double_it", args -> ((Number) args[0]).intValue() * 2); + + String yaml = """ + inputs: + values: "list" + then: + - run doubled as map(values, "double_it") + output: + doubled: list + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("values", List.of(1, 2, 3, 4))); + + assertThat(result.isSuccess()).isTrue(); + @SuppressWarnings("unchecked") + List doubled = (List) result.getOutputData().get("doubled"); + assertThat(doubled).containsExactly(2, 4, 6, 8); + } + + @Test + @DisplayName("reduce(list, initial, function_name) accumulates left-to-right") + void reduceAccumulates() { + registry.register("add_two", args -> ((Number) args[0]).intValue() + ((Number) args[1]).intValue()); + + String yaml = """ + inputs: + values: "list" + then: + - run total as reduce(values, 0, "add_two") + output: + total: number + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("values", List.of(1, 2, 3, 4, 5))); + + assertThat(result.isSuccess()).isTrue(); + assertThat(((Number) result.getOutputData().get("total")).intValue()).isEqualTo(15); + } + + @Test + @DisplayName("find(list, function_name) returns the first matching item, or null if none") + void findReturnsFirstMatch() { + registry.register("is_positive_pred", args -> ((Number) args[0]).intValue() > 0); + + String yaml = """ + inputs: + values: "list" + then: + - run firstPositive as find(values, "is_positive_pred") + output: + firstPositive: number + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("values", List.of(-3, -1, 5, 2))); + assertThat(result.isSuccess()).isTrue(); + assertThat(((Number) result.getOutputData().get("firstPositive")).intValue()).isEqualTo(5); + } + + @Test + @DisplayName("sort, reverse, distinct work on simple lists") + void sortReverseDistinct() { + String yaml = """ + inputs: + nums: "list" + then: + - run sorted as sort(nums) + - run reversed as reverse(nums) + - run unique as distinct(nums) + output: + sorted: list + reversed: list + unique: list + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("nums", List.of(3, 1, 4, 1, 5, 9, 2, 6))); + + assertThat(result.isSuccess()).isTrue(); + @SuppressWarnings("unchecked") List sorted = (List) result.getOutputData().get("sorted"); + @SuppressWarnings("unchecked") List reversed = (List) result.getOutputData().get("reversed"); + @SuppressWarnings("unchecked") List unique = (List) result.getOutputData().get("unique"); + + assertThat(sorted).containsExactly(1, 1, 2, 3, 4, 5, 6, 9); + assertThat(reversed).containsExactly(6, 2, 9, 5, 1, 4, 1, 3); + assertThat(unique).containsExactly(3, 1, 4, 5, 9, 2, 6); + } + + // --------------------------------------------------------------------------------- + // Statistical aggregates + // --------------------------------------------------------------------------------- + + @Test + @DisplayName("median of an odd-length list returns the middle element") + void medianOddLength() { + String yaml = """ + inputs: + data: "list" + then: + - run m as median(data) + output: + m: number + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("data", List.of(1, 3, 2, 5, 4))); + assertThat(result.isSuccess()).isTrue(); + assertThat(new BigDecimal(result.getOutputData().get("m").toString())).isEqualByComparingTo("3"); + } + + @Test + @DisplayName("median of an even-length list returns the mean of the two middle elements") + void medianEvenLength() { + String yaml = """ + inputs: + data: "list" + then: + - run m as median(data) + output: + m: number + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("data", List.of(1, 2, 3, 4))); + assertThat(result.isSuccess()).isTrue(); + // Mean of 2 and 3 = 2.5 + assertThat(new BigDecimal(result.getOutputData().get("m").toString())).isEqualByComparingTo("2.5"); + } + + @Test + @DisplayName("stddev and variance for a known sequence match the expected sample-statistic values") + void stddevAndVariance() { + String yaml = """ + inputs: + data: "list" + then: + - run v as variance(data) + - run s as stddev(data) + output: + v: number + s: number + """; + // Sample variance of [2, 4, 4, 4, 5, 5, 7, 9] = 32/7 ≈ 4.571 (n-1 denominator). + // Sample stddev = sqrt(32/7) ≈ 2.138. + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, + Map.of("data", List.of(2, 4, 4, 4, 5, 5, 7, 9))); + assertThat(result.isSuccess()).isTrue(); + BigDecimal variance = new BigDecimal(result.getOutputData().get("v").toString()); + BigDecimal stddev = new BigDecimal(result.getOutputData().get("s").toString()); + assertThat(variance.doubleValue()).isCloseTo(32.0 / 7.0, org.assertj.core.data.Offset.offset(0.0001)); + assertThat(stddev.doubleValue()).isCloseTo(Math.sqrt(32.0 / 7.0), org.assertj.core.data.Offset.offset(0.0001)); + } + + // --------------------------------------------------------------------------------- + // Date field extractors + // --------------------------------------------------------------------------------- + + @Test + @DisplayName("year_of / month_of / day_of_month / day_of_week extract the right ISO field") + void dateFieldExtractors() { + // 2026-05-24 -- Sunday (ISO day-of-week 7) + String yaml = """ + inputs: + d: "string" + then: + - run y as year_of(d) + - run mo as month_of(d) + - run dom as day_of_month(d) + - run dow as day_of_week(d) + output: + y: number + mo: number + dom: number + dow: number + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("d", "2026-05-24")); + assertThat(result.isSuccess()).isTrue(); + Map out = result.getOutputData(); + assertThat(new BigDecimal(out.get("y").toString())).isEqualByComparingTo("2026"); + assertThat(new BigDecimal(out.get("mo").toString())).isEqualByComparingTo("5"); + assertThat(new BigDecimal(out.get("dom").toString())).isEqualByComparingTo("24"); + assertThat(new BigDecimal(out.get("dow").toString())).isEqualByComparingTo("7"); + } + + @Test + @DisplayName("year_of on an unparseable date surfaces a clean error message") + void dateExtractorOnBadInputFails() { + String yaml = """ + inputs: + d: "string" + then: + - run y as year_of(d) + output: + y: number + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("d", "not-a-date")); + assertThat(result.isSuccess()).isFalse(); + assertThat(result.getError()).contains("year_of"); + } + + // --------------------------------------------------------------------------------- + // String formatting + // --------------------------------------------------------------------------------- + + @Test + @DisplayName("format(template, args...) substitutes {0}, {1}, ... placeholders") + void formatPlaceholders() { + String yaml = """ + inputs: + name: "string" + score: "number" + then: + - run greeting as format("Hello, {0}! Your score is {1}.", name, score) + output: + greeting: text + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, + Map.of("name", "Alice", "score", 92)); + assertThat(result.isSuccess()).isTrue(); + assertThat((String) result.getOutputData().get("greeting")) + .isEqualTo("Hello, Alice! Your score is 92."); + } + + @Test + @DisplayName("format raises a clear error when the template references a missing placeholder") + void formatMissingPlaceholderFails() { + String yaml = """ + then: + - run msg as format("Need {0} and {1}", "only-one") + output: + msg: text + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + assertThat(result.isSuccess()).isFalse(); + assertThat(result.getError()).contains("format").contains("{1}"); + } + + @Test + @DisplayName("concat(...args) joins all argument string representations") + void concatJoinsArgs() { + String yaml = """ + then: + - run joined as concat("a", "-", "b", "-", "c") + output: + joined: text + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of()); + assertThat(result.isSuccess()).isTrue(); + assertThat((String) result.getOutputData().get("joined")).isEqualTo("a-b-c"); + } + + // --------------------------------------------------------------------------------- + // Real-world usage: combine list ops + statistical + formatting in one rule + // --------------------------------------------------------------------------------- + + @Test + @DisplayName("End-to-end: filter, map, statistics, and format compose for a transaction summary") + void endToEndComposed() { + registry.register("is_above_100", args -> ((Number) args[0]).intValue() > 100); + registry.register("with_fee", args -> ((Number) args[0]).intValue() + 5); + + // The format() template contains colons, so the entire action line must be wrapped + // in YAML single-quotes; otherwise YAML interprets the colon as a key/value separator. + String yaml = """ + inputs: + amounts: "list" + then: + - run large_txns as filter(amounts, "is_above_100") + - run with_fees as map(large_txns, "with_fee") + - run total as sum(with_fees) + - run avg_amount as avg(with_fees) + - 'run summary as format("Large txns - {0}, total - {1}, avg - {2}", count(large_txns), total, avg_amount)' + output: + large_txns: list + total: number + avg_amount: number + summary: text + """; + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, + Map.of("amounts", List.of(50, 150, 75, 200, 300, 80, 110))); + + assertThat(result.isSuccess()).isTrue(); + // large_txns = [150, 200, 300, 110]; with_fees = [155, 205, 305, 115]; sum = 780; avg = 195 + @SuppressWarnings("unchecked") + List large = (List) result.getOutputData().get("large_txns"); + assertThat(large).containsExactly(150, 200, 300, 110); + assertThat(((Number) result.getOutputData().get("total")).intValue()).isEqualTo(780); + assertThat(((String) result.getOutputData().get("summary"))) + .startsWith("Large txns - 4") + .contains("total - 780"); + } +} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCodeGeneratorTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCodeGeneratorTest.java deleted file mode 100644 index 1263523..0000000 --- a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCodeGeneratorTest.java +++ /dev/null @@ -1,165 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.compiler; - -import org.fireflyframework.rules.core.dsl.model.ASTRulesDSL; -import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.junit.jupiter.MockitoExtension; - -import static org.junit.jupiter.api.Assertions.*; - -/** - * Test class for PythonCodeGenerator. - * - * Tests the compilation of various DSL constructs to Python code. - */ -@ExtendWith(MockitoExtension.class) -class PythonCodeGeneratorTest { - - private PythonCodeGenerator pythonCodeGenerator; - private ASTRulesDSLParser astRulesDSLParser; - - @BeforeEach - void setUp() { - pythonCodeGenerator = new PythonCodeGenerator(); - astRulesDSLParser = new ASTRulesDSLParser(new org.fireflyframework.rules.core.dsl.parser.DSLParser()); - } - - @Test - void testSimpleRuleCompilation() { - String yamlDsl = """ - name: "simple_credit_check" - description: "Simple credit score validation" - version: "1.0.0" - - input: - creditScore: "number" - - output: - approved: "boolean" - - when: creditScore >= 650 - then: - - set approved to true - else: - - set approved to false - """; - - ASTRulesDSL rule = astRulesDSLParser.parseRules(yamlDsl); - String pythonCode = pythonCodeGenerator.generatePythonFunction(rule); - - assertNotNull(pythonCode); - assertTrue(pythonCode.contains("def simple_credit_check(context):")); - assertTrue(pythonCode.contains("from firefly_runtime import *")); - assertTrue(pythonCode.contains("creditScore")); - assertTrue(pythonCode.contains("approved")); - assertTrue(pythonCode.contains("return {")); - } - - @Test - void testComplexRuleCompilation() { - String yamlDsl = """ - name: "loan_approval" - description: "Complex loan approval logic" - version: "1.0.0" - - input: - creditScore: "number" - income: "number" - debtToIncomeRatio: "number" - - output: - approved: "boolean" - loanAmount: "number" - interestRate: "number" - - rules: - - name: "high_credit_score" - when: creditScore >= 750 - then: - - set approved to true - - set loanAmount to income * 5 - - set interestRate to 3.5 - - - name: "medium_credit_score" - when: creditScore >= 650 and creditScore < 750 - then: - - set approved to true - - set loanAmount to income * 3 - - set interestRate to 4.5 - - - name: "low_credit_score" - when: creditScore < 650 - then: - - set approved to false - - set loanAmount to 0 - - set interestRate to 0 - """; - - ASTRulesDSL rule = astRulesDSLParser.parseRules(yamlDsl); - String pythonCode = pythonCodeGenerator.generatePythonFunction(rule); - - assertNotNull(pythonCode); - assertTrue(pythonCode.contains("def loan_approval(context):")); - assertTrue(pythonCode.contains("high_credit_score")); - assertTrue(pythonCode.contains("medium_credit_score")); - assertTrue(pythonCode.contains("low_credit_score")); - assertTrue(pythonCode.contains("creditScore', 0) >= 750")); - assertTrue(pythonCode.contains("income', 0) * 5")); - } - - @Test - void testFunctionNameSanitization() { - assertEquals("test_rule", pythonCodeGenerator.sanitizeFunctionName("Test Rule")); - assertEquals("test_rule_123", pythonCodeGenerator.sanitizeFunctionName("Test-Rule-123")); - assertEquals("_123_test", pythonCodeGenerator.sanitizeFunctionName("123-Test")); - assertEquals("test_rule", pythonCodeGenerator.sanitizeFunctionName("test__rule")); - assertEquals("unnamed_rule", pythonCodeGenerator.sanitizeFunctionName(null)); - } - - @Test - void testInputOutputVariableExtraction() { - String yamlDsl = """ - name: "test_rule" - input: - var1: "number" - var2: "string" - output: - result1: "boolean" - result2: "number" - when: var1 > 0 - then: - - set result1 to true - """; - - ASTRulesDSL rule = astRulesDSLParser.parseRules(yamlDsl); - - var inputVars = pythonCodeGenerator.extractInputVariables(rule); - var outputVars = pythonCodeGenerator.extractOutputVariables(rule); - - assertEquals(2, inputVars.size()); - assertTrue(inputVars.contains("var1")); - assertTrue(inputVars.contains("var2")); - - assertEquals(2, outputVars.size()); - assertTrue(outputVars.containsKey("result1")); - assertTrue(outputVars.containsKey("result2")); - } -} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilationServiceTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilationServiceTest.java deleted file mode 100644 index 6c7b29e..0000000 --- a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilationServiceTest.java +++ /dev/null @@ -1,234 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.compiler; - -import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; -import org.fireflyframework.rules.core.dsl.model.ASTRulesDSL; -import org.fireflyframework.rules.core.validation.YamlDslValidator; -import org.fireflyframework.rules.interfaces.dtos.validation.ValidationResult; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; - -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.when; - -/** - * Test class for PythonCompilationService. - */ -@ExtendWith(MockitoExtension.class) -class PythonCompilationServiceTest { - - @Mock - private ASTRulesDSLParser astRulesDSLParser; - - @Mock - private YamlDslValidator yamlDslValidator; - - @Mock - private PythonCodeGenerator pythonCodeGenerator; - - private PythonCompilationService pythonCompilationService; - - @BeforeEach - void setUp() { - pythonCompilationService = new PythonCompilationService( - astRulesDSLParser, yamlDslValidator, pythonCodeGenerator); - } - - @Test - void testSuccessfulCompilation() { - String yamlDsl = """ - name: "test_rule" - when: creditScore >= 650 - then: - - set approved = true - """; - - // Mock successful validation - ValidationResult validationResult = ValidationResult.builder() - .status(ValidationResult.ValidationStatus.VALID) - .summary(ValidationResult.ValidationSummary.builder() - .totalIssues(0) - .criticalErrors(0) - .errors(0) - .warnings(0) - .suggestions(0) - .qualityScore(100.0) - .build()) - .build(); - when(yamlDslValidator.validate(any())).thenReturn(validationResult); - - // Mock AST parsing - ASTRulesDSL mockRule = ASTRulesDSL.builder() - .name("test_rule") - .description("Test rule") - .build(); - when(astRulesDSLParser.parseRules(any())).thenReturn(mockRule); - - // Mock Python code generation - String expectedPythonCode = "def test_rule(context):\n return {}"; - when(pythonCodeGenerator.generatePythonFunction(any(), any())).thenReturn(expectedPythonCode); - - PythonCompiledRule result = pythonCompilationService.compileRule(yamlDsl, "test_rule"); - - assertNotNull(result); - assertEquals("test_rule", result.getRuleName()); - assertEquals(expectedPythonCode, result.getPythonCode()); - } - - @Test - void testCompilationWithValidationError() { - String yamlDsl = "invalid yaml"; - - // Mock validation failure - ValidationResult validationResult = ValidationResult.builder() - .status(ValidationResult.ValidationStatus.ERROR) - .summary(ValidationResult.ValidationSummary.builder() - .totalIssues(1) - .criticalErrors(0) - .errors(1) - .warnings(0) - .suggestions(0) - .qualityScore(0.0) - .build()) - .build(); - when(yamlDslValidator.validate(any())).thenReturn(validationResult); - - assertThrows(PythonCompilationService.PythonCompilationException.class, () -> { - pythonCompilationService.compileRule(yamlDsl, "test_rule"); - }); - } - - @Test - void testCacheOperations() { - String yamlDsl = """ - name: "cached_rule" - when: true - then: - - set result = true - """; - - // Mock successful validation and generation - ValidationResult validationResult = ValidationResult.builder() - .status(ValidationResult.ValidationStatus.VALID) - .summary(ValidationResult.ValidationSummary.builder() - .totalIssues(0) - .criticalErrors(0) - .errors(0) - .warnings(0) - .suggestions(0) - .qualityScore(100.0) - .build()) - .build(); - when(yamlDslValidator.validate(any())).thenReturn(validationResult); - - // Mock AST parsing - ASTRulesDSL mockRule = ASTRulesDSL.builder() - .name("cached_rule") - .description("Cached rule") - .build(); - when(astRulesDSLParser.parseRules(any())).thenReturn(mockRule); - - when(pythonCodeGenerator.generatePythonFunction(any(), any())).thenReturn("def cached_rule(context): return {}"); - - // First compilation should cache the result - PythonCompiledRule result1 = pythonCompilationService.compileRule(yamlDsl, "cached_rule", true); - - // Check if rule is cached - assertTrue(pythonCompilationService.isRuleCached(yamlDsl, "cached_rule")); - - // Get cached rule - PythonCompiledRule cachedRule = pythonCompilationService.getCachedRule(yamlDsl, "cached_rule"); - assertNotNull(cachedRule); - assertEquals(result1.getRuleName(), cachedRule.getRuleName()); - - // Remove from cache - assertTrue(pythonCompilationService.removeCachedRule(yamlDsl, "cached_rule")); - assertFalse(pythonCompilationService.isRuleCached(yamlDsl, "cached_rule")); - } - - @Test - void testBatchCompilation() { - Map rules = Map.of( - "rule1", "name: rule1\nwhen: true\nthen:\n - set result = 1", - "rule2", "name: rule2\nwhen: false\nthen:\n - set result = 2" - ); - - // Mock successful validation and generation - ValidationResult validationResult = ValidationResult.builder() - .status(ValidationResult.ValidationStatus.VALID) - .summary(ValidationResult.ValidationSummary.builder() - .totalIssues(0) - .criticalErrors(0) - .errors(0) - .warnings(0) - .suggestions(0) - .qualityScore(100.0) - .build()) - .build(); - when(yamlDslValidator.validate(any())).thenReturn(validationResult); - - // Mock AST parsing - ASTRulesDSL mockRule1 = ASTRulesDSL.builder() - .name("rule1") - .description("Rule 1") - .build(); - ASTRulesDSL mockRule2 = ASTRulesDSL.builder() - .name("rule2") - .description("Rule 2") - .build(); - when(astRulesDSLParser.parseRules(any())) - .thenReturn(mockRule1) - .thenReturn(mockRule2); - - when(pythonCodeGenerator.generatePythonFunction(any(), any())) - .thenReturn("def rule1(context): return {}") - .thenReturn("def rule2(context): return {}"); - - Map results = pythonCompilationService.compileRules(rules, true); - - assertEquals(2, results.size()); - assertTrue(results.containsKey("rule1")); - assertTrue(results.containsKey("rule2")); - } - - @Test - void testCompilationStatistics() { - Map stats = pythonCompilationService.getCompilationStats(); - - assertNotNull(stats); - assertTrue(stats.containsKey("totalCompilations")); - assertTrue(stats.containsKey("successfulCompilations")); - assertTrue(stats.containsKey("failedCompilations")); - assertTrue(stats.containsKey("cacheHits")); - assertTrue(stats.containsKey("cacheSize")); - assertTrue(stats.containsKey("successRate")); - assertTrue(stats.containsKey("cacheHitRate")); - } - - @Test - void testClearCache() { - // This should not throw any exception - assertDoesNotThrow(() -> pythonCompilationService.clearCache()); - } -} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilerIntegrationTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilerIntegrationTest.java deleted file mode 100644 index bf7b126..0000000 --- a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/compiler/PythonCompilerIntegrationTest.java +++ /dev/null @@ -1,501 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.core.dsl.compiler; - -import org.fireflyframework.rules.core.dsl.model.ASTRulesDSL; -import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; -import org.fireflyframework.rules.core.dsl.parser.DSLParser; -import org.fireflyframework.rules.core.services.ConstantService; -import org.fireflyframework.rules.core.validation.YamlDslValidator; -import org.fireflyframework.rules.interfaces.dtos.crud.ConstantDTO; -import org.fireflyframework.rules.interfaces.dtos.validation.ValidationResult; -import org.fireflyframework.rules.interfaces.enums.ValueType; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import reactor.core.publisher.Flux; - -import java.math.BigDecimal; -import java.util.List; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyList; -import static org.mockito.Mockito.when; - -/** - * Integration test for the complete Python compilation pipeline. - * Tests the end-to-end process from YAML DSL to executable Python code. - */ -@ExtendWith(MockitoExtension.class) -class PythonCompilerIntegrationTest { - - private PythonCodeGenerator pythonCodeGenerator; - private PythonCompilationService pythonCompilationService; - private ASTRulesDSLParser astRulesDSLParser; - - @Mock - private YamlDslValidator yamlDslValidator; - - @Mock - private ConstantService constantService; - - @BeforeEach - void setUp() { - pythonCodeGenerator = new PythonCodeGenerator(); - // Inject the mock ConstantService into PythonCodeGenerator - pythonCodeGenerator.setConstantService(constantService); - - astRulesDSLParser = new ASTRulesDSLParser(new DSLParser()); - pythonCompilationService = new PythonCompilationService( - astRulesDSLParser, yamlDslValidator, pythonCodeGenerator); - - // Mock validator to always return valid - ValidationResult validResult = ValidationResult.builder() - .status(ValidationResult.ValidationStatus.VALID) - .summary(ValidationResult.ValidationSummary.builder() - .totalIssues(0) - .criticalErrors(0) - .errors(0) - .warnings(0) - .suggestions(0) - .qualityScore(100.0) - .build()) - .build(); - when(yamlDslValidator.validate(any(String.class))).thenReturn(validResult); - } - - @Test - void testSimpleRuleCompilation() { - String yamlDsl = """ - name: "Simple Test Rule" - description: "A simple test rule" - version: "1.0" - - inputs: - score: "number" - - outputs: - result: "string" - - when: - - score > 80 - then: - - set result to "passed" - else: - - set result to "failed" - """; - - PythonCompiledRule compiledRule = pythonCompilationService.compileRule(yamlDsl, "simple_test"); - - assertNotNull(compiledRule); - assertEquals("simple_test", compiledRule.getRuleName()); - assertEquals("A simple test rule", compiledRule.getDescription()); - assertEquals("1.0", compiledRule.getVersion()); - assertNotNull(compiledRule.getPythonCode()); - assertNotNull(compiledRule.getFunctionName()); - assertNotNull(compiledRule.getCompiledAt()); - - String pythonCode = compiledRule.getPythonCode(); - - // Debug: Print the generated Python code - System.out.println("=== GENERATED PYTHON CODE ==="); - System.out.println(pythonCode); - System.out.println("=== END PYTHON CODE ==="); - - // Verify the generated Python code contains expected elements - assertTrue(pythonCode.contains("from firefly_runtime import *")); - assertTrue(pythonCode.contains("def simple_test(context):")); - assertTrue(pythonCode.contains("context.get('score', 0) > 80")); - assertTrue(pythonCode.contains("context['result'] = \"passed\"")); - assertTrue(pythonCode.contains("context['result'] = \"failed\"")); - assertTrue(pythonCode.contains("return {")); - assertTrue(pythonCode.contains("'result': context.get('result')")); - } - - @Test - void testComplexRuleWithCalculations() { - String yamlDsl = """ - name: "Credit Scoring Rule" - description: "Calculate credit score and approval" - version: "2.0" - - inputs: - income: "number" - debt: "number" - age: "number" - - outputs: - creditScore: "number" - approved: "boolean" - reason: "string" - - rules: - - when: - - income > 50000 - - debt < (income * 0.3) - - age >= 21 - then: - - calculate creditScore as (income / 1000) + (100 - (debt / income * 100)) - - set approved to true - - set reason to "Approved based on income and debt ratio" - else: - - set creditScore to 300 - - set approved to false - - set reason to "Denied - insufficient criteria" - """; - - PythonCompiledRule compiledRule = pythonCompilationService.compileRule(yamlDsl, "credit_scoring"); - - assertNotNull(compiledRule); - assertEquals("credit_scoring", compiledRule.getRuleName()); - assertEquals("Calculate credit score and approval", compiledRule.getDescription()); - assertEquals("2.0", compiledRule.getVersion()); - - String pythonCode = compiledRule.getPythonCode(); - - // Verify complex calculations are properly generated - assertTrue(pythonCode.contains("context.get('income', 0) > 50000")); - assertTrue(pythonCode.contains("context.get('debt', 0) < (context.get('income', 0) * 0.3)")); - assertTrue(pythonCode.contains("context.get('age', 0) >= 21")); - assertTrue(pythonCode.contains("(context.get('income', 0) / 1000)")); - assertTrue(pythonCode.contains("context['approved'] = True")); - assertTrue(pythonCode.contains("context['approved'] = False")); - - // Verify input and output variables are extracted - assertTrue(compiledRule.getInputVariables().contains("income")); - assertTrue(compiledRule.getInputVariables().contains("debt")); - assertTrue(compiledRule.getInputVariables().contains("age")); - - assertTrue(compiledRule.getOutputVariables().containsKey("creditScore")); - assertTrue(compiledRule.getOutputVariables().containsKey("approved")); - assertTrue(compiledRule.getOutputVariables().containsKey("reason")); - } - - @Test - void testFunctionNameSanitization() { - String yamlDsl = """ - name: "Test Rule with Special-Characters & Spaces!" - - when: - - true - then: - - set result to "ok" - """; - - PythonCompiledRule compiledRule = pythonCompilationService.compileRule(yamlDsl, "test-rule-123"); - - assertNotNull(compiledRule.getFunctionName()); - // Function name should be sanitized for Python - assertTrue(compiledRule.getFunctionName().matches("[a-zA-Z_][a-zA-Z0-9_]*")); - assertFalse(compiledRule.getFunctionName().contains("-")); - assertFalse(compiledRule.getFunctionName().contains(" ")); - assertFalse(compiledRule.getFunctionName().contains("!")); - } - - @Test - void testCacheHitAndMiss() { - String yamlDsl = """ - name: "Cache Test Rule" - - when: - - true - then: - - set result to "cached" - """; - - // First compilation - cache miss - PythonCompiledRule firstCompilation = pythonCompilationService.compileRule(yamlDsl, "cache_test", true); - assertNotNull(firstCompilation); - - // Second compilation - should hit cache - PythonCompiledRule secondCompilation = pythonCompilationService.compileRule(yamlDsl, "cache_test", true); - assertNotNull(secondCompilation); - - // Should be the same instance from cache - assertEquals(firstCompilation.getSourceHash(), secondCompilation.getSourceHash()); - assertEquals(firstCompilation.getPythonCode(), secondCompilation.getPythonCode()); - } - - @Test - void testBatchCompilation() { - String rule1 = """ - name: "Rule 1" - when: - - value > 10 - then: - - set result to "high" - """; - - String rule2 = """ - name: "Rule 2" - when: - - value <= 10 - then: - - set result to "low" - """; - - Map rules = Map.of( - "rule1", rule1, - "rule2", rule2 - ); - - Map compiledRules = pythonCompilationService.compileRules(rules, false); - - assertEquals(2, compiledRules.size()); - assertTrue(compiledRules.containsKey("rule1")); - assertTrue(compiledRules.containsKey("rule2")); - - PythonCompiledRule compiledRule1 = compiledRules.get("rule1"); - PythonCompiledRule compiledRule2 = compiledRules.get("rule2"); - - assertNotNull(compiledRule1); - assertNotNull(compiledRule2); - assertEquals("Rule 1", compiledRule1.getDescription()); - assertEquals("Rule 2", compiledRule2.getDescription()); - } - - @Test - @DisplayName("Should compile complex B2B Credit Scoring rule with constants") - void testComplexB2BCreditScoringCompilation() { - String yamlDsl = getB2BCreditScoringRule(); - - PythonCompiledRule result = pythonCompilationService.compileRule(yamlDsl, "b2b_credit_scoring"); - - assertNotNull(result); - assertEquals("b2b_credit_scoring", result.getRuleName()); - - // Verify the Python code contains expected elements - String pythonCode = result.getPythonCode(); - - // Check copyright and license headers - assertTrue(pythonCode.contains("Copyright 2024-2026 Firefly Software Foundation")); - assertTrue(pythonCode.contains("Licensed under the Apache License, Version 2.0")); - assertTrue(pythonCode.contains("Made with ❤️")); - - // Check constants initialization - assertTrue(pythonCode.contains("Initialize constants from database")); - assertTrue(pythonCode.contains("MIN_BUSINESS_CREDIT_SCORE")); - assertTrue(pythonCode.contains("EXCELLENT_CREDIT_THRESHOLD")); - assertTrue(pythonCode.contains("MAX_DEBT_TO_INCOME_RATIO")); - - // Check interactive main section - assertTrue(pythonCode.contains("if __name__ == \"__main__\":")); - assertTrue(pythonCode.contains("print_firefly_header")); - assertTrue(pythonCode.contains("constants_need_config")); - - // Check function definition - assertTrue(pythonCode.contains("def b2b_credit_scoring(context):")); - - // Check complex rule logic - assertTrue(pythonCode.contains("data_validation_complete")); - - // Print the generated code for inspection - System.out.println("=== GENERATED B2B CREDIT SCORING PYTHON CODE ==="); - System.out.println(pythonCode); - System.out.println("=== END GENERATED CODE ==="); - } - - private String getB2BCreditScoringRule() { - return """ - name: "B2B Credit Scoring Platform" - description: "Comprehensive business credit assessment using multiple data sources" - version: "1.0.0" - - # Input variables from loan application API and external data sources - inputs: - # Business identification and basic info - businessId: text - businessName: text - taxId: text - businessType: text - industryCode: text - yearsInBusiness: number - numberOfEmployees: number - - # Loan application details - requestedAmount: number - loanPurpose: text - requestedTerm: number - hasCollateral: boolean - collateralValue: number - - # Financial information from application - annualRevenue: number - monthlyRevenue: number - monthlyExpenses: number - existingDebt: number - monthlyDebtPayments: number - - # Business owner information - ownerCreditScore: number - ownerYearsExperience: number - ownershipPercentage: number - - # Credit bureau data - businessCreditScore: number - paymentHistoryScore: number - creditUtilization: number - publicRecordsCount: number - tradelineCount: number - - # System constants for business rules - constants: - # Credit score thresholds - - code: MIN_BUSINESS_CREDIT_SCORE - defaultValue: 650 - - code: EXCELLENT_CREDIT_THRESHOLD - defaultValue: 750 - - # Financial ratio limits - - code: MAX_DEBT_TO_INCOME_RATIO - defaultValue: 0.4 - - code: MIN_DEBT_SERVICE_COVERAGE - defaultValue: 1.25 - - code: MAX_LOAN_TO_VALUE_RATIO - defaultValue: 0.8 - - # Business criteria - - code: MIN_YEARS_IN_BUSINESS - defaultValue: 2 - - code: MIN_ANNUAL_REVENUE - defaultValue: 100000 - - # Multi-stage evaluation using sequential rules - rules: - # Stage 1: Data Validation and Preparation - - name: "Data Validation and Preparation" - when: - - businessId is_not_empty - - requestedAmount is_positive - - annualRevenue is_positive - - businessCreditScore is_credit_score - - ownerCreditScore is_credit_score - then: - # Validate all required financial data is present and valid - - set monthly_revenue_valid to (monthlyRevenue is_positive) - - set monthly_expenses_valid to (monthlyExpenses is_positive) - - set existing_debt_valid to (existingDebt is_not_null) - - set has_complete_financial_data to (monthly_revenue_valid AND monthly_expenses_valid AND existing_debt_valid) - - # Calculate data quality indicators - - calculate debt_to_income_ratio as monthlyDebtPayments / monthlyRevenue - - set data_validation_complete to has_complete_financial_data - - - if data_validation_complete then set validation_status to "PASSED" - - if NOT data_validation_complete then set validation_status to "FAILED" - else: - - set data_validation_complete to false - - set validation_status to "FAILED" - - # Define all output variables that will be returned - output: - # Primary decision outputs - validation_status: text - data_validation_complete: boolean - debt_to_income_ratio: number - has_complete_financial_data: boolean - """; - } - - @Test - @DisplayName("Should handle constants from database vs default values correctly") - void testConstantsFromDatabaseVsDefaultValues() { - // Setup mock constants from database - ConstantDTO existingConstant = ConstantDTO.builder() - .code("EXISTING_CONSTANT") - .currentValue(999) // This should override the default value of 100 - .valueType(ValueType.NUMBER) - .build(); - - // Mock the ConstantService to return only the existing constant - when(constantService.getConstantsByCodes(anyList())) - .thenReturn(Flux.just(existingConstant)); - - String yamlDsl = getConstantsTestRule(); - - PythonCompiledRule result = pythonCompilationService.compileRule(yamlDsl, "constants_test"); - - assertNotNull(result); - assertEquals("constants_test", result.getRuleName()); - - String pythonCode = result.getPythonCode(); - - // Check that constants are properly initialized with correct comments - assertTrue(pythonCode.contains("Initialize constants from database")); - - // Constant that exists in database should override default value - assertTrue(pythonCode.contains("constants['EXISTING_CONSTANT'] = 999")); - assertTrue(pythonCode.contains("# From database")); - - // Constant with default value but not in database should use default - assertTrue(pythonCode.contains("constants['DEFAULT_ONLY_CONSTANT'] = 500")); - assertTrue(pythonCode.contains("# Default value")); - - // Constant without default and not in database should be None with warning - assertTrue(pythonCode.contains("constants['MISSING_CONSTANT'] = None")); - assertTrue(pythonCode.contains("# WARNING: Constant not found in database and no default value provided")); - - // Print the generated code for inspection - System.out.println("=== CONSTANTS TEST PYTHON CODE ==="); - System.out.println(pythonCode); - System.out.println("=== END CONSTANTS TEST CODE ==="); - } - - private String getConstantsTestRule() { - return """ - name: "Constants Test Rule" - description: "Test rule to demonstrate constants handling from database vs defaults" - version: "1.0.0" - - inputs: - score: number - amount: number - - constants: - # This constant exists in database and should override default value - - code: EXISTING_CONSTANT - defaultValue: 100 - - # This constant has default but doesn't exist in database - - code: DEFAULT_ONLY_CONSTANT - defaultValue: 500 - - # This constant has no default and doesn't exist in database - - code: MISSING_CONSTANT - - rules: - - name: "Test Constants Usage" - when: - - score is_positive - then: - - if score greater_than EXISTING_CONSTANT then set result to "high" - - if amount greater_than DEFAULT_ONLY_CONSTANT then set approved to true - - if MISSING_CONSTANT is_not_null then set has_config to true - - if MISSING_CONSTANT is_null then set has_config to false - - output: - result: text - approved: boolean - has_config: boolean - """; - } -} diff --git a/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/function/CustomFunctionRegistryTest.java b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/function/CustomFunctionRegistryTest.java new file mode 100644 index 0000000..14cd184 --- /dev/null +++ b/fireflyframework-rule-engine-core/src/test/java/org/fireflyframework/rules/core/dsl/function/CustomFunctionRegistryTest.java @@ -0,0 +1,156 @@ +/* + * Copyright 2024-2026 Firefly Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.fireflyframework.rules.core.dsl.function; + +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationEngine; +import org.fireflyframework.rules.core.dsl.evaluation.ASTRulesEvaluationResult; +import org.fireflyframework.rules.core.dsl.parser.ASTRulesDSLParser; +import org.fireflyframework.rules.core.dsl.parser.DSLParser; +import org.fireflyframework.rules.core.services.ConstantService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Flux; + +import java.math.BigDecimal; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +/** + * Behavioural tests for {@link CustomFunctionRegistry} and its integration with the + * evaluation engine. These cover the public extension contract: name resolution, + * shadowing of built-ins, error semantics, and unknown-function diagnostics. + */ +class CustomFunctionRegistryTest { + + private CustomFunctionRegistry registry; + private ASTRulesEvaluationEngine engine; + + @BeforeEach + void setUp() { + registry = new CustomFunctionRegistry(); + DSLParser dslParser = new DSLParser(); + ASTRulesDSLParser parser = new ASTRulesDSLParser(dslParser); + ConstantService constantService = Mockito.mock(ConstantService.class); + Mockito.when(constantService.getConstantsByCodes(Mockito.anyList())).thenReturn(Flux.empty()); + engine = new ASTRulesEvaluationEngine(parser, constantService, null, null, registry); + } + + @Test + @DisplayName("Registering a custom function makes it callable from `run`") + void registeredFunctionCallableFromRun() { + registry.register("triple", args -> ((Number) args[0]).intValue() * 3); + + String yaml = """ + when: + - amount at_least 0 + then: + - run result as triple(amount) + output: + result: result + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("amount", 7)); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("result", 21); + } + + @Test + @DisplayName("Custom function shadows built-in of the same name") + void customFunctionShadowsBuiltin() { + // The built-in `max` returns the largest argument. Shadow it with a no-op that returns 999. + registry.register("max", args -> BigDecimal.valueOf(999)); + + String yaml = """ + when: + - score at_least 0 + then: + - run winner as max(score, 1) + output: + winner: winner + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("score", 5)); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.getOutputData()).containsEntry("winner", BigDecimal.valueOf(999)); + } + + @Test + @DisplayName("Unknown function name surfaces as a structured evaluation failure (not silent null)") + void unknownFunctionFailsEvaluation() { + String yaml = """ + when: + - amount at_least 0 + then: + - run result as no_such_function(amount) + output: + result: result + """; + + ASTRulesEvaluationResult result = engine.evaluateRules(yaml, Map.of("amount", 1)); + + // The engine now fails the whole evaluation rather than silently swallowing the + // unknown-function error and continuing past the broken action. + assertThat(result.isSuccess()).isFalse(); + assertThat(result.getError()).contains("no_such_function"); + } + + @Test + @DisplayName("Lookup is case-insensitive") + void lookupIsCaseInsensitive() { + registry.register("MyFunc", args -> "called"); + + assertThat(registry.lookup("myfunc")).isPresent(); + assertThat(registry.lookup("MYFUNC")).isPresent(); + assertThat(registry.lookup("MyFunc")).isPresent(); + } + + @Test + @DisplayName("Re-registering a name replaces the previous function") + void reRegistrationReplaces() { + registry.register("f", args -> "v1"); + registry.register("f", args -> "v2"); + + assertThat(registry.lookup("f").orElseThrow().apply(new Object[0])).isEqualTo("v2"); + } + + @Test + @DisplayName("Unregister removes the function") + void unregisterRemoves() { + registry.register("temp", args -> 1); + assertThat(registry.contains("temp")).isTrue(); + assertThat(registry.unregister("temp")).isTrue(); + assertThat(registry.contains("temp")).isFalse(); + assertThat(registry.unregister("temp")).isFalse(); + } + + @Test + @DisplayName("Blank name and null function are rejected at registration time") + void rejectsInvalidInputs() { + assertThatThrownBy(() -> registry.register("", args -> null)) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> registry.register(null, args -> null)) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> registry.register("ok", null)) + .isInstanceOf(IllegalArgumentException.class); + } +} diff --git a/fireflyframework-rule-engine-sdk/src/main/resources/api-spec/openapi.yml b/fireflyframework-rule-engine-sdk/src/main/resources/api-spec/openapi.yml index cb6fe23..caf051f 100644 --- a/fireflyframework-rule-engine-sdk/src/main/resources/api-spec/openapi.yml +++ b/fireflyframework-rule-engine-sdk/src/main/resources/api-spec/openapi.yml @@ -12,8 +12,6 @@ servers: - url: / description: Local Development Environment tags: - - name: Python Compilation - description: Compile DSL rules to Python code - name: YAML DSL Validation description: Static code analysis and validation for YAML DSL rules - name: Batch Rules Evaluation @@ -640,257 +638,6 @@ paths: '*/*': schema: $ref: '#/components/schemas/BatchRulesEvaluationResponseDTO' - /api/v1/python/compile: - post: - tags: - - Python Compilation - summary: Compile DSL rule to Python - description: Compiles a YAML DSL rule definition to executable Python code - operationId: compileRule - parameters: - - name: ruleName - in: query - description: Optional rule name - required: false - schema: - type: string - - name: useCache - in: query - description: Whether to use compilation cache - required: false - schema: - type: boolean - default: true - - name: X-Idempotency-Key - in: header - description: Unique key for idempotent requests. If provided, ensures that identical requests with the same key will only be processed once. - required: false - schema: - type: string - requestBody: - content: - application/json: - schema: - type: string - description: YAML DSL rule definition - required: true - responses: - '200': - description: Rule compiled successfully - content: - application/json: - schema: - $ref: '#/components/schemas/PythonCompiledRule' - '400': - description: Invalid DSL or compilation error - content: - application/json: {} - '500': - description: Internal server error - content: - application/json: {} - /api/v1/python/compile/rule/{ruleId}: - post: - tags: - - Python Compilation - summary: Compile rule from database by ID - description: Compiles a rule definition stored in the database to Python code using the rule ID - operationId: compileRuleById - parameters: - - name: ruleId - in: path - description: Rule definition ID - required: true - schema: - type: string - format: uuid - - name: useCache - in: query - description: Whether to use compilation cache - required: false - schema: - type: boolean - default: true - - name: X-Idempotency-Key - in: header - description: Unique key for idempotent requests. If provided, ensures that identical requests with the same key will only be processed once. - required: false - schema: - type: string - responses: - '200': - description: Rule compiled successfully - content: - application/json: - schema: - $ref: '#/components/schemas/PythonCompiledRule' - '400': - description: Invalid rule ID or compilation error - content: - application/json: {} - '404': - description: Rule definition not found - content: - application/json: {} - '500': - description: Internal server error - content: - application/json: {} - /api/v1/python/compile/rule/code/{ruleCode}: - post: - tags: - - Python Compilation - summary: Compile rule from database by code - description: Compiles a rule definition stored in the database to Python code using the rule code - operationId: compileRuleByCode - parameters: - - name: ruleCode - in: path - description: Rule definition code - required: true - schema: - type: string - - name: useCache - in: query - description: Whether to use compilation cache - required: false - schema: - type: boolean - default: true - - name: X-Idempotency-Key - in: header - description: Unique key for idempotent requests. If provided, ensures that identical requests with the same key will only be processed once. - required: false - schema: - type: string - responses: - '200': - description: Rule compiled successfully - content: - application/json: - schema: - $ref: '#/components/schemas/PythonCompiledRule' - '400': - description: Invalid rule code or compilation error - content: - application/json: {} - '404': - description: Rule definition not found - content: - application/json: {} - '500': - description: Internal server error - content: - application/json: {} - /api/v1/python/compile/batch: - post: - tags: - - Python Compilation - summary: Batch compile multiple DSL rules - description: Compiles multiple YAML DSL rules to Python code in parallel - operationId: compileRules - parameters: - - name: useCache - in: query - description: Whether to use compilation cache - required: false - schema: - type: boolean - default: true - - name: X-Idempotency-Key - in: header - description: Unique key for idempotent requests. If provided, ensures that identical requests with the same key will only be processed once. - required: false - schema: - type: string - requestBody: - content: - application/json: - schema: - type: object - additionalProperties: - type: string - description: Map of rule names to YAML DSL definitions - required: true - responses: - '200': - description: Batch compilation completed - content: - application/json: {} - '400': - description: Invalid request or compilation errors - content: - application/json: {} - /api/v1/python/cache/get: - post: - tags: - - Python Compilation - summary: Get cached compiled rule - description: Retrieves a compiled rule from cache if it exists - operationId: getCachedRule - parameters: - - name: ruleName - in: query - description: Optional rule name - required: false - schema: - type: string - - name: X-Idempotency-Key - in: header - description: Unique key for idempotent requests. If provided, ensures that identical requests with the same key will only be processed once. - required: false - schema: - type: string - requestBody: - content: - application/json: - schema: - type: string - description: YAML DSL rule definition - required: true - responses: - '200': - description: Cached rule found - content: - application/json: - schema: - $ref: '#/components/schemas/PythonCompiledRule' - '404': - description: Rule not found in cache - content: - application/json: {} - /api/v1/python/cache/check: - post: - tags: - - Python Compilation - summary: Check if rule is cached - description: Checks if a specific rule is already compiled and cached - operationId: checkCache - parameters: - - name: ruleName - in: query - description: Optional rule name - required: false - schema: - type: string - - name: X-Idempotency-Key - in: header - description: Unique key for idempotent requests. If provided, ensures that identical requests with the same key will only be processed once. - required: false - schema: - type: string - requestBody: - content: - application/json: - schema: - type: string - description: YAML DSL rule definition - required: true - responses: - '200': - description: Cache status retrieved - content: - application/json: {} /api/v1/constants: post: tags: @@ -1104,18 +851,6 @@ paths: '*/*': schema: $ref: '#/components/schemas/BatchRulesEvaluationResponseDTO' - /api/v1/python/stats: - get: - tags: - - Python Compilation - summary: Get compilation statistics - description: Retrieves compilation statistics including success rate and cache performance - operationId: getCompilationStats - responses: - '200': - description: Statistics retrieved successfully - content: - application/json: {} /api/v1/constants/code/{code}: get: tags: @@ -1352,37 +1087,6 @@ paths: type: object additionalProperties: type: object - /api/v1/python/cache: - delete: - tags: - - Python Compilation - summary: Clear compilation cache - description: Clears all cached compiled rules - operationId: clearCache - responses: - '200': - description: Cache cleared successfully - content: - application/json: {} - /api/v1/python/cache/rule: - delete: - tags: - - Python Compilation - summary: Remove rule from cache - description: Removes a specific compiled rule from the cache using rule name or cache key - operationId: removeCachedRule - parameters: - - name: ruleName - in: query - description: Rule name or cache key to remove - required: true - schema: - type: string - responses: - '200': - description: Rule removed from cache - content: - application/json: {} /api/v1/audit/trails/cleanup: delete: tags: @@ -2365,45 +2069,6 @@ components: type: object additionalProperties: type: object - PythonCompiledRule: - type: object - properties: - ruleName: - type: string - description: - type: string - version: - type: string - pythonCode: - type: string - inputVariables: - type: array - items: - type: string - outputVariables: - type: object - additionalProperties: - type: string - compiledAt: - type: string - format: date-time - sourceHash: - type: string - functionName: - type: string - dependencies: - type: array - items: - type: string - metadata: - $ref: '#/components/schemas/CompilationMetadata' - valid: - type: boolean - codeSize: - type: integer - format: int32 - mainFunctionName: - type: string FilterRequestConstantDTO: required: - pagination @@ -2629,4 +2294,4 @@ components: type: integer description: The current page number, typically zero-based. format: int32 - description: Represents a paginated response containing a list of items and pagination metadata. \ No newline at end of file + description: Represents a paginated response containing a list of items and pagination metadata. diff --git a/fireflyframework-rule-engine-web/src/main/java/org/fireflyframework/rules/web/controllers/PythonCompilationController.java b/fireflyframework-rule-engine-web/src/main/java/org/fireflyframework/rules/web/controllers/PythonCompilationController.java deleted file mode 100644 index a19ed35..0000000 --- a/fireflyframework-rule-engine-web/src/main/java/org/fireflyframework/rules/web/controllers/PythonCompilationController.java +++ /dev/null @@ -1,471 +0,0 @@ -/* - * Copyright 2024-2026 Firefly Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.fireflyframework.rules.web.controllers; - -import org.fireflyframework.rules.core.dsl.compiler.PythonCompilationService; -import org.fireflyframework.rules.core.dsl.compiler.PythonCompiledRule; -import org.fireflyframework.rules.core.services.RuleDefinitionService; -import io.swagger.v3.oas.annotations.Operation; -import io.swagger.v3.oas.annotations.Parameter; -import io.swagger.v3.oas.annotations.media.Content; -import io.swagger.v3.oas.annotations.media.Schema; -import io.swagger.v3.oas.annotations.responses.ApiResponse; -import io.swagger.v3.oas.annotations.responses.ApiResponses; -import io.swagger.v3.oas.annotations.tags.Tag; -import lombok.RequiredArgsConstructor; -import lombok.extern.slf4j.Slf4j; -import org.springframework.http.HttpStatus; -import org.springframework.http.MediaType; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.*; -import org.springframework.web.server.ServerWebExchange; - -import reactor.core.publisher.Mono; - -import java.util.Map; -import java.util.UUID; - -/** - * REST Controller for Python compilation functionality. - * - * This controller provides endpoints to compile YAML DSL rules to Python code, - * manage compilation cache, and retrieve compilation statistics. - */ -@RestController -@RequestMapping("/api/v1/python") -@RequiredArgsConstructor -@Slf4j -@Tag(name = "Python Compilation", description = "Compile DSL rules to Python code") -public class PythonCompilationController { - - private final PythonCompilationService pythonCompilationService; - private final RuleDefinitionService ruleDefinitionService; - - @Operation( - summary = "Compile DSL rule to Python", - description = "Compiles a YAML DSL rule definition to executable Python code" - ) - @ApiResponses(value = { - @ApiResponse( - responseCode = "200", - description = "Rule compiled successfully", - content = @Content( - mediaType = MediaType.APPLICATION_JSON_VALUE, - schema = @Schema(implementation = PythonCompiledRule.class) - ) - ), - @ApiResponse( - responseCode = "400", - description = "Invalid DSL or compilation error", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ), - @ApiResponse( - responseCode = "500", - description = "Internal server error", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - }) - @PostMapping("/compile") - public ResponseEntity compileRule( - @Parameter(description = "YAML DSL rule definition", required = true) - @RequestBody String yamlDsl, - - @Parameter(description = "Optional rule name") - @RequestParam(required = false) String ruleName, - - @Parameter(description = "Whether to use compilation cache") - @RequestParam(defaultValue = "true") boolean useCache) { - - try { - log.info("Compiling rule '{}' to Python (cache: {})", ruleName, useCache); - - PythonCompiledRule compiledRule = pythonCompilationService.compileRule(yamlDsl, ruleName, useCache); - - return ResponseEntity.ok(compiledRule); - - } catch (PythonCompilationService.PythonCompilationException e) { - log.error("Compilation failed for rule '{}': {}", ruleName, e.getMessage()); - return ResponseEntity.badRequest() - .body(Map.of( - "error", "Compilation failed", - "message", e.getMessage(), - "ruleName", ruleName != null ? ruleName : "unknown" - )); - - } catch (Exception e) { - log.error("Unexpected error compiling rule '{}': {}", ruleName, e.getMessage(), e); - return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) - .body(Map.of( - "error", "Internal server error", - "message", e.getMessage() - )); - } - } - - @Operation( - summary = "Compile rule from database by ID", - description = "Compiles a rule definition stored in the database to Python code using the rule ID" - ) - @ApiResponses(value = { - @ApiResponse( - responseCode = "200", - description = "Rule compiled successfully", - content = @Content( - mediaType = MediaType.APPLICATION_JSON_VALUE, - schema = @Schema(implementation = PythonCompiledRule.class) - ) - ), - @ApiResponse( - responseCode = "404", - description = "Rule definition not found", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ), - @ApiResponse( - responseCode = "400", - description = "Invalid rule ID or compilation error", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ), - @ApiResponse( - responseCode = "500", - description = "Internal server error", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - }) - @PostMapping("/compile/rule/{ruleId}") - public Mono> compileRuleById( - @Parameter(description = "Rule definition ID", required = true) - @PathVariable UUID ruleId, - - @Parameter(description = "Whether to use compilation cache") - @RequestParam(defaultValue = "true") boolean useCache, - - ServerWebExchange exchange) { - - log.info("Compiling rule with ID '{}' to Python (cache: {})", ruleId, useCache); - - return ruleDefinitionService.getRuleDefinitionByIdWithAudit(ruleId, exchange) - .>map(ruleDefinition -> { - try { - PythonCompiledRule compiledRule = pythonCompilationService.compileRule( - ruleDefinition.getYamlContent(), - ruleDefinition.getName(), - useCache - ); - - log.info("Successfully compiled rule '{}' (ID: {}) to Python", - ruleDefinition.getName(), ruleId); - - return ResponseEntity.ok(compiledRule); - - } catch (PythonCompilationService.PythonCompilationException e) { - log.error("Compilation failed for rule '{}' (ID: {}): {}", - ruleDefinition.getName(), ruleId, e.getMessage()); - return ResponseEntity.badRequest() - .body(Map.of( - "error", "Compilation failed", - "message", e.getMessage(), - "ruleId", ruleId.toString(), - "ruleName", ruleDefinition.getName() - )); - } catch (Exception e) { - log.error("Unexpected error compiling rule '{}' (ID: {}): {}", - ruleDefinition.getName(), ruleId, e.getMessage(), e); - return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) - .body(Map.of( - "error", "Internal server error", - "ruleId", ruleId.toString() - )); - } - }) - .switchIfEmpty( - Mono.>just(ResponseEntity.status(HttpStatus.NOT_FOUND) - .body(Map.of( - "error", "Rule definition not found", - "message", "No rule definition found with ID: " + ruleId, - "ruleId", ruleId.toString() - ))) - ) - .onErrorResume(e -> { - log.error("Unexpected error fetching/compiling rule with ID '{}': {}", ruleId, e.getMessage(), e); - return Mono.>just(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) - .body(Map.of( - "error", "Internal server error", - "ruleId", ruleId.toString() - ))); - }); - } - - @Operation( - summary = "Compile rule from database by code", - description = "Compiles a rule definition stored in the database to Python code using the rule code" - ) - @ApiResponses(value = { - @ApiResponse( - responseCode = "200", - description = "Rule compiled successfully", - content = @Content( - mediaType = MediaType.APPLICATION_JSON_VALUE, - schema = @Schema(implementation = PythonCompiledRule.class) - ) - ), - @ApiResponse( - responseCode = "404", - description = "Rule definition not found", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ), - @ApiResponse( - responseCode = "400", - description = "Invalid rule code or compilation error", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ), - @ApiResponse( - responseCode = "500", - description = "Internal server error", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - }) - @PostMapping("/compile/rule/code/{ruleCode}") - public Mono> compileRuleByCode( - @Parameter(description = "Rule definition code", required = true) - @PathVariable String ruleCode, - - @Parameter(description = "Whether to use compilation cache") - @RequestParam(defaultValue = "true") boolean useCache, - - ServerWebExchange exchange) { - - log.info("Compiling rule with code '{}' to Python (cache: {})", ruleCode, useCache); - - return ruleDefinitionService.getRuleDefinitionByCodeWithAudit(ruleCode, exchange) - .>map(ruleDefinition -> { - try { - PythonCompiledRule compiledRule = pythonCompilationService.compileRule( - ruleDefinition.getYamlContent(), - ruleDefinition.getName(), - useCache - ); - - log.info("Successfully compiled rule '{}' (code: {}) to Python", - ruleDefinition.getName(), ruleCode); - - return ResponseEntity.ok(compiledRule); - - } catch (PythonCompilationService.PythonCompilationException e) { - log.error("Compilation failed for rule '{}' (code: {}): {}", - ruleDefinition.getName(), ruleCode, e.getMessage()); - return ResponseEntity.badRequest() - .body(Map.of( - "error", "Compilation failed", - "message", e.getMessage(), - "ruleCode", ruleCode, - "ruleName", ruleDefinition.getName() - )); - } catch (Exception e) { - log.error("Unexpected error compiling rule '{}' (code: {}): {}", - ruleDefinition.getName(), ruleCode, e.getMessage(), e); - return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) - .body(Map.of( - "error", "Internal server error", - "ruleCode", ruleCode - )); - } - }) - .switchIfEmpty( - Mono.>just(ResponseEntity.status(HttpStatus.NOT_FOUND) - .body(Map.of( - "error", "Rule definition not found", - "message", "No rule definition found with code: " + ruleCode, - "ruleCode", ruleCode - ))) - ) - .onErrorResume(e -> { - log.error("Unexpected error fetching/compiling rule with code '{}': {}", ruleCode, e.getMessage(), e); - return Mono.>just(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) - .body(Map.of( - "error", "Internal server error", - "ruleCode", ruleCode - ))); - }); - } - - @Operation( - summary = "Batch compile multiple DSL rules", - description = "Compiles multiple YAML DSL rules to Python code in parallel" - ) - @ApiResponses(value = { - @ApiResponse( - responseCode = "200", - description = "Batch compilation completed", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ), - @ApiResponse( - responseCode = "400", - description = "Invalid request or compilation errors", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - }) - @PostMapping("/compile/batch") - public ResponseEntity compileRules( - @Parameter(description = "Map of rule names to YAML DSL definitions", required = true) - @RequestBody Map rules, - - @Parameter(description = "Whether to use compilation cache") - @RequestParam(defaultValue = "true") boolean useCache) { - - try { - log.info("Batch compiling {} rules to Python (cache: {})", rules.size(), useCache); - - Map compiledRules = pythonCompilationService.compileRules(rules, useCache); - - return ResponseEntity.ok(Map.of( - "compiledRules", compiledRules, - "totalRules", rules.size(), - "successfulCompilations", compiledRules.size(), - "failedCompilations", rules.size() - compiledRules.size() - )); - - } catch (Exception e) { - log.error("Unexpected error in batch compilation: {}", e.getMessage(), e); - return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) - .body(Map.of( - "error", "Batch compilation failed", - "message", e.getMessage() - )); - } - } - - @Operation( - summary = "Get compilation statistics", - description = "Retrieves compilation statistics including success rate and cache performance" - ) - @ApiResponse( - responseCode = "200", - description = "Statistics retrieved successfully", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - @GetMapping("/stats") - public ResponseEntity> getCompilationStats() { - Map stats = pythonCompilationService.getCompilationStats(); - return ResponseEntity.ok(stats); - } - - @Operation( - summary = "Clear compilation cache", - description = "Clears all cached compiled rules" - ) - @ApiResponse( - responseCode = "200", - description = "Cache cleared successfully", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - @DeleteMapping("/cache") - public ResponseEntity> clearCache() { - pythonCompilationService.clearCache(); - return ResponseEntity.ok(Map.of( - "message", "Compilation cache cleared successfully" - )); - } - - @Operation( - summary = "Check if rule is cached", - description = "Checks if a specific rule is already compiled and cached" - ) - @ApiResponse( - responseCode = "200", - description = "Cache status retrieved", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - @PostMapping("/cache/check") - public ResponseEntity> checkCache( - @Parameter(description = "YAML DSL rule definition", required = true) - @RequestBody String yamlDsl, - - @Parameter(description = "Optional rule name") - @RequestParam(required = false) String ruleName) { - - boolean isCached = pythonCompilationService.isRuleCached(yamlDsl, ruleName); - - return ResponseEntity.ok(Map.of( - "cached", isCached, - "ruleName", ruleName != null ? ruleName : "unknown" - )); - } - - @Operation( - summary = "Remove rule from cache", - description = "Removes a specific compiled rule from the cache using rule name or cache key" - ) - @ApiResponse( - responseCode = "200", - description = "Rule removed from cache", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - @DeleteMapping("/cache/rule") - public ResponseEntity> removeCachedRule( - @Parameter(description = "Rule name or cache key to remove", required = true) - @RequestParam String ruleName) { - - // For DELETE requests, we use query parameters instead of request body - // This follows HTTP best practices where DELETE should not have a body - boolean removed = pythonCompilationService.removeCachedRuleByName(ruleName); - - return ResponseEntity.ok(Map.of( - "removed", removed, - "ruleName", ruleName - )); - } - - @Operation( - summary = "Get cached compiled rule", - description = "Retrieves a compiled rule from cache if it exists" - ) - @ApiResponses(value = { - @ApiResponse( - responseCode = "200", - description = "Cached rule found", - content = @Content( - mediaType = MediaType.APPLICATION_JSON_VALUE, - schema = @Schema(implementation = PythonCompiledRule.class) - ) - ), - @ApiResponse( - responseCode = "404", - description = "Rule not found in cache", - content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE) - ) - }) - @PostMapping("/cache/get") - public ResponseEntity getCachedRule( - @Parameter(description = "YAML DSL rule definition", required = true) - @RequestBody String yamlDsl, - - @Parameter(description = "Optional rule name") - @RequestParam(required = false) String ruleName) { - - PythonCompiledRule cachedRule = pythonCompilationService.getCachedRule(yamlDsl, ruleName); - - if (cachedRule != null) { - return ResponseEntity.ok(cachedRule); - } else { - return ResponseEntity.status(HttpStatus.NOT_FOUND) - .body(Map.of( - "error", "Rule not found in cache", - "ruleName", ruleName != null ? ruleName : "unknown" - )); - } - } -} diff --git a/pom.xml b/pom.xml index 193d3ed..945a623 100644 --- a/pom.xml +++ b/pom.xml @@ -17,7 +17,7 @@ pom Firefly Framework - Rule Engine Library - YAML DSL-based rule engine with AST processing, Python compilation, audit trails, and reactive APIs for dynamic business rule evaluation + YAML DSL-based rule engine with AST processing, audit trails, and reactive APIs for dynamic business rule evaluation fireflyframework-rule-engine-core diff --git a/python-runtime/README.md b/python-runtime/README.md deleted file mode 100644 index 5abdd7a..0000000 --- a/python-runtime/README.md +++ /dev/null @@ -1,337 +0,0 @@ -# Firefly Framework Rule Engine Python Runtime - -The Firefly Framework Rule Engine Python Runtime provides all the built-in functions and utilities needed to execute compiled Python rules from the Firefly Framework Rule Engine. - -## 🚀 Installation - -### Option 1: Global Installation (macOS - Recommended for Development) - -For macOS systems, you can install the runtime globally: - -```bash -# Install dependencies globally -pip3 install --break-system-packages requests cryptography urllib3 - -# Navigate to the runtime directory -cd python-runtime - -# Install firefly_runtime globally -pip3 install --break-system-packages -e . - -# Verify installation -python3 -c "import firefly_runtime; print(f'Firefly Runtime v{firefly_runtime.__version__} installed successfully!')" -``` - -### Option 2: Install from Source (Development with Virtual Environment) - -```bash -# Clone the repository -git clone https://github.com/fireflyframework/fireflyframework-rule-engine.git -cd fireflyframework-rule-engine/python-runtime - -# Create virtual environment -python3 -m venv firefly-env -source firefly-env/bin/activate - -# Install in development mode -pip install -e . -``` - -### Option 3: Install from Package (Production) - -```bash -# Install from PyPI (when published) -pip install firefly-rule-engine-runtime - -# Or install from wheel file -pip install firefly_rule_engine_runtime-1.0.0-py3-none-any.whl -``` - -### Option 4: Install Dependencies Only - -If you want to include the runtime files directly in your project: - -```bash -# Install required dependencies -pip install -r requirements.txt -``` - -### Option 5: Build and Install from Source - -```bash -# Clone and build -git clone https://github.com/fireflyframework/fireflyframework-rule-engine.git -cd fireflyframework-rule-engine/python-runtime - -# Build wheel -python setup.py bdist_wheel - -# Install the built wheel -pip install dist/firefly_runtime-1.0.0-py3-none-any.whl -``` - -### Verify Installation - -```bash -# Check if firefly_runtime is installed -python -c "import firefly_runtime; print(f'Firefly Runtime v{firefly_runtime.__version__} installed successfully!')" - -# Test basic functionality -python -c "from firefly_runtime import *; print('All functions imported successfully!')" -``` - -## 📦 Dependencies - -The runtime requires the following Python packages: - -- `requests>=2.31.0` - For REST API functions -- `cryptography>=41.0.0` - For security/encryption functions -- `urllib3>=2.0.0` - Enhanced HTTP client with retry capabilities - -**Optional dependencies:** - -- `python-dateutil>=2.8.0` - For accurate month/year arithmetic in date functions (`firefly_dateadd`, `firefly_datediff`). Without it, month/year operations use approximate day-based calculations. - -## 🔧 Usage - -### Import Statement - -All compiled Python rules from the Firefly Framework Rule Engine start with: - -```python -from firefly_runtime import * -``` - -This imports all the necessary functions, constants, and utilities needed for rule execution. - -### Basic Usage - -```python -from firefly_runtime import * - -# Initialize constants dictionary (required) -constants = {} - -# Your compiled rule function -def my_rule(context): - # Rule logic here - return {'result': 'success'} - -# Execute the rule -context = {'input_value': 100} -result = my_rule(context) -print(result) -``` - -### Interactive Execution - -The runtime provides utilities for interactive rule execution: - -```python -from firefly_runtime import * - -# Initialize constants -constants = {} - -def my_rule(context): - if context.get('score', 0) > 80: - context['result'] = 'passed' - else: - context['result'] = 'failed' - return {'result': context.get('result')} - -# Interactive execution with full UI -if __name__ == "__main__": - # Print header - print_firefly_header("My Test Rule", "A simple test rule", "1.0") - - # Collect inputs - input_definitions = { - 'score': 'number', - 'name': 'text' - } - context = collect_inputs(input_definitions) - - # Execute rule - print("\n🚀 Executing rule...") - result = my_rule(context) - - # Print results - print_execution_results(result) - print_firefly_footer() -``` - -### Constants Configuration - -```python -from firefly_runtime import * - -# Initialize constants -constants = { - 'MIN_SCORE': 650, - 'MAX_AMOUNT': 100000 -} - -# Interactive constant configuration -constants_need_config = ['INTEREST_RATE', 'PROCESSING_FEE'] -constants_values = configure_constants_interactively(constants_need_config) -constants.update(constants_values) -``` - -## 🛠️ Available Functions - -### Core Functions -- `get_nested_value()` - Access nested dictionary values -- `get_indexed_value()` - Access list/array values by index -- `is_empty()` - Check if value is empty -- `list_remove()` - Remove items from lists - -### Financial Functions -- `firefly_calculate_loan_payment()` - Calculate loan payments -- `firefly_calculate_compound_interest()` - Calculate compound interest -- `firefly_debt_to_income_ratio()` - Calculate debt-to-income ratio -- `firefly_credit_utilization()` - Calculate credit utilization -- `firefly_loan_to_value()` - Calculate loan-to-value ratio - -### Validation Functions -- `firefly_is_valid_credit_score()` - Validate credit scores -- `firefly_is_valid_ssn()` - Validate Social Security Numbers -- `firefly_is_valid_account()` - Validate account numbers -- `firefly_validate_email()` - Validate email addresses -- `firefly_validate_phone()` - Validate phone numbers - -### Utility Functions -- `firefly_format_currency()` - Format currency values -- `firefly_format_percentage()` - Format percentage values -- `firefly_generate_account_number()` - Generate account numbers -- `firefly_calculate_age()` - Calculate age from birthdate - -### REST API Functions -- `firefly_rest_get()` - HTTP GET requests -- `firefly_rest_post()` - HTTP POST requests -- `firefly_rest_put()` - HTTP PUT requests -- `firefly_rest_delete()` - HTTP DELETE requests - -### JSON Functions -- `firefly_json_get()` - Extract values from JSON -- `firefly_json_exists()` - Check if JSON path exists -- `firefly_json_size()` - Get JSON array/object size - -### Security Functions -- `firefly_encrypt()` - Encrypt sensitive data (requires key configuration via `configure_encryption_key()`) -- `firefly_decrypt()` - Decrypt sensitive data (requires key configuration via `configure_encryption_key()`) -- `firefly_mask_data()` - Mask sensitive information -- `hash_data()` - Hash data with SHA-256 or SHA-512 (MD5 is not supported) -- `verify_hash()` - Timing-safe hash verification - -### Interactive Functions -- `get_user_input()` - Get user input with type conversion -- `collect_inputs()` - Collect multiple inputs -- `configure_constants_interactively()` - Configure constants -- `print_firefly_header()` - Print rule header -- `print_execution_results()` - Print formatted results -- `print_firefly_footer()` - Print rule footer -- `execute_rule_interactively()` - Full interactive execution - -## ⚙️ Configuration - -```python -from firefly_runtime import configure - -# Configure runtime settings -configure( - rest_timeout=60, - currency_symbol='€', - date_format='%d/%m/%Y', - decimal_places=4, - audit_enabled=True, - logging_level='DEBUG' -) -``` - -## 📝 Examples - -### Simple Rule Execution - -```python -from firefly_runtime import * - -constants = {} - -def credit_check(context): - score = context.get('credit_score', 0) - if score >= 750: - context['decision'] = 'APPROVED' - context['rate'] = 3.5 - elif score >= 650: - context['decision'] = 'APPROVED' - context['rate'] = 5.5 - else: - context['decision'] = 'DECLINED' - context['rate'] = None - - return { - 'decision': context.get('decision'), - 'rate': context.get('rate') - } - -# Execute -result = credit_check({'credit_score': 720}) -print(result) # {'decision': 'APPROVED', 'rate': 5.5} -``` - -### Complex Business Rule - -```python -from firefly_runtime import * - -constants = { - 'MIN_CREDIT_SCORE': 650, - 'MAX_DEBT_RATIO': 0.4, - 'MIN_INCOME': 50000 -} - -def loan_approval(context): - # Validation - if not firefly_is_positive(context.get('income', 0)): - return {'decision': 'DECLINED', 'reason': 'Invalid income'} - - # Business logic - credit_score = context.get('credit_score', 0) - debt_ratio = firefly_debt_to_income_ratio( - context.get('monthly_debt', 0), - context.get('monthly_income', 0) - ) - - if (credit_score >= constants['MIN_CREDIT_SCORE'] and - debt_ratio <= constants['MAX_DEBT_RATIO'] and - context.get('income', 0) >= constants['MIN_INCOME']): - - context['decision'] = 'APPROVED' - context['rate'] = firefly_calculate_rate(credit_score) - else: - context['decision'] = 'DECLINED' - context['reason'] = 'Does not meet criteria' - - return { - 'decision': context.get('decision'), - 'rate': context.get('rate'), - 'reason': context.get('reason') - } -``` - -## 📄 License - -Copyright 2024-2026 Firefly Software Foundation - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/python-runtime/examples/compiled-b2b-credit-scoring.py b/python-runtime/examples/compiled-b2b-credit-scoring.py deleted file mode 100644 index edd0c4d..0000000 --- a/python-runtime/examples/compiled-b2b-credit-scoring.py +++ /dev/null @@ -1,135 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -# -# Copyright 2024-2026 Firefly Software Foundation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Generated by Firefly Rule Engine Python Compiler -# Made with ❤️ by Firefly Software Foundation -# Compilation Date: 2025-09-15T14:24:16.037726+02:00 -# -# Rule: B2B Credit Scoring Platform -# Description: Comprehensive business credit assessment using multiple data sources -# Version: 1.0.0 -# - -from firefly_runtime import * - - -def b2b_credit_scoring(context): - """ - Rule: B2B Credit Scoring Platform - Comprehensive business credit assessment using multiple data sources - - Args: - context (dict): Execution context with input variables - - Returns: - dict: Output variables - """ - # Initialize constants from database or default values - # NOTE: Constants marked as 'None' need to be configured in the database - # or updated manually before execution - constants = {} - constants['MIN_BUSINESS_CREDIT_SCORE'] = 650 # Default value - constants['EXCELLENT_CREDIT_THRESHOLD'] = 750 # Default value - constants['MAX_DEBT_TO_INCOME_RATIO'] = 0.4 # Default value - constants['MIN_DEBT_SERVICE_COVERAGE'] = 1.25 # Default value - constants['MAX_LOAN_TO_VALUE_RATIO'] = 0.8 # Default value - constants['MIN_YEARS_IN_BUSINESS'] = 2 # Default value - constants['MIN_ANNUAL_REVENUE'] = 100000 # Default value - - # Sub-rule: Data Validation and Preparation - if bool(firefly_is_not_empty(context.get('businessId', ''))) and bool(firefly_is_positive(context.get('requestedAmount', 0))) and bool(firefly_is_positive(context.get('annualRevenue', ''))) and bool(firefly_is_valid_credit_score(context.get('businessCreditScore', 0))) and bool(firefly_is_valid_credit_score(context.get('ownerCreditScore', 0))): - context['monthly_revenue_valid'] = firefly_is_positive(context.get('monthlyRevenue', '')) - context['monthly_expenses_valid'] = firefly_is_positive(context.get('monthlyExpenses', '')) - context['existing_debt_valid'] = firefly_is_not_null(context.get('existingDebt', 0)) - context['has_complete_financial_data'] = ((context.get('monthly_revenue_valid', '') and context.get('monthly_expenses_valid', '')) and context.get('existing_debt_valid', 0)) - context['debt_to_income_ratio'] = (context.get('monthlyDebtPayments', 0) / context.get('monthlyRevenue', '')) - context['data_validation_complete'] = context.get('has_complete_financial_data', '') - if bool(context.get('data_validation_complete', '')): - context['validation_status'] = "PASSED" - if (not bool(context.get('data_validation_complete', ''))): - context['validation_status'] = "FAILED" - else: - context['data_validation_complete'] = False - context['validation_status'] = "FAILED" - - # Return output variables - return { - 'validation_status': context.get('validation_status'), - 'data_validation_complete': context.get('data_validation_complete'), - 'debt_to_income_ratio': context.get('debt_to_income_ratio'), - 'has_complete_financial_data': context.get('has_complete_financial_data'), - } - - -def test_b2b_credit_scoring(): - """Test the compiled B2B credit scoring rule with sample data""" - print("🔥 Testing Compiled B2B Credit Scoring Rule") - print("="*60) - - # Test case 1: Valid business with good credit - print("\n✅ Test Case 1: Valid business with good credit") - context1 = { - 'businessId': 'BIZ123', - 'requestedAmount': 100000, - 'annualRevenue': 500000, - 'businessCreditScore': 750, - 'ownerCreditScore': 780, - 'monthlyRevenue': 41667, # 500k/12 - 'monthlyExpenses': 30000, - 'existingDebt': 50000, - 'monthlyDebtPayments': 2500 - } - - result1 = b2b_credit_scoring(context1) - print(f" Result: {result1}") - - # Test case 2: Invalid business (missing required data) - print("\n❌ Test Case 2: Invalid business (missing required data)") - context2 = { - 'businessId': '', # Empty business ID - 'requestedAmount': 100000, - 'annualRevenue': 500000, - 'businessCreditScore': 750, - 'ownerCreditScore': 780 - } - - result2 = b2b_credit_scoring(context2) - print(f" Result: {result2}") - - # Test case 3: Poor credit scores - print("\n⚠️ Test Case 3: Poor credit scores") - context3 = { - 'businessId': 'BIZ456', - 'requestedAmount': 50000, - 'annualRevenue': 200000, - 'businessCreditScore': 500, # Poor credit - 'ownerCreditScore': 520, # Poor credit - 'monthlyRevenue': 16667, - 'monthlyExpenses': 15000, - 'existingDebt': 30000, - 'monthlyDebtPayments': 1500 - } - - result3 = b2b_credit_scoring(context3) - print(f" Result: {result3}") - - print("\n🎉 All tests completed!") - print("="*60) - - -if __name__ == "__main__": - test_b2b_credit_scoring() diff --git a/python-runtime/examples/python-compilation-example.md b/python-runtime/examples/python-compilation-example.md deleted file mode 100644 index b505d6d..0000000 --- a/python-runtime/examples/python-compilation-example.md +++ /dev/null @@ -1,170 +0,0 @@ -# Python Compilation Example - -This example demonstrates how to use the Firefly Framework Rule Engine Python Compiler to convert YAML DSL rules into executable Python code. - -## Example Rule - -```yaml -name: "Credit Approval Rule" -description: "Determines if a loan application should be approved" -version: "1.0" - -inputs: - creditScore: "number" - annualIncome: "number" - loanAmount: "number" - employmentYears: "number" - -outputs: - approved: "boolean" - reason: "string" - maxLoanAmount: "number" - -rules: - - when: - - creditScore >= 650 - - annualIncome >= 30000 - - loanAmount <= (annualIncome * 4) - - employmentYears >= 2 - then: - - set approved to true - - set reason to "Application approved" - - calculate maxLoanAmount as (annualIncome * 4) - else: - - set approved to false - - set reason to "Application denied - insufficient criteria" - - set maxLoanAmount to 0 -``` - -## Generated Python Code - -```python -from firefly_runtime import * - -def credit_approval_rule(context): - """ - Credit Approval Rule - Determines if a loan application should be approved - Version: 1.0 - """ - - # Rule 1 - if (context.get('creditScore', 0) >= 650 and - context.get('annualIncome', 0) >= 30000 and - context.get('loanAmount', 0) <= (context.get('annualIncome', 0) * 4) and - context.get('employmentYears', 0) >= 2): - - context['approved'] = True - context['reason'] = "Application approved" - context['maxLoanAmount'] = (context.get('annualIncome', 0) * 4) - else: - context['approved'] = False - context['reason'] = "Application denied - insufficient criteria" - context['maxLoanAmount'] = 0 - - return { - 'approved': context.get('approved'), - 'reason': context.get('reason'), - 'maxLoanAmount': context.get('maxLoanAmount') - } -``` - -## Usage - -### Java Side (Compilation) - -```java -@Autowired -private PythonCompilationService pythonCompilationService; - -// Compile the rule -String yamlDsl = "..."; // Your YAML DSL -PythonCompiledRule compiledRule = pythonCompilationService.compileRule(yamlDsl, "credit_approval"); - -// Get the generated Python code -String pythonCode = compiledRule.getPythonCode(); - -// Save to file or execute -Files.write(Paths.get("credit_approval_rule.py"), pythonCode.getBytes()); -``` - -### Python Side (Execution) - -```python -# Import the generated rule -from credit_approval_rule import credit_approval_rule - -# Prepare input data -input_data = { - 'creditScore': 720, - 'annualIncome': 75000, - 'loanAmount': 250000, - 'employmentYears': 5 -} - -# Execute the rule -result = credit_approval_rule(input_data) - -print(f"Approved: {result['approved']}") -print(f"Reason: {result['reason']}") -print(f"Max Loan Amount: ${result['maxLoanAmount']:,}") -``` - -## Advanced Features - -### REST API Calls - -```yaml -rules: - - when: - - true - then: - - calculate creditBureauData as rest_get("https://api.creditbureau.com/score", {"Authorization": "Bearer token"}) - - set externalScore to json_get(creditBureauData, "score") -``` - -Generated Python: -```python -context['creditBureauData'] = firefly_rest_call("GET", "https://api.creditbureau.com/score", None, {"Authorization": "Bearer token"}) -context['externalScore'] = firefly_json_get(context.get('creditBureauData'), "score") -``` - -### Financial Functions - -```yaml -rules: - - when: - - true - then: - - calculate monthlyPayment as loan_payment(loanAmount, 0.05, 360) - - calculate debtToIncomeRatio as (monthlyPayment * 12) / annualIncome -``` - -Generated Python: -```python -context['monthlyPayment'] = firefly_loan_payment(context.get('loanAmount', 0), 0.05, 360) -context['debtToIncomeRatio'] = (context.get('monthlyPayment', 0) * 12) / context.get('annualIncome', 0) -``` - -## Benefits - -1. **Performance**: Compiled Python code runs faster than interpreted DSL -2. **Portability**: Rules can run in Python environments without Java -3. **Integration**: Easy to integrate with Python ML/AI pipelines -4. **Debugging**: Generated Python code is readable and debuggable -5. **Scalability**: Can be deployed to serverless Python functions - -## Runtime Dependencies - -The generated Python code requires the `firefly_runtime` package: - -```bash -pip install -r python-runtime/requirements.txt -``` - -Or install the package: - -```bash -cd python-runtime -pip install . -``` diff --git a/python-runtime/firefly_runtime/__init__.py b/python-runtime/firefly_runtime/__init__.py deleted file mode 100644 index a705dab..0000000 --- a/python-runtime/firefly_runtime/__init__.py +++ /dev/null @@ -1,208 +0,0 @@ -#!/usr/bin/env python3 -""" -Firefly Rule Engine Python Runtime Library - -This module provides all the built-in functions and utilities needed -to execute compiled Python rules from the Firefly Rule Engine. - -Copyright 2024-2026 Firefly Software Foundation -Licensed under the Apache License, Version 2.0 -""" - -import math -import re -import statistics -import datetime -import json -import requests -import hashlib -import uuid -from typing import Any, Dict, List, Optional, Union -from decimal import Decimal, ROUND_HALF_UP - -# Version information -__version__ = "1.0.0" -__author__ = "Firefly Software Foundation" - -# Import all modules to make them available -from .core import * -from .financial import * -from .validation import * -from .utilities import * -from .rest_client import * -from .json_utils import * -from .security import * -from .logging_utils import * -from .interactive import * -from .string_functions import * -from .datetime_functions import * - -# Export all public functions -__all__ = [ - # Core utilities - 'get_nested_value', - 'get_indexed_value', - 'is_empty', - 'list_remove', - 'circuit_breaker_action', - 'safe_divide', - 'coerce_to_number', - 'coerce_to_boolean', - - # Financial functions - 'firefly_calculate_loan_payment', - 'firefly_calculate_compound_interest', - 'firefly_calculate_amortization', - 'firefly_debt_to_income_ratio', - 'firefly_credit_utilization', - 'firefly_loan_to_value', - 'firefly_calculate_apr', - 'firefly_calculate_credit_score', - 'firefly_calculate_risk_score', - 'firefly_payment_history_score', - 'firefly_calculate_rate', - - # Validation functions - 'firefly_is_valid_credit_score', - 'firefly_is_valid_ssn', - 'firefly_is_valid_account', - 'firefly_is_valid_routing', - 'firefly_is_business_day', - 'firefly_age_meets_requirement', - 'firefly_validate_email', - 'firefly_validate_phone', - - # Basic validation functions - 'firefly_is_positive', - 'firefly_is_negative', - 'firefly_is_zero', - 'firefly_is_non_zero', - 'firefly_is_null', - 'firefly_is_not_null', - 'firefly_is_empty', - 'firefly_is_not_empty', - 'firefly_is_numeric', - 'firefly_is_not_numeric', - 'firefly_is_email', - 'firefly_is_phone', - 'firefly_is_date', - 'firefly_is_percentage', - 'firefly_is_currency', - 'firefly_is_credit_score', - 'firefly_is_ssn', - 'firefly_is_account_number', - 'firefly_is_routing_number', - 'firefly_is_weekend', - 'firefly_age_at_least', - 'firefly_age_less_than', - - # Utility functions - 'firefly_format_currency', - 'firefly_format_percentage', - 'firefly_generate_account_number', - 'firefly_generate_transaction_id', - 'firefly_distance_between', - 'firefly_is_valid', - 'firefly_in_range', - 'firefly_substring', - 'firefly_format_date', - 'firefly_calculate_age', - - # REST API functions - 'firefly_rest_get', - 'firefly_rest_post', - 'firefly_rest_put', - 'firefly_rest_delete', - 'firefly_rest_patch', - 'firefly_rest_call', - - # JSON functions - 'firefly_json_get', - 'firefly_json_exists', - 'firefly_json_size', - 'firefly_json_type', - 'json_path_get', - - # Security functions - 'firefly_encrypt', - 'firefly_decrypt', - 'firefly_mask_data', - - # Logging functions - 'firefly_audit', - 'firefly_audit_log', - 'firefly_send_notification', - 'firefly_log', - - # Interactive functions - 'get_user_input', - 'collect_inputs', - 'configure_constants_interactively', - 'print_firefly_header', - 'print_execution_results', - 'print_firefly_footer', - 'execute_rule_interactively', - - # Additional core functions - 'firefly_average', - 'firefly_between', - 'firefly_not_between', - 'firefly_exists', - 'firefly_not_exists', - 'firefly_size', - 'firefly_count', - 'firefly_first', - 'firefly_last', - 'firefly_is_number', - 'firefly_is_string', - 'firefly_is_boolean', - 'firefly_is_list', - 'firefly_tonumber', - 'firefly_tostring', - 'firefly_toboolean', - - # String functions - 'firefly_upper', - 'firefly_lower', - 'firefly_trim', - 'firefly_length', - 'firefly_contains', - 'firefly_startswith', - 'firefly_endswith', - 'firefly_replace', - 'firefly_matches', - 'firefly_not_matches', - 'firefly_length_equals', - 'firefly_length_greater_than', - 'firefly_length_less_than', - - # Date/time functions - 'firefly_now', - 'firefly_today', - 'firefly_dateadd', - 'firefly_datediff', - 'firefly_time_hour', - - # Additional financial functions - 'firefly_calculate_debt_ratio', - 'firefly_calculate_ltv', - 'firefly_calculate_payment_schedule', -] - -# Global configuration -CONFIG = { - 'rest_timeout': 30, - 'currency_symbol': '$', - 'date_format': '%Y-%m-%d', - 'decimal_places': 2, - 'audit_enabled': True, - 'logging_level': 'INFO' -} - -def configure(**kwargs): - """Configure the runtime library settings""" - CONFIG.update(kwargs) - -def get_version(): - """Get the runtime library version""" - return __version__ diff --git a/python-runtime/firefly_runtime/core.py b/python-runtime/firefly_runtime/core.py deleted file mode 100644 index 144d215..0000000 --- a/python-runtime/firefly_runtime/core.py +++ /dev/null @@ -1,317 +0,0 @@ -#!/usr/bin/env python3 -""" -Core utilities for the Firefly Rule Engine Python Runtime - -This module provides essential utility functions for variable access, -data manipulation, and control flow operations. -""" - -from typing import Any, Dict, List, Optional, Union - - -def get_nested_value(context: Dict[str, Any], path: str) -> Any: - """ - Get a nested value from a context dictionary using dot notation. - - Args: - context: The context dictionary - path: Dot-separated path (e.g., "user.profile.name") - - Returns: - The value at the specified path, or None if not found - """ - if not path: - return None - - keys = path.split('.') - current = context - - for key in keys: - if isinstance(current, dict) and key in current: - current = current[key] - else: - return None - - return current - - -def get_indexed_value(context: Dict[str, Any], variable_name: str, index: int) -> Any: - """ - Get a value from a list variable by index. - - Args: - context: The context dictionary - variable_name: Name of the list variable - index: Index to access - - Returns: - The value at the specified index, or None if not found - """ - value = context.get(variable_name) - - if isinstance(value, (list, tuple)) and 0 <= index < len(value): - return value[index] - - return None - - -def is_empty(value: Any) -> bool: - """ - Check if a value is empty (None, empty string, empty list, etc.). - - Args: - value: The value to check - - Returns: - True if the value is considered empty, False otherwise - """ - if value is None: - return True - - if isinstance(value, (str, list, dict, tuple, set)): - return len(value) == 0 - - return False - - -def list_remove(lst: List[Any], value: Any) -> List[Any]: - """ - Remove all occurrences of a value from a list. - - Args: - lst: The list to modify - value: The value to remove - - Returns: - The modified list - """ - if not isinstance(lst, list): - return lst - - return [item for item in lst if item != value] - - -def circuit_breaker_action(action: str, threshold: Union[int, float]) -> bool: - """ - Execute a circuit breaker action. - - Args: - action: The action to perform - threshold: The threshold value - - Returns: - True if the action was successful, False otherwise - """ - # This is a placeholder implementation - # In a real system, this would integrate with a circuit breaker library - print(f"Circuit breaker action: {action} with threshold: {threshold}") - return True - - -def safe_divide(numerator: Union[int, float], denominator: Union[int, float], - default: Union[int, float] = 0) -> Union[int, float]: - """ - Safely divide two numbers, returning a default value if division by zero. - - Args: - numerator: The numerator - denominator: The denominator - default: Default value to return if division by zero - - Returns: - The result of the division or the default value - """ - try: - if denominator == 0: - return default - return numerator / denominator - except (TypeError, ZeroDivisionError): - return default - - -def safe_convert_to_number(value: Any, default: Union[int, float] = 0) -> Union[int, float]: - """ - Safely convert a value to a number. - - Args: - value: The value to convert - default: Default value if conversion fails - - Returns: - The converted number or the default value - """ - if isinstance(value, (int, float)): - return value - - if isinstance(value, str): - try: - # Try integer first - if '.' not in value: - return int(value) - else: - return float(value) - except ValueError: - return default - - return default - - -def coerce_to_boolean(value: Any) -> bool: - """ - Convert a value to a boolean using rule engine semantics. - - Args: - value: The value to convert - - Returns: - The boolean representation of the value - """ - if isinstance(value, bool): - return value - - if value is None: - return False - - if isinstance(value, (int, float)): - return value != 0 - - if isinstance(value, str): - return value.lower() in ('true', 'yes', '1', 'on', 'enabled') - - if isinstance(value, (list, dict, tuple, set)): - return len(value) > 0 - - return bool(value) - - -# Aliases for backward compatibility -coerce_to_number = safe_convert_to_number - - -def deep_merge_dicts(dict1: Dict[str, Any], dict2: Dict[str, Any]) -> Dict[str, Any]: - """ - Deep merge two dictionaries. - - Args: - dict1: First dictionary - dict2: Second dictionary (takes precedence) - - Returns: - Merged dictionary - """ - result = dict1.copy() - - for key, value in dict2.items(): - if key in result and isinstance(result[key], dict) and isinstance(value, dict): - result[key] = deep_merge_dicts(result[key], value) - else: - result[key] = value - - return result - - -# Additional utility functions for DSL support - -def firefly_average(*args) -> float: - """Calculate the average of numeric values.""" - numbers = [] - for arg in args: - if isinstance(arg, (list, tuple)): - numbers.extend([coerce_to_number(x) for x in arg]) - else: - numbers.append(coerce_to_number(arg)) - - if not numbers: - return 0.0 - return sum(numbers) / len(numbers) - - -def firefly_between(value: Any, min_val: Any, max_val: Any) -> bool: - """Check if value is between min and max (inclusive).""" - try: - val = coerce_to_number(value) - min_num = coerce_to_number(min_val) - max_num = coerce_to_number(max_val) - return min_num <= val <= max_num - except (ValueError, TypeError): - return False - - -def firefly_not_between(value: Any, min_val: Any, max_val: Any) -> bool: - """Check if value is NOT between min and max.""" - return not firefly_between(value, min_val, max_val) - - -def firefly_exists(value: Any) -> bool: - """Check if value exists (not None).""" - return value is not None - - -def firefly_not_exists(value: Any) -> bool: - """Check if value does not exist (is None).""" - return value is None - - -def firefly_size(value: Any) -> int: - """Get the size/length of a value.""" - if hasattr(value, '__len__'): - return len(value) - return 0 - - -def firefly_count(value: Any) -> int: - """Alias for firefly_size.""" - return firefly_size(value) - - -def firefly_first(value: Any) -> Any: - """Get the first element of a list/sequence.""" - if isinstance(value, (list, tuple)) and len(value) > 0: - return value[0] - return None - - -def firefly_last(value: Any) -> Any: - """Get the last element of a list/sequence.""" - if isinstance(value, (list, tuple)) and len(value) > 0: - return value[-1] - return None - - -# Type checking functions -def firefly_is_number(value: Any) -> bool: - """Check if value is a number.""" - return isinstance(value, (int, float)) - - -def firefly_is_string(value: Any) -> bool: - """Check if value is a string.""" - return isinstance(value, str) - - -def firefly_is_boolean(value: Any) -> bool: - """Check if value is a boolean.""" - return isinstance(value, bool) - - -def firefly_is_list(value: Any) -> bool: - """Check if value is a list.""" - return isinstance(value, list) - - -# Type conversion functions -def firefly_tonumber(value: Any, default: Union[int, float] = 0) -> Union[int, float]: - """Convert value to number.""" - return coerce_to_number(value, default) - - -def firefly_tostring(value: Any) -> str: - """Convert value to string.""" - if value is None: - return "" - return str(value) - - -def firefly_toboolean(value: Any) -> bool: - """Convert value to boolean.""" - return coerce_to_boolean(value) diff --git a/python-runtime/firefly_runtime/datetime_functions.py b/python-runtime/firefly_runtime/datetime_functions.py deleted file mode 100644 index 77e5091..0000000 --- a/python-runtime/firefly_runtime/datetime_functions.py +++ /dev/null @@ -1,122 +0,0 @@ -#!/usr/bin/env python3 -""" -Date and time functions for the Firefly Rule Engine Python Runtime -""" - -from datetime import datetime, timedelta -from typing import Any, Union - -try: - from dateutil.relativedelta import relativedelta - _HAS_DATEUTIL = True -except ImportError: - _HAS_DATEUTIL = False - - -def firefly_now() -> datetime: - """Get current date and time.""" - return datetime.now() - - -def firefly_today() -> datetime: - """Get current date (midnight).""" - return datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) - - -def firefly_dateadd(date_value: Any, amount: Union[int, float], unit: str) -> datetime: - """Add time to a date.""" - try: - if isinstance(date_value, str): - base_date = datetime.fromisoformat(date_value.replace('Z', '+00:00')) - elif isinstance(date_value, datetime): - base_date = date_value - else: - base_date = datetime.now() - - amount_int = int(amount) - unit_lower = unit.lower() - - if unit_lower in ['day', 'days']: - return base_date + timedelta(days=amount_int) - elif unit_lower in ['month', 'months']: - if _HAS_DATEUTIL: - return base_date + relativedelta(months=amount_int) - # Fallback: approximate month addition - return base_date + timedelta(days=amount_int * 30) - elif unit_lower in ['year', 'years']: - if _HAS_DATEUTIL: - return base_date + relativedelta(years=amount_int) - # Fallback: approximate year addition - return base_date + timedelta(days=amount_int * 365) - elif unit_lower in ['hour', 'hours']: - return base_date + timedelta(hours=amount_int) - elif unit_lower in ['minute', 'minutes']: - return base_date + timedelta(minutes=amount_int) - elif unit_lower in ['second', 'seconds']: - return base_date + timedelta(seconds=amount_int) - else: - return base_date - - except (ValueError, TypeError): - return datetime.now() - - -def firefly_datediff(start_date: Any, end_date: Any, unit: str) -> int: - """Calculate difference between two dates.""" - try: - if isinstance(start_date, str): - start = datetime.fromisoformat(start_date.replace('Z', '+00:00')) - elif isinstance(start_date, datetime): - start = start_date - else: - start = datetime.now() - - if isinstance(end_date, str): - end = datetime.fromisoformat(end_date.replace('Z', '+00:00')) - elif isinstance(end_date, datetime): - end = end_date - else: - end = datetime.now() - - diff = end - start - unit_lower = unit.lower() - - if unit_lower in ['day', 'days']: - return diff.days - elif unit_lower in ['hour', 'hours']: - return int(diff.total_seconds() / 3600) - elif unit_lower in ['minute', 'minutes']: - return int(diff.total_seconds() / 60) - elif unit_lower in ['second', 'seconds']: - return int(diff.total_seconds()) - elif unit_lower in ['month', 'months']: - if _HAS_DATEUTIL: - rd = relativedelta(end, start) - return rd.years * 12 + rd.months - return int(diff.days / 30) - elif unit_lower in ['year', 'years']: - if _HAS_DATEUTIL: - rd = relativedelta(end, start) - return rd.years - return int(diff.days / 365) - else: - return diff.days - - except (ValueError, TypeError): - return 0 - - -def firefly_time_hour(timestamp: Any) -> int: - """Extract hour from timestamp.""" - try: - if isinstance(timestamp, str): - dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00')) - elif isinstance(timestamp, datetime): - dt = timestamp - else: - dt = datetime.now() - - return dt.hour - - except (ValueError, TypeError): - return 0 diff --git a/python-runtime/firefly_runtime/financial.py b/python-runtime/firefly_runtime/financial.py deleted file mode 100644 index e90849d..0000000 --- a/python-runtime/firefly_runtime/financial.py +++ /dev/null @@ -1,424 +0,0 @@ -#!/usr/bin/env python3 -""" -Financial calculation functions for the Firefly Rule Engine Python Runtime - -This module provides comprehensive financial calculation functions -equivalent to those in the Java implementation. -""" - -import math -from typing import Union, List, Dict, Any -from decimal import Decimal, ROUND_HALF_UP - - -def firefly_calculate_loan_payment(principal: Union[int, float], - annual_rate: Union[int, float], - term_months: int) -> float: - """ - Calculate monthly loan payment using the standard amortization formula. - - Args: - principal: Loan principal amount - annual_rate: Annual interest rate (as percentage, e.g., 5.5 for 5.5%) - term_months: Loan term in months - - Returns: - Monthly payment amount - """ - if principal <= 0 or term_months <= 0: - return 0.0 - - if annual_rate <= 0: - return principal / term_months - - monthly_rate = annual_rate / 100 / 12 - payment = principal * (monthly_rate * (1 + monthly_rate) ** term_months) / \ - ((1 + monthly_rate) ** term_months - 1) - - return round(payment, 2) - - -def firefly_calculate_compound_interest(principal: Union[int, float], - annual_rate: Union[int, float], - years: Union[int, float], - compounds_per_year: int = 12) -> float: - """ - Calculate compound interest. - - Args: - principal: Initial principal amount - annual_rate: Annual interest rate (as percentage) - years: Number of years - compounds_per_year: Number of times interest compounds per year - - Returns: - Final amount after compound interest - """ - if principal <= 0 or years <= 0: - return principal - - if annual_rate <= 0: - return principal - - rate = annual_rate / 100 - amount = principal * (1 + rate / compounds_per_year) ** (compounds_per_year * years) - - return round(amount, 2) - - -def firefly_calculate_amortization(principal: Union[int, float], - annual_rate: Union[int, float], - term_months: int, - payment_number: int) -> Dict[str, float]: - """ - Calculate amortization details for a specific payment. - - Args: - principal: Loan principal amount - annual_rate: Annual interest rate (as percentage) - term_months: Loan term in months - payment_number: Payment number (1-based) - - Returns: - Dictionary with payment details - """ - if payment_number < 1 or payment_number > term_months: - return {"principal": 0.0, "interest": 0.0, "balance": 0.0} - - monthly_payment = firefly_calculate_loan_payment(principal, annual_rate, term_months) - monthly_rate = annual_rate / 100 / 12 - - remaining_balance = principal - - for i in range(1, payment_number + 1): - interest_payment = remaining_balance * monthly_rate - principal_payment = monthly_payment - interest_payment - remaining_balance -= principal_payment - - return { - "principal": round(principal_payment, 2), - "interest": round(interest_payment, 2), - "balance": round(max(0, remaining_balance), 2) - } - - -def firefly_debt_to_income_ratio(monthly_debt: Union[int, float], - monthly_income: Union[int, float]) -> float: - """ - Calculate debt-to-income ratio. - - Args: - monthly_debt: Total monthly debt payments - monthly_income: Total monthly income - - Returns: - Debt-to-income ratio as a percentage - """ - if monthly_income <= 0: - return 100.0 - - ratio = (monthly_debt / monthly_income) * 100 - return round(ratio, 2) - - -def firefly_credit_utilization(current_balance: Union[int, float], - credit_limit: Union[int, float]) -> float: - """ - Calculate credit utilization ratio. - - Args: - current_balance: Current credit card balance - credit_limit: Credit card limit - - Returns: - Credit utilization ratio as a percentage - """ - if credit_limit <= 0: - return 100.0 - - utilization = (current_balance / credit_limit) * 100 - return round(min(100.0, max(0.0, utilization)), 2) - - -def firefly_loan_to_value(loan_amount: Union[int, float], - property_value: Union[int, float]) -> float: - """ - Calculate loan-to-value ratio. - - Args: - loan_amount: Loan amount - property_value: Property value - - Returns: - Loan-to-value ratio as a percentage - """ - if property_value <= 0: - return 100.0 - - ltv = (loan_amount / property_value) * 100 - return round(ltv, 2) - - -def firefly_calculate_apr(loan_amount: Union[int, float], - total_cost: Union[int, float], - term_years: Union[int, float]) -> float: - """ - Calculate Annual Percentage Rate (APR). - - Args: - loan_amount: Principal loan amount - total_cost: Total cost of the loan - term_years: Loan term in years - - Returns: - APR as a percentage - """ - if loan_amount <= 0 or term_years <= 0: - return 0.0 - - total_interest = total_cost - loan_amount - apr = (total_interest / loan_amount / term_years) * 100 - - return round(apr, 2) - - -def firefly_calculate_credit_score(payment_history: float, - credit_utilization: float, - credit_history_length: int, - credit_mix: int, - new_credit: int) -> int: - """ - Calculate a simplified credit score based on key factors. - - Args: - payment_history: Payment history score (0-100) - credit_utilization: Credit utilization percentage - credit_history_length: Length of credit history in months - credit_mix: Number of different credit types - new_credit: Number of recent credit inquiries - - Returns: - Calculated credit score (300-850) - """ - # Simplified credit score calculation - base_score = 300 - - # Payment history (35% weight) - payment_score = (payment_history / 100) * 350 * 0.35 - - # Credit utilization (30% weight) - lower is better - utilization_score = max(0, (100 - credit_utilization) / 100) * 350 * 0.30 - - # Credit history length (15% weight) - history_score = min(1.0, credit_history_length / 120) * 350 * 0.15 - - # Credit mix (10% weight) - mix_score = min(1.0, credit_mix / 5) * 350 * 0.10 - - # New credit (10% weight) - fewer inquiries is better - new_credit_score = max(0, (10 - new_credit) / 10) * 350 * 0.10 - - total_score = base_score + payment_score + utilization_score + history_score + mix_score + new_credit_score - - return int(round(min(850, max(300, total_score)))) - - -def firefly_calculate_risk_score(credit_score: int, - debt_to_income: float, - employment_years: Union[int, float], - down_payment_percent: float) -> int: - """ - Calculate a risk score for lending decisions. - - Args: - credit_score: Credit score (300-850) - debt_to_income: Debt-to-income ratio percentage - employment_years: Years of employment - down_payment_percent: Down payment as percentage of purchase price - - Returns: - Risk score (0-100, lower is better) - """ - risk_score = 0 - - # Credit score factor (40% weight) - if credit_score >= 750: - credit_risk = 0 - elif credit_score >= 700: - credit_risk = 10 - elif credit_score >= 650: - credit_risk = 25 - elif credit_score >= 600: - credit_risk = 40 - else: - credit_risk = 60 - - risk_score += credit_risk * 0.4 - - # Debt-to-income factor (30% weight) - if debt_to_income <= 20: - dti_risk = 0 - elif debt_to_income <= 30: - dti_risk = 15 - elif debt_to_income <= 40: - dti_risk = 30 - else: - dti_risk = 50 - - risk_score += dti_risk * 0.3 - - # Employment stability factor (20% weight) - if employment_years >= 5: - employment_risk = 0 - elif employment_years >= 2: - employment_risk = 10 - elif employment_years >= 1: - employment_risk = 20 - else: - employment_risk = 35 - - risk_score += employment_risk * 0.2 - - # Down payment factor (10% weight) - if down_payment_percent >= 20: - down_payment_risk = 0 - elif down_payment_percent >= 10: - down_payment_risk = 10 - elif down_payment_percent >= 5: - down_payment_risk = 20 - else: - down_payment_risk = 30 - - risk_score += down_payment_risk * 0.1 - - return int(round(min(100, max(0, risk_score)))) - - -def firefly_payment_history_score(on_time_payments: int, - total_payments: int, - late_payments_30: int = 0, - late_payments_60: int = 0, - late_payments_90: int = 0) -> float: - """ - Calculate payment history score. - - Args: - on_time_payments: Number of on-time payments - total_payments: Total number of payments - late_payments_30: Number of 30-day late payments - late_payments_60: Number of 60-day late payments - late_payments_90: Number of 90+ day late payments - - Returns: - Payment history score (0-100) - """ - if total_payments == 0: - return 100.0 - - base_score = (on_time_payments / total_payments) * 100 - - # Penalties for late payments - penalty = (late_payments_30 * 5) + (late_payments_60 * 10) + (late_payments_90 * 20) - - final_score = max(0, base_score - penalty) - - return round(final_score, 2) - - -def firefly_calculate_rate(credit_score: Union[int, float]) -> float: - """ - Calculate interest rate based on credit score. - - Args: - credit_score: Credit score (300-850) - - Returns: - Interest rate as percentage - """ - try: - score = float(credit_score) - - # Rate calculation based on credit score tiers - if score >= 800: - return 3.5 # Excellent credit - elif score >= 750: - return 4.5 # Very good credit - elif score >= 700: - return 5.5 # Good credit - elif score >= 650: - return 7.0 # Fair credit - elif score >= 600: - return 9.0 # Poor credit - else: - return 12.0 # Very poor credit - - except (ValueError, TypeError): - return 12.0 # Default high rate for invalid scores - - -def firefly_calculate_debt_ratio(total_debt: Union[int, float], - total_income: Union[int, float]) -> float: - """ - Calculate debt-to-income ratio (alias for firefly_debt_to_income_ratio). - - Args: - total_debt: Total monthly debt payments - total_income: Total monthly income - - Returns: - Debt-to-income ratio as a percentage - """ - return firefly_debt_to_income_ratio(total_debt, total_income) - - -def firefly_calculate_ltv(loan_amount: Union[int, float], - property_value: Union[int, float]) -> float: - """ - Calculate loan-to-value ratio (alias for firefly_loan_to_value). - - Args: - loan_amount: Loan amount - property_value: Property value - - Returns: - LTV ratio as a percentage - """ - return firefly_loan_to_value(loan_amount, property_value) - - -def firefly_calculate_payment_schedule(principal: Union[int, float], - annual_rate: Union[int, float], - term_months: int) -> List[Dict[str, float]]: - """ - Calculate complete payment schedule for a loan. - - Args: - principal: Loan principal amount - annual_rate: Annual interest rate (as percentage) - term_months: Loan term in months - - Returns: - List of payment details for each month - """ - schedule = [] - remaining_balance = float(principal) - monthly_payment = firefly_calculate_loan_payment(principal, annual_rate, term_months) - monthly_rate = annual_rate / 100 / 12 - - for payment_num in range(1, term_months + 1): - if remaining_balance <= 0: - break - - interest_payment = remaining_balance * monthly_rate - principal_payment = min(monthly_payment - interest_payment, remaining_balance) - remaining_balance -= principal_payment - - schedule.append({ - 'payment_number': payment_num, - 'payment_amount': round(monthly_payment, 2), - 'principal_payment': round(principal_payment, 2), - 'interest_payment': round(interest_payment, 2), - 'remaining_balance': round(max(0, remaining_balance), 2) - }) - - return schedule diff --git a/python-runtime/firefly_runtime/interactive.py b/python-runtime/firefly_runtime/interactive.py deleted file mode 100644 index 5a4330d..0000000 --- a/python-runtime/firefly_runtime/interactive.py +++ /dev/null @@ -1,220 +0,0 @@ -#!/usr/bin/env python3 -""" -Firefly Rule Engine Interactive Utilities - -This module provides utilities for interactive execution of compiled rules, -including user input collection with type conversion and error handling. - -Copyright 2024-2026 Firefly Software Foundation -Licensed under the Apache License, Version 2.0 -""" - -import sys -from typing import Any, Optional, Union - - -_MAX_INPUT_RETRIES = 10 - - -def get_user_input(prompt: str, input_type: str = "text", required: bool = False) -> Optional[Any]: - """ - Helper function to get user input with type conversion and error handling. - - Args: - prompt (str): The prompt to display to the user - input_type (str): Expected type - 'text', 'number', 'boolean' - required (bool): Whether the input is required - - Returns: - The parsed input value or None if not provided and not required - - Raises: - SystemExit: If user cancels with Ctrl+C - """ - for _ in range(_MAX_INPUT_RETRIES): - try: - value = input(prompt).strip() - if not value: - if required: - print("This field is required.") - continue - return None - - # Type conversion - if input_type == "number": - try: - return float(value) if '.' in value else int(value) - except ValueError: - print(f"Invalid number format: {value}") - continue - elif input_type == "boolean": - return value.lower() in ['true', '1', 'yes', 'y'] - else: # text - return value - - except KeyboardInterrupt: - print("\n\nExecution cancelled by user.") - sys.exit(1) - except Exception as e: - print(f"Error reading input: {e}") - continue - - print("Maximum input retries exceeded.") - return None - - -def collect_inputs(input_definitions: dict) -> dict: - """ - Collect multiple inputs based on definitions. - - Args: - input_definitions (dict): Dictionary mapping input names to their types - - Returns: - dict: Dictionary with collected input values - """ - context = {} - - print("📝 Please provide input values:") - for input_name, input_type in input_definitions.items(): - value = get_user_input(f"{input_name} ({input_type}): ", input_type) - if value is not None: - context[input_name] = value - - return context - - -def configure_constants_interactively(constants_need_config: list) -> dict: - """ - Interactively configure constants that need values. - - Args: - constants_need_config (list): List of constant names that need configuration - - Returns: - dict: Dictionary with configured constant values - """ - constants_values = {} - - if not constants_need_config: - return constants_values - - print("⚠️ WARNING: The following constants are not configured:") - for const in constants_need_config: - print(f" - {const}") - print("\nPlease configure these constants in the database or update the code manually.") - print("You can still run the rule, but it may not work correctly.\n") - - # Interactive constant configuration - configure = input("Would you like to configure constants interactively? (y/n): ").lower().strip() - if configure == 'y' or configure == 'yes': - for const in constants_need_config: - value = input(f"Enter value for {const}: ").strip() - try: - # Try to parse as number first - if '.' in value: - constants_values[const] = float(value) - else: - constants_values[const] = int(value) - except ValueError: - # If not a number, treat as string - if value.lower() in ['true', 'false']: - constants_values[const] = value.lower() == 'true' - else: - constants_values[const] = value - print("\n✅ Constants configured!\n") - - return constants_values - - -def print_firefly_header(rule_name: str, description: str = None, version: str = None): - """ - Print the standard Firefly Rule Engine header. - - Args: - rule_name (str): Name of the rule - description (str, optional): Rule description - version (str, optional): Rule version - """ - print("\n" + "="*80) - print("🔥 FIREFLY RULE ENGINE - COMPILED PYTHON RULE") - print("="*80) - print(f"Rule: {rule_name}") - if description: - print(f"Description: {description}") - if version: - print(f"Version: {version}") - print("Copyright 2024-2026 Firefly Software Foundation") - print("Licensed under Apache 2.0 | Made with ❤️") - print("="*80) - - -def print_execution_results(result: dict): - """ - Print execution results in a formatted way. - - Args: - result (dict): The execution results to display - """ - import json - - print("✅ Rule executed successfully!") - print("\n📊 RESULTS:") - print(json.dumps(result, indent=2, default=str)) - - -def print_firefly_footer(): - """Print the standard Firefly Rule Engine footer.""" - print("\n" + "="*80) - print("🎉 Execution completed successfully!") - print("Thank you for using Firefly Rule Engine ❤️") - print("="*80) - - -def execute_rule_interactively(rule_function, rule_name: str, description: str = None, - version: str = None, input_definitions: dict = None, - constants_need_config: list = None): - """ - Execute a rule function interactively with full user interface. - - Args: - rule_function: The compiled rule function to execute - rule_name (str): Name of the rule - description (str, optional): Rule description - version (str, optional): Rule version - input_definitions (dict, optional): Input definitions {name: type} - constants_need_config (list, optional): List of constants needing configuration - """ - import traceback - - # Print header - print_firefly_header(rule_name, description, version) - - # Configure constants if needed - if constants_need_config: - constants_values = configure_constants_interactively(constants_need_config) - # Apply configured constants to global constants dict - if 'constants' in globals(): - globals()['constants'].update(constants_values) - - # Collect inputs - context = {} - if input_definitions: - context = collect_inputs(input_definitions) - else: - print("ℹ️ No input variables required for this rule.") - - # Execute rule - print("\n🚀 Executing rule...") - print("-" * 40) - - try: - result = rule_function(context) - print_execution_results(result) - except Exception as e: - print(f"❌ Error executing rule: {e}") - traceback.print_exc() - sys.exit(1) - - # Print footer - print_firefly_footer() diff --git a/python-runtime/firefly_runtime/json_utils.py b/python-runtime/firefly_runtime/json_utils.py deleted file mode 100644 index 134a1b3..0000000 --- a/python-runtime/firefly_runtime/json_utils.py +++ /dev/null @@ -1,286 +0,0 @@ -#!/usr/bin/env python3 -""" -JSON utility functions for the Firefly Rule Engine Python Runtime - -This module provides JSON path and manipulation functions equivalent to the Java implementation. -""" - -import json -import re -from typing import Any, Dict, List, Optional, Union - - -def firefly_json_get(data: Union[Dict, List, str], path: str) -> Any: - """ - Get value from JSON data using JSONPath-like syntax. - - Args: - data: JSON data (dict, list, or JSON string) - path: JSONPath expression (simplified) - - Returns: - The value at the specified path, or None if not found - """ - if isinstance(data, str): - try: - data = json.loads(data) - except json.JSONDecodeError: - return None - - return json_path_get(data, path) - - -def json_path_get(data: Any, path: str) -> Any: - """ - Extract value using simplified JSONPath syntax. - - Supports: - - $.field - root field access - - $.field.subfield - nested field access - - $.array[0] - array index access - - $.array[*] - all array elements - - $..field - recursive field search - - Args: - data: The data to search - path: JSONPath expression - - Returns: - The value at the specified path, or None if not found - """ - if not path or not path.startswith('$'): - return None - - # Remove the root '$' and split by '.' - path = path[1:] - if path.startswith('.'): - path = path[1:] - - if not path: - return data - - # Handle recursive search (..) - if path.startswith('.'): - field = path[1:] - return _recursive_search(data, field) - - # Split path into segments - segments = _parse_path_segments(path) - current = data - - for segment in segments: - current = _navigate_segment(current, segment) - if current is None: - return None - - return current - - -_SENTINEL = object() - - -def firefly_json_exists(data: Union[Dict, List, str], path: str) -> bool: - """ - Check if a path exists in JSON data. - Returns True even if the value at the path is None/null. - - Args: - data: JSON data - path: JSONPath expression - - Returns: - True if path exists, False otherwise - """ - if isinstance(data, str): - try: - data = json.loads(data) - except json.JSONDecodeError: - return False - - return _json_path_exists(data, path) - - -def _json_path_exists(data: Any, path: str) -> bool: - """Check if a path exists (distinguishing None value from missing key).""" - if not path or not path.startswith('$'): - return False - - path = path[1:] - if path.startswith('.'): - path = path[1:] - - if not path: - return True - - segments = _parse_path_segments(path) - current = data - - for segment in segments: - if segment.startswith('[') and segment.endswith(']'): - index_str = segment[1:-1] - if isinstance(current, list): - try: - index = int(index_str) - if 0 <= index < len(current): - current = current[index] - else: - return False - except ValueError: - if index_str == '*': - return isinstance(current, list) and len(current) > 0 - return False - else: - return False - else: - if isinstance(current, dict) and segment in current: - current = current[segment] - else: - return False - - return True - - -def firefly_json_size(data: Union[Dict, List, str], path: str = None) -> int: - """ - Get the size of a JSON structure or array at a specific path. - - Args: - data: JSON data - path: Optional JSONPath expression - - Returns: - Size of the structure - """ - if path: - target = firefly_json_get(data, path) - else: - if isinstance(data, str): - try: - target = json.loads(data) - except json.JSONDecodeError: - return 0 - else: - target = data - - if isinstance(target, (list, dict, str)): - return len(target) - - return 0 - - -def firefly_json_type(data: Union[Dict, List, str], path: str = None) -> str: - """ - Get the type of a value in JSON data. - - Args: - data: JSON data - path: Optional JSONPath expression - - Returns: - Type name (object, array, string, number, boolean, null) - """ - if path: - target = firefly_json_get(data, path) - else: - if isinstance(data, str): - try: - target = json.loads(data) - except json.JSONDecodeError: - return 'string' - else: - target = data - - if target is None: - return 'null' - elif isinstance(target, bool): - return 'boolean' - elif isinstance(target, int): - return 'number' - elif isinstance(target, float): - return 'number' - elif isinstance(target, str): - return 'string' - elif isinstance(target, list): - return 'array' - elif isinstance(target, dict): - return 'object' - else: - return 'unknown' - - -# Helper functions for JSONPath processing - -def _parse_path_segments(path: str) -> List[str]: - """Parse path into segments, handling array indices.""" - segments = [] - current = "" - in_brackets = False - - for char in path: - if char == '[': - if current: - segments.append(current) - current = "" - in_brackets = True - current += char - elif char == ']': - current += char - segments.append(current) - current = "" - in_brackets = False - elif char == '.' and not in_brackets: - if current: - segments.append(current) - current = "" - else: - current += char - - if current: - segments.append(current) - - return segments - - -def _navigate_segment(data: Any, segment: str) -> Any: - """Navigate a single path segment.""" - if segment.startswith('[') and segment.endswith(']'): - # Array index access - index_str = segment[1:-1] - if index_str == '*': - # Return all elements if it's an array - return data if isinstance(data, list) else None - - try: - index = int(index_str) - if isinstance(data, list) and 0 <= index < len(data): - return data[index] - except ValueError: - pass - - return None - else: - # Object field access - if isinstance(data, dict): - return data.get(segment) - - return None - - -def _recursive_search(data: Any, field: str) -> Any: - """Recursively search for a field in nested structures.""" - if isinstance(data, dict): - if field in data: - return data[field] - - for value in data.values(): - result = _recursive_search(value, field) - if result is not None: - return result - - elif isinstance(data, list): - for item in data: - result = _recursive_search(item, field) - if result is not None: - return result - - return None diff --git a/python-runtime/firefly_runtime/logging_utils.py b/python-runtime/firefly_runtime/logging_utils.py deleted file mode 100644 index a6fd008..0000000 --- a/python-runtime/firefly_runtime/logging_utils.py +++ /dev/null @@ -1,226 +0,0 @@ -#!/usr/bin/env python3 -""" -Logging and auditing functions for the Firefly Rule Engine Python Runtime - -This module provides logging, auditing, and notification functions. -""" - -import logging -import json -import uuid -from datetime import datetime -from typing import Any, Dict, Optional, Union - - -# Configure logging -logging.basicConfig( - level=logging.INFO, - format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' -) - -logger = logging.getLogger('firefly_runtime') - -# Global audit configuration -_audit_config = { - 'enabled': True, - 'log_level': 'INFO', - 'include_context': True, - 'max_context_size': 1000 -} - - -def configure_logging(level: str = 'INFO', format_string: Optional[str] = None) -> None: - """ - Configure the logging system. - - Args: - level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL) - format_string: Optional custom format string - """ - numeric_level = getattr(logging, level.upper(), logging.INFO) - logger.setLevel(numeric_level) - - if format_string: - handler = logging.StreamHandler() - formatter = logging.Formatter(format_string) - handler.setFormatter(formatter) - logger.handlers = [handler] - - -def configure_audit(enabled: bool = True, log_level: str = 'INFO', - include_context: bool = True, max_context_size: int = 1000) -> None: - """ - Configure audit settings. - - Args: - enabled: Whether auditing is enabled - log_level: Audit log level - include_context: Whether to include context in audit logs - max_context_size: Maximum size of context data to log - """ - global _audit_config - _audit_config.update({ - 'enabled': enabled, - 'log_level': log_level, - 'include_context': include_context, - 'max_context_size': max_context_size - }) - - -def firefly_log(message: str, level: str = 'INFO', **kwargs) -> None: - """ - Log a message with optional additional data. - - Args: - message: Log message - level: Log level - **kwargs: Additional data to include in log - """ - numeric_level = getattr(logging, level.upper(), logging.INFO) - - if kwargs: - extra_data = json.dumps(kwargs, default=str) - full_message = f"{message} | Data: {extra_data}" - else: - full_message = message - - logger.log(numeric_level, full_message) - - -def firefly_audit(action: str, rule_name: Optional[str] = None, - context: Optional[Dict[str, Any]] = None, - result: Optional[Any] = None, **kwargs) -> str: - """ - Create an audit log entry. - - Args: - action: Action being audited - rule_name: Name of the rule being executed - context: Execution context - result: Execution result - **kwargs: Additional audit data - - Returns: - Audit ID - """ - if not _audit_config['enabled']: - return "" - - audit_id = str(uuid.uuid4()) - timestamp = datetime.utcnow().isoformat() - - audit_entry = { - 'audit_id': audit_id, - 'timestamp': timestamp, - 'action': action, - 'rule_name': rule_name, - 'result': _truncate_data(result, _audit_config['max_context_size']), - **kwargs - } - - if _audit_config['include_context'] and context: - audit_entry['context'] = _truncate_data(context, _audit_config['max_context_size']) - - audit_message = f"AUDIT: {json.dumps(audit_entry, default=str)}" - numeric_level = getattr(logging, _audit_config['log_level'].upper(), logging.INFO) - logger.log(numeric_level, audit_message) - - return audit_id - - -def firefly_audit_log(event_type: str, data: Dict[str, Any], - severity: str = 'INFO') -> str: - """ - Create a structured audit log entry. - - Args: - event_type: Type of event being logged - data: Event data - severity: Event severity - - Returns: - Audit ID - """ - return firefly_audit( - action=event_type, - severity=severity, - **data - ) - - -def firefly_send_notification(recipient: str, subject: str, message: str, - notification_type: str = 'email') -> bool: - """ - Send a notification (placeholder implementation). - - Args: - recipient: Notification recipient - subject: Notification subject - message: Notification message - notification_type: Type of notification (email, sms, webhook) - - Returns: - True if notification was sent successfully - """ - # This is a placeholder implementation - # In a real system, this would integrate with notification services - - notification_data = { - 'recipient': recipient, - 'subject': subject, - 'message': message, - 'type': notification_type, - 'timestamp': datetime.utcnow().isoformat() - } - - firefly_log( - f"Notification sent to {recipient}", - level='INFO', - notification=notification_data - ) - - return True - - -def _truncate_data(data: Any, max_size: int) -> Any: - """ - Truncate data if it exceeds the maximum size. - - Args: - data: Data to truncate - max_size: Maximum size in characters - - Returns: - Truncated data - """ - if data is None: - return None - - data_str = json.dumps(data, default=str) - - if len(data_str) <= max_size: - return data - - # Truncate and add indicator - truncated_str = data_str[:max_size - 20] + "...[TRUNCATED]" - - try: - return json.loads(truncated_str) - except json.JSONDecodeError: - return truncated_str - - -def get_audit_stats() -> Dict[str, Any]: - """ - Get audit system statistics. - - Returns: - Dictionary with audit statistics - """ - return { - 'audit_enabled': _audit_config['enabled'], - 'log_level': _audit_config['log_level'], - 'include_context': _audit_config['include_context'], - 'max_context_size': _audit_config['max_context_size'], - 'timestamp': datetime.utcnow().isoformat() - } diff --git a/python-runtime/firefly_runtime/rest_client.py b/python-runtime/firefly_runtime/rest_client.py deleted file mode 100644 index 4e05856..0000000 --- a/python-runtime/firefly_runtime/rest_client.py +++ /dev/null @@ -1,327 +0,0 @@ -#!/usr/bin/env python3 -""" -REST API client functions for the Firefly Rule Engine Python Runtime - -This module provides HTTP client functionality equivalent to the Java implementation. -""" - -import requests -import json -from typing import Any, Dict, Optional, Union -from requests.adapters import HTTPAdapter -from urllib3.util.retry import Retry - - -def _create_session() -> requests.Session: - """Create a new session with retry strategy (only idempotent methods).""" - s = requests.Session() - retry_strategy = Retry( - total=3, - status_forcelist=[429, 500, 502, 503, 504], - allowed_methods=["HEAD", "GET", "OPTIONS"], - backoff_factor=1 - ) - adapter = HTTPAdapter(max_retries=retry_strategy) - s.mount("http://", adapter) - s.mount("https://", adapter) - return s - - -# Global session — lazy-initialized per thread is ideal, but a module-level -# session is acceptable for the runtime's use case. -session = _create_session() - - -def firefly_rest_get(url: str, headers: Optional[Dict[str, str]] = None, - timeout: int = 30) -> Dict[str, Any]: - """ - Perform HTTP GET request. - - Args: - url: The URL to request - headers: Optional headers dictionary - timeout: Request timeout in seconds - - Returns: - Dictionary with response data - """ - try: - response = session.get(url, headers=headers or {}, timeout=timeout) - return { - 'status_code': response.status_code, - 'headers': dict(response.headers), - 'data': _parse_response_data(response), - 'success': response.status_code < 400 - } - except requests.RequestException as e: - return { - 'status_code': 0, - 'headers': {}, - 'data': None, - 'success': False, - 'error': str(e) - } - - -def firefly_rest_post(url: str, body: Optional[Union[Dict, str]] = None, - headers: Optional[Dict[str, str]] = None, - timeout: int = 30) -> Dict[str, Any]: - """ - Perform HTTP POST request. - - Args: - url: The URL to request - body: Request body (dict or string) - headers: Optional headers dictionary - timeout: Request timeout in seconds - - Returns: - Dictionary with response data - """ - try: - headers = headers or {} - if isinstance(body, dict): - headers.setdefault('Content-Type', 'application/json') - data = json.dumps(body) - else: - data = body - - response = session.post(url, data=data, headers=headers, timeout=timeout) - return { - 'status_code': response.status_code, - 'headers': dict(response.headers), - 'data': _parse_response_data(response), - 'success': response.status_code < 400 - } - except requests.RequestException as e: - return { - 'status_code': 0, - 'headers': {}, - 'data': None, - 'success': False, - 'error': str(e) - } - - -def firefly_rest_put(url: str, body: Optional[Union[Dict, str]] = None, - headers: Optional[Dict[str, str]] = None, - timeout: int = 30) -> Dict[str, Any]: - """ - Perform HTTP PUT request. - - Args: - url: The URL to request - body: Request body (dict or string) - headers: Optional headers dictionary - timeout: Request timeout in seconds - - Returns: - Dictionary with response data - """ - try: - headers = headers or {} - if isinstance(body, dict): - headers.setdefault('Content-Type', 'application/json') - data = json.dumps(body) - else: - data = body - - response = session.put(url, data=data, headers=headers, timeout=timeout) - return { - 'status_code': response.status_code, - 'headers': dict(response.headers), - 'data': _parse_response_data(response), - 'success': response.status_code < 400 - } - except requests.RequestException as e: - return { - 'status_code': 0, - 'headers': {}, - 'data': None, - 'success': False, - 'error': str(e) - } - - -def firefly_rest_delete(url: str, headers: Optional[Dict[str, str]] = None, - timeout: int = 30) -> Dict[str, Any]: - """ - Perform HTTP DELETE request. - - Args: - url: The URL to request - headers: Optional headers dictionary - timeout: Request timeout in seconds - - Returns: - Dictionary with response data - """ - try: - response = session.delete(url, headers=headers or {}, timeout=timeout) - return { - 'status_code': response.status_code, - 'headers': dict(response.headers), - 'data': _parse_response_data(response), - 'success': response.status_code < 400 - } - except requests.RequestException as e: - return { - 'status_code': 0, - 'headers': {}, - 'data': None, - 'success': False, - 'error': str(e) - } - - -def firefly_rest_patch(url: str, body: Optional[Union[Dict, str]] = None, - headers: Optional[Dict[str, str]] = None, - timeout: int = 30) -> Dict[str, Any]: - """ - Perform HTTP PATCH request. - - Args: - url: The URL to request - body: Request body (dict or string) - headers: Optional headers dictionary - timeout: Request timeout in seconds - - Returns: - Dictionary with response data - """ - try: - headers = headers or {} - if isinstance(body, dict): - headers.setdefault('Content-Type', 'application/json') - data = json.dumps(body) - else: - data = body - - response = session.patch(url, data=data, headers=headers, timeout=timeout) - return { - 'status_code': response.status_code, - 'headers': dict(response.headers), - 'data': _parse_response_data(response), - 'success': response.status_code < 400 - } - except requests.RequestException as e: - return { - 'status_code': 0, - 'headers': {}, - 'data': None, - 'success': False, - 'error': str(e) - } - - -def firefly_rest_call(method: str, url: str, body: Optional[Union[Dict, str]] = None, - headers: Optional[Dict[str, str]] = None, - timeout: int = 30) -> Dict[str, Any]: - """ - Generic REST call function. - - Args: - method: HTTP method (GET, POST, PUT, DELETE, PATCH) - url: The URL to request - body: Request body (dict or string). Note: body is ignored for GET and DELETE - requests as per HTTP standards. A warning will be issued if body is - provided for DELETE requests. - headers: Optional headers dictionary - timeout: Request timeout in seconds - - Returns: - Dictionary with response data - - Note: - - GET and DELETE requests do not support request bodies per HTTP standards - - If a body is provided for DELETE, a warning will be issued and the body ignored - - For GET requests, use query parameters in the URL instead of a body - """ - method = method.upper() - - if method == 'GET': - # HTTP GET requests should not have a body according to HTTP standards - # If a body is provided, log a warning but proceed without it - if body is not None: - import warnings - warnings.warn( - "GET requests should not include a request body according to HTTP standards. " - "Use query parameters in the URL instead. The body parameter will be ignored.", - UserWarning, - stacklevel=2 - ) - return firefly_rest_get(url, headers, timeout) - elif method == 'POST': - return firefly_rest_post(url, body, headers, timeout) - elif method == 'PUT': - return firefly_rest_put(url, body, headers, timeout) - elif method == 'DELETE': - # HTTP DELETE requests should not have a body according to RFC 7231 - # If a body is provided, log a warning but proceed without it - if body is not None: - import warnings - warnings.warn( - "DELETE requests should not include a request body according to HTTP standards. " - "The body parameter will be ignored.", - UserWarning, - stacklevel=2 - ) - return firefly_rest_delete(url, headers, timeout) - elif method == 'PATCH': - return firefly_rest_patch(url, body, headers, timeout) - else: - return { - 'status_code': 0, - 'headers': {}, - 'data': None, - 'success': False, - 'error': f'Unsupported HTTP method: {method}' - } - - -def _parse_response_data(response: requests.Response) -> Any: - """ - Parse response data based on content type. - - Args: - response: The requests Response object - - Returns: - Parsed response data - """ - content_type = response.headers.get('content-type', '').lower() - - try: - if 'application/json' in content_type: - return response.json() - elif 'text/' in content_type: - return response.text - else: - return response.content - except (json.JSONDecodeError, UnicodeDecodeError): - return response.text if response.text else None - - -def configure_rest_client(timeout: int = 30, retries: int = 3, - backoff_factor: float = 1.0) -> None: - """ - Configure the global REST client settings. - - Args: - timeout: Default timeout in seconds - retries: Number of retry attempts - backoff_factor: Backoff factor for retries - """ - global session - - retry_strategy = Retry( - total=retries, - status_forcelist=[429, 500, 502, 503, 504], - allowed_methods=["HEAD", "GET", "OPTIONS"], - backoff_factor=backoff_factor - ) - - adapter = HTTPAdapter(max_retries=retry_strategy) - session = requests.Session() - session.mount("http://", adapter) - session.mount("https://", adapter) diff --git a/python-runtime/firefly_runtime/security.py b/python-runtime/firefly_runtime/security.py deleted file mode 100644 index b9f03e7..0000000 --- a/python-runtime/firefly_runtime/security.py +++ /dev/null @@ -1,207 +0,0 @@ -#!/usr/bin/env python3 -""" -Security functions for the Firefly Rule Engine Python Runtime - -This module provides encryption, decryption, and data masking functions. -""" - -import hashlib -import hmac -import base64 -import os -import secrets -from typing import Any, Optional, Union -from cryptography.fernet import Fernet -from cryptography.hazmat.primitives import hashes -from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC - - -# Global encryption key and salt (should be configured externally in production) -_encryption_key: Optional[bytes] = None -_encryption_salt: Optional[bytes] = None - - -def configure_encryption_key(key: Union[str, bytes], salt: Optional[bytes] = None) -> None: - """ - Configure the global encryption key. - - Args: - key: Encryption key (string or bytes). Must be provided externally. - salt: Optional salt bytes. If not provided, a random 16-byte salt is generated. - """ - global _encryption_key, _encryption_salt - - if isinstance(key, str): - key = key.encode('utf-8') - - # Use provided salt or generate a cryptographically random one - _encryption_salt = salt if salt is not None else os.urandom(16) - - kdf = PBKDF2HMAC( - algorithm=hashes.SHA256(), - length=32, - salt=_encryption_salt, - iterations=480000, - ) - _encryption_key = base64.urlsafe_b64encode(kdf.derive(key)) - - -def firefly_encrypt(data: str, key: Optional[str] = None) -> str: - """ - Encrypt data using Fernet symmetric encryption. - - Args: - data: Data to encrypt - key: Optional encryption key (uses global key if not provided) - - Returns: - Encrypted data as base64 string - """ - if key: - configure_encryption_key(key) - - if not _encryption_key: - raise ValueError( - "No encryption key configured. Call configure_encryption_key() first " - "or pass a key parameter." - ) - - try: - fernet = Fernet(_encryption_key) - encrypted_data = fernet.encrypt(data.encode('utf-8')) - return base64.urlsafe_b64encode(encrypted_data).decode('utf-8') - except Exception as e: - raise ValueError(f"Encryption failed: {str(e)}") - - -def firefly_decrypt(encrypted_data: str, key: Optional[str] = None) -> str: - """ - Decrypt data using Fernet symmetric encryption. - - Args: - encrypted_data: Encrypted data as base64 string - key: Optional encryption key (uses global key if not provided) - - Returns: - Decrypted data as string - """ - if key: - configure_encryption_key(key) - - if not _encryption_key: - raise ValueError( - "No encryption key configured. Call configure_encryption_key() first " - "or pass a key parameter." - ) - - try: - fernet = Fernet(_encryption_key) - decoded_data = base64.urlsafe_b64decode(encrypted_data.encode('utf-8')) - decrypted_data = fernet.decrypt(decoded_data) - return decrypted_data.decode('utf-8') - except Exception as e: - raise ValueError(f"Decryption failed: {str(e)}") - - -def firefly_mask_data(data: str, mask_type: str = 'partial', mask_char: str = '*') -> str: - """ - Mask sensitive data for logging or display. - - Args: - data: Data to mask - mask_type: Type of masking ('partial', 'full', 'email', 'ssn', 'credit_card') - mask_char: Character to use for masking - - Returns: - Masked data string - """ - if not data: - return data - - if mask_type == 'full': - return mask_char * len(data) - - elif mask_type == 'partial': - if len(data) <= 4: - return mask_char * len(data) - return data[:2] + mask_char * (len(data) - 4) + data[-2:] - - elif mask_type == 'email': - if '@' in data: - local, domain = data.split('@', 1) - if len(local) <= 2: - masked_local = mask_char * len(local) - else: - masked_local = local[0] + mask_char * (len(local) - 2) + local[-1] - return f"{masked_local}@{domain}" - return firefly_mask_data(data, 'partial', mask_char) - - elif mask_type == 'ssn': - # Mask SSN format: XXX-XX-1234 - clean_ssn = data.replace('-', '').replace(' ', '') - if len(clean_ssn) == 9: - return f"{mask_char * 3}-{mask_char * 2}-{clean_ssn[-4:]}" - return firefly_mask_data(data, 'partial', mask_char) - - elif mask_type == 'credit_card': - # Mask credit card: XXXX-XXXX-XXXX-1234 - clean_cc = data.replace('-', '').replace(' ', '') - if len(clean_cc) >= 12: - masked = mask_char * (len(clean_cc) - 4) + clean_cc[-4:] - # Format with dashes every 4 digits - return '-'.join([masked[i:i+4] for i in range(0, len(masked), 4)]) - return firefly_mask_data(data, 'partial', mask_char) - - else: - # Default to partial masking - return firefly_mask_data(data, 'partial', mask_char) - - -def generate_secure_token(length: int = 32) -> str: - """ - Generate a cryptographically secure random token. - - Args: - length: Length of the token in bytes - - Returns: - Secure token as hex string - """ - return secrets.token_hex(length) - - -def hash_data(data: str, algorithm: str = 'sha256') -> str: - """ - Hash data using the specified algorithm. - - Args: - data: Data to hash - algorithm: Hash algorithm ('sha256', 'sha512') - - Returns: - Hashed data as hex string - """ - data_bytes = data.encode('utf-8') - - if algorithm == 'sha256': - return hashlib.sha256(data_bytes).hexdigest() - elif algorithm == 'sha512': - return hashlib.sha512(data_bytes).hexdigest() - else: - raise ValueError(f"Unsupported hash algorithm: {algorithm}. Use 'sha256' or 'sha512'.") - - -def verify_hash(data: str, hash_value: str, algorithm: str = 'sha256') -> bool: - """ - Verify data against a hash value using timing-safe comparison. - - Args: - data: Original data - hash_value: Hash to verify against - algorithm: Hash algorithm used - - Returns: - True if hash matches, False otherwise - """ - computed_hash = hash_data(data, algorithm) - return hmac.compare_digest(computed_hash, hash_value) diff --git a/python-runtime/firefly_runtime/string_functions.py b/python-runtime/firefly_runtime/string_functions.py deleted file mode 100644 index 607b25a..0000000 --- a/python-runtime/firefly_runtime/string_functions.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env python3 -""" -String manipulation functions for the Firefly Rule Engine Python Runtime -""" - -import re -from typing import Any, Union - - -def firefly_upper(value: Any) -> str: - """Convert string to uppercase.""" - return str(value).upper() if value is not None else "" - - -def firefly_lower(value: Any) -> str: - """Convert string to lowercase.""" - return str(value).lower() if value is not None else "" - - -def firefly_trim(value: Any) -> str: - """Remove leading and trailing whitespace.""" - return str(value).strip() if value is not None else "" - - -def firefly_length(value: Any) -> int: - """Get the length of a string or collection.""" - if value is None: - return 0 - if hasattr(value, '__len__'): - return len(value) - return len(str(value)) - - -def firefly_contains(text: Any, substring: Any) -> bool: - """Check if text contains substring.""" - if text is None or substring is None: - return False - return str(substring) in str(text) - - -def firefly_startswith(text: Any, prefix: Any) -> bool: - """Check if text starts with prefix.""" - if text is None or prefix is None: - return False - return str(text).startswith(str(prefix)) - - -def firefly_endswith(text: Any, suffix: Any) -> bool: - """Check if text ends with suffix.""" - if text is None or suffix is None: - return False - return str(text).endswith(str(suffix)) - - -def firefly_replace(text: Any, old: Any, new: Any) -> str: - """Replace occurrences of old with new in text.""" - if text is None: - return "" - return str(text).replace(str(old), str(new)) - - -def firefly_matches(text: Any, pattern: Any) -> bool: - """Check if text matches regex pattern.""" - if text is None or pattern is None: - return False - try: - return bool(re.match(str(pattern), str(text))) - except re.error: - return False - - -def firefly_not_matches(text: Any, pattern: Any) -> bool: - """Check if text does NOT match regex pattern.""" - return not firefly_matches(text, pattern) - - -# Length comparison functions -def firefly_length_equals(value: Any, length: Union[int, float]) -> bool: - """Check if value length equals specified length.""" - try: - return firefly_length(value) == int(length) - except (ValueError, TypeError): - return False - - -def firefly_length_greater_than(value: Any, length: Union[int, float]) -> bool: - """Check if value length is greater than specified length.""" - try: - return firefly_length(value) > int(length) - except (ValueError, TypeError): - return False - - -def firefly_length_less_than(value: Any, length: Union[int, float]) -> bool: - """Check if value length is less than specified length.""" - try: - return firefly_length(value) < int(length) - except (ValueError, TypeError): - return False diff --git a/python-runtime/firefly_runtime/utilities.py b/python-runtime/firefly_runtime/utilities.py deleted file mode 100644 index f57369f..0000000 --- a/python-runtime/firefly_runtime/utilities.py +++ /dev/null @@ -1,80 +0,0 @@ -#!/usr/bin/env python3 -"""Utility functions for the Firefly Rule Engine Python Runtime""" - -import uuid -import random -from datetime import datetime, timedelta -from typing import Any, Union -import math - - -def firefly_format_currency(amount: Union[int, float], symbol: str = '$') -> str: - """Format amount as currency""" - return f"{symbol}{amount:,.2f}" - - -def firefly_format_percentage(value: Union[int, float], decimals: int = 2) -> str: - """Format value as percentage""" - return f"{value:.{decimals}f}%" - - -def firefly_generate_account_number() -> str: - """Generate a random account number""" - return ''.join([str(random.randint(0, 9)) for _ in range(12)]) - - -def firefly_generate_transaction_id() -> str: - """Generate a unique transaction ID""" - return str(uuid.uuid4()) - - -def firefly_distance_between(lat1: float, lon1: float, lat2: float, lon2: float) -> float: - """Calculate distance between two coordinates in miles""" - R = 3959 # Earth's radius in miles - lat1_rad, lon1_rad = math.radians(lat1), math.radians(lon1) - lat2_rad, lon2_rad = math.radians(lat2), math.radians(lon2) - - dlat = lat2_rad - lat1_rad - dlon = lon2_rad - lon1_rad - - a = math.sin(dlat/2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon/2)**2 - c = 2 * math.asin(math.sqrt(a)) - - return R * c - - -def firefly_is_valid(value: Any) -> bool: - """Check if value is valid (not None, not empty)""" - return value is not None and value != "" - - -def firefly_in_range(value: Union[int, float], min_val: Union[int, float], max_val: Union[int, float]) -> bool: - """Check if value is in range""" - try: - return min_val <= float(value) <= max_val - except (ValueError, TypeError): - return False - - -def firefly_substring(text: str, start: int, length: int = None) -> str: - """Extract substring""" - if not isinstance(text, str): - return "" - if length is None: - return text[start:] - return text[start:start+length] - - -def firefly_format_date(date_obj: datetime, format_str: str = '%Y-%m-%d') -> str: - """Format date object""" - return date_obj.strftime(format_str) - - -def firefly_calculate_age(birth_date: str) -> int: - """Calculate age from birth date""" - try: - birth = datetime.strptime(birth_date, '%Y-%m-%d') - today = datetime.now() - return today.year - birth.year - ((today.month, today.day) < (birth.month, birth.day)) - except ValueError: - return 0 diff --git a/python-runtime/firefly_runtime/validation.py b/python-runtime/firefly_runtime/validation.py deleted file mode 100644 index ffd7208..0000000 --- a/python-runtime/firefly_runtime/validation.py +++ /dev/null @@ -1,230 +0,0 @@ -#!/usr/bin/env python3 -""" -Validation functions for the Firefly Rule Engine Python Runtime -""" - -import re -from datetime import datetime -from typing import Any, Union - - -def firefly_is_valid_credit_score(score: Union[int, float]) -> bool: - """Check if a credit score is valid (300-850)""" - try: - return 300 <= float(score) <= 850 - except (ValueError, TypeError): - return False - - -def firefly_is_valid_ssn(ssn: str) -> bool: - """Check if SSN format is valid""" - if not isinstance(ssn, str): - return False - pattern = r'^\d{3}-\d{2}-\d{4}$|^\d{9}$' - return bool(re.match(pattern, ssn)) - - -def firefly_is_valid_account(account: str) -> bool: - """Check if account number format is valid""" - if not isinstance(account, str): - return False - return account.isdigit() and 8 <= len(account) <= 17 - - -def firefly_is_valid_routing(routing: str) -> bool: - """Check if routing number is valid""" - if not isinstance(routing, str) or len(routing) != 9 or not routing.isdigit(): - return False - # Simple checksum validation - checksum = sum(int(routing[i]) * (3, 7, 1)[i % 3] for i in range(9)) - return checksum % 10 == 0 - - -def firefly_is_business_day(date_str: str) -> bool: - """Check if date is a business day""" - try: - date_obj = datetime.strptime(date_str, '%Y-%m-%d') - return date_obj.weekday() < 5 # Monday=0, Sunday=6 - except ValueError: - return False - - -def firefly_age_meets_requirement(birth_date: str, min_age: int) -> bool: - """Check if age meets minimum requirement""" - try: - birth = datetime.strptime(birth_date, '%Y-%m-%d') - today = datetime.now() - age = today.year - birth.year - ((today.month, today.day) < (birth.month, birth.day)) - return age >= min_age - except ValueError: - return False - - -def firefly_validate_email(email: str) -> bool: - """Validate email format""" - if not isinstance(email, str): - return False - pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' - return bool(re.match(pattern, email)) - - -def firefly_validate_phone(phone: str) -> bool: - """Validate phone number format""" - if not isinstance(phone, str): - return False - # Remove all non-digits - digits = re.sub(r'\D', '', phone) - return len(digits) == 10 or (len(digits) == 11 and digits[0] == '1') - - -# Basic validation functions used in compiled rules -def firefly_is_positive(value: Union[int, float]) -> bool: - """Check if value is positive""" - try: - return float(value) > 0 - except (ValueError, TypeError): - return False - - -def firefly_is_negative(value: Union[int, float]) -> bool: - """Check if value is negative""" - try: - return float(value) < 0 - except (ValueError, TypeError): - return False - - -def firefly_is_zero(value: Union[int, float]) -> bool: - """Check if value is zero""" - try: - return float(value) == 0 - except (ValueError, TypeError): - return False - - -def firefly_is_non_zero(value: Union[int, float]) -> bool: - """Check if value is non-zero""" - try: - return float(value) != 0 - except (ValueError, TypeError): - return False - - -def firefly_is_null(value: Any) -> bool: - """Check if value is null/None""" - return value is None - - -def firefly_is_not_null(value: Any) -> bool: - """Check if value is not null/None""" - return value is not None - - -def firefly_is_empty(value: Any) -> bool: - """Check if value is empty""" - if value is None: - return True - if isinstance(value, (str, list, dict, tuple, set)): - return len(value) == 0 - return False - - -def firefly_is_not_empty(value: Any) -> bool: - """Check if value is not empty""" - return not firefly_is_empty(value) - - -def firefly_is_numeric(value: Any) -> bool: - """Check if value is numeric""" - try: - float(value) - return True - except (ValueError, TypeError): - return False - - -def firefly_is_not_numeric(value: Any) -> bool: - """Check if value is not numeric""" - return not firefly_is_numeric(value) - - -def firefly_is_email(value: str) -> bool: - """Check if value is a valid email""" - return firefly_validate_email(value) - - -def firefly_is_phone(value: str) -> bool: - """Check if value is a valid phone number""" - return firefly_validate_phone(value) - - -def firefly_is_date(value: str) -> bool: - """Check if value is a valid date""" - try: - datetime.strptime(value, '%Y-%m-%d') - return True - except (ValueError, TypeError): - return False - - -def firefly_is_percentage(value: Union[int, float]) -> bool: - """Check if value is a valid percentage (0-100)""" - try: - val = float(value) - return 0 <= val <= 100 - except (ValueError, TypeError): - return False - - -def firefly_is_currency(value: Union[int, float]) -> bool: - """Check if value is a valid currency amount""" - try: - val = float(value) - return val >= 0 - except (ValueError, TypeError): - return False - - -def firefly_is_credit_score(value: Union[int, float]) -> bool: - """Check if value is a valid credit score""" - return firefly_is_valid_credit_score(value) - - -def firefly_is_ssn(value: str) -> bool: - """Check if value is a valid SSN""" - return firefly_is_valid_ssn(value) - - -def firefly_is_account_number(value: str) -> bool: - """Check if value is a valid account number""" - return firefly_is_valid_account(value) - - -def firefly_is_routing_number(value: str) -> bool: - """Check if value is a valid routing number""" - return firefly_is_valid_routing(value) - - -def firefly_is_weekend(date_str: str) -> bool: - """Check if date is a weekend""" - try: - date_obj = datetime.strptime(date_str, '%Y-%m-%d') - return date_obj.weekday() >= 5 # Saturday=5, Sunday=6 - except ValueError: - return False - - -def firefly_age_at_least(birth_date: str, min_age: int) -> bool: - """Check if age is at least minimum""" - return firefly_age_meets_requirement(birth_date, min_age) - - -def firefly_age_less_than(birth_date: str, max_age: int) -> bool: - """Check if age is less than maximum""" - try: - birth = datetime.strptime(birth_date, '%Y-%m-%d') - today = datetime.now() - age = today.year - birth.year - ((today.month, today.day) < (birth.month, birth.day)) - return age < max_age - except ValueError: - return False diff --git a/python-runtime/requirements.txt b/python-runtime/requirements.txt deleted file mode 100644 index baf7296..0000000 --- a/python-runtime/requirements.txt +++ /dev/null @@ -1,20 +0,0 @@ -# Firefly Framework Rule Engine Python Runtime Dependencies - -# HTTP client library -requests>=2.31.0 - -# Cryptography for security functions -cryptography>=41.0.0 - -# Enhanced HTTP client with retry capabilities -urllib3>=2.0.0 - -# Optional: JSON path library for more advanced JSONPath support -# jsonpath-ng>=1.6.0 - -# Development dependencies (optional) -# pytest>=7.0.0 -# pytest-cov>=4.0.0 -# black>=23.0.0 -# flake8>=6.0.0 -# mypy>=1.0.0 diff --git a/python-runtime/run_tests.py b/python-runtime/run_tests.py deleted file mode 100644 index 5e369af..0000000 --- a/python-runtime/run_tests.py +++ /dev/null @@ -1,27 +0,0 @@ -#!/usr/bin/env python3 -""" -Test runner for Firefly Runtime -""" - -import unittest -import sys -import os - -# Add the current directory to the path -sys.path.insert(0, os.path.dirname(__file__)) - -def run_tests(): - """Run all tests""" - # Discover and run tests - loader = unittest.TestLoader() - start_dir = os.path.join(os.path.dirname(__file__), 'tests') - suite = loader.discover(start_dir, pattern='test_*.py') - - runner = unittest.TextTestRunner(verbosity=2) - result = runner.run(suite) - - # Return exit code based on test results - return 0 if result.wasSuccessful() else 1 - -if __name__ == '__main__': - sys.exit(run_tests()) diff --git a/python-runtime/setup.py b/python-runtime/setup.py deleted file mode 100644 index 704cc00..0000000 --- a/python-runtime/setup.py +++ /dev/null @@ -1,77 +0,0 @@ -#!/usr/bin/env python3 -""" -Setup script for the Firefly Rule Engine Python Runtime Library -""" - -from setuptools import setup, find_packages -import os - -# Read the README file -def read_readme(): - readme_path = os.path.join(os.path.dirname(__file__), 'README.md') - if os.path.exists(readme_path): - with open(readme_path, 'r', encoding='utf-8') as f: - return f.read() - return "Firefly Rule Engine Python Runtime Library" - -# Read requirements -def read_requirements(): - requirements_path = os.path.join(os.path.dirname(__file__), 'requirements.txt') - if os.path.exists(requirements_path): - with open(requirements_path, 'r', encoding='utf-8') as f: - return [line.strip() for line in f if line.strip() and not line.startswith('#')] - return [] - -setup( - name="firefly-runtime", - version="1.0.0", - author="Firefly Software Foundation", - author_email="support@firefly-solutions.com", - description="Python runtime library for the Firefly Rule Engine", - long_description=read_readme(), - long_description_content_type="text/markdown", - url="https://github.com/firefly-oss/fireflyframework-rule-engine", - packages=find_packages(), - classifiers=[ - "Development Status :: 5 - Production/Stable", - "Intended Audience :: Developers", - "License :: OSI Approved :: Apache Software License", - "Operating System :: OS Independent", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - "Programming Language :: Python :: 3.12", - "Topic :: Software Development :: Libraries :: Python Modules", - "Topic :: Office/Business :: Financial", - "Topic :: Scientific/Engineering :: Mathematics", - ], - python_requires=">=3.8", - install_requires=read_requirements(), - extras_require={ - "dev": [ - "pytest>=7.0.0", - "pytest-cov>=4.0.0", - "black>=23.0.0", - "flake8>=6.0.0", - "mypy>=1.0.0", - ], - "jsonpath": [ - "jsonpath-ng>=1.6.0", - ], - }, - entry_points={ - "console_scripts": [ - "firefly-runtime=firefly_runtime:get_version", - ], - }, - include_package_data=True, - zip_safe=False, - keywords="firefly rule-engine python runtime financial banking", - project_urls={ - "Bug Reports": "https://github.com/firefly-oss/fireflyframework-rule-engine/issues", - "Source": "https://github.com/firefly-oss/fireflyframework-rule-engine", - "Documentation": "https://github.com/firefly-oss/fireflyframework-rule-engine/docs", - }, -) diff --git a/python-runtime/tests/__init__.py b/python-runtime/tests/__init__.py deleted file mode 100644 index 14b36c4..0000000 --- a/python-runtime/tests/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# Tests for Firefly Runtime diff --git a/python-runtime/tests/test_core.py b/python-runtime/tests/test_core.py deleted file mode 100644 index ee5a089..0000000 --- a/python-runtime/tests/test_core.py +++ /dev/null @@ -1,173 +0,0 @@ -#!/usr/bin/env python3 -""" -Tests for core functions in the Firefly Runtime -""" - -import unittest -import sys -import os - -# Add the parent directory to the path so we can import firefly_runtime -sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) - -from firefly_runtime import * - - -class TestCoreFunctions(unittest.TestCase): - """Test core functions""" - - def test_get_nested_value(self): - """Test get_nested_value function""" - context = { - 'user': { - 'profile': { - 'name': 'John Doe', - 'age': 30 - }, - 'settings': { - 'theme': 'dark' - } - }, - 'score': 750 - } - - # Test valid paths - self.assertEqual(get_nested_value(context, 'user.profile.name'), 'John Doe') - self.assertEqual(get_nested_value(context, 'user.profile.age'), 30) - self.assertEqual(get_nested_value(context, 'user.settings.theme'), 'dark') - self.assertEqual(get_nested_value(context, 'score'), 750) - - # Test invalid paths - self.assertIsNone(get_nested_value(context, 'user.profile.invalid')) - self.assertIsNone(get_nested_value(context, 'invalid.path')) - self.assertIsNone(get_nested_value(context, '')) - - def test_get_indexed_value(self): - """Test get_indexed_value function""" - context = { - 'scores': [100, 200, 300], - 'users': [ - {'name': 'Alice'}, - {'name': 'Bob'}, - {'name': 'Charlie'} - ] - } - - # Test valid indices - self.assertEqual(get_indexed_value(context, 'scores', 0), 100) - self.assertEqual(get_indexed_value(context, 'scores', 2), 300) - self.assertEqual(get_indexed_value(context, 'users', 1), {'name': 'Bob'}) - - # Test invalid indices - self.assertIsNone(get_indexed_value(context, 'scores', 5)) - self.assertIsNone(get_indexed_value(context, 'scores', -1)) - self.assertIsNone(get_indexed_value(context, 'invalid', 0)) - - def test_is_empty(self): - """Test is_empty function""" - # Test empty values - self.assertTrue(is_empty(None)) - self.assertTrue(is_empty("")) - self.assertTrue(is_empty([])) - self.assertTrue(is_empty({})) - self.assertTrue(is_empty(())) - self.assertTrue(is_empty(set())) - - # Test non-empty values - self.assertFalse(is_empty("test")) - self.assertFalse(is_empty([1])) - self.assertFalse(is_empty({"a": 1})) - self.assertFalse(is_empty((1,))) - self.assertFalse(is_empty({1})) - self.assertFalse(is_empty(0)) - self.assertFalse(is_empty(False)) - - def test_list_remove(self): - """Test list_remove function""" - # Test normal case - original = [1, 2, 3, 2, 4] - result = list_remove(original, 2) - self.assertEqual(result, [1, 3, 4]) - - # Test removing non-existent value - result = list_remove([1, 2, 3], 5) - self.assertEqual(result, [1, 2, 3]) - - # Test empty list - result = list_remove([], 1) - self.assertEqual(result, []) - - # Test non-list input - result = list_remove("not a list", 1) - self.assertEqual(result, "not a list") - - def test_safe_divide(self): - """Test safe_divide function""" - # Test normal division - self.assertEqual(safe_divide(10, 2), 5.0) - self.assertEqual(safe_divide(7, 3), 7/3) - - # Test division by zero - self.assertEqual(safe_divide(10, 0), 0) - self.assertEqual(safe_divide(10, 0, 999), 999) - - # Test invalid inputs - self.assertEqual(safe_divide("invalid", 2), 0) - self.assertEqual(safe_divide(10, "invalid"), 0) - - def test_coerce_to_number(self): - """Test coerce_to_number function""" - # Test valid numbers - self.assertEqual(coerce_to_number(123), 123) - self.assertEqual(coerce_to_number(123.45), 123.45) - self.assertEqual(coerce_to_number("123"), 123.0) - self.assertEqual(coerce_to_number("123.45"), 123.45) - - # Test invalid inputs - self.assertEqual(coerce_to_number("invalid"), 0) - self.assertEqual(coerce_to_number(None), 0) - self.assertEqual(coerce_to_number([]), 0) - - # Test with custom default - self.assertEqual(coerce_to_number("invalid", -1), -1) - - def test_coerce_to_boolean(self): - """Test coerce_to_boolean function""" - # Test boolean values - self.assertTrue(coerce_to_boolean(True)) - self.assertFalse(coerce_to_boolean(False)) - - # Test numbers - self.assertTrue(coerce_to_boolean(1)) - self.assertTrue(coerce_to_boolean(-1)) - self.assertTrue(coerce_to_boolean(0.1)) - self.assertFalse(coerce_to_boolean(0)) - - # Test strings - self.assertTrue(coerce_to_boolean("true")) - self.assertTrue(coerce_to_boolean("yes")) - self.assertTrue(coerce_to_boolean("1")) - self.assertTrue(coerce_to_boolean("on")) - self.assertTrue(coerce_to_boolean("enabled")) - self.assertFalse(coerce_to_boolean("false")) - self.assertFalse(coerce_to_boolean("no")) - self.assertFalse(coerce_to_boolean("")) - - # Test None - self.assertFalse(coerce_to_boolean(None)) - - # Test collections - self.assertTrue(coerce_to_boolean([1])) - self.assertTrue(coerce_to_boolean({"a": 1})) - self.assertFalse(coerce_to_boolean([])) - self.assertFalse(coerce_to_boolean({})) - - def test_circuit_breaker_action(self): - """Test circuit_breaker_action function""" - # This is a placeholder function, just test it doesn't crash - result = circuit_breaker_action("test_action", 10) - self.assertTrue(result) - - -if __name__ == '__main__': - unittest.main() diff --git a/python-runtime/tests/test_financial.py b/python-runtime/tests/test_financial.py deleted file mode 100644 index 085d624..0000000 --- a/python-runtime/tests/test_financial.py +++ /dev/null @@ -1,176 +0,0 @@ -#!/usr/bin/env python3 -""" -Tests for financial functions in the Firefly Runtime -""" - -import unittest -import sys -import os - -# Add the parent directory to the path so we can import firefly_runtime -sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) - -from firefly_runtime import * - - -class TestFinancialFunctions(unittest.TestCase): - """Test financial functions""" - - def test_firefly_calculate_loan_payment(self): - """Test firefly_calculate_loan_payment function""" - # Test normal case - payment = firefly_calculate_loan_payment(100000, 5.0, 360) # 30-year mortgage - self.assertAlmostEqual(payment, 536.82, places=2) - - # Test zero interest - payment = firefly_calculate_loan_payment(12000, 0, 12) - self.assertEqual(payment, 1000.0) - - # Test invalid inputs - payment = firefly_calculate_loan_payment(0, 5.0, 360) - self.assertEqual(payment, 0.0) - - payment = firefly_calculate_loan_payment(100000, 5.0, 0) - self.assertEqual(payment, 0.0) - - def test_firefly_debt_to_income_ratio(self): - """Test firefly_debt_to_income_ratio function""" - # Test normal case - ratio = firefly_debt_to_income_ratio(2000, 8000) - self.assertEqual(ratio, 25.0) # Returns percentage - - # Test zero income - ratio = firefly_debt_to_income_ratio(2000, 0) - self.assertEqual(ratio, 100.0) # Returns 100% when no income - - # Test zero debt - ratio = firefly_debt_to_income_ratio(0, 8000) - self.assertEqual(ratio, 0.0) - - def test_firefly_credit_utilization(self): - """Test firefly_credit_utilization function""" - # Test normal case - utilization = firefly_credit_utilization(2500, 10000) - self.assertEqual(utilization, 25.0) - - # Test zero limit - utilization = firefly_credit_utilization(2500, 0) - self.assertEqual(utilization, 100.0) # Returns 100% when no limit - - # Test zero balance - utilization = firefly_credit_utilization(0, 10000) - self.assertEqual(utilization, 0.0) - - def test_firefly_loan_to_value(self): - """Test firefly_loan_to_value function""" - # Test normal case - ltv = firefly_loan_to_value(200000, 250000) - self.assertEqual(ltv, 80.0) - - # Test zero property value - ltv = firefly_loan_to_value(200000, 0) - self.assertEqual(ltv, 100.0) # Returns 100% when no property value - - # Test zero loan amount - ltv = firefly_loan_to_value(0, 250000) - self.assertEqual(ltv, 0.0) - - def test_firefly_calculate_compound_interest(self): - """Test firefly_calculate_compound_interest function""" - # Test normal case - amount = firefly_calculate_compound_interest(1000, 5.0, 1) # 1 year - self.assertAlmostEqual(amount, 1051.16, places=2) - - # Test zero principal - amount = firefly_calculate_compound_interest(0, 5.0, 1) - self.assertEqual(amount, 0.0) - - # Test zero rate - amount = firefly_calculate_compound_interest(1000, 0, 1) - self.assertEqual(amount, 1000.0) - - def test_firefly_calculate_rate(self): - """Test firefly_calculate_rate function""" - # Test excellent credit - rate = firefly_calculate_rate(800) - self.assertEqual(rate, 3.5) - - # Test very good credit - rate = firefly_calculate_rate(750) - self.assertEqual(rate, 4.5) - - # Test good credit - rate = firefly_calculate_rate(700) - self.assertEqual(rate, 5.5) - - # Test fair credit - rate = firefly_calculate_rate(650) - self.assertEqual(rate, 7.0) - - # Test poor credit - rate = firefly_calculate_rate(600) - self.assertEqual(rate, 9.0) - - # Test very poor credit - rate = firefly_calculate_rate(500) - self.assertEqual(rate, 12.0) - - # Test invalid score - rate = firefly_calculate_rate("invalid") - self.assertEqual(rate, 12.0) - - rate = firefly_calculate_rate(None) - self.assertEqual(rate, 12.0) - - def test_firefly_calculate_credit_score(self): - """Test firefly_calculate_credit_score function""" - # Test with good credit factors - score = firefly_calculate_credit_score( - payment_history=95.0, # Good payment history - credit_utilization=10.0, # Low utilization - credit_history_length=120, # 10 years - credit_mix=5, # Good mix - new_credit=1 # Few inquiries - ) - self.assertIsInstance(score, int) - self.assertGreaterEqual(score, 300) - self.assertLessEqual(score, 850) - - def test_firefly_payment_history_score(self): - """Test firefly_payment_history_score function""" - # Test perfect payment history - score = firefly_payment_history_score(12, 12, 0, 0, 0) - self.assertEqual(score, 100.0) - - # Test with some late payments - score = firefly_payment_history_score(10, 12, 2, 0, 0) - self.assertEqual(score, 73.33) # (10/12)*100 - 2*5 - - # Test no payment history - score = firefly_payment_history_score(0, 0, 0, 0, 0) - self.assertEqual(score, 100.0) - - def test_firefly_calculate_apr(self): - """Test firefly_calculate_apr function""" - # Test normal case: $100,000 loan with $110,000 total cost over 5 years - apr = firefly_calculate_apr(100000, 110000, 5) - self.assertIsInstance(apr, float) - self.assertEqual(apr, 2.0) # (10000 / 100000 / 5) * 100 = 2% - - def test_firefly_calculate_risk_score(self): - """Test firefly_calculate_risk_score function""" - # Test low risk - score = firefly_calculate_risk_score(800, 20.0, 5, 20.0) - self.assertIsInstance(score, int) - self.assertGreaterEqual(score, 0) - self.assertLessEqual(score, 100) - - # Test high risk - score = firefly_calculate_risk_score(500, 60.0, 1, 5.0) - self.assertIsInstance(score, int) - self.assertGreaterEqual(score, 0) - self.assertLessEqual(score, 100) - - -if __name__ == '__main__': - unittest.main() diff --git a/python-runtime/tests/test_interactive.py b/python-runtime/tests/test_interactive.py deleted file mode 100644 index f999949..0000000 --- a/python-runtime/tests/test_interactive.py +++ /dev/null @@ -1,189 +0,0 @@ -#!/usr/bin/env python3 -""" -Tests for interactive functions in the Firefly Runtime -""" - -import unittest -import sys -import os -from unittest.mock import patch, MagicMock -from io import StringIO - -# Add the parent directory to the path so we can import firefly_runtime -sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) - -from firefly_runtime import * - - -class TestInteractiveFunctions(unittest.TestCase): - """Test interactive functions""" - - @patch('builtins.input') - def test_get_user_input_text(self, mock_input): - """Test get_user_input with text input""" - mock_input.return_value = "test value" - result = get_user_input("Enter text: ", "text") - self.assertEqual(result, "test value") - - @patch('builtins.input') - def test_get_user_input_number(self, mock_input): - """Test get_user_input with number input""" - mock_input.return_value = "123.45" - result = get_user_input("Enter number: ", "number") - self.assertEqual(result, 123.45) - - mock_input.return_value = "123" - result = get_user_input("Enter number: ", "number") - self.assertEqual(result, 123) - - @patch('builtins.input') - def test_get_user_input_boolean(self, mock_input): - """Test get_user_input with boolean input""" - mock_input.return_value = "true" - result = get_user_input("Enter boolean: ", "boolean") - self.assertTrue(result) - - mock_input.return_value = "false" - result = get_user_input("Enter boolean: ", "boolean") - self.assertFalse(result) - - mock_input.return_value = "yes" - result = get_user_input("Enter boolean: ", "boolean") - self.assertTrue(result) - - @patch('builtins.input') - def test_get_user_input_empty(self, mock_input): - """Test get_user_input with empty input""" - mock_input.return_value = "" - result = get_user_input("Enter text: ", "text") - self.assertIsNone(result) - - @patch('builtins.input') - def test_get_user_input_invalid_number(self, mock_input): - """Test get_user_input with invalid number input""" - # First call returns invalid, second call returns valid - mock_input.side_effect = ["invalid", "123"] - result = get_user_input("Enter number: ", "number") - self.assertEqual(result, 123) - - @patch('firefly_runtime.interactive.get_user_input') - def test_collect_inputs(self, mock_get_input): - """Test collect_inputs function""" - mock_get_input.side_effect = [750, "John Doe", True] - - input_definitions = { - 'creditScore': 'number', - 'name': 'text', - 'hasCollateral': 'boolean' - } - - result = collect_inputs(input_definitions) - - expected = { - 'creditScore': 750, - 'name': "John Doe", - 'hasCollateral': True - } - - self.assertEqual(result, expected) - - @patch('builtins.input') - def test_configure_constants_interactively_empty_list(self, mock_input): - """Test configure_constants_interactively with empty list""" - result = configure_constants_interactively([]) - self.assertEqual(result, {}) - - @patch('builtins.input') - def test_configure_constants_interactively_with_constants(self, mock_input): - """Test configure_constants_interactively with constants""" - # User chooses to configure, then provides values - mock_input.side_effect = ["y", "650", "0.4"] - - constants_need_config = ['MIN_CREDIT_SCORE', 'MAX_DEBT_RATIO'] - result = configure_constants_interactively(constants_need_config) - - expected = { - 'MIN_CREDIT_SCORE': 650, - 'MAX_DEBT_RATIO': 0.4 - } - - self.assertEqual(result, expected) - - @patch('builtins.input') - def test_configure_constants_interactively_decline(self, mock_input): - """Test configure_constants_interactively when user declines""" - mock_input.return_value = "n" - - constants_need_config = ['MIN_CREDIT_SCORE'] - result = configure_constants_interactively(constants_need_config) - - self.assertEqual(result, {}) - - @patch('sys.stdout', new_callable=StringIO) - def test_print_firefly_header(self, mock_stdout): - """Test print_firefly_header function""" - print_firefly_header("Test Rule", "Test Description", "1.0") - output = mock_stdout.getvalue() - - self.assertIn("FIREFLY RULE ENGINE", output) - self.assertIn("Test Rule", output) - self.assertIn("Test Description", output) - self.assertIn("1.0", output) - self.assertIn("Firefly Software Foundation", output) - - @patch('sys.stdout', new_callable=StringIO) - def test_print_execution_results(self, mock_stdout): - """Test print_execution_results function""" - result = { - 'decision': 'APPROVED', - 'rate': 5.5, - 'score': 750 - } - - print_execution_results(result) - output = mock_stdout.getvalue() - - self.assertIn("Rule executed successfully", output) - self.assertIn("RESULTS", output) - self.assertIn("APPROVED", output) - - @patch('sys.stdout', new_callable=StringIO) - def test_print_firefly_footer(self, mock_stdout): - """Test print_firefly_footer function""" - print_firefly_footer() - output = mock_stdout.getvalue() - - self.assertIn("Execution completed successfully", output) - self.assertIn("Thank you for using Firefly Rule Engine", output) - - @patch('firefly_runtime.interactive.print_firefly_header') - @patch('firefly_runtime.interactive.collect_inputs') - @patch('firefly_runtime.interactive.print_execution_results') - @patch('firefly_runtime.interactive.print_firefly_footer') - def test_execute_rule_interactively(self, mock_footer, mock_results, mock_collect, mock_header): - """Test execute_rule_interactively function""" - # Mock the rule function - def mock_rule(context): - return {'result': 'success'} - - # Mock inputs - mock_collect.return_value = {'input1': 'value1'} - - # Execute - execute_rule_interactively( - rule_function=mock_rule, - rule_name="Test Rule", - description="Test Description", - version="1.0", - input_definitions={'input1': 'text'} - ) - - # Verify calls - mock_header.assert_called_once_with("Test Rule", "Test Description", "1.0") - mock_collect.assert_called_once_with({'input1': 'text'}) - mock_results.assert_called_once_with({'result': 'success'}) - mock_footer.assert_called_once() - - -if __name__ == '__main__': - unittest.main() diff --git a/python-runtime/tests/test_rest_client.py b/python-runtime/tests/test_rest_client.py deleted file mode 100644 index 89ed51b..0000000 --- a/python-runtime/tests/test_rest_client.py +++ /dev/null @@ -1,139 +0,0 @@ -#!/usr/bin/env python3 -""" -Tests for REST client functions in the Firefly Runtime -""" - -import unittest -import warnings -from unittest.mock import patch, MagicMock -from firefly_runtime.rest_client import ( - firefly_rest_get, - firefly_rest_post, - firefly_rest_put, - firefly_rest_delete, - firefly_rest_patch, - firefly_rest_call -) - - -class TestRestClientFunctions(unittest.TestCase): - """Test REST client functions""" - - @patch('firefly_runtime.rest_client.session') - def test_firefly_rest_get(self, mock_session): - """Test firefly_rest_get function""" - # Mock response - mock_response = MagicMock() - mock_response.status_code = 200 - mock_response.headers = {'content-type': 'application/json'} - mock_response.text = '{"message": "success"}' - mock_response.json.return_value = {"message": "success"} - mock_session.get.return_value = mock_response - - result = firefly_rest_get("https://api.example.com/test") - - self.assertEqual(result['status_code'], 200) - self.assertTrue(result['success']) - self.assertEqual(result['data'], {"message": "success"}) - mock_session.get.assert_called_once() - - @patch('firefly_runtime.rest_client.session') - def test_firefly_rest_post(self, mock_session): - """Test firefly_rest_post function""" - # Mock response - mock_response = MagicMock() - mock_response.status_code = 201 - mock_response.headers = {'content-type': 'application/json'} - mock_response.text = '{"id": 123}' - mock_response.json.return_value = {"id": 123} - mock_session.post.return_value = mock_response - - result = firefly_rest_post("https://api.example.com/create", {"name": "test"}) - - self.assertEqual(result['status_code'], 201) - self.assertTrue(result['success']) - self.assertEqual(result['data'], {"id": 123}) - mock_session.post.assert_called_once() - - @patch('firefly_runtime.rest_client.session') - def test_firefly_rest_delete(self, mock_session): - """Test firefly_rest_delete function""" - # Mock response - mock_response = MagicMock() - mock_response.status_code = 204 - mock_response.headers = {} - mock_response.text = '' - mock_session.delete.return_value = mock_response - - result = firefly_rest_delete("https://api.example.com/delete/123") - - self.assertEqual(result['status_code'], 204) - self.assertTrue(result['success']) - mock_session.delete.assert_called_once() - - def test_firefly_rest_call_delete_with_body_warning(self): - """Test that DELETE with body issues a warning""" - with patch('firefly_runtime.rest_client.firefly_rest_delete') as mock_delete: - mock_delete.return_value = {'status_code': 204, 'success': True} - - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - firefly_rest_call("DELETE", "https://api.example.com/delete/123", - body={"should_not_be_here": True}) - - # Check that a warning was issued - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, UserWarning)) - self.assertIn("DELETE requests should not include a request body", str(w[0].message)) - - # Verify that firefly_rest_delete was called without the body - mock_delete.assert_called_once_with("https://api.example.com/delete/123", None, 30) - - def test_firefly_rest_call_get_with_body_warning(self): - """Test that GET with body issues a warning""" - with patch('firefly_runtime.rest_client.firefly_rest_get') as mock_get: - mock_get.return_value = {'status_code': 200, 'success': True} - - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - firefly_rest_call("GET", "https://api.example.com/data", - body={"should_not_be_here": True}) - - # Check that a warning was issued - self.assertEqual(len(w), 1) - self.assertTrue(issubclass(w[0].category, UserWarning)) - self.assertIn("GET requests should not include a request body", str(w[0].message)) - - # Verify that firefly_rest_get was called without the body - mock_get.assert_called_once_with("https://api.example.com/data", None, 30) - - def test_firefly_rest_call_post_with_body_no_warning(self): - """Test that POST with body does not issue a warning""" - with patch('firefly_runtime.rest_client.firefly_rest_post') as mock_post: - mock_post.return_value = {'status_code': 201, 'success': True} - - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - - firefly_rest_call("POST", "https://api.example.com/create", - body={"name": "test"}) - - # Check that no warning was issued - self.assertEqual(len(w), 0) - - # Verify that firefly_rest_post was called with the body - mock_post.assert_called_once_with("https://api.example.com/create", {"name": "test"}, None, 30) - - def test_firefly_rest_call_unsupported_method(self): - """Test unsupported HTTP method""" - result = firefly_rest_call("INVALID", "https://api.example.com/test") - - self.assertEqual(result['status_code'], 0) - self.assertFalse(result['success']) - self.assertIn("Unsupported HTTP method", result['error']) - - -if __name__ == '__main__': - unittest.main() diff --git a/python-runtime/tests/test_validation.py b/python-runtime/tests/test_validation.py deleted file mode 100644 index d01db96..0000000 --- a/python-runtime/tests/test_validation.py +++ /dev/null @@ -1,175 +0,0 @@ -#!/usr/bin/env python3 -""" -Tests for validation functions in the Firefly Runtime -""" - -import unittest -import sys -import os - -# Add the parent directory to the path so we can import firefly_runtime -sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) - -from firefly_runtime import * - - -class TestValidationFunctions(unittest.TestCase): - """Test validation functions""" - - def test_firefly_is_positive(self): - """Test firefly_is_positive function""" - self.assertTrue(firefly_is_positive(1)) - self.assertTrue(firefly_is_positive(0.1)) - self.assertTrue(firefly_is_positive(100)) - self.assertFalse(firefly_is_positive(0)) - self.assertFalse(firefly_is_positive(-1)) - self.assertFalse(firefly_is_positive(-0.1)) - self.assertFalse(firefly_is_positive("invalid")) - self.assertFalse(firefly_is_positive(None)) - - def test_firefly_is_negative(self): - """Test firefly_is_negative function""" - self.assertTrue(firefly_is_negative(-1)) - self.assertTrue(firefly_is_negative(-0.1)) - self.assertTrue(firefly_is_negative(-100)) - self.assertFalse(firefly_is_negative(0)) - self.assertFalse(firefly_is_negative(1)) - self.assertFalse(firefly_is_negative(0.1)) - self.assertFalse(firefly_is_negative("invalid")) - self.assertFalse(firefly_is_negative(None)) - - def test_firefly_is_zero(self): - """Test firefly_is_zero function""" - self.assertTrue(firefly_is_zero(0)) - self.assertTrue(firefly_is_zero(0.0)) - self.assertTrue(firefly_is_zero("0")) - self.assertFalse(firefly_is_zero(1)) - self.assertFalse(firefly_is_zero(-1)) - self.assertFalse(firefly_is_zero(0.1)) - self.assertFalse(firefly_is_zero("invalid")) - self.assertFalse(firefly_is_zero(None)) - - def test_firefly_is_null(self): - """Test firefly_is_null function""" - self.assertTrue(firefly_is_null(None)) - self.assertFalse(firefly_is_null(0)) - self.assertFalse(firefly_is_null("")) - self.assertFalse(firefly_is_null([])) - self.assertFalse(firefly_is_null({})) - self.assertFalse(firefly_is_null(False)) - - def test_firefly_is_not_null(self): - """Test firefly_is_not_null function""" - self.assertFalse(firefly_is_not_null(None)) - self.assertTrue(firefly_is_not_null(0)) - self.assertTrue(firefly_is_not_null("")) - self.assertTrue(firefly_is_not_null([])) - self.assertTrue(firefly_is_not_null({})) - self.assertTrue(firefly_is_not_null(False)) - - def test_firefly_is_empty(self): - """Test firefly_is_empty function""" - self.assertTrue(firefly_is_empty(None)) - self.assertTrue(firefly_is_empty("")) - self.assertTrue(firefly_is_empty([])) - self.assertTrue(firefly_is_empty({})) - self.assertTrue(firefly_is_empty(())) - self.assertTrue(firefly_is_empty(set())) - self.assertFalse(firefly_is_empty("test")) - self.assertFalse(firefly_is_empty([1])) - self.assertFalse(firefly_is_empty({"a": 1})) - self.assertFalse(firefly_is_empty(0)) - self.assertFalse(firefly_is_empty(False)) - - def test_firefly_is_not_empty(self): - """Test firefly_is_not_empty function""" - self.assertFalse(firefly_is_not_empty(None)) - self.assertFalse(firefly_is_not_empty("")) - self.assertFalse(firefly_is_not_empty([])) - self.assertFalse(firefly_is_not_empty({})) - self.assertTrue(firefly_is_not_empty("test")) - self.assertTrue(firefly_is_not_empty([1])) - self.assertTrue(firefly_is_not_empty({"a": 1})) - self.assertTrue(firefly_is_not_empty(0)) - self.assertTrue(firefly_is_not_empty(False)) - - def test_firefly_is_numeric(self): - """Test firefly_is_numeric function""" - self.assertTrue(firefly_is_numeric(1)) - self.assertTrue(firefly_is_numeric(1.5)) - self.assertTrue(firefly_is_numeric("123")) - self.assertTrue(firefly_is_numeric("123.45")) - self.assertTrue(firefly_is_numeric("-123")) - self.assertFalse(firefly_is_numeric("abc")) - self.assertFalse(firefly_is_numeric("")) - self.assertFalse(firefly_is_numeric(None)) - self.assertFalse(firefly_is_numeric([])) - - def test_firefly_is_valid_credit_score(self): - """Test firefly_is_valid_credit_score function""" - self.assertTrue(firefly_is_valid_credit_score(300)) - self.assertTrue(firefly_is_valid_credit_score(850)) - self.assertTrue(firefly_is_valid_credit_score(720)) - self.assertFalse(firefly_is_valid_credit_score(299)) - self.assertFalse(firefly_is_valid_credit_score(851)) - self.assertFalse(firefly_is_valid_credit_score("invalid")) - self.assertFalse(firefly_is_valid_credit_score(None)) - - def test_firefly_validate_email(self): - """Test firefly_validate_email function""" - self.assertTrue(firefly_validate_email("test@example.com")) - self.assertTrue(firefly_validate_email("user.name@domain.co.uk")) - self.assertTrue(firefly_validate_email("test+tag@example.org")) - self.assertFalse(firefly_validate_email("invalid-email")) - self.assertFalse(firefly_validate_email("@example.com")) - self.assertFalse(firefly_validate_email("test@")) - self.assertFalse(firefly_validate_email("")) - self.assertFalse(firefly_validate_email(None)) - - def test_firefly_validate_phone(self): - """Test firefly_validate_phone function""" - self.assertTrue(firefly_validate_phone("1234567890")) - self.assertTrue(firefly_validate_phone("11234567890")) - self.assertTrue(firefly_validate_phone("(123) 456-7890")) - self.assertTrue(firefly_validate_phone("123-456-7890")) - self.assertFalse(firefly_validate_phone("123456789")) # Too short - self.assertFalse(firefly_validate_phone("123456789012")) # Too long - self.assertFalse(firefly_validate_phone("abc-def-ghij")) - self.assertFalse(firefly_validate_phone("")) - self.assertFalse(firefly_validate_phone(None)) - - def test_firefly_is_valid_ssn(self): - """Test firefly_is_valid_ssn function""" - self.assertTrue(firefly_is_valid_ssn("123-45-6789")) - self.assertTrue(firefly_is_valid_ssn("123456789")) - self.assertFalse(firefly_is_valid_ssn("123-45-678")) # Too short - self.assertFalse(firefly_is_valid_ssn("123-45-67890")) # Too long - self.assertFalse(firefly_is_valid_ssn("abc-de-fghi")) - self.assertFalse(firefly_is_valid_ssn("")) - self.assertFalse(firefly_is_valid_ssn(None)) - - def test_firefly_is_percentage(self): - """Test firefly_is_percentage function""" - self.assertTrue(firefly_is_percentage(0)) - self.assertTrue(firefly_is_percentage(50)) - self.assertTrue(firefly_is_percentage(100)) - self.assertTrue(firefly_is_percentage(25.5)) - self.assertFalse(firefly_is_percentage(-1)) - self.assertFalse(firefly_is_percentage(101)) - self.assertFalse(firefly_is_percentage("invalid")) - self.assertFalse(firefly_is_percentage(None)) - - def test_firefly_is_currency(self): - """Test firefly_is_currency function""" - self.assertTrue(firefly_is_currency(0)) - self.assertTrue(firefly_is_currency(100)) - self.assertTrue(firefly_is_currency(99.99)) - self.assertTrue(firefly_is_currency(1000000)) - self.assertFalse(firefly_is_currency(-1)) - self.assertFalse(firefly_is_currency(-0.01)) - self.assertFalse(firefly_is_currency("invalid")) - self.assertFalse(firefly_is_currency(None)) - - -if __name__ == '__main__': - unittest.main()