doubledash

Doubledash

A schema-based object parser

• Installation
• Example
• API
• License

Installation

npm install doubledash --save

Example

/* Custom class as an example */
class CustomClass {
  constructor (hey) { this._hey = hey }
}

/* Creating the schema */
const Schema = require('doubledash')
const template = {
  option1: Boolean, // Shorthand for { type: Boolean }
  option2: { type: Number, required: true, min: 5 }, // Custom function 'min' (see below)
  option3: [{
    option3_1: { type: String, default: 'string' },
    option3_2: { type: Object, required: true },
    option3_3: CustomClass
  }] // Embedding keys into an object (see result)
}

const schema = new Schema(template) // Constructed schema

function min (rule, input, key) {
  if (input <= rule) {
    input = rule
  }
  return input
}

schema.plugin('min', min) // Add new functionality to the schema

const options = {
  option2: 1,
  option3: {
    option3_2: { },
    option3_3: new CustomClass('hi there')
  }
}

console.log(schema.use(options)) // Use the schema on the input object

/*
{ option2: 5,
  option3: {
    option3_1: 'string',
    option3_2: { },
    option3_3: CustomClass { _hey: 'hi there' }
  }
}
*/

API

• Schema
• schema#plugin()
• schema#use()

Schema(template)

Schema is the exposed class. Create it by using new Schema(template).
The template argument is an object with the following notation:

const template = {
  option1: Boolean // simple option of type 'Boolean'
  option2: { type: Number, required: true } // a simple option with multiple properties
  option3: [{ // an option containing suboptions
    option3_1: { type: String, default: 'string' },
    option3_2: { type: Object, required: true }
  }]
}

Objects can have the following rules by default:

• type: Any
  Will throw an error when input is not of this type
  Mandatory at versions below 0.4.0

• required: Boolean
  Will throw an error when a required option is not set

• default: Any
  Overrides input when not set

schema.plugin(key, function, overwrite)

This method plugs in your functions to the object parser, making it modular.

• key: String
  The key you use in your schema to use the function.

• function: Function
  Function that processes the input relative to the value of key during parsing.

• overwrite: Boolean
  When true, this will overwrite the previous function at key with function function.
  This is useful for overwriting built-in plugins, such as type, required or default.

This function should return the processed input, or throw errors:

const template = { num: { type: Number, required: true, minimum: 5 } }
const schema = new Schema(template)

function min (rule, input, key) {
  if (input <= rule) {
    input = rule
  }
  return input
}

schema.plugin('minimum', min)

Doubledash will pass three arguments to your function whenever it reads the set key in a template.
These three arguments are:

• rule: Any
  The given value when you create your template. In the example above, this value is 5.

• input: Any
  The actual input of the object that use was called on.

• key: String
  The name of the object with given input. Useful for throwing errors.

If this might still be too vague, you could check out the built-in plugins in doubledash.js, the source file of the project.

schema.use(input)

This method is used to test your input to the referencing schema.

The input argument should be an object that will be tested against the schema.
This method will return a processed object, which is in accordance to this schema.

See the example for more info.

License

MIT