@morojs/moro 1.0.0 → 1.0.1

package/src/core/http/index.ts

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

package/src/core/http/router.ts

@@ -5,38 +5,34 @@ import {
   HttpHandler,
   Middleware,
   RouteDefinition,
-} from "../../types/http";
-import { createFrameworkLogger } from "../logger";
+} from '../../types/http';
+import { createFrameworkLogger } from '../logger';
 
 export class Router {
   private routes: RouteDefinition[] = [];
-  private logger = createFrameworkLogger("Router");
+  private logger = createFrameworkLogger('Router');
 
   get(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute("GET", path, handlers);
+    this.addRoute('GET', path, handlers);
   }
 
   post(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute("POST", path, handlers);
+    this.addRoute('POST', path, handlers);
   }
 
   put(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute("PUT", path, handlers);
+    this.addRoute('PUT', path, handlers);
   }
 
   delete(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute("DELETE", path, handlers);
+    this.addRoute('DELETE', path, handlers);
   }
 
   patch(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute("PATCH", path, handlers);
+    this.addRoute('PATCH', path, handlers);
   }
 
-  private addRoute(
-    method: string,
-    path: string,
-    handlers: (Middleware | HttpHandler)[],
-  ): void {
+  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[];
@@ -58,9 +54,9 @@ export class Router {
     const regexPattern = path
       .replace(/\/:([^/]+)/g, (match, paramName) => {
         paramNames.push(paramName);
-        return "/([^/]+)";
+        return '/([^/]+)';
       })
-      .replace(/\//g, "\\/");
+      .replace(/\//g, '\\/');
 
     return {
       pattern: new RegExp(`^${regexPattern}$`),
@@ -68,32 +64,24 @@ export class Router {
     };
   }
 
-  async handle(
-    req: HttpRequest,
-    res: HttpResponse,
-    basePath: string = "",
-  ): Promise<boolean> {
-    let path = req.path.startsWith(basePath)
-      ? req.path.substring(basePath.length)
-      : req.path;
+  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 = "/";
+    if (path === '' || path === undefined) {
+      path = '/';
     }
 
     this.logger.debug(
       `Router processing: originalPath="${req.path}", basePath="${basePath}", processedPath="${path}"`,
-      "Processing",
+      'Processing'
     );
 
-    const route = this.routes.find(
-      (r) => r.method === req.method && r.pattern.test(path),
-    );
+    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",
+      `Found route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
+      'RouteMatch'
     );
 
     if (!route) {

package/src/core/logger/filters.ts

@@ -1,5 +1,5 @@
 // Advanced Logger Filters
-import { LogEntry, LogFilter } from "../../types/logger";
+import { LogEntry, LogFilter } from '../../types/logger';
 
 // Level-based filter
 export const levelFilter = (minLevel: string): LogFilter => ({
@@ -12,10 +12,10 @@ export const levelFilter = (minLevel: string): LogFilter => ({
 
 // Context-based filter
 export const contextFilter = (allowedContexts: string[]): LogFilter => ({
-  name: "context-filter",
+  name: 'context-filter',
   filter: (entry: LogEntry) => {
     if (!entry.context) return true;
-    return allowedContexts.some((ctx) => entry.context!.includes(ctx));
+    return allowedContexts.some(ctx => entry.context!.includes(ctx));
   },
 });
 
@@ -24,7 +24,7 @@ export const rateLimitFilter = (maxPerSecond: number): LogFilter => {
   const timestamps: number[] = [];
 
   return {
-    name: "rate-limit",
+    name: 'rate-limit',
     filter: (entry: LogEntry) => {
       const now = Date.now();
       const oneSecondAgo = now - 1000;
@@ -47,16 +47,16 @@ export const rateLimitFilter = (maxPerSecond: number): LogFilter => {
 
 // Sensitive data filter
 export const sanitizeFilter = (
-  sensitiveKeys: string[] = ["password", "token", "key", "secret"],
+  sensitiveKeys: string[] = ['password', 'token', 'key', 'secret']
 ): LogFilter => ({
-  name: "sanitize",
+  name: 'sanitize',
   filter: (entry: LogEntry) => {
     if (entry.metadata) {
       const sanitized = { ...entry.metadata };
 
       for (const key of sensitiveKeys) {
         if (sanitized[key]) {
-          sanitized[key] = "[REDACTED]";
+          sanitized[key] = '[REDACTED]';
         }
       }
 
@@ -66,8 +66,8 @@ export const sanitizeFilter = (
     // 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]");
+      const regex = new RegExp(`(${key}["\\s]*[:=]["\\s]*)([^"\\s]+)`, 'gi');
+      sanitizedMessage = sanitizedMessage.replace(regex, '$1[REDACTED]');
     }
     entry.message = sanitizedMessage;
 
@@ -77,7 +77,7 @@ export const sanitizeFilter = (
 
 // Performance filter - only log slow operations
 export const performanceFilter = (minDuration: number): LogFilter => ({
-  name: "performance",
+  name: 'performance',
   filter: (entry: LogEntry) => {
     if (!entry.performance?.duration) return true;
     return entry.performance.duration >= minDuration;
@@ -87,16 +87,16 @@ export const performanceFilter = (minDuration: number): LogFilter => ({
 // Error aggregation filter - prevent spam
 export const errorAggregationFilter = (
   maxSameErrors: number = 5,
-  timeWindow: number = 60000,
+  timeWindow: number = 60000
 ): LogFilter => {
   const errorCounts = new Map<string, { count: number; firstSeen: number }>();
 
   return {
-    name: "error-aggregation",
+    name: 'error-aggregation',
     filter: (entry: LogEntry) => {
-      if (entry.level !== "error" && entry.level !== "fatal") return true;
+      if (entry.level !== 'error' && entry.level !== 'fatal') return true;
 
-      const errorKey = `${entry.message}:${entry.context || ""}`;
+      const errorKey = `${entry.message}:${entry.context || ''}`;
       const now = Date.now();
       const existing = errorCounts.get(errorKey);
 
@@ -123,16 +123,13 @@ export const errorAggregationFilter = (
 };
 
 // Development vs Production filter
-export const environmentFilter = (
-  environment: "development" | "production",
-): LogFilter => ({
+export const environmentFilter = (environment: 'development' | 'production'): LogFilter => ({
   name: `env-${environment}`,
   filter: (entry: LogEntry) => {
-    if (environment === "production") {
+    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;
+      if (entry.level === 'debug') return false;
+      if (entry.context?.includes('dev') || entry.context?.includes('test')) return false;
     }
     return true;
   },
@@ -140,7 +137,7 @@ export const environmentFilter = (
 
 // Module-specific filter
 export const moduleFilter = (allowedModules: string[]): LogFilter => ({
-  name: "module-filter",
+  name: 'module-filter',
   filter: (entry: LogEntry) => {
     if (!entry.moduleId) return true;
     return allowedModules.includes(entry.moduleId);

package/src/core/logger/index.ts

@@ -5,8 +5,8 @@ export {
   createFrameworkLogger,
   configureGlobalLogger,
   applyLoggingConfiguration,
-} from "./logger";
-export * from "./filters";
+} from './logger';
+export * from './filters';
 
 export type {
   LogLevel,
@@ -17,4 +17,4 @@ export type {
   LogFilter,
   LogMetrics,
   ColorScheme,
-} from "../../types/logger";
+} from '../../types/logger';

package/src/core/logger/logger.ts

@@ -1,5 +1,5 @@
 // Moro Logger - Beautiful, Fast, Feature-Rich
-import { performance } from "perf_hooks";
+import { performance } from 'perf_hooks';
 import {
   LogLevel,
   LogEntry,
@@ -9,10 +9,10 @@ import {
   LogFilter,
   LogMetrics,
   ColorScheme,
-} from "../../types/logger";
+} from '../../types/logger';
 
 export class MoroLogger implements Logger {
-  private level: LogLevel = "info";
+  private level: LogLevel = 'info';
   private options: LoggerOptions;
   private outputs: Map<string, LogOutput> = new Map();
   private filters: Map<string, LogFilter> = new Map();
@@ -39,108 +39,84 @@ export class MoroLogger implements Logger {
   };
 
   private static readonly COLORS: ColorScheme = {
-    debug: "\x1b[36m", // Cyan
-    info: "\x1b[32m", // Green
-    warn: "\x1b[33m", // Yellow
-    error: "\x1b[31m", // Red
-    fatal: "\x1b[35m", // Magenta
-    timestamp: "\x1b[90m", // Gray
-    context: "\x1b[34m", // Blue
-    metadata: "\x1b[37m", // White
-    performance: "\x1b[36m", // Cyan
+    debug: '\x1b[36m', // Cyan
+    info: '\x1b[32m', // Green
+    warn: '\x1b[33m', // Yellow
+    error: '\x1b[31m', // Red
+    fatal: '\x1b[35m', // Magenta
+    timestamp: '\x1b[90m', // Gray
+    context: '\x1b[34m', // Blue
+    metadata: '\x1b[37m', // White
+    performance: '\x1b[36m', // Cyan
   };
 
-  private static readonly RESET = "\x1b[0m";
-  private static readonly BOLD = "\x1b[1m";
+  private static readonly RESET = '\x1b[0m';
+  private static readonly BOLD = '\x1b[1m';
 
   constructor(options: LoggerOptions = {}) {
     this.options = {
-      level: "info",
+      level: 'info',
       enableColors: true,
       enableTimestamp: true,
       enableContext: true,
       enableMetadata: true,
       enablePerformance: true,
-      format: "pretty",
+      format: 'pretty',
       outputs: [],
       filters: [],
       maxEntries: 1000,
       ...options,
     };
 
-    this.level = this.options.level || "info";
+    this.level = this.options.level || 'info';
 
     // Add default console output
     this.addOutput({
-      name: "console",
+      name: 'console',
       write: this.writeToConsole.bind(this),
       format: this.options.format,
     });
 
     // Add custom outputs
-    this.options.outputs?.forEach((output) => this.addOutput(output));
-    this.options.filters?.forEach((filter) => this.addFilter(filter));
+    this.options.outputs?.forEach(output => this.addOutput(output));
+    this.options.filters?.forEach(filter => this.addFilter(filter));
   }
 
-  debug(
-    message: string,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void {
-    this.log("debug", message, context, metadata);
+  debug(message: string, context?: string, metadata?: Record<string, any>): void {
+    this.log('debug', message, context, metadata);
   }
 
-  info(
-    message: string,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void {
-    this.log("info", message, context, metadata);
+  info(message: string, context?: string, metadata?: Record<string, any>): void {
+    this.log('info', message, context, metadata);
   }
 
-  warn(
-    message: string,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void {
-    this.log("warn", message, context, metadata);
+  warn(message: string, context?: string, metadata?: Record<string, any>): void {
+    this.log('warn', message, context, metadata);
   }
 
-  error(
-    message: string | Error,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void {
+  error(message: string | Error, context?: string, metadata?: Record<string, any>): void {
     const msg = message instanceof Error ? message.message : message;
     const stack = message instanceof Error ? message.stack : undefined;
-    this.log("error", msg, context, { ...metadata, stack });
+    this.log('error', msg, context, { ...metadata, stack });
   }
 
-  fatal(
-    message: string | Error,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void {
+  fatal(message: string | Error, context?: string, metadata?: Record<string, any>): void {
     const msg = message instanceof Error ? message.message : message;
     const stack = message instanceof Error ? message.stack : undefined;
-    this.log("fatal", msg, context, { ...metadata, stack });
+    this.log('fatal', msg, context, { ...metadata, stack });
   }
 
   time(label: string): void {
     this.timers.set(label, performance.now());
   }
 
-  timeEnd(
-    label: string,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void {
+  timeEnd(label: string, context?: string, metadata?: Record<string, any>): void {
     const startTime = this.timers.get(label);
     if (startTime !== undefined) {
       const duration = performance.now() - startTime;
       this.timers.delete(label);
 
-      this.log("info", `Timer: ${label}`, context, {
+      this.log('info', `Timer: ${label}`, context, {
         ...metadata,
         performance: { duration: Math.round(duration * 100) / 100 },
       });
@@ -149,9 +125,7 @@ export class MoroLogger implements Logger {
 
   child(context: string, metadata?: Record<string, any>): Logger {
     const childLogger = new MoroLogger(this.options);
-    childLogger.contextPrefix = this.contextPrefix
-      ? `${this.contextPrefix}:${context}`
-      : context;
+    childLogger.contextPrefix = this.contextPrefix ? `${this.contextPrefix}:${context}` : context;
     childLogger.contextMetadata = { ...this.contextMetadata, ...metadata };
     childLogger.outputs = this.outputs;
     childLogger.filters = this.filters;
@@ -187,12 +161,8 @@ export class MoroLogger implements Logger {
     const now = Date.now();
     const uptime = (now - this.startTime) / 1000; // seconds
     const avgRate = uptime > 0 ? this.metrics.totalLogs / uptime : 0;
-    const errorCount =
-      this.metrics.logsByLevel.error + this.metrics.logsByLevel.fatal;
-    const errorRate =
-      this.metrics.totalLogs > 0
-        ? (errorCount / this.metrics.totalLogs) * 100
-        : 0;
+    const errorCount = this.metrics.logsByLevel.error + this.metrics.logsByLevel.fatal;
+    const errorRate = this.metrics.totalLogs > 0 ? (errorCount / this.metrics.totalLogs) * 100 : 0;
 
     return {
       ...this.metrics,
@@ -218,7 +188,7 @@ export class MoroLogger implements Logger {
     level: LogLevel,
     message: string,
     context?: string,
-    metadata?: Record<string, any>,
+    metadata?: Record<string, any>
   ): void {
     // Check level threshold
     if (MoroLogger.LEVELS[level] < MoroLogger.LEVELS[this.level]) {
@@ -261,14 +231,11 @@ export class MoroLogger implements Logger {
 
     // Write to outputs
     for (const output of this.outputs.values()) {
-      if (
-        !output.level ||
-        MoroLogger.LEVELS[level] >= MoroLogger.LEVELS[output.level]
-      ) {
+      if (!output.level || MoroLogger.LEVELS[level] >= MoroLogger.LEVELS[output.level]) {
         try {
           output.write(entry);
         } catch (error) {
-          console.error("Logger output error:", error);
+          console.error('Logger output error:', error);
         }
       }
     }
@@ -285,16 +252,16 @@ export class MoroLogger implements Logger {
   }
 
   private writeToConsole(entry: LogEntry): void {
-    const format = this.options.format || "pretty";
+    const format = this.options.format || 'pretty';
 
-    if (format === "json") {
+    if (format === 'json') {
       console.log(JSON.stringify(entry));
       return;
     }
 
-    if (format === "compact") {
+    if (format === 'compact') {
       const level = entry.level.toUpperCase().padEnd(5);
-      const context = entry.context ? `[${entry.context}] ` : "";
+      const context = entry.context ? `[${entry.context}] ` : '';
       console.log(`${level} ${context}${entry.message}`);
       return;
     }
@@ -309,26 +276,21 @@ export class MoroLogger implements Logger {
 
     // Timestamp
     if (this.options.enableTimestamp !== false) {
-      const timestamp = entry.timestamp
-        .toISOString()
-        .replace("T", " ")
-        .slice(0, 19);
+      const timestamp = entry.timestamp.toISOString().replace('T', ' ').slice(0, 19);
       parts.push(
-        colors
-          ? `${MoroLogger.COLORS.timestamp}${timestamp}${MoroLogger.RESET}`
-          : timestamp,
+        colors ? `${MoroLogger.COLORS.timestamp}${timestamp}${MoroLogger.RESET}` : timestamp
       );
     }
 
     // Level with color (remove icons)
-    const levelColor = colors ? MoroLogger.COLORS[entry.level] : "";
-    const levelReset = colors ? MoroLogger.RESET : "";
+    const levelColor = colors ? MoroLogger.COLORS[entry.level] : '';
+    const levelReset = colors ? MoroLogger.RESET : '';
     const levelText = entry.level.toUpperCase();
     parts.push(`${levelColor}${MoroLogger.BOLD}${levelText}${levelReset}`);
 
     // Context
     if (entry.context && this.options.enableContext !== false) {
-      const contextColor = colors ? MoroLogger.COLORS.context : "";
+      const contextColor = colors ? MoroLogger.COLORS.context : '';
       parts.push(`${contextColor}[${entry.context}]${levelReset}`);
     }
 
@@ -337,7 +299,7 @@ export class MoroLogger implements Logger {
 
     // Performance info
     if (entry.performance && this.options.enablePerformance !== false) {
-      const perfColor = colors ? MoroLogger.COLORS.performance : "";
+      const perfColor = colors ? MoroLogger.COLORS.performance : '';
       const perfParts: string[] = [];
 
       if (entry.performance.duration !== undefined) {
@@ -348,7 +310,7 @@ export class MoroLogger implements Logger {
       }
 
       if (perfParts.length > 0) {
-        parts.push(`${perfColor}(${perfParts.join(", ")})${levelReset}`);
+        parts.push(`${perfColor}(${perfParts.join(', ')})${levelReset}`);
       }
     }
 
@@ -358,7 +320,7 @@ export class MoroLogger implements Logger {
       Object.keys(entry.metadata).length > 0 &&
       this.options.enableMetadata !== false
     ) {
-      const metaColor = colors ? MoroLogger.COLORS.metadata : "";
+      const metaColor = colors ? MoroLogger.COLORS.metadata : '';
       const cleanMetadata = { ...entry.metadata };
       delete cleanMetadata.stack; // Handle stack separately
 
@@ -368,14 +330,11 @@ export class MoroLogger implements Logger {
     }
 
     // Output main log line
-    console.log(parts.join(" "));
+    console.log(parts.join(' '));
 
     // Stack trace for errors
-    if (
-      entry.metadata?.stack &&
-      (entry.level === "error" || entry.level === "fatal")
-    ) {
-      const stackColor = colors ? MoroLogger.COLORS.error : "";
+    if (entry.metadata?.stack && (entry.level === 'error' || entry.level === 'fatal')) {
+      const stackColor = colors ? MoroLogger.COLORS.error : '';
       console.log(`${stackColor}${entry.metadata.stack}${levelReset}`);
     }
   }
@@ -385,12 +344,12 @@ export class MoroLogger implements Logger {
 const initialLogLevel =
   process.env.LOG_LEVEL ||
   process.env.MORO_LOG_LEVEL ||
-  (process.env.NODE_ENV === "production" ? "warn" : "debug");
+  (process.env.NODE_ENV === 'production' ? 'warn' : 'debug');
 
 export const logger = new MoroLogger({
   level: initialLogLevel as LogLevel,
   enableColors: !process.env.NO_COLOR,
-  format: (process.env.LOG_FORMAT as any) || "pretty",
+  format: (process.env.LOG_FORMAT as any) || 'pretty',
 });
 
 /**
@@ -410,7 +369,7 @@ export function configureGlobalLogger(options: Partial<LoggerOptions>): void {
  */
 export function applyLoggingConfiguration(
   configLogging?: any,
-  appOptions?: Partial<LoggerOptions> | boolean,
+  appOptions?: Partial<LoggerOptions> | boolean
 ): void {
   // First apply config system settings (from environment variables)
   if (configLogging?.level) {
@@ -421,8 +380,8 @@ export function applyLoggingConfiguration(
   if (appOptions !== undefined) {
     if (appOptions === false) {
       // Disable logging by setting to fatal level
-      configureGlobalLogger({ level: "fatal" });
-    } else if (typeof appOptions === "object") {
+      configureGlobalLogger({ level: 'fatal' });
+    } else if (typeof appOptions === 'object') {
       configureGlobalLogger(appOptions);
     }
   }
@@ -430,5 +389,5 @@ export function applyLoggingConfiguration(
 
 // Framework-specific logger
 export const createFrameworkLogger = (context: string) => {
-  return logger.child("Moro", { framework: "moro", context });
+  return logger.child('Moro', { framework: 'moro', context });
 };