@morojs/moro 1.6.2 → 1.6.3

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

@@ -1,410 +0,0 @@
-// Auth.js Authentication Middleware
-
-import crypto from 'crypto';
-import { MiddlewareInterface, HookContext } from '../../../types/hooks.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import {
-  AuthOptions,
-  AuthProvider,
-  AuthUser,
-  AuthSession,
-  AuthRequest,
-  OAuthProvider,
-  CredentialsProvider,
-  EmailProvider,
-} from '../../../types/auth.js';
-import { safeVerifyJWT, createAuthErrorResponse } from './jwt-helpers.js';
-
-const logger = createFrameworkLogger('AuthMiddleware');
-
-// Auth.js provider factory functions
-export const providers = {
-  google: (options: { clientId: string; clientSecret: string }): AuthProvider => ({
-    id: 'google',
-    name: 'Google',
-    type: 'oauth' as const,
-    authorization: 'https://accounts.google.com/oauth/authorize',
-    token: 'https://oauth2.googleapis.com/token',
-    userinfo: 'https://www.googleapis.com/oauth2/v2/userinfo',
-    ...options,
-  }),
-
-  github: (options: { clientId: string; clientSecret: string }): AuthProvider => ({
-    id: 'github',
-    name: 'GitHub',
-    type: 'oauth' as const,
-    authorization: 'https://github.com/login/oauth/authorize',
-    token: 'https://github.com/login/oauth/access_token',
-    userinfo: 'https://api.github.com/user',
-    ...options,
-  }),
-
-  discord: (options: { clientId: string; clientSecret: string }): AuthProvider => ({
-    id: 'discord',
-    name: 'Discord',
-    type: 'oauth' as const,
-    authorization: 'https://discord.com/api/oauth2/authorize',
-    token: 'https://discord.com/api/oauth2/token',
-    userinfo: 'https://discord.com/api/users/@me',
-    ...options,
-  }),
-
-  credentials: (options: {
-    name?: string;
-    credentials: Record<string, any>;
-    authorize: (credentials: any) => Promise<any>;
-  }): AuthProvider => ({
-    id: 'credentials',
-    name: options.name || 'Credentials',
-    type: 'credentials' as const,
-    ...options,
-  }),
-
-  email: (options: {
-    server: string | { host: string; port: number; auth: any };
-    from: string;
-  }): AuthProvider => ({
-    id: 'email',
-    name: 'Email',
-    type: 'email' as const,
-    ...options,
-  }),
-};
-
-// Auth.js middleware that integrates with MoroJS's hooks system
-export const auth = (options: AuthOptions): MiddlewareInterface => ({
-  name: 'auth',
-  version: '2.0.0',
-  metadata: {
-    name: 'auth',
-    version: '2.0.0',
-    description: 'Auth.js authentication middleware with OAuth, JWT, and session support',
-    author: 'MoroJS Team',
-    dependencies: [], // No dependencies - auth middleware is self-contained
-    tags: ['authentication', 'oauth', 'jwt', 'security'],
-  },
-
-  install: async (hooks: any, middlewareOptions: Partial<AuthOptions> = {}) => {
-    logger.debug('Installing Auth.js middleware', 'Installation', { options: middlewareOptions });
-
-    // Merge configuration
-    const config: AuthOptions = {
-      secret: process.env.NEXTAUTH_SECRET || process.env.AUTH_SECRET || 'default-secret',
-      session: {
-        strategy: 'jwt',
-        maxAge: 30 * 24 * 60 * 60, // 30 days
-        updateAge: 24 * 60 * 60, // 24 hours
-      },
-      basePath: '/api/auth',
-      trustHost: true,
-      debug: process.env.NODE_ENV === 'development',
-      ...options,
-      ...middlewareOptions,
-    };
-
-    if (!config.providers || config.providers.length === 0) {
-      throw new Error('At least one authentication provider must be configured');
-    }
-
-    // Initialize Auth.js
-    let authInstance: any;
-    try {
-      authInstance = await initializeAuthJS(config);
-      logger.info('Auth.js initialized successfully', 'Initialization');
-    } catch (error) {
-      logger.error('Failed to initialize Auth.js', 'InitializationError', { error });
-      throw error;
-    }
-
-    // Register hooks for request processing
-    hooks.before('request', async (context: HookContext) => {
-      const req = context.request as any;
-      const res = context.response as any;
-
-      // Handle Auth.js API routes first
-      if (req.url?.startsWith(config.basePath!)) {
-        try {
-          const response = await authInstance.handler(req, res);
-          if (response) {
-            // Auth.js handled the request, don't call next()
-            return response;
-          }
-        } catch (error) {
-          logger.error('Auth.js handler error', 'HandlerError', { error });
-          throw error;
-        }
-      }
-
-      // Add auth object to request for all other routes
-
-      // Extend request with auth methods
-      const authRequest: AuthRequest = {
-        user: undefined,
-        session: undefined,
-        token: undefined,
-        isAuthenticated: false,
-        signIn: async (provider?: string, options?: any) => {
-          return authInstance.signIn(provider, options);
-        },
-        signOut: async (options?: any) => {
-          return authInstance.signOut(options);
-        },
-        getSession: async () => {
-          return authInstance.getSession({ req });
-        },
-        getToken: async () => {
-          try {
-            return authInstance.verifyJWT(authRequest.token || '');
-          } catch (error: any) {
-            // Handle JWT errors gracefully in getToken method
-            logger.debug('Failed to verify token in getToken', 'TokenValidation', {
-              error: error.message,
-            });
-            return null;
-          }
-        },
-        getCsrfToken: async () => {
-          return authInstance.getCsrfToken();
-        },
-        getProviders: async () => {
-          return config.providers.reduce((acc: Record<string, AuthProvider>, provider) => {
-            acc[provider.id] = provider;
-            return acc;
-          }, {});
-        },
-      };
-
-      // Get session/token from request
-      let session: AuthSession | null = null;
-      let token: string | null = null;
-
-      // Try JWT token first (Authorization header)
-      const authHeader = req.headers?.authorization;
-      if (authHeader?.startsWith('Bearer ')) {
-        token = authHeader.substring(7);
-        try {
-          const decoded = await authInstance.verifyJWT(token);
-          if (decoded) {
-            session = await authInstance.getSession({ req: { ...req, token } });
-          }
-        } catch (error: any) {
-          // Handle specific JWT errors gracefully and return proper HTTP responses
-          if (error.name === 'TokenExpiredError') {
-            logger.debug('JWT token expired', 'TokenValidation', {
-              message: error.message,
-              expiredAt: error.expiredAt,
-            });
-
-            // If this is a protected route request, return a proper 401 response
-            if (req.headers.accept?.includes('application/json')) {
-              return res.status(401).json(
-                createAuthErrorResponse({
-                  type: 'expired',
-                  message: error.message,
-                  expiredAt: error.expiredAt,
-                })
-              );
-            }
-          } else if (error.name === 'JsonWebTokenError') {
-            logger.debug('Invalid JWT token format', 'TokenValidation', {
-              message: error.message,
-            });
-
-            // If this is a protected route request, return a proper 401 response
-            if (req.headers.accept?.includes('application/json')) {
-              return res.status(401).json(
-                createAuthErrorResponse({
-                  type: 'invalid',
-                  message: error.message,
-                })
-              );
-            }
-          } else if (error.name === 'NotBeforeError') {
-            logger.debug('JWT token not active yet', 'TokenValidation', {
-              message: error.message,
-              date: error.date,
-            });
-
-            // If this is a protected route request, return a proper 401 response
-            if (req.headers.accept?.includes('application/json')) {
-              return res.status(401).json(
-                createAuthErrorResponse({
-                  type: 'malformed',
-                  message: error.message,
-                  date: error.date,
-                })
-              );
-            }
-          } else {
-            logger.debug('JWT token validation failed', 'TokenValidation', {
-              error: error.message || error,
-            });
-          }
-          // Continue with unauthenticated state for non-API requests
-        }
-      }
-
-      // Try session cookie if no valid token
-      if (!session) {
-        try {
-          session = await authInstance.getSession({ req });
-        } catch (error) {
-          logger.debug('No valid session found', 'SessionValidation', { error });
-        }
-      }
-
-      // Populate auth request
-      if (session?.user) {
-        authRequest.user = session.user;
-        authRequest.session = session;
-        authRequest.token = token || undefined;
-        authRequest.isAuthenticated = true;
-
-        logger.debug('User authenticated', 'Authentication', {
-          userId: session.user.id,
-          provider: session.user.provider || 'unknown',
-        });
-      }
-
-      // Attach auth to request
-      req.auth = authRequest;
-    });
-
-    // Response processing hook
-    hooks.after('response', async (context: HookContext) => {
-      const req = context.request as any;
-
-      if (req.auth?.session) {
-        // Update session activity if needed
-        try {
-          await authInstance.updateSession(req.auth.session);
-        } catch (error) {
-          logger.warn('Failed to update session', 'SessionUpdate', { error });
-        }
-      }
-    });
-
-    logger.info(
-      `Auth.js middleware installed with ${config.providers.length} providers`,
-      'Installation'
-    );
-  },
-});
-
-// Auth.js implementation with proper JWT handling
-async function initializeAuthJS(config: AuthOptions): Promise<any> {
-  return {
-    handler: async (req: any, res: any) => {
-      // Basic Auth.js request handler
-      const path = req.url.replace(config.basePath!, '');
-
-      if (path.startsWith('/signin')) {
-        // Handle sign in
-        return handleSignIn(req, res, config);
-      } else if (path.startsWith('/signout')) {
-        // Handle sign out
-        return handleSignOut(req, res, config);
-      } else if (path.startsWith('/callback')) {
-        // Handle OAuth callback
-        return handleCallback(req, res, config);
-      } else if (path.startsWith('/session')) {
-        // Handle session endpoint
-        return handleSession(req, res, config);
-      }
-
-      return null;
-    },
-
-    getSession: async ({ req }: { req: any }) => {
-      // Basic session retrieval
-      const sessionId =
-        req.cookies?.['next-auth.session-token'] ||
-        req.cookies?.['__Secure-next-auth.session-token'];
-
-      if (sessionId && req.session) {
-        return {
-          user: req.session.user || null,
-          expires: new Date(Date.now() + config.session!.maxAge! * 1000).toISOString(),
-        };
-      }
-
-      return null;
-    },
-
-    verifyJWT: async (token: string) => {
-      const secret = process.env.JWT_SECRET || config.jwt?.secret || config.secret || '';
-
-      // Use the safe JWT verification function
-      const result = await safeVerifyJWT(token, secret);
-
-      if (!result.success) {
-        // Create a custom error that includes the structured error information
-        const customError = new Error(result.error?.message || 'JWT verification failed');
-
-        // Add the error type information for upstream handling
-        (customError as any).jwtErrorType = result.error?.type;
-        (customError as any).jwtErrorDetails = result.error;
-
-        // Map the safe error types back to standard JWT error names for compatibility
-        if (result.error?.type === 'expired') {
-          customError.name = 'TokenExpiredError';
-          (customError as any).expiredAt = result.error.expiredAt;
-        } else if (result.error?.type === 'invalid') {
-          customError.name = 'JsonWebTokenError';
-        } else if (result.error?.type === 'malformed') {
-          customError.name = 'NotBeforeError';
-          (customError as any).date = result.error.date;
-        }
-
-        throw customError;
-      }
-
-      return result.payload;
-    },
-
-    signIn: async (provider?: string, options?: any) => {
-      // Basic sign in redirect
-      return { url: `${config.basePath}/signin${provider ? `/${provider}` : ''}` };
-    },
-
-    signOut: async (options?: any) => {
-      // Basic sign out redirect
-      return { url: `${config.basePath}/signout` };
-    },
-
-    updateSession: async (session: any) => {
-      // Basic session update
-      return session;
-    },
-
-    getCsrfToken: async () => {
-      // Basic CSRF token generation
-      return crypto.randomBytes(32).toString('hex');
-    },
-  };
-}
-
-// Mock Auth.js handlers
-async function handleSignIn(req: any, res: any, config: AuthOptions) {
-  // Implementation would depend on the provider
-  logger.debug('Handling sign in request', 'SignIn');
-  return null;
-}
-
-async function handleSignOut(req: any, res: any, config: AuthOptions) {
-  // Clear session and redirect
-  logger.debug('Handling sign out request', 'SignOut');
-  return null;
-}
-
-async function handleCallback(req: any, res: any, config: AuthOptions) {
-  // Handle OAuth callback
-  logger.debug('Handling OAuth callback', 'Callback');
-  return null;
-}
-
-async function handleSession(req: any, res: any, config: AuthOptions) {
-  // Return current session
-  logger.debug('Handling session request', 'Session');
-  return null;
-}

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

