@morojs/moro 1.0.0

package/src/types/cache.ts

@@ -0,0 +1,38 @@
+// Cache Types and Interfaces
+export interface CacheAdapter {
+  get(key: string): Promise<any>;
+  set(key: string, value: any, ttl?: number): Promise<void>;
+  del(key: string): Promise<void>;
+  clear(): Promise<void>;
+  exists(key: string): Promise<boolean>;
+  ttl(key: string): Promise<number>;
+}
+
+export interface CacheStrategy {
+  key: (req: any) => string;
+  ttl: number;
+  condition?: (req: any, res: any) => boolean;
+  invalidateOn?: string[];
+}
+
+export interface CacheOptions {
+  adapter?: string | CacheAdapter;
+  adapterOptions?: any;
+  strategies?: {
+    [pattern: string]: CacheStrategy;
+  };
+  defaultTtl?: number;
+  keyPrefix?: string;
+  maxAge?: number;
+  staleWhileRevalidate?: number;
+  vary?: string[];
+  etag?: boolean | "weak" | "strong";
+}
+
+export interface CachedResponse {
+  body: any;
+  status: number;
+  headers: Record<string, any>;
+  contentType?: string;
+  timestamp: number;
+}

package/src/types/cdn.ts

@@ -0,0 +1,22 @@
+// CDN Types and Interfaces
+export interface CDNAdapter {
+  purge(urls: string[]): Promise<void>;
+  prefetch?(urls: string[]): Promise<void>;
+  getStats?(): Promise<any>;
+  setHeaders(response: any): void;
+}
+
+export interface CDNOptions {
+  adapter?: string | CDNAdapter;
+  adapterOptions?: any;
+  autoInvalidate?: boolean;
+  invalidationPatterns?: string[];
+}
+
+export interface CDNStats {
+  provider: string;
+  status: string;
+  lastPurge?: Date;
+  hitRate?: string;
+  bandwidth?: string;
+}

package/src/types/core.ts

@@ -0,0 +1,17 @@
+// Core Framework Types
+import { RuntimeConfig } from "./runtime";
+import { LogLevel, LoggerOptions } from "./logger";
+
+export interface MoroOptions {
+  autoDiscover?: boolean;
+  modulesPath?: string;
+  middleware?: any[];
+  database?: any;
+  cors?: boolean | object;
+  compression?: boolean | object;
+  helmet?: boolean | object;
+  // Runtime configuration
+  runtime?: RuntimeConfig;
+  // Logger configuration
+  logger?: LoggerOptions | boolean;
+}

package/src/types/database.ts

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

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

package/src/types/events.ts

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

@@ -0,0 +1,47 @@
+// Hooks and Middleware Types
+import { HttpRequest, HttpResponse } from "./http";
+
+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

@@ -0,0 +1,70 @@
+// 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;
+}
+
+export interface HttpResponse extends ServerResponse {
+  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>;
+}
+
+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

@@ -0,0 +1,109 @@
+// 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;
+}
+
+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;
+  addOutput(output: LogOutput): void;
+  removeOutput(name: string): void;
+  addFilter(filter: LogFilter): void;
+  removeFilter(name: string): 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;
+}
+
+export interface ColorScheme {
+  debug: string;
+  info: string;
+  warn: string;
+  error: string;
+  fatal: string;
+  timestamp: string;
+  context: string;
+  metadata: string;
+  performance: string;
+}

package/src/types/module.ts

@@ -0,0 +1,87 @@
+// 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[];
+}
+
+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;
+}
+
+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

@@ -0,0 +1,91 @@
+// Runtime abstraction types for multi-environment support
+import { HttpRequest, HttpResponse } from "./http";
+
+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
+}