@morojs/moro 1.6.2 → 1.6.4

package/src/core/routing/app-integration.ts

@@ -1,164 +0,0 @@
-// Integration layer for intelligent routing system with main Moro app
-// Provides both chainable and schema-first APIs
-//
-// NOTE: This is now a thin facade to UnifiedRouter
-// All routing logic has been consolidated in unified-router.ts
-
-import {
-  RouteBuilder,
-  RouteSchema,
-  CompiledRoute,
-  createRoute,
-  defineRoute,
-  HttpMethod,
-} from './index.js';
-import { HttpRequest, HttpResponse } from '../http/index.js';
-import { UnifiedRouter } from './unified-router.js';
-import { createFrameworkLogger } from '../logger/index.js';
-
-const logger = createFrameworkLogger('AppIntegration');
-
-// ===== RouteRegistry (Public API - Backward Compatibility) =====
-
-/**
- * RouteRegistry - Facade to UnifiedRouter for backward compatibility
- * This was part of the public API, so we maintain it as an alias
- */
-export class RouteRegistry {
-  private router = UnifiedRouter.getInstance();
-
-  register(route: CompiledRoute): void {
-    // Routes are automatically registered with UnifiedRouter when created
-    // This is a no-op for API compatibility
-  }
-
-  async handleRequest(req: HttpRequest, res: HttpResponse): Promise<boolean> {
-    return this.router.handleRequest(req, res) as Promise<boolean>;
-  }
-
-  getRoutes(): CompiledRoute[] {
-    const routes = this.router.getAllRoutes();
-    return routes.map(routeSchema => ({
-      schema: routeSchema as RouteSchema,
-      execute: async (_req: HttpRequest, _res: HttpResponse) => {
-        throw new Error('CompiledRoute.execute() not used - routing handled by UnifiedRouter');
-      },
-    }));
-  }
-}
-
-// Extended app interface with intelligent routing
-export interface IntelligentApp {
-  get(path: string): RouteBuilder;
-  post(path: string): RouteBuilder;
-  put(path: string): RouteBuilder;
-  delete(path: string): RouteBuilder;
-  patch(path: string): RouteBuilder;
-  head(path: string): RouteBuilder;
-  options(path: string): RouteBuilder;
-  route(schema: RouteSchema): CompiledRoute;
-  register(route: CompiledRoute): void;
-  directRoute(method: string, path: string, handler: Function, options?: any): void;
-}
-
-// Intelligent routing manager class
-// Now a thin facade to UnifiedRouter
-export class IntelligentRoutingManager implements IntelligentApp {
-  private router = UnifiedRouter.getInstance();
-
-  // Chainable route methods - delegate to createRoute
-  get(path: string): RouteBuilder {
-    return this.createChainableRoute('GET', path);
-  }
-
-  post(path: string): RouteBuilder {
-    return this.createChainableRoute('POST', path);
-  }
-
-  put(path: string): RouteBuilder {
-    return this.createChainableRoute('PUT', path);
-  }
-
-  delete(path: string): RouteBuilder {
-    return this.createChainableRoute('DELETE', path);
-  }
-
-  patch(path: string): RouteBuilder {
-    return this.createChainableRoute('PATCH', path);
-  }
-
-  head(path: string): RouteBuilder {
-    return this.createChainableRoute('HEAD', path);
-  }
-
-  options(path: string): RouteBuilder {
-    return this.createChainableRoute('OPTIONS', path);
-  }
-
-  // Schema-first route method
-  route(schema: RouteSchema): CompiledRoute {
-    const compiledRoute = defineRoute(schema);
-    this.register(compiledRoute);
-    return compiledRoute;
-  }
-
-  // Register compiled route (no-op, already registered by defineRoute)
-  register(_route: CompiledRoute): void {
-    // Routes are automatically registered with UnifiedRouter in defineRoute()
-    // This is just for API compatibility
-  }
-
-  // Handle incoming requests - delegates to UnifiedRouter
-  async handleIntelligentRoute(req: HttpRequest, res: HttpResponse): Promise<boolean> {
-    return this.router.handleRequest(req, res) as Promise<boolean>;
-  }
-
-  // Get all registered routes - fetch from UnifiedRouter
-  getIntelligentRoutes(): CompiledRoute[] {
-    // Convert UnifiedRouter's internal routes to CompiledRoute format for docs
-    const routes = this.router.getAllRoutes();
-    return routes.map(routeSchema => ({
-      schema: routeSchema as RouteSchema, // Cast to match CompiledRoute interface
-      execute: async (_req: HttpRequest, _res: HttpResponse) => {
-        // Not used - routing handled by UnifiedRouter
-        throw new Error('CompiledRoute.execute() not used - routing handled by UnifiedRouter');
-      },
-    }));
-  }
-
-  // Direct route method (deprecated but kept for compatibility)
-  directRoute(method: string, path: string, handler: Function, options?: any): void {
-    logger.warn('Using deprecated direct route method', 'DirectRoute', {
-      method,
-      path,
-      suggestion: 'Use chainable or schema-first API instead',
-    });
-
-    const schema: RouteSchema = {
-      method: method.toUpperCase() as HttpMethod,
-      path,
-      handler: handler as any,
-    };
-
-    if (options?.validation) {
-      schema.validation = { body: options.validation };
-    }
-
-    if (options?.rateLimit) {
-      schema.rateLimit = options.rateLimit;
-    }
-
-    this.route(schema);
-  }
-
-  private createChainableRoute(method: HttpMethod, path: string): RouteBuilder {
-    // Just create and return the builder - it auto-registers with UnifiedRouter
-    return createRoute(method, path);
-  }
-}
-
-// Convenience type for apps with intelligent routing
-export type AppWithIntelligentRouting = IntelligentApp & {
-  handleIntelligentRoute(req: HttpRequest, res: HttpResponse): Promise<boolean>;
-  getIntelligentRoutes(): CompiledRoute[];
-};