@@ -1,213 +0,0 @@
-// Built-in Cache Middleware
-import crypto from 'crypto';
-import { MiddlewareInterface, HookContext } from '../../../types/hooks.js';
-import { CacheAdapter, CacheOptions, CachedResponse } from '../../../types/cache.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { createCacheAdapter } from './adapters/cache/index.js';
-
-const logger = createFrameworkLogger('CacheMiddleware');
-
-export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
-  name: 'cache',
-  version: '1.0.0',
-  metadata: {
-    name: 'cache',
-    version: '1.0.0',
-    description: 'Built-in cache middleware with pluggable storage adapters',
-    author: 'MoroJS Team',
-  },
-
-  install: async (hooks: any, middlewareOptions: any = {}) => {
-    logger.debug('Installing cache middleware', 'Installation');
-
-    // Initialize storage adapter
-    let storageAdapter: CacheAdapter;
-
-    if (options.adapter && typeof options.adapter === 'object' && 'get' in options.adapter) {
-      storageAdapter = options.adapter as CacheAdapter;
-    } else if (typeof options.adapter === 'string') {
-      storageAdapter = createCacheAdapter(options.adapter, options.adapterOptions);
-    } else {
-      // Default to memory cache
-      storageAdapter = createCacheAdapter('memory');
-    }
-
-    // Cache key generation
-    const generateCacheKey = (req: any, strategy?: any): string => {
-      const prefix = options.keyPrefix || 'moro:cache:';
-
-      if (strategy?.key) {
-        return `${prefix}${strategy.key(req)}`;
-      }
-
-      // Default key: method + path + query
-      const query = new URLSearchParams(req.query || {}).toString();
-      return `${prefix}${req.method}:${req.path}${query ? `?${query}` : ''}`;
-    };
-
-    // Find matching strategy
-    const findStrategy = (req: any): any | undefined => {
-      if (!options.strategies) return undefined;
-
-      for (const [pattern, strategy] of Object.entries(options.strategies)) {
-        const regex = new RegExp(pattern);
-        if (regex.test(req.path)) {
-          return strategy;
-        }
-      }
-
-      return undefined;
-    };
-
-    hooks.before('request', async (context: HookContext) => {
-      const req = context.request as any;
-      const res = context.response as any;
-
-      // Only cache GET requests by default
-      if (req.method !== 'GET') {
-        return;
-      }
-
-      const strategy = findStrategy(req);
-      const cacheKey = generateCacheKey(req, strategy);
-
-      // Check if caching is disabled for this request
-      if (strategy?.condition && !strategy.condition(req, res)) {
-        return;
-      }
-
-      try {
-        // Try to get from cache
-        const cachedResponse = await storageAdapter.get(cacheKey);
-
-        if (cachedResponse) {
-          logger.debug(`Cache hit: ${cacheKey}`, 'CacheHit');
-
-          // Set cache headers
-          res.setHeader('X-Cache', 'HIT');
-          res.setHeader('X-Cache-Key', cacheKey);
-
-          // Set HTTP cache headers
-          if (options.maxAge) {
-            res.setHeader('Cache-Control', `public, max-age=${options.maxAge}`);
-          }
-
-          if (options.vary && options.vary.length > 0) {
-            res.setHeader('Vary', options.vary.join(', '));
-          }
-
-          // Send cached response
-          res.status(cachedResponse.status || 200);
-
-          // Set cached headers
-          if (cachedResponse.headers) {
-            Object.entries(cachedResponse.headers).forEach(([key, value]) => {
-              res.setHeader(key, value as string);
-            });
-          }
-
-          if (cachedResponse.contentType) {
-            res.setHeader('Content-Type', cachedResponse.contentType);
-          }
-
-          res.send(cachedResponse.body);
-
-          // Mark as handled
-          (context as any).handled = true;
-          return;
-        }
-
-        logger.debug(`Cache miss: ${cacheKey}`, 'CacheMiss');
-        res.setHeader('X-Cache', 'MISS');
-        res.setHeader('X-Cache-Key', cacheKey);
-      } catch (error) {
-        logger.error('Cache retrieval error', 'CacheError', {
-          error,
-          key: cacheKey,
-        });
-      }
-
-      // Store original response methods
-      const originalJson = res.json;
-      const originalSend = res.send;
-      const originalEnd = res.end;
-
-      // Wrap response methods to cache the response
-      const cacheResponse = async (body: any, contentType?: string) => {
-        try {
-          const ttl = strategy?.ttl || options.defaultTtl || 3600;
-
-          const cacheData: CachedResponse = {
-            body,
-            status: res.statusCode,
-            headers: res.getHeaders ? res.getHeaders() : {},
-            contentType: contentType || res.getHeader('Content-Type'),
-            timestamp: Date.now(),
-          };
-
-          await storageAdapter.set(cacheKey, cacheData, ttl);
-          logger.debug(`Response cached: ${cacheKey} (TTL: ${ttl}s)`, 'CacheSet');
-        } catch (error) {
-          logger.error('Cache storage error', 'CacheError', {
-            error,
-            key: cacheKey,
-          });
-        }
-      };
-
-      // Override response methods
-      res.json = function (data: any) {
-        cacheResponse(data, 'application/json');
-        return originalJson.call(this, data);
-      };
-
-      res.send = function (data: any) {
-        cacheResponse(data);
-        return originalSend.call(this, data);
-      };
-
-      res.end = function (data?: any) {
-        if (data) {
-          cacheResponse(data);
-        }
-        return originalEnd.call(this, data);
-      };
-
-      // Add cache control methods
-      res.cacheControl = (directives: any) => {
-        const parts: string[] = [];
-
-        if (directives.public) parts.push('public');
-        if (directives.private) parts.push('private');
-        if (directives.noCache) parts.push('no-cache');
-        if (directives.noStore) parts.push('no-store');
-        if (directives.mustRevalidate) parts.push('must-revalidate');
-        if (directives.immutable) parts.push('immutable');
-
-        if (typeof directives.maxAge === 'number') parts.push(`max-age=${directives.maxAge}`);
-        if (typeof directives.staleWhileRevalidate === 'number') {
-          parts.push(`stale-while-revalidate=${directives.staleWhileRevalidate}`);
-        }
-
-        if (!res.headersSent) {
-          res.setHeader('Cache-Control', parts.join(', '));
-        }
-        return res;
-      };
-
-      // Add ETag generation
-      if (options.etag !== false) {
-        res.generateETag = (content: string | Buffer) => {
-          const hash = crypto.createHash('md5').update(content).digest('hex');
-          const prefix = options.etag === 'weak' ? 'W/' : '';
-          return `${prefix}"${hash}"`;
-        };
-      }
-    });
-
-    logger.info('Cache middleware installed', 'Installation', {
-      adapter: typeof options.adapter === 'string' ? options.adapter : 'custom',
-      strategies: Object.keys(options.strategies || {}).length,
-    });
-  },
-});