insforge 0.3.3 → 1.3.0

package/backend/src/core/logs/analytics.ts

@@ -1,76 +0,0 @@
-import { LogSource, AnalyticsLogRecord, LogSourceStats } from '@/types/logs.js';
-import logger from '@/utils/logger.js';
-import { isCloudEnvironment } from '@/utils/environment.js';
-import { LocalDBProvider } from './providers/localdb.provider.js';
-import { CloudWatchProvider } from './providers/cloudwatch.provider.js';
-import { AnalyticsProvider } from './providers/base.provider.js';
-
-export class AnalyticsManager {
-  private static instance: AnalyticsManager;
-  private provider!: AnalyticsProvider;
-
-  private constructor() {}
-
-  static getInstance(): AnalyticsManager {
-    if (!AnalyticsManager.instance) {
-      AnalyticsManager.instance = new AnalyticsManager();
-    }
-    return AnalyticsManager.instance;
-  }
-
-  async initialize(): Promise<void> {
-    // Decide provider based on explicit override or cloud environment
-    const explicitProvider = (process.env.ANALYTICS_PROVIDER || '').toLowerCase();
-    const shouldUseCloudwatch =
-      explicitProvider === 'cloudwatch' ||
-      (!explicitProvider && isCloudEnvironment() && !!process.env.CLOUDWATCH_LOG_GROUP);
-
-    logger.info(
-      `Using analytics provider: ${shouldUseCloudwatch ? 'CloudWatch' : 'LocalDB/Postgres'}`
-    );
-
-    if (shouldUseCloudwatch) {
-      this.provider = new CloudWatchProvider();
-    } else {
-      this.provider = new LocalDBProvider();
-    }
-
-    await this.provider.initialize();
-  }
-
-  async getLogSources(): Promise<LogSource[]> {
-    return this.provider.getLogSources();
-  }
-
-  async getLogsBySource(
-    sourceName: string,
-    limit: number = 100,
-    beforeTimestamp?: string
-  ): Promise<{
-    logs: AnalyticsLogRecord[];
-    total: number;
-    tableName: string;
-  }> {
-    return this.provider.getLogsBySource(sourceName, limit, beforeTimestamp);
-  }
-
-  async getLogSourceStats(): Promise<LogSourceStats[]> {
-    return this.provider.getLogSourceStats();
-  }
-
-  async searchLogs(
-    query: string,
-    sourceName?: string,
-    limit: number = 100,
-    offset: number = 0
-  ): Promise<{
-    logs: (AnalyticsLogRecord & { source: string })[];
-    total: number;
-  }> {
-    return this.provider.searchLogs(query, sourceName, limit, offset);
-  }
-
-  async close(): Promise<void> {
-    await this.provider.close();
-  }
-}

package/backend/src/core/logs/providers/localdb.provider.ts

