Fix detection of AmplifyErrors (#2200)

* Fix detection of AmplifyErrors

* fix check

* fix check

Author: Kamil Sobol

.changeset/green-cups-jam.md

@@ -0,0 +1,10 @@
+---
+'@aws-amplify/platform-core': minor
+'@aws-amplify/backend-deployer': patch
+'@aws-amplify/backend-data': patch
+'@aws-amplify/backend': patch
+'@aws-amplify/sandbox': patch
+'@aws-amplify/backend-cli': patch
+---
+
+Fix detection of AmplifyErrors

.eslint_dictionary.json

@@ -81,6 +81,7 @@
   "idps",
   "implementors",
   "inheritdoc",
+  "instanceof",
   "interop",
   "invokable",
   "invoker",

packages/backend-data/src/factory.ts

@@ -184,7 +184,7 @@ class DataGenerator implements ConstructContainerEntryGenerator {
         this.props.authorizationModes
       );
     } catch (error) {
-      if (error instanceof AmplifyError) {
+      if (AmplifyError.isAmplifyError(error)) {
         throw error;
       }
       throw new AmplifyUserError<AmplifyDataError>(

packages/backend-deployer/src/cdk_deployer.ts

@@ -86,7 +86,7 @@ export class CDKDeployer implements BackendDeployer {
     } catch (typeError: unknown) {
       if (
         synthError &&
-        typeError instanceof AmplifyError &&
+        AmplifyError.isAmplifyError(typeError) &&
         typeError.cause?.message.match(
           /Cannot find module '\$amplify\/env\/.*' or its corresponding type declarations/
         )

packages/cli/src/commands/sandbox/sandbox_command.test.ts

@@ -121,7 +121,7 @@ void describe('sandbox command', () => {
       () =>
         commandRunner.runCommand(`sandbox --identifier ${invalidIdentifier}`), // invalid identifier
       (err: TestCommandError) => {
-        assert.ok(err.error instanceof AmplifyError);
+        assert.ok(AmplifyError.isAmplifyError(err.error));
         assert.strictEqual(
           err.error.message,
           'Invalid --identifier provided: invalid@'

packages/cli/src/commands/sandbox/sandbox_event_handler_factory.ts

@@ -64,7 +64,7 @@ export class SandboxEventHandlerFactory {
             return;
           }
           const deployError = args[0];
-          if (deployError && deployError instanceof AmplifyError) {
+          if (deployError && AmplifyError.isAmplifyError(deployError)) {
             await usageDataEmitter.emitFailure(deployError, {
               command: 'Sandbox',
             });

packages/cli/src/error_handler.ts

@@ -111,7 +111,7 @@ const handleError = async ({
 
   printMessagePreamble?.();
 
-  if (error instanceof AmplifyError) {
+  if (AmplifyError.isAmplifyError(error)) {
     printer.print(format.error(`${error.name}: ${error.message}`));
 
     if (error.resolution) {
@@ -141,7 +141,7 @@ const handleError = async ({
   }
 
   await usageDataEmitter?.emitFailure(
-    error instanceof AmplifyError
+    AmplifyError.isAmplifyError(error)
       ? error
       : AmplifyError.fromError(
           error && error instanceof Error ? error : new Error(message)

packages/eslint-rules/src/index.ts

@@ -2,9 +2,11 @@ import { noEmptyCatchRule } from './rules/no_empty_catch.js';
 import { amplifyErrorNameRule } from './rules/amplify_error_name.js';
 import { preferAmplifyErrorsRule } from './rules/prefer_amplify_errors.js';
 import { noAmplifyErrors } from './rules/no_amplify_errors.js';
+import { amplifyErrorNoInstanceOf } from './rules/amplify_error_no_instance_of';
 
 export const rules: Record<string, unknown> = {
   'amplify-error-name': amplifyErrorNameRule,
+  'amplify-error-no-instanceof': amplifyErrorNoInstanceOf,
   'no-empty-catch': noEmptyCatchRule,
   'prefer-amplify-errors': preferAmplifyErrorsRule,
   'no-amplify-errors': noAmplifyErrors,
@@ -15,6 +17,7 @@ export const configs = {
     plugins: ['amplify-backend-rules'],
     rules: {
       'amplify-backend-rules/amplify-error-name': 'error',
+      'amplify-backend-rules/amplify-error-no-instanceof': 'error',
       'amplify-backend-rules/no-empty-catch': 'error',
       'amplify-backend-rules/prefer-amplify-errors': 'off',
       'amplify-backend-rules/no-amplify-errors': 'off',

packages/eslint-rules/src/rules/amplify_error_no_instance_of.test.ts

@@ -0,0 +1,28 @@
+import * as nodeTest from 'node:test';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { amplifyErrorNoInstanceOf } from './amplify_error_no_instance_of.js';
+
+RuleTester.afterAll = nodeTest.after;
+// See https://typescript-eslint.io/packages/rule-tester/#with-specific-frameworks
+// Node test runner methods return promises which are not relevant in the context of testing.
+// We do ignore them in other places with void keyword.
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+RuleTester.it = nodeTest.it;
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+RuleTester.describe = nodeTest.describe;
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('amplify-error-no-instanceof', amplifyErrorNoInstanceOf, {
+  valid: ['e instanceof Error'],
+  invalid: [
+    {
+      code: 'e instanceof AmplifyError',
+      errors: [
+        {
+          messageId: 'noInstanceOfWithAmplifyError',
+        },
+      ],
+    },
+  ],
+});

packages/eslint-rules/src/rules/amplify_error_no_instance_of.ts

@@ -0,0 +1,41 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+/**
+ * This rule flags empty catch blocks. Even if they contain comments.
+ *
+ * This rule differs from built in https://github.com/eslint/eslint/blob/main/lib/rules/no-empty.js
+ * in such a way that it uses typescript-eslint and typescript AST
+ * which does not include comments as statements in catch clause body block.
+ */
+export const amplifyErrorNoInstanceOf = ESLintUtils.RuleCreator.withoutDocs({
+  create(context) {
+    return {
+      // This naming comes from @typescript-eslint/utils types.
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      BinaryExpression(node) {
+        if (
+          node.operator === 'instanceof' &&
+          node.right.type === 'Identifier' &&
+          node.right.name === 'AmplifyError'
+        ) {
+          context.report({
+            messageId: 'noInstanceOfWithAmplifyError',
+            node,
+          });
+        }
+      },
+    };
+  },
+  meta: {
+    docs: {
+      description: 'Instanceof operator must not be used with AmplifyError.',
+    },
+    messages: {
+      noInstanceOfWithAmplifyError:
+        'Do not use instanceof with AmplifyError. Use AmplifyError.isAmplifyError instead.',
+    },
+    type: 'problem',
+    schema: [],
+  },
+  defaultOptions: [],
+});