OxiRS SAMM - Semantic Aspect Meta Model for Rust

Status: 🚀 Beta.1 Production-Ready (v0.1.0-beta.1+++++++++++++) ✅ APIs stable. Ready for production use with backward compatibility guarantees.

Overview

OxiRS SAMM is a Rust implementation of the Semantic Aspect Meta Model (SAMM), which enables the creation of semantic models to describe digital twins and their aspects.

SAMM was developed by the Eclipse Semantic Modeling Framework (ESMF) project and provides a standardized way to model domain-specific aspects of digital twins.

Features

Core Capabilities

• ✅ SAMM 2.0.0-2.3.0 Support: Full implementation of SAMM specification
• ✅ RDF/Turtle Parsing: Load SAMM models from Turtle (.ttl) files with streaming support
• ✅ Type-Safe Metamodel: Rust structs for all SAMM elements with builder patterns
• ✅ SHACL Validation: Complete structural validation with detailed error reporting
• ✅ HTTP/HTTPS Resolution: Remote URN resolution with caching
• ✅ Error Recovery: Robust parser with configurable recovery strategies

Code Generation (16 Formats)

• ✅ Programming Languages: Rust, Java, Python, TypeScript, Scala
• ✅ API Specs: GraphQL, OpenAPI, AsyncAPI, JSON Schema
• ✅ Data Formats: JSON-LD, SQL DDL, HTML documentation
• ✅ Industry Standards: AAS (Asset Administration Shell), AASX packages
• ✅ Multi-File Generation: Package/module organization with automatic imports

Advanced Features

• ✅ Model Query API: Introspection, dependency analysis, complexity metrics
• ✅ Model Transformation: Fluent API for refactoring and migration
• ✅ Model Comparison: Diff generation with breaking change detection
• ✅ Model Migration: BAMM → SAMM upgrades with version detection
• ✅ Performance Optimizations: Parallel processing, caching, memory-efficient streaming
• ✅ Production Metrics: Comprehensive monitoring and health checks

Quick Start

Installation

Add this to your Cargo.toml:

[dependencies]
oxirs-samm = "0.1.0-beta.1"

Basic Usage

use oxirs_samm::parser::parse_aspect_model;
use oxirs_samm::validator::validate_aspect;
use oxirs_samm::generators::generate_typescript;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse a SAMM model from a Turtle file
    let aspect = parse_aspect_model("path/to/AspectModel.ttl").await?;

    println!("Aspect: {}", aspect.name());
    println!("Properties: {}", aspect.properties().len());

    // Validate the model
    let validation = validate_aspect(&aspect).await?;
    if validation.is_valid {
        println!("✓ Model is valid!");
    }

    // Generate TypeScript code
    let ts_code = generate_typescript(&aspect, Default::default())?;
    println!("{}", ts_code);

    Ok(())
}

Runnable Examples

The crate includes 6 comprehensive examples demonstrating real-world workflows:

1. model_query - Model introspection, dependency analysis, and complexity metrics

   cargo run --example model_query
   

2. model_transformation - Refactoring models (rename, namespace changes, optional/required)

   cargo run --example model_transformation
   

3. model_comparison - Version comparison with diff reports and breaking change detection

   cargo run --example model_comparison
   

4. code_generation_pipeline - Multi-language code generation (TypeScript, Python, Java, GraphQL)

   cargo run --example code_generation_pipeline
   

5. performance_optimization - Caching, parallel processing, and production metrics

   cargo run --example performance_optimization
   

6. model_lifecycle - Complete CRUD operations and workflow patterns

   cargo run --example model_lifecycle
   

Each example includes extensive documentation and demonstrates best practices for production use.

SAMM Metamodel

OxiRS SAMM implements all core SAMM metamodel elements:

Core Elements

• Aspect: Root element describing a digital twin's specific aspect
• Property: Named feature with a defined characteristic
• Characteristic: Describes the semantics of a property's value
• Entity: Complex data structure with multiple properties
• Operation: Function that can be performed on an aspect
• Event: Occurrence that can be emitted by an aspect

Characteristics

Supports all SAMM characteristic types:

Constraints

Supports all SAMM constraint types:

• LanguageConstraint: Restrict to specific language
• LocaleConstraint: Restrict to specific locale
• RangeConstraint: Value range limits
• LengthConstraint: String/collection length limits
• RegularExpressionConstraint: Pattern matching
• EncodingConstraint: Character encoding
• FixedPointConstraint: Decimal precision

Architecture

oxirs-samm/
├── src/
│   ├── lib.rs                # Crate entry point
│   ├── error.rs              # Error types
│   ├── metamodel/            # SAMM metamodel types
│   │   ├── aspect.rs
│   │   ├── property.rs
│   │   ├── characteristic.rs
│   │   ├── entity.rs
│   │   └── operation.rs
│   ├── parser/               # RDF/Turtle parser
│   │   ├── ttl_parser.rs
│   │   └── resolver.rs
│   └── validator/            # SHACL validation
│       └── shacl_validator.rs
└── tests/
    └── fixtures/             # Example SAMM models

