@morojs/moro 1.0.0

package/src/core/utilities/hooks.ts

@@ -0,0 +1,148 @@
+// Hook System for Moro
+import { EventEmitter } from "events";
+import { HookFunction, HookContext, MoroMiddleware } from "../../types/hooks";
+import { createFrameworkLogger } from "../logger";
+
+export const HOOK_EVENTS = {
+  BEFORE_REQUEST: "before:request",
+  AFTER_REQUEST: "after:request",
+  BEFORE_RESPONSE: "before:response",
+  AFTER_RESPONSE: "after:response",
+  ERROR: "error",
+} as const;
+
+export class HookManager extends EventEmitter {
+  private hooks = new Map<string, HookFunction[]>();
+  private beforeHooks = new Map<string, HookFunction[]>();
+  private afterHooks = new Map<string, HookFunction[]>();
+  private logger = createFrameworkLogger("Hooks");
+
+  constructor() {
+    super();
+    // Initialize hook arrays
+    Object.values(HOOK_EVENTS).forEach((event) => {
+      this.hooks.set(event, []);
+      this.beforeHooks.set(event, []);
+      this.afterHooks.set(event, []);
+    });
+  }
+
+  // Register a hook for a specific event
+  hook(event: string, fn: HookFunction): this {
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event)!.push(fn);
+    return this;
+  }
+
+  // Register a before hook
+  before(event: string, fn: HookFunction): this {
+    if (!this.beforeHooks.has(event)) {
+      this.beforeHooks.set(event, []);
+    }
+    this.beforeHooks.get(event)!.push(fn);
+    return this;
+  }
+
+  // Register an after hook
+  after(event: string, fn: HookFunction): this {
+    if (!this.afterHooks.has(event)) {
+      this.afterHooks.set(event, []);
+    }
+    this.afterHooks.get(event)!.push(fn);
+    return this;
+  }
+
+  // Execute hooks for an event
+  async execute(
+    event: string,
+    context: HookContext = {},
+  ): Promise<HookContext> {
+    // Execute before hooks
+    const beforeHooks = this.beforeHooks.get(event) || [];
+    for (const hook of beforeHooks) {
+      await this.executeHook(hook, context);
+    }
+
+    // Execute main hooks
+    const hooks = this.hooks.get(event) || [];
+    for (const hook of hooks) {
+      await this.executeHook(hook, context);
+    }
+
+    // Execute after hooks
+    const afterHooks = this.afterHooks.get(event) || [];
+    for (const hook of afterHooks) {
+      await this.executeHook(hook, context);
+    }
+
+    // Emit event for listeners
+    this.emit(event, context);
+
+    return context;
+  }
+
+  // Execute a single hook with error handling
+  private async executeHook(
+    hook: HookFunction,
+    context: HookContext,
+  ): Promise<void> {
+    try {
+      await hook(context);
+    } catch (error) {
+      this.logger.error("Hook execution error", "HookExecution", {
+        error: error instanceof Error ? error.message : String(error),
+        context: context.request?.method || "unknown",
+      });
+      throw error;
+    }
+  }
+
+  // Remove hooks
+  removeHook(event: string, fn?: HookFunction): this {
+    if (!fn) {
+      this.hooks.delete(event);
+      this.beforeHooks.delete(event);
+      this.afterHooks.delete(event);
+    } else {
+      [this.hooks, this.beforeHooks, this.afterHooks].forEach((map) => {
+        const hooks = map.get(event);
+        if (hooks) {
+          const index = hooks.indexOf(fn);
+          if (index !== -1) {
+            hooks.splice(index, 1);
+          }
+        }
+      });
+    }
+    return this;
+  }
+
+  // Get all registered hooks for debugging
+  getHooks(event?: string): Record<string, any> {
+    if (event) {
+      return {
+        before: this.beforeHooks.get(event) || [],
+        main: this.hooks.get(event) || [],
+        after: this.afterHooks.get(event) || [],
+      };
+    }
+
+    const allHooks: Record<string, any> = {};
+    const allEvents = new Set([
+      ...this.hooks.keys(),
+      ...this.beforeHooks.keys(),
+      ...this.afterHooks.keys(),
+    ]);
+
+    allEvents.forEach((event) => {
+      allHooks[event] = this.getHooks(event);
+    });
+
+    return allHooks;
+  }
+}
+
+// Built-in middleware - now organized in individual files
+export { simpleMiddleware as middleware } from "../middleware/index";

package/src/core/utilities/index.ts

