DuckTyper

A tool for validating input based on the fundamental js idea of duck typing. The concept of this is to allow the fluidness of a dynamically typed language with the clarity of a static one. It takes advantage of a typing that is commonly known in js as duck typing. Meaning, If it walks and talks like a duck it's a duck.

Ducktyper has the single goal of having simple and clear syntax. It follows similar design patterns of styled-components and class-validator. With ducktyper, validators are easy, quick, and clear to make. By allowing complex validaton that stricter validation libraries don't provide, ducktyper puts validation in the hands of the developer as though it was a typing system.

Usage

It was designed functionally, and as a result operates best when used as such. However, a classical version is included and is described more in depth below.

This is a list of the main functions that ducktyper provides. The main two are makeDuck and duckfaults which allow you do make any validation you could hope for.

| Functions | Description | | --------- | ----------- | | makeDuck(...types): isDuck | Used to create a type. Any of the basic types can be used within it along with isDuck types | | dtoToIsDuck(DuckDto): isDuck | This is used to convert any DuckDto to an isDuck function so that dtos can be used as valid types in a makeDuck | | duckorate(isDuck, options): duckorator(val) | this is used to make a new decorator to place on a class. | | duckfaults(isDuck, options): isDuck | This is used to chain options into isDuck. Returns an isDuck that will be called with the provided options as its new defaults | | isDuck(val, options): Bool/Error | This is the type that is used to check a value. This is generated by makeduck | | classifyDuck(dto, options): Bool/Error | This is used in the same way that an isDuck is used. However it takes in a dto with duckorators as input. | | initClassifyDuckOptions(obj) | this is used to update the default options that are used when classifyDuck is called on a dto | | initIsDuckOptions(obj) | this is used to update the default options when makeDuck is called to initalize a isDuck | | trimDuck(duck, DuckDto) | this is used to remove any extra fields from the duck dto |

These are frequently used types that will allow you to save overhead time rather then having to make a new validator every time you need a basic type. If there are any common types you would like added raise an issue in the github.

| Common | Description | | --------- | ----------- | | isString | checks if input is a string | | isNumber | checks if an input is a number | | isObject | checks if an input is an object | | isBoolean | checks if an input is a bool | | isArray | checks if input is an array |

These are a list of accepted types which you can put into makeDuck. Most of which are generic types that most languages have. They can be inserted by themselves, or they can be placed in an array or object.

| Basic Types | Description | | -------------- | ----------- | | initialized primitives ("string", 1234, ...etc) | Will accept any value that is equal to the primitive passed in | | Primitives (String, Number, ...etc) | Will accept any primative value https://developer.mozilla.org/en-US/docs/Glossary/Primitive | | Array | Has two types of arrays: single type arrays and structured arrays | | Object | An object with fields any of the accepted types | | isDuck | the type returned when a type is created | | Any: function | Indicates that anything is accepted | | Class: object | You can use any type of class that you would like. This includes custom and defaut js classes | | function(val):boolean | This is used when a value has specifics that it must follow other then generic types | | DuckDto | a Duck dto can be used as a type inside of a makeDuck function |

These are a list of option that you can attach to a isDuck or call at runtime.

| Options | Description | | ------- | ----------- | | throw: Boolean | Value indicating if a boolean for success will be returned or if it will throw a message on error | | allowUndefiend: Boolean | Value indicating if an undefined input will be accepted | | message: String | The message that is thrown when input fails to pass tests | | allowEmpty: Boolean | By default this is true. However when you want to make sure an array or string is not empty set this to false | | allowEmptyString: Boolean | By default this is not included. However when you want to make sure a string is not empty set this to false if it is okay set it to true. This takes precidence over allowEmpty | | allowEmptyArray: Boolean | By default this is not included. However when you want to make sure an array is not empty set this to false if it is okay set it to true. This takes precidence over allowEmpty | | childMessage: Boolean | By default this is set as true. What this does is signify that we want the message given by the child if any are given. If it is set to false it will return the parent message every time | | forceDuckDto: Boolean | This is used to force that all functions which take a dto as a parameter to force the use of a duckDto. |

functional usage

import {makeDuck, duckfaults, Any} from "ducktyper";
 
//here we create an object that could be passed into any of these types
let person = {
   name: "Benjamin",
   age: 22,
   address: ["city", "state", 1234, "road"]
   children: [{name:"goliath"}, {name:"fin"}],
   employed: true,
   single: true,
}
 
 
const isName = duckfaults(isString, {
   message: "name must be a string"
});
 
//we can attach default options
//and we can use custom validation functions
const isAge = duckfaults(makeDuck(v=>v>=0), {
   throw: true,
   error: "failed to provide age field"
});
 
//we can do a structured array
const isAddress = makeDuck([String, String, Number, String]);
 
const isChildren = makeDuck([isNamed]);

const hasId = makeDuck({
   id: Number,
});
 
//can combine ducks into one big duck and also sinply define a schema.
const isPerson = makeDuck({
   name: isName,
   age: isAge,
   address: isAddress,
   children: isChildren
}, hasId);
 
//usage
isPerson(person)

dto usage

Ducktyper can now be used to decorate classes with the use of dtos in mind. This is supported in both js and ts!

import {makeDuck, duckorate, classifyDuck, DuckDto} from "ducktyper";

const isQuack = makeDuck((val)=>"quack"===val);
const isEats = makeDuck((val)=>val==="bread" || val==="seeds");

class Duck extends DuckDto {
   @duckorate(isQuack)
   sound;

   @duckorate(isEats)
   eats;   
}

let duck = new DuckDto();
duck.sound = "quack";
duck.eats = "bannanas";

try {
   classifyDuck(duck, {throw:true});
} catch (error) {
   alert(error.message);
}