noex

Golang style error handling for Functions, Promises and Thenables.

Install

Using npm:

$ npm install noex

Using yarn:

$ yarn add noex

Usage

// ESM
import { noex } from 'noex'

// CJS
const { noex } = require('noex')

Resolve a Promise:

// as a "tuple"
const [ file, fileError ] = await noex(fs.promises.readFile('someFile'))
// as a "named tuple"
const { value, error } = await noex(fs.promises.readFile('someFile'))

Call a Function:

// as a "tuple"
const [ json, jsonError ] = noex(() => JSON.parse('{"success": true}'))
// as a "named tuple"
const { value, error } = noex(() => JSON.parse('{"success": true}'))

Example

router.get('/api/resource/:id', async (req, res) => {
    const [ resource, resourceErr ] = await noex(
        resourceService.findById(req.params.id)
    )

    // database error
    if (resourceErr) {
        logger.error(resourceErr)
        return res.sendStatus(500)
    }

    // resource not found
    if (! resource) {
        return res.sendStatus(404)
    }

    return res.json(resource)
})

API

noex(predicate: Promise<any>): Promise<Result<any, Error>>

Run a function in a try-catch block and return the result.

const [ content, error ] = await noex(
    fs.promises.readFile('path/to/file')
)

noex(predicate: Function): Result<any, Error>

Run a promise or thenable in a try-catch block and return the result.

const [ json, error ] = noex(function () {
    return JSON.parse('{ "identity": "Bourne" }')
})

noex(predicate: Array<Promise<any>|Function>): Promise<Array<Result<any, Error>>>

Run a series of functions, promises and/or thenables and return their results.

const [ res1, res2 ] = await noex([
    () => JSON.parse('{ "identity": "Bourne" }'),
    fs.promises.readFile('path/to/file')
])

noex.wrap(fn: (...args: any[]) => Promise<any>): (...args: any[]) => Promise<Result<any, Error>>

Wrap a function that returns a promise with noex.

const readFile = noex.wrap(function (file) {
    return fs.promises.readFile(file)
})

const [ content, error ] = await readfile('path/to/file')

noex.wrap(fn: (...args: any[]) => any): (...args: any[]) => Result<any, Error>

Wrap a function with noex.

const parseJson = noex.wrap(JSON.parse)

const [ json, error ] = parseJson('{ "identity": "Bourne" }')

noex.chain(predicates: Array<(...args: any[]) => any>): Promise<Result<any, Error>>

Run the given predicates in sequence, passing the result of each predicate to the next one in the list.

 const [ val, err ] = await noex([
    ()  => JSON.parse('{ "identity": "Bourne" }'),
    json => json.identity.toUpperCase(),
 ])
 console.log(val) //=> "BOURNE"

Result<any, Error>: Array<any>

The object to hold the resulting value or error of a function, promise or thenable.

Properties:

• value (any) : The resulting value of a function, promise or thenable.
• val (any) : Same as value.
• error (Error) : The error caught by the try-catch block.
• err (Error) : Same as error.

License

This project is open-sourced software licensed under the MIT license.