package/src/core/routing/index.ts

@@ -1,261 +0,0 @@
-// Intelligent Routing System for Moro Framework
-// Schema-first with automatic middleware ordering and chainable API
-//
-// NOTE: This file exports types and thin facades to UnifiedRouter
-// All routing logic has been consolidated in unified-router.ts
-
-import { ValidationSchema } from '../validation/schema-interface.js';
-import { HttpRequest, HttpResponse } from '../http/index.js';
-import { UnifiedRouter } from './unified-router.js';
-
-// ===== TYPE EXPORTS (Keep all - used by app code) =====
-
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-export type RouteHandler<T = any> = (req: HttpRequest, res: HttpResponse) => T | Promise<T>;
-export type Middleware = (
-  req: HttpRequest,
-  res: HttpResponse,
-  next: () => void
-) => void | Promise<void>;
-
-export interface ValidationConfig {
-  body?: ValidationSchema;
-  query?: ValidationSchema;
-  params?: ValidationSchema;
-  headers?: ValidationSchema;
-}
-
-export interface AuthConfig {
-  roles?: string[];
-  permissions?: string[];
-  optional?: boolean;
-}
-
-export interface RateLimitConfig {
-  requests: number;
-  window: number;
-  skipSuccessfulRequests?: boolean;
-}
-
-export interface CacheConfig {
-  ttl: number;
-  key?: string;
-  tags?: string[];
-}
-
-export interface MiddlewarePhases {
-  before?: Middleware[];
-  after?: Middleware[];
-  transform?: Middleware[];
-}
-
-export interface RouteSchema {
-  method: HttpMethod;
-  path: string;
-  handler: RouteHandler;
-  validation?: ValidationConfig;
-  auth?: AuthConfig;
-  rateLimit?: RateLimitConfig;
-  cache?: CacheConfig;
-  middleware?: MiddlewarePhases;
-  description?: string;
-  tags?: string[];
-}
-
-export const EXECUTION_PHASES = [
-  'security',
-  'parsing',
-  'rateLimit',
-  'before',
-  'auth',
-  'validation',
-  'transform',
-  'cache',
-  'after',
-  'handler',
-] as const;
-
-export type ExecutionPhase = (typeof EXECUTION_PHASES)[number];
-
-export interface ValidatedRequest<T = any> extends HttpRequest {
-  validatedBody?: T;
-  validatedQuery?: any;
-  validatedParams?: any;
-  validatedHeaders?: any;
-  user?: any;
-}
-
-// ===== ROUTE BUILDER INTERFACE (Public API) =====
-
-export interface RouteBuilder {
-  validate(config: ValidationConfig): RouteBuilder;
-  body<T>(schema: ValidationSchema<T>): RouteBuilder;
-  query<T>(schema: ValidationSchema<T>): RouteBuilder;
-  params<T>(schema: ValidationSchema<T>): RouteBuilder;
-  headers<T>(schema: ValidationSchema<T>): RouteBuilder;
-  auth(config: AuthConfig): RouteBuilder;
-  rateLimit(config: RateLimitConfig): RouteBuilder;
-  cache(config: CacheConfig): RouteBuilder;
-  before(...middleware: Middleware[]): RouteBuilder;
-  after(...middleware: Middleware[]): RouteBuilder;
-  transform(...middleware: Middleware[]): RouteBuilder;
-  use(...middleware: Middleware[]): RouteBuilder;
-  describe(description: string): RouteBuilder;
-  tag(...tags: string[]): RouteBuilder;
-  handler<T>(handler: RouteHandler<T>): void;
-}
-
-// ===== COMPILED ROUTE INTERFACE (Public API) =====
-
-export interface CompiledRoute {
-  schema: RouteSchema;
-  execute(req: HttpRequest, res: HttpResponse): Promise<void>;
-}
-
-// ===== FACADE IMPLEMENTATIONS (Delegate to UnifiedRouter) =====
-
-/**
- * Thin facade to UnifiedRouter.RouteBuilder
- * Maintains backward compatibility while using optimized implementation
- */
-export class IntelligentRouteBuilder implements RouteBuilder {
-  private schema: Partial<RouteSchema>;
-  private router = UnifiedRouter.getInstance();
-
-  constructor(method: HttpMethod, path: string) {
-    this.schema = {
-      method,
-      path,
-      middleware: {} as MiddlewarePhases,
-    };
-  }
-
-  validate(config: ValidationConfig): RouteBuilder {
-    this.schema.validation = { ...this.schema.validation, ...config };
-    return this;
-  }
-
-  body<T>(schema: ValidationSchema<T>): RouteBuilder {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.body = schema;
-    return this;
-  }
-
-  query<T>(schema: ValidationSchema<T>): RouteBuilder {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.query = schema;
-    return this;
-  }
-
-  params<T>(schema: ValidationSchema<T>): RouteBuilder {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.params = schema;
-    return this;
-  }
-
-  headers<T>(schema: ValidationSchema<T>): RouteBuilder {
-    if (!this.schema.validation) this.schema.validation = {};
-    this.schema.validation.headers = schema;
-    return this;
-  }
-
-  auth(config: AuthConfig): RouteBuilder {
-    this.schema.auth = config;
-    return this;
-  }
-
-  rateLimit(config: RateLimitConfig): RouteBuilder {
-    this.schema.rateLimit = config;
-    return this;
-  }
-
-  cache(config: CacheConfig): RouteBuilder {
-    this.schema.cache = config;
-    return this;
-  }
-
-  before(...middleware: Middleware[]): RouteBuilder {
-    if (!this.schema.middleware) this.schema.middleware = {};
-    const phases = this.schema.middleware as MiddlewarePhases;
-    phases.before = [...(phases.before || []), ...middleware];
-    return this;
-  }
-
-  after(...middleware: Middleware[]): RouteBuilder {
-    if (!this.schema.middleware) this.schema.middleware = {};
-    const phases = this.schema.middleware as MiddlewarePhases;
-    phases.after = [...(phases.after || []), ...middleware];
-    return this;
-  }
-
-  transform(...middleware: Middleware[]): RouteBuilder {
-    if (!this.schema.middleware) this.schema.middleware = {};
-    const phases = this.schema.middleware as MiddlewarePhases;
-    phases.transform = [...(phases.transform || []), ...middleware];
-    return this;
-  }
-
-  use(...middleware: Middleware[]): RouteBuilder {
-    return this.after(...middleware);
-  }
-
-  describe(description: string): RouteBuilder {
-    this.schema.description = description;
-    return this;
-  }
-
-  tag(...tags: string[]): RouteBuilder {
-    this.schema.tags = [...(this.schema.tags || []), ...tags];
-    return this;
-  }
-
-  handler<T>(handler: RouteHandler<T>): void {
-    if (!handler) {
-      throw new Error('Handler is required');
-    }
-
-    const completeSchema: RouteSchema = {
-      ...(this.schema as RouteSchema),
-      handler,
-    };
-
-    // Delegate to UnifiedRouter
-    this.router.registerRoute(completeSchema);
-  }
-}
-
-/**
- * Thin facade implementing CompiledRoute interface
- * Just stores schema for documentation purposes
- */
-export class ExecutableRoute implements CompiledRoute {
-  constructor(public readonly schema: RouteSchema) {
-    // Register with UnifiedRouter
-    UnifiedRouter.getInstance().registerRoute(schema);
-  }
-
-  async execute(req: HttpRequest, res: HttpResponse): Promise<void> {
-    // This is never called - UnifiedRouter handles execution
-    // But we implement it for interface compatibility
-    throw new Error(
-      'ExecutableRoute.execute() should not be called directly - routing handled by UnifiedRouter'
-    );
-  }
-}
-
-// ===== FACTORY FUNCTIONS (Backward Compatibility) =====
-
-export function createRoute(method: HttpMethod, path: string): RouteBuilder {
-  return new IntelligentRouteBuilder(method, path);
-}
-
-export function defineRoute(schema: RouteSchema): CompiledRoute {
-  return new ExecutableRoute(schema);
-}
-
-// ===== RE-EXPORTS FROM UNIFIED ROUTER =====
-
-export { UnifiedRouter } from './unified-router.js';
-export { RouteBuilder as UnifiedRouteBuilder } from './unified-router.js';
-export { PathMatcher, type CompiledPath, type MatchResult } from './path-matcher.js';
-export { ObjectPoolManager, getPoolManager } from '../pooling/object-pool-manager.js';

