might-fail
v0.3.1
Published
Return an Either object instead of throwing an exception
Downloads
111
Maintainers
Readme
Might Fail
A TypeScript library for handling async and sync errors without try
and catch
blocks. Inspired by other languages that utilize Result or Either types for safer error handling. The following examples are verbose to show how you would handle different types of errors differently instead of just catching all errors together and handling them in the same way. However, you can use mightFail
to handle all errors in the same way if you want.
Async
Wrap Promise in mightFail
const { error, result } = await mightFail(axios.get("/posts"));
if (error) {
// handle error
return;
}
const posts = result.data
posts.map((post) => console.log(post.title));
or:
const { error: networkError, result } = await mightFail(fetch("/posts"));
if (networkError) {
// handle network error
return;
}
if (!result.ok) {
// handle an error response from server
return;
}
const { error: convertToJSONError, result: posts } = await mightFail(
result.json()
);
if (convertToJSONError) {
// handle convertToJSONError
return;
}
posts.map((post) => console.log(post.title));
Or Wrap Async Function in makeMightFail
const get = makeMightFail(axios.get);
const { error, result } = await get("/posts");
if (error) {
// handle error
return;
}
const posts = result.data
posts.map((post) => console.log(post.title));
Sync
Wrap throwing functions in mightFailSync
const {error, result} = mightFailSync(() => JSON.parse("")); // JSON.parse might throw
if (error) {
console.error('Parsing failed:', error);
return
}
console.log('Parsed object:', result);
Or Wrap Sync Function in makeMightFailSync
function parseJSON(jsonString: string) {
return JSON.parse(jsonString); // This might throw
}
const safeParseJSON = makeMightFailSync(parseJSON);
const { error, result } = safeParseJSON("");
if (error) {
console.error("Parsing failed:", error);
return;
}
console.log("Parsed object:", result);
Either Type
await
ing the mightFail
functions will return an Either
type with either an error
or a result
.
error
always has the typeError | undefined
.result
always has the typeT | undefined
whereT
is the type of the result of the promise passed tomightFail
.
This means that the you never lose the type information of the result of the promise passed to mightFail
.
Motivation
I think throwing exceptions is cool, I like that an exception breaks control flow and I like exception propogation. The only thing I don't like catching exceptions. This mostly happens at the most "user facing" part of the code like an api endpoint or a UI component, the outer most function call. So catching an exception needs to notify the user that something went wrong, log the error for debugging, and stop the currently execution flow.
Guard ✅
Guarding allows you to handle your errors early and return from the function early, making them more readable and easier to reason about.
const { error: networkError, result } = await mightFail(fetch("/posts"));
// guard against a network error
if (networkError) {
return;
}
// guard against an error response from the server
if (!result.ok) {
return;
}
const { error: convertToJSONError, result: posts } = await mightFail(
result.json()
);
// guard against an error converting the response to JSON
if (convertToJSONError) {
return;
}
// success case, unnested and at the bottom of the function
posts.map((post) => console.log(post.title));
The success case is now the only code that is not nested in an if
statement. It's also at the very bottom of the function making it easy to find.
Everything in One Try/Catch Block ❌
try {
const response = await fetch("/posts");
if (!response.ok) {
// handle an error response from server
return;
}
const posts = await response.json();
posts.map((post) => console.log(post.title));
} catch (error) {
// handle any errors, not sure which one though 🤷♀️
}
This is bad because:
- Error handling happens in multiple places in the function.
- The catch block will catch any and all errors which makes it difficult to handle different errors differently.
- All the success case code will happen inside of the try block
Multiple Try/Catch Blocks ❌
let response: Response;
try {
response = await fetch("/posts");
} catch (error) {
// guard against a network error
return;
}
if (!response.ok) {
// guard against an error response from server
return;
}
let posts: Post[];
try {
posts = await response.json();
} catch (error) {
// guard against an error converting the response to JSON
return;
}
posts.map((post) => console.log(post.title));
Declaring the variable ahead of time is a little weird and it makes infering the type of the variable a little more difficult. Also, try catch finally blocks can be confusing.
try
catch
finally
can be confusing ❌
function something() {
try {
throw new Error("something went wrong");
} catch(error) {
console.log("error happened")
return "error return"
} finally {
console.log("finally happened")
return "finally return"
}
return "something return"
}
console.log(something())
Can every single dev in your team understand what the above code will print out?