domainforge 0.13.0

package/domainforge-core/src/projection/registry.rs

@@ -0,0 +1,43 @@
+use crate::graph::Graph;
+use crate::parser::ast::TargetFormat;
+use crate::primitives::{MappingContract, ProjectionContract};
+
+pub struct ProjectionRegistry<'a> {
+    graph: &'a Graph,
+}
+
+impl<'a> ProjectionRegistry<'a> {
+    pub fn new(graph: &'a Graph) -> Self {
+        Self { graph }
+    }
+
+    pub fn find_mappings_for_target(&self, target: &TargetFormat) -> Vec<&MappingContract> {
+        self.graph
+            .all_mappings()
+            .into_iter()
+            .filter(|m| m.target_format() == target)
+            .collect()
+    }
+
+    pub fn find_projections_for_target(&self, target: &TargetFormat) -> Vec<&ProjectionContract> {
+        self.graph
+            .all_projections()
+            .into_iter()
+            .filter(|p| p.target_format() == target)
+            .collect()
+    }
+
+    pub fn get_mapping_by_name(&self, name: &str) -> Option<&MappingContract> {
+        self.graph
+            .all_mappings()
+            .into_iter()
+            .find(|m| m.name() == name)
+    }
+
+    pub fn get_projection_by_name(&self, name: &str) -> Option<&ProjectionContract> {
+        self.graph
+            .all_projections()
+            .into_iter()
+            .find(|p| p.name() == name)
+    }
+}

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

@@ -0,0 +1,253 @@
+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 pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+// =============================================================================
+// Enums
+// =============================================================================
+
+#[pyclass(eq, eq_int, from_py_object)]
+#[derive(Clone, PartialEq)]
+pub enum FinalDecision {
+    Allow,
+    Deny,
+    Escalate,
+    NotApplicable,
+    Reject,
+}
+
+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,
+        }
+    }
+}
+
+#[pyclass(eq, eq_int, from_py_object)]
+#[derive(Clone, PartialEq)]
+pub enum PolicyModality {
+    Permission,
+    Prohibition,
+    Obligation,
+    Override,
+}
+
+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,
+        }
+    }
+}
+
+#[pyclass(eq, eq_int, from_py_object)]
+#[derive(Clone, PartialEq)]
+pub enum SourceClass {
+    CallerSupplied,
+    RuntimeObserved,
+    SystemOfRecord,
+    Attested,
+    ManualApproval,
+    Derived,
+    UnknownSource,
+}
+
+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,
+        }
+    }
+}
+
+#[pyclass(eq, eq_int, from_py_object)]
+#[derive(Clone, PartialEq)]
+pub enum ClaimLevel {
+    AuditBacked,
+    Validated,
+    FormallyProven,
+}
+
+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,
+        }
+    }
+}
+
+// =============================================================================
+// Structs
+// =============================================================================
+
+#[pyclass(skip_from_py_object)]
+pub struct AuthorityEnvironment {
+    inner: RustAuthorityEnvironment,
+}
+
+#[pymethods]
+impl AuthorityEnvironment {
+    #[new]
+    fn new(config_json: &str) -> PyResult<Self> {
+        let config: RustAuthorityEnvironmentConfig = serde_json::from_str(config_json)
+            .map_err(|e| PyValueError::new_err(format!("Invalid config JSON: {}", e)))?;
+        let env = RustAuthorityEnvironment::new(config)
+            .map_err(|e| PyValueError::new_err(format!("Authority error: {}", e)))?;
+        Ok(Self { inner: env })
+    }
+
+    fn validate(&mut self) -> PyResult<()> {
+        self.inner
+            .validate()
+            .map_err(|e| PyValueError::new_err(format!("Validation error: {}", e)))
+    }
+
+    #[pyo3(signature = (request_json, facts_json = "[]"))]
+    fn evaluate(&self, request_json: &str, facts_json: &str) -> PyResult<(String, String)> {
+        let request: crate::authority::AuthorityRequest = serde_json::from_str(request_json)
+            .map_err(|e| PyValueError::new_err(format!("Invalid request JSON: {}", e)))?;
+        let facts: Vec<RustFactEnvelope> = serde_json::from_str(facts_json)
+            .map_err(|e| PyValueError::new_err(format!("Invalid facts JSON: {}", e)))?;
+        let (trace, decision) = self
+            .inner
+            .evaluate(&request, &facts)
+            .map_err(|e| PyValueError::new_err(format!("Evaluation error: {}", e)))?;
+        let trace_json = serde_json::to_string(&trace)
+            .map_err(|e| PyValueError::new_err(format!("Trace serialization error: {}", e)))?;
+        let decision_json = serde_json::to_string(&decision)
+            .map_err(|e| PyValueError::new_err(format!("Decision serialization error: {}", e)))?;
+        Ok((trace_json, decision_json))
+    }
+
+    fn __repr__(&self) -> String {
+        "<Py AuthorityEnvironment>".to_string()
+    }
+}
+
+#[pyclass(from_py_object)]
+#[derive(Clone)]
+pub struct AuthorityErrorCode {
+    #[pyo3(get)]
+    pub code: String,
+    #[pyo3(get)]
+    pub message: String,
+    #[pyo3(get)]
+    pub recoverable: bool,
+}
+
+#[pymethods]
+impl AuthorityErrorCode {
+    fn __repr__(&self) -> String {
+        format!(
+            "AuthorityError(code='{}', message='{}')",
+            self.code, self.message
+        )
+    }
+}
+
+/// Evaluate an authority request against a policy environment configuration.
+///
+/// Args:
+///     config_json: JSON string of AuthorityEnvironmentConfig
+///     request_json: JSON string of AuthorityRequest
+///     facts_json: JSON array of FactEnvelope objects (optional)
+///
+/// Returns:
+///     Tuple of (trace_json, decision_json)
+#[pyfunction]
+#[pyo3(signature = (config_json, request_json, facts_json = "[]"))]
+pub fn evaluate_authority(
+    config_json: &str,
+    request_json: &str,
+    facts_json: &str,
+) -> PyResult<(String, String)> {
+    let config: RustAuthorityEnvironmentConfig = serde_json::from_str(config_json)
+        .map_err(|e| PyValueError::new_err(format!("Invalid config: {}", e)))?;
+    let mut env = RustAuthorityEnvironment::new(config)
+        .map_err(|e| PyValueError::new_err(format!("Environment error: {}", e)))?;
+    env.validate()
+        .map_err(|e| PyValueError::new_err(format!("Validation error: {}", e)))?;
+
+    let request: crate::authority::AuthorityRequest = serde_json::from_str(request_json)
+        .map_err(|e| PyValueError::new_err(format!("Invalid request: {}", e)))?;
+    let facts: Vec<RustFactEnvelope> = serde_json::from_str(facts_json)
+        .map_err(|e| PyValueError::new_err(format!("Invalid facts: {}", e)))?;
+
+    let (trace, decision) = env
+        .evaluate(&request, &facts)
+        .map_err(|e| PyValueError::new_err(format!("Evaluation error: {}", e)))?;
+
+    let trace_json = serde_json::to_string(&trace)
+        .map_err(|e| PyValueError::new_err(format!("Trace serialization error: {}", e)))?;
+    let decision_json = serde_json::to_string(&decision)
+        .map_err(|e| PyValueError::new_err(format!("Decision serialization error: {}", e)))?;
+    Ok((trace_json, decision_json))
+}

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

