@revealui/core 0.0.1-pre.0

package/dist/core/logging/plugins/FilePlugin.ts

@@ -0,0 +1,132 @@
+/**
+ * File Logger Plugin
+ *
+ * Plugin for UnifiedLoggerV2 that writes logs to files.
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'path';
+import type { LogEntry, LoggerConfig, LoggerPlugin } from '../UnifiedLoggerV2';
+
+export interface FilePluginConfig {
+  enabled?: boolean;
+  logPath?: string;
+  maxFileSize?: number; // in bytes
+  maxFiles?: number;
+  format?: 'json' | 'text';
+}
+
+export class FilePlugin implements LoggerPlugin {
+  name = 'file';
+  private config: Required<FilePluginConfig>;
+  private currentFile: string;
+  private currentFileSize: number = 0;
+  private fileHandle: fs.FileHandle | null = null;
+
+  constructor(config: FilePluginConfig = {}) {
+    this.config = {
+      enabled: config.enabled ?? false,
+      logPath: config.logPath || './logs',
+      maxFileSize: config.maxFileSize || 10 * 1024 * 1024, // 10MB
+      maxFiles: config.maxFiles || 5,
+      format: config.format || 'json',
+    };
+    this.currentFile = path.join(this.config.logPath, `app-${Date.now()}.log`);
+  }
+
+  async initialize(_config: LoggerConfig): Promise<void> {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    try {
+      // Ensure log directory exists
+      await fs.mkdir(this.config.logPath, { recursive: true });
+
+      // Open or create log file
+      this.fileHandle = await fs.open(this.currentFile, 'a');
+      this.currentFileSize = (await this.fileHandle.stat()).size;
+    } catch (error) {
+      console.error('File plugin initialization error:', error);
+    }
+  }
+
+  async log(entry: LogEntry): Promise<void> {
+    if (!this.config.enabled || !this.fileHandle) {
+      return;
+    }
+
+    try {
+      const logLine =
+        this.config.format === 'json'
+          ? JSON.stringify(entry) + '\n'
+          : `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${entry.message}\n`;
+
+      await this.fileHandle.appendFile(logLine);
+      this.currentFileSize += Buffer.byteLength(logLine, 'utf8');
+
+      // Rotate file if needed
+      if (this.currentFileSize >= this.config.maxFileSize) {
+        await this.rotateFile();
+      }
+    } catch (error) {
+      console.error('File plugin log error:', error);
+    }
+  }
+
+  private async rotateFile(): Promise<void> {
+    if (!this.fileHandle) return;
+
+    try {
+      await this.fileHandle.close();
+      this.fileHandle = null;
+
+      // Create new file
+      this.currentFile = path.join(this.config.logPath, `app-${Date.now()}.log`);
+      this.fileHandle = await fs.open(this.currentFile, 'a');
+      this.currentFileSize = 0;
+
+      // Clean up old files
+      await this.cleanupOldFiles();
+    } catch (error) {
+      console.error('File rotation error:', error);
+    }
+  }
+
+  private async cleanupOldFiles(): Promise<void> {
+    try {
+      const files = await fs.readdir(this.config.logPath);
+      const logFiles = files
+        .filter(f => f.startsWith('app-') && f.endsWith('.log'))
+        .map(f => ({
+          name: f,
+          path: path.join(this.config.logPath, f),
+        }));
+
+      // Sort by modification time (oldest first)
+      const fileStats = await Promise.all(
+        logFiles.map(async f => ({
+          ...f,
+          stat: await fs.stat(f.path),
+        }))
+      );
+      fileStats.sort((a, b) => a.stat.mtime.getTime() - b.stat.mtime.getTime());
+
+      // Remove oldest files if we exceed maxFiles
+      if (fileStats.length > this.config.maxFiles) {
+        const filesToDelete = fileStats.slice(0, fileStats.length - this.config.maxFiles);
+        await Promise.all(filesToDelete.map(f => fs.unlink(f.path)));
+      }
+    } catch (error) {
+      console.error('File cleanup error:', error);
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    if (this.fileHandle) {
+      await this.fileHandle.close();
+      this.fileHandle = null;
+    }
+  }
+}
+

package/dist/core/logging/plugins/PayloadCMSPlugin.ts

@@ -0,0 +1,71 @@
+/**
+ * PayloadCMS Logger Plugin
+ *
+ * Plugin for UnifiedLoggerV2 that integrates with PayloadCMS logger.
+ */
+
+import type { LogEntry, LoggerConfig, LoggerPlugin } from '../UnifiedLoggerV2';
+
+export interface PayloadCMSPluginConfig {
+  payloadLike?: {
+    logger?: Record<string, (msg: string, data?: unknown) => void>;
+  } | null;
+}
+
+export class PayloadCMSPlugin implements LoggerPlugin {
+  name = 'payload';
+  private payloadLike: PayloadCMSPluginConfig['payloadLike'] = null;
+
+  async initialize(_config: LoggerConfig): Promise<void> {
+    // PayloadCMS logger will be set via setPayloadLike
+    // This is called from infrastructure setup
+  }
+
+  setPayloadLike(payloadLike: PayloadCMSPluginConfig['payloadLike']): void {
+    this.payloadLike = payloadLike;
+  }
+
+  log(entry: LogEntry): void {
+    if (!this.payloadLike?.logger) {
+      return;
+    }
+
+    try {
+      const logger = this.payloadLike.logger;
+      const message = entry.message;
+      const data = {
+        context: entry.context,
+        ...(entry.service ? { service: entry.service } : {}),
+        ...(entry.operation ? { operation: entry.operation } : {}),
+        ...(entry.userId ? { userId: entry.userId } : {}),
+        ...(entry.requestId ? { requestId: entry.requestId } : {}),
+        ...(entry.data ? { data: entry.data } : {}),
+      };
+
+      // Map log levels to PayloadCMS logger methods
+      switch (entry.level) {
+        case 'debug':
+          (logger['debug'] as ((message: string, data?: unknown) => void) | undefined)?.(
+            message,
+            data
+          );
+          break;
+        case 'info':
+        case 'success':
+          logger['info']?.(message, data);
+          break;
+        case 'warn':
+          logger['warn']?.(message, data);
+          break;
+        case 'error':
+          logger['error']?.(message, { ...data, error: entry.error });
+          break;
+      }
+    } catch (error) {
+      // Don't let PayloadCMS logging errors break the app
+      // eslint-disable-next-line reveal/enforce-reveal-logging
+      console.error('PayloadCMS plugin error:', error);
+    }
+  }
+}
+

