@morojs/moro 1.6.1 → 1.6.3

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

@@ -1,288 +0,0 @@
-// 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';
-
-const logger = createFrameworkLogger('SessionMiddleware');
-
-export interface SessionOptions {
-  // Session store configuration
-  store?: 'memory' | 'redis' | 'file' | CacheAdapter;
-  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
-}
-
-export interface SessionData {
-  [key: string]: any;
-  cookie?: {
-    originalMaxAge?: number;
-    expires?: Date;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: string;
-  };
-}
-
-class Session {
-  private data: SessionData = {};
-  private id: string;
-  private store: CacheAdapter;
-  private options: SessionOptions;
-  private isNew: boolean = false;
-  private isModified: boolean = false;
-
-  constructor(id: string, store: CacheAdapter, options: SessionOptions, isNew: boolean = false) {
-    this.id = id;
-    this.store = store;
-    this.options = options;
-    this.isNew = isNew;
-  }
-
-  // Proxy to make session.prop = value work
-  static create(
-    id: string,
-    store: CacheAdapter,
-    options: SessionOptions,
-    data: SessionData = {},
-    isNew: boolean = false
-  ): Session {
-    const session = new Session(id, store, options, isNew);
-    session.data = data;
-
-    return new Proxy(session, {
-      get(target, prop) {
-        if (prop in target) {
-          return target[prop as keyof Session];
-        }
-        return target.data[prop as string];
-      },
-
-      set(target, prop, value) {
-        if (prop in target) {
-          (target as any)[prop] = value;
-        } else {
-          target.data[prop as string] = value;
-          target.isModified = true;
-        }
-        return true;
-      },
-
-      has(target, prop) {
-        return prop in target || prop in target.data;
-      },
-
-      deleteProperty(target, prop) {
-        if (prop in target.data) {
-          delete target.data[prop as string];
-          target.isModified = true;
-          return true;
-        }
-        return false;
-      },
-    });
-  }
-
-  async save(): Promise<void> {
-    if (this.isModified || this.isNew || this.options.resave) {
-      const ttl = this.options.cookie?.maxAge
-        ? Math.floor(this.options.cookie.maxAge / 1000)
-        : 86400; // 24h default
-      await this.store.set(this.id, this.data, ttl);
-      this.isModified = false;
-      this.isNew = false;
-      logger.debug(`Session saved: ${this.id}`, 'SessionSave');
-    }
-  }
-
-  async destroy(): Promise<void> {
-    await this.store.del(this.id);
-    this.data = {};
-    this.isModified = false;
-    logger.debug(`Session destroyed: ${this.id}`, 'SessionDestroy');
-  }
-
-  async regenerate(): Promise<string> {
-    await this.destroy();
-    this.id = this.generateId();
-    this.isNew = true;
-    this.isModified = true;
-    logger.debug(`Session regenerated: ${this.id}`, 'SessionRegenerate');
-    return this.id;
-  }
-
-  async touch(): Promise<void> {
-    if (this.options.rolling) {
-      this.isModified = true;
-      await this.save();
-    }
-  }
-
-  private generateId(): string {
-    if (this.options.genid) {
-      return this.options.genid();
-    }
-
-    const crypto = require('crypto');
-    return crypto.randomBytes(24).toString('hex');
-  }
-
-  get sessionID(): string {
-    return this.id;
-  }
-}
-
-export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
-  name: 'session',
-  version: '1.0.0',
-  metadata: {
-    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');
-
-    // Merge options
-    const config: SessionOptions = {
-      store: 'memory',
-      name: 'connect.sid',
-      secret: 'moro-session-secret',
-      rolling: false,
-      resave: false,
-      saveUninitialized: false,
-      cookie: {
-        maxAge: 24 * 60 * 60 * 1000, // 24 hours
-        httpOnly: true,
-        secure: false,
-        sameSite: 'lax',
-        path: '/',
-      },
-      unset: 'keep',
-      ...options,
-      ...middlewareOptions,
-    };
-
-    // Initialize store
-    let store: CacheAdapter;
-
-    if (typeof config.store === 'string') {
-      switch (config.store) {
-        case 'redis':
-          store = new RedisCacheAdapter({
-            keyPrefix: 'sess:',
-            ...config.storeOptions,
-          });
-          break;
-        case 'file':
-          store = new FileCacheAdapter({
-            cacheDir: config.storeOptions?.path || './sessions',
-          });
-          break;
-        case 'memory':
-        default:
-          store = new MemoryCacheAdapter();
-          break;
-      }
-    } else {
-      store = config.store as CacheAdapter;
-    }
-
-    // Generate session ID
-    const generateSessionId = (): string => {
-      if (config.genid) {
-        return config.genid();
-      }
-      const crypto = require('crypto');
-      return crypto.randomBytes(24).toString('hex');
-    };
-
-    hooks.before('request', async (context: HookContext) => {
-      const req = context.request as any;
-      const res = context.response as any;
-
-      // Get session ID from cookie
-      let sessionId = req.cookies?.[config.name!];
-      let sessionData: SessionData = {};
-      let isNew = false;
-
-      if (sessionId) {
-        try {
-          sessionData = (await store.get(sessionId)) || {};
-          logger.debug(`Session loaded: ${sessionId}`, 'SessionLoad');
-        } catch (error) {
-          logger.warn(`Failed to load session: ${sessionId}`, 'SessionLoadError', { error });
-          sessionId = generateSessionId();
-          isNew = true;
-        }
-      } else {
-        sessionId = generateSessionId();
-        isNew = true;
-      }
-
-      // Create session object
-      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'),
-        });
-      }
-    });
-
-    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) {
-            await req.session.save();
-          }
-        } catch (error) {
-          logger.error('Failed to save session', 'SessionSaveError', { error });
-        }
-      }
-    });
-
-    logger.info(`Session middleware installed with ${config.store} store`, 'Installation');
-  },
-});

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