@@ -0,0 +1,16 @@
+// Core Utilities - Centralized Exports
+export {
+  Container,
+  FunctionalContainer,
+  ServiceScope,
+  ServiceLifecycle,
+  withLogging,
+  withCaching,
+  withRetry,
+  withTimeout,
+} from "./container";
+export { CircuitBreaker } from "./circuit-breaker";
+export { HookManager, HOOK_EVENTS } from "./hooks";
+
+// Re-export middleware from hooks
+export { middleware } from "./hooks";

package/src/core/validation/index.ts

@@ -0,0 +1,216 @@
+// Functional Validation System for Moro Framework
+// Elegant, type-safe validation using Zod with functional composition
+
+import { z, ZodSchema, ZodError } from "zod";
+import { HttpRequest, HttpResponse } from "../http";
+import { createFrameworkLogger } from "../logger";
+
+const logger = createFrameworkLogger("Validation");
+
+// Validation configuration interface
+export interface ValidationConfig {
+  body?: ZodSchema;
+  query?: ZodSchema;
+  params?: ZodSchema;
+  headers?: ZodSchema;
+}
+
+// Validation result types
+export interface ValidationResult<T = any> {
+  success: boolean;
+  data?: T;
+  errors?: ValidationError[];
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
+  code: string;
+}
+
+// Enhanced request type with validated data
+export interface ValidatedRequest<T = any> extends HttpRequest {
+  validatedBody?: T;
+  validatedQuery?: any;
+  validatedParams?: any;
+  validatedHeaders?: any;
+}
+
+// Main validation wrapper function
+export function validate<TBody = any, TQuery = any, TParams = any>(
+  config: ValidationConfig,
+  handler: (
+    req: ValidatedRequest<TBody>,
+    res: HttpResponse,
+  ) => any | Promise<any>,
+) {
+  return async (req: HttpRequest, res: HttpResponse): Promise<any> => {
+    try {
+      const validatedReq = req as ValidatedRequest<TBody>;
+
+      // Validate body
+      if (config.body) {
+        const result = await validateField(config.body, req.body, "body");
+        if (!result.success) {
+          return sendValidationError(res, result.errors!, "body");
+        }
+        validatedReq.validatedBody = result.data;
+        validatedReq.body = result.data; // Also update original body for compatibility
+      }
+
+      // Validate query parameters
+      if (config.query) {
+        const result = await validateField(config.query, req.query, "query");
+        if (!result.success) {
+          return sendValidationError(res, result.errors!, "query");
+        }
+        validatedReq.validatedQuery = result.data;
+        validatedReq.query = result.data; // Also update original query for compatibility
+      }
+
+      // Validate path parameters
+      if (config.params) {
+        const result = await validateField(config.params, req.params, "params");
+        if (!result.success) {
+          return sendValidationError(res, result.errors!, "params");
+        }
+        validatedReq.validatedParams = result.data;
+        validatedReq.params = result.data; // Also update original params for compatibility
+      }
+
+      // Validate headers
+      if (config.headers) {
+        const result = await validateField(
+          config.headers,
+          req.headers,
+          "headers",
+        );
+        if (!result.success) {
+          return sendValidationError(res, result.errors!, "headers");
+        }
+        validatedReq.validatedHeaders = result.data;
+      }
+
+      logger.debug("Request validation passed", "ValidationSuccess", {
+        path: req.path,
+        method: req.method,
+        validatedFields: Object.keys(config),
+      });
+
+      // Execute the handler with validated request
+      return await handler(validatedReq, res);
+    } catch (error) {
+      logger.error("Validation wrapper error", "ValidationError", {
+        error: error instanceof Error ? error.message : String(error),
+        path: req.path,
+        method: req.method,
+      });
+
+      if (!res.headersSent) {
+        res.status(500).json({
+          success: false,
+          error: "Internal validation error",
+          requestId: req.requestId,
+        });
+      }
+    }
+  };
+}
+
+// Validate individual field
+async function validateField(
+  schema: ZodSchema,
+  data: any,
+  fieldName: string,
+): Promise<ValidationResult> {
+  try {
+    const validated = await schema.parseAsync(data);
+    return {
+      success: true,
+      data: validated,
+    };
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const errors: ValidationError[] = error.issues.map((err: any) => ({
+        field: err.path.length > 0 ? err.path.join(".") : fieldName,
+        message: err.message,
+        code: err.code,
+      }));
+
+      logger.debug("Field validation failed", "ValidationFailed", {
+        field: fieldName,
+        errors: errors.length,
+        details: errors,
+      });
+
+      return {
+        success: false,
+        errors,
+      };
+    }
+
+    // Re-throw unexpected errors
+    throw error;
+  }
+}
+
+// Send validation error response
+function sendValidationError(
+  res: HttpResponse,
+  errors: ValidationError[],
+  field: string,
+): void {
+  logger.debug("Sending validation error response", "ValidationResponse", {
+    field,
+    errorCount: errors.length,
+  });
+
+  res.status(400).json({
+    success: false,
+    error: `Validation failed for ${field}`,
+    details: errors,
+    requestId: (res as any).req?.requestId,
+  });
+}
+
+// Convenience functions for single-field validation
+export function body<T>(schema: ZodSchema<T>) {
+  return (
+    handler: (
+      req: ValidatedRequest<T>,
+      res: HttpResponse,
+    ) => any | Promise<any>,
+  ) => {
+    return validate({ body: schema }, handler);
+  };
+}
+
+export function query<T>(schema: ZodSchema<T>) {
+  return (
+    handler: (
+      req: ValidatedRequest<any>,
+      res: HttpResponse,
+    ) => any | Promise<any>,
+  ) => {
+    return validate({ query: schema }, handler);
+  };
+}
+
+export function params<T>(schema: ZodSchema<T>) {
+  return (
+    handler: (
+      req: ValidatedRequest<any>,
+      res: HttpResponse,
+    ) => any | Promise<any>,
+  ) => {
+    return validate({ params: schema }, handler);
+  };
+}
+
+// Schema composition helpers
+export function combineSchemas(schemas: ValidationConfig): ValidationConfig {
+  return schemas;
+}
+
+// Re-export Zod for convenience
+export { z } from "zod";

