Rez TypeScript

So you think error-handling in TypeScript sucks? Congratulations you've found the right lib!

Rez provides an alternative way to handle failures. A way that is:

• Transparent: Makes all possible failures visible via function signatures.
• Rigorous: Makes it possible to define and handle errors by type.
• Enforcing: Makes error-handling a must.
• Fluent: Makes advanced error-handling easy to reason about.

Installation

Run npm install rez-ts. Then import { define, AsyncResult, Result, exhaust } from "rez-ts";

Usage

Rez allows you to define a fluent result monad that can hold a rigorous set of typed failures that all become transparent within the type system:

public trySaveToDB = <TName extends DBStoreName>(plainRecord: DTO<TName>): AsyncResult<"()", "db: no connection" | "db: non-existing store">;

The first type argument of the AsyncResult, I.e "()" represents the value of the result if the function should succeed. The second type "db: no connection" | "db: non-existing store" represents known failure codes the function can fail with.

Using pattern matching we can easily handle each failure separately with side effects.

await trySaveToDB(record)
    .onSuccess(notifyRecordSaved)
    .onFailure(failure => {
        if (failure.type === "db: no connection")
            handleNoConnection(failure.error);
        else if (failure.type === "db: non-existing store")
            handleNoStore(failure.error);
        else
            exhaust(failure.type);
    });

This way of handling failures is not always ideal. Sometimes we need to design with fault tolerance in mind, we need a way to recover.

 await trySaveToDB(record)
   .tryRecoverFrom("db: no connection")
   .with(putInQueueStorage); 

After a recovery we're free to continue traveling on our happy path result chain.