paperhive/fefe

Validate, sanitize and transform values with proper TypeScript types and zero dependencies.

fefe's Issues

Use Github actions instead of Travis

Support providing type hints for validation functions

Validation functions assume that the input is unknown. Sometimes you know more about the input value (e.g., in envfefe it's { [k: string]: string}. Allow to provide the type of input values.

Add default() helper

Similar to the optional() helper (see #6), it'd be great if we could also use a default() helper for generating object validation options like this one

  id: {
    validator: string(),
    default: () => generateUuid()
  }

via something like

id: default(string(), () => generateUuid())

However, default is a keyword in JS so we need to find another name for exporting such a helper. Any ideas? @andywer

Add optional() helper

Currently, our object description looks something like this:

  dateOfBirth: parseDate(),
  addressLine1: string(),
  addressLine2: {
    validator: string(),
    optional: true
  }

I think it would be really nice to have fefe come with a convenience function, so that we write it like this instead:

  dateOfBirth: parseDate(),
  addressLine1: string(),
  addressLine2: optional(string())

Of course it would be trivial for the user to write such a function themself, but it feels so basic, that it would probably make more sense to ship it as part of fefe.

Cheers!

Support metadata for schema documentation

A fefe function could return metadata about what it is doing, for example for

import { date } from 'fefe'
const validateReleaseDate = date({ min: new Date() })

the resulting function could offer a function validateReleaseDate.describe() that returns something like

{
  params: { min: Date(2019-02-26) },
  description: 'A date after 2019-02-26.'
}

The user could also provide a semantic description via

date({ min: new Date(), description: 'The release date.' })

or a function that can use the standard description

date({ min: new Date(), description: msg => `The release date: ${msg}` })

CC @andywer :)

Generate validator for type/interface

Given a type/interface, it would be great if fefe could construct a runtime validator for that type.

Example:

import { fromType } from 'fefe'

interface Person {
  name: string
  birthday?: Date
}

const validator = fromType(Person)

validator then should be of type (value: unknown) => Person and behave like

import { object, string, date } from 'fefe'
const explicitValidator = object({ 
  name: string(),
  birthdate: { validator: date(), optional: true }
})

which is tedious to type and error-prone.

This feature would make validating user input significantly easier, e.g. in REST APIs.

Rename 'enum' function

It would be great to rename enum function, to something else (e.g. oneOf, enumerate...), because 'enum' is typescript keyword, so it needs to be aliased everytime, when importing.

Rewrite fefe with functional Either<Error, Result> pattern

Throwing errors (like fefe does currently) is not a pure functional approach and lacks error type safety. We could rewrite error handling by employing the Either<Error, Result> type, e.g. like in https://dev.to/gcanti/getting-started-with-fp-ts-either-vs-validation-5eja.

Add types for recursive validation

Make this work with proper types:

const validatePerson = (value: unknown) => validate.object({ friend: validatePerson })(value)