iOS Rules Engine

dependencies: [
    .package(url: "https://github.com/gorules/zen-engine-swift", from: "0.4.7")
]

import UIKit
import ZenUniffi

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        Task {
            guard let ruleData = Bundle.main.url(forResource: "pricing", withExtension: "json")
                .flatMap({ try? Data(contentsOf: $0) }) else {
                return
            }

            let engine = ZenEngine(loader: nil, customNode: nil)
            let decision = try engine.createDecision(content: ruleData)

            let input = """
                {
                    "customer": { "tier": "gold", "yearsActive": 3 },
                    "order": { "subtotal": 150, "items": 5 }
                }
            """.data(using: .utf8)!

            let response = try await decision.evaluate(context: input, options: nil)

            if let resultString = String(data: response.result, encoding: .utf8) {
                print(resultString)
                // => {"discount":0.15,"freeShipping":true}
            }
        }
    }
}

import ZenUniffi
import Foundation

func createEngine() throws -> ZenEngine {
    let url = Bundle.main.url(forResource: "pricing", withExtension: "json")!
    let pricing = try Data(contentsOf: url)

    let loader = ZenLoader.static(content: ["pricing.json": pricing])
    return ZenEngine(loader: loader, customNode: nil)
}

import ZenUniffi
import Foundation

func createEngine() -> ZenEngine {
    let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
    let rulesURL = documentsURL.appendingPathComponent("rules")

    let loader = ZenLoader.filesystem(path: rulesURL.path)
    return ZenEngine(loader: loader, customNode: nil)
}

import ZenUniffi
import Foundation

func createEngine() async throws -> ZenEngine {
    let url = URL(string: "https://api.example.com/decisions.zip")!
    let (zipData, _) = try await URLSession.shared.data(from: url)

    let loader = ZenLoader.zip(bytes: zipData)
    return ZenEngine(loader: loader, customNode: nil)
}

import ZenUniffi
import Foundation

class BundleLoader: ZenDecisionLoaderCallback {
    func load(key: String) async throws -> Data? {
        guard let url = Bundle.main.url(forResource: key, withExtension: nil) else {
            return nil
        }
        return try Data(contentsOf: url)
    }
}

func createEngine() -> ZenEngine {
    let loader = ZenLoader.callback(callback: BundleLoader())
    return ZenEngine(loader: loader, customNode: nil)
}

let results = await engine.evaluateBatch(
    requests: [
        ZenBatchRequest(key: "pricing.json", context: #"{ "amount": 100 }"#.data(using: .utf8)!),
        ZenBatchRequest(key: "pricing.json", context: #"{ "amount": 250 }"#.data(using: .utf8)!)
    ],
    options: nil
)

for result in results {
    if result.success, let data = result.data,
       let resultString = String(data: data.result, encoding: .utf8) {
        print(resultString)
    } else {
        print("Evaluation failed: \(result.error ?? "unknown")")
    }
}

import ZenUniffi

func evaluateMultiple(decision: ZenDecision, inputs: [Data]) async throws -> [ZenEvaluateResponse] {
    try await withThrowingTaskGroup(of: ZenEvaluateResponse.self) { group in
        for input in inputs {
            group.addTask {
                try await decision.evaluate(context: input, options: nil)
            }
        }

        var results: [ZenEvaluateResponse] = []
        for try await result in group {
            results.append(result)
        }
        return results
    }
}

import ZenUniffi

do {
    let response = try await decision.evaluate(context: input, options: nil)
    if let resultString = String(data: response.result, encoding: .utf8) {
        print(resultString)
    }
} catch let error as ZenError {
    print("Evaluation failed: \(error.localizedDescription)")
} catch {
    print("Unexpected error: \(error)")
}

import ZenUniffi

let options = ZenEvaluateOptions(trace: true, maxDepth: nil)

let response = try await decision.evaluate(context: input, options: options)

if let traceData = response.trace,
   let traceString = String(data: traceData, encoding: .utf8) {
    print("Trace: \(traceString)")
}
print("Performance: \(response.performance)")

import ZenUniffi

// Standard expressions
let result = try evaluateExpression(
    expression: "a + b",
    context: #"{ "a": 5, "b": 3 }"#.data(using: .utf8)!
)
// => 8

let total = try evaluateExpression(
    expression: "sum(items)",
    context: #"{ "items": [1, 2, 3, 4] }"#.data(using: .utf8)!
)
// => 10

// Unary expressions (comparison against $)
let isValid = try evaluateUnaryExpression(
    expression: ">= 5",
    context: #"{ "$": 10 }"#.data(using: .utf8)!
)
// => true

let inList = try evaluateUnaryExpression(
    expression: "'US', 'CA', 'MX'",
    context: #"{ "$": "US" }"#.data(using: .utf8)!
)
// => true

class RulesEngine {
    static let shared = RulesEngine()
    private let engine: ZenEngine

    private init() {
        engine = ZenEngine(loader: nil, customNode: nil)
    }

    func evaluate(decision: Data, context: Data) async throws -> Data {
        let dec = try engine.createDecision(content: decision)
        let response = try await dec.evaluate(context: context, options: nil)
        return response.result
    }
}