insforge 1.2.10 → 1.4.8

package/backend/src/providers/ai/openrouter.provider.ts

@@ -41,8 +41,8 @@ interface OpenRouterLimitation {
   };
 }
 
-export class AIClientService {
-  private static instance: AIClientService;
+export class OpenRouterProvider {
+  private static instance: OpenRouterProvider;
   private cloudCredentials: CloudCredentials | undefined;
   private openRouterClient: OpenAI | null = null;
   private currentApiKey: string | undefined;
@@ -51,11 +51,11 @@ export class AIClientService {
 
   private constructor() {}
 
-  static getInstance(): AIClientService {
-    if (!AIClientService.instance) {
-      AIClientService.instance = new AIClientService();
+  static getInstance(): OpenRouterProvider {
+    if (!OpenRouterProvider.instance) {
+      OpenRouterProvider.instance = new OpenRouterProvider();
     }
-    return AIClientService.instance;
+    return OpenRouterProvider.instance;
   }
 
   /**
@@ -100,9 +100,9 @@ export class AIClientService {
 
   /**
    * Get the OpenAI client, creating or updating it as needed
-   * This is the main method services should use
+   * Used internally by sendRequest()
    */
-  async getClient(): Promise<OpenAI> {
+  private async getClient(): Promise<OpenAI> {
     if (!this.openRouterClient) {
       this.openRouterClient = this.createClient(await this.getApiKey());
       return this.openRouterClient;
@@ -185,7 +185,10 @@ export class AIClientService {
         };
       }
     } catch (error) {
-      console.error('Failed to fetch remaining credits:', error);
+      logger.error('Failed to fetch remaining credits', {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
       throw error;
     }
   }
@@ -243,7 +246,10 @@ export class AIClientService {
 
         return data.openrouter.api_key;
       } catch (error) {
-        console.error('Failed to fetch cloud API key:', error);
+        logger.error('Failed to fetch cloud API key', {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        });
         throw error;
       } finally {
         // Clear the promise after completion (success or failure)
@@ -317,7 +323,10 @@ export class AIClientService {
 
         return data.openrouter.api_key;
       } catch (error) {
-        console.error('Failed to renew cloud API key:', error);
+        logger.error('Failed to renew cloud API key', {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        });
         throw error;
       } finally {
         // Clear the promise after completion (success or failure)
@@ -349,6 +358,9 @@ export class AIClientService {
         logger.info(`Received ${error.status} insufficient credits, renewing API key...`);
         await this.renewCloudApiKey();
 
+        // Get fresh client with renewed API key
+        const renewedClient = await this.getClient();
+
         // Retry with exponential backoff (3 attempts)
         const maxRetries = 3;
 
@@ -360,7 +372,7 @@ export class AIClientService {
             );
             await new Promise((resolve) => setTimeout(resolve, backoffMs));
 
-            const result = await request(client);
+            const result = await request(renewedClient);
             logger.info('Request succeeded after API key renewal');
             return result;
           } catch (retryError) {

package/backend/src/providers/database/base.provider.ts

@@ -0,0 +1,39 @@
+/**
+ * Database connection information
+ */
+export interface DatabaseConnectionInfo {
+  connectionURL: string;
+  parameters: {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    sslmode: string;
+  };
+}
+
+/**
+ * Database password information
+ */
+export interface DatabasePasswordInfo {
+  databasePassword: string;
+}
+
+/**
+ * Database provider interface
+ * Defines the contract for fetching database connection information
+ */
+export interface DatabaseProvider {
+  /**
+   * Get database connection string
+   * @returns Database connection info with masked password
+   */
+  getDatabaseConnectionString(): Promise<DatabaseConnectionInfo>;
+
+  /**
+   * Get database password
+   * @returns Database password (unmasked)
+   */
+  getDatabasePassword(): Promise<DatabasePasswordInfo>;
+}

package/backend/src/providers/database/cloud.provider.ts

@@ -0,0 +1,159 @@
+import jwt from 'jsonwebtoken';
+import axios from 'axios';
+import { z } from 'zod';
+import { config } from '@/infra/config/app.config.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { DatabaseProvider, DatabaseConnectionInfo, DatabasePasswordInfo } from './base.provider.js';
+
+/**
+ * Zod schema for validating database connection info response
+ */
+const DatabaseConnectionInfoSchema = z.object({
+  connectionURL: z.string(),
+  parameters: z.object({
+    host: z.string(),
+    port: z.number(),
+    database: z.string(),
+    user: z.string(),
+    password: z.string(),
+    sslmode: z.string(),
+  }),
+});
+
+/**
+ * Zod schema for validating database password response
+ */
+const DatabasePasswordInfoSchema = z.object({
+  databasePassword: z.string(),
+});
+
+/**
+ * Cloud database provider for fetching database connection info via Insforge cloud backend
+ */
+export class CloudDatabaseProvider implements DatabaseProvider {
+  private static instance: CloudDatabaseProvider;
+
+  private constructor() {}
+
+  public static getInstance(): CloudDatabaseProvider {
+    if (!CloudDatabaseProvider.instance) {
+      CloudDatabaseProvider.instance = new CloudDatabaseProvider();
+    }
+    return CloudDatabaseProvider.instance;
+  }
+
+  /**
+   * Generate JWT sign token for cloud API authentication
+   */
+  private generateSignToken(): string {
+    const projectId = config.cloud.projectId;
+    const jwtSecret = config.app.jwtSecret;
+
+    if (!projectId || projectId === 'local') {
+      throw new AppError(
+        'PROJECT_ID is not configured. Cannot access cloud API without cloud project setup.',
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+
+    if (!jwtSecret) {
+      throw new AppError(
+        'JWT_SECRET is not configured. Cannot generate sign token.',
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+
+    return jwt.sign({ sub: projectId }, jwtSecret, { expiresIn: '10m' });
+  }
+
+  /**
+   * Get database connection string from cloud backend
+   */
+  async getDatabaseConnectionString(): Promise<DatabaseConnectionInfo> {
+    const signToken = this.generateSignToken();
+    const url = `${config.cloud.apiHost}/projects/v1/${config.cloud.projectId}/database-connection-string`;
+
+    try {
+      const response = await axios.get(url, {
+        headers: { sign: signToken },
+        timeout: 10000,
+      });
+
+      const parsed = DatabaseConnectionInfoSchema.safeParse(response.data);
+      if (!parsed.success) {
+        throw new AppError(
+          `Invalid database connection info response: ${parsed.error.message}`,
+          500,
+          ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+
+      return parsed.data;
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      if (axios.isAxiosError(error)) {
+        const status = error.response?.status ?? 500;
+        const message = error.response?.data?.message ?? error.message;
+        throw new AppError(
+          `Failed to fetch database connection string: ${message}`,
+          status,
+          ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+      throw new AppError(
+        `Unexpected error fetching database connection string: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+
+  /**
+   * Get database password from cloud backend
+   */
+  async getDatabasePassword(): Promise<DatabasePasswordInfo> {
+    const signToken = this.generateSignToken();
+    const url = `${config.cloud.apiHost}/projects/v1/${config.cloud.projectId}/database-password`;
+
+    try {
+      const response = await axios.get(url, {
+        headers: { sign: signToken },
+        timeout: 10000,
+      });
+
+      const parsed = DatabasePasswordInfoSchema.safeParse(response.data);
+      if (!parsed.success) {
+        throw new AppError(
+          `Invalid database password response: ${parsed.error.message}`,
+          500,
+          ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+
+      return parsed.data;
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      if (axios.isAxiosError(error)) {
+        const status = error.response?.status ?? 500;
+        const message = error.response?.data?.message ?? error.message;
+        throw new AppError(
+          `Failed to fetch database password: ${message}`,
+          status,
+          ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+      throw new AppError(
+        `Unexpected error fetching database password: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+}