ducktyper v6.0.3

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.

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.

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.

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.

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

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);
}