typescript-eslint · JoshuaKGoldberg · Nov 4, 2024 · Oct 28, 2024 · Oct 28, 2024 · Oct 28, 2024
diff --git a/docs/packages/type-utils/TypeOrValueSpecifier.mdx b/docs/packages/type-utils/TypeOrValueSpecifier.mdx
@@ -132,4 +132,5 @@ Universal string specifiers will be removed in a future major version of typescr
 
 - [`@typescript-eslint/no-floating-promises` > `allowForKnownSafeCalls`](/rules/no-floating-promises#allowforknownsafecalls)
 - [`@typescript-eslint/no-floating-promises` > `allowForKnownSafePromises`](/rules/no-floating-promises#allowforknownsafepromises)
+- [`@typescript-eslint/only-throw-error` > `allow`](/rules/only-throw-error/#allow)
 - [`@typescript-eslint/prefer-readonly-parameter-types` > `allow`](/rules/prefer-readonly-parameter-types/#allow)
diff --git a/packages/eslint-plugin/docs/rules/only-throw-error.mdx b/packages/eslint-plugin/docs/rules/only-throw-error.mdx
@@ -102,6 +102,27 @@ This rule adds the following options:
 
 ```ts
 interface Options {
+  /**
+   * Type specifiers that can be thrown.
+   */
+  allow?: (
+    | {
+        from: 'file';
+        name: [string, ...string[]] | string;
+        path?: string;
+      }
+    | {
+        from: 'lib';
+        name: [string, ...string[]] | string;
+      }
+    | {
+        from: 'package';
+        name: [string, ...string[]] | string;
+        package: string;
+      }
+    | string
+  )[];
+
   /**
    * Whether to always allow throwing values typed as `any`.
    */
@@ -114,8 +135,9 @@ interface Options {
 }
 
 const defaultOptions: Options = {
-  allowThrowingAny: false,
-  allowThrowingUnknown: false,
+  allow: [],
+  allowThrowingAny: true,
+  allowThrowingUnknown: true,
 };
 ```
 

diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -3,18 +3,23 @@ import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
+import type { TypeOrValueSpecifier } from '../util';
+
 import {
   createRule,
   getParserServices,
   isErrorLike,
   isTypeAnyType,
   isTypeUnknownType,
+  typeMatchesSomeSpecifier,
+  typeOrValueSpecifiersSchema,
 } from '../util';
 
 type MessageIds = 'object' | 'undef';
 
 type Options = [
   {
+    allow?: TypeOrValueSpecifier[];
     allowThrowingAny?: boolean;
     allowThrowingUnknown?: boolean;
   },
@@ -39,6 +44,10 @@ export default createRule<Options, MessageIds>({
         type: 'object',
         additionalProperties: false,
         properties: {
+          allow: {
+            ...typeOrValueSpecifiersSchema,
+            description: 'Type specifiers that can be thrown.',
+          },
           allowThrowingAny: {
             type: 'boolean',
             description:
@@ -55,13 +64,14 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [
     {
+      allow: [],
       allowThrowingAny: true,
       allowThrowingUnknown: true,
     },
   ],
   create(context, [options]) {
     const services = getParserServices(context);
-
+    const allow = options.allow;
     function checkThrowArgument(node: TSESTree.Node): void {
       if (
         node.type === AST_NODE_TYPES.AwaitExpression ||
@@ -72,6 +82,10 @@ export default createRule<Options, MessageIds>({
 
       const type = services.getTypeAtLocation(node);
 
+      if (typeMatchesSomeSpecifier(type, allow, services.program)) {
+        return;
+      }
+
       if (type.flags & ts.TypeFlags.Undefined) {
         context.report({ node, messageId: 'undef' });
         return;

diff --git a/packages/eslint-plugin/tests/fixtures/errors.ts b/packages/eslint-plugin/tests/fixtures/errors.ts
@@ -0,0 +1,6 @@
+// @ts-ignore
+declare module 'errors' {
+  class ErrorLike {}
+
+  export function createError(): ErrorLike;
+}
diff --git a/packages/eslint-plugin/tests/fixtures/tsconfig.json b/packages/eslint-plugin/tests/fixtures/tsconfig.json
@@ -14,6 +14,7 @@
     "deprecated.ts",
     "mixed-enums-decl.ts",
     "react.tsx",
-    "var-declaration.ts"
+    "var-declaration.ts",
+    "errors.ts"
   ]
 }
diff --git a/packages/eslint-plugin/tests/rules/only-throw-error.test.ts b/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
@@ -139,6 +139,56 @@ function fun<T extends Error>(t: T): void {
   throw t;
 }
     `,
+    {
+      code: `
+throw undefined;
+      `,
+      options: [
+        {
+          allow: [{ from: 'lib', name: 'undefined' }],
+          allowThrowingAny: false,
+          allowThrowingUnknown: false,
+        },
+      ],
+    },
+    {
+      code: `
+class CustomError implements Error {}
+throw new CustomError();
+      `,
+      options: [
+        {
+          allow: [{ from: 'file', name: 'CustomError' }],
+          allowThrowingAny: false,
+          allowThrowingUnknown: false,
+        },
+      ],
+    },
+    {
+      code: `
+throw new Map();
+      `,
+      options: [
+        {
+          allow: [{ from: 'lib', name: 'Map' }],
+          allowThrowingAny: false,
+          allowThrowingUnknown: false,
+        },
+      ],
+    },
+    {
+      code: `
+        import { createError } from 'errors';
+        throw createError();
+      `,
+      options: [
+        {
+          allow: [{ from: 'package', name: 'ErrorLike', package: 'errors' }],
+          allowThrowingAny: false,
+          allowThrowingUnknown: false,
+        },
+      ],
+    },
   ],
   invalid: [
     {
@@ -485,5 +535,23 @@ function fun<T extends number>(t: T): void {
         },
       ],
     },
+    {
+      code: `
+class UnknownError implements Error {}
+throw new UnknownError();
+      `,
+      errors: [
+        {
+          messageId: 'object',
+        },
+      ],
+      options: [
+        {
+          allow: [{ from: 'file', name: 'CustomError' }],
+          allowThrowingAny: false,
+          allowThrowingUnknown: false,
+        },
+      ],
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/schema-snapshots/only-throw-error.shot b/packages/eslint-plugin/tests/schema-snapshots/only-throw-error.shot