@morojs/moro 1.0.0 → 1.0.2

package/src/core/logger/outputs.ts

@@ -1,19 +1,19 @@
 // Advanced Logger Outputs
-import { writeFile, appendFile, mkdir } from "fs/promises";
-import { join, dirname } from "path";
-import { LogEntry, LogOutput } from "../../types/logger";
+import { writeFile, appendFile, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { LogEntry, LogOutput } from '../../types/logger';
 
 // File output for persistent logging
 export class FileOutput implements LogOutput {
-  name = "file";
+  name = 'file';
 
   constructor(
     private filePath: string,
     private options: {
-      format?: "json" | "pretty";
+      format?: 'json' | 'pretty';
       maxSize?: number; // MB
       rotate?: boolean;
-    } = {},
+    } = {}
   ) {}
 
   async write(entry: LogEntry): Promise<void> {
@@ -21,28 +21,26 @@ export class FileOutput implements LogOutput {
       // Ensure directory exists
       await mkdir(dirname(this.filePath), { recursive: true });
 
-      const format = this.options.format || "json";
+      const format = this.options.format || 'json';
       const line =
-        format === "json"
-          ? JSON.stringify(entry) + "\n"
-          : this.formatPretty(entry) + "\n";
+        format === 'json' ? JSON.stringify(entry) + '\n' : this.formatPretty(entry) + '\n';
 
-      await appendFile(this.filePath, line, "utf8");
+      await appendFile(this.filePath, line, 'utf8');
 
       // TODO: Implement log rotation if needed
     } catch (error) {
-      console.error("File logger error:", error);
+      console.error('File logger error:', error);
     }
   }
 
   private formatPretty(entry: LogEntry): string {
     const timestamp = entry.timestamp.toISOString();
     const level = entry.level.toUpperCase().padEnd(5);
-    const context = entry.context ? `[${entry.context}] ` : "";
+    const context = entry.context ? `[${entry.context}] ` : '';
     const metadata =
       entry.metadata && Object.keys(entry.metadata).length > 0
         ? ` ${JSON.stringify(entry.metadata)}`
-        : "";
+        : '';
 
     return `${timestamp} ${level} ${context}${entry.message}${metadata}`;
   }
@@ -50,7 +48,7 @@ export class FileOutput implements LogOutput {
 
 // HTTP webhook output for external logging services
 export class WebhookOutput implements LogOutput {
-  name = "webhook";
+  name = 'webhook';
 
   constructor(
     private url: string,
@@ -59,15 +57,15 @@ export class WebhookOutput implements LogOutput {
       batch?: boolean;
       batchSize?: number;
       timeout?: number;
-    } = {},
+    } = {}
   ) {}
 
   async write(entry: LogEntry): Promise<void> {
     try {
       const response = await fetch(this.url, {
-        method: "POST",
+        method: 'POST',
         headers: {
-          "Content-Type": "application/json",
+          'Content-Type': 'application/json',
           ...this.options.headers,
         },
         body: JSON.stringify(entry),
@@ -78,14 +76,14 @@ export class WebhookOutput implements LogOutput {
         throw new Error(`Webhook failed: ${response.status}`);
       }
     } catch (error) {
-      console.error("Webhook logger error:", error);
+      console.error('Webhook logger error:', error);
     }
   }
 }
 
 // Memory buffer output for testing and debugging
 export class MemoryOutput implements LogOutput {
-  name = "memory";
+  name = 'memory';
   private buffer: LogEntry[] = [];
 
   constructor(private maxSize: number = 1000) {}
@@ -108,21 +106,19 @@ export class MemoryOutput implements LogOutput {
 
 // Stream output for custom processing
 export class StreamOutput implements LogOutput {
-  name = "stream";
-  format?: "pretty" | "json" | "compact";
+  name = 'stream';
+  format?: 'pretty' | 'json' | 'compact';
 
   constructor(
     private stream: NodeJS.WritableStream,
-    format: "json" | "pretty" = "json",
+    format: 'json' | 'pretty' = 'json'
   ) {
     this.format = format;
   }
 
   write(entry: LogEntry): void {
     const data =
-      this.format === "json"
-        ? JSON.stringify(entry) + "\n"
-        : this.formatPretty(entry) + "\n";
+      this.format === 'json' ? JSON.stringify(entry) + '\n' : this.formatPretty(entry) + '\n';
 
     this.stream.write(data);
   }
@@ -130,7 +126,7 @@ export class StreamOutput implements LogOutput {
   private formatPretty(entry: LogEntry): string {
     const timestamp = entry.timestamp.toISOString();
     const level = entry.level.toUpperCase().padEnd(5);
-    const context = entry.context ? `[${entry.context}] ` : "";
+    const context = entry.context ? `[${entry.context}] ` : '';
     return `${timestamp} ${level} ${context}${entry.message}`;
   }
 }

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

@@ -1,37 +1,37 @@
 // File System Cache Adapter
-import { CacheAdapter } from "../../../../../types/cache";
-import { createFrameworkLogger } from "../../../../logger";
+import { CacheAdapter } from '../../../../../types/cache';
+import { createFrameworkLogger } from '../../../../logger';
 
-const logger = createFrameworkLogger("FileCacheAdapter");
+const logger = createFrameworkLogger('FileCacheAdapter');
 
 export class FileCacheAdapter implements CacheAdapter {
   private cacheDir: string;
 
   constructor(options: { cacheDir?: string } = {}) {
-    this.cacheDir = options.cacheDir || "./cache";
+    this.cacheDir = options.cacheDir || './cache';
     this.ensureCacheDir();
   }
 
   private async ensureCacheDir(): Promise<void> {
-    const fs = await import("fs/promises");
+    const fs = await import('fs/promises');
     try {
       await fs.mkdir(this.cacheDir, { recursive: true });
     } catch (error) {
-      logger.error("Failed to create cache directory", "FileCache", { error });
+      logger.error('Failed to create cache directory', 'FileCache', { error });
     }
   }
 
   private getFilePath(key: string): string {
-    const crypto = require("crypto");
-    const hash = crypto.createHash("md5").update(key).digest("hex");
+    const crypto = require('crypto');
+    const hash = crypto.createHash('md5').update(key).digest('hex');
     return `${this.cacheDir}/${hash}.json`;
   }
 
   async get(key: string): Promise<any> {
     try {
-      const fs = await import("fs/promises");
+      const fs = await import('fs/promises');
       const filePath = this.getFilePath(key);
-      const data = await fs.readFile(filePath, "utf-8");
+      const data = await fs.readFile(filePath, 'utf-8');
       const parsed = JSON.parse(data);
 
       if (Date.now() > parsed.expires) {
@@ -47,24 +47,24 @@ export class FileCacheAdapter implements CacheAdapter {
 
   async set(key: string, value: any, ttl: number = 3600): Promise<void> {
     try {
-      const fs = await import("fs/promises");
+      const fs = await import('fs/promises');
       const filePath = this.getFilePath(key);
       const expires = Date.now() + ttl * 1000;
       const data = JSON.stringify({ value, expires });
 
       await fs.writeFile(filePath, data);
-      logger.debug(`Cached item to file: ${key} (TTL: ${ttl}s)`, "FileCache");
+      logger.debug(`Cached item to file: ${key} (TTL: ${ttl}s)`, 'FileCache');
     } catch (error) {
-      logger.error("File cache set error", "FileCache", { key, error });
+      logger.error('File cache set error', 'FileCache', { key, error });
     }
   }
 
   async del(key: string): Promise<void> {
     try {
-      const fs = await import("fs/promises");
+      const fs = await import('fs/promises');
       const filePath = this.getFilePath(key);
       await fs.unlink(filePath);
-      logger.debug(`Deleted file cache item: ${key}`, "FileCache");
+      logger.debug(`Deleted file cache item: ${key}`, 'FileCache');
     } catch (error) {
       // File might not exist, which is okay
     }
@@ -72,16 +72,14 @@ export class FileCacheAdapter implements CacheAdapter {
 
   async clear(): Promise<void> {
     try {
-      const fs = await import("fs/promises");
+      const fs = await import('fs/promises');
       const files = await fs.readdir(this.cacheDir);
 
-      await Promise.all(
-        files.map((file) => fs.unlink(`${this.cacheDir}/${file}`)),
-      );
+      await Promise.all(files.map(file => fs.unlink(`${this.cacheDir}/${file}`)));
 
-      logger.debug("Cleared all file cache items", "FileCache");
+      logger.debug('Cleared all file cache items', 'FileCache');
     } catch (error) {
-      logger.error("File cache clear error", "FileCache", { error });
+      logger.error('File cache clear error', 'FileCache', { error });
     }
   }
 
@@ -92,9 +90,9 @@ export class FileCacheAdapter implements CacheAdapter {
 
   async ttl(key: string): Promise<number> {
     try {
-      const fs = await import("fs/promises");
+      const fs = await import('fs/promises');
       const filePath = this.getFilePath(key);
-      const data = await fs.readFile(filePath, "utf-8");
+      const data = await fs.readFile(filePath, 'utf-8');
       const parsed = JSON.parse(data);
 
       const remaining = Math.floor((parsed.expires - Date.now()) / 1000);

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

@@ -1,24 +1,21 @@
 // Cache Adapters
-export { MemoryCacheAdapter } from "./memory";
-export { RedisCacheAdapter } from "./redis";
-export { FileCacheAdapter } from "./file";
+export { MemoryCacheAdapter } from './memory';
+export { RedisCacheAdapter } from './redis';
+export { FileCacheAdapter } from './file';
 
-import { MemoryCacheAdapter } from "./memory";
-import { RedisCacheAdapter } from "./redis";
-import { FileCacheAdapter } from "./file";
-import { CacheAdapter } from "../../../../../types/cache";
+import { MemoryCacheAdapter } from './memory';
+import { RedisCacheAdapter } from './redis';
+import { FileCacheAdapter } from './file';
+import { CacheAdapter } from '../../../../../types/cache';
 
 // Adapter factory function for auto-loading
-export function createCacheAdapter(
-  type: string,
-  options: any = {},
-): CacheAdapter {
+export function createCacheAdapter(type: string, options: any = {}): CacheAdapter {
   switch (type.toLowerCase()) {
-    case "memory":
+    case 'memory':
       return new MemoryCacheAdapter();
-    case "redis":
+    case 'redis':
       return new RedisCacheAdapter(options);
-    case "file":
+    case 'file':
       return new FileCacheAdapter(options);
     default:
       throw new Error(`Unknown cache adapter type: ${type}`);

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

@@ -1,8 +1,8 @@
 // Memory Cache Adapter
-import { CacheAdapter } from "../../../../../types/cache";
-import { createFrameworkLogger } from "../../../../logger";
+import { CacheAdapter } from '../../../../../types/cache';
+import { createFrameworkLogger } from '../../../../logger';
 
-const logger = createFrameworkLogger("MemoryCacheAdapter");
+const logger = createFrameworkLogger('MemoryCacheAdapter');
 
 export class MemoryCacheAdapter implements CacheAdapter {
   private cache = new Map<string, { value: any; expires: number }>();
@@ -39,7 +39,7 @@ export class MemoryCacheAdapter implements CacheAdapter {
     }, ttl * 1000);
 
     this.timers.set(key, timer);
-    logger.debug(`Cached item: ${key} (TTL: ${ttl}s)`, "MemoryCache");
+    logger.debug(`Cached item: ${key} (TTL: ${ttl}s)`, 'MemoryCache');
   }
 
   async del(key: string): Promise<void> {
@@ -49,14 +49,14 @@ export class MemoryCacheAdapter implements CacheAdapter {
       clearTimeout(timer);
       this.timers.delete(key);
     }
-    logger.debug(`Deleted cache item: ${key}`, "MemoryCache");
+    logger.debug(`Deleted cache item: ${key}`, 'MemoryCache');
   }
 
   async clear(): Promise<void> {
     this.cache.clear();
-    this.timers.forEach((timer) => clearTimeout(timer));
+    this.timers.forEach(timer => clearTimeout(timer));
     this.timers.clear();
-    logger.debug("Cleared all cache items", "MemoryCache");
+    logger.debug('Cleared all cache items', 'MemoryCache');
   }
 
   async exists(key: string): Promise<boolean> {

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

@@ -1,8 +1,8 @@
 // Redis Cache Adapter
-import { CacheAdapter } from "../../../../../types/cache";
-import { createFrameworkLogger } from "../../../../logger";
+import { CacheAdapter } from '../../../../../types/cache';
+import { createFrameworkLogger } from '../../../../logger';
 
-const logger = createFrameworkLogger("RedisCacheAdapter");
+const logger = createFrameworkLogger('RedisCacheAdapter');
 
 export class RedisCacheAdapter implements CacheAdapter {
   private client: any;
@@ -14,29 +14,26 @@ export class RedisCacheAdapter implements CacheAdapter {
       password?: string;
       db?: number;
       keyPrefix?: string;
-    } = {},
+    } = {}
   ) {
     try {
-      const redis = require("redis");
+      const redis = require('redis');
       this.client = redis.createClient({
-        host: options.host || "localhost",
+        host: options.host || 'localhost',
         port: options.port || 6379,
         password: options.password,
         db: options.db || 0,
-        key_prefix: options.keyPrefix || "moro:cache:",
+        key_prefix: options.keyPrefix || 'moro:cache:',
       });
 
-      this.client.on("error", (err: Error) => {
-        logger.error("Redis cache error", "RedisCache", { error: err.message });
+      this.client.on('error', (err: Error) => {
+        logger.error('Redis cache error', 'RedisCache', { error: err.message });
       });
 
-      logger.info("Redis cache adapter initialized", "RedisCache");
+      logger.info('Redis cache adapter initialized', 'RedisCache');
     } catch (error) {
-      logger.error(
-        "Redis not available, falling back to memory cache",
-        "RedisCache",
-      );
-      throw new Error("Redis package not installed. Run: npm install redis");
+      logger.error('Redis not available, falling back to memory cache', 'RedisCache');
+      throw new Error('Redis package not installed. Run: npm install redis');
     }
   }
 
@@ -45,7 +42,7 @@ export class RedisCacheAdapter implements CacheAdapter {
       const value = await this.client.get(key);
       return value ? JSON.parse(value) : null;
     } catch (error) {
-      logger.error("Redis get error", "RedisCache", { key, error });
+      logger.error('Redis get error', 'RedisCache', { key, error });
       return null;
     }
   }
@@ -58,27 +55,27 @@ export class RedisCacheAdapter implements CacheAdapter {
       } else {
         await this.client.set(key, serialized);
       }
-      logger.debug(`Cached item in Redis: ${key} (TTL: ${ttl}s)`, "RedisCache");
+      logger.debug(`Cached item in Redis: ${key} (TTL: ${ttl}s)`, 'RedisCache');
     } catch (error) {
-      logger.error("Redis set error", "RedisCache", { key, error });
+      logger.error('Redis set error', 'RedisCache', { key, error });
     }
   }
 
   async del(key: string): Promise<void> {
     try {
       await this.client.del(key);
-      logger.debug(`Deleted Redis cache item: ${key}`, "RedisCache");
+      logger.debug(`Deleted Redis cache item: ${key}`, 'RedisCache');
     } catch (error) {
-      logger.error("Redis del error", "RedisCache", { key, error });
+      logger.error('Redis del error', 'RedisCache', { key, error });
     }
   }
 
   async clear(): Promise<void> {
     try {
       await this.client.flushdb();
-      logger.debug("Cleared all Redis cache items", "RedisCache");
+      logger.debug('Cleared all Redis cache items', 'RedisCache');
     } catch (error) {
-      logger.error("Redis clear error", "RedisCache", { error });
+      logger.error('Redis clear error', 'RedisCache', { error });
     }
   }
 
@@ -87,7 +84,7 @@ export class RedisCacheAdapter implements CacheAdapter {
       const exists = await this.client.exists(key);
       return exists === 1;
     } catch (error) {
-      logger.error("Redis exists error", "RedisCache", { key, error });
+      logger.error('Redis exists error', 'RedisCache', { key, error });
       return false;
     }
   }
@@ -96,7 +93,7 @@ export class RedisCacheAdapter implements CacheAdapter {
     try {
       return await this.client.ttl(key);
     } catch (error) {
-      logger.error("Redis TTL error", "RedisCache", { key, error });
+      logger.error('Redis TTL error', 'RedisCache', { key, error });
       return -1;
     }
   }

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

@@ -1,8 +1,8 @@
 // Azure CDN Adapter
-import { CDNAdapter } from "../../../../../types/cdn";
-import { createFrameworkLogger } from "../../../../logger";
+import { CDNAdapter } from '../../../../../types/cdn';
+import { createFrameworkLogger } from '../../../../logger';
 
-const logger = createFrameworkLogger("AzureCDNAdapter");
+const logger = createFrameworkLogger('AzureCDNAdapter');
 
 export class AzureCDNAdapter implements CDNAdapter {
   private endpoint: string;
@@ -27,7 +27,7 @@ export class AzureCDNAdapter implements CDNAdapter {
     this.endpointName = options.endpointName;
     this.endpoint = options.endpoint;
 
-    logger.info("Azure CDN adapter initialized", "AzureCDN");
+    logger.info('Azure CDN adapter initialized', 'AzureCDN');
   }
 
   async purge(urls: string[]): Promise<void> {
@@ -35,34 +35,26 @@ export class AzureCDNAdapter implements CDNAdapter {
       const purgeUrl = `https://management.azure.com/subscriptions/${this.subscriptionId}/resourceGroups/${this.resourceGroup}/providers/Microsoft.Cdn/profiles/${this.profileName}/endpoints/${this.endpointName}/purge`;
 
       const purgeData = {
-        contentPaths: urls.map((url) =>
-          url.startsWith("/") ? url : `/${url}`,
-        ),
+        contentPaths: urls.map(url => (url.startsWith('/') ? url : `/${url}`)),
       };
 
-      logger.info(
-        `Azure CDN cache purge requested: ${urls.length} URLs`,
-        "AzureCDN",
-      );
+      logger.info(`Azure CDN cache purge requested: ${urls.length} URLs`, 'AzureCDN');
 
       // Implementation would use Azure SDK or REST API calls
       // const response = await fetch(purgeUrl, { method: 'POST', body: JSON.stringify(purgeData) });
     } catch (error) {
-      logger.error("Azure CDN purge failed", "AzureCDN", { error, urls });
+      logger.error('Azure CDN purge failed', 'AzureCDN', { error, urls });
       throw error;
     }
   }
 
   async prefetch(urls: string[]): Promise<void> {
-    logger.debug(
-      `Azure CDN prefetch requested for ${urls.length} URLs`,
-      "AzureCDN",
-    );
+    logger.debug(`Azure CDN prefetch requested for ${urls.length} URLs`, 'AzureCDN');
     // Azure CDN prefetch implementation
   }
 
   setHeaders(response: any): void {
-    response.setHeader("Cache-Control", "public, max-age=3600");
-    response.setHeader("Azure-CDN-Edge-Location", "US-East");
+    response.setHeader('Cache-Control', 'public, max-age=3600');
+    response.setHeader('Azure-CDN-Edge-Location', 'US-East');
   }
 }

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

@@ -1,8 +1,8 @@
 // Cloudflare CDN Adapter
-import { CDNAdapter } from "../../../../../types/cdn";
-import { createFrameworkLogger } from "../../../../logger";
+import { CDNAdapter } from '../../../../../types/cdn';
+import { createFrameworkLogger } from '../../../../logger';
 
-const logger = createFrameworkLogger("CloudflareCDNAdapter");
+const logger = createFrameworkLogger('CloudflareCDNAdapter');
 
 export class CloudflareCDNAdapter implements CDNAdapter {
   private apiToken: string;
@@ -12,72 +12,55 @@ export class CloudflareCDNAdapter implements CDNAdapter {
     this.apiToken = options.apiToken;
     this.zoneId = options.zoneId;
 
-    logger.info("Cloudflare CDN adapter initialized", "Cloudflare");
+    logger.info('Cloudflare CDN adapter initialized', 'Cloudflare');
   }
 
   async purge(urls: string[]): Promise<void> {
     try {
-      const response = await this.cfRequest(
-        "POST",
-        `/zones/${this.zoneId}/purge_cache`,
-        {
-          files: urls,
-        },
-      );
+      const response = await this.cfRequest('POST', `/zones/${this.zoneId}/purge_cache`, {
+        files: urls,
+      });
 
       if (response.success) {
-        logger.info(
-          `Cloudflare cache purged: ${urls.length} URLs`,
-          "Cloudflare",
-        );
+        logger.info(`Cloudflare cache purged: ${urls.length} URLs`, 'Cloudflare');
       } else {
-        throw new Error("Cloudflare purge failed");
+        throw new Error('Cloudflare purge failed');
       }
     } catch (error) {
-      logger.error("Cloudflare purge failed", "Cloudflare", { error, urls });
+      logger.error('Cloudflare purge failed', 'Cloudflare', { error, urls });
       throw error;
     }
   }
 
   async prefetch(urls: string[]): Promise<void> {
     try {
-      logger.debug(
-        `Cloudflare prefetch requested for ${urls.length} URLs`,
-        "Cloudflare",
-      );
+      logger.debug(`Cloudflare prefetch requested for ${urls.length} URLs`, 'Cloudflare');
       // Cloudflare doesn't have direct prefetch, but we can use preload links
       for (const url of urls) {
         // Implementation would depend on Cloudflare Workers or edge functions
       }
     } catch (error) {
-      logger.error("Cloudflare prefetch failed", "Cloudflare", { error, urls });
+      logger.error('Cloudflare prefetch failed', 'Cloudflare', { error, urls });
     }
   }
 
   async getStats(): Promise<any> {
     try {
-      const response = await this.cfRequest(
-        "GET",
-        `/zones/${this.zoneId}/analytics/dashboard`,
-      );
+      const response = await this.cfRequest('GET', `/zones/${this.zoneId}/analytics/dashboard`);
       return response.result;
     } catch (error) {
-      logger.error("Cloudflare stats failed", "Cloudflare", { error });
+      logger.error('Cloudflare stats failed', 'Cloudflare', { error });
       return null;
     }
   }
 
   setHeaders(response: any): void {
-    response.setHeader("Cache-Control", "public, max-age=3600");
-    response.setHeader("CF-Cache-Status", "DYNAMIC");
-    response.setHeader("CF-Ray", `${Math.random().toString(36)}-DFW`);
+    response.setHeader('Cache-Control', 'public, max-age=3600');
+    response.setHeader('CF-Cache-Status', 'DYNAMIC');
+    response.setHeader('CF-Ray', `${Math.random().toString(36)}-DFW`);
   }
 
-  private async cfRequest(
-    method: string,
-    endpoint: string,
-    data?: any,
-  ): Promise<any> {
+  private async cfRequest(method: string, endpoint: string, data?: any): Promise<any> {
     const url = `https://api.cloudflare.com/client/v4${endpoint}`;
 
     try {
@@ -89,7 +72,7 @@ export class CloudflareCDNAdapter implements CDNAdapter {
 
       return response;
     } catch (error) {
-      logger.error("Cloudflare API request failed", "Cloudflare", {
+      logger.error('Cloudflare API request failed', 'Cloudflare', {
         error,
         method,
         endpoint,