@webpieces/eslint-rules 0.0.1 → 0.2.114

package/src/__tests__/max-method-lines.test.ts

@@ -1,258 +0,0 @@
-/**
- * Tests for max-method-lines ESLint rule
- */
-
-import { RuleTester } from 'eslint';
-import rule from '../rules/max-method-lines';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Use require to load parser at runtime (avoids TypeScript import issues)
-const tsParser = require('@typescript-eslint/parser');
-
-const ruleTester = new RuleTester({
-    languageOptions: {
-        parser: tsParser,
-        parserOptions: {
-            ecmaVersion: 2020,
-            sourceType: 'module',
-        },
-    },
-});
-
-ruleTester.run('max-method-lines', rule, {
-    valid: [
-        // Short function (well under limit)
-        {
-            code: `function shortFunc() {
-    return 42;
-}`,
-        },
-        // Function with exactly 70 lines (default limit)
-        {
-            code: `function exactlySeventyLines() {
-${Array(68)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-}`,
-        },
-        // Function with 69 lines (just under default limit)
-        {
-            code: `function sixtyNineLines() {
-${Array(67)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-}`,
-        },
-        // Custom limit: 10 lines
-        {
-            code: `function shortFunc() {
-    const a = 1;
-    const b = 2;
-    const c = 3;
-    const d = 4;
-    const e = 5;
-    const f = 6;
-    const g = 7;
-    return a + b + c + d + e + f + g;
-}`,
-            options: [{ max: 10 }],
-        },
-        // Arrow function under limit
-        {
-            code: `const shortArrow = () => {
-    return 42;
-};`,
-        },
-        // Method definition under limit
-        {
-            code: `class MyClass {
-    shortMethod() {
-        return 42;
-    }
-}`,
-        },
-        // Function expression under limit
-        {
-            code: `const func = function() {
-    return 42;
-};`,
-        },
-    ],
-
-    invalid: [
-        // Function with 71 lines (exceeds default limit)
-        {
-            code: `function tooLong() {
-${Array(69)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-}`,
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'tooLong', actual: '71', max: '70' },
-                },
-            ],
-        },
-        // Function with 100 lines (way over limit)
-        {
-            code: `function wayTooLong() {
-${Array(98)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-}`,
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'wayTooLong', actual: '100', max: '70' },
-                },
-            ],
-        },
-        // Custom limit: exceed 5 lines
-        {
-            code: `function tooLongForCustom() {
-    const a = 1;
-    const b = 2;
-    const c = 3;
-    const d = 4;
-    return a + b + c + d;
-}`,
-            options: [{ max: 5 }],
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'tooLongForCustom', actual: '7', max: '5' },
-                },
-            ],
-        },
-        // Arrow function exceeding limit
-        {
-            code: `const tooLongArrow = () => {
-${Array(69)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-};`,
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'anonymous', actual: '71', max: '70' },
-                },
-            ],
-        },
-        // Method definition exceeding limit
-        {
-            code: `class MyClass {
-    tooLongMethod() {
-${Array(69)
-    .fill(0)
-    .map((_, i) => `        const line${i} = ${i};`)
-    .join('\n')}
-    }
-}`,
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'tooLongMethod', actual: '71', max: '70' },
-                },
-            ],
-        },
-        // Function expression exceeding limit
-        {
-            code: `const func = function tooLongFunc() {
-${Array(69)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-};`,
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'tooLongFunc', actual: '71', max: '70' },
-                },
-            ],
-        },
-        // Multiple functions, one exceeds limit
-        {
-            code: `function shortFunc() {
-    return 42;
-}
-
-function tooLong() {
-${Array(69)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-}
-
-function anotherShort() {
-    return 24;
-}`,
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { name: 'tooLong', actual: '71', max: '70' },
-                },
-            ],
-        },
-    ],
-});
-
-console.log('All max-method-lines rule tests passed!');
-
-// Test documentation file creation
-const docPath = path.join(process.cwd(), 'tmp', 'webpieces', 'webpieces.methods.md');
-
-// Ensure tmp directory exists before test
-fs.mkdirSync(path.dirname(docPath), { recursive: true });
-
-// Delete file if it exists (to test creation)
-if (fs.existsSync(docPath)) {
-    fs.unlinkSync(docPath);
-}
-
-// Run a test that triggers violation (will create doc file)
-try {
-    ruleTester.run('max-method-lines-doc-test', rule, {
-        valid: [],
-        invalid: [
-            {
-                code: `function veryLongMethod() {
-${Array(100)
-    .fill(0)
-    .map((_, i) => `    const line${i} = ${i};`)
-    .join('\n')}
-}`,
-                errors: [{ messageId: 'tooLong' }],
-            },
-        ],
-    });
-    console.log('Doc test passed without errors');
-} catch (err: unknown) {
-    // Test may fail due to too many errors, but file should be created
-    console.log('Doc test threw error (expected):', err instanceof Error ? err.message : String(err));
-}
-
-// Verify file was created - if not, manually create it for the test
-// (The rule should have created it, but Jest test runner might not trigger it properly)
-if (!fs.existsSync(docPath)) {
-    console.warn('Warning: Rule did not create doc file during test, creating manually for verification');
-    // For now, just skip this part of the test since the main rule tests passed
-    console.log('Documentation file creation test skipped (rule functionality verified in main tests)');
-} else {
-    // Verify content has AI directive
-    const content = fs.readFileSync(docPath, 'utf-8');
-    if (!content.includes('READ THIS FILE to fix methods that are too long')) {
-        throw new Error('Documentation file missing AI directive');
-    }
-    if (!content.includes('TABLE OF CONTENTS')) {
-        throw new Error('Documentation file missing table of contents principle');
-    }
-
-    console.log('Documentation file creation test passed!');
-}

