@morojs/moro 1.6.2 → 1.6.3

package/src/types/core.ts

@@ -1,58 +0,0 @@
-// Core Framework Types
-import { RuntimeConfig } from './runtime.js';
-import { LogLevel, LoggerOptions } from './logger.js';
-import { AppConfig } from './config.js';
-
-export interface MoroOptions {
-  autoDiscover?:
-    | boolean
-    | {
-        enabled?: boolean;
-        paths?: string[];
-        patterns?: string[];
-        recursive?: boolean;
-        loadingStrategy?: 'eager' | 'lazy' | 'conditional';
-        watchForChanges?: boolean;
-        ignorePatterns?: string[];
-        loadOrder?: 'alphabetical' | 'dependency' | 'custom';
-        failOnError?: boolean;
-        maxDepth?: number;
-      };
-  modulesPath?: string; // Deprecated: use autoDiscover.paths instead
-  middleware?: any[];
-
-  // Runtime configuration
-  runtime?: RuntimeConfig;
-
-  // HTTP/WebSocket options
-  http2?: boolean;
-  https?: {
-    key: string | Buffer;
-    cert: string | Buffer;
-    ca?: string | Buffer;
-  };
-  websocket?:
-    | {
-        enabled?: boolean;
-        adapter?: any;
-        compression?: boolean;
-        customIdGenerator?: () => string;
-        options?: any;
-      }
-    | false;
-
-  // Simplified config options (these map to the full config)
-  cors?: boolean | object;
-  compression?: boolean | object;
-  helmet?: boolean | object;
-  logger?: LoggerOptions | boolean;
-
-  // Direct config overrides (partial)
-  server?: Partial<AppConfig['server']>;
-  database?: Partial<AppConfig['database']>;
-  modules?: Partial<AppConfig['modules']>;
-  logging?: Partial<AppConfig['logging']>;
-  security?: Partial<AppConfig['security']>;
-  external?: Partial<AppConfig['external']>;
-  performance?: Partial<AppConfig['performance']>;
-}

package/src/types/database.ts

@@ -1,32 +0,0 @@
-// src/types/database.ts
-export interface DatabaseAdapter {
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  query<T = any>(sql: string, params?: any[]): Promise<T[]>;
-  queryOne<T = any>(sql: string, params?: any[]): Promise<T | null>;
-  insert<T = any>(table: string, data: Record<string, any>): Promise<T>;
-  update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<T>;
-  delete(table: string, where: Record<string, any>): Promise<number>;
-  transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T>;
-}
-
-export interface DatabaseTransaction {
-  query<T = any>(sql: string, params?: any[]): Promise<T[]>;
-  queryOne<T = any>(sql: string, params?: any[]): Promise<T | null>;
-  insert<T = any>(table: string, data: Record<string, any>): Promise<T>;
-  update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<T>;
-  delete(table: string, where: Record<string, any>): Promise<number>;
-  commit(): Promise<void>;
-  rollback(): Promise<void>;
-}
-
-export interface DatabaseConfig {
-  host: string;
-  port: number;
-  user: string;
-  password: string;
-  database: string;
-  connectionLimit?: number;
-  acquireTimeout?: number;
-  timeout?: number;
-}

package/src/types/discovery.ts

@@ -1,7 +0,0 @@
-// Auto-Discovery Types
-export interface DiscoveryOptions {
-  baseDir?: string;
-  pattern?: RegExp;
-  recursive?: boolean;
-  extensions?: string[];
-}

package/src/types/events.ts

