Say goodbye Trycatch Hell
Tags: programming, productivity, typescript, webdev
Published: 2021-09-18 23:28:43

Hi everyone! It is possible that it is here for the post title, and I daresay you have had problems handling errors with `async/await`. In this post you will learn a trick to avoid **trycatch hell** but before, it is neccessary to know a little history.

## History of Callback.
Once upon a time, developers had to deal with tasks that took a while, and the way we could check if the task was done was through callback.

*Callbacks* are nothing more than functions that are executed when a task has been completed, either erroneously or successfully. Until this moment, there is nothing bad. The problem arises when these callbacks in turn execute other functions, and so on. And that's when the macabre happens.

![Animation Callback Hell](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w0qf9d2j4o72qaco5ib4.gif)

For this reason. Promise are born, as a solution to this problem.

## Promises.
The promises are objects that represent the completion of a process, this can be a failure (reject) or a success (resolve). Also, lets add this beauty.

![Comparation Promise vs Callback](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/48wy8acxcumw75rtiqq3.png)

Everything seemed magical, until...

![Picture trycatch hell](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qxq0uis5ffx039it6y8m.png)

Using async await makes the code more readable, it looks more beautiful, but it has a problem, is that if the promise fails, it will stop the flow of our system, so it is necessary to handle the errors.

But when handling these with trycatch we lose that readability, but don't worry, those are over now my dear friend.

## How implemented.
First, we are going to simulate a whole. Let's do it.

We define some interfaces, and add test content.

```ts
interface Note {
  id: number;
  name: string;
}

interface Query {
  [key: string]: any;
}

const notes: Note[] = [
  {
    id: 1,
    name: "Megadeth",
  },
  {
    id: 2,
    name: "Korn",
  },
];

```

We define some functions.

```ts
async function update(id: number, data: Omit<Note, "id">, options: Query): Promise<Note> {
  const index: number = notes.findIndex(n => n.id === id);
  if (index < 0) throw new Error("Note does not exist");

  const updated: Note = { id, ...data };
  notes.splice(index, 1, updated);
  return updated;
};

async function remove(id: number, options: Query): Promise<Note> {
  const index: number = notes.findIndex(n => n.id === id);
  if (index < 0) throw new Error("Note does not exist.");

  const note: Note = notes[index];
  notes.splice(index, 1);
  return note;
};

```

We define our promise handler.

```ts
async function promHandler<T>(
  prom: Promise<T>
): Promise<[T | null, any]> {
  try {
    return [await prom, null];
  } catch (error) {
    return [null, error];
  }
}
```

This function receives a promise as a parameter, then we execute the promise within the trycatch, in order to handle the errors, and we will return an array, in which the first index [0] will be the Response or Result and the second [1] the Error.

> Note: You may see a **T**, this is necessary because we need to know the type of data at all times, they are called generics, if you need to know more, click on the following link: https://www.typescriptlang.org/docs/handbook/2/generics.html

Now, we only consume our handler.

```ts
  const [updated, err] = await promHandler(
    update(1, { name: "Mudvayne" }, {})
  );
  // updated -> {id: 1, name: "Mudvayne"}
  // err -> null

  const [removed, error] = await promHandler(remove(4, {}));
  // removed -> null
  // error -> Error "Does not exist."

```

*Now I ask you, does it look better?*

Perfect, we already know how to avoid trycatch hell, but this only using promises, what about synchronous functions?

## Handling synchronous functions.

We convert our previous functions to synchronous.

```ts
function update(id: number, data: Omit<Note, "id">, options: Query): Note {
  // ...
};

function remove(id: number, options: Query): Note {
  // ...
};
```

We define our synchronous function handler.

```ts
function funcHandler<T extends any[], K>(
  func: (...args: T) => K,
  ...params: T
): [K | null, any] {
  try {
    return [func(...params), null];
  } catch (error) {
    return [null, error];
  }
}
```

> Explanation: This function is a bit different than the previous one, since in this one, we have to give it the function (without executing) and the parameters.

This function will have two generics, where **T** represents the parameters that the function receives, and **K** the value that it returns. Also, we make use of the *spread syntax* As we do not know the number of parameters that can reach us, we will make use of these 3 magic points (...) ✨

And now, we carry out the previous process, first index, Result; second indicer, Error. And ready!

We carry out the operations.

```ts
  const [updated, err] = funcHandler(update, 1, { name: "Mudvayne" }, {});
  // updated -> {id: 1, name: "Mudvayne"}
  // err -> null

  const [removed, error] = funcHandler(remove, 6, {});
  // removed -> null
  // error -> Error "Does not exist."

```

Great, we no longer have to struggle to make our code look more readable, and also, we reuse the handles.

You know, if you have something to contribute, a question, an improvement, you can contribute in the comments, and if it has been useful, leave your reaction, that makes me happy.

### Follow me on social networks.

- 🎉 Twitter: https://twitter.com/ToSatn2
- 💡 Github: https://github.com/IvanZM123