open-index/open-npm huggingface dataset:
npm package: @peassoft/jdv
Description: Data validator
Author: Alexey Gorokhov
Latest version: 0.1.0

# @peassoft/jdv

JavaScript data validator.

## You may not need it!

This is a highly opinionated solution aimed at code reuse for a few private projects. You'd be better off using something popular, like [joi](https://github.com/hapijs/joi) and friends.

## Installation

```bash
$ npm i --save @peassoft/typesgen
```

## Example

```typescript
import Jdv, { validate } from '@peassoft/jdv';

const schema = Jdv.object('error message about data not being an object')
  .keys({
    userName: Jdv.string('error message about "userName" not being a string')
      .required('error message about missing "userName"')
      .nullable(),
  });

const incomingData = {
  userName: 'John Smith',
};

const errors: string[] = Jdv.validate(schema, incomingData);

if (errors.length) {
  res.status(400).json({ errorMessages: errors.join(', ')});
  return;
}

// Here start using "incomingData"
```

## API Reference

### validate(schema: Schema, data: unknown) => string[]

Validates `data` against `schema` and returns an array of errors. If validation fully
succeeds, the returned array is empty.

### Jdv

```typescript
import Jdv from '@peassoft/jdv';

const schema = Jdv.object('expected data to be an object')
  .keys({
    // Any value in "a" is acceptable, or "a" may not be present
    a: Jdv.any(),

    // Any value in "b" is acceptable, however "b" must be present
    b: Jdv.any().required('"b" is required'),

    // Schema to validate a string to be a correct UUID.
    // The value in "c" may also be "null".
    c: Jdv.uuid('expected "c" be an UUID').nullable(),

    // Schema to validate an array value
    d: Jdv.array({
      // Schema to validate every item in the array. Optional - if not passed,
      // array items are not validated
      schema: Jdv.any(),
      msg: 'expected "d" be an array',
    })
      .notEmpty('expected "d" be non-empty'),

    e: Jdv.record({
      // Schema to validate keys of the record. Optional - if not passed,
      // keys are not validated
      schemaForKey: Jdv.uuid('expected keys of "e" be UUIDs'),
      // Schema to validate values of the record. Optional - if not passed,
      // values are not validated
      schemaForValue: Jdv.string('expected values of "e" be strings'),
      msg: 'expected "e" be a record',
    })
      .notEmpty('expected "e" be non-empty'),

    f: Jdv.string('expected "f" be a string')
      .notEmpty('expected "f" be a non-empty string')
      .validate((str: string): boolean => string.length > 5),

    g: Jdv.integer('expected "g" be an integer')
      .min(10, 'expected "g" be greater or equal to 10')
      .max(20, 'expected "g" be less or equal to 20'),

    h: Jdv.number('expected "h" be a number')
      .min(10.5, 'expected "h" be greater or equal to 10.5')
      .max(20.5, 'expected "h" be less or equal to 20.5'),

    i: Jdv.boolean('expected "i" be a boolean'),

    // Schema to validate a string to be a correct UTC date representation
    // in format `YYYY-MM-DDTHH:MM:SS.sssZ`
    j: Jdv.ISODateString('expected "j" be an ISO date string'),
  });
```