nevereverthrow 🔥

nevereverthrow is a fork of neverthrow that extends it's behavior with some additional useful utilities. It remains fully backward compatible to make switching as simple as changing an import.

npm i nevereverthrow

Table Of Contents

This fork extends the behavior of neverthrow so instead of making you play spot the difference we will just detail the things that have been added. For documentation of the entire API please refer back to the original project.

• Installation
• API Documentation

Installation

Because nevereverthrow is fully compatible with neverthrow all you need to do is change the import and then find and replace neverthrow with nevereverthrow.

npm un neverthrow
npm i nevereverthrow

-import { Result, ResultAsync } from "neverthrow";
+import { Result, ResultAsync } from "nevereverthrow";

⬆️ Back to top

API Documentation

ResultJson

ResultJson solves the problem of transporting results between the client and server.

In nevereverthrow you can serialize the Result type and then attach the helper methods to it again on the client/server.

Example:

// === server ===

import { ResultJson } from "nevereverthrow";

export async function mutation(): Promise<Result<number, string>> {
	if (1 > 0) return ResultJson.err("oops!");

	return ResultJson.ok(12);
}

// === client ===

import { Result, ResultAsync, ResultJson } from "nevereverthrow";

function callClient<T>(fn: () => Promise<T>): ResultAsync<T, string> {
	return ResultAsync.fromPromise(
		(async () => {
			const res = await fn();

			if (ResultJson.is(res)) {
				// cast here cause we are just turning it into the right type
				return Result.fromJson(res) as T;
			} else {
				return res;
			}
		})(),
		(e) => `${e}`
	);
}

export async function callMutation() {
	const result = await callClient(mutation);

	if (result.isErr()) {
		// internal server error
		return;
	}

	if (result.value.isErr()) {
		// show this error to the user
		return;
	}
}

ResultAsync.finally

ResultAsync.finally is a method that allows you to run a function after the ResultAsync is resolved as you traditionally would with Promise.finally.

import { ResultAsync } from "nevereverthrow";

async function callClient<T>(fn: () => Promise<T>): ResultAsync<T, string> {
	return ResultAsync.fromPromise(
		(async () => {
			// ...
		})(),
		(e) => `${e}`,
		() => console.log("finally") // declare in fromPromise
	);
}

export async function callMutation() {
	const posthog = initPosthog();
	const result = await callClient(mutation).finally(() => posthog.shutdown()); // call finally method on `ResultAsync`
}

⬆️ Back to top

If you find this package useful, please consider sponsoring supermacro or simply buying him a coffee!