@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/metrics-configs.ts

@@ -1,1061 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import {
-  getStoreLattice,
-  metricsServerManager,
-  SemanticMetricsClient,
-} from "@axiom-lattice/core";
-import type {
-  MetricsServerConfigStore,
-  MetricsServerConfigEntry,
-  CreateMetricsServerConfigRequest,
-  UpdateMetricsServerConfigRequest,
-  MetricsServerConfig,
-  DataSource,
-  SemanticMetricsQueryRequest,
-  SemanticMetricsServerConfig,
-} from "@axiom-lattice/protocols";
-import { randomUUID } from "crypto";
-
-/**
- * Metrics Server Config Controller
- * Handles metrics server configuration CRUD operations
- */
-
-/**
- * Get tenant ID from authenticated user context
- * Falls back to request headers for backward compatibility
- */
-function getTenantId(request: FastifyRequest): string {
-  // First try to get from authenticated user context
-  const userTenantId = (request as any).user?.tenantId;
-  if (userTenantId) {
-    return userTenantId;
-  }
-
-  // Fallback to request headers for backward compatibility
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-/**
- * Metrics server config list response
- */
-interface MetricsServerConfigListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: MetricsServerConfigEntry[];
-    total: number;
-  };
-}
-
-/**
- * Metrics server config response
- */
-interface MetricsServerConfigResponse {
-  success: boolean;
-  message: string;
-  data?: MetricsServerConfigEntry;
-}
-
-/**
- * Test connection response
- */
-interface TestConnectionResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    connected: boolean;
-    latency?: number;
-    error?: string;
-  };
-}
-
-/**
- * List available metrics response
- */
-interface ListMetricsResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    metrics: Array<{
-      name: string;
-      type?: string;
-      description?: string;
-    }>;
-  };
-}
-
-/**
- * Query metric data response
- */
-interface QueryMetricDataResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    metricName: string;
-    dataPoints: Array<{
-      timestamp: number;
-      value: number;
-      labels?: Record<string, string>;
-    }>;
-  };
-}
-
-/**
- * Data sources list response
- */
-interface DataSourcesResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    datasources: DataSource[];
-  };
-}
-
-/**
- * Datasource metrics response
- */
-interface DatasourceMetricsResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    index: {
-      datasourceId: number;
-      datasourceName: string;
-      catalogVersion: string;
-      domainCategories: string[];
-      metrics: Array<{
-        metricName: string;
-        displayName: string;
-        domain: string;
-        shortDesc: string;
-        searchKeywords: string[];
-        registered: boolean;
-      }>;
-      tables?: Array<{
-        tableName: string;
-        displayName: string;
-        docType: string;
-        docTypeEn: string;
-        mainTable?: string;
-        lineTable?: string;
-        columnCount: number;
-        shortDesc: string;
-      }>;
-    };
-    metricsDetails: Array<{
-      datasourceId: number;
-      metricName: string;
-      displayName: string;
-      domain: string;
-      description: string;
-      dataType: string;
-      format: string;
-      defaultTimeContext: {
-        timeDimension: string;
-        label: string;
-        granularity: string;
-        window: string;
-        supportedGrains: string[];
-      };
-      supportedDimensions: Array<{
-        dim_id: string;
-        field_name: string;
-        type: string;
-        filter_operators?: string[];
-        filter_example?: object;
-        group_by_example?: string;
-      }>;
-      aiAgentContext: {
-        polarity: string;
-        synonyms: string[];
-        thresholds: Array<{
-          metric: string;
-          operator: string;
-          value: number;
-          level: string;
-        }>;
-        diagnosticWorkflow: {
-          trigger: {
-            any_of: Array<{
-              metric: string;
-              operator: string;
-              value: number;
-            }>;
-          };
-          actions: Array<{
-            type: string;
-            metric?: string;
-            dimensions?: string[];
-            intent: string;
-          }>;
-          analysis_logic: string;
-        };
-        humanReadableExplanation: string;
-      };
-    }>;
-    tablesDetails?: Array<{
-      tableName: string;
-      docType: string;
-      docTypeEn: string;
-      objTypeCode?: number;
-      mainTable?: string;
-      lineTable?: string;
-      selectSql: string;
-      columns: Array<{
-        name: string;
-        label: string;
-        description?: string;
-        type?: string;
-        example?: string;
-      } | null>;
-    }>;
-  };
-}
-
-/**
- * Semantic query response
- */
-interface SemanticQueryResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    semanticModel: string;
-    columns: string[];
-    dataPoints: Array<{
-      timestamp?: number;
-      value: number;
-      labels?: Record<string, string>;
-    }>;
-    metadata?: {
-      rowCount?: number;
-      columnCount?: number;
-    };
-  };
-}
-
-/**
- * Get all metrics server configs for a tenant
- */
-export async function getMetricsServerConfigList(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<MetricsServerConfigListResponse> {
-  const tenantId = getTenantId(request);
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const configs = await store.getAllConfigs(tenantId);
-
-    return {
-      success: true,
-      message: "Metrics server configurations retrieved successfully",
-      data: {
-        records: configs,
-        total: configs.length,
-      },
-    };
-  } catch (error) {
-    console.error("Failed to get metrics server configs:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve metrics server configurations",
-      data: {
-        records: [],
-        total: 0,
-      },
-    };
-  }
-}
-
-/**
- * Get metrics server config by key
- */
-export async function getMetricsServerConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<MetricsServerConfigResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-
-    if (!config) {
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    return {
-      success: true,
-      message: "Metrics server configuration retrieved successfully",
-      data: config,
-    };
-  } catch (error) {
-    console.error("Failed to get metrics server config:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve metrics server configuration",
-    };
-  }
-}
-
-/**
- * Create new metrics server config
- */
-export async function createMetricsServerConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<MetricsServerConfigResponse> {
-  const tenantId = getTenantId(request);
-  const body = request.body as CreateMetricsServerConfigRequest & { 
-    id?: string;
-    selectedDataSources?: string[];
-  };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    // Check if key already exists
-    const existing = await store.getConfigByKey(tenantId, body.key);
-    if (existing) {
-      reply.code(409);
-      return {
-        success: false,
-        message: "Metrics server configuration with this key already exists",
-      };
-    }
-
-    if (body.config.type === "semantic" && !body.selectedDataSources) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "selectedDataSources is required for semantic metrics servers",
-      };
-    }
-
-    const id = body.id || randomUUID();
-    const configData: CreateMetricsServerConfigRequest = {
-      key: body.key,
-      name: body.name,
-      description: body.description,
-      config: body.config.type === "semantic" 
-        ? {
-            ...body.config,
-            selectedDataSources: body.selectedDataSources || [],
-          } as SemanticMetricsServerConfig
-        : body.config,
-    };
-
-    const config = await store.createConfig(tenantId, id, configData);
-
-    // Auto-register to MetricsServerManager
-    try {
-      metricsServerManager.registerServer(tenantId, config.key, config.config);
-    } catch (error) {
-      console.warn("Failed to auto-register metrics server:", error);
-    }
-
-    reply.code(201);
-    return {
-      success: true,
-      message: "Metrics server configuration created successfully",
-      data: config,
-    };
-  } catch (error) {
-    console.error("Failed to create metrics server config:", error);
-    return {
-      success: false,
-      message: "Failed to create metrics server configuration",
-    };
-  }
-}
-
-/**
- * Update metrics server config
- */
-export async function updateMetricsServerConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<MetricsServerConfigResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-  const updates = request.body as Partial<UpdateMetricsServerConfigRequest> & {
-    selectedDataSources?: string[];
-  };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const existing = await store.getConfigByKey(tenantId, key);
-    if (!existing) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    const isSemantic = updates.config?.type === "semantic" ||
-      (existing.config.type === "semantic" && !updates.config?.type);
-
-    if (isSemantic && updates.selectedDataSources !== undefined) {
-      updates.config = {
-        ...existing.config,
-        ...updates.config,
-        type: "semantic",
-        selectedDataSources: updates.selectedDataSources,
-      } as SemanticMetricsServerConfig;
-    }
-
-    const updated = await store.updateConfig(tenantId, existing.id, updates);
-
-    if (!updated) {
-      return {
-        success: false,
-        message: "Failed to update metrics server configuration",
-      };
-    }
-
-    if (updates.config) {
-      try {
-        metricsServerManager.registerServer(tenantId, updated.key, updated.config);
-      } catch (error) {
-        console.warn("Failed to re-register metrics server:", error);
-      }
-    }
-
-    return {
-      success: true,
-      message: "Metrics server configuration updated successfully",
-      data: updated,
-    };
-  } catch (error) {
-    console.error("Failed to update metrics server config:", error);
-    return {
-      success: false,
-      message: "Failed to update metrics server configuration",
-    };
-  }
-}
-
-/**
- * Delete metrics server config by key or id
- */
-export async function deleteMetricsServerConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<MetricsServerConfigResponse> {
-  const tenantId = getTenantId(request);
-  const { keyOrId } = request.params as { keyOrId: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    // 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: "Metrics server configuration not found",
-      };
-    }
-
-    const deleted = await store.deleteConfig(tenantId, config.id);
-
-    if (!deleted) {
-      return {
-        success: false,
-        message: "Failed to delete metrics server configuration",
-      };
-    }
-
-    // Remove from MetricsServerManager
-    try {
-      if (metricsServerManager.hasServer(tenantId, configKey)) {
-        metricsServerManager.removeServer(tenantId, configKey);
-      }
-    } catch (error) {
-      console.warn("Failed to remove from MetricsServerManager:", error);
-    }
-
-    return {
-      success: true,
-      message: "Metrics server configuration deleted successfully",
-    };
-  } catch (error) {
-    console.error("Failed to delete metrics server config:", error);
-    return {
-      success: false,
-      message: "Failed to delete metrics server configuration",
-    };
-  }
-}
-
-/**
- * Test metrics server connection
- */
-export async function testMetricsServerConnection(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<TestConnectionResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    // Register temporarily for testing
-    const testKey = `__test_${key}_${Date.now()}`;
-    metricsServerManager.registerServer(tenantId, testKey, config.config);
-
-    try {
-      const client = await metricsServerManager.getClient(tenantId, testKey);
-      const result = await client.testConnection();
-
-      // Cleanup
-      metricsServerManager.removeServer(tenantId, testKey);
-
-      return {
-        success: true,
-        message: result.connected ? "Connection test successful" : "Connection test failed",
-        data: result,
-      };
-    } catch (error) {
-      // Cleanup on error
-      try {
-        metricsServerManager.removeServer(tenantId, testKey);
-      } catch { /* cleanup error, ignore */ }
-
-      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 metrics server connection:", error);
-    return {
-      success: false,
-      message: "Failed to test metrics server connection",
-      data: {
-        connected: false,
-        error: error instanceof Error ? error.message : "Unknown error",
-      },
-    };
-  }
-}
-
-/**
- * List available metrics from a server
- */
-export async function listAvailableMetrics(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<ListMetricsResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    // Ensure server is registered
-    if (!metricsServerManager.hasServer(tenantId, key)) {
-      metricsServerManager.registerServer(tenantId, key, config.config);
-    }
-
-    const client = await metricsServerManager.getClient(tenantId, key);
-    const metrics = await client.listMetrics();
-
-    return {
-      success: true,
-      message: "Metrics retrieved successfully",
-      data: {
-        metrics: metrics.map(m => ({
-          name: m.name,
-          type: m.type,
-          description: m.description,
-        })),
-      },
-    };
-  } catch (error) {
-    console.error("Failed to list metrics:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve metrics",
-    };
-  }
-}
-
-/**
- * Query metric data from a server
- */
-export async function queryMetricsData(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<QueryMetricDataResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-  const { metricName, startTime, endTime, step, labels } = request.body as {
-    metricName: string;
-    startTime?: number;
-    endTime?: number;
-    step?: number;
-    labels?: Record<string, string>;
-  };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    if (!metricName) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "metricName is required",
-      };
-    }
-
-    // Ensure server is registered
-    if (!metricsServerManager.hasServer(tenantId, key)) {
-      metricsServerManager.registerServer(tenantId, key, config.config);
-    }
-
-    const client = await metricsServerManager.getClient(tenantId, key);
-    const result = await client.queryMetricData(metricName, {
-      startTime,
-      endTime,
-      step,
-      labels,
-    });
-
-    return {
-      success: true,
-      message: "Metric data retrieved successfully",
-      data: {
-        metricName: result.metricName,
-        dataPoints: result.dataPoints,
-      },
-    };
-  } catch (error) {
-    console.error("Failed to query metric data:", error);
-    return {
-      success: false,
-      message: "Failed to query metric data",
-    };
-  }
-}
-
-/**
- * Get data sources for a semantic metrics server
- * GET /api/metrics-configs/:key/datasources
- */
-export async function getDataSources(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DataSourcesResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    if (config.config.type !== "semantic") {
-      reply.code(400);
-      return {
-        success: false,
-        message: "This endpoint is only available for semantic metrics servers",
-      };
-    }
-
-    const semanticConfig = config.config as SemanticMetricsServerConfig;
-
-    const client = new SemanticMetricsClient(semanticConfig);
-    const allDatasources = await client.getDataSources();
-
-    // Filter datasources by selectedDataSources if configured
-    const selectedIds = semanticConfig.selectedDataSources || [];
-    const filteredDatasources = selectedIds.length > 0
-      ? allDatasources.filter(ds => selectedIds.includes(String(ds.id)))
-      : allDatasources;
-
-    return {
-      success: true,
-      message: "Data sources retrieved successfully",
-      data: {
-        datasources: filteredDatasources,
-      },
-    };
-  } catch (error) {
-    console.error("Failed to get data sources:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve data sources",
-    };
-  }
-}
-
-/**
- * Get metrics for a specific data source
- * GET /api/metrics-configs/:key/datasources/:datasourceId/metrics
- */
-export async function getDatasourceMetrics(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatasourceMetricsResponse> {
-  const tenantId = getTenantId(request);
-  const { key, datasourceId } = request.params as { key: string; datasourceId: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    if (config.config.type !== "semantic") {
-      reply.code(400);
-      return {
-        success: false,
-        message: "This endpoint is only available for semantic metrics servers",
-      };
-    }
-
-    const semanticConfig = config.config as SemanticMetricsServerConfig;
-
-    const client = new SemanticMetricsClient(semanticConfig);
-    const metrics = await client.getDatasourceMetrics(datasourceId);
-
-    return {
-      success: true,
-      message: "Datasource metrics retrieved successfully",
-      data: metrics,
-    };
-  } catch (error) {
-    console.error("Failed to get datasource metrics:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve datasource metrics",
-    };
-  }
-}
-
-/**
- * Query semantic metrics data
- * POST /api/metrics-configs/:key/semantic-query
- */
-export async function querySemanticMetrics(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<SemanticQueryResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-  const body = request.body as SemanticMetricsQueryRequest;
-
-  try {
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Metrics server configuration not found",
-      };
-    }
-
-    if (config.config.type !== "semantic") {
-      reply.code(400);
-      return {
-        success: false,
-        message: "This endpoint is only available for semantic metrics servers",
-      };
-    }
-
-    if (!body.datasourceId || !body.metrics || body.metrics.length === 0) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "datasourceId and metrics array are required",
-      };
-    }
-
-    const semanticConfig = config.config as SemanticMetricsServerConfig;
-
-    const client = new SemanticMetricsClient(semanticConfig);
-    const result = await client.semanticQuery(body);
-
-    // Transform SemanticMetricsQueryResponse to response format
-    // The response contains columns and rows arrays
-    const columnNames = result.columns.map(col => col.name);
-    const allDataPoints: Array<{
-      timestamp?: number;
-      value: number;
-      labels?: Record<string, string>;
-    }> = [];
-
-    // Find timestamp column and value column indices
-    const timestampColIdx = columnNames.findIndex(col => 
-      col.toLowerCase().includes('date') || col.toLowerCase().includes('time')
-    );
-    const valueColIdx = columnNames.findIndex(col => 
-      col.toLowerCase().includes('value') || col.toLowerCase().includes('rate') || col.toLowerCase().includes('amt')
-    );
-
-    for (const row of result.rows ?? []) {
-      const timestamp = timestampColIdx >= 0 ? row[timestampColIdx] : undefined;
-      const value = valueColIdx >= 0 ? row[valueColIdx] : row[row.length - 1];
-      
-      allDataPoints.push({
-        timestamp: timestamp ? new Date(String(timestamp)).getTime() : undefined,
-        value: typeof value === 'number' ? value : Number(value) || 0,
-        labels: Object.fromEntries(
-          columnNames.map((col, idx) => [col, String(row[idx] ?? '')])
-        ),
-      });
-    }
-
-    return {
-      success: true,
-      message: "Semantic query executed successfully",
-      data: {
-        semanticModel: result.semanticModel,
-        columns: columnNames,
-        dataPoints: allDataPoints,
-        metadata: {
-          rowCount: result.rows?.length ?? 0,
-          columnCount: result.columns.length,
-        },
-      },
-    };
-  } catch (error) {
-    console.error("Failed to query semantic metrics:", error);
-    return {
-      success: false,
-      message: "Failed to query semantic metrics",
-    };
-  }
-}
-
-/**
- * Test datasources endpoint without saving config
- * Used for multi-step configuration flow
- * POST /api/metrics-configs/test-datasources
- */
-export async function testSemanticDataSources(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DataSourcesResponse> {
-  const body = request.body as {
-    serverUrl: string;
-    apiKey?: string;
-    username?: string;
-    password?: string;
-    headers?: Record<string, string>;
-  };
-
-  try {
-    if (!body.serverUrl) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "serverUrl is required",
-      };
-    }
-
-    const testConfig: SemanticMetricsServerConfig = {
-      type: "semantic",
-      serverUrl: body.serverUrl,
-      apiKey: body.apiKey,
-      username: body.username,
-      password: body.password,
-      headers: body.headers,
-    };
-
-    const client = new SemanticMetricsClient(testConfig);
-
-    const datasources = await client.getDataSources();
-
-    return {
-      success: true,
-      message: "Data sources retrieved successfully",
-      data: {
-        datasources,
-      },
-    };
-  } catch (error) {
-    console.error("Failed to test datasources:", error);
-    return {
-      success: false,
-      message: `Failed to retrieve data sources: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-/**
- * Test datasource metrics endpoint without saving config
- * Used for multi-step configuration flow
- * POST /api/metrics-configs/test-datasources/:datasourceId/metrics
- */
-export async function testDatasourceMetrics(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatasourceMetricsResponse> {
-  const { datasourceId } = request.params as { datasourceId: string };
-  const body = request.body as {
-    serverUrl: string;
-    apiKey?: string;
-    username?: string;
-    password?: string;
-    headers?: Record<string, string>;
-  };
-
-  try {
-    if (!body.serverUrl) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "serverUrl is required",
-      };
-    }
-
-    const testConfig: SemanticMetricsServerConfig = {
-      type: "semantic",
-      serverUrl: body.serverUrl,
-      apiKey: body.apiKey,
-      username: body.username,
-      password: body.password,
-      headers: body.headers,
-    };
-
-    const client = new SemanticMetricsClient(testConfig);
-    const metrics = await client.getDatasourceMetrics(datasourceId);
-
-    return {
-      success: true,
-      message: "Datasource metrics retrieved successfully",
-      data: metrics,
-    };
-  } catch (error) {
-    console.error("Failed to test datasource metrics:", error);
-    return {
-      success: false,
-      message: `Failed to retrieve datasource metrics: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-/**
- * Register metrics server config routes
- */
-export function registerMetricsServerConfigRoutes(app: any): void {
-  // Get all configs
-  app.get("/api/metrics-configs", getMetricsServerConfigList);
-
-  // Get config by key
-  app.get("/api/metrics-configs/:key", getMetricsServerConfig);
-
-  // Create config
-  app.post("/api/metrics-configs", createMetricsServerConfig);
-
-  // Update config
-  app.put("/api/metrics-configs/:key", updateMetricsServerConfig);
-
-  // Delete config by key or id
-  app.delete("/api/metrics-configs/:keyOrId", deleteMetricsServerConfig);
-
-  // Test connection
-  app.post("/api/metrics-configs/:key/test", testMetricsServerConnection);
-
-  // List available metrics
-  app.get("/api/metrics-configs/:key/metrics", listAvailableMetrics);
-
-  // Query metric data
-  app.post("/api/metrics-configs/:key/query", queryMetricsData);
-
-  // Semantic-specific routes
-  // Get data sources for a semantic server
-  app.get("/api/metrics-configs/:key/datasources", getDataSources);
-
-  // Get metrics meta for a specific datasource
-  app.get("/api/metrics-configs/:key/datasources/:datasourceId/meta", getDatasourceMetrics);
-
-  // Query semantic metrics data
-  app.post("/api/metrics-configs/:key/semantic-query", querySemanticMetrics);
-
-  // Test datasources without saving config (for multi-step config flow)
-  app.post("/api/metrics-configs/test-datasources", testSemanticDataSources);
-
-  // Test datasource metrics meta without saving config (for multi-step config flow)
-  app.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
-}