check-types-mini

Check the types of your options object's values after user has customised them

Table of Contents

• Install
• Idea
• API
• Contributing
• Licence

TLDR - use default opts to enforce types

const checkTypes = require("check-types-mini");

function yourFunction(input, originalOpts) {
  // 1. declare defaults:
  const defaults = { placeholderEnabled: false };
  // 2. merge given opts into defaults:
  const opts = Object.assign({}, defaults, originalOpts);
  // 3. type check:
  checkTypes(opts, defaults, {
    msg: "newLibrary/yourFunction(): [THROW_ID_01]"
  });

  // rest of your app goes here...
}

// NOW, let's call our function with wrong opts and see what happens:
let res = yourFunction(1, { placeholderEnabled: "zzz" }); // <---  notice opts key was Boolean in defaults

// WE GET A TYPE ERROR THROWN:
// =>> TypeError: 'newLibrary/yourFunction(): [THROW_ID_01] opts.placeholderEnabled was customised to "zzz" which is not boolean but string'

Install

npm i check-types-mini

Consume:

// as CommonJS require:
const checkTypes = require("check-types-mini");
// or native source directly, as an ES Module:
import checkTypes from "check-types-mini";

Here's what you'll get:

⬆ back to top

Idea

Imagine you have a library where you let users set the options object which comes as one of the input arguments.

Here's a challenge: how do you check (and throw) errors easily, when users set your options to wrong things?

Answer: this library.

Features:

• Use a default options object to enforce types
• Supplement or fully customise types (via a simple schema)
• Customise error messages so that errors show source as your library, even though check-types-mini threw them

For example, here's a typical throw error generated by this library:

TypeError: yourLibrary/yourFunction(): [THROW_ID_01] opts.placeholder was customised to "false" which is not boolean but string

Originally this library started as a function within one of my libraries. When I was about to copy-paste the thing into another library, I stopped and put that into a separate library, this library. I'm glad I did it, because already 7 22 36 of my libraries depend on it.

The point of check-types-mini is to save your time: time spent coding up all these checks, time spent debugging, and even consumers' time spent debugging your API when they try to use it wrongly. Every library that has options object will need some type checks if you let user tinker with it.

⬆ back to top

API

checkTypes(obj[, ref^, opts])

Use it by calling its function. You don't need to assign it to anything - good outcome is nothing happens, bad outcode is error thrown.

Technically speaking, the main and only job of check-types-mini is to throw errors when your library's consumers are using it wrongly. Error messages can be customised:

^ref can be null or undefined if all keys are set via opts.schema (see below).

⬆ back to top

Options object

Here are all defaults in one place:

{
  ignoreKeys: [],
  ignorePaths: [],
  acceptArrays: false,
  acceptArraysIgnore: [],
  enforceStrictKeyset: true,
  schema: {},
  msg: "check-types-mini",
  optsVarName: "opts"
}

⬆ back to top

For example

The common pattern is,

1. a) Define defaults object. Later it will be used to validate user's options, PLUS, if that's not enough, you can allow users to provide arrays of the matching type (set opts.acceptArrays to true)
2. b) Alternatively, you can skip defaults object and provide schema for each key via opts.schema. Just stick an object there, as a value, with all keys. Put allowed types in an array.
3. Object.assign cloned defaults onto the options object that comes from the input.
4. call check-types-mini with the above.
5. If input types mismatch, error will be thrown.

const checkTypes = require("check-types-mini");

function yourFunction(input, opts) {
  // declare defaults, so we can enforce types later:
  const defaults = {
    placeholder: false
  };
  // fill any settings with defaults if missing:
  opts = Object.assign({}, defaults, opts);

  // the check:
  checkTypes(opts, defaults, {
    msg: "newLibrary/yourFunction(): [THROW_ID_01]",
    optsVarName: "opts"
  });
  // ...
}

let res = yourFunction(1, { placeholder: "zzz" });

// =>> [TypeError: 'newLibrary/yourFunction(): [THROW_ID_01] opts.placeholder was customised to "zzz" which is not boolean but string']

Sometimes you want to accept either a string (or type "X") or an arrays of strings (elements of type "X"). As long as ALL the elements within the array match the reference type, it's OK. For these cases set opts.acceptArrays to true.

This will throw:

const checkTypes = require("check-types-mini");
checkTypes(
  {
    // < input
    option1: "setting1",
    option2: [true, true],
    option3: false
  },
  {
    // < reference
    option1: "setting1",
    option2: false,
    option3: false
  }
);
// => Throws, because reference's `option2` is Boolean ("false") but input `option2` is array ("[true, true]").

But when we allow arrays of the matching type, it won't throw anymore:

const checkTypes = require("check-types-mini");
checkTypes(
  {
    option1: "setting1",
    option2: ["setting3", "setting4"],
    option3: false
  },
  {
    option1: "setting1",
    option2: "setting2",
    option3: false
  },
  {
    acceptArrays: true
  }
);
// => Does not throw, because we allow arrays full of a matching type

If you want, you can blacklist certain keys of your objects so that opts.acceptArrays will not apply to them. Just add keys into opts.acceptArraysIgnore array.

⬆ back to top

opts.enforceStrictKeyset

When I was coding a new major version of ast-delete-object I had to update all the unit tests too. Previously, the settings were set using only one argument, Boolean-type. I had to change it to be a plain object. I noticed that when I missed updating some tests, their Booleans were Object.assigned into a default settings object and no alarm was being raised! That's not good.

Then I came up with the idea to enforce the keys of the object to match the reference and/or schema keys in options. It's on by default because I can't imagine how you would end up with settings object that does not match your default settings object, key-wise, but if you don't like that, feel free to turn it off. It's opts.enforceStrictKeyset Boolean flag.

⬆ back to top

opts.schema

Sometimes your API is more complex than a single type or array of them. Sometimes you want to allow, let's say, string or array of strings or null. What do you do?

Enter opts.schema. You can define all the types for particular key, as an array:

const checkTypes = require("check-types-mini");
checkTypes(
  {
    option1: "setting1",
    option2: null
  },
  {
    option1: "zz",
    option2: "yy" // << notice, it's given as string in defaults object
  },
  {
    schema: {
      option2: ["stRing", null]
    }
  }
);
// => does not throw

The types are case-insensitive and come from type-detect, a Chai library:

• 'object' (meaning a plain object literal, nothing else)
• 'array'
• 'string'
• 'null'
• and other usual types

Also, you can use more specific subtypes:

• 'true'
• 'false'

The 'true' and 'false' are handy in cases when API's accept only one of them, for example, 'false' and 'string', but doesn't accept 'true'.

For example,

const res = checkTypes(
  {
    // <--- this is object we're checking
    option1: "setting1",
    option2: true // <--- bad
  },
  {
    // <--- this is default reference object
    option1: "zz",
    option2: null
  },
  {
    // <--- opts
    schema: {
      option2: ["null", "false", "string"]
    }
  }
);
// => throws an error because `option2` should be either false or string, not true

All the type values you put into opts.schema are not validated, on purpose, so please don't make typos.

⬆ back to top

Contributing

• If you want a new feature in this package or you would like us to change some of its functionality, raise an issue on this repo.

• If you tried to use this library but it misbehaves, or you need advice setting it up, and its readme doesn't make sense, just document it and raise an issue on this repo.

• If you would like to add or change some features, just fork it, hack away, and file a pull request. We'll do our best to merge it quickly. Prettier is enabled, so you don't need to worry about the code style.

⬆ back to top

Licence

MIT License (MIT)

Copyright © 2018 Codsen Ltd, Roy Revelt