Graphantic Schema Validation

# Python (included in ison-graph)
pip install ison-graph

# TypeScript (included in ison-graph-ts)
npm install ison-graph-ts

# Rust (included in ison-graph-rs)
cargo add ison-graph-rs

from ison_graph.schema import (
    GraphSchema, NodeType, EdgeType,
    StringField, IntField, Cardinality
)

# Define node types
Person = NodeType('person') \
    .id(IntField()) \
    .field('name', StringField().required().max(100)) \
    .field('age', IntField().min(0).max(150)) \
    .field('email', StringField().email())

Company = NodeType('company') \
    .id(IntField()) \
    .field('name', StringField().required()) \
    .field('employees', IntField().min(1))

# Define edge types
Knows = EdgeType('KNOWS') \
    .from_node(Person) \
    .to_node(Person) \
    .field('since', IntField()) \
    .no_self_loop() \
    .unique()

WorksAt = EdgeType('WORKS_AT') \
    .from_node(Person) \
    .to_node(Company) \
    .field('role', StringField()) \
    .cardinality(Cardinality.MANY_TO_ONE)

# Create schema
schema = GraphSchema('social') \
    .node_types(Person, Company) \
    .edge_types(Knows, WorksAt) \
    .no_orphans()

# Validate a graph
result = schema.validate(graph)

if result.valid:
    print("Graph is valid!")
else:
    for error in result.errors:
        print(f"{error.code}: {error.message}")

StringField()
    .required()              # Must be present
    .min(1)                  # Minimum length
    .max(100)                # Maximum length
    .pattern(r'\w+')         # Regex pattern
    .email()                 # Email format
    .enum('a', 'b', 'c')     # Allowed values

IntField()
    .required()              # Must be present
    .min(0)                  # Minimum value
    .max(100)                # Maximum value
    .range(0, 100)           # Min and max together

FloatField()
    .required()
    .min(0.0)
    .max(1.0)
    .range(0.0, 100.0)

BoolField()
    .required()
    .default(True)

RefField('person')           # Reference to person nodes
    .required()
    .to('company')           # Alternative syntax

Person = NodeType('person')
    .id(IntField())                              # ID field type
    .field('name', StringField().required())     # Add property
    .field('age', IntField().min(0))
    .constraint(lambda n: n['age'] < 150)        # Custom validation

Knows = EdgeType('KNOWS')
    .from_node(Person)       # Source node type
    .to_node(Person)         # Target node type
    .field('since', IntField())
    .no_self_loop()          # Disallow A -> A
    .unique()                # No duplicate edges
    .acyclic()               # Enforce DAG
    .bidirectional()         # Require symmetric edges
    .cardinality(Cardinality.ONE_TO_MANY)
    .constraint(lambda e: e['since'] > 1900)

schema = GraphSchema('my_graph')
    .node_types(Person, Company, Product)
    .edge_types(Knows, WorksAt, Purchased)
    .connected()             # All nodes reachable
    .no_orphans()            # All nodes have edges
    .max_depth(10)           # Maximum path length
    .constraint(fn)          # Custom graph constraint

result = schema.validate(graph)

# Check if valid
if result.valid:
    print("All good!")
else:
    # Access errors
    for error in result.errors:
        print(f"Code: {error.code}")
        print(f"Message: {error.message}")
        print(f"Path: {error.path}")
        print(f"Value: {error.value}")