API Highlights

Model Query API

Powerful introspection and analysis:

use oxirs_samm::query::ModelQuery;

let query = ModelQuery::new(&aspect);

// Find optional properties
let optional = query.find_optional_properties();

// Analyze complexity
let metrics = query.complexity_metrics();
println!("Properties: {}", metrics.total_properties);
println!("Max nesting: {}", metrics.max_nesting_depth);

// Build dependency graph
let dependencies = query.build_dependency_graph();

// Detect circular dependencies
let cycles = query.detect_circular_dependencies();

Model Transformation API

Fluent API for model refactoring:

use oxirs_samm::transformation::ModelTransformation;

let mut aspect = create_aspect();
let mut transformation = ModelTransformation::new(&mut aspect);

transformation.rename_property("oldName", "newName");
transformation.change_namespace("old:namespace", "new:namespace");
transformation.make_property_optional("propertyName");

let result = transformation.apply();
println!("Applied {} transformations", result.transformations_applied);

Model Comparison API

Version comparison with diff generation:

use oxirs_samm::comparison::ModelComparison;

let v1 = parse_aspect_model("v1.ttl").await?;
let v2 = parse_aspect_model("v2.ttl").await?;

let comparison = ModelComparison::compare(&v1, &v2);

println!("Added properties: {}", comparison.properties_added.len());
println!("Breaking changes: {}", comparison.has_breaking_changes());

let report = comparison.generate_report();

Code Examples

Defining an Aspect

use oxirs_samm::metamodel::{Aspect, Property, Characteristic, CharacteristicKind};

let mut aspect = Aspect::new("urn:samm:com.example:1.0.0#Movement".to_string());
aspect.metadata.add_preferred_name("en".to_string(), "Movement".to_string());

let property = Property::new("urn:samm:com.example:1.0.0#speed".to_string())
    .with_characteristic(
        Characteristic::new(
            "urn:samm:com.example:1.0.0#SpeedCharacteristic".to_string(),
            CharacteristicKind::Measurement {
                unit: "unit:kilometrePerHour".to_string(),
            },
        )
    );

aspect.add_property(property);

Parsing from Turtle

use oxirs_samm::parser::parse_aspect_from_string;

let ttl = r#"
@prefix : <urn:samm:com.example:1.0.0#> .
@prefix samm: <urn:samm:org.eclipse.esmf.samm:meta-model:2.3.0#> .
@prefix samm-c: <urn:samm:org.eclipse.esmf.samm:characteristic:2.3.0#> .

:Movement a samm:Aspect ;
   samm:preferredName "Movement"@en ;
   samm:properties ( :speed ) .

:speed a samm:Property ;
   samm:characteristic :SpeedCharacteristic .

:SpeedCharacteristic a samm-c:Measurement ;
   samm:dataType xsd:float ;
   samm-c:unit unit:kilometrePerHour .
"#;

let aspect = parse_aspect_from_string(ttl, "http://example.org").await?;

CLI Integration

The oxirs aspect command suite provides tools for working with SAMM Aspect Models (Java ESMF SDK compatible):

# Validate a SAMM Aspect model
oxirs aspect validate AspectModel.ttl
oxirs aspect validate AspectModel.ttl --detailed
oxirs aspect validate AspectModel.ttl --format json

# Pretty-print a model
oxirs aspect prettyprint AspectModel.ttl
oxirs aspect prettyprint AspectModel.ttl -o formatted.ttl

# Generate Rust code
oxirs aspect AspectModel.ttl to rust

# Generate Markdown documentation
oxirs aspect AspectModel.ttl to markdown

# Generate JSON Schema
oxirs aspect AspectModel.ttl to jsonschema

# Generate OpenAPI 3.1 specification
oxirs aspect AspectModel.ttl to openapi

# Generate AsyncAPI 2.6 specification
oxirs aspect AspectModel.ttl to asyncapi

# Generate HTML documentation
oxirs aspect AspectModel.ttl to html

# Generate GraphQL schema
oxirs aspect AspectModel.ttl to graphql

# Generate TypeScript interfaces
oxirs aspect AspectModel.ttl to typescript

# Generate Python dataclasses
oxirs aspect AspectModel.ttl to python

# Generate Java code (POJOs/Records)
oxirs aspect AspectModel.ttl to java

# Generate Scala case classes
oxirs aspect AspectModel.ttl to scala

# Generate SQL DDL (PostgreSQL)
oxirs aspect AspectModel.ttl to sql --format postgresql

# Generate AAS (Asset Administration Shell) JSON
oxirs aspect AspectModel.ttl to aas --format json

# Generate diagram (DOT format)
oxirs aspect AspectModel.ttl to diagram --format dot

# Generate diagram (SVG format, requires Graphviz installed)
oxirs aspect AspectModel.ttl to diagram --format svg

# Generate sample JSON payload
oxirs aspect AspectModel.ttl to payload

