Add method helper

[mmkal]

This is something I've wished existed for a while. The problem being: I'd like to write a function with specific input types, which is going to be invoked from call-sites outside the project I'm working in (e.g., a library function, an http request/serverless function handler/some json file processor etc.).

But I'd also like to be able to call it internally - the simplest use case being from a unit test.

Example:

// calculator.ts
import ow from 'ow'

const add = ow.method([ow.number, ow.number], (a, b) => a + b)

const subtract = ow.method([ow.number, ow.number], (a, b) => a - b)

const multiply = ow.method([ow.number, ow.number], (a, b) => a * b)

const divide = ow.method([ow.number, ow.number.not.equal(0)], (a, b) => a / b)

Note that a and b are strongly typed (as numbers in the above example) in each function.

Previously the options aren't that great. You can either be safe by typing all inputs as unknown, which makes sure that the validation is done, but offers no help to callers or the function:

const add = (a: unknown, b: unknown) => {
  // good: the type system makes sure we remember to validate the inputs (albeit with some boilerplate)
  ow(a, ow.number)
  ow(b, ow.number)
  return a + b
}

// bad: the type system doesn't stop callers from sending bad inputs.
// This isn't a bug in the function, but it'll still lead to errors:
add('foo', { bar: true })

Or you can type them as number, which provides types to callers, but means that allows skipping the assertion at the type level, leading to errors at runtime if bad data is passed to the function:

// bad: type system has been told the inputs will definitely be a number. But what if the inputs come from an `any` type, or javascript?
const add = (a: number, b: number) => a + b

app.use((req, res) => {
  // undefined behaviour if someone sends a body like { "a": "foo", "b": { "bar": true } }?
  res.send({ sum: add(req.body.a, req.body.b) })
})

Or, you can write a separate type signature, leading to confusing/unnecessary boilerplate:

Instead of:

const add = ow.method([ow.number, ow.number], (a, b) => a + b)

you would have to do:

const add: (a: number, b: number) => number = (a: unknown, b: unknown) => {
  ow(a, ow.number)
  ow(b, ow.number)
  return a + b
}

Curious to hear any thoughts on the idea!

Update :I've since noticed similar functionality in zod.

[sindresorhus]

It's common to support 10 when doing this kind of thing.

[sindresorhus]

Would be useful to elaborate a little bit more on the use-case. As a user, I'm not entirely sure still when I would use it.

[sindresorhus]

Do we really need an overload here? Can't we just make this parameter optional?

[sindresorhus]

Looks like a useful utility to me.

[sindresorhus]

What do you think about the name .wrap instead of .method?

[sindresorhus]

Bump :)

[mmkal]

@sindresorhus sorry, I don't think I'll find the time anytime soon to take this over the line, so closing. Feel free to use as a reference for a future implementation though/if you want to make an issue for this idea.