@morojs/moro 1.0.0

package/src/core/middleware/built-in/error-tracker.ts

@@ -0,0 +1,16 @@
+// Error tracking middleware
+import { createFrameworkLogger } from "../../logger";
+
+const logger = createFrameworkLogger("ErrorTracker");
+
+export const errorTracker = async (context: any): Promise<void> => {
+  context.onError = (error: Error) => {
+    logger.error("Request error", "ErrorTracking", {
+      error: error.message,
+      stack: error.stack,
+      url: context.request?.url,
+      method: context.request?.method,
+      timestamp: new Date().toISOString(),
+    });
+  };
+};

package/src/core/middleware/built-in/index.ts

@@ -0,0 +1,57 @@
+// Built-in Middleware Exports
+export { auth } from "./auth";
+export { rateLimit } from "./rate-limit";
+export { cors } from "./cors";
+export { validation } from "./validation";
+export { requestLogger } from "./request-logger";
+export { performanceMonitor } from "./performance-monitor";
+export { errorTracker } from "./error-tracker";
+
+// Advanced Security & Performance Middleware
+export { cookie } from "./cookie";
+export { csrf } from "./csrf";
+export { csp } from "./csp";
+export { sse } from "./sse";
+export { session } from "./session";
+
+// Clean Architecture Middleware
+export { cache } from "./cache";
+export { cdn } from "./cdn";
+
+// Import for collections
+import { auth } from "./auth";
+import { rateLimit } from "./rate-limit";
+import { cors } from "./cors";
+import { validation } from "./validation";
+import { requestLogger } from "./request-logger";
+import { performanceMonitor } from "./performance-monitor";
+import { errorTracker } from "./error-tracker";
+import { cookie } from "./cookie";
+import { csrf } from "./csrf";
+import { csp } from "./csp";
+import { sse } from "./sse";
+import { session } from "./session";
+import { cache } from "./cache";
+import { cdn } from "./cdn";
+
+export const builtInMiddleware = {
+  auth,
+  rateLimit,
+  cors,
+  validation,
+  // Advanced middleware
+  cookie,
+  csrf,
+  csp,
+  sse,
+  session,
+  // Clean architecture middleware
+  cache,
+  cdn,
+};
+
+export const simpleMiddleware = {
+  requestLogger,
+  performanceMonitor,
+  errorTracker,
+};

package/src/core/middleware/built-in/performance-monitor.ts

@@ -0,0 +1,25 @@
+// Performance monitoring middleware
+import { createFrameworkLogger } from "../../logger";
+
+const logger = createFrameworkLogger("PerformanceMonitor");
+
+export const performanceMonitor = async (context: any): Promise<void> => {
+  const startTime = Date.now();
+
+  context.onComplete = () => {
+    const duration = Date.now() - startTime;
+
+    // Log slow requests
+    if (duration > 1000) {
+      logger.warn(
+        `Slow request detected: ${context.request?.path} took ${duration}ms`,
+        "SlowRequest",
+        {
+          path: context.request?.path,
+          method: context.request?.method,
+          duration,
+        },
+      );
+    }
+  };
+};

package/src/core/middleware/built-in/rate-limit.ts

@@ -0,0 +1,60 @@
+// Rate Limiting Middleware
+import { MiddlewareInterface, HookContext } from "../../../types/hooks";
+import { createFrameworkLogger } from "../../logger";
+
+const logger = createFrameworkLogger("RateLimitMiddleware");
+
+export const rateLimit = (
+  options: {
+    windowMs?: number;
+    max?: number;
+    message?: string;
+  } = {},
+): MiddlewareInterface => ({
+  name: "rate-limit",
+  version: "1.0.0",
+  metadata: {
+    name: "rate-limit",
+    version: "1.0.0",
+    description: "Rate limiting middleware with configurable windows",
+    author: "MoroJS Team",
+  },
+
+  install: async (hooks: any, options: any = {}) => {
+    logger.debug("Installing rate limit middleware", "Installation", {
+      options,
+    });
+
+    const windowMs = options.windowMs || 60000; // 1 minute default
+    const max = options.max || 100; // 100 requests per window
+    const clientCounts = new Map();
+
+    hooks.before("request", async (context: HookContext) => {
+      const req = context.request as any;
+      const clientId = req.connection?.remoteAddress || "unknown";
+      const now = Date.now();
+
+      if (!clientCounts.has(clientId)) {
+        clientCounts.set(clientId, { count: 0, resetTime: now + windowMs });
+      }
+
+      const client = clientCounts.get(clientId);
+
+      if (now > client.resetTime) {
+        client.count = 0;
+        client.resetTime = now + windowMs;
+      }
+
+      client.count++;
+
+      if (client.count > max) {
+        logger.warn(`Rate limit exceeded for ${clientId}`, "RateLimit", {
+          clientId,
+          count: client.count,
+          max,
+        });
+        throw new Error(options.message || "Too many requests");
+      }
+    });
+  },
+});

