@morojs/moro 1.0.0 → 1.0.2

package/src/types/cache.ts

@@ -26,7 +26,7 @@ export interface CacheOptions {
   maxAge?: number;
   staleWhileRevalidate?: number;
   vary?: string[];
-  etag?: boolean | "weak" | "strong";
+  etag?: boolean | 'weak' | 'strong';
 }
 
 export interface CachedResponse {

package/src/types/core.ts

@@ -1,6 +1,6 @@
 // Core Framework Types
-import { RuntimeConfig } from "./runtime";
-import { LogLevel, LoggerOptions } from "./logger";
+import { RuntimeConfig } from './runtime';
+import { LogLevel, LoggerOptions } from './logger';
 
 export interface MoroOptions {
   autoDiscover?: boolean;

package/src/types/database.ts

@@ -5,11 +5,7 @@ export interface DatabaseAdapter {
   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>;
+  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>;
 }
@@ -18,11 +14,7 @@ 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>;
+  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>;

package/src/types/events.ts

@@ -1,5 +1,5 @@
 // Enterprise Event System Types
-import { EventEmitter } from "events";
+import { EventEmitter } from 'events';
 
 export interface EventContext {
   timestamp: Date;
@@ -20,19 +20,13 @@ export interface EventBusOptions {
   maxListeners?: number;
   enablePersistence?: boolean;
   enableMetrics?: boolean;
-  isolation?: "none" | "module" | "strict";
+  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;
+  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;
@@ -55,36 +49,34 @@ export interface EventMetrics {
 }
 
 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": {
+  '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": {
+  '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 };
+  '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>;
+export type EventHandler<T = any> = (payload: EventPayload<T>) => void | Promise<void>;

package/src/types/hooks.ts

@@ -1,5 +1,5 @@
 // Hooks and Middleware Types
-import { HttpRequest, HttpResponse } from "./http";
+import { HttpRequest, HttpResponse } from './http';
 
 export type HookFunction = (...args: any[]) => Promise<any> | any;
 

package/src/types/http.ts

@@ -1,5 +1,5 @@
 // HTTP Server Types
-import { IncomingMessage, ServerResponse } from "http";
+import { IncomingMessage, ServerResponse } from 'http';
 
 export interface HttpRequest extends IncomingMessage {
   params: Record<string, string>;
@@ -19,7 +19,7 @@ export interface CookieOptions {
   expires?: Date;
   httpOnly?: boolean;
   secure?: boolean;
-  sameSite?: "strict" | "lax" | "none";
+  sameSite?: 'strict' | 'lax' | 'none';
   domain?: string;
   path?: string;
 }
@@ -35,19 +35,16 @@ export interface HttpResponse extends ServerResponse {
   render?(template: string, data?: any): Promise<void>;
 }
 
-export type HttpHandler = (
-  req: HttpRequest,
-  res: HttpResponse,
-) => Promise<void> | void;
+export type HttpHandler = (req: HttpRequest, res: HttpResponse) => Promise<void> | void;
 export type Middleware = (
   req: HttpRequest,
   res: HttpResponse,
-  next: () => void,
+  next: () => void
 ) => Promise<void> | void;
 export type MiddlewareFunction = (
   req: HttpRequest,
   res: HttpResponse,
-  next: () => void,
+  next: () => void
 ) => void | Promise<void>;
 
 // Internal router types

package/src/types/logger.ts

@@ -1,5 +1,5 @@
 // Enterprise Logger Types
-export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 
 export interface LogEntry {
   timestamp: Date;
@@ -26,7 +26,7 @@ export interface LoggerOptions {
   enableContext?: boolean;
   enableMetadata?: boolean;
   enablePerformance?: boolean;
-  format?: "pretty" | "json" | "compact";
+  format?: 'pretty' | 'json' | 'compact';
   outputs?: LogOutput[];
   filters?: LogFilter[];
   maxEntries?: number;
@@ -36,7 +36,7 @@ export interface LogOutput {
   name: string;
   write: (entry: LogEntry) => Promise<void> | void;
   level?: LogLevel;
-  format?: "pretty" | "json" | "compact";
+  format?: 'pretty' | 'json' | 'compact';
 }
 
 export interface LogFilter {
@@ -45,31 +45,15 @@ export interface LogFilter {
 }
 
 export interface Logger {
-  debug(
-    message: string,
-    context?: string,
-    metadata?: Record<string, any>,
-  ): void;
+  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;
+  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;
+  timeEnd(label: string, context?: string, metadata?: Record<string, any>): void;
 
   // Structured logging
   child(context: string, metadata?: Record<string, any>): Logger;

package/src/types/module.ts

@@ -1,6 +1,6 @@
 // Module Definition Types
 export interface ModuleRoute {
-  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
   path: string;
   handler: (req: any, res: any) => any | Promise<any>;
   validation?: any;
@@ -50,7 +50,7 @@ export interface ModuleConfig {
 }
 
 export interface InternalRouteDefinition {
-  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
   path: string;
   handler: string;
   middleware?: string[];

package/src/types/runtime.ts

@@ -1,11 +1,7 @@
 // Runtime abstraction types for multi-environment support
-import { HttpRequest, HttpResponse } from "./http";
+import { HttpRequest, HttpResponse } from './http';
 
-export type RuntimeType =
-  | "node"
-  | "vercel-edge"
-  | "aws-lambda"
-  | "cloudflare-workers";
+export type RuntimeType = 'node' | 'vercel-edge' | 'aws-lambda' | 'cloudflare-workers';
 
 // Generic runtime request/response interfaces
 export interface RuntimeRequest {
@@ -44,11 +40,7 @@ export interface RuntimeHttpResponse {
 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>;
+export type WorkerHandler = (request: Request, env: any, ctx: any) => Promise<Response>;
 
 // Runtime adapter interface
 export interface RuntimeAdapter {
@@ -60,21 +52,14 @@ export interface RuntimeAdapter {
   // Convert MoroJS HttpResponse to runtime-specific response
   adaptResponse(
     moroResponse: HttpResponse | RuntimeHttpResponse,
-    runtimeRequest: any,
+    runtimeRequest: any
   ): Promise<any>;
 
   // Create the appropriate server/handler for the runtime
-  createServer(
-    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
-  ): any;
+  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;
+  listen?(server: any, port: number, host?: string, callback?: () => void): void;
 }
 
 // Runtime configuration

package/src/types/session.ts

@@ -22,14 +22,14 @@ export interface SessionInstance {
 
   // Session properties
   readonly sessionID: string;
-  readonly cookie?: SessionData["cookie"];
+  readonly cookie?: SessionData['cookie'];
   readonly isNew?: boolean;
   readonly isModified?: boolean;
 }
 
 export interface SessionOptions {
   // Store configuration
-  store?: "memory" | "redis" | "file" | any;
+  store?: 'memory' | 'redis' | 'file' | any;
   storeOptions?: {
     // Redis options
     host?: string;
@@ -56,14 +56,14 @@ export interface SessionOptions {
     expires?: Date; // Absolute expiry
     httpOnly?: boolean; // Prevent XSS access
     secure?: boolean; // HTTPS only
-    sameSite?: "strict" | "lax" | "none";
+    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
+  unset?: 'destroy' | 'keep'; // What to do when session is unset
 }
 
 // Extend the HTTP request type to include session