Nonlinear Programming Methods

    This package has been deprecated

    Author message:

    idonttrustlikethat is the new name with newer versions

    validation.ts
    TypeScript icon, indicating that this package has built-in type declarations

    0.0.30 • Public • Published

    validation.ts

    Validation for TypeScript

    This module helps validating incoming JSON, url params, etc in a type safe manner.

    validate

    Every validator has a validate function which returns a Result (either a {type: 'ok', value} or a {type: 'error', errors})

    A validated value can be transformed at any point during the validation process (e.g. isoDate).
    Errors are accumulated.

    import { errorDebugString, isOk } from 'validation.ts'
     
    const myValidator = ...
     
    const result = myValidator.validate(myJson)
     
    if (isOk(result)) {
      console.log(result.value)
    }
    else {
      console.error(errorDebugString(result.errors))
    }

    In case of errors, The Result contains an Array of { message: string, context: string } where message is a debug error message for developers and context is the path where the error occured (e.g root / data / 0 / name)

    errorDebugString will give you a complete debug string of all errors, e.g.

    At [root / c] Error validating the key. "c" is not a key of {
      "a": true,
      "b": true
    }
    At [root / c] Error validating the value. Type error: expected number but got string
    

    primitives

    import * as v from 'validation.ts'
     
    v.string
    v.number
    v.boolean
    v.null
    v.undefined
    v.isoDate

    tagged primitive

    Sometimes, a string or a number is not just any string or number but carries extra meaning, e.g: email, uuid, userId, KiloGram, etc.
    Tagging such a primitive as it's being validated can help make the downstream code more robust.

    type UserId = string & { __tag: 'UserId' } // Note: You can use any naming convention for the tag.
     
    const userIdValidator = v.string.tagged<UserId>()

    literal

    import { literal } from 'validation.ts'
     
    // The only value that can ever pass this validation is the 'X' string literal
    const validator = literal('X')

    array

    import { array, string } from 'validation.ts'
     
    const validator = array(string)

    tuple

    import { tuple, string, number } from 'validation.ts'
     
    const validator = tuple(string, number) // Tuple2

    object, literal union, optional

    import { string, object, union, optional } from 'validation.ts'
     
     
    const person = object({
      id: string,
      prefs: object({
        csvSeparator: optional(union(',', ';', '|'))
      })
    })

    Note: For bigger unions of strings, consider using the keyof validator instead.

    dictionary

    A dictionary is an object where all keys and all values share a common type.

    import { dictionary, string, number } from 'validation.ts'
     
    const validator = dictionary(string, number)

    keyof

    import Set from 'space-lift/object/set'
    import { keyof } from 'validation.ts'
     
    const keys = Set('aa', 'bb', 'cc').value()
     
    const keyValidator = keyof(keys)
     
    keyValidator.validate('bb') // Ok<'aa' | 'bb' | 'cc'> = Ok('bb')
     
    // keyof typeof keys === typeof keyValidator.T === 'aa' | 'bb' | 'cc'

    map, filter, flatMap

    import { string, Ok } from 'validation.ts'
     
    const validator = string
      .filter(str => str.length > 3)
      .map(str => `${str}...`)
      .flatMap(str => Ok(str.toLowerCase()))

    recursion

    import { recursion, string, array, object }
     
    type Category = { name: string, categories: Category[] }
     
    const category = recursion<Category>(self => object({
      name: string,
      categories: array(self)
    }))

    Deriving the typescript type from the validator type

    Note: this can be used with any combination of validators except ones using recursion.

    Instead of using the derived type as your sole interface, use it to compare its compatibility with your handcrafted interfaces which will always be more readable in IDE's tooltips.

    import { object, string, number } from 'validation.ts'
     
    const person = object({
      name: string,
      age: number
    })
     
    type PersonFromValidator = typeof person.T
     
    type Person = {
      name: string
      age: number
    }

    Configuration

    A Configuration object can be passed to modify the default behavior of the validators:

    Configuration.transformObjectKeys

    Transforms every keys of every objects before validating.

    const burger = v.object({
      options: v.object({
        doubleBacon: v.boolean
      })
    })
     
    const ok = burger.validate({
      options: {
        'double_bacon': true
      }
    }, { transformObjectKeys: v.snakeCaseTransformation })

    Thanks

    To gcanti and his io-ts library which provided great inspiration.

    Install

    npm i validation.ts

    DownloadsWeekly Downloads

    171

    Version

    0.0.30

    License

    MIT

    Unpacked Size

    54.2 kB

    Total Files

    6

    Last publish

    Collaborators

    • boubiyeah