@webpieces/dev-config 0.2.94 → 0.2.97

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

@@ -1,359 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-/**
- * ESLint plugin for WebPieces
- * 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

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * ESLint plugin for WebPieces
- * 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 +0,0 @@
-{"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

@@ -1,29 +0,0 @@
-/**
- * ESLint plugin for WebPieces
- * 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/catch-error-pattern.d.ts

@@ -1,11 +0,0 @@
-/**
- * ESLint rule to enforce standardized catch block error handling patterns
- *
- * Enforces three approved patterns:
- * 1. Standard: catch (err: any) { const error = toError(err); }
- * 2. Ignored: catch (err: any) { //const error = toError(err); }
- * 3. Nested: catch (err2: any) { const error2 = toError(err2); }
- */
-import type { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export = rule;

package/eslint-plugin/rules/catch-error-pattern.js

@@ -1,196 +0,0 @@
-"use strict";
-/**
- * ESLint rule to enforce standardized catch block error handling patterns
- *
- * Enforces three approved patterns:
- * 1. Standard: catch (err: any) { const error = toError(err); }
- * 2. Ignored: catch (err: any) { //const error = toError(err); }
- * 3. Nested: catch (err2: any) { const error2 = toError(err2); }
- */
-const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce standardized catch block error handling patterns',
-            category: 'Best Practices',
-            recommended: true,
-            url: 'https://github.com/deanhiller/webpieces-ts/blob/main/claude.patterns.md#error-handling-pattern',
-        },
-        messages: {
-            missingToError: 'Catch block must call toError({{param}}) as first statement or comment it out to explicitly ignore errors',
-            wrongVariableName: 'Error variable must be named "{{expected}}", got "{{actual}}"',
-            missingTypeAnnotation: 'Catch parameter must be typed as "any": catch ({{param}}: any)',
-            wrongParameterName: 'Catch parameter must be named "err" (or "err2", "err3" for nested catches), got "{{actual}}"',
-            toErrorNotFirst: 'toError({{param}}) must be the first statement in the catch block',
-        },
-        fixable: undefined,
-        schema: [],
-    },
-    create(context) {
-        // Track nesting depth for err, err2, err3, etc.
-        const catchStack = [];
-        return {
-            CatchClause(node) {
-                const catchNode = node;
-                // Calculate depth (1-based: first catch is depth 1)
-                const depth = catchStack.length + 1;
-                catchStack.push(catchNode);
-                // Build expected names based on depth
-                const suffix = depth === 1 ? '' : String(depth);
-                const expectedParamName = 'err' + suffix;
-                const expectedVarName = 'error' + suffix;
-                // Get the catch parameter
-                const param = catchNode.param;
-                if (!param) {
-                    // No parameter - unusual but technically valid (though not our pattern)
-                    context.report({
-                        node: catchNode,
-                        messageId: 'missingTypeAnnotation',
-                        data: { param: expectedParamName },
-                    });
-                    return;
-                }
-                // Track the actual parameter name for validation (may differ from expected)
-                const actualParamName = param.type === 'Identifier' ? param.name : expectedParamName;
-                // RULE 1: Parameter must be named correctly (err, err2, err3, etc.)
-                if (param.type === 'Identifier' && param.name !== expectedParamName) {
-                    context.report({
-                        node: param,
-                        messageId: 'wrongParameterName',
-                        data: {
-                            actual: param.name,
-                        },
-                    });
-                }
-                // RULE 2: Must have type annotation ": any"
-                if (!param.typeAnnotation ||
-                    !param.typeAnnotation.typeAnnotation ||
-                    param.typeAnnotation.typeAnnotation.type !== 'TSAnyKeyword') {
-                    context.report({
-                        node: param,
-                        messageId: 'missingTypeAnnotation',
-                        data: {
-                            param: param.name || expectedParamName,
-                        },
-                    });
-                }
-                // RULE 3: Check first statement in catch block
-                const body = catchNode.body.body;
-                const sourceCode = context.sourceCode || context.getSourceCode();
-                // IMPORTANT: Check for commented ignore pattern FIRST (before checking if body is empty)
-                // This allows Pattern 2 (empty catch with only comment) to be valid
-                // Look for: //const error = toError(err);
-                const catchBlockStart = catchNode.body.range[0];
-                const catchBlockEnd = catchNode.body.range[1];
-                const catchBlockText = sourceCode.text.substring(catchBlockStart, catchBlockEnd);
-                const ignorePattern = new RegExp(`//\\s*const\\s+${expectedVarName}\\s*=\\s*toError\\(${actualParamName}\\)`);
-                if (ignorePattern.test(catchBlockText)) {
-                    // Pattern 2: Explicitly ignored - valid!
-                    return;
-                }
-                // Now check if body is empty (after checking for commented pattern)
-                if (body.length === 0) {
-                    // Empty catch block without comment - not allowed
-                    context.report({
-                        node: catchNode.body,
-                        messageId: 'missingToError',
-                        data: {
-                            param: expectedParamName,
-                        },
-                    });
-                    return;
-                }
-                const firstStatement = body[0];
-                // Check if first statement is: const error = toError(err)
-                if (firstStatement.type !== 'VariableDeclaration') {
-                    context.report({
-                        node: firstStatement,
-                        messageId: 'missingToError',
-                        data: {
-                            param: expectedParamName,
-                        },
-                    });
-                    return;
-                }
-                const varDecl = firstStatement;
-                const declaration = varDecl.declarations[0];
-                if (!declaration) {
-                    context.report({
-                        node: firstStatement,
-                        messageId: 'missingToError',
-                        data: {
-                            param: expectedParamName,
-                        },
-                    });
-                    return;
-                }
-                // Check variable name
-                if (declaration.id.type !== 'Identifier' ||
-                    declaration.id.name !== expectedVarName) {
-                    context.report({
-                        node: declaration.id,
-                        messageId: 'wrongVariableName',
-                        data: {
-                            expected: expectedVarName,
-                            actual: declaration.id.name || 'unknown',
-                        },
-                    });
-                    return;
-                }
-                // Check initialization: toError(err)
-                if (!declaration.init) {
-                    context.report({
-                        node: declaration,
-                        messageId: 'missingToError',
-                        data: {
-                            param: expectedParamName,
-                        },
-                    });
-                    return;
-                }
-                if (declaration.init.type !== 'CallExpression') {
-                    context.report({
-                        node: declaration.init,
-                        messageId: 'missingToError',
-                        data: {
-                            param: expectedParamName,
-                        },
-                    });
-                    return;
-                }
-                const callExpr = declaration.init;
-                const callee = callExpr.callee;
-                if (callee.type !== 'Identifier' || callee.name !== 'toError') {
-                    context.report({
-                        node: callee,
-                        messageId: 'missingToError',
-                        data: {
-                            param: expectedParamName,
-                        },
-                    });
-                    return;
-                }
-                // Check argument: must be the catch parameter (use actual param name)
-                const args = callExpr.arguments;
-                if (args.length !== 1 ||
-                    args[0].type !== 'Identifier' ||
-                    args[0].name !== actualParamName) {
-                    context.report({
-                        node: callExpr,
-                        messageId: 'missingToError',
-                        data: {
-                            param: actualParamName,
-                        },
-                    });
-                    return;
-                }
-                // All checks passed! ✅
-            },
-            'CatchClause:exit'() {
-                catchStack.pop();
-            },
-        };
-    },
-};
-module.exports = rule;
-//# sourceMappingURL=catch-error-pattern.js.map