@engjts/nexus 0.1.8 → 0.1.10

package/src/core/router/index.ts

@@ -1,260 +0,0 @@
-/**
- * Router implementation with schema validation
- */
-
-import { RadixTree } from './radix-tree';
-import {
-  HTTPMethod,
-  Handler,
-  Middleware,
-  RouteConfig,
-  RouteMatch,
-  SchemaConfig,
-  RouteMeta,
-  Context
-} from '../types';
-import { SerializerFunction, createSerializer, JSONSchema } from '../serializer';
-
-/**
- * Route with validation schema and metadata
- */
-export interface RouteEntry {
-  handler: Handler;
-  middlewares: Middleware[];
-  schema?: SchemaConfig;
-  meta?: RouteMeta;
-  serializers?: Map<number | string, SerializerFunction>;
-}
-
-/**
- * Router class
- */
-export class Router {
-  private trees: Map<HTTPMethod, RadixTree> = new Map();
-  private routes: Array<{ method: HTTPMethod; path: string; config: RouteEntry }> = [];
-  private prefix: string = '';
-
-  constructor(prefix: string = '') {
-    this.prefix = prefix;
-    // Initialize trees for each HTTP method
-    const methods: HTTPMethod[] = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
-    for (const method of methods) {
-      this.trees.set(method, new RadixTree());
-    }
-  }
-
-  /**
-   * Register a route
-   */
-  addRoute(config: RouteConfig): void {
-    const { method, path, handler, middlewares = [], schema, meta } = config;
-    const fullPath = this.prefix ? `${this.prefix}${path}` : path;
-
-    const tree = this.trees.get(method);
-    if (!tree) {
-      throw new Error(`Unsupported HTTP method: ${method}`);
-    }
-
-    // Wrap handler with schema validation if provided
-    const wrappedHandler = schema ? this.wrapWithValidation(handler, schema) : handler;
-
-    // Compile response serializers if response schema is provided
-    let serializers: Map<number | string, SerializerFunction> | undefined;
-    if (schema?.response) {
-      serializers = this.compileResponseSerializers(schema.response);
-    }
-
-    tree.insert(fullPath, wrappedHandler, middlewares, serializers);
-
-    // Store for introspection (including schema, meta, and serializers for documentation)
-    this.routes.push({
-      method,
-      path: fullPath,
-      config: { handler: wrappedHandler, middlewares, schema, meta, serializers }
-    });
-  }
-
-  /**
-   * Compile response schemas into fast serializers
-   */
-  private compileResponseSerializers(
-    responseSchema: Record<string | number, any>
-  ): Map<number | string, SerializerFunction> {
-    const serializers = new Map<number | string, SerializerFunction>();
-
-    for (const [statusKey, schema] of Object.entries(responseSchema)) {
-      if (schema && typeof schema === 'object') {
-        try {
-          const serializer = createSerializer(schema as JSONSchema);
-          serializers.set(statusKey, serializer);
-        } catch (e) {
-          // If compilation fails, skip this serializer (will fall back to JSON.stringify)
-          console.warn(`[Router] Failed to compile serializer for status ${statusKey}:`, e);
-        }
-      }
-    }
-
-    return serializers;
-  }
-
-  /**
-   * Find a matching route
-   */
-  match(method: string, path: string): RouteMatch | null {
-    const tree = this.trees.get(method as HTTPMethod);
-    if (!tree) {
-      return null;
-    }
-
-    const result = tree.search(path);
-    if (!result) {
-      return null;
-    }
-
-    return {
-      handler: result.handler,
-      params: result.params,
-      middlewares: result.middlewares,
-      schema: undefined, // Schema already applied in wrapped handler
-      _serializer: result.serializers || undefined
-    };
-  }
-
-  /**
-   * Get all registered routes with full metadata
-   */
-  getRoutes(): Array<{ method: string; path: string; schema?: SchemaConfig; meta?: RouteMeta }> {
-    return this.routes.map(r => ({
-      method: r.method,
-      path: r.path,
-      schema: r.config.schema,
-      meta: r.config.meta
-    }));
-  }
-
-  /**
-   * Get raw route configs for merging into Application
-   */
-  getRawRoutes(): Array<{ method: HTTPMethod; path: string; config: RouteEntry }> {
-    return this.routes;
-  }
-
-  /**
-   * Get internal radix trees for merging
-   */
-  getTrees(): Map<HTTPMethod, RadixTree> {
-    return this.trees;
-  }
-
-  /**
-   * Mount another router with a prefix (group routes)
-   * 
-   * @example
-   * ```typescript
-   * const userRoutes = new Router();
-   * userRoutes.get('/', getAllUsers);
-   * userRoutes.get('/:id', getUserById);
-   * 
-   * const router = new Router();
-   * router.group('/api/users', userRoutes);
-   * ```
-   */
-  group(prefix: string, router: Router): void {
-    const routes = router.getRawRoutes();
-    for (const route of routes) {
-      const fullPath = `${prefix}${route.path}`;
-      this.addRoute({
-        method: route.method,
-        path: fullPath,
-        handler: route.config.handler,
-        middlewares: route.config.middlewares,
-        schema: route.config.schema,
-        meta: route.config.meta
-      });
-    }
-  }
-
-  /**
-   * Convenience methods for HTTP verbs
-   */
-  get(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-    this.addRoute({ method: 'GET', path, handler, ...options });
-  }
-
-  post(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-    this.addRoute({ method: 'POST', path, handler, ...options });
-  }
-
-  put(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-    this.addRoute({ method: 'PUT', path, handler, ...options });
-  }
-
-  delete(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-    this.addRoute({ method: 'DELETE', path, handler, ...options });
-  }
-
-  patch(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-    this.addRoute({ method: 'PATCH', path, handler, ...options });
-  }
-
-  /**
-   * Wrap handler with schema validation
-   */
-  private wrapWithValidation(handler: Handler, schema: SchemaConfig): Handler {
-    return async (ctx: Context) => {
-      try {
-        // Validate params
-        if (schema.params) {
-          ctx.params = await schema.params.parseAsync(ctx.params);
-        }
-
-        // Validate query
-        if (schema.query) {
-          ctx.query = await schema.query.parseAsync(ctx.query);
-        }
-
-        // Validate body - MUST await getBody() first to parse the request body
-        if (schema.body) {
-          const rawBody = await ctx.getBody();
-          ctx.body = await schema.body.parseAsync(rawBody);
-        }
-
-        // Validate headers
-        if (schema.headers) {
-          ctx.headers = await schema.headers.parseAsync(ctx.headers);
-        }
-
-        // Call original handler with validated data
-        return handler(ctx, {});
-      } catch (error: any) {
-        // Zod validation error
-        if (error.name === 'ZodError') {
-          // Use custom error handler if provided
-          if (schema.onValidationError) {
-            const customResponse = schema.onValidationError(error.errors, ctx);
-            // If it's already a Response object, return it
-            if (customResponse?.statusCode) {
-              return customResponse;
-            }
-            // Otherwise wrap it as JSON response
-            return ctx.json(customResponse, 400);
-          }
-
-          // Default error response - extract first error message
-          const firstError = error.errors[0];
-          const message = firstError?.message || 'Validation failed';
-
-          return ctx.json({
-            success: false,
-            message
-          }, 400);
-        }
-        throw error;
-      }
-    };
-  }
-}
-
-// Re-export file router
-export { FileRouter, createFileRouter, useFileRoutes } from './file-router';
-export type { FileRouterOptions, FileRouteClass, RouteModule } from './file-router';

