@morojs/moro 1.6.2 → 1.6.3

package/src/core/logger/outputs.ts

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

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

@@ -1,104 +0,0 @@
-// File System Cache Adapter
-import { CacheAdapter } from '../../../../../types/cache.js';
-import { createFrameworkLogger } from '../../../../logger/index.js';
-import crypto from 'crypto';
-
-const logger = createFrameworkLogger('FileCacheAdapter');
-
-export class FileCacheAdapter implements CacheAdapter {
-  private cacheDir: string;
-
-  constructor(options: { cacheDir?: string } = {}) {
-    this.cacheDir = options.cacheDir || './cache';
-    this.ensureCacheDir();
-  }
-
-  private async ensureCacheDir(): Promise<void> {
-    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 });
-    }
-  }
-
-  private getFilePath(key: string): string {
-    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 filePath = this.getFilePath(key);
-      const data = await fs.readFile(filePath, 'utf-8');
-      const parsed = JSON.parse(data);
-
-      if (Date.now() > parsed.expires) {
-        await this.del(key);
-        return null;
-      }
-
-      return parsed.value;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  async set(key: string, value: any, ttl: number = 3600): Promise<void> {
-    try {
-      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');
-    } catch (error) {
-      logger.error('File cache set error', 'FileCache', { key, error });
-    }
-  }
-
-  async del(key: string): Promise<void> {
-    try {
-      const fs = await import('fs/promises');
-      const filePath = this.getFilePath(key);
-      await fs.unlink(filePath);
-      logger.debug(`Deleted file cache item: ${key}`, 'FileCache');
-    } catch (error) {
-      // File might not exist, which is okay
-    }
-  }
-
-  async clear(): Promise<void> {
-    try {
-      const fs = await import('fs/promises');
-      const files = await fs.readdir(this.cacheDir);
-
-      await Promise.all(files.map(file => fs.unlink(`${this.cacheDir}/${file}`)));
-
-      logger.debug('Cleared all file cache items', 'FileCache');
-    } catch (error) {
-      logger.error('File cache clear error', 'FileCache', { error });
-    }
-  }
-
-  async exists(key: string): Promise<boolean> {
-    const value = await this.get(key);
-    return value !== null;
-  }
-
-  async ttl(key: string): Promise<number> {
-    try {
-      const fs = await import('fs/promises');
-      const filePath = this.getFilePath(key);
-      const data = await fs.readFile(filePath, 'utf-8');
-      const parsed = JSON.parse(data);
-
-      const remaining = Math.floor((parsed.expires - Date.now()) / 1000);
-      return remaining > 0 ? remaining : -1;
-    } catch (error) {
-      return -1;
-    }
-  }
-}

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

