@morojs/moro 1.6.1 → 1.6.3

package/src/core/http/index.ts

@@ -1,6 +0,0 @@
-// 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

@@ -1,141 +0,0 @@
-// 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

@@ -1,145 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-// 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';