domainforge 0.13.0

package/domainforge-core/src/kg_import.rs

@@ -0,0 +1,251 @@
+use crate::graph::Graph;
+use crate::kg::KnowledgeGraph;
+
+// These types are only used when the 'shacl' feature is enabled; make their
+// imports conditional to avoid unused-import warnings when the feature is off.
+#[cfg(feature = "shacl")]
+use crate::kg::{ShaclProperty, ShaclShape};
+use std::fmt;
+
+#[cfg(feature = "shacl")]
+use oxigraph::model::{GraphNameRef, Term};
+#[cfg(feature = "shacl")]
+use oxigraph::sparql::QueryResults;
+#[cfg(feature = "shacl")]
+use oxigraph::store::Store;
+
+#[derive(Debug)]
+pub enum ImportError {
+    ShaclValidation(String),
+    Other(String),
+}
+
+impl fmt::Display for ImportError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ImportError::ShaclValidation(msg) => write!(f, "{}", msg),
+            ImportError::Other(msg) => write!(f, "{}", msg),
+        }
+    }
+}
+
+impl std::error::Error for ImportError {}
+
+pub fn import_kg_turtle(turtle: &str) -> Result<Graph, ImportError> {
+    match KnowledgeGraph::from_turtle(turtle) {
+        Ok(kg) => validate_and_convert(kg),
+        Err(e) => Err(ImportError::Other(format!(
+            "Failed to parse Turtle KG: {}",
+            e
+        ))),
+    }
+}
+
+fn validate_and_convert(kg: KnowledgeGraph) -> Result<Graph, ImportError> {
+    match kg.validate_shacl() {
+        Ok(vs) => {
+            if !vs.is_empty() {
+                let summary = vs
+                    .iter()
+                    .map(|v| format!("[{:?}] {}", v.severity, v.message))
+                    .collect::<Vec<_>>()
+                    .join("; ");
+                Err(ImportError::ShaclValidation(format!(
+                    "SHACL validation failed: {}",
+                    summary
+                )))
+            } else {
+                match kg.to_graph() {
+                    Ok(graph) => Ok(graph),
+                    Err(e) => Err(ImportError::Other(format!(
+                        "Failed to convert KG to Graph: {}",
+                        e
+                    ))),
+                }
+            }
+        }
+        Err(e) => Err(ImportError::ShaclValidation(format!(
+            "SHACL validation failed: {}",
+            e
+        ))),
+    }
+}
+
+pub fn import_kg_rdfxml(xml: &str) -> Result<Graph, ImportError> {
+    #[cfg(feature = "shacl")]
+    {
+        let store = Store::new()
+            .map_err(|e| ImportError::Other(format!("Failed to create oxigraph store: {}", e)))?;
+        let fmt = oxigraph::io::GraphFormat::RdfXml;
+
+        // Load the RDF/XML into the default graph
+        store
+            .load_graph(xml.as_bytes(), fmt, GraphNameRef::DefaultGraph, None)
+            .map_err(|e| {
+                ImportError::Other(format!("Failed to parse RDF/XML with oxigraph: {}", e))
+            })?;
+
+        // Serialize the parsed RDF/XML into Turtle so we can reuse KnowledgeGraph::from_turtle
+        let mut writer = Vec::new();
+        let turtle_fmt = oxigraph::io::GraphFormat::Turtle;
+        store
+            .dump_graph(&mut writer, turtle_fmt, GraphNameRef::DefaultGraph)
+            .map_err(|e| {
+                ImportError::Other(format!("Failed to serialize RDF/XML to Turtle: {}", e))
+            })?;
+        let turtle_str = String::from_utf8(writer)
+            .map_err(|e| ImportError::Other(format!("Invalid UTF-8: {}", e)))?;
+
+        let mut kg = KnowledgeGraph::from_turtle(&turtle_str)
+            .map_err(|e| ImportError::Other(format!("Failed to convert RDF/XML to KG: {}", e)))?;
+
+        // If we didn't pick up any shapes from the Turtle representation, try to extract
+        // SHACL shapes directly from the store via SPARQL.
+        if kg.shapes.is_empty() {
+            augment_shapes_from_store(&store, &mut kg)?;
+        }
+
+        validate_and_convert(kg)
+    }
+    #[cfg(not(feature = "shacl"))]
+    {
+        let _ = xml;
+        Err(ImportError::Other(
+            "RDF/XML import is not supported in this build (enable feature 'shacl')".to_string(),
+        ))
+    }
+}
+
+#[cfg(feature = "shacl")]
+fn augment_shapes_from_store(store: &Store, kg: &mut KnowledgeGraph) -> Result<(), ImportError> {
+    let q = r#"
+        PREFIX sh: <http://www.w3.org/ns/shacl#>
+        PREFIX sea: <http://domainforge.ai/sea#>
+        PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+        SELECT ?shape ?target ?path ?datatype ?minCount ?maxCount ?minExclusive WHERE {
+            ?shape a sh:NodeShape .
+            OPTIONAL { ?shape sh:targetClass ?target . }
+            ?shape sh:property ?prop .
+            ?prop sh:path ?path .
+            OPTIONAL { ?prop sh:datatype ?datatype . }
+            OPTIONAL { ?prop sh:minCount ?minCount . }
+            OPTIONAL { ?prop sh:maxCount ?maxCount . }
+            OPTIONAL { ?prop sh:minExclusive ?minExclusive . }
+        }
+    "#;
+
+    match store.query(q) {
+        Ok(QueryResults::Solutions(solutions)) => {
+            use std::collections::HashMap;
+
+            // Map: shape URI -> (optional target class IRI, properties)
+            let mut map: HashMap<String, (Option<String>, Vec<ShaclProperty>)> = HashMap::new();
+
+            for sol_res in solutions {
+                let sol = sol_res.map_err(|e| {
+                    ImportError::Other(format!("Error reading SHACL SPARQL solution: {}", e))
+                })?;
+
+                let term_to_named_str = |t: &Term| match t {
+                    Term::NamedNode(nn) => Some(nn.as_str().to_string()),
+                    _ => None,
+                };
+                let term_to_literal_val = |t: &Term| match t {
+                    Term::Literal(l) => Some(l.value().to_string()),
+                    _ => None,
+                };
+
+                let shape_term = sol.get("shape").and_then(term_to_named_str);
+                let target_term = sol.get("target").and_then(term_to_named_str);
+                let path_term = sol.get("path").and_then(term_to_named_str);
+                // datatype can be an IRI like http://www.w3.org/2001/XMLSchema#decimal
+                let datatype_term = sol.get("datatype").and_then(term_to_named_str);
+                let min_count = sol
+                    .get("minCount")
+                    .and_then(term_to_literal_val)
+                    .and_then(|v| v.parse::<u32>().ok());
+                let max_count = sol
+                    .get("maxCount")
+                    .and_then(term_to_literal_val)
+                    .and_then(|v| v.parse::<u32>().ok());
+                // minExclusive returns a literal value (e.g., "0"^^xsd:decimal); we only use the lexical form
+                let min_exclusive = sol.get("minExclusive").and_then(term_to_literal_val);
+
+                if let (Some(shape), Some(path)) = (shape_term.clone(), path_term.clone()) {
+                    let path_pref =
+                        if let Some(stripped) = path.strip_prefix("http://domainforge.ai/sea#") {
+                            format!("sea:{}", stripped)
+                        } else if let Some(stripped) =
+                            path.strip_prefix("http://www.w3.org/2000/01/rdf-schema#")
+                        {
+                            format!("rdfs:{}", stripped)
+                        } else {
+                            path.clone()
+                        };
+
+                    // Normalize datatype IRIs to xsd: prefixes
+                    let datatype_pref = datatype_term.as_ref().map(|dt| {
+                        if let Some(rest) = dt.strip_prefix("http://www.w3.org/2001/XMLSchema#") {
+                            format!("xsd:{}", rest)
+                        } else {
+                            dt.clone()
+                        }
+                    });
+
+                    // If min_exclusive present but datatype not specified, assume xsd:decimal
+                    let inferred_datatype = match (&datatype_pref, &min_exclusive) {
+                        (None, Some(_)) => Some("xsd:decimal".to_string()),
+                        _ => datatype_pref.clone(),
+                    };
+
+                    let prop = ShaclProperty {
+                        path: path_pref,
+                        datatype: inferred_datatype,
+                        min_count,
+                        max_count,
+                        min_exclusive,
+                    };
+
+                    let entry = map.entry(shape.clone()).or_insert((None, Vec::new()));
+                    if let Some(target) = target_term.clone() {
+                        entry.0 = Some(target.clone());
+                    }
+                    entry.1.push(prop);
+                }
+            }
+
+            let mut extracted_shapes: Vec<ShaclShape> = Vec::new();
+            for (shape_uri, (target_opt, props)) in map.into_iter() {
+                let target_class = if let Some(target) = target_opt {
+                    if let Some(stripped) = target.strip_prefix("http://domainforge.ai/sea#") {
+                        format!("sea:{}", stripped)
+                    } else {
+                        target
+                    }
+                } else if let Some(pos) = shape_uri.find('#') {
+                    let fragment = &shape_uri[pos + 1..];
+                    let fragment = fragment.strip_suffix("Shape").unwrap_or(fragment);
+                    format!("sea:{}", fragment)
+                } else {
+                    shape_uri.clone()
+                };
+
+                extracted_shapes.push(ShaclShape {
+                    target_class,
+                    properties: props,
+                });
+            }
+
+            if !extracted_shapes.is_empty() {
+                kg.shapes = extracted_shapes;
+            }
+
+            Ok(())
+        }
+        Ok(_) => Ok(()),
+        Err(e) => Err(ImportError::Other(format!(
+            "Failed to execute SHACL SPARQL query: {}",
+            e
+        ))),
+    }
+}

