@morojs/moro 1.0.0 → 1.0.1

package/src/core/middleware/built-in/session.ts

@@ -1,16 +1,16 @@
 // Session Middleware
-import { MiddlewareInterface, HookContext } from "../../../types/hooks";
-import { createFrameworkLogger } from "../../logger";
-import { CacheAdapter } from "../../../types/cache";
-import { MemoryCacheAdapter } from "./adapters/cache/memory";
-import { RedisCacheAdapter } from "./adapters/cache/redis";
-import { FileCacheAdapter } from "./adapters/cache/file";
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
+import { CacheAdapter } from '../../../types/cache';
+import { MemoryCacheAdapter } from './adapters/cache/memory';
+import { RedisCacheAdapter } from './adapters/cache/redis';
+import { FileCacheAdapter } from './adapters/cache/file';
 
-const logger = createFrameworkLogger("SessionMiddleware");
+const logger = createFrameworkLogger('SessionMiddleware');
 
 export interface SessionOptions {
   // Session store configuration
-  store?: "memory" | "redis" | "file" | CacheAdapter;
+  store?: 'memory' | 'redis' | 'file' | CacheAdapter;
   storeOptions?: {
     // Redis options
     host?: string;
@@ -37,14 +37,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
 }
 
 export interface SessionData {
@@ -66,12 +66,7 @@ class Session {
   private isNew: boolean = false;
   private isModified: boolean = false;
 
-  constructor(
-    id: string,
-    store: CacheAdapter,
-    options: SessionOptions,
-    isNew: boolean = false,
-  ) {
+  constructor(id: string, store: CacheAdapter, options: SessionOptions, isNew: boolean = false) {
     this.id = id;
     this.store = store;
     this.options = options;
@@ -84,7 +79,7 @@ class Session {
     store: CacheAdapter,
     options: SessionOptions,
     data: SessionData = {},
-    isNew: boolean = false,
+    isNew: boolean = false
   ): Session {
     const session = new Session(id, store, options, isNew);
     session.data = data;
@@ -130,7 +125,7 @@ class Session {
       await this.store.set(this.id, this.data, ttl);
       this.isModified = false;
       this.isNew = false;
-      logger.debug(`Session saved: ${this.id}`, "SessionSave");
+      logger.debug(`Session saved: ${this.id}`, 'SessionSave');
     }
   }
 
@@ -138,7 +133,7 @@ class Session {
     await this.store.del(this.id);
     this.data = {};
     this.isModified = false;
-    logger.debug(`Session destroyed: ${this.id}`, "SessionDestroy");
+    logger.debug(`Session destroyed: ${this.id}`, 'SessionDestroy');
   }
 
   async regenerate(): Promise<string> {
@@ -146,7 +141,7 @@ class Session {
     this.id = this.generateId();
     this.isNew = true;
     this.isModified = true;
-    logger.debug(`Session regenerated: ${this.id}`, "SessionRegenerate");
+    logger.debug(`Session regenerated: ${this.id}`, 'SessionRegenerate');
     return this.id;
   }
 
@@ -162,8 +157,8 @@ class Session {
       return this.options.genid();
     }
 
-    const crypto = require("crypto");
-    return crypto.randomBytes(24).toString("hex");
+    const crypto = require('crypto');
+    return crypto.randomBytes(24).toString('hex');
   }
 
   get sessionID(): string {
@@ -172,23 +167,23 @@ class Session {
 }
 
 export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
-  name: "session",
-  version: "1.0.0",
+  name: 'session',
+  version: '1.0.0',
   metadata: {
-    name: "session",
-    version: "1.0.0",
-    description: "Session management middleware with multiple store adapters",
-    author: "MoroJS Team",
+    name: 'session',
+    version: '1.0.0',
+    description: 'Session management middleware with multiple store adapters',
+    author: 'MoroJS Team',
   },
 
   install: async (hooks: any, middlewareOptions: any = {}) => {
-    logger.debug("Installing session middleware", "Installation");
+    logger.debug('Installing session middleware', 'Installation');
 
     // Merge options
     const config: SessionOptions = {
-      store: "memory",
-      name: "connect.sid",
-      secret: "moro-session-secret",
+      store: 'memory',
+      name: 'connect.sid',
+      secret: 'moro-session-secret',
       rolling: false,
       resave: false,
       saveUninitialized: false,
@@ -196,10 +191,10 @@ export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
         maxAge: 24 * 60 * 60 * 1000, // 24 hours
         httpOnly: true,
         secure: false,
-        sameSite: "lax",
-        path: "/",
+        sameSite: 'lax',
+        path: '/',
       },
-      unset: "keep",
+      unset: 'keep',
       ...options,
       ...middlewareOptions,
     };
@@ -207,20 +202,20 @@ export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
     // Initialize store
     let store: CacheAdapter;
 
-    if (typeof config.store === "string") {
+    if (typeof config.store === 'string') {
       switch (config.store) {
-        case "redis":
+        case 'redis':
           store = new RedisCacheAdapter({
-            keyPrefix: "sess:",
+            keyPrefix: 'sess:',
             ...config.storeOptions,
           });
           break;
-        case "file":
+        case 'file':
           store = new FileCacheAdapter({
-            cacheDir: config.storeOptions?.path || "./sessions",
+            cacheDir: config.storeOptions?.path || './sessions',
           });
           break;
-        case "memory":
+        case 'memory':
         default:
           store = new MemoryCacheAdapter();
           break;
@@ -234,11 +229,11 @@ export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
       if (config.genid) {
         return config.genid();
       }
-      const crypto = require("crypto");
-      return crypto.randomBytes(24).toString("hex");
+      const crypto = require('crypto');
+      return crypto.randomBytes(24).toString('hex');
     };
 
-    hooks.before("request", async (context: HookContext) => {
+    hooks.before('request', async (context: HookContext) => {
       const req = context.request as any;
       const res = context.response as any;
 
@@ -250,13 +245,9 @@ export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
       if (sessionId) {
         try {
           sessionData = (await store.get(sessionId)) || {};
-          logger.debug(`Session loaded: ${sessionId}`, "SessionLoad");
+          logger.debug(`Session loaded: ${sessionId}`, 'SessionLoad');
         } catch (error) {
-          logger.warn(
-            `Failed to load session: ${sessionId}`,
-            "SessionLoadError",
-            { error },
-          );
+          logger.warn(`Failed to load session: ${sessionId}`, 'SessionLoadError', { error });
           sessionId = generateSessionId();
           isNew = true;
         }
@@ -266,46 +257,32 @@ export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
       }
 
       // Create session object
-      req.session = Session.create(
-        sessionId,
-        store,
-        config,
-        sessionData,
-        isNew,
-      );
+      req.session = Session.create(sessionId, store, config, sessionData, isNew);
 
       // Set session cookie
       if (isNew || config.rolling) {
         res.cookie(config.name!, sessionId, {
           ...config.cookie,
           secure:
-            config.cookie?.secure ||
-            (config.proxy && req.headers["x-forwarded-proto"] === "https"),
+            config.cookie?.secure || (config.proxy && req.headers['x-forwarded-proto'] === 'https'),
         });
       }
     });
 
-    hooks.after("response", async (context: HookContext) => {
+    hooks.after('response', async (context: HookContext) => {
       const req = context.request as any;
 
       if (req.session) {
         try {
-          if (
-            config.saveUninitialized ||
-            !req.session.isNew ||
-            req.session.isModified
-          ) {
+          if (config.saveUninitialized || !req.session.isNew || req.session.isModified) {
             await req.session.save();
           }
         } catch (error) {
-          logger.error("Failed to save session", "SessionSaveError", { error });
+          logger.error('Failed to save session', 'SessionSaveError', { error });
         }
       }
     });
 
-    logger.info(
-      `Session middleware installed with ${config.store} store`,
-      "Installation",
-    );
+    logger.info(`Session middleware installed with ${config.store} store`, 'Installation');
   },
 });

package/src/core/middleware/built-in/sse.ts

@@ -1,58 +1,53 @@
 // Server-Sent Events Middleware
-import { MiddlewareInterface, HookContext } from "../../../types/hooks";
-import { createFrameworkLogger } from "../../logger";
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
 
-const logger = createFrameworkLogger("SSEMiddleware");
+const logger = createFrameworkLogger('SSEMiddleware');
 
 export const sse = (
   options: {
     heartbeat?: number;
     retry?: number;
     cors?: boolean;
-  } = {},
+  } = {}
 ): MiddlewareInterface => ({
-  name: "sse",
-  version: "1.0.0",
+  name: 'sse',
+  version: '1.0.0',
   metadata: {
-    name: "sse",
-    version: "1.0.0",
-    description:
-      "Server-Sent Events middleware with heartbeat and retry support",
-    author: "MoroJS Team",
+    name: 'sse',
+    version: '1.0.0',
+    description: 'Server-Sent Events middleware with heartbeat and retry support',
+    author: 'MoroJS Team',
   },
 
   install: async (hooks: any, middlewareOptions: any = {}) => {
-    logger.debug("Installing SSE middleware", "Installation");
+    logger.debug('Installing SSE middleware', 'Installation');
 
-    hooks.before("request", async (context: HookContext) => {
+    hooks.before('request', async (context: HookContext) => {
       const req = context.request as any;
       const res = context.response as any;
 
       // Only handle SSE requests
-      if (!req.headers.accept?.includes("text/event-stream")) {
+      if (!req.headers.accept?.includes('text/event-stream')) {
         return;
       }
 
-      logger.debug("Setting up SSE connection", "SSESetup");
+      logger.debug('Setting up SSE connection', 'SSESetup');
 
       // Set SSE headers
       res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        "Access-Control-Allow-Origin": options.cors ? "*" : undefined,
-        "Access-Control-Allow-Headers": options.cors
-          ? "Cache-Control"
-          : undefined,
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
+        'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
       });
 
       // Add SSE methods to response
       res.sendEvent = (data: any, event?: string, id?: string) => {
         if (id) res.write(`id: ${id}\n`);
         if (event) res.write(`event: ${event}\n`);
-        res.write(
-          `data: ${typeof data === "string" ? data : JSON.stringify(data)}\n\n`,
-        );
+        res.write(`data: ${typeof data === 'string' ? data : JSON.stringify(data)}\n\n`);
       };
 
       res.sendComment = (comment: string) => {
@@ -67,7 +62,7 @@ export const sse = (
       let heartbeatInterval: NodeJS.Timeout | null = null;
       if (options.heartbeat) {
         heartbeatInterval = setInterval(() => {
-          res.sendComment("heartbeat");
+          res.sendComment('heartbeat');
         }, options.heartbeat);
       }
 
@@ -77,11 +72,11 @@ export const sse = (
       }
 
       // Clean up on close
-      req.on("close", () => {
+      req.on('close', () => {
         if (heartbeatInterval) {
           clearInterval(heartbeatInterval);
         }
-        logger.debug("SSE connection closed", "SSECleanup");
+        logger.debug('SSE connection closed', 'SSECleanup');
       });
 
       // Mark that this middleware handled the request

package/src/core/middleware/built-in/validation.ts

@@ -1,30 +1,30 @@
 // Validation Middleware
-import { MiddlewareInterface, HookContext } from "../../../types/hooks";
-import { createFrameworkLogger } from "../../logger";
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
 
-const logger = createFrameworkLogger("ValidationMiddleware");
+const logger = createFrameworkLogger('ValidationMiddleware');
 
 export const validation = (): MiddlewareInterface => ({
-  name: "validation",
-  version: "1.0.0",
+  name: 'validation',
+  version: '1.0.0',
   metadata: {
-    name: "validation",
-    version: "1.0.0",
-    description: "Request validation middleware with content type checking",
-    author: "MoroJS Team",
+    name: 'validation',
+    version: '1.0.0',
+    description: 'Request validation middleware with content type checking',
+    author: 'MoroJS Team',
   },
 
   install: async (hooks: any, options: any = {}) => {
-    logger.debug("Installing validation middleware", "Installation");
+    logger.debug('Installing validation middleware', 'Installation');
 
-    hooks.before("request", async (context: HookContext) => {
+    hooks.before('request', async (context: HookContext) => {
       const request = context.request as any;
 
       // Basic content type validation
-      if (request.method === "POST" || request.method === "PUT") {
-        const contentType = request.headers["content-type"];
-        if (contentType && contentType.includes("application/json")) {
-          logger.debug("Validation: JSON content type verified", "ContentType");
+      if (request.method === 'POST' || request.method === 'PUT') {
+        const contentType = request.headers['content-type'];
+        if (contentType && contentType.includes('application/json')) {
+          logger.debug('Validation: JSON content type verified', 'ContentType');
           // Additional validation logic would go here
         }
       }

package/src/core/middleware/index.ts

@@ -1,23 +1,23 @@
 // Middleware System for Moro
-import { EventEmitter } from "events";
-import { HookManager } from "../utilities";
+import { EventEmitter } from 'events';
+import { HookManager } from '../utilities';
 import {
   MiddlewareMetadata,
   MiddlewareContext,
   MiddlewareInterface,
   SimpleMiddlewareFunction,
   MoroMiddleware,
-} from "../../types/hooks";
-import { createFrameworkLogger } from "../logger";
+} from '../../types/hooks';
+import { createFrameworkLogger } from '../logger';
 
 // Export types needed by built-in middleware
-export type { MiddlewareInterface, MoroMiddleware } from "../../types/hooks";
+export type { MiddlewareInterface, MoroMiddleware } from '../../types/hooks';
 
 export class MiddlewareManager extends EventEmitter {
   private middleware = new Map<string, MiddlewareInterface>();
   private simpleMiddleware = new Map<string, SimpleMiddlewareFunction>();
   private hooks: HookManager;
-  private logger = createFrameworkLogger("Middleware");
+  private logger = createFrameworkLogger('Middleware');
 
   constructor() {
     super();
@@ -31,34 +31,25 @@ export class MiddlewareManager extends EventEmitter {
     }
 
     this.middleware.set(name, middleware);
-    this.logger.debug(`Registered middleware: ${name}`, "Registration");
-    this.emit("registered", { name, middleware });
+    this.logger.debug(`Registered middleware: ${name}`, 'Registration');
+    this.emit('registered', { name, middleware });
   }
 
   // Install simple function-style middleware
-  install(
-    middleware: SimpleMiddlewareFunction | MiddlewareInterface,
-    options: any = {},
-  ): void {
-    if (typeof middleware === "function") {
+  install(middleware: SimpleMiddlewareFunction | MiddlewareInterface, options: any = {}): void {
+    if (typeof middleware === 'function') {
       // Simple function-style middleware
-      const simpleName = middleware.name || "anonymous";
-      this.logger.debug(
-        `Installing simple middleware: ${simpleName}`,
-        "Installation",
-      );
+      const simpleName = middleware.name || 'anonymous';
+      this.logger.debug(`Installing simple middleware: ${simpleName}`, 'Installation');
 
       this.simpleMiddleware.set(simpleName, middleware);
-      this.emit("installed", { name: simpleName, type: "simple" });
-      this.logger.info(
-        `Simple middleware installed: ${simpleName}`,
-        "Installation",
-      );
+      this.emit('installed', { name: simpleName, type: 'simple' });
+      this.logger.info(`Simple middleware installed: ${simpleName}`, 'Installation');
       return;
     }
 
     // Advanced middleware with dependencies and lifecycle
-    const name = middleware.metadata?.name || "unknown";
+    const name = middleware.metadata?.name || 'unknown';
 
     if (this.middleware.has(name)) {
       throw new Error(`Middleware ${name} is already installed`);
@@ -76,15 +67,15 @@ export class MiddlewareManager extends EventEmitter {
     // Store middleware
     this.middleware.set(name, middleware);
 
-    this.logger.debug(`Installing middleware: ${name}`, "Installation");
+    this.logger.debug(`Installing middleware: ${name}`, 'Installation');
 
     // Initialize middleware
     if (middleware.install) {
       middleware.install(this.hooks, options);
     }
 
-    this.emit("installed", { name, middleware, options });
-    this.logger.info(`Middleware installed: ${name}`, "Installation");
+    this.emit('installed', { name, middleware, options });
+    this.logger.info(`Middleware installed: ${name}`, 'Installation');
   }
 
   // Uninstall middleware and clean up
@@ -95,7 +86,7 @@ export class MiddlewareManager extends EventEmitter {
 
     const middleware = this.middleware.get(name)!;
 
-    this.logger.debug(`Uninstalling middleware: ${name}`, "Uninstallation");
+    this.logger.debug(`Uninstalling middleware: ${name}`, 'Uninstallation');
 
     // Call cleanup if available
     if (middleware.uninstall) {
@@ -103,8 +94,8 @@ export class MiddlewareManager extends EventEmitter {
     }
 
     this.middleware.delete(name);
-    this.emit("uninstalled", { name, middleware });
-    this.logger.info(`Middleware uninstalled: ${name}`, "Uninstallation");
+    this.emit('uninstalled', { name, middleware });
+    this.logger.info(`Middleware uninstalled: ${name}`, 'Uninstallation');
   }
 
   // Get installed middleware
@@ -130,7 +121,7 @@ export class MiddlewareManager extends EventEmitter {
   // Dependency resolution with topological sorting for optimal middleware loading
   async installWithDependencies(
     middleware: MiddlewareInterface[],
-    options?: Record<string, any>,
+    options?: Record<string, any>
   ): Promise<void> {
     // Advanced topological sort for dependency resolution
     const resolved = this.topologicalSort(middleware);
@@ -142,9 +133,7 @@ export class MiddlewareManager extends EventEmitter {
   }
 
   // Optimized topological sort implementation for middleware dependencies
-  private topologicalSort(
-    middleware: MiddlewareInterface[],
-  ): MiddlewareInterface[] {
+  private topologicalSort(middleware: MiddlewareInterface[]): MiddlewareInterface[] {
     const visited = new Set<string>();
     const temp = new Set<string>();
     const result: MiddlewareInterface[] = [];
@@ -160,7 +149,7 @@ export class MiddlewareManager extends EventEmitter {
         // Visit dependencies first
         if (middlewareItem.dependencies) {
           for (const depName of middlewareItem.dependencies) {
-            const dependency = middleware.find((m) => m.name === depName);
+            const dependency = middleware.find(m => m.name === depName);
             if (dependency) {
               visit(dependency);
             }
@@ -184,5 +173,5 @@ export class MiddlewareManager extends EventEmitter {
 }
 
 // Built-in middleware exports
-export { builtInMiddleware, simpleMiddleware } from "./built-in";
-export * from "./built-in";
+export { builtInMiddleware, simpleMiddleware } from './built-in';
+export * from './built-in';