@@ -1,86 +0,0 @@
-// Server-Sent Events Middleware
-import { MiddlewareInterface, HookContext } from '../../../types/hooks';
-import { createFrameworkLogger } from '../../logger';
-
-const logger = createFrameworkLogger('SSEMiddleware');
-
-export const sse = (
-  options: {
-    heartbeat?: number;
-    retry?: number;
-    cors?: boolean;
-  } = {}
-): MiddlewareInterface => ({
-  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',
-  },
-
-  install: async (hooks: any, middlewareOptions: any = {}) => {
-    logger.debug('Installing SSE middleware', 'Installation');
-
-    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')) {
-        return;
-      }
-
-      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,
-      });
-
-      // 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.sendComment = (comment: string) => {
-        res.write(`: ${comment}\n\n`);
-      };
-
-      res.sendRetry = (ms: number) => {
-        res.write(`retry: ${ms}\n\n`);
-      };
-
-      // Set up heartbeat if configured
-      let heartbeatInterval: NodeJS.Timeout | null = null;
-      if (options.heartbeat) {
-        heartbeatInterval = setInterval(() => {
-          res.sendComment('heartbeat');
-        }, options.heartbeat);
-      }
-
-      // Set retry if configured
-      if (options.retry) {
-        res.sendRetry(options.retry);
-      }
-
-      // Clean up on close
-      req.on('close', () => {
-        if (heartbeatInterval) {
-          clearInterval(heartbeatInterval);
-        }
-        logger.debug('SSE connection closed', 'SSECleanup');
-      });
-
-      // Mark that this middleware handled the request
-      (context as any).handled = true;
-    });
-  },
-});

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

@@ -1,33 +0,0 @@
-// Validation Middleware
-import { MiddlewareInterface, HookContext } from '../../../types/hooks';
-import { createFrameworkLogger } from '../../logger';
-
-const logger = createFrameworkLogger('ValidationMiddleware');
-
-export const validation = (): MiddlewareInterface => ({
-  name: 'validation',
-  version: '1.0.0',
-  metadata: {
-    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');
-
-    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');
-          // Additional validation logic would go here
-        }
-      }
-    });
-  },
-});

package/src/core/middleware/index.ts

