Skip to content

type_bridge.rules

rules

Validation rule builder for type-bridge.

Provides a Pythonic API for defining custom validation rules that are evaluated by the Rust core engine via a portable JSON DSL.

Example::

from type_bridge.rules import RuleBuilder

rules = (
    RuleBuilder()
    .required("name-req", entity="person", attribute="name")
    .regex("email-fmt", attribute="email", pattern=r"^.+@.+\..+$")
    .range("age-bounds", attribute="age", min=0, max=150)
)

json_str = rules.to_json()

RuleBuilder 

RuleBuilder()

Fluent builder for constructing validation rules as JSON DSL.

Source code in type_bridge/rules.py 
29
30
def __init__(self) -> None:
    self._rules: list[dict[str, Any]] = []

required 

required(rule_id, *, entity, attribute, message=None)

Add a Required rule (scoped to an entity type).

Source code in type_bridge/rules.py 
54
55
56
57
58
59
60
61
62
63
64
def required(
    self,
    rule_id: str,
    *,
    entity: str,
    attribute: str,
    message: str | None = None,
) -> Self:
    """Add a Required rule (scoped to an entity type)."""
    target = self._target(attribute, entity)
    return self._add(rule_id, target, {"type": "Required"}, message)

regex 

regex(rule_id, *, attribute, pattern, entity=None, message=None)

Add a Regex rule.

Source code in type_bridge/rules.py 
66
67
68
69
70
71
72
73
74
75
76
77
def regex(
    self,
    rule_id: str,
    *,
    attribute: str,
    pattern: str,
    entity: str | None = None,
    message: str | None = None,
) -> Self:
    """Add a Regex rule."""
    target = self._target(attribute, entity)
    return self._add(rule_id, target, {"type": "Regex", "data": {"pattern": pattern}}, message)

range 

range(rule_id, *, attribute, min=None, max=None, entity=None, message=None)

Add a Range rule.

Source code in type_bridge/rules.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def range(
    self,
    rule_id: str,
    *,
    attribute: str,
    min: float | None = None,
    max: float | None = None,
    entity: str | None = None,
    message: str | None = None,
) -> Self:
    """Add a Range rule."""
    target = self._target(attribute, entity)
    return self._add(
        rule_id, target, {"type": "Range", "data": {"min": min, "max": max}}, message
    )

values 

values(rule_id, *, attribute, allowed, entity=None, message=None)

Add a Values (allowlist) rule.

Source code in type_bridge/rules.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
def values(
    self,
    rule_id: str,
    *,
    attribute: str,
    allowed: list[Any],
    entity: str | None = None,
    message: str | None = None,
) -> Self:
    """Add a Values (allowlist) rule."""
    target = self._target(attribute, entity)
    return self._add(rule_id, target, {"type": "Values", "data": {"allowed": allowed}}, message)

cardinality 

cardinality(rule_id, *, entity, attribute, min=0, max=None, message=None)

Add a Cardinality rule (scoped to an entity type).

Source code in type_bridge/rules.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
def cardinality(
    self,
    rule_id: str,
    *,
    entity: str,
    attribute: str,
    min: int = 0,
    max: int | None = None,
    message: str | None = None,
) -> Self:
    """Add a Cardinality rule (scoped to an entity type)."""
    target = self._target(attribute, entity)
    return self._add(
        rule_id, target, {"type": "Cardinality", "data": {"min": min, "max": max}}, message
    )

length 

length(rule_id, *, attribute, min=None, max=None, entity=None, message=None)

Add a Length rule.

Source code in type_bridge/rules.py 
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
def length(
    self,
    rule_id: str,
    *,
    attribute: str,
    min: int | None = None,
    max: int | None = None,
    entity: str | None = None,
    message: str | None = None,
) -> Self:
    """Add a Length rule."""
    target = self._target(attribute, entity)
    return self._add(
        rule_id, target, {"type": "Length", "data": {"min": min, "max": max}}, message
    )

to_json 

to_json()

Serialize rules to a portable JSON DSL string.

Source code in type_bridge/rules.py 
140
141
142
def to_json(self) -> str:
    """Serialize rules to a portable JSON DSL string."""
    return json.dumps({"rules": self._rules}, indent=2)

build 

build()

Return rules as a list of dicts.

Source code in type_bridge/rules.py 
144
145
146
def build(self) -> list[dict[str, Any]]:
    """Return rules as a list of dicts."""
    return list(self._rules)