@@ -1,246 +0,0 @@
-import { Pool } from 'pg';
-import { LogSource, AnalyticsLogRecord, LogSourceStats } from '@/types/logs.js';
-import logger from '@/utils/logger.js';
-import { BaseAnalyticsProvider } from './base.provider.js';
-
-export class LocalDBProvider extends BaseAnalyticsProvider {
-  private pool!: Pool;
-
-  async initialize(): Promise<void> {
-    this.pool = new Pool({
-      host: process.env.POSTGRES_HOST || 'localhost',
-      port: parseInt(process.env.POSTGRES_PORT || '5432'),
-      database: '_insforge',
-      user: process.env.POSTGRES_USER || 'postgres',
-      password: process.env.POSTGRES_PASSWORD || 'postgres',
-      max: 10,
-      idleTimeoutMillis: 30000,
-      connectionTimeoutMillis: 2000,
-    });
-
-    try {
-      const client = await this.pool.connect();
-      client.release();
-      logger.info('Analytics database connection established');
-    } catch (error) {
-      logger.error('Failed to connect to analytics database', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async getLogSources(): Promise<LogSource[]> {
-    const client = await this.pool.connect();
-    try {
-      const result = await client.query(`
-        SELECT id, name, token
-        FROM _analytics.sources
-        ORDER BY name
-      `);
-
-      const sourcesWithData: LogSource[] = [];
-      for (const source of result.rows) {
-        const tableName = `log_events_${source.token.replace(/-/g, '_')}`;
-        try {
-          const countResult = await client.query(`
-            SELECT COUNT(*) as count
-            FROM _analytics.${tableName}
-          `);
-          const count = parseInt(countResult.rows[0].count);
-          if (count > 0) {
-            sourcesWithData.push({
-              ...source,
-              name: this.getDisplayName(source.name),
-            });
-          }
-        } catch (error) {
-          logger.warn(`Source ${source.name} has no accessible data`, {
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-      return sourcesWithData;
-    } finally {
-      client.release();
-    }
-  }
-
-  async getLogsBySource(
-    sourceName: string,
-    limit: number = 100,
-    beforeTimestamp?: string
-  ): Promise<{
-    logs: AnalyticsLogRecord[];
-    total: number;
-    tableName: string;
-  }> {
-    const client = await this.pool.connect();
-    try {
-      // Convert display name to internal name for query
-      const internalSourceName = this.getInternalName(sourceName);
-
-      // First, get the source token to determine the table name
-      const sourceResult = await client.query(
-        `SELECT token FROM _analytics.sources WHERE name = $1`,
-        [internalSourceName]
-      );
-
-      if (sourceResult.rows.length === 0) {
-        throw new Error(`Log source '${sourceName}' not found`);
-      }
-
-      const token = sourceResult.rows[0].token;
-      const tableName = `log_events_${token.replace(/-/g, '_')}`;
-
-      // Build the query with timestamp-based pagination
-      // If no beforeTimestamp provided, use current time
-      const beforeTs = beforeTimestamp || new Date().toISOString();
-
-      const query = `
-        SELECT id, event_message, timestamp, body
-        FROM _analytics.${tableName}
-        WHERE timestamp < $1
-        ORDER BY timestamp DESC
-        LIMIT $2
-      `;
-      const params = [beforeTs, limit];
-
-      const logsResult = await client.query(query, params);
-
-      // Get total count of all records (not filtered by timestamp)
-      const countQuery = `SELECT COUNT(*) as count FROM _analytics.${tableName}`;
-      const countResult = await client.query(countQuery);
-
-      return {
-        logs: logsResult.rows,
-        total: parseInt(countResult.rows[0].count),
-        tableName: `_analytics.${tableName}`,
-      };
-    } finally {
-      client.release();
-    }
-  }
-
-  async getLogSourceStats(): Promise<LogSourceStats[]> {
-    const client = await this.pool.connect();
-    try {
-      const sources = await this.getLogSources();
-      const stats: LogSourceStats[] = [];
-
-      for (const source of sources) {
-        const tableName = `log_events_${source.token.replace(/-/g, '_')}`;
-        try {
-          const result = await client.query(`
-            SELECT
-              COUNT(*) as count,
-              MAX(timestamp) as last_activity
-            FROM _analytics.${tableName}
-          `);
-          stats.push({
-            source: source.name,
-            count: parseInt(result.rows[0].count),
-            lastActivity: result.rows[0].last_activity || '',
-          });
-        } catch (error) {
-          logger.warn(`Failed to get stats for source ${source.name}`, {
-            error: error instanceof Error ? error.message : String(error),
-          });
-          stats.push({
-            source: source.name,
-            count: 0,
-            lastActivity: '',
-          });
-        }
-      }
-      return stats.sort((a, b) => b.count - a.count);
-    } finally {
-      client.release();
-    }
-  }
-
-  async searchLogs(
-    query: string,
-    sourceName?: string,
-    limit: number = 100,
-    offset: number = 0
-  ): Promise<{
-    logs: (AnalyticsLogRecord & { source: string })[];
-    total: number;
-  }> {
-    const client = await this.pool.connect();
-    try {
-      let sources: LogSource[];
-
-      if (sourceName) {
-        // Convert display name to internal name for query
-        const internalSourceName = this.getInternalName(sourceName);
-        const sourceResult = await client.query(
-          `SELECT id, name, token FROM _analytics.sources WHERE name = $1`,
-          [internalSourceName]
-        );
-        // Apply name mapping to the result
-        sources = sourceResult.rows.map((source) => ({
-          ...source,
-          name: this.getDisplayName(source.name),
-        }));
-      } else {
-        // getLogSources already returns mapped names
-        sources = await this.getLogSources();
-      }
-
-      const results: (AnalyticsLogRecord & { source: string })[] = [];
-      let totalCount = 0;
-
-      for (const source of sources) {
-        const tableName = `log_events_${source.token.replace(/-/g, '_')}`;
-
-        try {
-          // Search in event_message and body fields
-          const searchResult = await client.query(
-            `SELECT id, event_message, timestamp, body, $1 as source
-            FROM _analytics.${tableName}
-            WHERE event_message ILIKE $2
-               OR body::text ILIKE $2
-            ORDER BY timestamp DESC
-            LIMIT $3 OFFSET $4`,
-            [source.name, `%${query}%`, limit, offset]
-          );
-
-          results.push(...searchResult.rows);
-
-          // Get count for this source
-          const countResult = await client.query(
-            `SELECT COUNT(*) as count
-            FROM _analytics.${tableName}
-            WHERE event_message ILIKE $1
-               OR body::text ILIKE $1`,
-            [`%${query}%`]
-          );
-
-          totalCount += parseInt(countResult.rows[0].count);
-        } catch (error) {
-          logger.warn(`Failed to search in source ${source.name}`, {
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-
-      // Sort combined results by timestamp
-      results.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-
-      return {
-        logs: results.slice(0, limit),
-        total: totalCount,
-      };
-    } finally {
-      client.release();
-    }
-  }
-
-  async close(): Promise<void> {
-    if (this.pool) {
-      await this.pool.end();
-    }
-  }
-}

package/backend/src/core/socket/socket.ts

@@ -1,388 +0,0 @@
-import { Server as HttpServer } from 'http';
-import { Server as SocketIOServer, Socket } from 'socket.io';
-import logger from '@/utils/logger.js';
-import { AuthService } from '../auth/auth.js';
-import {
-  ServerEvents,
-  ClientEvents,
-  SocketMessage,
-  SocketMetadata,
-  NotificationPayload,
-  SubscribePayload,
-  UnsubscribePayload,
-} from './types.js';
-import { AppError } from '@/api/middleware/error.js';
-import { ERROR_CODES, NEXT_ACTION } from '@/types/error-constants.js';
-
-const authService = AuthService.getInstance();
-
-/**
- * SocketService - Industrial-grade Socket.IO implementation
- * Follows best practices for real-time communication
- */
-export class SocketService {
-  private static instance: SocketService;
-  private io: SocketIOServer | null = null;
-  private socketMetadata: Map<string, SocketMetadata> = new Map();
-
-  private constructor() {}
-
-  /**
-   * Singleton pattern for global socket service access
-   */
-  static getInstance(): SocketService {
-    if (!SocketService.instance) {
-      SocketService.instance = new SocketService();
-    }
-    return SocketService.instance;
-  }
-
-  /**
-   * Initialize Socket.IO server
-   */
-  initialize(server: HttpServer): void {
-    this.io = new SocketIOServer(server, {
-      cors: {
-        origin: true,
-        credentials: true,
-      },
-    });
-
-    this.setupConnectionHandlers();
-    this.setupMiddleware();
-
-    logger.info('Socket.IO server initialized');
-  }
-
-  /**
-   * Setup authentication and validation middleware
-   */
-  private setupMiddleware(): void {
-    if (!this.io) {
-      return;
-    }
-
-    // Authentication middleware
-    this.io.use((socket, next) => {
-      try {
-        const token = socket.handshake.auth.token;
-        const payload = authService.verifyToken(token);
-        if (!payload.role) {
-          throw new AppError(
-            'Invalid token: missing role',
-            401,
-            ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-            NEXT_ACTION.CHECK_TOKEN
-          );
-        }
-        socket.data.user = {
-          id: payload.sub,
-          email: payload.email,
-          role: payload.role,
-        };
-
-        next();
-      } catch {
-        next(
-          new AppError(
-            'Invalid token',
-            401,
-            ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-            NEXT_ACTION.CHECK_TOKEN
-          )
-        );
-      }
-    });
-  }
-
-  /**
-   * Setup main connection handlers
-   */
-  private setupConnectionHandlers(): void {
-    if (!this.io) {
-      return;
-    }
-
-    this.io.on('connection', (socket: Socket) => {
-      this.onSocketConnect(socket);
-
-      // Setup event listeners
-      this.setupClientEventHandlers(socket);
-
-      // Handle disconnection
-      socket.on('disconnect', (reason) => {
-        this.onSocketDisconnect(socket, reason);
-      });
-
-      // Handle errors
-      socket.on('error', (error: Error) => {
-        this.onSocketError(socket, error);
-      });
-    });
-  }
-
-  /**
-   * Handle new socket connection (includes reconnections)
-   */
-  private onSocketConnect(socket: Socket): void {
-    // Initialize socket metadata
-    const metadata: SocketMetadata = {
-      userId: socket.data.user?.id,
-      role: socket.data.user?.role,
-      connectedAt: new Date(),
-      lastActivity: new Date(),
-      subscriptions: new Set(),
-    };
-
-    this.socketMetadata.set(socket.id, metadata);
-
-    // Join appropriate rooms based on user role
-    if (metadata.userId) {
-      void socket.join(`user:${metadata.userId}`);
-    }
-    if (metadata.role) {
-      void socket.join(`role:${metadata.role}`);
-    }
-
-    // Log connection with reconnection status
-    logger.info('Socket client connected', {
-      socketId: socket.id,
-      userId: metadata.userId,
-      role: metadata.role,
-      restoredSubscriptions: metadata.subscriptions.size,
-    });
-  }
-
-  /**
-   * Handle socket disconnection
-   */
-  private onSocketDisconnect(socket: Socket, reason: string): void {
-    const metadata = this.socketMetadata.get(socket.id);
-
-    logger.info('Socket client disconnected', {
-      socketId: socket.id,
-      userId: metadata?.userId,
-      reason,
-      connectionDuration: metadata ? Date.now() - metadata.connectedAt.getTime() : 0,
-    });
-
-    // Cleanup
-    this.socketMetadata.delete(socket.id);
-  }
-
-  /**
-   * Handle socket errors
-   */
-  private onSocketError(socket: Socket, error: Error): void {
-    logger.error('Socket error occurred', {
-      socketId: socket.id,
-      error: error.message,
-      stack: error.stack,
-    });
-
-    // DO NOT clean up metadata here - the socket might recover
-    // The 'disconnect' event will handle cleanup when/if the socket actually disconnects
-  }
-
-  /**
-   * Setup handlers for client events
-   */
-  private setupClientEventHandlers(socket: Socket): void {
-    // Handle subscription requests
-    socket.on(ClientEvents.SUBSCRIBE, (payload: SubscribePayload) => {
-      this.handleSubscribe(socket, payload);
-    });
-
-    // Handle unsubscription requests
-    socket.on(ClientEvents.UNSUBSCRIBE, (payload: UnsubscribePayload) => {
-      this.handleUnsubscribe(socket, payload);
-    });
-
-    // Update last activity on any event
-    socket.onAny(() => {
-      const metadata = this.socketMetadata.get(socket.id);
-      if (metadata) {
-        metadata.lastActivity = new Date();
-      }
-    });
-  }
-
-  /**
-   * Handle channel subscription
-   */
-  private handleSubscribe(socket: Socket, payload: SubscribePayload): void {
-    const metadata = this.socketMetadata.get(socket.id);
-    if (!metadata) {
-      return;
-    }
-
-    void socket.join(payload.channel);
-    metadata.subscriptions.add(payload.channel);
-
-    logger.debug('Socket subscribed to channel', {
-      socketId: socket.id,
-      channel: payload.channel,
-    });
-  }
-
-  /**
-   * Handle channel unsubscription
-   */
-  private handleUnsubscribe(socket: Socket, payload: UnsubscribePayload): void {
-    const metadata = this.socketMetadata.get(socket.id);
-    if (!metadata) {
-      return;
-    }
-
-    void socket.leave(payload.channel);
-    metadata.subscriptions.delete(payload.channel);
-
-    logger.debug('Socket unsubscribed from channel', {
-      socketId: socket.id,
-      channel: payload.channel,
-    });
-  }
-
-  /**
-   * Emit event to specific socket with type safety
-   */
-  emitToSocket<T>(socket: Socket, event: ServerEvents, payload: T): void {
-    const message: SocketMessage<T> = {
-      type: event,
-      payload,
-      timestamp: Date.now(),
-      id: this.generateMessageId(),
-    };
-    socket.emit(event, message);
-  }
-
-  /**
-   * Broadcast to all connected clients
-   */
-  broadcastToAll<T>(event: ServerEvents, payload: T): void {
-    if (!this.io) {
-      logger.warn('Socket.IO server not initialized');
-      return;
-    }
-
-    const message: SocketMessage<T> = {
-      type: event,
-      payload,
-      timestamp: Date.now(),
-      id: this.generateMessageId(),
-    };
-
-    this.io.emit(event, message);
-
-    logger.info('Broadcasted message to all clients', {
-      event,
-      clientsCount: this.getConnectionCount(),
-    });
-  }
-
-  /**
-   * Broadcast to specific room
-   */
-  broadcastToRoom<T>(room: string, event: ServerEvents, payload?: T): void {
-    if (!this.io) {
-      logger.warn('Socket.IO server not initialized');
-      return;
-    }
-
-    const message: SocketMessage<T> = {
-      type: event,
-      payload,
-      timestamp: Date.now(),
-      id: this.generateMessageId(),
-    };
-
-    this.io.to(room).emit(event, message);
-
-    logger.info('Broadcasted message to room', {
-      event,
-      room,
-    });
-  }
-
-  /**
-   * Generate unique message ID
-   */
-  private generateMessageId(): string {
-    return crypto.randomUUID();
-  }
-
-  /**
-   * Get current connection count
-   */
-  getConnectionCount(): number {
-    return this.socketMetadata.size;
-  }
-
-  /**
-   * Get connection statistics
-   */
-  getConnectionStats(): {
-    total: number;
-    authenticated: number;
-    averageConnectionTime: number;
-  } {
-    const connections = Array.from(this.socketMetadata.values());
-    const authenticated = connections.filter((m) => m.userId).length;
-    const avgTime =
-      connections.reduce((acc, m) => {
-        return acc + (Date.now() - m.connectedAt.getTime());
-      }, 0) / (connections.length || 1);
-
-    return {
-      total: connections.length,
-      authenticated,
-      averageConnectionTime: avgTime,
-    };
-  }
-
-  /**
-   * Clean up inactive connections (can be called periodically)
-   */
-  cleanupInactiveConnections(maxInactivityMs: number = 300000): void {
-    const now = Date.now();
-
-    this.socketMetadata.forEach((metadata, socketId) => {
-      const inactivityTime = now - metadata.lastActivity.getTime();
-
-      if (inactivityTime > maxInactivityMs) {
-        const socket = this.io?.sockets.sockets.get(socketId);
-        if (socket) {
-          logger.info('Disconnecting inactive socket', {
-            socketId,
-            inactivityTime,
-          });
-          socket.disconnect(true);
-        }
-      }
-    });
-  }
-
-  /**
-   * Gracefully close the Socket.IO server
-   */
-  close(): void {
-    if (this.io) {
-      // Notify all clients about server shutdown
-      this.broadcastToAll<NotificationPayload>(ServerEvents.NOTIFICATION, {
-        level: 'warning',
-        title: 'Server Shutdown',
-        message: 'Server is shutting down',
-      });
-
-      // Close all connections
-      void this.io.close();
-      logger.info('Socket.IO server closed');
-    }
-
-    // Clear metadata
-    this.socketMetadata.clear();
-  }
-}
-
-// Export singleton instance for convenience
-export const socketService = SocketService.getInstance();