package/src/__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: unknown) {
-                    const error = toError(err);
-                    expect(error).toBeDefined();
-                }
-            `,
-            filename: 'SaveController.test.ts',
-        },
-        {
-            code: `
-                try {
-                    await controller.save(request);
-                    fail('Should have thrown');
-                } catch (err: unknown) {
-                    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: unknown) {
-                    const error = toError(err);
-                }
-            `,
-            filename: 'userService.spec.ts',
-        },
-        {
-            code: `
-                it('should throw error', async () => {
-                    try {
-                        await service.process();
-                        fail();
-                    } catch (err: unknown) {
-                        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: unknown) {
-                    const error = toError(err);
-                }
-            `,
-            filename: '/project/__tests__/integration.ts',
-        },
-        {
-            code: `
-                try {
-                    await runIntegrationTest();
-                } catch (err: unknown) {
-                    const error = toError(err);
-                    console.error(error);
-                }
-            `,
-            filename: '/project/packages/http/__tests__/server-integration.ts',
-        },
-        {
-            code: `
-                try {
-                    const result = performAction();
-                } catch (err: unknown) {
-                    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: unknown) {
-                    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: unknown) {
-                            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: unknown) {
-                    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: unknown) {
-                            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: unknown) {
-                    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: unknown) {
-                            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: unknown) {
-                        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: unknown) {
-                        const error = toError(err);
-                    }
-                }
-
-                async function operation2() {
-                    try {
-                        await doSomethingElse();
-                    } catch (err: unknown) {
-                        const error = toError(err);
-                    }
-                }
-            `,
-            filename: 'MultipleOperations.ts',
-            errors: [
-                { messageId: 'noUnmanagedExceptions' },
-                { messageId: 'noUnmanagedExceptions' },
-            ],
-        },
-
-        // ============================================
-        // Nested try-catch blocks
-        // ============================================
-        {
-            code: `
-                try {
-                    try {
-                        await operation();
-                    } catch (err2: unknown) {
-                        const error2 = toError(err2);
-                    }
-                } catch (err: unknown) {
-                    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: unknown) {
-                        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: unknown) {
-                            const error = toError(err);
-                            return null;
-                        }
-                    }
-                }
-            `,
-            filename: 'packages/processors/DataProcessor.ts',
-            errors: [{ messageId: 'noUnmanagedExceptions' }],
-        },
-    ],
-});
-
-console.log('All no-unmanaged-exceptions tests passed!');

package/src/index.ts

@@ -1,38 +0,0 @@
-/**
- * ESLint plugin for WebPieces
- * Provides rules for enforcing WebPieces code patterns
- *
- * This plugin is automatically included in @webpieces/webpieces-rules
- *
- * 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
- * - no-json-property-primitive-type: Ban @JsonProperty({ type: String/Number/Boolean })
- * - require-typed-template: Require [templateClassType] on ng-template with let- variables (Angular)
- * - no-mat-cell-def: Ban *matCellDef/*matHeaderCellDef — use div-grid tables (Angular)
- */
-
-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';
-import noJsonPropertyPrimitiveType from './rules/no-json-property-primitive-type';
-import requireTypedTemplate from './rules/require-typed-template';
-import noMatCellDef from './rules/no-mat-cell-def';
-
-export = {
-    rules: {
-        'catch-error-pattern': catchErrorPattern,
-        'no-unmanaged-exceptions': noUnmanagedExceptions,
-        'max-method-lines': maxMethodLines,
-        'max-file-lines': maxFileLines,
-        'enforce-architecture': enforceArchitecture,
-        'no-json-property-primitive-type': noJsonPropertyPrimitiveType,
-        'require-typed-template': requireTypedTemplate,
-        'no-mat-cell-def': noMatCellDef,
-    },
-};