package/domainforge-core/src/lib.rs

@@ -0,0 +1,203 @@
+//! SEA Core — Rust implementation of DomainForge Domain Specific Language
+//!
+//! This library provides the core primitives:
+//! 1. Entity - Domain entities and concepts
+//! 2. Resource - Resources that flow between entities
+//! 3. Flow - Movement of resources between entities
+//! 4. Instance - Instances of entities with field values
+//! 5. ResourceInstance - Instances of resources
+//! 6. Mapping - Data transformation and mapping contracts
+//! 7. Projection - Output format projections
+//! 8. Policy - Validation and constraint rules
+//!
+//! ## Building
+//!
+//! ```bash
+//! cargo build
+//! cargo test
+//! cargo doc --no-deps --open
+//! ```
+//!
+//! # Example
+//!
+//! ```
+//! use domainforge_core::VERSION;
+//! assert_eq!(VERSION, env!("CARGO_PKG_VERSION"));
+//! ```
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+// Use a compact allocator only when compiling to wasm to avoid pulling wasm-only symbols on other targets.
+#[cfg(all(feature = "lol_alloc", target_arch = "wasm32"))]
+#[global_allocator]
+static ALLOC: lol_alloc::LockedAllocator<lol_alloc::FreeListAllocator> =
+    lol_alloc::LockedAllocator::new(lol_alloc::FreeListAllocator::new());
+
+pub mod authority;
+pub mod calm;
+pub mod concept_id;
+pub mod error;
+pub mod formatter;
+pub mod graph;
+pub mod kg;
+pub mod kg_import;
+pub mod module;
+pub mod parser;
+pub mod patterns;
+pub mod policy;
+pub mod primitives;
+pub mod projection;
+pub mod registry;
+pub mod sbvr;
+pub mod semantic_pack;
+pub mod semantic_version;
+pub mod units;
+pub mod uuid_module;
+pub mod validation_error;
+pub mod validation_result;
+
+#[cfg(feature = "cli")]
+pub mod cli;
+
+#[cfg(feature = "python")]
+pub mod python;
+
+#[cfg(feature = "typescript")]
+pub mod typescript;
+
+#[cfg(feature = "typescript")]
+pub use typescript::primitives::{
+    Entity as TsEntity, Flow as TsFlow, Instance as TsInstance, Resource as TsResource,
+    ResourceInstance as TsResourceInstance,
+};
+
+#[cfg(feature = "typescript")]
+pub use typescript::graph::Graph as TsGraph;
+#[cfg(feature = "typescript")]
+pub use typescript::registry::{
+    NamespaceBinding as TsNamespaceBinding, NamespaceRegistry as TsNamespaceRegistry,
+};
+
+#[cfg(feature = "wasm")]
+pub mod wasm;
+
+pub use concept_id::ConceptId;
+pub use graph::Graph;
+pub use kg::{KgError, KnowledgeGraph};
+pub use kg_import::{import_kg_rdfxml, import_kg_turtle, ImportError};
+pub use parser::{parse, parse_to_graph, parse_to_graph_with_options, ParseOptions};
+pub use patterns::Pattern;
+pub use registry::{NamespaceBinding, NamespaceRegistry, RegistryError};
+pub use sbvr::{SbvrError, SbvrModel};
+pub use semantic_version::SemanticVersion;
+pub use units::{unit_from_string, Dimension, Unit, UnitError, UnitRegistry};
+pub use uuid_module::{format_uuid, generate_uuid_v7, parse_uuid};
+pub use validation_error::{ErrorCode, Position, SourceRange, ValidationError};
+pub use validation_result::ValidationResult;
+
+#[cfg(test)]
+mod test_utils;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_version() {
+        assert_eq!(VERSION, env!("CARGO_PKG_VERSION"));
+    }
+}
+
+#[cfg(feature = "python")]
+use pyo3::prelude::*;
+
+#[cfg(feature = "python")]
+#[pymodule]
+fn domainforge(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add("__version__", VERSION)?;
+
+    m.add_class::<python::primitives::Entity>()?;
+    m.add_class::<python::primitives::Resource>()?;
+    m.add_class::<python::primitives::Flow>()?;
+    m.add_class::<python::primitives::ResourceInstance>()?;
+    m.add_class::<python::primitives::Instance>()?;
+    m.add_class::<python::primitives::Mapping>()?;
+    m.add_class::<python::primitives::Projection>()?;
+    m.add_class::<python::graph::Graph>()?;
+    m.add_class::<python::primitives::Role>()?;
+    m.add_class::<python::primitives::Relation>()?;
+    m.add_class::<python::registry::NamespaceRegistry>()?;
+    m.add_class::<python::registry::NamespaceBinding>()?;
+    m.add_class::<python::policy::Severity>()?;
+    m.add_class::<python::policy::Violation>()?;
+    m.add_class::<python::policy::EvaluationResult>()?;
+    m.add_class::<python::policy::UnaryOp>()?;
+    m.add_class::<python::policy::Quantifier>()?;
+    m.add_class::<python::policy::BinaryOp>()?;
+    m.add_class::<python::policy::AggregateFunction>()?;
+    m.add_class::<python::policy::WindowSpec>()?;
+    m.add_class::<python::policy::Expression>()?;
+    m.add_class::<python::policy::NormalizedExpression>()?;
+    m.add_class::<python::authority::FinalDecision>()?;
+    m.add_class::<python::authority::PolicyModality>()?;
+    m.add_class::<python::authority::SourceClass>()?;
+    m.add_class::<python::authority::ClaimLevel>()?;
+    m.add_class::<python::authority::AuthorityEnvironment>()?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::authority::evaluate_authority,
+        m
+    )?)?;
+    m.add_class::<python::units::Dimension>()?;
+    m.add_class::<python::units::Unit>()?;
+
+    // Formatter functions
+    m.add_function(pyo3::wrap_pyfunction!(python::formatter::format_source, m)?)?;
+    m.add_function(pyo3::wrap_pyfunction!(python::formatter::check_format, m)?)?;
+
+    m.add_class::<python::semantic_pack::SemanticTruth>()?;
+    m.add_class::<python::semantic_pack::DiagnosticSeverity>()?;
+    m.add_class::<python::semantic_pack::ValidationMode>()?;
+    m.add_class::<python::semantic_pack::ApprovalState>()?;
+    m.add_class::<python::semantic_pack::SignatureState>()?;
+    m.add_class::<python::semantic_pack::ConceptStatus>()?;
+    m.add_class::<python::semantic_pack::ConceptKind>()?;
+    m.add_class::<python::semantic_pack::AliasStatus>()?;
+    m.add_class::<python::semantic_pack::SemanticValidationStatus>()?;
+    m.add_class::<python::semantic_pack::SemanticPack>()?;
+    m.add_class::<python::semantic_pack::SemanticValidationResult>()?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::build_semantic_pack,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::validate_semantic_pack,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::validate_graph_with_pack,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(python::semantic_pack::sign_pack, m)?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::verify_pack_signature,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::diff_packs,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::compute_pack_hash,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::normalize_lookup_key,
+        m
+    )?)?;
+    m.add_function(pyo3::wrap_pyfunction!(
+        python::semantic_pack::resolve_concept,
+        m
+    )?)?;
+
+    Ok(())
+}

package/domainforge-core/src/module/mod.rs

@@ -0,0 +1 @@
+pub mod resolver;