@morojs/moro 1.6.1 → 1.6.3

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

@@ -1,329 +0,0 @@
-// Auth.js Authentication Middleware
-
-import { MiddlewareInterface, HookContext } from '../../../types/hooks';
-import { createFrameworkLogger } from '../../logger';
-import {
-  AuthOptions,
-  AuthProvider,
-  AuthUser,
-  AuthSession,
-  AuthRequest,
-  OAuthProvider,
-  CredentialsProvider,
-  EmailProvider,
-} from '../../../types/auth';
-
-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 () => {
-          return authInstance.verifyJWT(authRequest.token || '');
-        },
-        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) {
-          logger.debug('Invalid JWT token', 'TokenValidation', { error });
-        }
-      }
-
-      // 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'
-    );
-  },
-});
-
-// Mock Auth.js implementation (would be replaced with actual Auth.js)
-async function initializeAuthJS(config: AuthOptions): Promise<any> {
-  return {
-    handler: async (req: any, res: any) => {
-      // Mock 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 }) => {
-      // Mock 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) => {
-      // Mock JWT verification
-      try {
-        // In real implementation, use jose or jsonwebtoken
-        const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
-        return payload;
-      } catch {
-        return null;
-      }
-    },
-
-    signIn: async (provider?: string, options?: any) => {
-      // Mock sign in
-      return { url: `${config.basePath}/signin${provider ? `/${provider}` : ''}` };
-    },
-
-    signOut: async (options?: any) => {
-      // Mock sign out
-      return { url: `${config.basePath}/signout` };
-    },
-
-    updateSession: async (session: any) => {
-      // Mock session update
-      return session;
-    },
-
-    getCsrfToken: async () => {
-      // Mock CSRF token generation
-      const crypto = require('crypto');
-      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,211 +0,0 @@
-// Built-in Cache Middleware
-import { MiddlewareInterface, HookContext } from '../../../types/hooks';
-import { CacheAdapter, CacheOptions, CachedResponse } from '../../../types/cache';
-import { createFrameworkLogger } from '../../logger';
-import { createCacheAdapter } from './adapters/cache';
-
-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}`);
-        }
-
-        res.setHeader('Cache-Control', parts.join(', '));
-        return res;
-      };
-
-      // Add ETag generation
-      if (options.etag !== false) {
-        res.generateETag = (content: string | Buffer) => {
-          const crypto = require('crypto');
-          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,
-    });
-  },
-});

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

@@ -1,124 +0,0 @@
-// Built-in CDN Middleware
-import { MiddlewareInterface, HookContext } from '../../../types/hooks';
-import { CDNAdapter, CDNOptions } from '../../../types/cdn';
-import { createFrameworkLogger } from '../../logger';
-import { createCDNAdapter } from './adapters/cdn';
-
-const logger = createFrameworkLogger('CDNMiddleware');
-
-export const cdn = (options: CDNOptions = {}): MiddlewareInterface => ({
-  name: 'cdn',
-  version: '1.0.0',
-  metadata: {
-    name: 'cdn',
-    version: '1.0.0',
-    description: 'Built-in CDN middleware with pluggable provider adapters',
-    author: 'MoroJS Team',
-  },
-
-  install: async (hooks: any, middlewareOptions: any = {}) => {
-    logger.debug('Installing CDN middleware', 'Installation');
-
-    // Initialize CDN adapter
-    let cdnAdapter: CDNAdapter | null = null;
-
-    if (options.adapter && typeof options.adapter === 'object' && 'purge' in options.adapter) {
-      cdnAdapter = options.adapter as CDNAdapter;
-    } else if (typeof options.adapter === 'string') {
-      cdnAdapter = createCDNAdapter(options.adapter, options.adapterOptions);
-    }
-
-    if (!cdnAdapter) {
-      logger.warn('No CDN adapter configured, CDN features will be disabled', 'Installation');
-      return;
-    }
-
-    hooks.before('request', async (context: HookContext) => {
-      const req = context.request as any;
-      const res = context.response as any;
-
-      // Set CDN headers on all responses
-      if (cdnAdapter) {
-        cdnAdapter.setHeaders(res);
-      }
-
-      // Add CDN methods to response
-      res.purgeCDN = async (urls?: string[]) => {
-        if (!cdnAdapter) {
-          logger.warn('CDN purge requested but no adapter configured', 'CDNPurge');
-          return;
-        }
-
-        try {
-          const urlsToPurge = urls || [req.path];
-          await cdnAdapter.purge(urlsToPurge);
-          logger.info(`CDN cache purged: ${urlsToPurge.join(', ')}`, 'CDNPurge');
-        } catch (error) {
-          logger.error('CDN purge failed', 'CDNError', { error, urls });
-          throw error;
-        }
-      };
-
-      res.prefetchCDN = async (urls: string[]) => {
-        if (!cdnAdapter || !cdnAdapter.prefetch) {
-          logger.warn('CDN prefetch requested but not supported by adapter', 'CDNPrefetch');
-          return;
-        }
-
-        try {
-          await cdnAdapter.prefetch(urls);
-          logger.info(`CDN prefetch requested: ${urls.join(', ')}`, 'CDNPrefetch');
-        } catch (error) {
-          logger.error('CDN prefetch failed', 'CDNError', { error, urls });
-        }
-      };
-
-      res.getCDNStats = async () => {
-        if (!cdnAdapter || !cdnAdapter.getStats) {
-          logger.warn('CDN stats requested but not supported by adapter', 'CDNStats');
-          return null;
-        }
-
-        try {
-          const stats = await cdnAdapter.getStats();
-          logger.debug('CDN stats retrieved', 'CDNStats');
-          return stats;
-        } catch (error) {
-          logger.error('CDN stats retrieval failed', 'CDNError', { error });
-          return null;
-        }
-      };
-    });
-
-    // Auto-invalidation on certain patterns
-    if (options.autoInvalidate && options.invalidationPatterns) {
-      hooks.after('response', async (context: HookContext) => {
-        const req = context.request as any;
-        const res = context.response as any;
-
-        // Check if this request matches invalidation patterns
-        const shouldInvalidate = options.invalidationPatterns?.some(pattern => {
-          const regex = new RegExp(pattern);
-          return regex.test(req.path);
-        });
-
-        if (shouldInvalidate && cdnAdapter) {
-          try {
-            await cdnAdapter.purge([req.path]);
-            logger.debug(`Auto-invalidated CDN cache for: ${req.path}`, 'CDNAutoInvalidate');
-          } catch (error) {
-            logger.error('CDN auto-invalidation failed', 'CDNError', {
-              error,
-              path: req.path,
-            });
-          }
-        }
-      });
-    }
-
-    logger.info('CDN middleware installed', 'Installation', {
-      adapter: typeof options.adapter === 'string' ? options.adapter : 'custom',
-      autoInvalidate: !!options.autoInvalidate,
-    });
-  },
-});