package/dist/core/logging/plugins/RemotePlugin.ts

@@ -0,0 +1,110 @@
+/**
+ * Remote Logger Plugin
+ *
+ * Plugin for UnifiedLoggerV2 that sends logs to a remote logging service.
+ */
+
+import type { LogEntry, LoggerConfig, LoggerPlugin } from '../UnifiedLoggerV2';
+
+export interface RemotePluginConfig {
+  enabled?: boolean;
+  endpoint?: string;
+  batchSize?: number;
+  batchInterval?: number; // milliseconds
+  retryCount?: number;
+  apiKey?: string;
+}
+
+export class RemotePlugin implements LoggerPlugin {
+  name = 'remote';
+  private config: Required<RemotePluginConfig>;
+  private logBuffer: LogEntry[] = [];
+  private batchTimer: NodeJS.Timeout | null = null;
+
+  constructor(config: RemotePluginConfig = {}) {
+    this.config = {
+      enabled: config.enabled ?? false,
+      endpoint: config.endpoint || '',
+      batchSize: config.batchSize || 10,
+      batchInterval: config.batchInterval || 5000, // 5 seconds
+      retryCount: config.retryCount || 3,
+      apiKey: config.apiKey || '',
+    };
+  }
+
+  async initialize(_config: LoggerConfig): Promise<void> {
+    if (!this.config.enabled || !this.config.endpoint) {
+      return;
+    }
+
+    // Start batch timer
+    this.batchTimer = setInterval(() => {
+      this.flushBatch().catch(error => {
+        console.error('Remote plugin batch flush error:', error);
+      });
+    }, this.config.batchInterval);
+  }
+
+  async log(entry: LogEntry): Promise<void> {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    this.logBuffer.push(entry);
+
+    // Flush if buffer is full
+    if (this.logBuffer.length >= this.config.batchSize) {
+      await this.flushBatch();
+    }
+  }
+
+  private async flushBatch(): Promise<void> {
+    if (this.logBuffer.length === 0) {
+      return;
+    }
+
+    const batch = [...this.logBuffer];
+    this.logBuffer = [];
+
+    let retries = 0;
+    while (retries < this.config.retryCount) {
+      try {
+        const response = await fetch(this.config.endpoint, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            ...(this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {}),
+          },
+          body: JSON.stringify({ logs: batch }),
+        });
+
+        if (response.ok) {
+          return;
+        }
+
+        throw new Error(`Remote logging failed: ${response.statusText}`);
+      } catch (error) {
+        retries++;
+        if (retries >= this.config.retryCount) {
+          console.error('Remote plugin error after retries:', error);
+          // Re-add logs to buffer for next attempt
+          this.logBuffer.unshift(...batch);
+        } else {
+          // Wait before retry
+          await new Promise(resolve => setTimeout(resolve, 1000 * retries));
+        }
+      }
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
+
+    // Flush remaining logs
+    await this.flushBatch();
+  }
+}
+

package/dist/core/logging/plugins/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Logger Plugins
+ *
+ * Exports all available logger plugins for UnifiedLoggerV2.
+ */
+
+export { PayloadCMSPlugin } from './PayloadCMSPlugin';
+export { FilePlugin } from './FilePlugin';
+export { RemotePlugin } from './RemotePlugin';
+export type { LoggerPlugin } from '../UnifiedLoggerV2';
+