feat: implement strong-typed-routes ESLint rule

[M-jerez]

Summary

Implements a new ESLint rule strong-typed-routes that enforces explicit parameter and return type annotations for router handler functions.

Rule Purpose

Enforce that handler functions passed to specific router functions have explicitly defined parameter types (except the first parameter) and return types.

Target Functions

The rule checks calls to these functions from @mionkit/router:

• route
• hook
• headersHook
• Ignores rawHook (not type-checked)

Rule Requirements

1. Handler functions must have explicit return type annotations
2. All parameters except the first must have explicit type annotations
3. The first parameter is always CallContext and is ignored by this rule
4. Both arrow functions and regular function expressions are supported

Valid Examples

import {route, hook, headersHook} from '@mionkit/router';

route((ctx, name: string): string => `hello ${name}`); // ✅ Valid
hook((ctx, data: number): void => { console.log(data); }); // ✅ Valid
headersHook(['auth'], (ctx, headers: Headers): boolean => true); // ✅ Valid

Invalid Examples

route((ctx, name) => `hello ${name}`); // ❌ Missing param type and return type
route((ctx, name: string) => `hello ${name}`); // ❌ Missing return type
route((ctx, name): string => `hello ${name}`); // ❌ Missing param type

Implementation Details

• Performance: Implemented as a single rule rather than splitting into separate param/return rules
• Import handling: Works with both direct function calls and when functions are imported/aliased
• Parameter focus: Focuses on the handler parameter specifically (first parameter for route/hook, second for headersHook)
• Comprehensive testing: 36 test cases covering various scenarios

Breaking Change Prevention

The rule is added to the recommended config but initially disabled in .eslintrc.js to avoid breaking the existing codebase:

rules: {
  // Disable the new strong-typed-routes rule initially to avoid breaking existing codebase
  '@mionkit/strong-typed-routes': 'off',
}

To enable the rule later, simply remove this line from the root ESLint configuration.

Files Changed

• packages/eslint-plugin/src/rules/strong-typed-routes.ts - Main rule implementation
• packages/eslint-plugin/src/rules/strong-typed-routes.spec.ts - Comprehensive test suite
• packages/eslint-plugin/src/index.ts - Export rule and add to recommended config
• .eslintrc.js - Disable rule initially to prevent breaking changes

Testing

✅ All tests pass (36 test cases)
✅ Build successful
✅ Linting passes
✅ Code formatted

Next Steps

Once this PR is merged, teams can gradually enable the rule by:

1. Removing '@mionkit/strong-typed-routes': 'off' from .eslintrc.js
2. Fixing any violations in the codebase
3. Enjoying better type safety in router handlers!

---

Pull Request opened by Augment Code with guidance from the PR author