domainforge 0.13.0

package/domainforge-core/src/validation_result.rs

@@ -0,0 +1,30 @@
+use crate::policy::{Severity, Violation};
+
+/// Result object produced by `Graph::validate()` collecting the
+/// set of policy violations and a quick summary count for errors
+/// to support the CLI and tests.
+#[derive(Debug, Clone)]
+pub struct ValidationResult {
+    /// Total number of policies evaluated
+    pub total_policies: usize,
+
+    /// All policy violations collected during evaluation
+    pub violations: Vec<Violation>,
+
+    /// Number of ERROR-severity violations
+    pub error_count: usize,
+}
+
+impl ValidationResult {
+    pub fn new(total: usize, violations: Vec<Violation>) -> Self {
+        let error_count = violations
+            .iter()
+            .filter(|v| v.severity == Severity::Error)
+            .count();
+        Self {
+            total_policies: total,
+            violations,
+            error_count,
+        }
+    }
+}

package/domainforge-core/src/wasm/authority.rs

@@ -0,0 +1,192 @@
+use crate::authority::{
+    AuthorityEnvironment as RustAuthorityEnvironment,
+    AuthorityEnvironmentConfig as RustAuthorityEnvironmentConfig, ClaimLevel as RustClaimLevel,
+    FactEnvelope as RustFactEnvelope, FinalDecision as RustFinalDecision,
+    PolicyModality as RustPolicyModality, SourceClass as RustSourceClass,
+};
+use wasm_bindgen::prelude::*;
+
+// =============================================================================
+// Enums
+// =============================================================================
+
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug)]
+pub enum FinalDecision {
+    Allow = 0,
+    Deny = 1,
+    Escalate = 2,
+    NotApplicable = 3,
+    Reject = 4,
+}
+
+impl From<FinalDecision> for RustFinalDecision {
+    fn from(v: FinalDecision) -> Self {
+        match v {
+            FinalDecision::Allow => RustFinalDecision::Allow,
+            FinalDecision::Deny => RustFinalDecision::Deny,
+            FinalDecision::Escalate => RustFinalDecision::Escalate,
+            FinalDecision::NotApplicable => RustFinalDecision::NotApplicable,
+            FinalDecision::Reject => RustFinalDecision::Reject,
+        }
+    }
+}
+
+impl From<RustFinalDecision> for FinalDecision {
+    fn from(v: RustFinalDecision) -> Self {
+        match v {
+            RustFinalDecision::Allow => FinalDecision::Allow,
+            RustFinalDecision::Deny => FinalDecision::Deny,
+            RustFinalDecision::Escalate => FinalDecision::Escalate,
+            RustFinalDecision::NotApplicable => FinalDecision::NotApplicable,
+            RustFinalDecision::Reject => FinalDecision::Reject,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug)]
+pub enum PolicyModality {
+    Permission = 0,
+    Prohibition = 1,
+    Obligation = 2,
+    Override = 3,
+}
+
+impl From<PolicyModality> for RustPolicyModality {
+    fn from(v: PolicyModality) -> Self {
+        match v {
+            PolicyModality::Permission => RustPolicyModality::Permission,
+            PolicyModality::Prohibition => RustPolicyModality::Prohibition,
+            PolicyModality::Obligation => RustPolicyModality::Obligation,
+            PolicyModality::Override => RustPolicyModality::Override,
+        }
+    }
+}
+
+impl From<RustPolicyModality> for PolicyModality {
+    fn from(v: RustPolicyModality) -> Self {
+        match v {
+            RustPolicyModality::Permission => PolicyModality::Permission,
+            RustPolicyModality::Prohibition => PolicyModality::Prohibition,
+            RustPolicyModality::Obligation => PolicyModality::Obligation,
+            RustPolicyModality::Override => PolicyModality::Override,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug)]
+pub enum SourceClass {
+    CallerSupplied = 0,
+    RuntimeObserved = 1,
+    SystemOfRecord = 2,
+    Attested = 3,
+    ManualApproval = 4,
+    Derived = 5,
+    UnknownSource = 6,
+}
+
+impl From<SourceClass> for RustSourceClass {
+    fn from(v: SourceClass) -> Self {
+        match v {
+            SourceClass::CallerSupplied => RustSourceClass::CallerSupplied,
+            SourceClass::RuntimeObserved => RustSourceClass::RuntimeObserved,
+            SourceClass::SystemOfRecord => RustSourceClass::SystemOfRecord,
+            SourceClass::Attested => RustSourceClass::Attested,
+            SourceClass::ManualApproval => RustSourceClass::ManualApproval,
+            SourceClass::Derived => RustSourceClass::Derived,
+            SourceClass::UnknownSource => RustSourceClass::UnknownSource,
+        }
+    }
+}
+
+impl From<RustSourceClass> for SourceClass {
+    fn from(v: RustSourceClass) -> Self {
+        match v {
+            RustSourceClass::CallerSupplied => SourceClass::CallerSupplied,
+            RustSourceClass::RuntimeObserved => SourceClass::RuntimeObserved,
+            RustSourceClass::SystemOfRecord => SourceClass::SystemOfRecord,
+            RustSourceClass::Attested => SourceClass::Attested,
+            RustSourceClass::ManualApproval => SourceClass::ManualApproval,
+            RustSourceClass::Derived => SourceClass::Derived,
+            RustSourceClass::UnknownSource => SourceClass::UnknownSource,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug)]
+pub enum ClaimLevel {
+    AuditBacked = 0,
+    Validated = 1,
+    FormallyProven = 2,
+}
+
+impl From<ClaimLevel> for RustClaimLevel {
+    fn from(v: ClaimLevel) -> Self {
+        match v {
+            ClaimLevel::AuditBacked => RustClaimLevel::AuditBacked,
+            ClaimLevel::Validated => RustClaimLevel::Validated,
+            ClaimLevel::FormallyProven => RustClaimLevel::FormallyProven,
+        }
+    }
+}
+
+impl From<RustClaimLevel> for ClaimLevel {
+    fn from(v: RustClaimLevel) -> Self {
+        match v {
+            RustClaimLevel::AuditBacked => ClaimLevel::AuditBacked,
+            RustClaimLevel::Validated => ClaimLevel::Validated,
+            RustClaimLevel::FormallyProven => ClaimLevel::FormallyProven,
+        }
+    }
+}
+
+// =============================================================================
+// Functions
+// =============================================================================
+
+/// Evaluate an authority request against a policy environment configuration.
+///
+/// # Arguments
+/// * `config_json` - JSON string of AuthorityEnvironmentConfig
+/// * `request_json` - JSON string of AuthorityRequest
+/// * `facts_json` - JSON array string of FactEnvelope objects
+///
+/// # Returns
+/// JSON string with `{ "trace": {...}, "decision": {...} }`
+#[wasm_bindgen(js_name = "evaluateAuthority")]
+pub fn evaluate_authority(
+    config_json: &str,
+    request_json: &str,
+    facts_json: Option<String>,
+) -> Result<JsValue, JsError> {
+    let config: RustAuthorityEnvironmentConfig = serde_json::from_str(config_json)
+        .map_err(|e| JsError::new(&format!("Invalid config: {}", e)))?;
+    let mut env = RustAuthorityEnvironment::new(config)
+        .map_err(|e| JsError::new(&format!("Environment error: {}", e)))?;
+    env.validate()
+        .map_err(|e| JsError::new(&format!("Validation error: {}", e)))?;
+
+    let request: crate::authority::AuthorityRequest = serde_json::from_str(request_json)
+        .map_err(|e| JsError::new(&format!("Invalid request: {}", e)))?;
+    let facts: Vec<RustFactEnvelope> = match facts_json.as_deref() {
+        None | Some("") => vec![],
+        Some(s) => {
+            serde_json::from_str(s).map_err(|e| JsError::new(&format!("Invalid facts: {}", e)))?
+        }
+    };
+
+    let (trace, decision) = env
+        .evaluate(&request, &facts)
+        .map_err(|e| JsError::new(&format!("Evaluation error: {}", e)))?;
+
+    let result = serde_json::json!({
+        "trace": trace,
+        "decision": decision,
+    });
+
+    serde_wasm_bindgen::to_value(&result)
+        .map_err(|e| JsError::new(&format!("Serialization error: {}", e)))
+}

package/domainforge-core/src/wasm/error.rs

@@ -0,0 +1,145 @@
+/// WASM-native error handling for domainforge
+///
+/// This module provides error conversion that creates error messages with embedded
+/// metadata for WASM bindings. JavaScript users get structured error information.
+use crate::validation_error::ValidationError;
+use wasm_bindgen::prelude::*;
+
+/// Convert ValidationError to JsValue error string with embedded metadata
+///
+/// The error message includes JSON metadata that JavaScript can parse to get
+/// structured error information including error codes, types, and suggestions.
+pub fn to_js_error(err: ValidationError) -> JsValue {
+    let code = err.error_code().as_str();
+    let error_type = match &err {
+        ValidationError::SyntaxError { .. } => "SyntaxError",
+        ValidationError::TypeError { .. } => "TypeError",
+        ValidationError::UnitError { .. } => "UnitError",
+        ValidationError::UndefinedReference { .. } => "ReferenceError",
+        ValidationError::ScopeError { .. } => "ScopeError",
+        ValidationError::DuplicateDeclaration { .. } => "DuplicateDeclaration",
+        ValidationError::DeterminismError { .. } => "DeterminismError",
+        ValidationError::InvalidExpression { .. } => "InvalidExpression",
+    };
+
+    let message = err.to_string();
+
+    // Create metadata JSON based on error variant
+    let metadata = match err {
+        ValidationError::SyntaxError {
+            line,
+            column,
+            end_line,
+            end_column,
+            ..
+        } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "line": line,
+                "column": column,
+                "endLine": end_line,
+                "endColumn": end_column,
+            })
+        }
+        ValidationError::TypeError {
+            expected_type,
+            found_type,
+            suggestion,
+            ..
+        } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "expected": expected_type,
+                "found": found_type,
+                "suggestion": suggestion,
+            })
+        }
+        ValidationError::UnitError {
+            expected,
+            found,
+            suggestion,
+            ..
+        } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "expectedDimension": format!("{}", expected),
+                "foundDimension": format!("{}", found),
+                "suggestion": suggestion,
+            })
+        }
+        ValidationError::UndefinedReference {
+            reference_type,
+            name,
+            suggestion,
+            ..
+        } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "referenceType": reference_type,
+                "name": name,
+                "suggestion": suggestion,
+            })
+        }
+        ValidationError::ScopeError {
+            variable,
+            available_in,
+            suggestion,
+            ..
+        } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "variable": variable,
+                "availableIn": available_in,
+                "suggestion": suggestion,
+            })
+        }
+        ValidationError::DuplicateDeclaration {
+            name,
+            first_location,
+            second_location,
+        } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "name": name,
+                "firstLocation": first_location,
+                "secondLocation": second_location,
+            })
+        }
+        ValidationError::DeterminismError { hint, .. } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "hint": hint,
+            })
+        }
+        ValidationError::InvalidExpression { suggestion, .. } => {
+            serde_json::json!({
+                "code": code,
+                "errorType": error_type,
+                "suggestion": suggestion,
+            })
+        }
+    };
+
+    // Create error message with embedded metadata
+    // Create error object with message and metadata
+    let error_object = serde_json::json!({
+        "message": message,
+        "metadata": metadata
+    });
+
+    // Convert to JsValue using serde-wasm-bindgen
+    match serde_wasm_bindgen::to_value(&error_object) {
+        Ok(val) => val,
+        Err(_) => {
+            // Fallback to string if serialization fails
+            JsValue::from_str(&message)
+        }
+    }
+}