@@ -1,82 +0,0 @@
-// Enterprise Event System Types
-import { EventEmitter } from 'events';
-
-export interface EventContext {
-  timestamp: Date;
-  source: string;
-  moduleId?: string;
-  requestId?: string;
-  userId?: string;
-  sessionId?: string;
-  metadata?: Record<string, any>;
-}
-
-export interface EventPayload<T = any> {
-  context: EventContext;
-  data: T;
-}
-
-export interface EventBusOptions {
-  maxListeners?: number;
-  enablePersistence?: boolean;
-  enableMetrics?: boolean;
-  isolation?: 'none' | 'module' | 'strict';
-}
-
-export interface ModuleEventBus {
-  emit<T = any>(event: string, data: T): Promise<boolean>;
-  on<T = any>(event: string, listener: (payload: EventPayload<T>) => void | Promise<void>): this;
-  once<T = any>(event: string, listener: (payload: EventPayload<T>) => void | Promise<void>): this;
-  off(event: string, listener: Function): this;
-  removeAllListeners(event?: string): this;
-  listenerCount(event: string): number;
-}
-
-export interface GlobalEventBus extends ModuleEventBus {
-  createModuleBus(moduleId: string): ModuleEventBus;
-  destroyModuleBus(moduleId: string): void;
-  getMetrics(): EventMetrics;
-  enableAuditLog(): void;
-  disableAuditLog(): void;
-}
-
-export interface EventMetrics {
-  totalEvents: number;
-  eventsByType: Record<string, number>;
-  eventsByModule: Record<string, number>;
-  averageLatency: number;
-  errorRate: number;
-}
-
-export type SystemEvents = {
-  'framework:initialized': { options: any };
-  'framework:shutdown': { graceful: boolean };
-  'module:loading': { moduleId: string; path?: string };
-  'module:loaded': { moduleId: string; version: string };
-  'module:unloaded': { moduleId: string };
-  'middleware:registered': { name: string; type: string };
-  'middleware:installed': { name: string; options?: any };
-  'database:connected': { adapter: string; config: any };
-  'database:disconnected': { adapter: string };
-  'server:starting': { port: number };
-  'server:started': { port: number; pid: number };
-  'server:stopping': { graceful: boolean };
-  'request:start': { method: string; path: string; requestId: string };
-  'request:end': {
-    method: string;
-    path: string;
-    requestId: string;
-    statusCode: number;
-    duration: number;
-  };
-  'websocket:connected': { namespace: string; socketId: string };
-  'websocket:disconnected': {
-    namespace: string;
-    socketId: string;
-    reason: string;
-  };
-  'error:handled': { error: Error; context: string; requestId?: string };
-  'error:unhandled': { error: Error; context: string };
-};
-
-export type EventHandler<T = any> = (payload: EventPayload<T>) => void | Promise<void>;

package/src/types/hooks.ts

@@ -1,47 +0,0 @@
-// Hooks and Middleware Types
-import { HttpRequest, HttpResponse } from '../core/http/index.js';
-
-export type HookFunction = (...args: any[]) => Promise<any> | any;
-
-export interface HookContext {
-  request?: HttpRequest;
-  response?: HttpResponse;
-  data?: any;
-  metadata?: Record<string, any>;
-}
-
-export interface MoroMiddleware {
-  name: string;
-  version?: string;
-  install: (hooks: any, options?: any) => Promise<void> | void;
-  uninstall?: (hooks: any) => Promise<void> | void;
-}
-
-// Advanced middleware types
-export interface MiddlewareMetadata {
-  name: string;
-  version?: string;
-  description?: string;
-  author?: string;
-  dependencies?: string[];
-  tags?: string[];
-}
-
-export interface MiddlewareContext {
-  app: any;
-  hooks: any; // HookManager
-  config: any;
-  logger?: any;
-}
-
-export interface MiddlewareInterface extends MoroMiddleware {
-  metadata?: MiddlewareMetadata;
-  dependencies?: string[];
-  configure?: (config: any) => void;
-  beforeInstall?: (context: MiddlewareContext) => Promise<void> | void;
-  afterInstall?: (context: MiddlewareContext) => Promise<void> | void;
-  beforeUninstall?: (context: MiddlewareContext) => Promise<void> | void;
-  afterUninstall?: (context: MiddlewareContext) => Promise<void> | void;
-}
-
-export type SimpleMiddlewareFunction = (app: any) => Promise<void> | void;

package/src/types/http.ts

