@morojs/moro 1.0.0 → 1.0.2

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

@@ -1,8 +1,8 @@
 // AWS CloudFront CDN Adapter
-import { CDNAdapter } from "../../../../../types/cdn";
-import { createFrameworkLogger } from "../../../../logger";
+import { CDNAdapter } from '../../../../../types/cdn';
+import { createFrameworkLogger } from '../../../../logger';
 
-const logger = createFrameworkLogger("CloudFrontCDNAdapter");
+const logger = createFrameworkLogger('CloudFrontCDNAdapter');
 
 export class CloudFrontCDNAdapter implements CDNAdapter {
   private cloudfront: any;
@@ -17,7 +17,7 @@ export class CloudFrontCDNAdapter implements CDNAdapter {
     this.distributionId = options.distributionId;
 
     try {
-      const AWS = require("aws-sdk");
+      const AWS = require('aws-sdk');
       AWS.config.update({
         accessKeyId: options.accessKeyId,
         secretAccessKey: options.secretAccessKey,
@@ -25,10 +25,10 @@ export class CloudFrontCDNAdapter implements CDNAdapter {
       });
 
       this.cloudfront = new AWS.CloudFront();
-      logger.info("CloudFront CDN adapter initialized", "CloudFront");
+      logger.info('CloudFront CDN adapter initialized', 'CloudFront');
     } catch (error) {
-      logger.error("AWS SDK not available", "CloudFront");
-      throw new Error("AWS SDK not installed. Run: npm install aws-sdk");
+      logger.error('AWS SDK not available', 'CloudFront');
+      throw new Error('AWS SDK not installed. Run: npm install aws-sdk');
     }
   }
 
@@ -40,39 +40,30 @@ export class CloudFrontCDNAdapter implements CDNAdapter {
           CallerReference: `moro-${Date.now()}`,
           Paths: {
             Quantity: urls.length,
-            Items: urls.map((url) => (url.startsWith("/") ? url : `/${url}`)),
+            Items: urls.map(url => (url.startsWith('/') ? url : `/${url}`)),
           },
         },
       };
 
       const result = await this.cloudfront.createInvalidation(params).promise();
-      logger.info(
-        `CloudFront cache purged: ${urls.length} URLs`,
-        "CloudFront",
-        {
-          invalidationId: result.Invalidation.Id,
-        },
-      );
+      logger.info(`CloudFront cache purged: ${urls.length} URLs`, 'CloudFront', {
+        invalidationId: result.Invalidation.Id,
+      });
     } catch (error) {
-      logger.error("CloudFront purge failed", "CloudFront", { error, urls });
+      logger.error('CloudFront purge failed', 'CloudFront', { error, urls });
       throw error;
     }
   }
 
   async prefetch(urls: string[]): Promise<void> {
-    logger.debug(
-      `CloudFront prefetch requested for ${urls.length} URLs`,
-      "CloudFront",
-    );
+    logger.debug(`CloudFront prefetch requested for ${urls.length} URLs`, 'CloudFront');
     // CloudFront doesn't have direct prefetch, but we can simulate with requests
   }
 
   async getStats(): Promise<any> {
     try {
       const params = { Id: this.distributionId };
-      const distribution = await this.cloudfront
-        .getDistribution(params)
-        .promise();
+      const distribution = await this.cloudfront.getDistribution(params).promise();
 
       return {
         status: distribution.Distribution.Status,
@@ -80,13 +71,13 @@ export class CloudFrontCDNAdapter implements CDNAdapter {
         enabled: distribution.Distribution.DistributionConfig.Enabled,
       };
     } catch (error) {
-      logger.error("CloudFront stats failed", "CloudFront", { error });
+      logger.error('CloudFront stats failed', 'CloudFront', { error });
       return null;
     }
   }
 
   setHeaders(response: any): void {
-    response.setHeader("Cache-Control", "public, max-age=3600");
-    response.setHeader("CloudFront-Viewer-Country", "US");
+    response.setHeader('Cache-Control', 'public, max-age=3600');
+    response.setHeader('CloudFront-Viewer-Country', 'US');
   }
 }

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

@@ -1,21 +1,21 @@
 // CDN Adapters
-export { CloudflareCDNAdapter } from "./cloudflare";
-export { CloudFrontCDNAdapter } from "./cloudfront";
-export { AzureCDNAdapter } from "./azure";
+export { CloudflareCDNAdapter } from './cloudflare';
+export { CloudFrontCDNAdapter } from './cloudfront';
+export { AzureCDNAdapter } from './azure';
 
