Class StringSchema

A base class for validation state. Provides methods for chaining.

Subclass constructors must accept a single argument: the new validator.

Hierarchy (view full)

Constructors

constructor

Properties

__type currentValidator operation? previousSchema? base

Accessors

description

Methods

and assert chain clone isValid matches maxLength maybe minLength noWhitespace notEmpty or orNull orUndefined self validate

Constructors

constructor

Properties

__type

__type: Invariant<string> = ...

Enforces T is in an invariant position. This prevents a validator with more strict rules is assigned to a less strict type, which can cause unexpected validation errors.

Protected ReadonlycurrentValidator

currentValidator: Validator<any, any>

Protected Optional Readonlyoperation

operation?: ((validatorA: Validator<any, unknown>, validatorB: Validator<any, any>) => Validator<string, unknown>)

Protected Optional ReadonlypreviousSchema

previousSchema?: SchemaBase<any>

Static Readonlybase

base: StringSchema = ...

Accessors

description

  • get description(): string

  • A short description of the validator.

    Returns string

Methods

and

  • and<U>(nextValidator): ValueSchema<string & U>

  • Returns a validator that asserts if this validator and the next passes.

    Type Parameters

    • U

    Parameters

    • nextValidator: Validator<U, any>

      The validator to run after the current.

    Returns ValueSchema<string & U>

    Returns a new ValueSchema intersecting this validator and the next.

    See

    andValidators

assert

  • assert(input, origin?, path?): asserts input is string

  • Validates the given input, asserting that the input is type T. If the input is not valid, a ValidationError will be thrown.

    Parameters

    • input: unknown

      The input to validate.

    • Optionalorigin: string

      The error origin. ErrorOrigin.API by default.

    • Optionalpath: readonly string[]

      The current field path to this validator.

    Returns asserts input is string

    Returns the input, cast as the validated type T

Protectedchain

  • chain(nextValidator): any

  • Constructs a new schema with a validator chaining the current validator with the provided next in an AND operation.

    Parameters

    • nextValidator: Validator<any, any>

      The validator to run after the current.

    Returns any

    Returns a new Schema instance the same class with a new validator chaining the current validator with the given next in an AND operation.

Protectedclone

  • clone(transform): any

  • Clones this schema, transforming all validators with the given mutator.

    Parameters

    • transform: ((validator: Validator<any, unknown>) => Validator<any, unknown>)

      A transformer which takes an existing validator in the chain and returns a new one. Validators should be considered to be immutable; transform should not change the input but instead return a new validator.

    Returns any

isValid

  • isValid(input): input is string

  • Returns true if the input is valid according to this validator.

    Parameters

    • input: unknown

    Returns input is string

matches

  • matches(regex): StringSchema

  • Creates a validator that asserts that the input string matches the given regex.

    Parameters

    • regex: RegExp

    Returns StringSchema

maxLength

  • maxLength(max): StringSchema

  • Creates a validator that asserts that the input string has at most the given maximum length.

    Parameters

    • max: number

      The string must be at most this length.

    Returns StringSchema

maybe

  • maybe(): ValueSchema<undefined | null | string>

  • Prepends this validator allowing for null or undefined.

    Returns ValueSchema<undefined | null | string>

minLength

  • minLength(min): StringSchema

  • Creates a validator that asserts that the input string has at least the given minimum length.

    Parameters

    • min: number

      The string must be at least this length.

    Returns StringSchema

noWhitespace

  • noWhitespace(): StringSchema

  • Creates a validator that asserts that the input string has no whitespace characters. Whitespace characters include space, new line, carriage return, and tab.

    Returns StringSchema

notEmpty

  • notEmpty(): StringSchema

  • Creates a validator that asserts that the input is not empty.

    Returns StringSchema

or

  • or<U>(nextValidator): ValueSchema<string | U>

  • Returns a validator that asserts if this validator or the next passes.

    Implementation note: subclasses should not change the schema instance returned unless all chainable validators accept input type 'unknown'.

    Type Parameters

    • U

    Parameters

    • nextValidator: Validator<U, any>

      The validator to run after the current.

    Returns ValueSchema<string | U>

    Returns a new ValueSchema providing the union of this validator and the next.

orNull

orUndefined

Protectedself

  • self(current): any

  • Parameters

    Returns any

  • self(currentValidator, previousSchema, operation): any

  • Parameters

    Returns any

validate

  • validate(input, options?, path?): readonly ValidationErrorMessage[]

  • Validates the provided input, returning a list of error messages, or an empty array if the input passes this validator.

    Parameters

    • input: unknown

      The input to validate.

    • Optionaloptions: ValidationOptions

      Validation options.

    • Optionalpath: readonly string[]

      The current field path to this validator.

    Returns readonly ValidationErrorMessage[]

    Returns an array of validation failures. If options.all is not true, only the first error will be returned.

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods