@axiom-lattice/gateway 2.1.28 → 2.1.30

package/src/controllers/database-configs.ts

@@ -0,0 +1,432 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import {
+  getStoreLattice,
+  sqlDatabaseManager,
+} from "@axiom-lattice/core";
+import type {
+  DatabaseConfigStore,
+  DatabaseConfigEntry,
+  CreateDatabaseConfigRequest,
+  UpdateDatabaseConfigRequest,
+  DatabaseConfig,
+} from "@axiom-lattice/protocols";
+import { randomUUID } from "crypto";
+
+/**
+ * Database Config Controller
+ * Handles database configuration CRUD operations
+ */
+
+/**
+ * Get tenant ID from request headers
+ */
+function getTenantId(request: FastifyRequest): string {
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+/**
+ * Database config list response
+ */
+interface DatabaseConfigListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: DatabaseConfigEntry[];
+    total: number;
+  };
+}
+
+/**
+ * Database config response
+ */
+interface DatabaseConfigResponse {
+  success: boolean;
+  message: string;
+  data?: DatabaseConfigEntry;
+}
+
+/**
+ * Test connection response
+ */
+interface TestConnectionResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    connected: boolean;
+    latency?: number;
+    error?: string;
+  };
+}
+
+/**
+ * Get all database configs for a tenant
+ */
+export async function getDatabaseConfigList(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<DatabaseConfigListResponse> {
+  const tenantId = getTenantId(request);
+
+  try {
+    const storeLattice = getStoreLattice("default", "database");
+    const store: DatabaseConfigStore = storeLattice.store;
+
+    const configs = await store.getAllConfigs(tenantId);
+    
+    console.log('Backend: getAllConfigs returned:', configs);
+    if (configs.length > 0) {
+      console.log('Backend: First config key:', configs[0].key);
+    }
+
+    return {
+      success: true,
+      message: "Database configurations retrieved successfully",
+      data: {
+        records: configs,
+        total: configs.length,
+      },
+    };
+  } catch (error) {
+    console.error("Failed to get database configs:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve database configurations",
+      data: {
+        records: [],
+        total: 0,
+      },
+    };
+  }
+}
+
+/**
+ * Get database config by key
+ */
+export async function getDatabaseConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<DatabaseConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "database");
+    const store: DatabaseConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+
+    if (!config) {
+      return {
+        success: false,
+        message: "Database configuration not found",
+      };
+    }
+
+    return {
+      success: true,
+      message: "Database configuration retrieved successfully",
+      data: config,
+    };
+  } catch (error) {
+    console.error("Failed to get database config:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve database configuration",
+    };
+  }
+}
+
+/**
+ * Create new database config
+ */
+export async function createDatabaseConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<DatabaseConfigResponse> {
+  const tenantId = getTenantId(request);
+  const body = request.body as CreateDatabaseConfigRequest & { id?: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "database");
+    const store: DatabaseConfigStore = storeLattice.store;
+
+    // Check if key already exists
+    const existing = await store.getConfigByKey(tenantId, body.key);
+    if (existing) {
+      reply.code(409);
+      return {
+        success: false,
+        message: "Database configuration with this key already exists",
+      };
+    }
+
+    const id = body.id || randomUUID();
+    const config = await store.createConfig(tenantId, id, body);
+
+    // Auto-register to SqlDatabaseManager
+    try {
+      sqlDatabaseManager.registerDatabase(config.key, config.config);
+    } catch (error) {
+      console.warn("Failed to auto-register database:", error);
+    }
+
+    reply.code(201);
+    return {
+      success: true,
+      message: "Database configuration created successfully",
+      data: config,
+    };
+  } catch (error) {
+    console.error("Failed to create database config:", error);
+    return {
+      success: false,
+      message: "Failed to create database configuration",
+    };
+  }
+}
+
+/**
+ * Update database config
+ */
+export async function updateDatabaseConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<DatabaseConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+  const updates = request.body as Partial<UpdateDatabaseConfigRequest>;
+
+  try {
+    const storeLattice = getStoreLattice("default", "database");
+    const store: DatabaseConfigStore = storeLattice.store;
+
+    const existing = await store.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found",
+      };
+    }
+
+    const updated = await store.updateConfig(tenantId, existing.id, updates);
+
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update database configuration",
+      };
+    }
+
+    // Re-register to SqlDatabaseManager if config changed
+    if (updates.config) {
+      try {
+        sqlDatabaseManager.registerDatabase(updated.key, updated.config);
+      } catch (error) {
+        console.warn("Failed to re-register database:", error);
+      }
+    }
+
+    return {
+      success: true,
+      message: "Database configuration updated successfully",
+      data: updated,
+    };
+  } catch (error) {
+    console.error("Failed to update database config:", error);
+    return {
+      success: false,
+      message: "Failed to update database configuration",
+    };
+  }
+}
+
+/**
+ * Delete database config by key or id
+ */
+export async function deleteDatabaseConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<DatabaseConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { keyOrId } = request.params as { keyOrId: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "database");
+    const store: DatabaseConfigStore = storeLattice.store;
+
+    console.log('Delete request - keyOrId:', keyOrId);
+
+    // Try to find by key first, then by id
+    let config = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+
+    if (!config) {
+      // Try to find by id
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
+      }
+    }
+
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found",
+      };
+    }
+
+    console.log('Found config to delete:', { id: config.id, key: config.key });
+
+    const deleted = await store.deleteConfig(tenantId, config.id);
+
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete database configuration",
+      };
+    }
+
+    // Remove from SqlDatabaseManager
+    try {
+      if (sqlDatabaseManager.hasDatabase(configKey)) {
+        await sqlDatabaseManager.removeDatabase(configKey);
+      }
+    } catch (error) {
+      console.warn("Failed to remove from SqlDatabaseManager:", error);
+    }
+
+    return {
+      success: true,
+      message: "Database configuration deleted successfully",
+    };
+  } catch (error) {
+    console.error("Failed to delete database config:", error);
+    return {
+      success: false,
+      message: "Failed to delete database configuration",
+    };
+  }
+}
+
+/**
+ * Test database connection
+ */
+export async function testDatabaseConnection(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<TestConnectionResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "database");
+    const store: DatabaseConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found",
+      };
+    }
+
+    // Register temporarily for testing
+    const testKey = `__test_${key}_${Date.now()}`;
+    sqlDatabaseManager.registerDatabase(testKey, config.config);
+
+    const startTime = Date.now();
+    const db = sqlDatabaseManager.getDatabase(testKey);
+
+    try {
+      // Try to connect and list tables
+      await db.connect();
+      await db.listTables();
+      const latency = Date.now() - startTime;
+
+      // Disconnect gracefully with delay to ensure all operations complete
+      await new Promise(resolve => setTimeout(resolve, 100));
+      await db.disconnect();
+      
+      // Cleanup
+      await sqlDatabaseManager.removeDatabase(testKey);
+
+      return {
+        success: true,
+        message: "Connection test successful",
+        data: {
+          connected: true,
+          latency,
+        },
+      };
+    } catch (error) {
+      // Cleanup on error
+      try {
+        await db.disconnect();
+        await sqlDatabaseManager.removeDatabase(testKey);
+      } catch {}
+
+      return {
+        success: true,
+        message: "Connection test failed",
+        data: {
+          connected: false,
+          error: error instanceof Error ? error.message : "Unknown error",
+        },
+      };
+    }
+  } catch (error) {
+    console.error("Failed to test database connection:", error);
+    return {
+      success: false,
+      message: "Failed to test database connection",
+      data: {
+        connected: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      },
+    };
+  }
+}
+
+/**
+ * Register database config routes
+ */
+export function registerDatabaseConfigRoutes(app: any): void {
+  // Get all configs
+  app.get(
+    "/api/database-configs",
+    getDatabaseConfigList
+  );
+
+  // Get config by key
+  app.get(
+    "/api/database-configs/:key",
+    getDatabaseConfig
+  );
+
+  // Create config
+  app.post(
+    "/api/database-configs",
+    createDatabaseConfig
+  );
+
+  // Update config
+  app.put(
+    "/api/database-configs/:key",
+    updateDatabaseConfig
+  );
+
+  // Delete config by key or id
+  app.delete(
+    "/api/database-configs/:keyOrId",
+    deleteDatabaseConfig
+  );
+
+  // Test connection
+  app.post(
+    "/api/database-configs/:key/test",
+    testDatabaseConnection
+  );
+}