-import { CloudflareCDNAdapter } from "./cloudflare";
-import { CloudFrontCDNAdapter } from "./cloudfront";
-import { AzureCDNAdapter } from "./azure";
-import { CDNAdapter } from "../../../../../types/cdn";
+import { CloudflareCDNAdapter } from './cloudflare';
+import { CloudFrontCDNAdapter } from './cloudfront';
+import { AzureCDNAdapter } from './azure';
+import { CDNAdapter } from '../../../../../types/cdn';
 
 // Adapter factory function for auto-loading
 export function createCDNAdapter(type: string, options: any = {}): CDNAdapter {
   switch (type.toLowerCase()) {
-    case "cloudflare":
+    case 'cloudflare':
       return new CloudflareCDNAdapter(options);
-    case "cloudfront":
+    case 'cloudfront':
       return new CloudFrontCDNAdapter(options);
-    case "azure":
+    case 'azure':
       return new AzureCDNAdapter(options);
     default:
       throw new Error(`Unknown CDN adapter type: ${type}`);

package/src/core/middleware/built-in/adapters/index.ts

@@ -1,7 +1,7 @@
 // Adapters Index
-export * from "./cache";
-export * from "./cdn";
+export * from './cache';
+export * from './cdn';
 
 // Re-export factory functions for convenience
-export { createCacheAdapter } from "./cache";
-export { createCDNAdapter } from "./cdn";
+export { createCacheAdapter } from './cache';
+export { createCDNAdapter } from './cdn';

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

@@ -1,37 +1,37 @@
 // Authentication Middleware
-import { MiddlewareInterface, HookContext } from "../../../types/hooks";
-import { createFrameworkLogger } from "../../logger";
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
 
-const logger = createFrameworkLogger("AuthMiddleware");
+const logger = createFrameworkLogger('AuthMiddleware');
 
 export const auth = (options: any = {}): MiddlewareInterface => ({
-  name: "auth",
-  version: "1.0.0",
+  name: 'auth',
+  version: '1.0.0',
   metadata: {
-    name: "auth",
-    version: "1.0.0",
-    description: "JWT authentication middleware with token validation",
-    author: "MoroJS Team",
+    name: 'auth',
+    version: '1.0.0',
+    description: 'JWT authentication middleware with token validation',
+    author: 'MoroJS Team',
   },
 
   install: async (hooks: any, options: any = {}) => {
-    logger.debug(`Installing auth middleware with options`, "Installation", {
+    logger.debug(`Installing auth middleware with options`, 'Installation', {
       options,
     });
 
-    hooks.before("request", async (context: HookContext) => {
+    hooks.before('request', async (context: HookContext) => {
       const req = context.request as any;
-      const token = req.headers?.authorization?.replace("Bearer ", "");
+      const token = req.headers?.authorization?.replace('Bearer ', '');
 
       if (token) {
         try {
           // Simple token validation (in production, use proper JWT verification)
-          if (token.startsWith("valid_")) {
-            req.user = { id: 1, role: "user" };
-            logger.debug(`Auth: Verified token for request`, "TokenValidation");
+          if (token.startsWith('valid_')) {
+            req.user = { id: 1, role: 'user' };
+            logger.debug(`Auth: Verified token for request`, 'TokenValidation');
           }
         } catch (error) {
-          throw new Error("Invalid token");
+          throw new Error('Invalid token');
         }
       }
     });

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

@@ -1,50 +1,39 @@
 // 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";
+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");
+const logger = createFrameworkLogger('CacheMiddleware');
 
 export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
-  name: "cache",
-  version: "1.0.0",
+  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",
+    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");
+    logger.debug('Installing cache middleware', 'Installation');
 
     // Initialize storage adapter
     let storageAdapter: CacheAdapter;
 
-    if (
-      options.adapter &&
-      typeof options.adapter === "object" &&
-      "get" in options.adapter
-    ) {
+    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 if (typeof options.adapter === 'string') {
+      storageAdapter = createCacheAdapter(options.adapter, options.adapterOptions);
     } else {
       // Default to memory cache
-      storageAdapter = createCacheAdapter("memory");
+      storageAdapter = createCacheAdapter('memory');
     }
 
     // Cache key generation
     const generateCacheKey = (req: any, strategy?: any): string => {
-      const prefix = options.keyPrefix || "moro:cache:";
+      const prefix = options.keyPrefix || 'moro:cache:';
 
       if (strategy?.key) {
         return `${prefix}${strategy.key(req)}`;
@@ -52,7 +41,7 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
 
       // Default key: method + path + query
       const query = new URLSearchParams(req.query || {}).toString();
-      return `${prefix}${req.method}:${req.path}${query ? `?${query}` : ""}`;
+      return `${prefix}${req.method}:${req.path}${query ? `?${query}` : ''}`;
     };
 
     // Find matching strategy
@@ -69,12 +58,12 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
       return undefined;
     };
 
-    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 cache GET requests by default
-      if (req.method !== "GET") {
+      if (req.method !== 'GET') {
         return;
       }
 
@@ -91,19 +80,19 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
         const cachedResponse = await storageAdapter.get(cacheKey);
 
         if (cachedResponse) {
-          logger.debug(`Cache hit: ${cacheKey}`, "CacheHit");
+          logger.debug(`Cache hit: ${cacheKey}`, 'CacheHit');
 
           // Set cache headers
-          res.setHeader("X-Cache", "HIT");
-          res.setHeader("X-Cache-Key", cacheKey);
+          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}`);
+            res.setHeader('Cache-Control', `public, max-age=${options.maxAge}`);
           }
 
           if (options.vary && options.vary.length > 0) {
-            res.setHeader("Vary", options.vary.join(", "));
+            res.setHeader('Vary', options.vary.join(', '));
           }
 
           // Send cached response
@@ -117,7 +106,7 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
           }
 
           if (cachedResponse.contentType) {
-            res.setHeader("Content-Type", cachedResponse.contentType);
+            res.setHeader('Content-Type', cachedResponse.contentType);
           }
 
           res.send(cachedResponse.body);
@@ -127,11 +116,11 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
           return;
         }
 
-        logger.debug(`Cache miss: ${cacheKey}`, "CacheMiss");
-        res.setHeader("X-Cache", "MISS");
-        res.setHeader("X-Cache-Key", cacheKey);
+        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", {
+        logger.error('Cache retrieval error', 'CacheError', {
           error,
           key: cacheKey,
         });
@@ -151,17 +140,14 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
             body,
             status: res.statusCode,
             headers: res.getHeaders ? res.getHeaders() : {},
-            contentType: contentType || res.getHeader("Content-Type"),
+            contentType: contentType || res.getHeader('Content-Type'),
             timestamp: Date.now(),
           };
 
           await storageAdapter.set(cacheKey, cacheData, ttl);
-          logger.debug(
-            `Response cached: ${cacheKey} (TTL: ${ttl}s)`,
-            "CacheSet",
-          );
+          logger.debug(`Response cached: ${cacheKey} (TTL: ${ttl}s)`, 'CacheSet');
         } catch (error) {
-          logger.error("Cache storage error", "CacheError", {
+          logger.error('Cache storage error', 'CacheError', {
             error,
             key: cacheKey,
           });
@@ -170,7 +156,7 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
 
       // Override response methods
       res.json = function (data: any) {
-        cacheResponse(data, "application/json");
+        cacheResponse(data, 'application/json');
         return originalJson.call(this, data);
       };
 
@@ -190,38 +176,35 @@ export const cache = (options: CacheOptions = {}): MiddlewareInterface => ({
       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 (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(", "));
+        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/" : "";
+          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",
+    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,46 +1,39 @@
 // 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";
+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");
+const logger = createFrameworkLogger('CDNMiddleware');
 
 export const cdn = (options: CDNOptions = {}): MiddlewareInterface => ({
-  name: "cdn",
-  version: "1.0.0",
+  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",
+    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");
+    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
-    ) {
+    if (options.adapter && typeof options.adapter === 'object' && 'purge' in options.adapter) {
       cdnAdapter = options.adapter as CDNAdapter;
-    } else if (typeof options.adapter === "string") {
+    } 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",
-      );
+      logger.warn('No CDN adapter configured, CDN features will be disabled', 'Installation');
       return;
     }
 
-    hooks.before("request", async (context: HookContext) => {
+    hooks.before('request', async (context: HookContext) => {
       const req = context.request as any;
       const res = context.response as any;
 
@@ -52,61 +45,46 @@ export const cdn = (options: CDNOptions = {}): MiddlewareInterface => ({
       // Add CDN methods to response
       res.purgeCDN = async (urls?: string[]) => {
         if (!cdnAdapter) {
-          logger.warn(
-            "CDN purge requested but no adapter configured",
-            "CDNPurge",
-          );
+          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",
-          );
+          logger.info(`CDN cache purged: ${urlsToPurge.join(', ')}`, 'CDNPurge');
         } catch (error) {
-          logger.error("CDN purge failed", "CDNError", { error, urls });
+          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",
-          );
+          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",
-          );
+          logger.info(`CDN prefetch requested: ${urls.join(', ')}`, 'CDNPrefetch');
         } catch (error) {
-          logger.error("CDN prefetch failed", "CDNError", { error, urls });
+          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",
-          );
+          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");
+          logger.debug('CDN stats retrieved', 'CDNStats');
           return stats;
         } catch (error) {
-          logger.error("CDN stats retrieval failed", "CDNError", { error });
+          logger.error('CDN stats retrieval failed', 'CDNError', { error });
           return null;
         }
       };
@@ -114,27 +92,22 @@ export const cdn = (options: CDNOptions = {}): MiddlewareInterface => ({
 
     // Auto-invalidation on certain patterns
     if (options.autoInvalidate && options.invalidationPatterns) {
-      hooks.after("response", async (context: HookContext) => {
+      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);
-          },
-        );
+        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",
-            );
+            logger.debug(`Auto-invalidated CDN cache for: ${req.path}`, 'CDNAutoInvalidate');
           } catch (error) {
-            logger.error("CDN auto-invalidation failed", "CDNError", {
+            logger.error('CDN auto-invalidation failed', 'CDNError', {
               error,
               path: req.path,
             });
@@ -143,8 +116,8 @@ export const cdn = (options: CDNOptions = {}): MiddlewareInterface => ({
       });
     }
 
-    logger.info("CDN middleware installed", "Installation", {
-      adapter: typeof options.adapter === "string" ? options.adapter : "custom",
+    logger.info('CDN middleware installed', 'Installation', {
+      adapter: typeof options.adapter === 'string' ? options.adapter : 'custom',
       autoInvalidate: !!options.autoInvalidate,
     });
   },