# Generate JSON-LD with semantic context
oxirs aspect AspectModel.ttl to jsonld

Java ESMF SDK Compatibility

OxiRS is a drop-in replacement for the Java ESMF SDK. Simply replace samm with oxirs in your commands:

# Java ESMF SDK
samm aspect Movement.ttl to aas --format xml

# OxiRS (identical syntax, just replace 'samm' with 'oxirs')
oxirs aspect Movement.ttl to aas --format xml

AAS Integration - Industry 4.0 Support

OxiRS Alpha.3 includes bidirectional AAS (Asset Administration Shell) integration:

# Convert AAS Submodel Templates to SAMM Aspect Models
oxirs aas AssetAdminShell.aasx to aspect
oxirs aas AssetAdminShell.aasx to aspect -d output/
oxirs aas AssetAdminShell.aasx to aspect -s 1 -s 2 -d output/

# List all submodel templates in an AAS file
oxirs aas AssetAdminShell.aasx list

# Supports all AAS formats (XML, JSON, AASX)
oxirs aas file.xml to aspect        # XML format
oxirs aas file.json to aspect       # JSON format
oxirs aas file.aasx to aspect       # AASX (default)

Implementation Status (Alpha.3):

• ✅ CLI command structure and routing
• ✅ File format detection (XML/JSON/AASX)
• ✅ Java ESMF SDK compatible syntax
• 🚧 AAS parser implementation (in progress)
• 🚧 Submodel template extraction (in progress)
• 🚧 AAS to SAMM conversion logic (in progress)

Complete command comparison: See SAMM_CLI_COMPARISON.md

Testing and Quality

Test Coverage

359 tests passing (100% pass rate):

• 224 unit tests
• 16 advanced integration tests
• 13 fuzz tests
• 11 integration tests
• 11 memory stress tests
• 8 lifecycle tests
• 14 performance regression tests
• 8 property-based tests (proptest generators)
• 12 property-based tests (proptest metadata)
• 42 documentation tests

Quality Metrics

Performance Benchmarks

All generators and parsers are benchmarked:

• Parser benchmarks (5): Aspect, Property, Characteristic parsing
• Generator benchmarks (6): TypeScript, Java, Python, GraphQL, JSON Schema, OpenAPI
• Validation benchmarks (4): SHACL validation, quick validation

Run benchmarks:

cargo bench

Property-Based Testing

Comprehensive property-based testing with proptest:

• Metadata properties: URN generation, name validation, version parsing
• Generator properties: Round-trip testing, format correctness
• 1000+ test cases per property test

Fuzz Testing

Robust fuzz testing for parser resilience:

• Malformed Turtle: Syntax errors, missing semicolons, invalid datatypes
• Large inputs: 10KB-1MB models for memory efficiency
• Invalid URNs: Malformed namespace patterns
• Edge cases: Empty models, circular references, deep nesting

Production Readiness

API Stability

✅ Published: API_STABILITY.md

• SemVer guarantees for public APIs
• Backward compatibility policy
• Deprecation process
• MSRV policy (Rust 1.75+)

Migration Guide

✅ Published: MIGRATION_GUIDE.md

• Java ESMF SDK to OxiRS migration
• API comparison tables
• Code examples for common patterns
• Breaking change handling

Documentation

✅ 100% Coverage:

• All public APIs documented with examples
• 42 documentation tests
• 6 comprehensive runnable examples
• Architecture and design decisions

Development Status

✅ Beta.1 Production-Ready (v0.1.0-beta.1+++++++++++++)

All major features complete and tested:

• SAMM 2.0.0-2.3.0 full specification support
• RDF/Turtle parsing with streaming
• SHACL validation engine
• 16 code generation formats
• Model query, transformation, comparison APIs
• HTTP/HTTPS URN resolution with caching
• Error recovery strategies
• Performance optimizations (parallel, streaming)
• Production metrics and health checks
• BAMM to SAMM migration
• Comprehensive testing (359 tests)
• API stability guarantees
• Migration guide for Java users
• 6 runnable examples
• Multi-file code generation

🎯 Toward GA Release (v0.1.0)

Remaining items for General Availability:

• Community feedback and API refinement
• Performance benchmarking on large models (>10K triples)
• Documentation website (docs.rs ready)
• Crate publication to crates.io

📅 Future Enhancements (v0.2.0+)

• Plugin architecture for custom generators
• Visual model editor integration
• SAMM 2.4.0 specification updates
• Advanced SciRS2 integration (graph algorithms, SIMD)
• Template system for custom output formats

References

• SAMM Specification
• Eclipse ESMF Project
• Eclipse ESMF SDK (Java)
• OxiRS Project

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE)
• MIT License (LICENSE-MIT)

at your option.

Contributing

Contributions are welcome! This is part of the OxiRS project. Please see the main CONTRIBUTING.md for guidelines.

Note: This crate is part of the OxiRS ecosystem, a Rust-native platform for Semantic Web, SPARQL 1.2, GraphQL, and AI-augmented reasoning.