@webpieces/dev-config 0.2.17 → 0.2.21

package/eslint-plugin/__tests__/no-unmanaged-exceptions.test.ts

@@ -0,0 +1,359 @@
+/**
+ * Tests for no-unmanaged-exceptions ESLint rule
+ *
+ * Validates that try-catch blocks are:
+ * - Auto-allowed in test files (.test.ts, .spec.ts, __tests__/)
+ * - Allowed with eslint-disable comment
+ * - Disallowed in production code without approval
+ */
+
+import { RuleTester } from 'eslint';
+import rule from '../rules/no-unmanaged-exceptions';
+
+const tsParser = require('@typescript-eslint/parser');
+
+const ruleTester = new RuleTester({
+    languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+            ecmaVersion: 2020,
+            sourceType: 'module',
+        },
+    },
+});
+
+ruleTester.run('no-unmanaged-exceptions', rule, {
+    valid: [
+        // ============================================
+        // Test files - auto-allowed
+        // ============================================
+        {
+            code: `
+                try {
+                    await operation();
+                } catch (err: any) {
+                    const error = toError(err);
+                    expect(error).toBeDefined();
+                }
+            `,
+            filename: 'SaveController.test.ts',
+        },
+        {
+            code: `
+                try {
+                    await controller.save(request);
+                    fail('Should have thrown');
+                } catch (err: any) {
+                    const error = toError(err);
+                    expect(error.message).toContain('Invalid');
+                }
+            `,
+            filename: 'packages/http/http-server/src/SaveController.test.ts',
+        },
+
+        // Spec files - auto-allowed
+        {
+            code: `
+                try {
+                    await operation();
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: 'userService.spec.ts',
+        },
+        {
+            code: `
+                it('should throw error', async () => {
+                    try {
+                        await service.process();
+                        fail();
+                    } catch (err: any) {
+                        const error = toError(err);
+                        expect(error).toBeDefined();
+                    }
+                });
+            `,
+            filename: 'packages/services/user/userService.spec.ts',
+        },
+
+        // __tests__ directory - auto-allowed (need full path)
+        {
+            code: `
+                try {
+                    await operation();
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: '/project/__tests__/integration.ts',
+        },
+        {
+            code: `
+                try {
+                    await runIntegrationTest();
+                } catch (err: any) {
+                    const error = toError(err);
+                    console.error(error);
+                }
+            `,
+            filename: '/project/packages/http/__tests__/server-integration.ts',
+        },
+        {
+            code: `
+                try {
+                    const result = performAction();
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: '/project/src/__tests__/helpers/testUtils.ts',
+        },
+
+        // ============================================
+        // Code without try-catch (preferred pattern)
+        // ============================================
+        {
+            code: `
+                async function processOrder(order: Order): Promise<void> {
+                    await validateOrder(order);
+                    await saveToDatabase(order);
+                }
+            `,
+            filename: 'OrderService.ts',
+        },
+        {
+            code: `
+                export class SaveController {
+                    async save(request: SaveRequest): Promise<SaveResponse> {
+                        const result = await this.service.save(request);
+                        return result;
+                    }
+                }
+            `,
+            filename: 'packages/http/http-server/src/SaveController.ts',
+        },
+
+        // ============================================
+        // Nested functions without try-catch
+        // ============================================
+        {
+            code: `
+                function outer() {
+                    function inner() {
+                        return doSomething();
+                    }
+                    return inner();
+                }
+            `,
+            filename: 'Utils.ts',
+        },
+    ],
+
+    invalid: [
+        // ============================================
+        // Controllers without approval
+        // ============================================
+        {
+            code: `
+                try {
+                    await operation();
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: 'SaveController.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+        {
+            code: `
+                export class SaveController {
+                    async save(request: SaveRequest): Promise<SaveResponse> {
+                        try {
+                            const result = await this.service.save(request);
+                            return result;
+                        } catch (err: any) {
+                            const error = toError(err);
+                            throw error;
+                        }
+                    }
+                }
+            `,
+            filename: 'packages/http/http-server/src/SaveController.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+
+        // ============================================
+        // Services without approval
+        // ============================================
+        {
+            code: `
+                try {
+                    await this.database.query(sql);
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: 'UserService.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+        {
+            code: `
+                export class UserService {
+                    async getUserById(id: string): Promise<User> {
+                        try {
+                            const user = await this.db.findOne({ id });
+                            return user;
+                        } catch (err: any) {
+                            const error = toError(err);
+                            console.error('Failed to fetch user:', error);
+                            return null;
+                        }
+                    }
+                }
+            `,
+            filename: 'packages/services/user/UserService.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+
+        // ============================================
+        // Filters without approval
+        // ============================================
+        {
+            code: `
+                try {
+                    return JSON.parse(body);
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: 'JsonFilter.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+        {
+            code: `
+                export class LogFilter implements Filter {
+                    async filter(meta: MethodMeta, next: NextFilter): Promise<Action> {
+                        try {
+                            return await next.execute();
+                        } catch (err: any) {
+                            const error = toError(err);
+                            console.error('Filter error:', error);
+                            throw error;
+                        }
+                    }
+                }
+            `,
+            filename: 'packages/http/http-server/src/filters/LogFilter.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+
+        // ============================================
+        // Utility functions without approval
+        // ============================================
+        {
+            code: `
+                async function fetchData(url: string): Promise<Data> {
+                    try {
+                        const response = await fetch(url);
+                        return await response.json();
+                    } catch (err: any) {
+                        const error = toError(err);
+                        throw new Error(\`Fetch failed: \${error.message}\`);
+                    }
+                }
+            `,
+            filename: 'packages/core/core-util/src/httpUtils.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+
+        // ============================================
+        // Multiple try-catch blocks in one file
+        // ============================================
+        {
+            code: `
+                async function operation1() {
+                    try {
+                        await doSomething();
+                    } catch (err: any) {
+                        const error = toError(err);
+                    }
+                }
+
+                async function operation2() {
+                    try {
+                        await doSomethingElse();
+                    } catch (err: any) {
+                        const error = toError(err);
+                    }
+                }
+            `,
+            filename: 'MultipleOperations.ts',
+            errors: [
+                { messageId: 'noUnmanagedExceptions' },
+                { messageId: 'noUnmanagedExceptions' },
+            ],
+        },
+
+        // ============================================
+        // Nested try-catch blocks
+        // ============================================
+        {
+            code: `
+                try {
+                    try {
+                        await operation();
+                    } catch (err2: any) {
+                        const error2 = toError(err2);
+                    }
+                } catch (err: any) {
+                    const error = toError(err);
+                }
+            `,
+            filename: 'NestedOperations.ts',
+            errors: [
+                { messageId: 'noUnmanagedExceptions' },
+                { messageId: 'noUnmanagedExceptions' },
+            ],
+        },
+
+        // ============================================
+        // Try-catch in arrow functions
+        // ============================================
+        {
+            code: `
+                const handler = async () => {
+                    try {
+                        await doSomething();
+                    } catch (err: any) {
+                        const error = toError(err);
+                    }
+                };
+            `,
+            filename: 'Handlers.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+
+        // ============================================
+        // Try-catch in class methods
+        // ============================================
+        {
+            code: `
+                export class DataProcessor {
+                    process(data: Data): Result {
+                        try {
+                            return this.performProcessing(data);
+                        } catch (err: any) {
+                            const error = toError(err);
+                            return null;
+                        }
+                    }
+                }
+            `,
+            filename: 'packages/processors/DataProcessor.ts',
+            errors: [{ messageId: 'noUnmanagedExceptions' }],
+        },
+    ],
+});
+
+console.log('All no-unmanaged-exceptions tests passed!');

package/eslint-plugin/index.d.ts

@@ -3,10 +3,21 @@
  * Provides rules for enforcing WebPieces code patterns
  *
  * This plugin is automatically included in @webpieces/dev-config
+ *
+ * Available rules:
+ * - catch-error-pattern: Enforce toError() usage in catch blocks (HOW to handle)
+ * - no-unmanaged-exceptions: Discourage try-catch outside tests (WHERE to handle)
+ * - max-method-lines: Enforce maximum method length (default: 70 lines)
+ * - max-file-lines: Enforce maximum file length (default: 700 lines)
+ * - enforce-architecture: Enforce architecture dependency boundaries
  */
 declare const _default: {
     rules: {
         'catch-error-pattern': import("eslint").Rule.RuleModule;
+        'no-unmanaged-exceptions': import("eslint").Rule.RuleModule;
+        'max-method-lines': import("eslint").Rule.RuleModule;
+        'max-file-lines': import("eslint").Rule.RuleModule;
+        'enforce-architecture': import("eslint").Rule.RuleModule;
     };
 };
 export = _default;

package/eslint-plugin/index.js

@@ -4,12 +4,27 @@
  * Provides rules for enforcing WebPieces code patterns
  *
  * This plugin is automatically included in @webpieces/dev-config
+ *
+ * Available rules:
+ * - catch-error-pattern: Enforce toError() usage in catch blocks (HOW to handle)
+ * - no-unmanaged-exceptions: Discourage try-catch outside tests (WHERE to handle)
+ * - max-method-lines: Enforce maximum method length (default: 70 lines)
+ * - max-file-lines: Enforce maximum file length (default: 700 lines)
+ * - enforce-architecture: Enforce architecture dependency boundaries
  */
 const tslib_1 = require("tslib");
 const catch_error_pattern_1 = tslib_1.__importDefault(require("./rules/catch-error-pattern"));
+const no_unmanaged_exceptions_1 = tslib_1.__importDefault(require("./rules/no-unmanaged-exceptions"));
+const max_method_lines_1 = tslib_1.__importDefault(require("./rules/max-method-lines"));
+const max_file_lines_1 = tslib_1.__importDefault(require("./rules/max-file-lines"));
+const enforce_architecture_1 = tslib_1.__importDefault(require("./rules/enforce-architecture"));
 module.exports = {
     rules: {
         'catch-error-pattern': catch_error_pattern_1.default,
+        'no-unmanaged-exceptions': no_unmanaged_exceptions_1.default,
+        'max-method-lines': max_method_lines_1.default,
+        'max-file-lines': max_file_lines_1.default,
+        'enforce-architecture': enforce_architecture_1.default,
     },
 };
 //# sourceMappingURL=index.js.map

package/eslint-plugin/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/tooling/dev-config/eslint-plugin/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAEH,8FAA4D;AAE5D,iBAAS;IACL,KAAK,EAAE;QACH,qBAAqB,EAAE,6BAAiB;KAC3C;CACJ,CAAC","sourcesContent":["/**\n * ESLint plugin for WebPieces\n * Provides rules for enforcing WebPieces code patterns\n *\n * This plugin is automatically included in @webpieces/dev-config\n */\n\nimport catchErrorPattern from './rules/catch-error-pattern';\n\nexport = {\n    rules: {\n        'catch-error-pattern': catchErrorPattern,\n    },\n};\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/tooling/dev-config/eslint-plugin/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AAEH,8FAA4D;AAC5D,sGAAoE;AACpE,wFAAsD;AACtD,oFAAkD;AAClD,gGAA+D;AAE/D,iBAAS;IACL,KAAK,EAAE;QACH,qBAAqB,EAAE,6BAAiB;QACxC,yBAAyB,EAAE,iCAAqB;QAChD,kBAAkB,EAAE,0BAAc;QAClC,gBAAgB,EAAE,wBAAY;QAC9B,sBAAsB,EAAE,8BAAmB;KAC9C;CACJ,CAAC","sourcesContent":["/**\n * ESLint plugin for WebPieces\n * Provides rules for enforcing WebPieces code patterns\n *\n * This plugin is automatically included in @webpieces/dev-config\n *\n * Available rules:\n * - catch-error-pattern: Enforce toError() usage in catch blocks (HOW to handle)\n * - no-unmanaged-exceptions: Discourage try-catch outside tests (WHERE to handle)\n * - max-method-lines: Enforce maximum method length (default: 70 lines)\n * - max-file-lines: Enforce maximum file length (default: 700 lines)\n * - enforce-architecture: Enforce architecture dependency boundaries\n */\n\nimport catchErrorPattern from './rules/catch-error-pattern';\nimport noUnmanagedExceptions from './rules/no-unmanaged-exceptions';\nimport maxMethodLines from './rules/max-method-lines';\nimport maxFileLines from './rules/max-file-lines';\nimport enforceArchitecture from './rules/enforce-architecture';\n\nexport = {\n    rules: {\n        'catch-error-pattern': catchErrorPattern,\n        'no-unmanaged-exceptions': noUnmanagedExceptions,\n        'max-method-lines': maxMethodLines,\n        'max-file-lines': maxFileLines,\n        'enforce-architecture': enforceArchitecture,\n    },\n};\n"]}

package/eslint-plugin/index.ts

@@ -3,12 +3,27 @@
  * Provides rules for enforcing WebPieces code patterns
  *
  * This plugin is automatically included in @webpieces/dev-config
+ *
+ * Available rules:
+ * - catch-error-pattern: Enforce toError() usage in catch blocks (HOW to handle)
+ * - no-unmanaged-exceptions: Discourage try-catch outside tests (WHERE to handle)
+ * - max-method-lines: Enforce maximum method length (default: 70 lines)
+ * - max-file-lines: Enforce maximum file length (default: 700 lines)
+ * - enforce-architecture: Enforce architecture dependency boundaries
  */
 
 import catchErrorPattern from './rules/catch-error-pattern';
+import noUnmanagedExceptions from './rules/no-unmanaged-exceptions';
+import maxMethodLines from './rules/max-method-lines';
+import maxFileLines from './rules/max-file-lines';
+import enforceArchitecture from './rules/enforce-architecture';
 
 export = {
     rules: {
         'catch-error-pattern': catchErrorPattern,
+        'no-unmanaged-exceptions': noUnmanagedExceptions,
+        'max-method-lines': maxMethodLines,
+        'max-file-lines': maxFileLines,
+        'enforce-architecture': enforceArchitecture,
     },
 };

package/eslint-plugin/rules/enforce-architecture.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ESLint rule to enforce architecture boundaries
+ *
+ * Validates that imports from @webpieces/* packages comply with the
+ * blessed dependency graph in .graphs/dependencies.json
+ *
+ * Supports transitive dependencies: if A depends on B and B depends on C,
+ * then A can import from C.
+ *
+ * Configuration:
+ * '@webpieces/enforce-architecture': 'error'
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export = rule;