@@ -1,89 +0,0 @@
-// HTTP Server Types
-import { IncomingMessage, ServerResponse } from 'http';
-
-export interface HttpRequest extends IncomingMessage {
-  params: Record<string, string>;
-  query: Record<string, string>;
-  body: any;
-  path: string;
-  headers: Record<string, string>;
-  ip: string;
-  requestId: string;
-  cookies?: Record<string, string>;
-  files?: Record<string, any>;
-  [key: string]: any;
-}
-
-export interface CookieOptions {
-  maxAge?: number;
-  expires?: Date;
-  httpOnly?: boolean;
-  secure?: boolean;
-  sameSite?: 'strict' | 'lax' | 'none';
-  domain?: string;
-  path?: string;
-  // Security options
-  critical?: boolean; // Mark as critical for security (throws on late set)
-  throwOnLateSet?: boolean; // Force throw if headers already sent
-}
-
-export interface ResponseState {
-  headersSent: boolean;
-  statusCode: number;
-  headers: Record<string, any>;
-  finished: boolean;
-  writable: boolean;
-}
-
-export interface MoroResponseMethods {
-  json(data: any): void;
-  status(code: number): HttpResponse;
-  send(data: string | Buffer): void;
-  cookie(name: string, value: string, options?: CookieOptions): HttpResponse;
-  clearCookie(name: string, options?: CookieOptions): HttpResponse;
-  redirect(url: string, status?: number): void;
-  sendFile(filePath: string): Promise<void>;
-  render?(template: string, data?: any): Promise<void>;
-
-  // Header management utilities
-  hasHeader(name: string): boolean;
-  setBulkHeaders(headers: Record<string, string | number>): HttpResponse;
-  appendHeader(name: string, value: string | string[]): HttpResponse;
-
-  // Response state utilities
-  canSetHeaders(): boolean;
-  getResponseState(): ResponseState;
-}
-
-export type HttpResponse = ServerResponse & MoroResponseMethods;
-
-export type HttpHandler = (req: HttpRequest, res: HttpResponse) => Promise<void> | void;
-export type Middleware = (
-  req: HttpRequest,
-  res: HttpResponse,
-  next: () => void
-) => Promise<void> | void;
-export type MiddlewareFunction = (
-  req: HttpRequest,
-  res: HttpResponse,
-  next: () => void
-) => void | Promise<void>;
-
-// Internal router types
-export interface RouteEntry {
-  method: string;
-  path: string;
-  pattern: RegExp;
-  paramNames: string[];
-  handler: HttpHandler;
-  middleware: Middleware[];
-}
-
-export interface RouteDefinition {
-  method: string;
-  path: string;
-  pattern: RegExp;
-  paramNames: string[];
-  handler: HttpHandler;
-  middleware: Middleware[];
-}

package/src/types/logger.ts

@@ -1,102 +0,0 @@
-// Enterprise Logger Types
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
-
-export interface LogEntry {
-  timestamp: Date;
-  level: LogLevel;
-  message: string;
-  context?: string;
-  metadata?: Record<string, any>;
-  requestId?: string;
-  moduleId?: string;
-  userId?: string;
-  sessionId?: string;
-  performance?: {
-    duration?: number;
-    memory?: number;
-    cpu?: number;
-  };
-  stack?: string;
-}
-
-export interface LoggerOptions {
-  level?: LogLevel;
-  enableColors?: boolean;
-  enableTimestamp?: boolean;
-  enableContext?: boolean;
-  enableMetadata?: boolean;
-  enablePerformance?: boolean;
-  format?: 'pretty' | 'json' | 'compact';
-  outputs?: LogOutput[];
-  filters?: LogFilter[];
-  maxEntries?: number;
-  maxBufferSize?: number;
-}
-
-export interface LogOutput {
-  name: string;
-  write: (entry: LogEntry) => Promise<void> | void;
-  level?: LogLevel;
-  format?: 'pretty' | 'json' | 'compact';
-}
-
-export interface LogFilter {
-  name: string;
-  filter: (entry: LogEntry) => boolean;
-}
-
-export interface Logger {
-  debug(message: string, context?: string, metadata?: Record<string, any>): void;
-  info(message: string, context?: string, metadata?: Record<string, any>): void;
-  warn(message: string, context?: string, metadata?: Record<string, any>): void;
-  error(message: string | Error, context?: string, metadata?: Record<string, any>): void;
-  fatal(message: string | Error, context?: string, metadata?: Record<string, any>): void;
-
-  // Performance logging
-  time(label: string): void;
-  timeEnd(label: string, context?: string, metadata?: Record<string, any>): void;
-
-  // Structured logging
-  child(context: string, metadata?: Record<string, any>): Logger;
-
-  // Configuration
-  setLevel(level: LogLevel): void;
-  getLevel(): LogLevel;
-  addOutput(output: LogOutput): void;
-  removeOutput(name: string): void;
-  addFilter(filter: LogFilter): void;
-  removeFilter(name: string): void;
-
-  // Cleanup
-  flush(): void;
-  flushBuffer(): void;
-  destroy(): void;
-
-  // Metrics and history
-  getHistory(count?: number): LogEntry[];
-  getMetrics(): LogMetrics;
-  clear(): void;
-}
-
-export interface LogMetrics {
-  totalLogs: number;
-  logsByLevel: Record<LogLevel, number>;
-  logsByContext: Record<string, number>;
-  averageLogRate: number;
-  errorRate: number;
-  memoryUsage: number;
-  outputErrors?: Record<string, number>;
-}
-
-export interface ColorScheme {
-  debug: string;
-  info: string;
-  warn: string;
-  error: string;
-  fatal: string;
-  timestamp: string;
-  context: string;
-  metadata: string;
-  performance: string;
-  reset: string;
-}

