READMEBetterlol/moon_zod/core does not have a README file
#SchemaResult
Result type returned by Schema::parse.
Ok(json) on success, Err(errors) with all collected errors on failure.
#ConstraintInfo
pub(all) struct ConstraintInfo {
min_value : Double
max_value : Double
format : String
pattern : String
is_int : Bool
is_positive : Bool
is_negative : Bool
multiple_of : Double
custom_messages : Array[String]
}Unified constraint information extracted from Rule annotations.
This data structure consolidates all constraint metadata across different types.
#ObjectMode
Object validation mode.
#Rule
A single validation rule: a predicate + error message + optional JSON Schema annotation.
#Schema
pub(all) struct Schema {
schema_type : SchemaType
rules : Array[Rule]
description : String
required_error : String
invalid_type_error : String
name : String
brand : String
} derive(Debug)A schema defines the shape and constraints of JSON data.
#Schema::brand
Assign a brand to a schema for nominal typing.
Branded schemas carry a type-level marker that distinguishes
structurally identical schemas (e.g., UserId vs string).
The brand is rendered in prompt and JSON Schema exports.
#Schema::cuid
Require the string to be a valid CUID (25 chars, starts with 'c', alphanumeric).
#Schema::datetime
Require the string to be a valid ISO 8601 datetime.
#Schema::default
Provide a default value when the input is null.
Rules chained after .default() are pushed through to the inner schema
via append_rule.
#Schema::describe
Attach a human-readable description to a schema.
The description is rendered by schema_to_prompt() alongside type and constraints,
helping LLMs understand the semantic meaning of each field.
#Schema::email
Require the string to be a valid email.
#Schema::endsWith
Require the string to end with the given suffix.
#Schema::extend_with
Extend an object schema with additional fields.
Fields in extension override fields with the same name in the base schema.
#Schema::finite
Require the number to be finite (reject Infinity and NaN).
#Schema::includes
Require the string to contain the given substring.
#Schema::int
Require the number to be an integer (no fractional part).
#Schema::intersect
Combine two schemas with intersection (both must match).
Equivalent to intersection([self, other]).
#Schema::invalid_type_error
Override the error message when the input type does not match.
#Schema::ip
Require the string to be a valid IPv4 or IPv6 address.
#Schema::ipv4
Require the string to be a valid IPv4 address.
#Schema::ipv6
Require the string to be a valid IPv6 address.
#Schema::length
Require the string or array to have exactly n items.
#Schema::max
Require the string length to be at most n.
#Schema::merge
Merge two object schemas.
Fields from other override fields with the same name in self.
The merged schema inherits the right schema's object mode.
#Schema::message
Override the error message of the last rule in the chain.
Peels through OptionalType / DefaultType / TransformType wrappers
to find the base schema with the rules array.
Example
string().min(2).message("姓名至少需要 2 个字符")#Schema::min
Require the string length to be at least n.
#Schema::multipleOf
Require the number to be a multiple of n.
#Schema::name
Give a schema a name for export.
When used with schema_to_prompt_named(), named schemas are extracted as separate
interface/type definitions in the generated prompt, supporting Object and Enum types.
#Schema::negative
Require the number to be negative (< 0).
#Schema::nonempty
Require the string to be non-empty (or array to be non-empty).
#Schema::omit
Omit the specified fields from an object schema.
Returns a new object schema with the same mode (Strip/Passthrough/Strict).
Example
let s = object({"a": string(), "b": number()}).omit(["b"])
s.parse(json) // validates only field "a"#Schema::optional
Make a field optional: null or missing values pass validation.
Rules chained after .optional() are pushed through to the inner schema
via append_rule, so string().optional().min(3) works correctly.
#Schema::parse
Validate json against this schema.
Public API — accepts an optional root path string.
Internally converts to a mutable path stack to avoid string allocations
on the success path.
#Schema::parse_array
#Schema::parse_default
#Schema::parse_enum
#Schema::parse_intersection
#Schema::parse_literal
#Schema::parse_object
fn Schema::parse_object(self : Schema, spec : Map[String, Schema], mode : ObjectMode, json : Json, path_stack : Array[String]) -> Result[Json, Array[ValidationError]]#Schema::parse_optional
#Schema::parse_preprocess
fn Schema::parse_preprocess(self : Schema, closure : TransformClosure, inner : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[ValidationError]]#Schema::parse_transform
fn Schema::parse_transform(_self : Schema, inner : Schema, closure : TransformClosure, json : Json, path_stack : Array[String]) -> Result[Json, Array[ValidationError]]#Schema::parse_tuple
#Schema::parse_union
#Schema::partial
Make all fields of an object schema optional.
Useful for partial updates (e.g., PATCH operations).
Existing optional fields remain optional.
Example
let s = object({"name": string(), "age": number()}).partial()
s.parse(json) // all fields are now optional#Schema::passthrough
Allow fields not defined in the schema spec.
#Schema::pick
Select only the specified fields from an object schema.
Returns a new object schema with the same mode (Strip/Passthrough/Strict).
Keys not present in the original spec are silently ignored.
Example
let s = object({"a": string(), "b": number()}).pick(["a"])
s.parse(json) // validates only field "a"#Schema::positive
Require the number to be positive (> 0).
#Schema::refine
Add a custom validation rule.
check is a predicate on the JSON value; message is the error message
shown when the predicate returns false.
#Schema::regex
Require the string to match the given regex pattern.
#Schema::required_error
Override the error message when a required field is missing.
Only effective when this schema is used as an object field value.
#Schema::safe
Require the number to be a safe integer (within ±2^53-1).
#Schema::startsWith
Require the string to start with the given prefix.
#Schema::strict
Reject fields not defined in the schema spec.
#Schema::strip
Silently strip extra fields not defined in the schema spec.
This is the default mode.
#Schema::transform
Apply a transformation function to the validated JSON value.
The schema is first validated normally. If validation succeeds, f is
called with the validated JSON. The transform can modify the value or
return an error.
Rules chained after .transform() are applied to the transformed value.
Example
let s = string().transform(fn(json) {
match json {
String(s) => Ok(Json::string(s + "!"))
_ => Err("expected string")
}
})#Schema::trim
Trim leading and trailing whitespace from the string.
#Schema::ulid
Require the string to be a valid ULID (26 chars, Crockford Base32).
#Schema::url
Require the string to be a valid URL with http:// or https:// scheme.
#SchemaType
pub(all) enum SchemaType {
StringType
NumberType
BooleanType
NullType
AnyType
UnknownType
ObjectType(Map[String, Schema], ObjectMode)
ArrayType(Schema)
TupleType(Array[Schema])
OptionalType(Schema)
DefaultType(Schema, Json)
EnumType(Array[String])
UnionType(Array[Schema])
IntersectionType(Array[Schema])
PreprocessType(TransformClosure, Schema)
TransformType(Schema, TransformClosure)
LiteralType(Json)
} derive(Debug)Internal tag for runtime type dispatch.
#TransformClosure
Internal wrapper for a transform function stored in TransformType.
#ValidationError
Represents a single validation failure.
path is the field path (e.g. "name", "address.city").
message describes what went wrong.
got is the actual JSON value that failed validation.
#ValidationError::to_string
Format a validation error as a human-readable string.
Uses Debug for the received value to avoid Show deprecation.
#any
Create a schema that accepts any JSON value.
#append_rule
Append a rule through decoration wrappers.
#append_rule_with_annotation
Append a rule with a JSON Schema annotation fragment.
The annotation is merged into the JSON Schema output when to_json_schema()
is called, enabling constraint export (minLength, maximum, pattern, etc.).
#array
Create a schema that validates JSON arrays.
Each element in the array is validated against element_schema.
#bigint
Create a schema that validates JSON integer values as big integers.
This is a convenience alias for number().int() that expresses
semantic intent. Useful for financial amounts, large IDs, and
other scenarios where the semantic type is "big integer" rather
than "number that is an integer".
#boolean
Create a schema that validates JSON booleans.
#collect_named_schemas
Collect all named schemas from the input schema tree.
#collect_named_schemas_impl
#constraint_comment
Extract and format constraint comment for a schema (without description).
Dispatches to type-appropriate formatter based on the unwrapped schema type.
#constraint_info_default
Create a default empty ConstraintInfo
#constraint_info_to_array_comment
Convert ConstraintInfo to prompt comment string for arrays.
#constraint_info_to_fallback_comment
Convert ConstraintInfo to prompt comment string (fallback for unknown types).
#constraint_info_to_number_comment
Convert ConstraintInfo to prompt comment string for numbers.
#constraint_info_to_string_comment
Convert ConstraintInfo to prompt comment string for strings.
#dfs_topo_sort
DFS for topological sorting. Adds schemas to sorted list in dependency order.
#enum_values
Create a schema that accepts one of a fixed set of string values.
#escape_function_name
fn escape_function_name(name : String) -> Stringescape a string to be a valid MoonBit function name (lowercase first letter, valid identifier).
#escape_ident
fn escape_ident(name : String) -> Stringescape a string to be a valid MoonBit identifier by replacing invalid characters with underscores.
#escape_mbt_string
fn escape_mbt_string(s : String) -> StringEscape a string for use in MoonBit code, handling backslashes, quotes, newlines, and tabs.
#escape_type_name
fn escape_type_name(name : String) -> Stringescape a string to be a valid MoonBit type name (uppercase first letter, valid identifier).
#escape_variable_name
fn escape_variable_name(name : String) -> Stringescape a string to be a valid MoonBit variable name (lowercase first letter, valid identifier).
#extract_constraints
Extract all constraint information from a Rule array.
Unified extraction that works across all types.
#filter_named_schemas
Filter named schemas based on include_names optional parameter.
If include_names is None, returns all schemas.
If Some(names), returns only schemas whose names are in the list.
#find_schema_dependencies
Find all named schema dependencies within a schema.
#find_schema_dependencies_impl
#format_double_simple
fn format_double_simple(v : Double) -> StringFormat a Double as a string, stripping ".0" for whole numbers.
#inner_type
Peel OptionalType / DefaultType wrappers to find the effective base type.
#intersection
Create a schema that requires all given schemas to match (intersection / and).
For objects, fields from all schemas are merged into one.
#is_keyword
fn is_keyword(name : String) -> BoolCheck if a name is a reserved keyword in MoonBit.
#json_infer_schema
Generate a schema from a JSON value.
Simple heuristics are used to infer types and constraints from the value.
#literal
Create a schema that accepts a specific literal JSON value.
The value must match exactly (String, Number, Boolean, or Null).
Example
let schema = @moon_zod.literal(Json::string("hello"))
schema.parse(Json::string("hello")) // Ok
schema.parse(Json::string("world")) // Err#null
Create a schema that validates JSON null.
#number
Create a schema that validates JSON numbers.
#object
Create a schema that validates JSON objects.
Each key in spec defines a required field and its schema.
By default, extra fields in the input JSON are silently stripped (Strip mode).
Use .passthrough() to allow extra fields, or .strict() to reject them.
#peel_optional
Peel OptionalType / DefaultType wrappers to check optionality.
#preprocess
Preprocess a JSON value before validating it with inner.
This is the inverse order of .transform(): f runs on raw input first,
then the returned JSON value is validated against inner.
#string
Create a schema that validates JSON strings.
#topological_sort_schemas
Topologically sort named schemas so dependents come before dependees.
#tuple
Create a schema that validates fixed-length JSON arrays.
Each item in items validates the array element at the same index.
#union
Create a schema that accepts any of the given schemas (union / or).
Schemas are tried in order; the first match succeeds.
#unknown
Create a schema that accepts any JSON value as unknown.
Runtime behavior matches any(); the distinction is semantic for consumers.
#unwrap_schema
Peel OptionalType / DefaultType / TransformType wrappers to find the
innermost schema that carries the actual rules.
#value_in_array
Check if a value is in an array of strings.
#visited_contains
Helper: check if a name is in visited list
#visited_get_status
Helper: get status from visited list (0 = unvisited by default)
A runtime JSON schema validation library for MoonBit, inspired by Zod and Pydantic
jsonschemavalidationzodllmtool-calling
0.8.2
Apache-2.0
Updated last month
64 downloadsDependencies
- moonbitlang/regexp0.3.5