Is there a way to accurately identify the type of error that arises from a promise?

Question

Is there a way to accurately identify the type of error that arises from a promise?

Utilizing the promise method within my script is essential.

  try {
    const secretData = await secretManager.getSecretValue({ SecretId: secretId }).promise();
    const secretString = secretData.SecretString;
  } catch (error) {
    if (error.code !== 'ResourceNotFoundException') {
      throw(error);
    }
  }

Upon inspecting the promise method, it reveals a type of

Promise<PromiseResult<AWS.SecretsManager.GetSecretValueResponse, AWS.AWSError>>

.

However, the type of the error in the catch block remains as unknown.

I am eager to understand how I can prompt TypeScript to recognize the error's type.

typescript amazon-web-services

Answer 1

Answer №1

Issue

In TypeScript, the exception variable in a catch block is typed as unknown for safety reasons since the type of the thrown error is not known due to the possibility of throwing any valid JavaScript expression. However, there have been ongoing discussions about enhancing this behavior, refer to TypeScript#13219 for more information.

Resolution

To address this, you can assist TypeScript in narrowing down the error type using the following methods:

Narrowing with `instanceof`

If you know the specific error class, you can narrow down the error by checking if it is an instance of that class.

class CustomError extends Error {
  foo: string;

  constructor(message: string) {
    super(message);
    this.name = "CustomError";
    this.foo = "foo";
  }
}

function foo() {}

try {
  foo();
} catch (error) {
  if (error instanceof CustomError)  {
    console.log(error);
    //          ^^^^^
    //        Hover here
    // `var error: CustomError` should appear
    // `error` has been narrowed to `CustomError`
  }
}

TypeScript Playground

Type predicate and `in` operator narrowing

You can also narrow down the error type by checking for specific properties that your error should possess through a type predicate.

class CustomError extends Error {
  foo: string;

  constructor(message: string) {
    super(message);
    this.name = "CustomError";
    this.foo = "foo";
  }
}

function foo() {}

function isCustomError(error: any): error is CustomError {
  return "foo" in error;
}

try {
  foo();
} catch (error) {
  if (isCustomError(error)) {
    console.log(error);
    //          ^^^^^
    //        Hover here
    // `var error: CustomError` should appear
    // `error` has been narrowed to `CustomError`
  }
}

TypeScript Playground

For additional information

Answer 2

Issue

In TypeScript, the exception variable in a catch block is typed as unknown for safety reasons since the type of the thrown error is not known due to the possibility of throwing any valid JavaScript expression. However, there have been ongoing discussions about enhancing this behavior, refer to TypeScript#13219 for more information.

Resolution

To address this, you can assist TypeScript in narrowing down the error type using the following methods:

Narrowing with `instanceof`

If you know the specific error class, you can narrow down the error by checking if it is an instance of that class.

class CustomError extends Error {
  foo: string;

  constructor(message: string) {
    super(message);
    this.name = "CustomError";
    this.foo = "foo";
  }
}

function foo() {}

try {
  foo();
} catch (error) {
  if (error instanceof CustomError)  {
    console.log(error);
    //          ^^^^^
    //        Hover here
    // `var error: CustomError` should appear
    // `error` has been narrowed to `CustomError`
  }
}

TypeScript Playground

Type predicate and `in` operator narrowing

You can also narrow down the error type by checking for specific properties that your error should possess through a type predicate.

class CustomError extends Error {
  foo: string;

  constructor(message: string) {
    super(message);
    this.name = "CustomError";
    this.foo = "foo";
  }
}

function foo() {}

function isCustomError(error: any): error is CustomError {
  return "foo" in error;
}

try {
  foo();
} catch (error) {
  if (isCustomError(error)) {
    console.log(error);
    //          ^^^^^
    //        Hover here
    // `var error: CustomError` should appear
    // `error` has been narrowed to `CustomError`
  }
}

TypeScript Playground

For additional information

Is there a way to accurately identify the type of error that arises from a promise?

Answer №1

Issue

Resolution

Narrowing with `instanceof`

Type predicate and `in` operator narrowing

For additional information

Similar questions

Utilizing Angular 2's NgFor directive in SVG Elements

Angular2 restricts Http requests within a specified time interval

Can you explain the distinction between App: React.FunctionComponent and App = (): React.FunctionComponent()?

Guide for setting CSRF cookie in Next.js for Django

Issue: Control with the specified name '0' could not be located

One-of-a-kind npm module for typescript

What is a way to merge all the letters from every console.log result together?

An issue occurred while attempting to pretty-print JSON in Typescript

Limiting the combinations of types in TypeScript

When using react-admin with TypeScript, it is not possible to treat a namespace as a type

Typedoc encountering an issue due to the require syntax

Azure pipeline failing to run Visual Studio 2017 task because of outdated Typescript SDK version

Determining the height of dynamically rendered child elements in a React application

What is the best way to implement generics for a zip function in TypeScript?

Alert: Circular dependency identified: Unable to determine the module

Ways to manage an interactive pricing structure chart in Angular?

The type 'MutableRefObject<undefined>' cannot be assigned to the type 'LegacyRef<HTMLDivElement> | undefined'

This code cannot be called as a function, Every individual in the union

Custom type declaration file in Typescript fails to function properly

Enhance your coding experience with TypeScript's autocomplete in Visual Studio Code

Is there a way to accurately identify the type of error that arises from a promise?

Answer №1

Issue

Resolution

Narrowing with instanceof

Type predicate and in operator narrowing

For additional information

Similar questions

Utilizing Angular 2's NgFor directive in SVG Elements

Angular2 restricts Http requests within a specified time interval

Can you explain the distinction between App: React.FunctionComponent and App = (): React.FunctionComponent()?

Guide for setting CSRF cookie in Next.js for Django

Issue: Control with the specified name '0' could not be located

One-of-a-kind npm module for typescript

What is a way to merge all the letters from every console.log result together?

An issue occurred while attempting to pretty-print JSON in Typescript

Limiting the combinations of types in TypeScript

When using react-admin with TypeScript, it is not possible to treat a namespace as a type

Typedoc encountering an issue due to the require syntax

Azure pipeline failing to run Visual Studio 2017 task because of outdated Typescript SDK version

Determining the height of dynamically rendered child elements in a React application

What is the best way to implement generics for a zip function in TypeScript?

Alert: Circular dependency identified: Unable to determine the module

Ways to manage an interactive pricing structure chart in Angular?

The type 'MutableRefObject<undefined>' cannot be assigned to the type 'LegacyRef<HTMLDivElement> | undefined'

This code cannot be called as a function, Every individual in the union

Custom type declaration file in Typescript fails to function properly

Enhance your coding experience with TypeScript's autocomplete in Visual Studio Code

Narrowing with `instanceof`

Type predicate and `in` operator narrowing