@morojs/moro 1.0.0

package/src/core/http/index.ts

@@ -0,0 +1,11 @@
+// HTTP System - Centralized Exports
+export { MoroHttpServer, middleware } from "./http-server";
+export { Router } from "./router";
+
+// Type exports
+export type {
+  HttpRequest,
+  HttpResponse,
+  HttpHandler,
+  Middleware,
+} from "../../types/http";

package/src/core/http/router.ts

@@ -0,0 +1,153 @@
+// src/core/router.ts
+import {
+  HttpRequest,
+  HttpResponse,
+  HttpHandler,
+  Middleware,
+  RouteDefinition,
+} from "../../types/http";
+import { createFrameworkLogger } from "../logger";
+
+export class Router {
+  private routes: RouteDefinition[] = [];
+  private logger = createFrameworkLogger("Router");
+
+  get(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
+    this.addRoute("GET", path, handlers);
+  }
+
+  post(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
+    this.addRoute("POST", path, handlers);
+  }
+
+  put(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
+    this.addRoute("PUT", path, handlers);
+  }
+
+  delete(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
+    this.addRoute("DELETE", path, handlers);
+  }
+
+  patch(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
+    this.addRoute("PATCH", path, handlers);
+  }
+
+  private addRoute(
+    method: string,
+    path: string,
+    handlers: (Middleware | HttpHandler)[],
+  ): void {
+    const { pattern, paramNames } = this.pathToRegex(path);
+    const handler = handlers.pop() as HttpHandler;
+    const middleware = handlers as Middleware[];
+
+    this.routes.push({
+      method,
+      path,
+      pattern,
+      paramNames,
+      handler,
+      middleware,
+    });
+  }
+
+  private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
+    const paramNames: string[] = [];
+
+    // Convert parameterized routes to regex
+    const regexPattern = path
+      .replace(/\/:([^/]+)/g, (match, paramName) => {
+        paramNames.push(paramName);
+        return "/([^/]+)";
+      })
+      .replace(/\//g, "\\/");
+
+    return {
+      pattern: new RegExp(`^${regexPattern}$`),
+      paramNames,
+    };
+  }
+
+  async handle(
+    req: HttpRequest,
+    res: HttpResponse,
+    basePath: string = "",
+  ): Promise<boolean> {
+    let path = req.path.startsWith(basePath)
+      ? req.path.substring(basePath.length)
+      : req.path;
+
+    // If removing basePath results in empty string, default to '/'
+    if (path === "" || path === undefined) {
+      path = "/";
+    }
+
+    this.logger.debug(
+      `Router processing: originalPath="${req.path}", basePath="${basePath}", processedPath="${path}"`,
+      "Processing",
+    );
+
+    const route = this.routes.find(
+      (r) => r.method === req.method && r.pattern.test(path),
+    );
+
+    this.logger.debug(
+      `Found route: ${!!route}${route ? ` ${route.method} ${route.path}` : " none"}`,
+      "RouteMatch",
+    );
+
+    if (!route) {
+      return false; // Route not found
+    }
+
+    // Extract path parameters
+    const matches = path.match(route.pattern);
+    if (matches) {
+      req.params = {};
+      route.paramNames.forEach((name, index) => {
+        req.params[name] = matches[index + 1];
+      });
+    }
+
+    // Execute middleware
+    for (const mw of route.middleware) {
+      await new Promise<void>((resolve, reject) => {
+        let nextCalled = false;
+
+        const next = () => {
+          if (nextCalled) return;
+          nextCalled = true;
+          resolve();
+        };
+
+        try {
+          const result = mw(req, res, next);
+
+          if (result instanceof Promise) {
+            result
+              .then(() => {
+                if (!nextCalled) next();
+              })
+              .catch(reject);
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }
+
+    // Execute handler
+    const result = await route.handler(req, res);
+
+    // If handler returns data and response hasn't been sent, send it
+    if (result !== undefined && result !== null && !res.headersSent) {
+      res.json(result);
+    }
+
+    return true;
+  }
+
+  getRoutes(): RouteDefinition[] {
+    return [...this.routes];
+  }
+}

package/src/core/logger/filters.ts

@@ -0,0 +1,148 @@
+// Advanced Logger Filters
+import { LogEntry, LogFilter } from "../../types/logger";
+
+// Level-based filter
+export const levelFilter = (minLevel: string): LogFilter => ({
+  name: `level-${minLevel}`,
+  filter: (entry: LogEntry) => {
+    const levels = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 };
+    return levels[entry.level] >= levels[minLevel as keyof typeof levels];
+  },
+});
+
+// Context-based filter
+export const contextFilter = (allowedContexts: string[]): LogFilter => ({
+  name: "context-filter",
+  filter: (entry: LogEntry) => {
+    if (!entry.context) return true;
+    return allowedContexts.some((ctx) => entry.context!.includes(ctx));
+  },
+});
+
+// Rate limiting filter
+export const rateLimitFilter = (maxPerSecond: number): LogFilter => {
+  const timestamps: number[] = [];
+
+  return {
+    name: "rate-limit",
+    filter: (entry: LogEntry) => {
+      const now = Date.now();
+      const oneSecondAgo = now - 1000;
+
+      // Remove old timestamps
+      while (timestamps.length > 0 && timestamps[0] < oneSecondAgo) {
+        timestamps.shift();
+      }
+
+      // Check rate limit
+      if (timestamps.length >= maxPerSecond) {
+        return false;
+      }
+
+      timestamps.push(now);
+      return true;
+    },
+  };
+};
+
+// Sensitive data filter
+export const sanitizeFilter = (
+  sensitiveKeys: string[] = ["password", "token", "key", "secret"],
+): LogFilter => ({
+  name: "sanitize",
+  filter: (entry: LogEntry) => {
+    if (entry.metadata) {
+      const sanitized = { ...entry.metadata };
+
+      for (const key of sensitiveKeys) {
+        if (sanitized[key]) {
+          sanitized[key] = "[REDACTED]";
+        }
+      }
+
+      entry.metadata = sanitized;
+    }
+
+    // Also sanitize message content
+    let sanitizedMessage = entry.message;
+    for (const key of sensitiveKeys) {
+      const regex = new RegExp(`(${key}["\\s]*[:=]["\\s]*)([^"\\s]+)`, "gi");
+      sanitizedMessage = sanitizedMessage.replace(regex, "$1[REDACTED]");
+    }
+    entry.message = sanitizedMessage;
+
+    return true;
+  },
+});
+
+// Performance filter - only log slow operations
+export const performanceFilter = (minDuration: number): LogFilter => ({
+  name: "performance",
+  filter: (entry: LogEntry) => {
+    if (!entry.performance?.duration) return true;
+    return entry.performance.duration >= minDuration;
+  },
+});
+
+// Error aggregation filter - prevent spam
+export const errorAggregationFilter = (
+  maxSameErrors: number = 5,
+  timeWindow: number = 60000,
+): LogFilter => {
+  const errorCounts = new Map<string, { count: number; firstSeen: number }>();
+
+  return {
+    name: "error-aggregation",
+    filter: (entry: LogEntry) => {
+      if (entry.level !== "error" && entry.level !== "fatal") return true;
+
+      const errorKey = `${entry.message}:${entry.context || ""}`;
+      const now = Date.now();
+      const existing = errorCounts.get(errorKey);
+
+      if (!existing) {
+        errorCounts.set(errorKey, { count: 1, firstSeen: now });
+        return true;
+      }
+
+      // Reset if outside time window
+      if (now - existing.firstSeen > timeWindow) {
+        errorCounts.set(errorKey, { count: 1, firstSeen: now });
+        return true;
+      }
+
+      // Check if we've exceeded the limit
+      if (existing.count >= maxSameErrors) {
+        return false;
+      }
+
+      existing.count++;
+      return true;
+    },
+  };
+};
+
+// Development vs Production filter
+export const environmentFilter = (
+  environment: "development" | "production",
+): LogFilter => ({
+  name: `env-${environment}`,
+  filter: (entry: LogEntry) => {
+    if (environment === "production") {
+      // In production, filter out debug logs and sensitive development info
+      if (entry.level === "debug") return false;
+      if (entry.context?.includes("dev") || entry.context?.includes("test"))
+        return false;
+    }
+    return true;
+  },
+});
+
+// Module-specific filter
+export const moduleFilter = (allowedModules: string[]): LogFilter => ({
+  name: "module-filter",
+  filter: (entry: LogEntry) => {
+    if (!entry.moduleId) return true;
+    return allowedModules.includes(entry.moduleId);
+  },
+});

package/src/core/logger/index.ts

@@ -0,0 +1,20 @@
+// Logger System - Main Exports
+export {
+  MoroLogger,
+  logger,
+  createFrameworkLogger,
+  configureGlobalLogger,
+  applyLoggingConfiguration,
+} from "./logger";
+export * from "./filters";
+
+export type {
+  LogLevel,
+  LogEntry,
+  LoggerOptions,
+  Logger,
+  LogOutput,
+  LogFilter,
+  LogMetrics,
+  ColorScheme,
+} from "../../types/logger";