Struct StringSchema 

pub struct StringSchema { /* private fields */ }

A schema for validating string values.

StringSchema validates that values are strings and optionally applies constraints like minimum/maximum length and regex patterns. All constraint violations are accumulated rather than short-circuiting on the first failure.

Example

use postmortem::{Schema, JsonPath};
use serde_json::json;

// Create schema with multiple constraints
let schema = Schema::string()
    .min_len(3)
    .max_len(20)
    .pattern(r"^[a-z]+$")
    .unwrap();

// Validation accumulates all errors
let result = schema.validate(&json!("AB"), &JsonPath::root());
assert!(result.is_failure());
// Will report both: too short AND pattern mismatch

Implementations

impl StringSchema

pub fn new() -> Self

Creates a new string schema with no constraints.

pub fn min_len(self, min: usize) -> Self

Adds a minimum length constraint.

The string must have at least min characters (Unicode scalar values).

Example

use postmortem::{Schema, JsonPath};
use serde_json::json;

let schema = Schema::string().min_len(5);

let result = schema.validate(&json!("hello"), &JsonPath::root());
assert!(result.is_success());

let result = schema.validate(&json!("hi"), &JsonPath::root());
assert!(result.is_failure());

pub fn max_len(self, max: usize) -> Self

Adds a maximum length constraint.

The string must have at most max characters (Unicode scalar values).

Example

use postmortem::{Schema, JsonPath};
use serde_json::json;

let schema = Schema::string().max_len(10);

let result = schema.validate(&json!("hello"), &JsonPath::root());
assert!(result.is_success());

let result = schema.validate(&json!("this is too long"), &JsonPath::root());
assert!(result.is_failure());

pub fn pattern(self, pattern: &str) -> Result<Self, Error>

Adds a regex pattern constraint.

The string must match the provided regex pattern. Returns an error if the regex pattern is invalid.

Example

use postmortem::{Schema, JsonPath};
use serde_json::json;

let schema = Schema::string()
    .pattern(r"^\d+$")
    .unwrap();

let result = schema.validate(&json!("12345"), &JsonPath::root());
assert!(result.is_success());

let result = schema.validate(&json!("abc"), &JsonPath::root());
assert!(result.is_failure());

pub fn email(self) -> Self

Adds an email format constraint.

pub fn url(self) -> Self

Adds a URL format constraint (http/https).

pub fn uuid(self) -> Self

Adds a UUID format constraint.

pub fn date(self) -> Self

Adds a date format constraint (YYYY-MM-DD).

pub fn datetime(self) -> Self

Adds a datetime format constraint (ISO 8601).

pub fn ip(self) -> Self

Adds an IP address format constraint (IPv4 or IPv6).

pub fn ipv4(self) -> Self

Adds an IPv4 format constraint.

pub fn ipv6(self) -> Self

Adds an IPv6 format constraint.

pub fn one_of<I, S>(self, values: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Adds an enumeration constraint.

pub fn starts_with(self, prefix: impl Into<String>) -> Self

Adds a starts-with constraint.

pub fn ends_with(self, suffix: impl Into<String>) -> Self

Adds an ends-with constraint.

pub fn contains(self, substring: impl Into<String>) -> Self

Adds a contains constraint.

pub fn trim(self) -> Self

Adds a trim transformation.

pub fn lowercase(self) -> Self

Adds a lowercase transformation.

pub fn custom<F>(self, validator: F) -> Self

where F: Fn(&str, &JsonPath) -> Validation<(), SchemaErrors> + Send + Sync + 'static,

Adds a custom validator.

pub fn error(self, message: impl Into<String>) -> Self

Sets a custom error message for the most recent constraint.

If no constraints have been added yet, this sets the type error message (used when the value is not a string).

Example

use postmortem::{Schema, JsonPath};
use serde_json::json;

let schema = Schema::string()
    .min_len(5)
    .error("username must be at least 5 characters");

let result = schema.validate(&json!("hi"), &JsonPath::root());
// Error message will be "username must be at least 5 characters"

pub fn validate( &self, value: &Value, path: &JsonPath, ) -> Validation<String, SchemaErrors>

Validates a value against this schema.

Returns Validation::Success with the validated string if all constraints pass, or Validation::Failure with all accumulated errors if any constraints fail.

Example

use postmortem::{Schema, JsonPath};
use serde_json::json;

let schema = Schema::string().min_len(1).max_len(10);

match schema.validate(&json!("hello"), &JsonPath::root()) {
    stillwater::Validation::Success(s) => println!("Valid: {}", s),
    stillwater::Validation::Failure(errors) => {
        for error in errors.iter() {
            println!("Error: {}", error);
        }
    }
}

Trait Implementations

impl Clone for StringSchema

fn clone(&self) -> StringSchema

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for StringSchema

fn default() -> Self

Returns the “default value” for a type.

impl SchemaLike for StringSchema

type Output = String

The output type produced by successful validation.

fn validate( &self, value: &Value, path: &JsonPath, ) -> Validation<Self::Output, SchemaErrors>

Validates a value against this schema.

fn validate_to_value( &self, value: &Value, path: &JsonPath, ) -> Validation<Value, SchemaErrors>

Validates a value and returns the result as a serde_json::Value.

fn validate_with_context( &self, value: &Value, path: &JsonPath, _context: &ValidationContext, ) -> Validation<Self::Output, SchemaErrors>

Validates a value with registry context for schema reference resolution.

fn validate_to_value_with_context( &self, value: &Value, path: &JsonPath, _context: &ValidationContext, ) -> Validation<Value, SchemaErrors>

Validates a value with context and returns the result as a serde_json::Value.

fn collect_refs(&self, _refs: &mut Vec<String>)

Collects all schema reference names used by this schema.

impl ToJsonSchema for StringSchema

fn to_json_schema(&self) -> Value

Converts this schema to a JSON Schema representation.