insforge 0.3.3 → 1.2.10

package/backend/src/services/logs/log.service.ts

@@ -0,0 +1,73 @@
+import logger from '@/utils/logger.js';
+import { CloudWatchProvider } from '@/providers/logs/cloudwatch.provider.js';
+import { LocalFileProvider } from '@/providers/logs/local.provider.js';
+import { LogProvider } from '@/providers/logs/base.provider.js';
+import { LogSchema, LogSourceSchema, LogStatsSchema } from '@insforge/shared-schemas';
+import { isCloudEnvironment } from '@/utils/environment.js';
+
+export class LogService {
+  private static instance: LogService;
+  private provider!: LogProvider;
+
+  private constructor() {}
+
+  static getInstance(): LogService {
+    if (!LogService.instance) {
+      LogService.instance = new LogService();
+    }
+    return LogService.instance;
+  }
+
+  async initialize(): Promise<void> {
+    // Use CloudWatch if AWS credentials are available or if it's cloud environment since we provided the permissions in instance profile
+    // otherwise use file-based logging
+    const hasAwsCredentials =
+      (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) || isCloudEnvironment();
+
+    if (hasAwsCredentials) {
+      logger.info('Using log provider: CloudWatch');
+      this.provider = new CloudWatchProvider();
+    } else {
+      logger.info('Using log provider: File-based (no AWS credentials required)');
+      this.provider = new LocalFileProvider();
+    }
+
+    await this.provider.initialize();
+  }
+
+  getLogSources(): Promise<LogSourceSchema[]> {
+    return this.provider.getLogSources();
+  }
+
+  getLogsBySource(
+    sourceName: string,
+    limit: number = 100,
+    beforeTimestamp?: string
+  ): Promise<{
+    logs: LogSchema[];
+    total: number;
+    tableName: string;
+  }> {
+    return this.provider.getLogsBySource(sourceName, limit, beforeTimestamp);
+  }
+
+  getLogSourceStats(): Promise<LogStatsSchema[]> {
+    return this.provider.getLogSourceStats();
+  }
+
+  searchLogs(
+    query: string,
+    sourceName?: string,
+    limit: number = 100,
+    offset: number = 0
+  ): Promise<{
+    logs: (LogSchema & { source: string })[];
+    total: number;
+  }> {
+    return this.provider.searchLogs(query, sourceName, limit, offset);
+  }
+
+  async close(): Promise<void> {
+    await this.provider.close();
+  }
+}

package/backend/src/{core/secrets/secrets.ts → services/secrets/secret.service.ts}

@@ -1,8 +1,8 @@
 import { Pool } from 'pg';
 import crypto from 'crypto';
-import { DatabaseManager } from '@/core/database/manager.js';
+import { DatabaseManager } from '@/infra/database/database.manager.js';
 import logger from '@/utils/logger.js';
