Betterlol/moon_zod/core

README
U
Constraint
U
ConstraintInfo
U
JsonNullable
U
JsonSchemaRenderer
U
NumericBound
U
ObjectMode
U
PathSegment
U
Rule
U
Schema
U
SchemaResult
U
SchemaType
U
SchemaView
U
StreamParseResult
U
StreamParser
U
StringRenderer
U
TransformClosure
U
TransformKind
U
ValidationError
V
any
V
append_rule
V
append_rule_with_annotation
V
array
V
bigint
V
boolean
V
collect_named_schemas
V
constraint_comment
V
constraint_info_default
V
constraint_info_to_array_comment
V
constraint_info_to_fallback_comment
V
constraint_info_to_number_comment
V
constraint_info_to_string_comment
V
discriminated_union
V
effective_rules
V
enum_values
V
escape_ident
V
escape_mbt_string
V
escape_variable_name
V
extract_constraints
V
filter_named_schemas
V
format_double_simple
V
format_path
V
format_path_segments
V
indent_str
V
inner_type
V
intersection
V
is_optional_schema
V
join_parts
V
json_infer_schema
V
json_schema_to_moon_zod
V
json_schema_to_prompt
V
json_schema_to_schema
V
literal
V
null
V
number
V
object
V
output_is_optional
V
parse_json
V
parse_path
V
peel_optional
V
preprocess
V
recursive
V
schema_children
V
schema_to_moon_zod_code
V
schema_to_moon_zod_code_inline_with_refs
V
schema_to_moon_zod_code_named
V
schema_to_moonbit_struct
V
schema_to_moonbit_struct_full
V
schema_to_prompt
V
schema_to_prompt_named
V
string
V
sub_index
V
sub_path
V
to_json_schema
V
to_json_schema_named
V
to_json_schema_skeleton
V
topological_sort_schemas
V
try_collect_named_schemas
V
try_schema_nodes
V
try_schema_to_moon_zod_code
V
try_to_json_schema
V
tuple
V
union
V
unknown
V
unwrap_schema
V
value_in_array

Betterlol/moon_zod/core does not have a README file

ErrorMap

type ErrorMap = (IssueCode, String, Json) -> String?

Error map function: contextual override for error messages. Returns Some(msg) to override, None to fall through to the pre-resolved message.

RawSchemaResult

source

type RawSchemaResult = Result[Json, Array[RawIssue]]

Internal result type used during parsing before error message finalization.

SchemaResult

source

type SchemaResult = Result[Json, Array[ValidationError]]

Result type returned by Schema::parse. Ok(json) on success, Err(errors) with all collected errors on failure.

NumericBound

source

pub(open) trait NumericBound {
  fn to_bound(Self) -> Double
}

Numeric bounds accept both integer arguments and Double arguments.

impl NumericBound for Int

impl NumericBound for Int64

impl NumericBound for Double

Constraint

source

pub(all) enum Constraint {
  Minimum(String, Double, Bool)
  Maximum(String, Double, Bool)
  ExactLength(String, Int)
  Multiple(Double)
  Integer
  Format(String)
  Pattern(String)
  Prefix(String)
  Suffix(String)
  Contains(String)
  Finite
  SafeInteger
  Opaque
} derive(@moonbitlang/core/debug.Debug
Debug)

A built-in constraint's semantic identity, independent of rendered messages.

Constraint::to_repr

source

#deprecated("`Constraint::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Constraint::to_repr(Constraint) -> @moonbitlang/core/debug.Repr
Repr

ConstraintInfo

source

pub(all) struct ConstraintInfo {
  min_value : Double?
  max_value : Double?
  min_inclusive : Bool
  max_inclusive : Bool
  format : String
  pattern : String
  patterns : Array[String]
  formats : Array[String]
  is_int : Bool
  is_positive : Bool
  is_negative : Bool
  multiple_of : Double
  multiples : Array[Double]
  custom_messages : Array[String]
}

Constraint metadata uses optional bounds, preserving negative values.

IssueCode

source