package/src/core/router/radix-tree.ts

@@ -1,242 +0,0 @@
-/**
- * Radix Tree implementation for efficient routing
- * Provides O(log n) route lookup performance
- */
-
-import { Handler, Middleware } from '../types';
-import { SerializerFunction } from '../serializer';
-
-/**
- * Node in the radix tree
- */
-export class RadixNode {
-    // The path segment this node represents
-    segment: string;
-
-    // Full path for this node (used for debugging)
-    fullPath: string;
-
-    // Handler if this is a terminal node
-    handler: Handler | null = null;
-
-    // Middleware for this route
-    middlewares: Middleware[] = [];
-
-    // Child nodes
-    children: RadixNode[] = [];
-
-    // Pattern type: 'static', 'param', or 'wildcard'
-    type: 'static' | 'param' | 'wildcard' = 'static';
-
-    // Parameter name for param nodes
-    paramName?: string;
-
-    // Compiled serializers for response (status code → serializer)
-    serializers: Map<number | string, SerializerFunction> | null = null;
-
-    constructor(segment: string, fullPath: string) {
-        this.segment = segment;
-        this.fullPath = fullPath;
-
-        // Detect node type
-        if (segment.startsWith(':')) {
-            this.type = 'param';
-            this.paramName = segment.slice(1);
-        } else if (segment === '*' || segment.startsWith('*')) {
-            this.type = 'wildcard';
-            this.paramName = segment.length > 1 ? segment.slice(1) : 'wildcard';
-        }
-    }
-
-    /**
-     * Add a child node
-     */
-    addChild(node: RadixNode): void {
-        // Insert maintaining order: static > param > wildcard
-        const priority = this.getTypePriority(node.type);
-        let inserted = false;
-
-        for (let i = 0; i < this.children.length; i++) {
-            const childPriority = this.getTypePriority(this.children[i].type);
-            if (priority < childPriority) {
-                this.children.splice(i, 0, node);
-                inserted = true;
-                break;
-            }
-        }
-
-        if (!inserted) {
-            this.children.push(node);
-        }
-    }
-
-    /**
-     * Find a child by segment
-     */
-    findChild(segment: string): RadixNode | null {
-        for (const child of this.children) {
-            if (child.segment === segment) {
-                return child;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Get type priority for ordering (lower = higher priority)
-     */
-    private getTypePriority(type: 'static' | 'param' | 'wildcard'): number {
-        switch (type) {
-            case 'static': return 0;
-            case 'param': return 1;
-            case 'wildcard': return 2;
-        }
-    }
-}
-
-/**
- * Radix tree for route storage and matching
- */
-export class RadixTree {
-    private root: RadixNode;
-
-    constructor() {
-        this.root = new RadixNode('', '/');
-    }
-
-    /**
-     * Insert a route into the tree
-     */
-    insert(
-        path: string, 
-        handler: Handler, 
-        middlewares: Middleware[] = [],
-        serializers?: Map<number | string, SerializerFunction>
-    ): void {
-        const segments = this.splitPath(path);
-        let current = this.root;
-
-        for (let i = 0; i < segments.length; i++) {
-            const segment = segments[i];
-            let child = current.findChild(segment);
-
-            if (!child) {
-                const fullPath = '/' + segments.slice(0, i + 1).join('/');
-                child = new RadixNode(segment, fullPath);
-                current.addChild(child);
-            }
-
-            current = child;
-        }
-
-        // Set handler, middleware, and serializers at terminal node
-        current.handler = handler;
-        current.middlewares = middlewares;
-        current.serializers = serializers || null;
-    }
-
-    /**
-     * Search for a route match
-     */
-    search(path: string): { 
-        handler: Handler; 
-        params: Record<string, string>; 
-        middlewares: Middleware[];
-        serializers: Map<number | string, SerializerFunction> | null;
-    } | null {
-        const segments = this.splitPath(path);
-        const params: Record<string, string> = {};
-
-        const result = this.searchNode(this.root, segments, 0, params);
-
-        if (result) {
-            return {
-                handler: result.handler!,
-                params,
-                middlewares: result.middlewares,
-                serializers: result.serializers
-            };
-        }
-
-        return null;
-    }
-
-    /**
-     * Recursively search nodes
-     */
-    private searchNode(
-        node: RadixNode,
-        segments: string[],
-        index: number,
-        params: Record<string, string>
-    ): RadixNode | null {
-        // Reached end of path
-        if (index === segments.length) {
-            return node.handler ? node : null;
-        }
-
-        const segment = segments[index];
-
-        // Try children in priority order
-        for (const child of node.children) {
-            if (child.type === 'static') {
-                // Exact match required
-                if (child.segment === segment) {
-                    const result = this.searchNode(child, segments, index + 1, params);
-                    if (result) return result;
-                }
-            } else if (child.type === 'param') {
-                // Parameter match - capture value
-                const oldValue = params[child.paramName!];
-                params[child.paramName!] = segment;
-
-                const result = this.searchNode(child, segments, index + 1, params);
-                if (result) return result;
-
-                // Backtrack
-                if (oldValue === undefined) {
-                    delete params[child.paramName!];
-                } else {
-                    params[child.paramName!] = oldValue;
-                }
-            } else if (child.type === 'wildcard') {
-                // Wildcard match - capture remaining path
-                params[child.paramName!] = segments.slice(index).join('/');
-                return child;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Split path into segments
-     */
-    private splitPath(path: string): string[] {
-        // Remove leading/trailing slashes and split
-        const normalized = path.replace(/^\/+|\/+$/g, '');
-        return normalized ? normalized.split('/') : [];
-    }
-
-    /**
-     * Get all routes (for debugging/introspection)
-     */
-    getAllRoutes(): Array<{ path: string; hasHandler: boolean }> {
-        const routes: Array<{ path: string; hasHandler: boolean }> = [];
-        this.collectRoutes(this.root, routes);
-        return routes;
-    }
-
-    /**
-     * Recursively collect all routes
-     */
-    private collectRoutes(node: RadixNode, routes: Array<{ path: string; hasHandler: boolean }>): void {
-        if (node.handler) {
-            routes.push({ path: node.fullPath, hasHandler: true });
-        }
-
-        for (const child of node.children) {
-            this.collectRoutes(child, routes);
-        }
-    }
-}