package/src/core/middleware/built-in/request-logger.ts

@@ -0,0 +1,14 @@
+// Simple request logging middleware
+export const requestLogger = async (context: any): Promise<void> => {
+  const startTime = Date.now();
+
+  console.log(
+    `[${new Date().toISOString()}] ${context.request?.method} ${context.request?.path}`,
+  );
+
+  // Log completion after response
+  context.onComplete = () => {
+    const duration = Date.now() - startTime;
+    console.log(`Request completed in ${duration}ms`);
+  };
+};

package/src/core/middleware/built-in/session.ts

@@ -0,0 +1,311 @@
+// Session Middleware
+import { MiddlewareInterface, HookContext } from "../../../types/hooks";
+import { createFrameworkLogger } from "../../logger";
+import { CacheAdapter } from "../../../types/cache";
+import { MemoryCacheAdapter } from "./adapters/cache/memory";
+import { RedisCacheAdapter } from "./adapters/cache/redis";
+import { FileCacheAdapter } from "./adapters/cache/file";
+
+const logger = createFrameworkLogger("SessionMiddleware");
+
+export interface SessionOptions {
+  // Session store configuration
+  store?: "memory" | "redis" | "file" | CacheAdapter;
+  storeOptions?: {
+    // Redis options
+    host?: string;
+    port?: number;
+    password?: string;
+    keyPrefix?: string;
+    // File options
+    path?: string;
+    // Memory options
+    max?: number;
+  };
+
+  // Session configuration
+  secret?: string;
+  name?: string; // Session cookie name
+  genid?: () => string; // Session ID generator
+  rolling?: boolean; // Reset expiry on each request
+  resave?: boolean; // Save session even if not modified
+  saveUninitialized?: boolean; // Save new but not modified sessions
+
+  // Cookie configuration
+  cookie?: {
+    maxAge?: number; // Session timeout in ms
+    expires?: Date; // Absolute expiry
+    httpOnly?: boolean; // Prevent XSS access
+    secure?: boolean; // HTTPS only
+    sameSite?: "strict" | "lax" | "none";
+    domain?: string;
+    path?: string;
+  };
+
+  // Security
+  proxy?: boolean; // Trust proxy for secure cookies
+  unset?: "destroy" | "keep"; // What to do when session is unset
+}
+
+export interface SessionData {
+  [key: string]: any;
+  cookie?: {
+    originalMaxAge?: number;
+    expires?: Date;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: string;
+  };
+}
+
+class Session {
+  private data: SessionData = {};
+  private id: string;
+  private store: CacheAdapter;
+  private options: SessionOptions;
+  private isNew: boolean = false;
+  private isModified: boolean = false;
+
+  constructor(
+    id: string,
+    store: CacheAdapter,
+    options: SessionOptions,
+    isNew: boolean = false,
+  ) {
+    this.id = id;
+    this.store = store;
+    this.options = options;
+    this.isNew = isNew;
+  }
+
+  // Proxy to make session.prop = value work
+  static create(
+    id: string,
+    store: CacheAdapter,
+    options: SessionOptions,
+    data: SessionData = {},
+    isNew: boolean = false,
+  ): Session {
+    const session = new Session(id, store, options, isNew);
+    session.data = data;
+
+    return new Proxy(session, {
+      get(target, prop) {
+        if (prop in target) {
+          return target[prop as keyof Session];
+        }
+        return target.data[prop as string];
+      },
+
+      set(target, prop, value) {
+        if (prop in target) {
+          (target as any)[prop] = value;
+        } else {
+          target.data[prop as string] = value;
+          target.isModified = true;
+        }
+        return true;
+      },
+
+      has(target, prop) {
+        return prop in target || prop in target.data;
+      },
+
+      deleteProperty(target, prop) {
+        if (prop in target.data) {
+          delete target.data[prop as string];
+          target.isModified = true;
+          return true;
+        }
+        return false;
+      },
+    });
+  }
+
+  async save(): Promise<void> {
+    if (this.isModified || this.isNew || this.options.resave) {
+      const ttl = this.options.cookie?.maxAge
+        ? Math.floor(this.options.cookie.maxAge / 1000)
+        : 86400; // 24h default
+      await this.store.set(this.id, this.data, ttl);
+      this.isModified = false;
+      this.isNew = false;
+      logger.debug(`Session saved: ${this.id}`, "SessionSave");
+    }
+  }
+
+  async destroy(): Promise<void> {
+    await this.store.del(this.id);
+    this.data = {};
+    this.isModified = false;
+    logger.debug(`Session destroyed: ${this.id}`, "SessionDestroy");
+  }
+
+  async regenerate(): Promise<string> {
+    await this.destroy();
+    this.id = this.generateId();
+    this.isNew = true;
+    this.isModified = true;
+    logger.debug(`Session regenerated: ${this.id}`, "SessionRegenerate");
+    return this.id;
+  }
+
+  async touch(): Promise<void> {
+    if (this.options.rolling) {
+      this.isModified = true;
+      await this.save();
+    }
+  }
+
+  private generateId(): string {
+    if (this.options.genid) {
+      return this.options.genid();
+    }
+
+    const crypto = require("crypto");
+    return crypto.randomBytes(24).toString("hex");
+  }
+
+  get sessionID(): string {
+    return this.id;
+  }
+}
+
+export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
+  name: "session",
+  version: "1.0.0",
+  metadata: {
+    name: "session",
+    version: "1.0.0",
+    description: "Session management middleware with multiple store adapters",
+    author: "MoroJS Team",
+  },
+
+  install: async (hooks: any, middlewareOptions: any = {}) => {
+    logger.debug("Installing session middleware", "Installation");
+
+    // Merge options
+    const config: SessionOptions = {
+      store: "memory",
+      name: "connect.sid",
+      secret: "moro-session-secret",
+      rolling: false,
+      resave: false,
+      saveUninitialized: false,
+      cookie: {
+        maxAge: 24 * 60 * 60 * 1000, // 24 hours
+        httpOnly: true,
+        secure: false,
+        sameSite: "lax",
+        path: "/",
+      },
+      unset: "keep",
+      ...options,
+      ...middlewareOptions,
+    };
+
+    // Initialize store
+    let store: CacheAdapter;
+
+    if (typeof config.store === "string") {
+      switch (config.store) {
+        case "redis":
+          store = new RedisCacheAdapter({
+            keyPrefix: "sess:",
+            ...config.storeOptions,
+          });
+          break;
+        case "file":
+          store = new FileCacheAdapter({
+            cacheDir: config.storeOptions?.path || "./sessions",
+          });
+          break;
+        case "memory":
+        default:
+          store = new MemoryCacheAdapter();
+          break;
+      }
+    } else {
+      store = config.store as CacheAdapter;
+    }
+
+    // Generate session ID
+    const generateSessionId = (): string => {
+      if (config.genid) {
+        return config.genid();
+      }
+      const crypto = require("crypto");
+      return crypto.randomBytes(24).toString("hex");
+    };
+
+    hooks.before("request", async (context: HookContext) => {
+      const req = context.request as any;
+      const res = context.response as any;
+
+      // Get session ID from cookie
+      let sessionId = req.cookies?.[config.name!];
+      let sessionData: SessionData = {};
+      let isNew = false;
+
+      if (sessionId) {
+        try {
+          sessionData = (await store.get(sessionId)) || {};
+          logger.debug(`Session loaded: ${sessionId}`, "SessionLoad");
+        } catch (error) {
+          logger.warn(
+            `Failed to load session: ${sessionId}`,
+            "SessionLoadError",
+            { error },
+          );
+          sessionId = generateSessionId();
+          isNew = true;
+        }
+      } else {
+        sessionId = generateSessionId();
+        isNew = true;
+      }
+
+      // Create session object
+      req.session = Session.create(
+        sessionId,
+        store,
+        config,
+        sessionData,
+        isNew,
+      );
+
+      // Set session cookie
+      if (isNew || config.rolling) {
+        res.cookie(config.name!, sessionId, {
+          ...config.cookie,
+          secure:
+            config.cookie?.secure ||
+            (config.proxy && req.headers["x-forwarded-proto"] === "https"),
+        });
+      }
+    });
+
+    hooks.after("response", async (context: HookContext) => {
+      const req = context.request as any;
+
+      if (req.session) {
+        try {
+          if (
+            config.saveUninitialized ||
+            !req.session.isNew ||
+            req.session.isModified
+          ) {
+            await req.session.save();
+          }
+        } catch (error) {
+          logger.error("Failed to save session", "SessionSaveError", { error });
+        }
+      }
+    });
+
+    logger.info(
+      `Session middleware installed with ${config.store} store`,
+      "Installation",
+    );
+  },
+});