@@ -0,0 +1,227 @@
+/// Python-native error types for domainforge
+///
+/// This module provides Python exception conversion that feels native to Python users.
+/// Users should never see Rust error types when using the Python bindings.
+use crate::validation_error::ValidationError;
+use pyo3::exceptions::PyException;
+use pyo3::prelude::*;
+
+/// Convert ValidationError to appropriate Python exception with custom attributes
+pub fn to_python_exception(py: Python, err: ValidationError) -> PyErr {
+    let code = err.error_code().as_str().to_string();
+
+    match err {
+        ValidationError::SyntaxError {
+            message,
+            line,
+            column,
+            ..
+        } => {
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("line", line) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("column", column) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "SyntaxError") {
+                return e;
+            }
+
+            exc
+        }
+        ValidationError::TypeError {
+            message,
+            expected_type,
+            found_type,
+            suggestion,
+            ..
+        } => {
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "TypeError") {
+                return e;
+            }
+            if let Some(exp) = expected_type {
+                if let Err(e) = exc_obj.setattr("expected", exp) {
+                    return e;
+                }
+            }
+            if let Some(fnd) = found_type {
+                if let Err(e) = exc_obj.setattr("found", fnd) {
+                    return e;
+                }
+            }
+            if let Some(sug) = suggestion {
+                if let Err(e) = exc_obj.setattr("suggestion", sug) {
+                    return e;
+                }
+            }
+
+            exc
+        }
+        ValidationError::UnitError {
+            expected,
+            found,
+            suggestion,
+            ..
+        } => {
+            let message = format!("Unit mismatch: expected {:?}, found {:?}", expected, found);
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "UnitError") {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("expected_dimension", format!("{:?}", expected)) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("found_dimension", format!("{:?}", found)) {
+                return e;
+            }
+            if let Some(sug) = suggestion {
+                if let Err(e) = exc_obj.setattr("suggestion", sug) {
+                    return e;
+                }
+            }
+
+            exc
+        }
+        ValidationError::UndefinedReference {
+            reference_type,
+            name,
+            suggestion,
+            ..
+        } => {
+            let message = format!("Undefined {}: '{}'", reference_type, name);
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "ReferenceError") {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("reference_type", reference_type.to_string()) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("name", name) {
+                return e;
+            }
+            if let Some(sug) = suggestion {
+                if let Err(e) = exc_obj.setattr("suggestion", sug) {
+                    return e;
+                }
+            }
+
+            exc
+        }
+        ValidationError::ScopeError {
+            variable,
+            suggestion,
+            ..
+        } => {
+            let message = format!("Variable '{}' not in scope", variable);
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "ScopeError") {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("variable", variable) {
+                return e;
+            }
+            if let Some(sug) = suggestion {
+                if let Err(e) = exc_obj.setattr("suggestion", sug) {
+                    return e;
+                }
+            }
+
+            exc
+        }
+        ValidationError::DuplicateDeclaration {
+            name,
+            first_location,
+            second_location,
+        } => {
+            let message = format!(
+                "Duplicate declaration of '{}': first at {}, duplicate at {}",
+                name, first_location, second_location
+            );
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "DuplicateDeclaration") {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("name", name) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("first_location", first_location) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("second_location", second_location) {
+                return e;
+            }
+
+            exc
+        }
+        ValidationError::DeterminismError { message, hint } => {
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "DeterminismError") {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("hint", hint) {
+                return e;
+            }
+
+            exc
+        }
+        ValidationError::InvalidExpression {
+            message,
+            suggestion,
+            ..
+        } => {
+            let exc = PyException::new_err(message);
+            let exc_obj = exc.value(py);
+
+            if let Err(e) = exc_obj.setattr("code", code) {
+                return e;
+            }
+            if let Err(e) = exc_obj.setattr("error_type", "InvalidExpression") {
+                return e;
+            }
+            if let Some(sug) = suggestion {
+                if let Err(e) = exc_obj.setattr("suggestion", sug) {
+                    return e;
+                }
+            }
+
+            exc
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+//! Python bindings for the SEA formatter.
+
+use crate::formatter::{format, FormatConfig, IndentStyle};
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+/// Format SEA-DSL source code.
+///
+/// Args:
+///     source: The SEA-DSL source code to format
+///     indent_width: Number of spaces per indent level (default: 4)
+///     use_tabs: Use tabs instead of spaces for indentation (default: false)
+///     preserve_comments: Preserve comments in output (default: true)
+///     sort_imports: Sort imports alphabetically (default: true)
+///
+/// Returns:
+///     The formatted source code
+///
+/// Raises:
+///     ValueError: If the source code cannot be parsed
+///
+/// Example:
+///     >>> from domainforge import format_source
+///     >>> formatted = format_source('Entity   "Foo"  in    bar')
+///     >>> print(formatted)
+///     Entity "Foo" in bar
+#[pyfunction]
+#[pyo3(signature = (source, indent_width=4, use_tabs=false, preserve_comments=true, sort_imports=true))]
+pub fn format_source(
+    source: &str,
+    indent_width: usize,
+    use_tabs: bool,
+    preserve_comments: bool,
+    sort_imports: bool,
+) -> PyResult<String> {
+    let config = FormatConfig {
+        indent_width,
+        indent_style: if use_tabs {
+            IndentStyle::Tabs
+        } else {
+            IndentStyle::Spaces
+        },
+        preserve_comments,
+        sort_imports,
+        ..Default::default()
+    };
+
+    format(source, config).map_err(|e| PyValueError::new_err(e.to_string()))
+}
+
+/// Check if SEA-DSL source code is already formatted.
+///
+/// Args:
+///     source: The SEA-DSL source code to check
+///     indent_width: Number of spaces per indent level (default: 4)
+///     use_tabs: Use tabs instead of spaces for indentation (default: false)
+///
+/// Returns:
+///     True if the source is already formatted, False otherwise
+///
+/// Raises:
+///     ValueError: If the source code cannot be parsed
+///
+/// Example:
+///     >>> from domainforge import check_format
+///     >>> check_format('Entity "Foo" in bar\\n')
+///     True
+///     >>> check_format('Entity   "Foo"  in    bar')
+///     False
+#[pyfunction]
+#[pyo3(signature = (source, indent_width=4, use_tabs=false))]
+pub fn check_format(source: &str, indent_width: usize, use_tabs: bool) -> PyResult<bool> {
+    let config = FormatConfig {
+        indent_width,
+        indent_style: if use_tabs {
+            IndentStyle::Tabs
+        } else {
+            IndentStyle::Spaces
+        },
+        ..Default::default()
+    };
+
+    let formatted = format(source, config).map_err(|e| PyValueError::new_err(e.to_string()))?;
+
+    Ok(source == formatted)
+}