package/src/core/routing/path-matcher.ts

@@ -1,222 +0,0 @@
-// Shared Path Matching Utility with Caching
-// Replaces 6 different pathToRegex implementations across the codebase
-
-export interface CompiledPath {
-  pattern: RegExp | null;
-  paramNames: string[];
-  isStatic: boolean;
-  path: string;
-  segments: number;
-}
-
-export interface MatchResult {
-  params: Record<string, string>;
-}
-
-/**
- * LRU Cache implementation for compiled paths
- */
-class LRUCache<K, V> {
-  private cache = new Map<K, V>();
-  private readonly maxSize: number;
-
-  constructor(maxSize: number = 1000) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: K): V | undefined {
-    const value = this.cache.get(key);
-    if (value !== undefined) {
-      // Move to end (most recently used)
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-
-  set(key: K, value: V): void {
-    // Remove if exists (to update position)
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    }
-
-    // Add to end
-    this.cache.set(key, value);
-
-    // Evict oldest if over capacity
-    if (this.cache.size > this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== undefined) {
-        this.cache.delete(firstKey);
-      }
-    }
-  }
-
-  has(key: K): boolean {
-    return this.cache.has(key);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  get size(): number {
-    return this.cache.size;
-  }
-}
-
-/**
- * PathMatcher - Single source of truth for path pattern compilation and matching
- */
-export class PathMatcher {
-  private static readonly cache = new LRUCache<string, CompiledPath>(1000);
-  private static compilationCount = 0;
-  private static cacheHits = 0;
-  private static cacheMisses = 0;
-
-  /**
-   * Compile a path pattern into an efficient matching structure
-   * Results are cached for performance
-   */
-  static compile(path: string): CompiledPath {
-    // Check cache first
-    const cached = this.cache.get(path);
-    if (cached) {
-      this.cacheHits++;
-      return cached;
-    }
-
-    this.cacheMisses++;
-    this.compilationCount++;
-
-    // Compile the pattern
-    const compiled = this.compileInternal(path);
-    this.cache.set(path, compiled);
-    return compiled;
-  }
-
-  /**
-   * Internal compilation logic
-   */
-  private static compileInternal(path: string): CompiledPath {
-    const paramNames: string[] = [];
-    const isStatic = !path.includes(':') && !path.includes('*');
-
-    // Calculate segment count for optimization
-    const segments = path.split('/').filter(s => s.length > 0).length;
-
-    if (isStatic) {
-      // No regex needed for static routes
-      return {
-        pattern: null,
-        paramNames: [],
-        isStatic: true,
-        path,
-        segments,
-      };
-    }
-
-    // Convert parameterized routes to regex
-    // Match :paramName and capture the parameter name
-    const regexPath = path
-      .replace(/\/:([^/]+)/g, (match, paramName) => {
-        paramNames.push(paramName);
-        return '/([^/]+)';
-      })
-      .replace(/\//g, '\\/');
-
-    return {
-      pattern: new RegExp(`^${regexPath}$`),
-      paramNames,
-      isStatic: false,
-      path,
-      segments,
-    };
-  }
-
-  /**
-   * Match a request path against a compiled pattern
-   * Returns match result with extracted parameters, or null if no match
-   */
-  static match(compiledPath: CompiledPath, requestPath: string): MatchResult | null {
-    // Path for static routes - simple string comparison
-    if (compiledPath.isStatic) {
-      return compiledPath.path === requestPath ? { params: {} } : null;
-    }
-
-    // Dynamic route - use regex matching
-    if (!compiledPath.pattern) {
-      return null;
-    }
-
-    const matches = requestPath.match(compiledPath.pattern);
-    if (!matches) {
-      return null;
-    }
-
-    // Extract parameters
-    const params: Record<string, string> = {};
-    compiledPath.paramNames.forEach((name, index) => {
-      params[name] = matches[index + 1];
-    });
-
-    return { params };
-  }
-
-  /**
-   * Compile and match in one operation (convenience method)
-   */
-  static compileAndMatch(pathPattern: string, requestPath: string): MatchResult | null {
-    const compiled = this.compile(pathPattern);
-    return this.match(compiled, requestPath);
-  }
-
-  /**
-   * Check if a path pattern is static (no parameters)
-   */
-  static isStatic(path: string): boolean {
-    return !path.includes(':') && !path.includes('*');
-  }
-
-  /**
-   * Get performance statistics
-   */
-  static getStats() {
-    const totalRequests = this.cacheHits + this.cacheMisses;
-    return {
-      cacheSize: this.cache.size,
-      cacheHits: this.cacheHits,
-      cacheMisses: this.cacheMisses,
-      hitRate: totalRequests > 0 ? this.cacheHits / totalRequests : 0,
-      compilationCount: this.compilationCount,
-    };
-  }
-
-  /**
-   * Clear the cache (useful for testing)
-   */
-  static clearCache(): void {
-    this.cache.clear();
-    this.cacheHits = 0;
-    this.cacheMisses = 0;
-  }
-
-  /**
-   * Pre-compile multiple paths (cache warming)
-   */
-  static precompile(paths: string[]): void {
-    paths.forEach(path => this.compile(path));
-  }
-}
-
-/**
- * Legacy compatibility function - maps to PathMatcher.compile
- * @deprecated Use PathMatcher.compile instead
- */
-export function pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
-  const compiled = PathMatcher.compile(path);
-  return {
-    pattern: compiled.pattern || new RegExp(`^${path.replace(/\//g, '\\/')}$`),
-    paramNames: compiled.paramNames,
-  };
-}