@axiom-lattice/gateway 2.1.28 → 2.1.30

package/src/controllers/metrics-configs.ts

@@ -0,0 +1,989 @@
+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 request headers
+ */
+function getTenantId(request: FastifyRequest): string {
+  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;
+      }>;
+    };
+    details: 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;
+      };
+    }>;
+  };
+}
+
+/**
+ * Semantic query response
+ */
+interface SemanticQueryResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    datasourceId: string | number;
+    metrics: string[];
+    dataPoints: Array<{
+      timestamp?: number;
+      value: number;
+      metricName?: string;
+      labels?: Record<string, string>;
+    }>;
+    metadata?: {
+      rowCount?: number;
+      queryTimeMs?: 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(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(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(configKey)) {
+        metricsServerManager.removeServer(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(testKey, config.config);
+
+    try {
+      const client = metricsServerManager.getClient(testKey);
+      const result = await client.testConnection();
+
+      // Cleanup
+      metricsServerManager.removeServer(testKey);
+
+      return {
+        success: true,
+        message: result.connected ? "Connection test successful" : "Connection test failed",
+        data: result,
+      };
+    } catch (error) {
+      // Cleanup on error
+      try {
+        metricsServerManager.removeServer(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 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(key)) {
+      metricsServerManager.registerServer(key, config.config);
+    }
+
+    const client = metricsServerManager.getClient(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(key)) {
+      metricsServerManager.registerServer(key, config.config);
+    }
+
+    const client = metricsServerManager.getClient(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 datasources = await client.getDataSources();
+
+    return {
+      success: true,
+      message: "Data sources retrieved successfully",
+      data: {
+        datasources,
+      },
+    };
+  } 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);
+
+    return {
+      success: true,
+      message: "Semantic query executed successfully",
+      data: {
+        datasourceId: result.datasourceId,
+        metrics: result.metrics,
+        dataPoints: result.dataPoints,
+        metadata: result.metadata,
+      },
+    };
+  } 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);
+}