package/src/types/module.ts

@@ -1,99 +0,0 @@
-// Module Definition Types
-export interface ModuleRoute {
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  path: string;
-  handler: (req: any, res: any) => any | Promise<any>;
-  validation?: any;
-  cache?: { ttl: number; key?: string };
-  rateLimit?: { requests: number; window: number };
-  middleware?: string[];
-  auth?: {
-    roles?: string[];
-    permissions?: string[];
-    optional?: boolean;
-  };
-}
-
-export interface ModuleSocket {
-  event: string;
-  handler: (socket: any, data: any) => any | Promise<any>;
-  validation?: any;
-  rateLimit?: { requests: number; window: number };
-  rooms?: string[];
-  broadcast?: boolean;
-}
-
-export interface ModuleDefinition {
-  name: string;
-  version: string;
-  config?: {
-    cache?: { ttl: number };
-    rateLimit?: { requests: number; window: number };
-    database?: {
-      path?: string;
-    };
-    [key: string]: any;
-  };
-  routes?: ModuleRoute[];
-  sockets?: ModuleSocket[];
-  dependencies?: string[];
-}
-
-// Internal Module Configuration (used by framework)
-export interface ModuleConfig {
-  name: string;
-  version: string;
-  routes?: InternalRouteDefinition[];
-  websockets?: WebSocketDefinition[];
-  sockets?: WebSocketDefinition[];
-  dependencies?: string[];
-  middleware?: any[]; // MiddlewareFunction from http types
-  services?: ServiceDefinition[];
-  config?: any; // Module-specific configuration
-  routeHandlers?: Record<string, Function>;
-  socketHandlers?: Record<string, Function>;
-}
-
-export interface InternalRouteDefinition {
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  path: string;
-  handler: string;
-  middleware?: string[];
-  validation?: any;
-  cache?: CacheConfig;
-  rateLimit?: RateLimitConfig;
-  auth?: {
-    roles?: string[];
-    permissions?: string[];
-    optional?: boolean;
-  };
-  // Allow additional properties for extensibility
-  [key: string]: any;
-}
-
-export interface WebSocketDefinition {
-  event: string;
-  handler: string;
-  middleware?: string[];
-  validation?: any;
-  rateLimit?: RateLimitConfig;
-  rooms?: string[];
-  broadcast?: boolean;
-}
-
-export interface ServiceDefinition {
-  name: string;
-  implementation: new (...args: any[]) => any;
-  singleton?: boolean;
-  dependencies?: string[];
-}
-
-export interface CacheConfig {
-  ttl: number;
-  key?: string;
-}
-
-export interface RateLimitConfig {
-  requests: number;
-  window: number;
-}

package/src/types/runtime.ts

