Check Types Definitions

Simple javascript library that give the ability to manage data types and Validate without typescript .

• Install
• How it works?
• Types
• Types Parameters
• Types Methods
• How to check data value?
• How to use interface?
• Define data types
• Define data types list
• How to use Schema?
• Define a Schema
• Schema types Allowed
• Valid Schema options
• Validate
• Validate Parameters
• Validate Methods
• Validate Phone Format
• Use data Validate

How to Install?

Simply run npm i check-types-definitions --s or yarn add check-types-definitions .

How it works?

First of all you have to require the main class. The Validate class will add new features for validation purpose like isEmail , isUrl or isPhone with some special options.

const { Types, Validate } = require('check-types-definitions');

Then you can use Types in two ways. First you can declare it on a new constant and use it multiple times:

const CheckTypes = new Types().options({
    return_false_boolean: true,
    return_true_boolean: true
});

const value = "12";
const check1 = CheckTypes.set(value).String().Number().Required().check();
const check2 = CheckTypes.set(value).Number().Required().check();

console.log(check1); // Log true
console.log(check2); // Log false

Or you can declare Types class every time you need it:

const value = "12";
const check1 = new Types(value).String().Number().Required().check();
const check2 = new Types(value).Number().Required().check();

console.log(check1); // Log true
console.log(check2); // Log false

Types

The first scope is to give the ability to manage data type without TypeScript. Types is a class wich constructor accept two parameters: value that is data to validate and Interface that is a class reference to check data.

Types Prameters

Parameter	Type	Description
value	Any	The data to validate.
Interface	Class reference	Class reference to validate data.

Types Methods

Name	Params	Description	Default
options()	(options<Object>)	return_false_boolean<Boolean> . If true the false response will be boolean otherwise it will throw a new Error. return_true_boolean<Boolean> . If true the true response will be boolean otherwise it will return the checked data.	false
set()	(<Any>, <Class>)	Set the value and Interface outside the constructor.	--
setSchema()	(<Schema>, <Options>)	Set the schema and options for your validation rules. More info here.	--
check()	--	Run the validation process.	--
Required()	--	Mark data as required so string can't be empty, null or undefined and Object and Array can't be empty.	--
Any()	--	Mark data type validation to Any and/or others specified.	--
Null()	--	Mark data type validation to Null and/or others specified.	--
String()	--	Mark data type validation to String and/or others specified.	--
Number()	--	Mark data type validation to Number and/or others specified.	--
BigInt()	--	Mark data type validation to BigInt and/or others specified.	--
Function()	--	Mark data type validation to Function and/or others specified.	--
Symbol()	--	Mark data type validation to Symbol and/or others specified.	--
Object()	--	Mark data type validation to Object and/or others specified.	--
Array()	`childrens<{ of:		}>`
Boolean()	--	Mark data type validation to Boolean and/or others specified.	--

How to check data value?

Eg. What if we want to check if data is provided and type of String or Number:

// Require Types class
const { Types } = required('check-types-definitions');
// Call Types contructor and set options
const CheckTypes = new Types().options({
    return_boolean: true
});
// Eg. Set data to validate and check if data type is String or Number and Required
const isValid = CheckTypes.set("123").Required().String().Number().check(); // Return true

How to check Array childrens data value?

// Require Types class
const { Types, Schema, DefineTypes } = require('../index');
// Call Types contructor and set options
const CheckTypes = new Types().options({
    return_false_boolean: true,
    return_true_boolean: false
});
// Input data
const data = {
    "aa": [{ "average": 12.3456, "frequency": [1123123, 1231233] }, { "average": 12.3456, "frequency": [1123123, 1231233] }],
    "bb": ["st", "rt", 12],
};
// Schema declaration
const aaSchema = new Schema({
    average: {
        type: DefineTypes.Number,
        required: true
    },
    frequency: {
        type: DefineTypes.Array, // Nested array type check not provided yet
        required: true
    }
});
// Now I want to check if `aa` is and array of objects defined in schema, `bb` is an array of Strings, and cc is an array of Strings or Numbers with a default value of `[]`
const aa = CheckTypes.set(data.aa).Required().Array({ of: aaSchema }).check(); // Return [{ "average": 12.3456, "frequency": [1123123, 1231233] }, { "average": 12.3456, "frequency": [1123123, 1231233] }]
const bb = CheckTypes.set(data.bb).Required().Array({ of: DefineTypes.String }).check(); // Return false
const cc = CheckTypes.set(data.cc).Default([]).Array({ of: [DefineTypes.String, DefineTypes.Number] }).check(); // Return [] as default

How to use Interface

You can compare data type to a specific class for validation purpose:

// Require Types class
const { Types } = required('check-types-definitions');
// Call Types contructor and set options
const CheckTypes = new Types().options({
    return_boolean: true
});
// My custom class
class UserData {
    constructor(first_name, last_name, email, phone) {
        this.first_name = first_name;
        this.last_name = last_name;
        this.email = email;
        this.phone = phone;
    }
}
// Get a new class istance
const user = new UserData("John", "Doe", "john.doe@domain.com", "0123456789");
// Now i want to check if `user` is `UserData` data type
const isValid = CheckTypes.set(user, UserData).check(); // Return true

That example give you the ability to check if user is a valid UserData instance.

Define data types