@@ -1,177 +0,0 @@
-// Middleware System for Moro
-import { EventEmitter } from 'events';
-import { HookManager } from '../utilities';
-import {
-  MiddlewareMetadata,
-  MiddlewareContext,
-  MiddlewareInterface,
-  SimpleMiddlewareFunction,
-  MoroMiddleware,
-} from '../../types/hooks';
-import { createFrameworkLogger } from '../logger';
-
-// Export types needed by built-in middleware
-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');
-
-  constructor() {
-    super();
-    this.hooks = new HookManager();
-  }
-
-  // Register middleware without installing
-  register(name: string, middleware: MiddlewareInterface): void {
-    if (this.middleware.has(name)) {
-      throw new Error(`Middleware ${name} is already registered`);
-    }
-
-    this.middleware.set(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') {
-      // Simple function-style middleware
-      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');
-      return;
-    }
-
-    // Advanced middleware with dependencies and lifecycle
-    const name = middleware.metadata?.name || 'unknown';
-
-    if (this.middleware.has(name)) {
-      throw new Error(`Middleware ${name} is already installed`);
-    }
-
-    // Check dependencies
-    if (middleware.metadata?.dependencies) {
-      for (const dep of middleware.metadata.dependencies) {
-        if (!this.middleware.has(dep)) {
-          throw new Error(`Dependency ${dep} not found for middleware ${name}`);
-        }
-      }
-    }
-
-    // Store middleware
-    this.middleware.set(name, middleware);
-
-    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');
-  }
-
-  // Uninstall middleware and clean up
-  uninstall(name: string): void {
-    if (!this.middleware.has(name)) {
-      throw new Error(`Middleware ${name} is not installed`);
-    }
-
-    const middleware = this.middleware.get(name)!;
-
-    this.logger.debug(`Uninstalling middleware: ${name}`, 'Uninstallation');
-
-    // Call cleanup if available
-    if (middleware.uninstall) {
-      middleware.uninstall(this.hooks);
-    }
-
-    this.middleware.delete(name);
-    this.emit('uninstalled', { name, middleware });
-    this.logger.info(`Middleware uninstalled: ${name}`, 'Uninstallation');
-  }
-
-  // Get installed middleware
-  getInstalled(): string[] {
-    return Array.from(this.middleware.keys());
-  }
-
-  // Get middleware configuration
-  getConfig(name: string): any {
-    return this.middleware.get(name)?.metadata;
-  }
-
-  // Check if middleware is installed
-  isInstalled(name: string): boolean {
-    return this.middleware.has(name);
-  }
-
-  // List all registered middleware
-  list(): MiddlewareInterface[] {
-    return Array.from(this.middleware.values());
-  }
-
-  // Dependency resolution with topological sorting for optimal middleware loading
-  async installWithDependencies(
-    middleware: MiddlewareInterface[],
-    options?: Record<string, any>
-  ): Promise<void> {
-    // Advanced topological sort for dependency resolution
-    const resolved = this.topologicalSort(middleware);
-
-    for (const middlewareItem of resolved) {
-      const middlewareOptions = options?.[middlewareItem.name];
-      await this.install(middlewareItem, middlewareOptions);
-    }
-  }
-
-  // Optimized topological sort implementation for middleware dependencies
-  private topologicalSort(middleware: MiddlewareInterface[]): MiddlewareInterface[] {
-    const visited = new Set<string>();
-    const temp = new Set<string>();
-    const result: MiddlewareInterface[] = [];
-
-    const visit = (middlewareItem: MiddlewareInterface) => {
-      if (temp.has(middlewareItem.name)) {
-        throw new Error(`Circular dependency detected: ${middlewareItem.name}`);
-      }
-
-      if (!visited.has(middlewareItem.name)) {
-        temp.add(middlewareItem.name);
-
-        // Visit dependencies first
-        if (middlewareItem.dependencies) {
-          for (const depName of middlewareItem.dependencies) {
-            const dependency = middleware.find(m => m.name === depName);
-            if (dependency) {
-              visit(dependency);
-            }
-          }
-        }
-
-        temp.delete(middlewareItem.name);
-        visited.add(middlewareItem.name);
-        result.push(middlewareItem);
-      }
-    };
-
-    for (const middlewareItem of middleware) {
-      if (!visited.has(middlewareItem.name)) {
-        visit(middlewareItem);
-      }
-    }
-
-    return result;
-  }
-}
-
-// Built-in middleware exports
-export { builtInMiddleware, simpleMiddleware } from './built-in';
-export * from './built-in';