package/src/core/middleware/built-in/sse.ts

@@ -0,0 +1,91 @@
+// Server-Sent Events Middleware
+import { MiddlewareInterface, HookContext } from "../../../types/hooks";
+import { createFrameworkLogger } from "../../logger";
+
+const logger = createFrameworkLogger("SSEMiddleware");
+
+export const sse = (
+  options: {
+    heartbeat?: number;
+    retry?: number;
+    cors?: boolean;
+  } = {},
+): MiddlewareInterface => ({
+  name: "sse",
+  version: "1.0.0",
+  metadata: {
+    name: "sse",
+    version: "1.0.0",
+    description:
+      "Server-Sent Events middleware with heartbeat and retry support",
+    author: "MoroJS Team",
+  },
+
+  install: async (hooks: any, middlewareOptions: any = {}) => {
+    logger.debug("Installing SSE middleware", "Installation");
+
+    hooks.before("request", async (context: HookContext) => {
+      const req = context.request as any;
+      const res = context.response as any;
+
+      // Only handle SSE requests
+      if (!req.headers.accept?.includes("text/event-stream")) {
+        return;
+      }
+
+      logger.debug("Setting up SSE connection", "SSESetup");
+
+      // Set SSE headers
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": options.cors ? "*" : undefined,
+        "Access-Control-Allow-Headers": options.cors
+          ? "Cache-Control"
+          : undefined,
+      });
+
+      // Add SSE methods to response
+      res.sendEvent = (data: any, event?: string, id?: string) => {
+        if (id) res.write(`id: ${id}\n`);
+        if (event) res.write(`event: ${event}\n`);
+        res.write(
+          `data: ${typeof data === "string" ? data : JSON.stringify(data)}\n\n`,
+        );
+      };
+
+      res.sendComment = (comment: string) => {
+        res.write(`: ${comment}\n\n`);
+      };
+
+      res.sendRetry = (ms: number) => {
+        res.write(`retry: ${ms}\n\n`);
+      };
+
+      // Set up heartbeat if configured
+      let heartbeatInterval: NodeJS.Timeout | null = null;
+      if (options.heartbeat) {
+        heartbeatInterval = setInterval(() => {
+          res.sendComment("heartbeat");
+        }, options.heartbeat);
+      }
+
+      // Set retry if configured
+      if (options.retry) {
+        res.sendRetry(options.retry);
+      }
+
+      // Clean up on close
+      req.on("close", () => {
+        if (heartbeatInterval) {
+          clearInterval(heartbeatInterval);
+        }
+        logger.debug("SSE connection closed", "SSECleanup");
+      });
+
+      // Mark that this middleware handled the request
+      (context as any).handled = true;
+    });
+  },
+});

package/src/core/middleware/built-in/validation.ts

@@ -0,0 +1,33 @@
+// Validation Middleware
+import { MiddlewareInterface, HookContext } from "../../../types/hooks";
+import { createFrameworkLogger } from "../../logger";
+
+const logger = createFrameworkLogger("ValidationMiddleware");
+
+export const validation = (): MiddlewareInterface => ({
+  name: "validation",
+  version: "1.0.0",
+  metadata: {
+    name: "validation",
+    version: "1.0.0",
+    description: "Request validation middleware with content type checking",
+    author: "MoroJS Team",
+  },
+
+  install: async (hooks: any, options: any = {}) => {
+    logger.debug("Installing validation middleware", "Installation");
+
+    hooks.before("request", async (context: HookContext) => {
+      const request = context.request as any;
+
+      // Basic content type validation
+      if (request.method === "POST" || request.method === "PUT") {
+        const contentType = request.headers["content-type"];
+        if (contentType && contentType.includes("application/json")) {
+          logger.debug("Validation: JSON content type verified", "ContentType");
+          // Additional validation logic would go here
+        }
+      }
+    });
+  },
+});