@morojs/moro 1.0.0

package/src/core/routing/index.ts

@@ -0,0 +1,519 @@
+// Intelligent Routing System for Moro Framework
+// Schema-first with automatic middleware ordering and chainable API
+
+import { z, ZodSchema } from "zod";
+import { HttpRequest, HttpResponse } from "../http";
+import { createFrameworkLogger } from "../logger";
+
+const logger = createFrameworkLogger("IntelligentRouting");
+
+// Core types
+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>;
+
+// Configuration interfaces
+export interface ValidationConfig {
+  body?: ZodSchema;
+  query?: ZodSchema;
+  params?: ZodSchema;
+  headers?: ZodSchema;
+}
+
+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[];
+}
+
+// Middleware phases for intelligent ordering
+export interface MiddlewarePhases {
+  before?: Middleware[]; // Before auth/validation
+  after?: Middleware[]; // After validation, before handler
+  transform?: Middleware[]; // Data transformation phase
+}
+
+// Core route schema
+export interface RouteSchema {
+  method: HttpMethod;
+  path: string;
+  handler: RouteHandler;
+
+  // Framework-managed (order-independent)
+  validation?: ValidationConfig;
+  auth?: AuthConfig;
+  rateLimit?: RateLimitConfig;
+  cache?: CacheConfig;
+
+  // Custom middleware with phase hints
+  middleware?: MiddlewarePhases;
+
+  // Metadata
+  description?: string;
+  tags?: string[];
+}
+
+// Execution phases in optimal order
+export const EXECUTION_PHASES = [
+  "security", // CORS, Helmet (framework-managed)
+  "parsing", // Body/query parsing (framework-managed)
+  "rateLimit", // Rate limiting (early protection)
+  "before", // Custom pre-processing middleware
+  "auth", // Authentication/authorization
+  "validation", // Request validation
+  "transform", // Data transformation middleware
+  "cache", // Caching logic
+  "after", // Custom post-processing middleware
+  "handler", // Route handler (always last)
+] as const;
+
+export type ExecutionPhase = (typeof EXECUTION_PHASES)[number];
+
+// Enhanced request with validation results
+export interface ValidatedRequest<T = any> extends HttpRequest {
+  validatedBody?: T;
+  validatedQuery?: any;
+  validatedParams?: any;
+  validatedHeaders?: any;
+  user?: any; // Added by auth middleware
+}
+
+// Route builder for chainable API
+export interface RouteBuilder {
+  // Validation methods
+  validate(config: ValidationConfig): RouteBuilder;
+  body<T>(schema: ZodSchema<T>): RouteBuilder;
+  query<T>(schema: ZodSchema<T>): RouteBuilder;
+  params<T>(schema: ZodSchema<T>): RouteBuilder;
+  headers<T>(schema: ZodSchema<T>): RouteBuilder;
+
+  // Security/Auth methods
+  auth(config: AuthConfig): RouteBuilder;
+  rateLimit(config: RateLimitConfig): RouteBuilder;
+
+  // Caching
+  cache(config: CacheConfig): RouteBuilder;
+
+  // Custom middleware with phase control
+  before(...middleware: Middleware[]): RouteBuilder;
+  after(...middleware: Middleware[]): RouteBuilder;
+  transform(...middleware: Middleware[]): RouteBuilder;
+  use(...middleware: Middleware[]): RouteBuilder; // Alias for 'after'
+
+  // Metadata
+  describe(description: string): RouteBuilder;
+  tag(...tags: string[]): RouteBuilder;
+
+  // Terminal method
+  handler<T>(handler: RouteHandler<T>): CompiledRoute;
+}
+
+// Compiled route ready for execution
+export interface CompiledRoute {
+  schema: RouteSchema;
+  execute(req: HttpRequest, res: HttpResponse): Promise<void>;
+}
+
+// Route builder implementation
+export class IntelligentRouteBuilder implements RouteBuilder {
+  private schema: Partial<RouteSchema>;
+
+  constructor(method: HttpMethod, path: string) {
+    this.schema = {
+      method,
+      path,
+      middleware: {},
+    };
+  }
+
+  // Validation methods
+  validate(config: ValidationConfig): RouteBuilder {
+    this.schema.validation = { ...this.schema.validation, ...config };
+    return this;
+  }
+
+  body<T>(schema: ZodSchema<T>): RouteBuilder {
+    if (!this.schema.validation) this.schema.validation = {};
+    this.schema.validation.body = schema;
+    return this;
+  }
+
+  query<T>(schema: ZodSchema<T>): RouteBuilder {
+    if (!this.schema.validation) this.schema.validation = {};
+    this.schema.validation.query = schema;
+    return this;
+  }
+
+  params<T>(schema: ZodSchema<T>): RouteBuilder {
+    if (!this.schema.validation) this.schema.validation = {};
+    this.schema.validation.params = schema;
+    return this;
+  }
+
+  headers<T>(schema: ZodSchema<T>): RouteBuilder {
+    if (!this.schema.validation) this.schema.validation = {};
+    this.schema.validation.headers = schema;
+    return this;
+  }
+
+  // Security methods
+  auth(config: AuthConfig): RouteBuilder {
+    this.schema.auth = config;
+    return this;
+  }
+
+  rateLimit(config: RateLimitConfig): RouteBuilder {
+    this.schema.rateLimit = config;
+    return this;
+  }
+
+  // Caching
+  cache(config: CacheConfig): RouteBuilder {
+    this.schema.cache = config;
+    return this;
+  }
+
+  // Custom middleware
+  before(...middleware: Middleware[]): RouteBuilder {
+    if (!this.schema.middleware) this.schema.middleware = {};
+    this.schema.middleware.before = [
+      ...(this.schema.middleware.before || []),
+      ...middleware,
+    ];
+    return this;
+  }
+
+  after(...middleware: Middleware[]): RouteBuilder {
+    if (!this.schema.middleware) this.schema.middleware = {};
+    this.schema.middleware.after = [
+      ...(this.schema.middleware.after || []),
+      ...middleware,
+    ];
+    return this;
+  }
+
+  transform(...middleware: Middleware[]): RouteBuilder {
+    if (!this.schema.middleware) this.schema.middleware = {};
+    this.schema.middleware.transform = [
+      ...(this.schema.middleware.transform || []),
+      ...middleware,
+    ];
+    return this;
+  }
+
+  use(...middleware: Middleware[]): RouteBuilder {
+    return this.after(...middleware);
+  }
+
+  // Metadata
+  describe(description: string): RouteBuilder {
+    this.schema.description = description;
+    return this;
+  }
+
+  tag(...tags: string[]): RouteBuilder {
+    this.schema.tags = [...(this.schema.tags || []), ...tags];
+    return this;
+  }
+
+  // Terminal method - compiles the route
+  handler<T>(handler: RouteHandler<T>): CompiledRoute {
+    if (!handler) {
+      throw new Error("Handler is required");
+    }
+
+    const completeSchema: RouteSchema = {
+      ...(this.schema as RouteSchema),
+      handler,
+    };
+
+    logger.debug(
+      `Compiled route: ${completeSchema.method} ${completeSchema.path}`,
+      "RouteCompilation",
+      {
+        hasValidation: !!completeSchema.validation,
+        hasAuth: !!completeSchema.auth,
+        hasRateLimit: !!completeSchema.rateLimit,
+        hasCache: !!completeSchema.cache,
+        customMiddleware: {
+          before: completeSchema.middleware?.before?.length || 0,
+          after: completeSchema.middleware?.after?.length || 0,
+          transform: completeSchema.middleware?.transform?.length || 0,
+        },
+      },
+    );
+
+    return new ExecutableRoute(completeSchema);
+  }
+}
+
+// Executable route with intelligent middleware ordering
+export class ExecutableRoute implements CompiledRoute {
+  constructor(public readonly schema: RouteSchema) {}
+
+  async execute(req: HttpRequest, res: HttpResponse): Promise<void> {
+    const validatedReq = req as ValidatedRequest;
+
+    try {
+      // Execute middleware in intelligent order
+      await this.executePhase("before", validatedReq, res);
+      await this.executePhase("rateLimit", validatedReq, res);
+      await this.executePhase("auth", validatedReq, res);
+      await this.executePhase("validation", validatedReq, res);
+      await this.executePhase("transform", validatedReq, res);
+      await this.executePhase("cache", validatedReq, res);
+      await this.executePhase("after", validatedReq, res);
+
+      // Execute handler last
+      if (!res.headersSent) {
+        await this.executePhase("handler", validatedReq, res);
+      }
+    } catch (error) {
+      logger.error("Route execution error", "RouteExecution", {
+        error: error instanceof Error ? error.message : String(error),
+        route: `${this.schema.method} ${this.schema.path}`,
+        requestId: req.requestId,
+      });
+
+      if (!res.headersSent) {
+        res.status(500).json({
+          success: false,
+          error: "Internal server error",
+          requestId: req.requestId,
+        });
+      }
+    }
+  }
+
+  private async executePhase(
+    phase: ExecutionPhase,
+    req: ValidatedRequest,
+    res: HttpResponse,
+  ): Promise<void> {
+    switch (phase) {
+      case "before":
+        if (this.schema.middleware?.before) {
+          for (const middleware of this.schema.middleware.before) {
+            await this.executeMiddleware(middleware, req, res);
+          }
+        }
+        break;
+
+      case "rateLimit":
+        if (this.schema.rateLimit) {
+          await this.executeRateLimit(req, res);
+        }
+        break;
+
+      case "auth":
+        if (this.schema.auth) {
+          await this.executeAuth(req, res);
+        }
+        break;
+
+      case "validation":
+        if (this.schema.validation) {
+          await this.executeValidation(req, res);
+        }
+        break;
+
+      case "transform":
+        if (this.schema.middleware?.transform) {
+          for (const middleware of this.schema.middleware.transform) {
+            await this.executeMiddleware(middleware, req, res);
+          }
+        }
+        break;
+
+      case "cache":
+        if (this.schema.cache) {
+          await this.executeCache(req, res);
+        }
+        break;
+
+      case "after":
+        if (this.schema.middleware?.after) {
+          for (const middleware of this.schema.middleware.after) {
+            await this.executeMiddleware(middleware, req, res);
+          }
+        }
+        break;
+
+      case "handler": {
+        const result = await this.schema.handler(req, res);
+        if (result !== undefined && !res.headersSent) {
+          res.json(result);
+        }
+        break;
+      }
+    }
+  }
+
+  private async executeMiddleware(
+    middleware: Middleware,
+    req: HttpRequest,
+    res: HttpResponse,
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const next = () => resolve();
+        const result = middleware(req, res, next);
+        if (result instanceof Promise) {
+          result.then(() => resolve()).catch(reject);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  private async executeRateLimit(
+    req: HttpRequest,
+    res: HttpResponse,
+  ): Promise<void> {
+    // Rate limiting implementation will be added
+    logger.debug("Rate limit check", "RateLimit", {
+      config: this.schema.rateLimit,
+      ip: req.ip,
+    });
+  }
+
+  private async executeAuth(
+    req: ValidatedRequest,
+    res: HttpResponse,
+  ): Promise<void> {
+    // Authentication implementation will be added
+    logger.debug("Auth check", "Auth", {
+      config: this.schema.auth,
+    });
+  }
+
+  private async executeValidation(
+    req: ValidatedRequest,
+    res: HttpResponse,
+  ): Promise<void> {
+    if (!this.schema.validation) return;
+
+    const { body, query, params, headers } = this.schema.validation;
+
+    // Validate body
+    if (body && req.body !== undefined) {
+      try {
+        req.validatedBody = await body.parseAsync(req.body);
+        req.body = req.validatedBody; // Update original for compatibility
+      } catch (error: any) {
+        this.sendValidationError(res, error, "body", req.requestId);
+        return;
+      }
+    }
+
+    // Validate query
+    if (query && req.query !== undefined) {
+      try {
+        req.validatedQuery = await query.parseAsync(req.query);
+        req.query = req.validatedQuery; // Update original for compatibility
+      } catch (error: any) {
+        this.sendValidationError(res, error, "query", req.requestId);
+        return;
+      }
+    }
+
+    // Validate params
+    if (params && req.params !== undefined) {
+      try {
+        req.validatedParams = await params.parseAsync(req.params);
+        req.params = req.validatedParams; // Update original for compatibility
+      } catch (error: any) {
+        this.sendValidationError(res, error, "params", req.requestId);
+        return;
+      }
+    }
+
+    // Validate headers
+    if (headers && req.headers !== undefined) {
+      try {
+        req.validatedHeaders = await headers.parseAsync(req.headers);
+      } catch (error: any) {
+        this.sendValidationError(res, error, "headers", req.requestId);
+        return;
+      }
+    }
+
+    logger.debug("Validation passed", "Validation", {
+      route: `${this.schema.method} ${this.schema.path}`,
+      validatedFields: Object.keys(this.schema.validation),
+    });
+  }
+
+  private sendValidationError(
+    res: HttpResponse,
+    error: any,
+    field: string,
+    requestId?: string,
+  ): void {
+    if (error.issues) {
+      res.status(400).json({
+        success: false,
+        error: `Validation failed for ${field}`,
+        details: error.issues.map((issue: any) => ({
+          field: issue.path.length > 0 ? issue.path.join(".") : field,
+          message: issue.message,
+          code: issue.code,
+        })),
+        requestId,
+      });
+    } else {
+      res.status(400).json({
+        success: false,
+        error: `Validation failed for ${field}`,
+        requestId,
+      });
+    }
+  }
+
+  private async executeCache(
+    req: HttpRequest,
+    res: HttpResponse,
+  ): Promise<void> {
+    // Caching implementation will be added
+    logger.debug("Cache check", "Cache", {
+      config: this.schema.cache,
+    });
+  }
+}
+
+// Factory functions for creating routes
+export function createRoute(method: HttpMethod, path: string): RouteBuilder {
+  return new IntelligentRouteBuilder(method, path);
+}
+
+// Schema-first route creation
+export function defineRoute(schema: RouteSchema): CompiledRoute {
+  return new ExecutableRoute(schema);
+}

package/src/core/runtime/aws-lambda-adapter.ts

@@ -0,0 +1,157 @@
+// AWS Lambda runtime adapter
+import { BaseRuntimeAdapter } from "./base-adapter";
+import { HttpRequest, HttpResponse } from "../../types/http";
+import { RuntimeHttpResponse } from "../../types/runtime";
+
+export interface LambdaEvent {
+  httpMethod: string;
+  path: string;
+  pathParameters?: Record<string, string> | null;
+  queryStringParameters?: Record<string, string> | null;
+  headers?: Record<string, string> | null;
+  multiValueHeaders?: Record<string, string[]> | null;
+  body?: string | null;
+  isBase64Encoded?: boolean;
+  requestContext?: {
+    identity?: {
+      sourceIp?: string;
+    };
+  };
+}
+
+export interface LambdaContext {
+  requestId: string;
+  functionName: string;
+  functionVersion: string;
+  invokedFunctionArn: string;
+  memoryLimitInMB: string;
+  awsRequestId: string;
+  logGroupName: string;
+  logStreamName: string;
+  getRemainingTimeInMillis(): number;
+}
+
+export interface LambdaResponse {
+  statusCode: number;
+  headers?: Record<string, string>;
+  multiValueHeaders?: Record<string, string[]>;
+  body: string;
+  isBase64Encoded?: boolean;
+}
+
+export class AWSLambdaAdapter extends BaseRuntimeAdapter {
+  readonly type = "aws-lambda" as const;
+
+  async adaptRequest(
+    event: LambdaEvent,
+    context: LambdaContext,
+  ): Promise<HttpRequest> {
+    const { pathname, query } = this.parseUrl(event.path);
+
+    // Merge query parameters from event
+    const mergedQuery = {
+      ...query,
+      ...(event.queryStringParameters || {}),
+    };
+
+    // Parse body
+    let body: any;
+    if (event.body) {
+      const contentType =
+        event.headers?.["content-type"] ||
+        event.headers?.["Content-Type"] ||
+        "";
+      if (event.isBase64Encoded) {
+        body = Buffer.from(event.body, "base64").toString();
+      } else {
+        body = event.body;
+      }
+      body = await this.parseBody(body, contentType);
+    }
+
+    const baseRequest = {
+      method: event.httpMethod,
+      url: event.path,
+      path: pathname,
+      query: mergedQuery,
+      body,
+      headers: event.headers || {},
+      ip: event.requestContext?.identity?.sourceIp || "unknown",
+      params: event.pathParameters || {},
+      requestId: context.awsRequestId,
+      cookies: this.parseCookies(event.headers?.cookie || ""),
+      files: {},
+    } as Partial<HttpRequest>;
+
+    return this.enhanceRequest(baseRequest);
+  }
+
+  async adaptResponse(
+    moroResponse: HttpResponse | RuntimeHttpResponse,
+  ): Promise<LambdaResponse> {
+    const runtimeResponse = moroResponse as RuntimeHttpResponse;
+
+    let body = runtimeResponse.body;
+    const status = runtimeResponse.statusCode || 200;
+    const headers = runtimeResponse.headers || {};
+
+    // Convert body to string
+    if (typeof body === "object" && body !== null) {
+      body = JSON.stringify(body);
+      headers["Content-Type"] = "application/json";
+    } else if (body === null || body === undefined) {
+      body = "";
+    } else {
+      body = String(body);
+    }
+
+    return {
+      statusCode: status,
+      headers,
+      body,
+      isBase64Encoded: false,
+    };
+  }
+
+  createServer(
+    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
+  ) {
+    // Return a Lambda-compatible handler function
+    return async (event: LambdaEvent, context: LambdaContext) => {
+      try {
+        const moroReq = await this.adaptRequest(event, context);
+        const moroRes = this.createMockResponse();
+
+        await handler(moroReq, moroRes as any);
+
+        return await this.adaptResponse(moroRes);
+      } catch (error) {
+        return {
+          statusCode: 500,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            success: false,
+            error: "Internal server error",
+            message: error instanceof Error ? error.message : "Unknown error",
+          }),
+        };
+      }
+    };
+  }
+
+  // Lambda doesn't have a listen method - it's event-driven
+  // listen method is optional in the interface
+
+  private parseCookies(cookieHeader: string): Record<string, string> {
+    const cookies: Record<string, string> = {};
+    if (cookieHeader) {
+      cookieHeader.split(";").forEach((cookie) => {
+        const [name, ...rest] = cookie.trim().split("=");
+        if (name && rest.length > 0) {
+          cookies[name] = rest.join("=");
+        }
+      });
+    }
+    return cookies;
+  }
+}