@@ -1,76 +0,0 @@
-// Runtime abstraction types for multi-environment support
-import { HttpRequest, HttpResponse } from '../core/http/index.js';
-
-export type RuntimeType = 'node' | 'vercel-edge' | 'aws-lambda' | 'cloudflare-workers';
-
-// Generic runtime request/response interfaces
-export interface RuntimeRequest {
-  method: string;
-  url: string;
-  headers: Record<string, string>;
-  body?: any;
-  query?: Record<string, string>;
-  params?: Record<string, string>;
-  [key: string]: any;
-}
-
-export interface RuntimeResponse {
-  status: number;
-  headers: Record<string, string>;
-  body: any;
-}
-
-// Runtime-specific response interface for adapters
-export interface RuntimeHttpResponse {
-  statusCode: number;
-  headers: Record<string, string>;
-  body: any;
-  headersSent: boolean;
-
-  status(code: number): RuntimeHttpResponse;
-  json(data: any): void;
-  send(data: string | Buffer): void;
-  cookie(name: string, value: string, options?: any): RuntimeHttpResponse;
-  clearCookie(name: string, options?: any): RuntimeHttpResponse;
-  redirect(url: string, status?: number): void;
-  sendFile?(filePath: string): Promise<void>;
-}
-
-// Runtime-specific handler types
-export type NodeHandler = (req: any, res: any) => Promise<void> | void;
-export type EdgeHandler = (request: Request) => Promise<Response>;
-export type LambdaHandler = (event: any, context: any) => Promise<any>;
-export type WorkerHandler = (request: Request, env: any, ctx: any) => Promise<Response>;
-
-// Runtime adapter interface
-export interface RuntimeAdapter {
-  readonly type: RuntimeType;
-
-  // Convert runtime-specific request to MoroJS HttpRequest
-  adaptRequest(runtimeRequest: any, ...args: any[]): Promise<HttpRequest>;
-
-  // Convert MoroJS HttpResponse to runtime-specific response
-  adaptResponse(
-    moroResponse: HttpResponse | RuntimeHttpResponse,
-    runtimeRequest: any
-  ): Promise<any>;
-
-  // Create the appropriate server/handler for the runtime
-  createServer(handler: (req: HttpRequest, res: HttpResponse) => Promise<void>): any;
-
-  // Start listening (for runtimes that support it)
-  listen?(server: any, port: number, host?: string, callback?: () => void): void;
-}
-
-// Runtime configuration
-export interface RuntimeConfig {
-  type: RuntimeType;
-  adapter?: RuntimeAdapter;
-  options?: any;
-}
-
-// Extended MoroOptions to include runtime configuration
-export interface RuntimeMoroOptions {
-  runtime?: RuntimeConfig;
-  // ... existing options
-}

package/src/types/session.ts

@@ -1,89 +0,0 @@
-// Session Types
-export interface SessionData {
-  [key: string]: any;
-  cookie?: {
-    originalMaxAge?: number;
-    expires?: Date;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: string;
-  };
-}
-
-export interface SessionInstance {
-  // Session data proxy
-  [key: string]: any;
-
-  // Session methods
-  save(): Promise<void>;
-  destroy(): Promise<void>;
-  regenerate(): Promise<string>;
-  touch(): Promise<void>;
-
-  // Session properties
-  readonly sessionID: string;
-  readonly cookie?: SessionData['cookie'];
-  readonly isNew?: boolean;
-  readonly isModified?: boolean;
-}
-
-export interface SessionOptions {
-  // Store configuration
-  store?: 'memory' | 'redis' | 'file' | any;
-  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
-}
-
-// Extend the HTTP request type to include session
-declare global {
-  namespace Express {
-    interface Request {
-      session: SessionInstance;
-    }
-  }
-}
-
-// For non-Express environments
-export interface RequestWithSession {
-  session: SessionInstance;
-}
-
-export interface SessionStore {
-  get(key: string): Promise<SessionData | null>;
-  set(key: string, data: SessionData, ttl?: number): Promise<void>;
-  del(key: string): Promise<void>;
-  clear?(): Promise<void>;
-  touch?(key: string): Promise<void>;
-}