Support for the loggerFunctions option

Author: Nodge

.prettierignore

@@ -1,3 +1,4 @@
 dist/
 node_modules/
 package-lock.json
+*.md

README.md

@@ -60,7 +60,12 @@ You can customize the logger functions that are used to log errors in your proje
 {
     "settings": {
         "handle-errors": {
-            "loggerFunctions": ["console.error", "console.warn", "Sentry.captureException", "logError"]
+            "loggerFunctions": [
+                "console.error", 
+                "console.warn", 
+                "Sentry.captureException", 
+                "logError"
+            ]
         }
     }
 }

src/rules/log-error-in-promises.test.ts

@@ -136,6 +136,11 @@ runRuleTester('log-error-in-promises', logErrorInPromises, {
             `,
         },
         {
+            settings: {
+                handleErrors: {
+                    loggerFunctions: ['logError'],
+                },
+            },
             code: dedent`
                a.then(callback).catch(logError)
             `,

src/rules/log-error-in-promises.ts

@@ -1,8 +1,6 @@
 import { createRule } from '../utils/createRule';
 import { createLoggerCallTracker, createCallExpression, createMemberExpression } from '../utils/loggerCallTracker';
-
-// TODO: add option to specify custom loggers
-const loggers = ['console.error', 'console.warn', 'Sentry.captureException'] as const;
+import { parseSettings } from '../utils/settings';
 
 export const logErrorInPromises = createRule({
     meta: {
@@ -21,7 +19,8 @@ export const logErrorInPromises = createRule({
         schema: [],
     },
     create(context) {
-        const tracker = createLoggerCallTracker(node =>
+        const settings = parseSettings(context.settings);
+        const tracker = createLoggerCallTracker(settings, node =>
             context.report({
                 node,
                 messageId: 'error-not-handled',
@@ -42,7 +41,7 @@ export const logErrorInPromises = createRule({
             [`${catchCall}[arguments.length=1] > :function BlockStatement ThrowStatement`]:
                 tracker.onErrorProccessingInBlock,
 
-            ...loggers.reduce((acc, logger) => {
+            ...settings.loggerFunctions.reduce((acc, logger) => {
                 Object.assign(acc, {
                     [`CallExpression[callee.property.name="catch"][arguments.length=1] > :function > BlockStatement > ExpressionStatement > ${createCallExpression(logger)}`]:
                         tracker.onErrorProccessingInRoot,

src/rules/log-error-in-trycatch.ts

@@ -1,8 +1,6 @@
 import { createRule } from '../utils/createRule';
 import { createLoggerCallTracker, createCallExpression } from '../utils/loggerCallTracker';
-
-// TODO: add option to specify custom loggers
-const loggers = ['console.error', 'console.warn', 'Sentry.captureException'] as const;
+import { parseSettings } from '../utils/settings';
 
 export const logErrorInTrycatch = createRule({
     meta: {
@@ -21,7 +19,8 @@ export const logErrorInTrycatch = createRule({
         schema: [],
     },
     create(context) {
-        const tracker = createLoggerCallTracker(node => {
+        const settings = parseSettings(context.settings);
+        const tracker = createLoggerCallTracker(settings, node => {
             context.report({
                 node,
                 messageId: 'error-not-handled',
@@ -40,7 +39,7 @@ export const logErrorInTrycatch = createRule({
             'CatchClause > BlockStatement > ThrowStatement': tracker.onErrorProccessingInRoot,
             'CatchClause BlockStatement ThrowStatement': tracker.onErrorProccessingInBlock,
 
-            ...loggers.reduce((acc, logger) => {
+            ...settings.loggerFunctions.reduce((acc, logger) => {
                 Object.assign(acc, {
                     [`CatchClause > BlockStatement > ExpressionStatement > ${createCallExpression(logger)}`]:
                         tracker.onErrorProccessingInRoot,

src/utils/loggerCallTracker.ts

@@ -1,6 +1,7 @@
 import { Rule } from 'eslint';
 import { BlockStatement, ReturnStatement, ThrowStatement } from 'estree';
 import t from '@babel/types';
+import { Settings } from './settings';
 
 interface ScopeStackEntry {
     isErrorHandled: boolean;
@@ -13,7 +14,7 @@ interface BlockStackEntry {
     isErrorHandled: boolean;
 }
 
-export function createLoggerCallTracker(report: (node: Rule.Node) => void) {
+export function createLoggerCallTracker(settings: Settings, report: (node: Rule.Node) => void) {
     const scopesStack: ScopeStackEntry[] = [];
     const blocksStack: BlockStackEntry[] = [];
 

src/utils/settings.ts

@@ -0,0 +1,42 @@
+export interface Settings {
+    readonly loggerFunctions: readonly string[];
+}
+
+const defaultLoggerFunctions = ['console.warn', 'console.error'] as const;
+
+const defaultSettings: Settings = {
+    loggerFunctions: defaultLoggerFunctions,
+};
+
+export function parseSettings(settings: unknown): Settings {
+    if (!isObject(settings)) return defaultSettings;
+    if (!isObject(settings.handleErrors)) return defaultSettings;
+
+    return parsePluginSettings(settings.handleErrors);
+}
+
+function parsePluginSettings(settings: Record<PropertyKey, unknown>): Settings {
+    const { loggerFunctions = defaultLoggerFunctions } = settings;
+
+    if (!isArrayOfString(loggerFunctions)) {
+        throw new Error(
+            `Invalid configuration value for settings.handleErrors.loggerFunctions. The value must be array of strings. Got: ${loggerFunctions}`
+        );
+    }
+
+    return {
+        loggerFunctions,
+    };
+}
+
+function isObject(settings: unknown): settings is Record<PropertyKey, unknown> {
+    return settings !== null && typeof settings === 'object';
+}
+
+function isString(value: unknown): value is string {
+    return typeof value === 'string';
+}
+
+function isArrayOfString(value: unknown): value is string[] {
+    return Array.isArray(value) && value.every(isString);
+}