pub(all) enum IssueCode {
  InvalidType(String)
  TooBig(String, Double, Bool)
  TooSmall(String, Double, Bool)
  InvalidFormat(String)
  NotMultipleOf(Double)
  UnrecognizedKeys(Array[String])
  InvalidUnion(Array[Array[RawIssue]])
  MissingRequired(String)
  InvalidKey(String)
  InvalidElement(String, Int)
  InvalidValue(Array[Json])
  Custom
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Machine-readable issue code for structured error classification.

IssueCode::equal

source

#deprecated("`IssueCode::equal` is deprecated, use `Eq::equal` instead.")
fn IssueCode::equal(IssueCode, IssueCode) -> Bool

IssueCode::not_equal

source

#deprecated("`IssueCode::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn IssueCode::not_equal(x : IssueCode, y : IssueCode) -> Bool

IssueCode::to_repr

source

#deprecated("`IssueCode::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn IssueCode::to_repr(IssueCode) -> @moonbitlang/core/debug.Repr
Repr

ObjectMode

source

pub(all) enum ObjectMode {
  Passthrough
  Strict
  Strip
} derive(@moonbitlang/core/debug.Debug
Debug)

Object validation mode.

ObjectMode::to_repr

source

#deprecated("`ObjectMode::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ObjectMode::to_repr(ObjectMode) -> @moonbitlang/core/debug.Repr
Repr

ParseParams

source

pub(all) struct ParseParams {
  path : String
  error_map : (IssueCode, String, Json) -> String??
}

Parameters for Schema::safe_parse.

ParseParams::default

source

fn ParseParams::default() -> ParseParams

PathSegment

source

pub(all) enum PathSegment {
  Field(String)
  Index(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A lossless path segment distinguishes literal object keys from array indices.

PathSegment::equal

source

#deprecated("`PathSegment::equal` is deprecated, use `Eq::equal` instead.")
fn PathSegment::equal(PathSegment, PathSegment) -> Bool

PathSegment::not_equal

source

#deprecated("`PathSegment::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn PathSegment::not_equal(x : PathSegment, y : PathSegment) -> Bool

PathSegment::to_repr

source

#deprecated("`PathSegment::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn PathSegment::to_repr(PathSegment) -> @moonbitlang/core/debug.Repr
Repr

RawIssue

source

pub(all) struct RawIssue {
  code : IssueCode
  path : String
  message : String
  input : Json
  path_segments : Array[PathSegment]
  explicit_message : Bool
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A raw validation issue with the message pre-resolved at the generation site. No Schema reference needed — messages are resolved immediately from rule.message / schema.invalid_type_error / schema.required_error / hardcoded default.

RawIssue::equal

source

#deprecated("`RawIssue::equal` is deprecated, use `Eq::equal` instead.")
fn RawIssue::equal(RawIssue, RawIssue) -> Bool

RawIssue::not_equal

source

#deprecated("`RawIssue::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn RawIssue::not_equal(x : RawIssue, y : RawIssue) -> Bool

RawIssue::to_repr

source

#deprecated("`RawIssue::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn RawIssue::to_repr(RawIssue) -> @moonbitlang/core/debug.Repr
Repr

Rule

source

pub(all) struct Rule {
  constraint : Constraint
  explicit_message : Bool
  check : (Json) -> Bool
  message : String
  code : IssueCode
  annotation : Json
} derive(@moonbitlang/core/debug.Debug
Debug)

A single validation rule: a predicate + error message + optional JSON Schema annotation.

Rule::to_repr

source

#deprecated("`Rule::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Rule::to_repr(Rule) -> @moonbitlang/core/debug.Repr
Repr

Schema

source

pub(all) struct Schema {
  id : Int
  schema_type : SchemaType
  rules : Array[Rule]
  description : String
  required_error : String
  invalid_type_error : String
  name : String
  brand : String
} derive(@moonbitlang/core/debug.Debug
Debug)

A schema defines the shape and constraints of JSON data.

Schema::brand

source

fn Schema::brand(self : Schema, text : String) -> Schema

Assign a brand to a schema for nominal typing. Brands are metadata (e.g., UserId); they do not create nominal MoonBit types. The brand is rendered in prompt and JSON Schema exports.

Schema::cuid

source

fn Schema::cuid(self : Schema, msg? : String) -> Schema

Require the string to be a valid CUID (25 chars, starts with 'c', alphanumeric).

Schema::datetime

source

fn Schema::datetime(self : Schema, msg? : String, offset? : Bool, allow_local? : Bool, precision? : Int) -> Schema

Require the string to be a valid ISO 8601 datetime.

Schema::default

source

fn Schema::default(self : Schema, value : Json) -> Schema

Return this output default when a key is absent. Explicit null is not replaced. Rules chained after .default() are pushed through to the inner schema via append_rule.

Schema::describe

source

fn Schema::describe(self : Schema, text : String) -> Schema

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

source

fn Schema::email(self : Schema, msg? : String) -> Schema

Require the string to be a valid email.

Schema::endsWith

source

fn Schema::endsWith(self : Schema, suffix : String, msg? : String) -> Schema

Require the string to end with the given suffix.

Schema::exclude

source

fn Schema::exclude(self : Schema, values : Array[String]) -> Schema

Exclude specific values from an enum schema. Returns a new schema with the remaining values. Aborts if called on a non-enum schema.

Example

let colors = enum_values(["red", "green", "blue"])

let no_green = colors.exclude(["green"])
// now accepts only "red" and "blue"

Schema::extend_with

source

fn Schema::extend_with(self : Schema, extension : Map[String, Schema]) -> Schema

Extend an object schema with additional fields. Fields in extension override fields with the same name in the base schema.

Schema::extract

source

fn Schema::extract(self : Schema, values : Array[String]) -> Schema

Extract specific values from an enum schema. Returns a new schema that only accepts the specified values. Aborts if called on a non-enum schema.

Example

let colors = enum_values(["red", "green", "blue"])

let warm = colors.extract(["red", "orange"]) // "orange" ignored, only "red" kept
// now accepts only "red"

Schema::finite

source

fn Schema::finite(self : Schema, msg? : String) -> Schema

Require the number to be finite (reject Infinity and NaN).

Schema::gt

source

fn[N : NumericBound] Schema::gt(self : Schema, bound : N, msg? : String) -> Schema

Require a number to be strictly greater than a finite bound.

Schema::includes

source

fn Schema::includes(self : Schema, substring : String, msg? : String) -> Schema

Require the string to contain the given substring.

Schema::int

source

fn Schema::int(self : Schema, msg? : String) -> Schema

Require the number to be an integer (no fractional part).

Schema::intersect

source

fn Schema::intersect(self : Schema, other : Schema) -> Schema

Combine two schemas with intersection (both must match). Equivalent to intersection([self, other]).

Schema::invalid_type_error

source

fn Schema::invalid_type_error(self : Schema, text : String) -> Schema

Override the error message when the input type does not match.

Schema::ip

source

fn Schema::ip(self : Schema, msg? : String) -> Schema

Require the string to be a valid IPv4 or IPv6 address.

Schema::ipv4

source

fn Schema::ipv4(self : Schema, msg? : String) -> Schema

Require the string to be a valid IPv4 address.

Schema::ipv6

source

fn Schema::ipv6(self : Schema, msg? : String) -> Schema

Require the string to be a valid IPv6 address.

Schema::length

source

fn Schema::length(self : Schema, n : Int, msg? : String) -> Schema

Require the string or array to have exactly n items.

Schema::lt

source

fn[N : NumericBound] Schema::lt(self : Schema, bound : N, msg? : String) -> Schema

Require a number to be strictly less than a finite bound.

Schema::max

source

fn[N : NumericBound] Schema::max(self : Schema, n : N, msg? : String) -> Schema

Require the string length to be at most n.

Schema::merge

source

fn Schema::merge(self : Schema, other : Schema) -> Schema

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

source

fn Schema::message(self : Schema, text : String) -> Schema

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

source

fn[N : NumericBound] Schema::min(self : Schema, n : N, msg? : String) -> Schema

Require the string length to be at least n.

Schema::multipleOf

source

fn[N : NumericBound] Schema::multipleOf(self : Schema, n : N, msg? : String) -> Schema

Require the number to be a multiple of n.

Schema::name

source

fn Schema::name(self : Schema, text : String) -> Schema

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

source

fn Schema::negative(self : Schema, msg? : String) -> Schema

Require the number to be negative (< 0).

Schema::nonempty

source

fn Schema::nonempty(self : Schema, msg? : String) -> Schema

Require the string to be non-empty (or array to be non-empty).

Schema::nullable

source

fn Schema::nullable(self : Schema) -> Schema

Accept explicit JSON null without making an object key optional.

Schema::nullish

source

fn Schema::nullish(self : Schema) -> Schema

Accept either an absent object key or explicit JSON null.

Schema::omit

source

fn Schema::omit(self : Schema, keys : Array[String]) -> Schema

Omit the specified fields from an object schema. Returns a new object schema with the same mode (Strip/Passthrough/Strict). Aborts if a requested key is not present in the original spec.

Example

let s = object({"a": string(), "b": number()}).omit(["b"])
s.parse(json)  // validates only field "a"

Schema::optional

source

fn Schema::optional(self : Schema) -> Schema

Make a field optional: absent keys pass; explicit null is validated normally. Rules chained after .optional() are pushed through to the inner schema via append_rule, so string().optional().min(3) works correctly.

Schema::parse

source

fn Schema::parse(self : Schema, json : Json, path? : String) -> Result[Json, Array[ValidationError]]

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

source

fn Schema::parse_array(self : Schema, element_schema : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_default

source

fn Schema::parse_default(self : Schema, inner : Schema, default_val : Json, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_discriminated_union

source

fn Schema::parse_discriminated_union(self : Schema, discriminator : String, options : Map[String, Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_enum

source

fn Schema::parse_enum(self : Schema, values : Array[String], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_intersection

source

fn Schema::parse_intersection(self : Schema, schemas : Array[Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_lazy

source

fn Schema::parse_lazy(self : Schema, f : () -> Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_literal

source

fn Schema::parse_literal(self : Schema, expected : Json, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_missing

source

fn Schema::parse_missing(self : Schema) -> Result[Json?, Array[ValidationError]]

Parse an absent value without conflating it with explicit JSON null. An absent optional result is None; a default/prefault result is Some(value).

Schema::parse_object

source

fn Schema::parse_object(self : Schema, spec : Map[String, Schema], mode : ObjectMode, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_optional

source

fn Schema::parse_optional(self : Schema, inner : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_pipe

source

fn Schema::parse_pipe(self : Schema, input_schema : Schema, bridge : TransformClosure, output_schema : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_preprocess

source

fn Schema::parse_preprocess(self : Schema, closure : TransformClosure, inner : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_stream

source

fn Schema::parse_stream(self : Schema, path? : String, max_length? : Int, max_depth? : Int) -> StreamParser

Start validating one JSON value from an incremental text stream.

Each call to StreamParser::feed() may contain one LLM token, part of a token, or multiple tokens. JSON strings and escape sequences may cross chunk boundaries. Continue feeding until EOF, then call finish() to run schema rules exactly once and confirm that no trailing content was received.

max_length bounds all input in UTF-16 code units (default 1 Mi units). max_depth bounds object/array nesting (default 128, range 1..=1024). max_length must be positive. Text is buffered until the root closes; whitespace after it is not retained.

Schema::parse_transform

source

fn Schema::parse_transform(self : Schema, inner : Schema, closure : TransformClosure, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_tuple

source

fn Schema::parse_tuple(self : Schema, items : Array[Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_union

source

fn Schema::parse_union(self : Schema, schemas : Array[Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::partial

source

fn Schema::partial(self : Schema) -> Schema

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

source

fn Schema::passthrough(self : Schema) -> Schema

Allow fields not defined in the schema spec.

Schema::pick

source

fn Schema::pick(self : Schema, keys : Array[String]) -> Schema

Select only the specified fields from an object schema. Returns a new object schema with the same mode (Strip/Passthrough/Strict). Aborts if a requested key is not present in the original spec.

Example

let s = object({"a": string(), "b": number()}).pick(["a"])
s.parse(json)  // validates only field "a"

Schema::pipe

source

fn Schema::pipe(self : Schema, output : Schema) -> Schema

Chain two schemas: validate the input against self, then validate the result against output. Errors from each stage are reported independently.

Unlike .transform(), .pipe() creates a clear two-stage pipeline where the output schema can have its own rules — errors are attributed to the correct stage.

Example

let s = string()
  .transform(fn(s) { Ok(Json::string(s.length().to_string())) })
  .pipe(number().min(5))
// string check → transform → number check(.min(5))

Schema::positive

source

fn Schema::positive(self : Schema, msg? : String) -> Schema

Require the number to be positive (> 0).

Schema::prefault

source

fn Schema::prefault(self : Schema, value : Json) -> Schema

Parse this input fallback when a key is absent. Explicit null is not replaced. Unlike default(), the fallback runs through inner validation and transforms.

Schema::refine

source

fn Schema::refine(self : Schema, check : (Json) -> Bool, message : String) -> Schema

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

source

fn Schema::regex(self : Schema, pattern : String, msg? : String) -> Schema

Require the string to match the given regex pattern.

Schema::required_error

source

fn Schema::required_error(self : Schema, text : String) -> Schema

Override the error message when a required field is missing. Only effective when this schema is used as an object field value.

Schema::safe

source

fn Schema::safe(self : Schema, msg? : String) -> Schema

Require the number to be a safe integer (within ±2^53-1).

Schema::safe_parse

source

fn Schema::safe_parse(self : Schema, json : Json, params : ParseParams) -> Result[Json, Array[ValidationError]]

Validate json against this schema with extended parameters. Supports contextual error map override.

Example

schema.safe_parse(json, { error_map: fn(code, path, input) {
  match code { InvalidType(expected) => Some("必须是: " + expected) _ => None }
}})

Schema::startsWith

source

fn Schema::startsWith(self : Schema, prefix : String, msg? : String) -> Schema

Require the string to start with the given prefix.

Schema::strict

source

fn Schema::strict(self : Schema) -> Schema

Reject fields not defined in the schema spec.

Schema::strip

source

fn Schema::strip(self : Schema) -> Schema

Silently strip extra fields not defined in the schema spec. This is the default mode.

Schema::to_lower

source

fn Schema::to_lower(self : Schema) -> Schema

Convert the string to lowercase.

Schema::to_repr

source

#deprecated("`Schema::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Schema::to_repr(Schema) -> @moonbitlang/core/debug.Repr
Repr

Schema::to_upper

source

fn Schema::to_upper(self : Schema) -> Schema

Convert the string to uppercase.

Schema::transform

source

fn Schema::transform(self : Schema, f : (Json) -> Result[Json, String]) -> Schema

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

source

fn Schema::trim(self : Schema) -> Schema

Trim leading and trailing whitespace from the string.

Schema::ulid

source

fn Schema::ulid(self : Schema, msg? : String) -> Schema

Require the string to be a valid ULID (26 chars, Crockford Base32).

Schema::url

source

fn Schema::url(self : Schema, msg? : String) -> Schema

Require an absolute URI; authority validation supports IPv4/IPv6 and ports. This portable validator does not perform WHATWG URL normalization.

Schema::uuid

source

fn Schema::uuid(self : Schema, msg? : String) -> Schema

Require the string to be a valid RFC UUID. Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx

SchemaType

source

pub(all) enum SchemaType {
  StringType
  NumberType
  BooleanType
  NullType
  AnyType
  UnknownType
  ObjectType(Map[String, Schema], ObjectMode)
  ArrayType(Schema)
  TupleType(Array[Schema])
  OptionalType(Schema)
  NullableType(Schema)
  PrefaultType(Schema, Json)
  DefaultType(Schema, Json)
  EnumType(Array[String])
  UnionType(Array[Schema])
  IntersectionType(Array[Schema])
  PreprocessType(TransformClosure, Schema)
  TransformType(Schema, TransformClosure)
  LiteralType(Json)
  LazyType(() -> Schema)
  DiscriminatedUnionType(String, Map[String, Schema])
  PipeType(Schema, TransformClosure, Schema)
} derive(@moonbitlang/core/debug.Debug
Debug)

Internal tag for runtime type dispatch.

SchemaType::to_repr

source

#deprecated("`SchemaType::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn SchemaType::to_repr(SchemaType) -> @moonbitlang/core/debug.Repr
Repr

StreamParseResult

source

pub(all) enum StreamParseResult {
  StreamPending
  StreamValid(Json)
  StreamInvalidJson(String)
  StreamInvalidSchema(Array[ValidationError])
}

The result of advancing a single-JSON streaming parser.

StreamPending means the document has not been finalized. Only finish() returns success; feed() can reject malformed input early. Other variants are terminal and subsequent calls return the same result.

StreamParser

source

pub struct StreamParser {
  // private fields
}

Mutable state for incrementally parsing and validating one JSON value.

Create this value with Schema::parse_stream(), feed arbitrary text chunks with feed(), then call finish() when the upstream token stream ends.

StreamParser::feed

source

fn StreamParser::feed(self : StreamParser, token : String) -> StreamParseResult

Feed the next text chunk into this parser.

A StreamInvalidJson result is reported as soon as an unmatched closing delimiter or trailing non-whitespace is seen. Other JSON syntax errors are reported when the root value closes or when finish() is called.

StreamParser::finish

source

fn StreamParser::finish(self : StreamParser) -> StreamParseResult

Mark the upstream token stream as finished and return its final result.

Required for every root type: success is final only at end of input.

TransformClosure

source

pub(all) struct TransformClosure {
  f : (Json) -> Result[Json, String]
  kind : TransformKind
} derive(@moonbitlang/core/debug.Debug
Debug)

Transform callbacks carry an explicit kind for inspection and source export.

TransformClosure::to_repr

source

#deprecated("`TransformClosure::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn TransformClosure::to_repr(TransformClosure) -> @moonbitlang/core/debug.Repr
Repr

TransformKind

source

pub(all) enum TransformKind {
  CustomTransform
  IdentityTransform
  TrimTransform
  LowerTransform
  UpperTransform
} derive(@moonbitlang/core/debug.Debug
Debug)

Internal wrapper for a transform function stored in TransformType.

TransformKind::to_repr

source

#deprecated("`TransformKind::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn TransformKind::to_repr(TransformKind) -> @moonbitlang/core/debug.Repr
Repr

ValidationError

source

pub(all) struct ValidationError {
  code : IssueCode
  path : String
  path_segments : Array[PathSegment]
  message : String
  got : Json
} derive(@moonbitlang/core/debug.Debug
Debug)

Represents a single validation failure.

code is the structured issue code for machine-readable error classification. 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_repr

source

#deprecated("`ValidationError::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ValidationError::to_repr(ValidationError) -> @moonbitlang/core/debug.Repr
Repr

ValidationError::to_string

source

fn ValidationError::to_string(self : ValidationError) -> String

Format a validation error as a human-readable string. Uses Debug for the received value to avoid Show deprecation.

any

source

fn any(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts any JSON value.

append_rule

source

fn append_rule(schema : Schema, check : (Json) -> Bool, message : String, code : IssueCode) -> Schema

Append a rule through decoration wrappers.

append_rule_with_annotation

source

fn append_rule_with_annotation(schema : Schema, check : (Json) -> Bool, message : String, code : IssueCode, annotation : Json) -> Schema

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

source

fn array(element_schema : Schema, required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON arrays.

Each element in the array is validated against element_schema.

bigint

source

fn bigint(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON integer values as big integers.

This is a JSON number().int() alias, limited to the safe Double integer range. It is not arbitrary precision BigInt storage. Use a validated decimal string or a dedicated numeric type for large IDs and exact financial amounts.

boolean

source

fn boolean(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON booleans.

collect_named_schemas

source

fn collect_named_schemas(schema : Schema) -> Array[Schema]

Collect all named schemas from the input schema tree.

collect_named_schemas_impl

source

fn collect_named_schemas_impl(schema : Schema, visited : Array[String], result : Array[Schema]) -> Unit

Compatibility helper; traversal is centralized in the checked collector.

collect_raw_errors

source

fn collect_raw_errors(out : Array[RawIssue], path_stack : Array[String], json : Json, rules : Array[Rule]) -> Unit

Collect raw issues from rule failures.

constraint_comment

source

fn constraint_comment(schema : Schema) -> String

Keep checks attached after built-in effects when rendering constraints.

constraint_info_default

source

fn constraint_info_default() -> ConstraintInfo

Empty constraints use None instead of a numeric sentinel.

constraint_info_to_array_comment

source

fn constraint_info_to_array_comment(info : ConstraintInfo) -> String

Render array cardinality constraints.

constraint_info_to_fallback_comment

source

fn constraint_info_to_fallback_comment(info : ConstraintInfo) -> String

Render opaque predicates.

constraint_info_to_number_comment

source

fn constraint_info_to_number_comment(info : ConstraintInfo) -> String

Render numeric constraints, including negative and exclusive bounds.

constraint_info_to_string_comment

source

fn constraint_info_to_string_comment(info : ConstraintInfo) -> String

Render every string bound, format and pattern.

dfs_topo_sort

source

fn dfs_topo_sort(name : String, deps_list : Array[(String, Array[String])], visited : Array[(String, Int)], sorted : Array[Schema], schema_map : Array[Schema]) -> Unit

DFS for topological sorting. Adds schemas to sorted list in dependency order.

discriminated_union

source

fn discriminated_union(discriminator : String, options : Map[String, Schema]) -> Schema

Create a schema that dispatches to one of several options based on a discriminator field value. Unlike union(), this directly selects the matching schema in O(1) instead of trying each branch in order.

Example

let pet = @moon_zod.discriminated_union("type", {
  "dog": @moon_zod.object({ "bark": @moon_zod.boolean() }),
  "cat": @moon_zod.object({ "meow": @moon_zod.boolean() }),
})

effective_rules

source

fn effective_rules(schema : Schema) -> Array[Rule]

All rules in their execution order, including checks on built-in effects. These describe execution stages; custom output types require an explicit pipe.

enum_values

source

fn enum_values(values : Array[String], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts one of a fixed set of string values.

escape_function_name

source

fn escape_function_name(name : String) -> String

escape a string to be a valid MoonBit function name (lowercase first letter, valid identifier).

escape_ident

source

fn escape_ident(name : String) -> String

escape a string to be a valid MoonBit identifier by replacing invalid characters with underscores.

escape_mbt_string

source

fn escape_mbt_string(s : String) -> String

Escape a string for use in MoonBit code, handling backslashes, quotes, newlines, and tabs.

escape_type_name

source

fn escape_type_name(name : String) -> String

escape a string to be a valid MoonBit type name (uppercase first letter, valid identifier).

escape_variable_name

source

fn escape_variable_name(name : String) -> String

escape a string to be a valid MoonBit variable name (lowercase first letter, valid identifier).

extract_constraints

source

fn extract_constraints(rules : Array[Rule]) -> ConstraintInfo

Extract built-in constraints and explicit annotation extensions.

filter_named_schemas

source

fn filter_named_schemas(all_named : Array[Schema], include_names : Array[String]?) -> Array[Schema]

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.

finalize_issue

source

fn finalize_issue(raw : RawIssue, params : ParseParams) -> ValidationError

Resolve an error message using the error map priority chain. Priority: explicit Schema/rule message → error_map → default message.

finalize_issues

source

fn finalize_issues(raw_issues : Array[RawIssue], params : ParseParams) -> Array[ValidationError]

Convert raw issues to validation errors using finalize_issue.

find_schema_dependencies

source

fn find_schema_dependencies(schema : Schema, schema_map : Array[Schema]) -> Array[String]

Find all named schema dependencies within a schema.

find_schema_dependencies_impl

source

fn find_schema_dependencies_impl(schema : Schema, schema_map : Array[Schema], deps : Array[String], _visited_names : Array[String]) -> Unit

format_double_simple

source

fn format_double_simple(v : Double) -> String

Format a Double as a string, stripping ".0" for whole numbers.

format_path

source

fn format_path(stack : Array[String]) -> String

format_path_segments

source

fn format_path_segments(segments : Array[PathSegment]) -> String

Format structured path segments without losing special object keys.

indent_str

source

fn indent_str(n : Int) -> String

Generate n * 2 spaces.

inner_type

source

fn inner_type(t : SchemaType) -> SchemaType

Peel OptionalType / DefaultType wrappers to find the effective base type.

intersection

source

fn intersection(schemas : Array[Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that requires all given schemas to match (intersection / and). For objects, fields from all schemas are merged into one.

is_keyword

source

fn is_keyword(name : String) -> Bool

Check if a name is a reserved keyword in MoonBit.

is_optional_schema

source

fn is_optional_schema(s : Schema) -> Bool

join_parts

source

fn join_parts(parts : Array[String]) -> String

Join constraint parts with ", ".

json_infer_schema

source

fn json_infer_schema(json : Json) -> Schema

Generate a schema from a JSON value. Simple heuristics are used to infer types and constraints from the value.

literal

source

fn literal(value : Json, required_error? : String, invalid_type_error? : String) -> Schema

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

source

fn null(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON null.

number

source

fn number(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON numbers.

object

source

fn object(spec : Map[String, Schema], required_error? : String, invalid_type_error? : String) -> Schema

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.

output_is_optional

source

fn output_is_optional(schema : Schema) -> Bool

Whether parsed output may omit a field. Fallible fallbacks are conservative; projection never executes validation or transformation callbacks.

parse_json

source

fn parse_json(input : String) -> Json

parse_path

source

fn parse_path(path : String) -> Array[PathSegment]

Decode the canonical path notation, including quoted keys and indices.

peel_optional

source

fn peel_optional(schema : Schema) -> Schema

Peel OptionalType / DefaultType wrappers to check optionality.

preprocess

source

fn preprocess(f : (Json) -> Result[Json, String], inner : Schema, required_error? : String, invalid_type_error? : String) -> Schema

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.

recursive

source

fn recursive(f : () -> Schema) -> Schema

Create a schema that defers resolution to parse time. Required for recursive/self-referencing schemas (trees, linked lists, etc.).

Example

fn tree_schema() -> @moon_zod.Schema {
  @moon_zod.recursive(fn() {
    @moon_zod.object({
      "value": @moon_zod.number(),
      "children": @moon_zod.array(@moon_zod.recursive(tree_schema)).optional(),
    })
  })
}

schema_children

source

fn schema_children(schema : Schema) -> Array[Schema]

Return every immediate child, including tuples, pipelines and lazy nodes.

string

source

fn string(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON strings.

sub_index

source

fn sub_index(path : String, i : Int) -> String

sub_path

source

fn sub_path(path : String, name : String) -> String

topological_sort_schemas

source

fn topological_sort_schemas(named_schemas : Array[Schema]) -> Array[Schema]

Topologically sort named schemas so dependents come before dependees.

try_collect_named_schemas

source

fn try_collect_named_schemas(schema : Schema) -> Result[Array[Schema], String]

Collect named nodes with checked duplicate-name and recursive-expansion errors.

try_schema_nodes

source

fn try_schema_nodes(schema : Schema) -> Result[Array[Schema], String]

Checked complete graph traversal for exporters and other schema consumers.

tuple

source

fn tuple(items : Array[Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates fixed-length JSON arrays.

Each item in items validates the array element at the same index.

type_origin

source

fn type_origin(t : SchemaType) -> String

Map SchemaType to its origin string for IssueCode payloads.

union

source

fn union(schemas : Array[Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts any of the given schemas (union / or). Schemas are tried in order; the first match succeeds.

unknown

source

fn unknown(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts any JSON value as unknown.

Runtime behavior matches any(); the distinction is semantic for consumers.

unwrap_schema

source

fn unwrap_schema(schema : Schema) -> Schema

Peel OptionalType / DefaultType / TransformType wrappers to find the innermost schema that carries the actual rules.

value_in_array

source

fn value_in_array(value : String, arr : Array[String]) -> Bool

Check if a value is in an array of strings.

visited_contains

source

fn visited_contains(visited_list : Array[(String, Int)], name : String) -> Bool

Helper: check if a name is in visited list

visited_get_status

source

fn visited_get_status(visited_list : Array[(String, Int)], name : String) -> Int

Helper: get status from visited list (0 = unvisited by default)

visited_set_status

source

fn visited_set_status(visited_list : Array[(String, Int)], name : String, status : Int) -> Unit

Helper: set status in visited list

Install

Download zip

A runtime JSON schema validation library for MoonBit, inspired by Zod and Pydantic

jsonschemavalidationzodllmtool-calling

Betterlol

Apache-2.0

github.com/Betterlol/moon_zod

Updated 2 days ago

211 downloads

Site source Report issue Modules Skills Build queue Statistics

#ErrorMap

#RawSchemaResult

#SchemaResult

#NumericBound

#Constraint

#Constraint::to_repr

#ConstraintInfo

#IssueCode

#IssueCode::equal

#IssueCode::not_equal

#IssueCode::to_repr

#ObjectMode

#ObjectMode::to_repr

#ParseParams

#ParseParams::default

#PathSegment

#PathSegment::equal

#PathSegment::not_equal

#PathSegment::to_repr

#RawIssue

#RawIssue::equal

#RawIssue::not_equal

#RawIssue::to_repr

#Rule

#Rule::to_repr

#Schema

#Schema::brand

#Schema::cuid

#Schema::datetime

#Schema::default

#Schema::describe

#Schema::email

#Schema::endsWith

#Schema::exclude

Example

#Schema::extend_with

#Schema::extract

Example

#Schema::finite

#Schema::gt

#Schema::includes

#Schema::int

#Schema::intersect

#Schema::invalid_type_error

#Schema::ip

#Schema::ipv4

#Schema::ipv6

#Schema::length

#Schema::lt

#Schema::max

#Schema::merge

#Schema::message

Example

#Schema::min

#Schema::multipleOf

#Schema::name

#Schema::negative

#Schema::nonempty

#Schema::nullable

#Schema::nullish

#Schema::omit

Example

#Schema::optional

#Schema::parse

#Schema::parse_array

#Schema::parse_default

#Schema::parse_discriminated_union

#Schema::parse_enum

#Schema::parse_intersection

#Schema::parse_lazy

#Schema::parse_literal

#Schema::parse_missing

#Schema::parse_object

#Schema::parse_optional

#Schema::parse_pipe

#Schema::parse_preprocess

#Schema::parse_stream

#Schema::parse_transform

#Schema::parse_tuple

#Schema::parse_union

ErrorMap

RawSchemaResult

SchemaResult

NumericBound

Constraint

Constraint::to_repr

ConstraintInfo

IssueCode

IssueCode::equal

IssueCode::not_equal

IssueCode::to_repr

ObjectMode

ObjectMode::to_repr

ParseParams

ParseParams::default

PathSegment

PathSegment::equal

PathSegment::not_equal

PathSegment::to_repr

RawIssue

RawIssue::equal

RawIssue::not_equal

RawIssue::to_repr

Rule

Rule::to_repr

Schema

Schema::brand

Schema::cuid

Schema::datetime

Schema::default

Schema::describe

Schema::email

Schema::endsWith

Schema::exclude

Schema::extend_with

Schema::extract

Schema::finite

Schema::gt

Schema::includes

Schema::int

Schema::intersect

Schema::invalid_type_error

Schema::ip

Schema::ipv4

Schema::ipv6

Schema::length

Schema::lt

Schema::max

Schema::merge

Schema::message

Schema::min

Schema::multipleOf

Schema::name

Schema::negative

Schema::nonempty

Schema::nullable

Schema::nullish

Schema::omit

Schema::optional

Schema::parse

Schema::parse_array

Schema::parse_default

Schema::parse_discriminated_union

Schema::parse_enum

Schema::parse_intersection

Schema::parse_lazy

Schema::parse_literal

Schema::parse_missing

Schema::parse_object

Schema::parse_optional

Schema::parse_pipe

Schema::parse_preprocess

Schema::parse_stream

Schema::parse_transform

Schema::parse_tuple

Schema::parse_union

Schema::partial

Schema::passthrough

Schema::pick

Schema::pipe