@@ -1,23 +0,0 @@
-// Cache Adapters
-export { MemoryCacheAdapter } from './memory.js';
-export { RedisCacheAdapter } from './redis.js';
-export { FileCacheAdapter } from './file.js';
-
-import { MemoryCacheAdapter } from './memory.js';
-import { RedisCacheAdapter } from './redis.js';
-import { FileCacheAdapter } from './file.js';
-import { CacheAdapter } from '../../../../../types/cache.js';
-
-// Adapter factory function for auto-loading
-export function createCacheAdapter(type: string, options: any = {}): CacheAdapter {
-  switch (type.toLowerCase()) {
-    case 'memory':
-      return new MemoryCacheAdapter();
-    case 'redis':
-      return new RedisCacheAdapter(options);
-    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,73 +0,0 @@
-// Memory Cache Adapter
-import { CacheAdapter } from '../../../../../types/cache.js';
-import { createFrameworkLogger } from '../../../../logger/index.js';
-
-const logger = createFrameworkLogger('MemoryCacheAdapter');
-
-export class MemoryCacheAdapter implements CacheAdapter {
-  private cache = new Map<string, { value: any; expires: number }>();
-  private timers = new Map<string, NodeJS.Timeout>();
-
-  async get(key: string): Promise<any> {
-    const item = this.cache.get(key);
-    if (!item) return null;
-
-    if (Date.now() > item.expires) {
-      await this.del(key);
-      return null;
-    }
-
-    return item.value;
-  }
-
-  async set(key: string, value: any, ttl: number = 3600): Promise<void> {
-    const expires = Date.now() + ttl * 1000;
-
-    // Clear existing timer
-    const existingTimer = this.timers.get(key);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
-    }
-
-    // Set new value
-    this.cache.set(key, { value, expires });
-
-    // Set expiration timer
-    const timer = setTimeout(() => {
-      this.cache.delete(key);
-      this.timers.delete(key);
-    }, ttl * 1000);
-
-    this.timers.set(key, timer);
-    logger.debug(`Cached item: ${key} (TTL: ${ttl}s)`, 'MemoryCache');
-  }
-
-  async del(key: string): Promise<void> {
-    this.cache.delete(key);
-    const timer = this.timers.get(key);
-    if (timer) {
-      clearTimeout(timer);
-      this.timers.delete(key);
-    }
-    logger.debug(`Deleted cache item: ${key}`, 'MemoryCache');
-  }
-
-  async clear(): Promise<void> {
-    this.cache.clear();
-    this.timers.forEach(timer => clearTimeout(timer));
-    this.timers.clear();
-    logger.debug('Cleared all cache items', 'MemoryCache');
-  }
-
-  async exists(key: string): Promise<boolean> {
-    return this.cache.has(key) && Date.now() <= this.cache.get(key)!.expires;
-  }
-
-  async ttl(key: string): Promise<number> {
-    const item = this.cache.get(key);
-    if (!item) return -1;
-
-    const remaining = Math.floor((item.expires - Date.now()) / 1000);
-    return remaining > 0 ? remaining : -1;
-  }
-}

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

@@ -1,114 +0,0 @@
-// Redis Cache Adapter
-import { CacheAdapter } from '../../../../../types/cache.js';
-import { createFrameworkLogger } from '../../../../logger/index.js';
-import { resolveUserPackage } from '../../../../utilities/package-utils.js';
-
-const logger = createFrameworkLogger('RedisCacheAdapter');
-
-export class RedisCacheAdapter implements CacheAdapter {
-  private client: any;
-
-  constructor(
-    options: {
-      host?: string;
-      port?: number;
-      password?: string;
-      db?: number;
-      keyPrefix?: string;
-    } = {}
-  ) {
-    this.initPromise = this.initialize(options);
-  }
-
-  private initPromise: Promise<void>;
-
-  private async initialize(options: {
-    host?: string;
-    port?: number;
-    password?: string;
-    db?: number;
-    keyPrefix?: string;
-  }): Promise<void> {
-    try {
-      const redisPath = resolveUserPackage('redis');
-      const redis = await import(redisPath);
-      this.client = redis.default.createClient({
-        host: options.host || 'localhost',
-        port: options.port || 6379,
-        password: options.password,
-        db: options.db || 0,
-        key_prefix: options.keyPrefix || 'moro:cache:',
-      });
-
-      this.client.on('error', (err: Error) => {
-        logger.error('Redis cache error', 'RedisCache', { error: err.message });
-      });
-
-      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');
-    }
-  }
-
-  async get(key: string): Promise<any> {
-    try {
-      const value = await this.client.get(key);
-      return value ? JSON.parse(value) : null;
-    } catch (error) {
-      logger.error('Redis get error', 'RedisCache', { key, error });
-      return null;
-    }
-  }
-
-  async set(key: string, value: any, ttl: number = 3600): Promise<void> {
-    try {
-      const serialized = JSON.stringify(value);
-      if (ttl > 0) {
-        await this.client.setex(key, ttl, serialized);
-      } else {
-        await this.client.set(key, serialized);
-      }
-      logger.debug(`Cached item in Redis: ${key} (TTL: ${ttl}s)`, 'RedisCache');
-    } catch (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');
-    } catch (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');
-    } catch (error) {
-      logger.error('Redis clear error', 'RedisCache', { error });
-    }
-  }
-
-  async exists(key: string): Promise<boolean> {
-    try {
-      const exists = await this.client.exists(key);
-      return exists === 1;
-    } catch (error) {
-      logger.error('Redis exists error', 'RedisCache', { key, error });
-      return false;
-    }
-  }
-
-  async ttl(key: string): Promise<number> {
-    try {
-      return await this.client.ttl(key);
-    } catch (error) {
-      logger.error('Redis TTL error', 'RedisCache', { key, error });
-      return -1;
-    }
-  }
-}

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

@@ -1,60 +0,0 @@
-// Azure CDN Adapter
-import { CDNAdapter } from '../../../../../types/cdn.js';
-import { createFrameworkLogger } from '../../../../logger/index.js';
-
-const logger = createFrameworkLogger('AzureCDNAdapter');
-
-export class AzureCDNAdapter implements CDNAdapter {
-  private endpoint: string;
-  private subscriptionId: string;
-  private resourceGroup: string;
-  private profileName: string;
-  private endpointName: string;
-
-  constructor(options: {
-    subscriptionId: string;
-    resourceGroup: string;
-    profileName: string;
-    endpointName: string;
-    endpoint: string;
-    clientId?: string;
-    clientSecret?: string;
-    tenantId?: string;
-  }) {
-    this.subscriptionId = options.subscriptionId;
-    this.resourceGroup = options.resourceGroup;
-    this.profileName = options.profileName;
-    this.endpointName = options.endpointName;
-    this.endpoint = options.endpoint;
-
-    logger.info('Azure CDN adapter initialized', 'AzureCDN');
-  }
-
-  async purge(urls: string[]): Promise<void> {
-    try {
-      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}`)),
-      };
-
-      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 });
-      throw error;
-    }
-  }
-
-  async prefetch(urls: string[]): Promise<void> {
-    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');
-  }
-}

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

@@ -1,83 +0,0 @@
-// Cloudflare CDN Adapter
-import { CDNAdapter } from '../../../../../types/cdn.js';
-import { createFrameworkLogger } from '../../../../logger/index.js';
-
-const logger = createFrameworkLogger('CloudflareCDNAdapter');
-
-export class CloudflareCDNAdapter implements CDNAdapter {
-  private apiToken: string;
-  private zoneId: string;
-
-  constructor(options: { apiToken: string; zoneId: string }) {
-    this.apiToken = options.apiToken;
-    this.zoneId = options.zoneId;
-
-    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,
-      });
-
-      if (response.success) {
-        logger.info(`Cloudflare cache purged: ${urls.length} URLs`, 'Cloudflare');
-      } else {
-        throw new Error('Cloudflare purge failed');
-      }
-    } catch (error) {
-      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');
-      // 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 });
-    }
-  }
-
-  async getStats(): Promise<any> {
-    try {
-      const response = await this.cfRequest('GET', `/zones/${this.zoneId}/analytics/dashboard`);
-      return response.result;
-    } catch (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`);
-  }
-
-  private async cfRequest(method: string, endpoint: string, data?: any): Promise<any> {
-    const url = `https://api.cloudflare.com/client/v4${endpoint}`;
-
-    try {
-      // In a real implementation, you'd use fetch or axios
-      const response = {
-        success: true,
-        result: data || {},
-      };
-
-      return response;
-    } catch (error) {
-      logger.error('Cloudflare API request failed', 'Cloudflare', {
-        error,
-        method,
-        endpoint,
-      });
-      throw error;
-    }
-  }
-}

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