To define data types you need to use the DefineTypes class:

const { DefineTypes } = require('check-types-definitions');
// Example: define a string data type
const stringType = DefineTypes.String;

Define data types list

1. DefineTypes.Any any types accepted.
2. DefineTypes.Null only null type accepted.
3. DefineTypes.String only string type accepted.
4. DefineTypes.Number only number type accepted.
5. DefineTypes.BigInt only bigint type accepted.
6. DefineTypes.Function only function type accepted.
7. DefineTypes.Symbol only symbol instance accepted.
8. DefineTypes.Object only object type accepted.
9. DefineTypes.Array only array type accepted.
10. DefineTypes.Boolean sonly boolean type accepted.

How to use Schema?

Define a Schema allow you to check data using strong validation definitions declared in it:

// Require classes
const { Types, DefineTypes, Schema } = require('check-types-definitions');
// Declare `Types` 
const CheckTypes = new Types().options({
    return_boolean: true
});
// Declare a new Schema
const schema = new Schema({
    first_name: {
        type: DefineTypes.String,
        default: "John"
    },
    last_name: {
        type: DefineTypes.String,
        required: true,
        default: null
    }
});
// My dummy data source
const data = {
    first_name: "John",
    last_name: "Doe",
    email: "example@example.com"
}
// Set schema e do checks
const isValid = CheckTypes.set(data).setSchema(schema, {
    strict: true,
    extended: false
}).check();
const isValidNotStrict = CheckTypes.set(data).setSchema(schema, {
    strict: false,
    extended: true
}).check();
const isValidExtended = CheckTypes.set(data).setSchema(schema, {
    strict: true,
    extended: true
}).check();
// Log results
console.log(isValid); // Log true
console.log(isValidNotStrict); // Log { isValid: true, dataValidated: { first_name: 'John', last_name: 'Doe',  email: 'example@example.com' } }
console.log(isValidExtended); // Log { isValid: true, dataValidated: { first_name: 'John', last_name: 'Doe' } }

Define a Schema

The setSchema() metode accept a <Schema> type object that need, for each paramenter specified, 3 parameters:

Parameter	Type	Description	Required
type	Any	The data type to validate.Here types allowed list.	true
required	Boolean	Mark that field as required.	false
default	Any	Provide a default value if data provided was empty.	false

Here an example of a valid schema definition:

// Require `Schema` 
const { DefineTypes, Schema } = require('check-types-definitions');
// Declare a new `Schema` object
const schema = new Schema({
    field_1: {
        type: DefineTypes.String
    },
    field_2: {
        type: DefineTypes.Number,
        required: true
    },
    field_3: {
        type: DefineTypes.String,
        default: null
    },
    field_4: {
        type: DefineTypes.String,
        required: true,
        default: null
    }
});

Schema types Allowed

The Schema type property allowed only DefineTypes data type definitions. Check the allowed list of typed here.

Valid Schema options

The setSchema() methode accept a <Options> type object that accept 2 parameters:

Parameter	Type	Description	Default
strict	Boolean	If true field not specified in schema will be removed. Otherwise they will pass the validation check.	true
extended	Boolean	If true the check methode will return filtered data, otherwise only boolean.	true

Validate

Class that extends the Types functions. It allow you to validate data in multiple case.

Validate Prameters

Parameter	Type	Description
value	Any	The data to validate.
Interface	Class reference	Class reference to validate data.

Validate Methods

It include all Types method adding some functionalities:

Name	Params	Description	Default
isEmail()	()	Check if data provided is a valid email address. [string@string.ext]	--
isUrl()	()	Check if data provided is a valid url. protocol://? www? domain_name.ext	--
isPhone()	(format<Validation.Format>)	Check if data provided is a valid phone number. There are some formats here.	GENERIC_INTERNATIONAL

Validate Phone Format

There are five validation type for phone numbers:

Name	Declaration	Description
GENERIC_INTERNATIONAL	Validate.GENERIC_INTERNATIONAL	Generic international phone number standard. Valid: +393331231232 or 3331231232 . +[0-9][0-9]? [0-9]{9-10}
IT_PHONE_NUMBER	Validate.IT_PHONE_NUMBER	Generic IT phone number standard. Check IT phone number standards.
US_PHONE_NUMBER	Validate.US_PHONE_NUMBER	Generic US phone number standard. Check US phone number standards.
FRANCE_PHONE_NUMBER	Validate.FRANCE_PHONE_NUMBER	Generic FR phone number standard. Check FR phone number standards.
GERMAN_PHONE_NUMBER	Validate.GERMAN_PHONE_NUMBER	Generic DE phone number standard. Check DE phone number standards.

Use data Validate

We can use Validate methods to check if data provided is a valid email, url or specific phone number:

// Require Validate class
const { Validate } = required('check-types-definitions');
// Call Validate contructor
const CheckValidate = new Validate().options({
    return_boolean: true
});
// Eg. Check if data is valid email
const isEmail = CheckValidate.set("email@domain.com").isEmail(); // Return true
// Eg. Check if data is valid url
const isEmail = CheckValidate.set("www.google.com").isUrl(); // Return true
// Eg. Check if data is valid IT phone number
const isEmail = CheckValidate.set("+39 338 1234567").isPhone(Validate.IT_PHONE_NUMBER); // Return true