package/domainforge-core/src/wasm/formatter.rs

@@ -0,0 +1,69 @@
+//! WASM bindings for the SEA formatter.
+
+use crate::formatter::{format, FormatConfig, IndentStyle};
+use wasm_bindgen::prelude::*;
+
+/// Format SEA-DSL source code.
+///
+/// @param source - The SEA-DSL source code to format
+/// @param indentWidth - Number of spaces per indent level (default: 4)
+/// @param useTabs - Use tabs instead of spaces for indentation (default: false)
+/// @param preserveComments - Preserve comments in output (default: true)
+/// @param sortImports - Sort imports alphabetically (default: true)
+/// @returns The formatted source code
+/// @throws Error if the source code cannot be parsed
+///
+/// @example
+/// ```javascript
+/// import { formatSource } from '@godspeedai/domainforge-wasm';
+///
+/// const formatted = formatSource('Entity   "Foo"  in    bar');
+/// console.log(formatted); // Entity "Foo" in bar
+/// ```
+#[wasm_bindgen(js_name = formatSource)]
+pub fn format_source(
+    source: &str,
+    indent_width: Option<u32>,
+    use_tabs: Option<bool>,
+    preserve_comments: Option<bool>,
+    sort_imports: Option<bool>,
+) -> Result<String, JsValue> {
+    let config = FormatConfig {
+        indent_width: indent_width.unwrap_or(4) as usize,
+        indent_style: if use_tabs.unwrap_or(false) {
+            IndentStyle::Tabs
+        } else {
+            IndentStyle::Spaces
+        },
+        preserve_comments: preserve_comments.unwrap_or(true),
+        sort_imports: sort_imports.unwrap_or(true),
+        ..Default::default()
+    };
+
+    format(source, config).map_err(|e| JsValue::from_str(&e.to_string()))
+}
+
+/// Check if SEA-DSL source code is already formatted.
+///
+/// @param source - The SEA-DSL source code to check
+/// @param indentWidth - Number of spaces per indent level (default: 4)
+/// @param useTabs - Use tabs instead of spaces for indentation (default: false)
+/// @returns True if the source is already formatted, false otherwise
+/// @throws Error if the source code cannot be parsed
+///
+/// @example
+/// ```javascript
+/// import { checkFormat } from '@godspeedai/domainforge-wasm';
+///
+/// console.log(checkFormat('Entity "Foo" in bar\n')); // true
+/// console.log(checkFormat('Entity   "Foo"  in    bar')); // false
+/// ```
+#[wasm_bindgen(js_name = checkFormat)]
+pub fn check_format(
+    source: &str,
+    indent_width: Option<u32>,
+    use_tabs: Option<bool>,
+) -> Result<bool, JsValue> {
+    let formatted = format_source(source, indent_width, use_tabs, Some(true), Some(true))?;
+    Ok(source == formatted)
+}