@@ -1,94 +0,0 @@
-// AWS CloudFront CDN Adapter
-import { CDNAdapter } from '../../../../../types/cdn.js';
-import { createFrameworkLogger } from '../../../../logger/index.js';
-import { resolveUserPackage } from '../../../../utilities/package-utils.js';
-
-const logger = createFrameworkLogger('CloudFrontCDNAdapter');
-
-export class CloudFrontCDNAdapter implements CDNAdapter {
-  private cloudfront: any;
-  private distributionId: string;
-
-  constructor(options: {
-    accessKeyId: string;
-    secretAccessKey: string;
-    region: string;
-    distributionId: string;
-  }) {
-    this.distributionId = options.distributionId;
-    this.initPromise = this.initialize(options);
-  }
-
-  private initPromise: Promise<void>;
-
-  private async initialize(options: {
-    accessKeyId: string;
-    secretAccessKey: string;
-    region: string;
-  }): Promise<void> {
-    try {
-      const awsPath = resolveUserPackage('aws-sdk');
-      const AWS = await import(awsPath);
-      AWS.default.config.update({
-        accessKeyId: options.accessKeyId,
-        secretAccessKey: options.secretAccessKey,
-        region: options.region,
-      });
-
-      this.cloudfront = new AWS.default.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');
-    }
-  }
-
-  async purge(urls: string[]): Promise<void> {
-    try {
-      const params = {
-        DistributionId: this.distributionId,
-        InvalidationBatch: {
-          CallerReference: `moro-${Date.now()}`,
-          Paths: {
-            Quantity: urls.length,
-            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,
-      });
-    } catch (error) {
-      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');
-    // 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();
-
-      return {
-        status: distribution.Distribution.Status,
-        domainName: distribution.Distribution.DomainName,
-        enabled: distribution.Distribution.DistributionConfig.Enabled,
-      };
-    } catch (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');
-  }
-}