-import { EncryptionUtils } from './encryption.js';
+import { EncryptionManager } from '@/infra/security/encryption.manager.js';
 
 export interface SecretSchema {
   id: string;
@@ -29,11 +29,19 @@ export interface UpdateSecretInput {
   expiresAt?: Date | null;
 }
 
-export class SecretsService {
+export class SecretService {
+  private static instance: SecretService;
   private pool: Pool | null = null;
 
-  constructor() {
-    // Encryption is now handled by the shared EncryptionUtils
+  private constructor() {
+    // Encryption is now handled by the shared EncryptionManager
+  }
+
+  public static getInstance(): SecretService {
+    if (!SecretService.instance) {
+      SecretService.instance = new SecretService();
+    }
+    return SecretService.instance;
   }
 
   private getPool(): Pool {
@@ -47,11 +55,10 @@ export class SecretsService {
    * Create a new secret
    */
   async createSecret(input: CreateSecretInput): Promise<{ id: string }> {
-    const client = await this.getPool().connect();
     try {
-      const encryptedValue = EncryptionUtils.encrypt(input.value);
+      const encryptedValue = EncryptionManager.encrypt(input.value);
 
-      const result = await client.query(
+      const result = await this.getPool().query(
         `INSERT INTO _secrets (key, value_ciphertext, is_reserved, expires_at)
          VALUES ($1, $2, $3, $4)
          RETURNING id`,
@@ -63,8 +70,6 @@ export class SecretsService {
     } catch (error) {
       logger.error('Failed to create secret', { error, key: input.key });
       throw new Error('Failed to create secret');
-    } finally {
-      client.release();
     }
   }
 
@@ -72,9 +77,8 @@ export class SecretsService {
    * Get a decrypted secret by ID
    */
   async getSecretById(id: string): Promise<string | null> {
-    const client = await this.getPool().connect();
     try {
-      const result = await client.query(
+      const result = await this.getPool().query(
         `UPDATE _secrets
          SET last_used_at = NOW()
          WHERE id = $1 AND is_active = true
@@ -83,18 +87,16 @@ export class SecretsService {
         [id]
       );
 
-      if (result.rows.length === 0) {
+      if (!result.rows.length) {
         return null;
       }
 
-      const decryptedValue = EncryptionUtils.decrypt(result.rows[0].value_ciphertext);
+      const decryptedValue = EncryptionManager.decrypt(result.rows[0].value_ciphertext);
       logger.info('Secret retrieved', { id });
       return decryptedValue;
     } catch (error) {
       logger.error('Failed to get secret', { error, id });
       throw new Error('Failed to get secret');
-    } finally {
-      client.release();
     }
   }
 
@@ -102,9 +104,8 @@ export class SecretsService {
    * Get a decrypted secret by key
    */
   async getSecretByKey(key: string): Promise<string | null> {
-    const client = await this.getPool().connect();
     try {
-      const result = await client.query(
+      const result = await this.getPool().query(
         `UPDATE _secrets
          SET last_used_at = NOW()
          WHERE key = $1 AND is_active = true
@@ -113,18 +114,16 @@ export class SecretsService {
         [key]
       );
 
-      if (result.rows.length === 0) {
+      if (!result.rows.length) {
         return null;
       }
 
-      const decryptedValue = EncryptionUtils.decrypt(result.rows[0].value_ciphertext);
+      const decryptedValue = EncryptionManager.decrypt(result.rows[0].value_ciphertext);
       logger.info('Secret retrieved by key', { key });
       return decryptedValue;
     } catch (error) {
       logger.error('Failed to get secret by key', { error, key });
       throw new Error('Failed to get secret');
-    } finally {
-      client.release();
     }
   }
 
@@ -132,9 +131,8 @@ export class SecretsService {
    * List all secrets (without decrypting values)
    */
   async listSecrets(): Promise<SecretSchema[]> {
-    const client = await this.getPool().connect();
     try {
-      const result = await client.query(
+      const result = await this.getPool().query(
         `SELECT
           id,
           key,
@@ -152,8 +150,6 @@ export class SecretsService {
     } catch (error) {
       logger.error('Failed to list secrets', { error });
       throw new Error('Failed to list secrets');
-    } finally {
-      client.release();
     }
   }
 
@@ -161,14 +157,13 @@ export class SecretsService {
    * Update a secret
    */
   async updateSecret(id: string, input: UpdateSecretInput): Promise<boolean> {
-    const client = await this.getPool().connect();
     try {
       const updates: string[] = [];
       const values: (string | boolean | Date | null)[] = [];
       let paramCount = 1;
 
       if (input.value !== undefined) {
-        const encryptedValue = EncryptionUtils.encrypt(input.value);
+        const encryptedValue = EncryptionManager.encrypt(input.value);
         updates.push(`value_ciphertext = $${paramCount++}`);
         values.push(encryptedValue);
       }
@@ -190,7 +185,7 @@ export class SecretsService {
 
       values.push(id);
 
-      const result = await client.query(
+      const result = await this.getPool().query(
         `UPDATE _secrets
          SET ${updates.join(', ')}
          WHERE id = $${paramCount}`,
@@ -205,8 +200,6 @@ export class SecretsService {
     } catch (error) {
       logger.error('Failed to update secret', { error, id });
       throw new Error('Failed to update secret');
-    } finally {
-      client.release();
     }
   }
 
@@ -214,34 +207,27 @@ export class SecretsService {
    * Check if a secret value matches the stored value
    */
   async checkSecretByKey(key: string, value: string): Promise<boolean> {
-    const client = await this.getPool().connect();
     try {
-      const result = await client.query(
-        `SELECT value_ciphertext FROM _secrets
+      // Optimized: Single query that retrieves and updates in one operation
+      const result = await this.getPool().query(
+        `UPDATE _secrets
+         SET last_used_at = NOW()
          WHERE key = $1
          AND is_active = true
          AND (expires_at IS NULL OR expires_at > NOW())
-         LIMIT 1`,
+         RETURNING value_ciphertext`,
         [key]
       );
 
-      if (result.rows.length === 0) {
+      if (!result.rows.length) {
         logger.warn('Secret not found for verification', { key });
         return false;
       }
 
-      const decryptedValue = EncryptionUtils.decrypt(result.rows[0].value_ciphertext);
+      const decryptedValue = EncryptionManager.decrypt(result.rows[0].value_ciphertext);
       const matches = decryptedValue === value;
 
-      // Update last_used_at if the check was successful
       if (matches) {
-        await client.query(
-          `UPDATE _secrets
-           SET last_used_at = NOW()
-           WHERE key = $1
-           AND is_active = true`,
-          [key]
-        );
         logger.info('Secret check successful', { key });
       } else {
         logger.warn('Secret check failed - value mismatch', { key });
@@ -251,8 +237,6 @@ export class SecretsService {
     } catch (error) {
       logger.error('Failed to check secret', { error, key });
       return false;
-    } finally {
-      client.release();
     }
   }
 
@@ -260,29 +244,30 @@ export class SecretsService {
    * Delete a secret
    */
   async deleteSecret(id: string): Promise<boolean> {
-    const client = await this.getPool().connect();
     try {
-      // Check if secret is reserved first
-      const checkResult = await client.query('SELECT is_reserved FROM _secrets WHERE id = $1', [
-        id,
-      ]);
-
-      if (checkResult.rows.length > 0 && checkResult.rows[0].is_reserved) {
-        throw new Error('Cannot delete reserved secret');
-      }
-
-      const result = await client.query('DELETE FROM _secrets WHERE id = $1', [id]);
+      // Optimized: Single query with WHERE clause to prevent deleting reserved secrets
+      const result = await this.getPool().query(
+        'DELETE FROM _secrets WHERE id = $1 AND is_reserved = false',
+        [id]
+      );
 
       const success = (result.rowCount ?? 0) > 0;
       if (success) {
         logger.info('Secret deleted', { id });
+      } else {
+        // Check if it exists but is reserved
+        const checkResult = await this.getPool().query(
+          'SELECT is_reserved FROM _secrets WHERE id = $1',
+          [id]
+        );
+        if (checkResult.rows.length && checkResult.rows[0].is_reserved) {
+          throw new Error('Cannot delete reserved secret');
+        }
       }
       return success;
     } catch (error) {
       logger.error('Failed to delete secret', { error, id });
       throw new Error('Failed to delete secret');
-    } finally {
-      client.release();
     }
   }
 
@@ -296,7 +281,7 @@ export class SecretsService {
 
       const oldSecretResult = await client.query(`SELECT key FROM _secrets WHERE id = $1`, [id]);
 
-      if (oldSecretResult.rows.length === 0) {
+      if (!oldSecretResult.rows.length) {
         throw new Error('Secret not found');
       }
 
@@ -310,7 +295,7 @@ export class SecretsService {
         [id]
       );
 
-      const encryptedValue = EncryptionUtils.encrypt(newValue);
+      const encryptedValue = EncryptionManager.encrypt(newValue);
       const newSecretResult = await client.query(
         `INSERT INTO _secrets (key, value_ciphertext)
          VALUES ($1, $2)
@@ -340,9 +325,8 @@ export class SecretsService {
    * Clean up expired secrets
    */
   async cleanupExpiredSecrets(): Promise<number> {
-    const client = await this.getPool().connect();
     try {
-      const result = await client.query(
+      const result = await this.getPool().query(
         `DELETE FROM _secrets
          WHERE expires_at IS NOT NULL
          AND expires_at < NOW()
@@ -357,8 +341,6 @@ export class SecretsService {
     } catch (error) {
       logger.error('Failed to cleanup expired secrets', { error });
       throw new Error('Failed to cleanup expired secrets');
-    } finally {
-      client.release();
     }
   }