Welcome to jsonschema-definer

This package provides simple, well typed API for creating and validating JSON Schemas

Install

npm install jsonschema-definer

Usage

This package was inspired by fluent-schema and prop-types, and is used to create and validate JSON Schema. It was written in typescript and provide a lot of usefull info from typings, such as infering interface types from schema. Here is an example:

import S from 'jsonschema-definer'

// Lets define a simple object schema
const UserSchema = S.shape({
  name: S.string(),
  email: S.string().format('email').optional(),
  password: S.string().minLength(8),
  role: S.enum('client', 'suplier'),
  birthday: S.instanceOf(Date)
})

// Now lets get interface of User from schema
type User = typeof UserSchema.type
/*
  type User = {
    name: string,
    email?: string | undefined,
    password: string,
    role: 'client' | 'suplier',
    birthday: Date
  }
*/

// We can validate user using .validate(data) function (ajv used)
const [valid, errors] = UserSchema.validate({
  name: 'Igor',
  email: 'fumo.sujimoshi@gmail.com',
  password: '12345678',
  role: 'client',
  birthday: new Date()
})

console.log(valid, errors) // [boolean, Error[]]

// Or get plain JSON Schema using .valueOf()
console.log(UserSchema.valueOf())

️ Show your support

Give a ️ if this project helped you!

Documentation

Full documentation available here

Main exported variable S: SchemaFactory extends BaseSchema

Method	Description	JSON Schema
S.any(): BaseSchema	Correspond to any type	{ }
S.string(): StringSchema	For strings validation	{ "type": "string" }
S.number(): NumericSchema	For float/integer validation	{ "type": "number" }
S.integer(): NumericSchema	For integer values validation	{ "type": "integer" }
S.boolean(): BaseSchema	For boolean values	{ "type": "boolean" }
S.null(): BaseSchema	For null value validation	{ "type": "null" }
S.array(): ArraySchema	Array validation	{ "type": "array" }
S.list(itemType: T): ArraySchema	Validation of lists. Example: S.list(S.string()): ArraySchema	{ "type": "array", "items": { ... } }
S.object(): ObjectSchema	Validation of object	{ "type": "object" }
S.shape({ key: Schema }: T): ObjectSchema	Validation of objects	{ "type": "object", properties: T, additionalProperties: false } }
S.instanceOf(type: T): BaseSchema	For validating instanceOf data. (Custom keyword used)	{ instanceOf: T.name }
S.enum(...constants: T[]): BaseSchema	Enumerable schema	{ enum: [ T[0], T[1] ] }
S.const(constant: T): BaseSchema	Constant value	{ const: T }
S.anyOf(...schemas: BaseSchema[]): BaseSchema	Any (one or more) of given types	{ anyOf: [ T[0], T[1], ... ] }
S.oneOf(...schemas: BaseSchema[]): BaseSchema	Value shoud correspond to ONE of given types	{ oneOf: [ T[0], T[1], ... ] }
S.allOf(...schemas: BaseSchema[]): BaseSchema	Value should correspond to ALL of given type	{ allOf: [ T[0], T[1], ... ] }
S.raw(values: any): BaseSchema	Set custom schema values (For Swagger definitions for example)	{ ...values }
S.custom(...validators: (value: T) => boolean): BaseSchema	Add custom validation functions to schema. Supported by AJV custom keyword	Does not supported by standard JSON Schema (Ajv support)

Contributing

Contributions, issues and feature requests are welcome!
Feel free to check issues page.

Run tests

npm run test

Author

Igor Solomakha fumo.sujimoshi@gmail.com

• Github: @Sujimoshi

License

Copyright 2020 Igor Solomakha fumo.sujimoshi@gmail.com.
This project is ISC licensed.

---

This README was generated with by readme-md-generator