Welcome to Basic Valid Object Schema 👋

This is an alpha version of the library and is subject to frequent changes and updates. We do not recommend using this version in production environments.

Please note that there may be breaking changes as we work towards the stable release version 1.0.

We do not assume responsibility for any changes made to the API due to the use of this alpha version.

Please be aware that this software is released under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). 

Validation tool or utility that allows for simple and fast validation of an object against a schema.

🏠 Homepage

Prerequisites

• npm >=8.0.0
• node >=14.0.0

Install

npm install basic-valid-object-schema

Run tests

npm run test

Supported Data Types

Methods

ValidationObject.prototype.constructor(schema: object)

ValidationObject.prototype.validate(o: object)

• Method that validates an object against the schema initialized in the ValidationObject instance.
• Return: {errors: object, data: null | object, isValid: boolean}

validate(schema: object, o: object): Promise<{errors, data, isValidate}>

• Return: Promise<{errors: object, data: null | object, isValidate: boolean}>

validateSync(schema: object, o: object): {errors, data, isValidate}

• Return: {errors: object, data: null | object, isValidate: boolean}

Usage/Examples

Basic Example

First, we create a schema. A schema is an object that represents an entity or object to be validated. Each object we want to validate will be validated against the requirements of this schema.

Once the schema is created, wherever we want to perform the validation, we will need to import the library and use 'validate' hook passing the schema and the object to validate. This will give us important variables that we can destructure as seen in the code below.

By default, all properties of a schema are required unless otherwise indicated.

import { validate } from 'basic-valid-object-schema';

const createProductSchema = {
    title: {
        type: "string",
        required: true
    }
    price: {
        type: "number",
        required: true
    },
    active: {
        type: "boolean",
        default: true
    },
    categories: {
        type: "array",
        schema: {
            type: "string"
        },
        default: ["category"],
        required: true
    }
}

const okRawProductData = {
  title: "title1",
  price: 300.5
}

const {
  // Boolean that indicates whether the object is valid or not
  isValid,
  // Validated object, can be null or an object with processed data ready to be used.
  data,
  // Error object produced during validation, can be null if the object is valid.
  errors
} = await validate(createProductSchema, badRawProductData);

console.log({ errors, isValid, data });
/*
errors: null,
isValid: true,
data: {
  title: "title1",
  price: 300.5,
  active: true,
  categories: ["category"]
}
*/ 
...

Example with the same schema and different input that causes the validation to fail and return an error.

const badRawProductData = {
  title: "title1",
  price: "$300.5"
};

const { isValid, data, errors } = await validate(createProductSchema, badRawProductData);

console.log({ errors, isValid, data });
/*
errors: {
  price: {
    error: "price must be a valid number"
  }
},
isValid: false,
data: null
*/

Options for validate:

How to avoid cleaning extra properties from my schema

const okRawProductData = {
  title: "title1",
  price: 300.5,
  extraProperty: true
}

const {
  // Boolean indicating whether the object is valid or not
  isValidate,
  // validated object, can be null or an object with processed data ready to be used.
  data, 
  // object of errors produced during validation, can be null if the object is valid.
  errors
} = validate( createProductSchema, badRawProductData, { whitelist: false } )

console.log({errors, isValidate, data})
/*
errors: null,
isValidate: true,
data: {
  title: "title1",
  price: 300.5,
  active: true,
  categories: ["category"],
  extraProperty: true --> Here is the property thanks to whitelist false attribute
}
*/

Shortcut for schema creation:

There is a way to shorten our schemas by leaving the default schema values to do their magic.

To understand this, it is necessary to understand that:

• Properties of each schema are required by default.
• The value of a subschema can be either an object that represents a schema or a string.

The schema seen earlier can be reduced to this:

const createProductSchema = {
    title: "string",
    price: "number",
    active: {
        type: "boolean",
        default: true
    },
    categories: {
        type: "array",
        schema: "string",
        default: ["category"]
    }
}

Authors

👤 Ilan Emanuel Fritzler contacto.fritzlerilan@gmail.com (http://github.com/ifritzler)

• Website: http://github.com/ifritzler
• Github: @ifritzler
• LinkedIn: @ilan-fritzler

👤 Federico Lautaro Hanson hanson.federico@gmail.com (http://github.com/FedeLH)

• Website: http://github.com/FedeLH
• Github: @FedeLH
• LinkedIn: @federico-lautaro-hanson-130944224

🤝 Contributing

Contributions, issues and feature requests are welcome!

Feel free to check issues page. You can also take a look at the contributing guide.

Show your support

Give a ⭐️ if this project helped you!

📝 License

Copyright © 2023 Ilan Emanuel Fritzler contacto.fritzlerilan@gmail.com (http://github.com/ifritzler).

This project is Apache 2.0 licensed.

This README was generated with ❤️ by readme-md-generator