package/src/index.ts

@@ -0,0 +1,120 @@
+// MoroJS Framework - Main Entry Point
+export {
+  Moro,
+  createApp,
+  createAppNode,
+  createAppEdge,
+  createAppLambda,
+  createAppWorker,
+} from "./moro";
+
+export type { MoroOptions } from "./core/framework";
+
+// Runtime system exports
+export type {
+  RuntimeType,
+  RuntimeAdapter,
+  RuntimeConfig,
+  RuntimeHttpResponse,
+} from "./types/runtime";
+
+export {
+  NodeRuntimeAdapter,
+  VercelEdgeAdapter,
+  AWSLambdaAdapter,
+  CloudflareWorkersAdapter,
+  createRuntimeAdapter,
+  createNodeHandler,
+  createEdgeHandler,
+  createLambdaHandler,
+  createWorkerHandler,
+} from "./core/runtime";
+
+// Runtime-specific types
+export type {
+  LambdaEvent,
+  LambdaContext,
+  LambdaResponse,
+} from "./core/runtime/aws-lambda-adapter";
+export type {
+  WorkersEnv,
+  WorkersContext,
+} from "./core/runtime/cloudflare-workers-adapter";
+
+// Core exports
+export { MoroHttpServer, middleware as httpMiddleware } from "./core/http";
+export {
+  builtInMiddleware,
+  simpleMiddleware,
+} from "./core/middleware/built-in";
+export { WebSocketManager } from "./core/networking";
+export { Container } from "./core/utilities";
+export { createFrameworkLogger, logger } from "./core/logger";
+
+// Validation System (Zod-based)
+export {
+  validate,
+  body,
+  query,
+  params,
+  combineSchemas,
+  z,
+} from "./core/validation";
+export type {
+  ValidationConfig,
+  ValidationResult,
+  ValidationError,
+  ValidatedRequest,
+} from "./core/validation";
+
+// Module System
+export { defineModule } from "./core/modules";
+export type {
+  ModuleDefinition,
+  ModuleRoute,
+  ModuleSocket,
+  ModuleConfig,
+} from "./types/module";
+
+// Intelligent Routing System
+export { createRoute, defineRoute, EXECUTION_PHASES } from "./core/routing";
+export {
+  IntelligentRoutingManager,
+  RouteRegistry,
+} from "./core/routing/app-integration";
+export type {
+  RouteBuilder,
+  RouteSchema,
+  CompiledRoute,
+  HttpMethod,
+  AuthConfig,
+  RateLimitConfig,
+  CacheConfig,
+  MiddlewarePhases,
+  ExecutionPhase,
+} from "./core/routing";
+
+// Additional exports if needed
+// export { Moro as MoroCore } from './core/framework';
+
+// Types
+export type * from "./types/core";
+export type * from "./types/http";
+export type * from "./types/hooks";
+export type * from "./types/cache";
+export type * from "./types/cdn";
+export type * from "./types/database";
+
+// Adapters
+export * from "./core/middleware/built-in/adapters";
+export * from "./core/database/adapters";
+
+// Re-export commonly used types for convenience
+export type { CacheAdapter, CacheOptions, CacheStrategy } from "./types/cache";
+export type { CDNAdapter, CDNOptions } from "./types/cdn";
+export type {
+  DatabaseAdapter,
+  DatabaseTransaction,
+  DatabaseConfig,
+} from "./types/database";
+export type { CookieOptions } from "./types/http";