@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/connections.ts

@@ -1,181 +0,0 @@
-import type { FastifyInstance, FastifyRequest } from "fastify";
-import { ConnectionRegistry, PluginRegistry } from "@axiom-lattice/core";
-import { z } from "zod";
-
-const createBody = z.object({
-  type: z.string().min(1),
-  key: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  config: z.record(z.unknown()),
-});
-
-const testOrDiscoverBody = z.object({
-  key: z.string().optional(),
-  config: z.record(z.unknown()).optional(),
-});
-
-function getTenant(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";
-}
-
-function maskSecrets(config: Record<string, unknown>): Record<string, unknown> {
-  const sensitive = new Set([
-    "password", "secret", "token", "apikey", "api_key", "session",
-    "privatekey", "private_key", "accesskey", "access_key",
-  ]);
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(config)) {
-    out[k] = sensitive.has(k.toLowerCase()) ? "********" : v;
-  }
-  return out;
-}
-
-/** Resolve target config: stored connection (by key) takes priority over inline config */
-async function resolveConfig(
-  type: string, body: { key?: string; config?: Record<string, unknown> }, tenantId: string,
-): Promise<Record<string, unknown>> {
-  if (body.key) {
-    const entry = await ConnectionRegistry.get(type, body.key, tenantId);
-    if (!entry) throw { status: 404, error: `Connection "${body.key}" not found` };
-    return entry.config;
-  }
-  if (body.config) return body.config;
-  throw { status: 400, error: "Either 'key' or 'config' is required" };
-}
-
-export function connectionRoutes(fastify: FastifyInstance): void {
-  // List connections by type
-  fastify.get("/api/connections", async (request, reply) => {
-    const { type } = request.query as { type?: string };
-    if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const entries = await ConnectionRegistry.list(type, getTenant(request));
-    return reply.send({
-      success: true,
-      data: { records: entries.map((e) => ({ ...e, config: maskSecrets(e.config) })), total: entries.length },
-    });
-  });
-
-  // Create connection
-  fastify.post("/api/connections", async (request, reply) => {
-    const parsed = createBody.parse(request.body);
-    const entry = await ConnectionRegistry.create({
-      tenantId: getTenant(request),
-      type: parsed.type,
-      key: parsed.key,
-      name: parsed.name,
-      description: parsed.description,
-      config: parsed.config,
-    });
-    return reply.status(201).send({
-      success: true,
-      data: { ...entry, config: maskSecrets(entry.config) },
-    });
-  });
-
-  // Update connection (type in query, key in path)
-  fastify.put("/api/connections/:key", async (request, reply) => {
-    const { type } = request.query as { type?: string };
-    if (!type) return reply.status(400).send({ error: "query 'type' required" });
-
-    const { key } = request.params as { key: string };
-    const body = request.body as Record<string, unknown>;
-    const tenantId = getTenant(request);
-
-    const existing = await ConnectionRegistry.get(type, key, tenantId);
-    if (!existing) return reply.status(404).send({ error: "not found" });
-
-    const updates: Record<string, unknown> = {};
-    if (body.name !== undefined) updates.name = body.name;
-    if (body.description !== undefined) updates.description = body.description;
-    if (body.config) {
-      updates.config = { ...existing.config, ...(body.config as Record<string, unknown>) };
-    }
-
-    const entry = await ConnectionRegistry.update(tenantId, type, key, updates);
-    return reply.send({
-      success: true,
-      data: { ...entry, config: maskSecrets(entry?.config ?? {}) },
-    });
-  });
-
-  // Delete connection
-  fastify.delete("/api/connections/:key", async (request, reply) => {
-    const { type } = request.query as { type?: string };
-    if (!type) return reply.status(400).send({ error: "query 'type' required" });
-
-    const { key } = request.params as { key: string };
-    const ok = await ConnectionRegistry.delete(getTenant(request), type, key);
-    return reply.send({ success: ok });
-  });
-
-  // Test connection (supports key-based stored connection or inline config)
-  fastify.post("/api/connections/test", async (request, reply) => {
-    const { type } = request.query as { type: string };
-    if (!type) return reply.status(400).send({ error: "query 'type' required" });
-
-    const plugin = PluginRegistry.get(type);
-    if (!plugin?.connection?.test) {
-      return reply.status(400).send({ error: "plugin does not support connection testing" });
-    }
-
-    try {
-      const body = testOrDiscoverBody.parse(request.body);
-      const targetConfig = await resolveConfig(type, body, getTenant(request));
-      const result = await plugin.connection.test(targetConfig);
-      return reply.send(result);
-    } catch (err) {
-      if ((err as Record<string, unknown>)?.status === 404) {
-        return reply.status(404).send(err);
-      }
-      if ((err as Record<string, unknown>)?.status === 400) {
-        return reply.status(400).send(err);
-      }
-      if (err instanceof z.ZodError) {
-        return reply.status(400).send({ error: err.errors });
-      }
-      return reply.status(500).send({
-        ok: false,
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-  });
-
-  // Resource discovery (supports key-based stored connection or inline config)
-  fastify.post("/api/connections/discover", async (request, reply) => {
-    const { type } = request.query as { type: string };
-    if (!type) return reply.status(400).send({ error: "query 'type' required" });
-
-    const plugin = PluginRegistry.get(type);
-    if (!plugin?.connection?.discover) {
-      return reply.status(400).send({ error: "plugin does not support resource discovery" });
-    }
-
-    try {
-      const body = testOrDiscoverBody.parse(request.body);
-      const targetConfig = await resolveConfig(type, body, getTenant(request));
-      const resources = await plugin.connection.discover(targetConfig);
-      return reply.send({ resources });
-    } catch (err) {
-      if ((err as Record<string, unknown>)?.status === 404) {
-        return reply.status(404).send(err);
-      }
-      if ((err as Record<string, unknown>)?.status === 400) {
-        return reply.status(400).send(err);
-      }
-      if (err instanceof z.ZodError) {
-        return reply.status(400).send({ error: err.errors });
-      }
-      return reply.status(500).send({
-        error: err instanceof Error ? err.message : String(err),
-      });
-    }
-  });
-}

package/src/controllers/data-query.ts

@@ -1,236 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import {
-  getStoreLattice,
-  metricsServerManager,
-  SemanticMetricsClient,
-} from "@axiom-lattice/core";
-import type {
-  MetricsServerConfigStore,
-  SemanticMetricsServerConfig,
-  SemanticMetricsFilter,
-} from "@axiom-lattice/protocols";
-
-/**
- * Get tenant ID from request headers
- */
-function getTenantId(request: FastifyRequest): string {
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-/**
- * Data query request body
- */
-interface DataQueryRequest {
-  serverKey?: string;
-  datasourceId?: string;
-  metrics?: string[];
-  groupBy?: string[];
-  filters?: Array<{
-    dimension: string;
-    operator: string;
-    values: (string | number | boolean)[];
-  }>;
-  customSql?: string;
-  params?: Record<string, string | number | boolean>;
-  limit?: number;
-}
-
-/**
- * Data query response - 只返回原始数据
- */
-interface DataQueryResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    // 语义查询结果
-    semanticModel?: string;
-    columns: Array<{ name: string; type: string }>;
-    rows?: Array<Array<unknown>>;
-    rowsObject?: Array<Record<string, unknown>>;
-    // SQL 查询结果
-    tableName?: string;
-    executedSql?: string;
-    // 通用元数据
-    metadata: {
-      rowCount: number;
-      executionTimeMs?: number;
-    };
-  };
-}
-
-/**
- * Execute data query (semantic or SQL)
- */
-export async function executeDataQuery(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DataQueryResponse> {
-  const tenantId = getTenantId(request);
-  const body = request.body as DataQueryRequest;
-
-  try {
-    // Validate request
-    if (!body.serverKey && !body.datasourceId) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "Either serverKey or datasourceId must be provided",
-      };
-    }
-
-    // Determine query type
-    const isSemanticQuery = body.metrics && body.metrics.length > 0;
-    const isSqlQuery = body.customSql && body.customSql.trim().length > 0;
-
-    if (!isSemanticQuery && !isSqlQuery) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "Either metrics (for semantic query) or customSql (for SQL query) must be provided",
-      };
-    }
-
-    if (isSemanticQuery && isSqlQuery) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "Cannot provide both metrics and customSql. Use one query type only.",
-      };
-    }
-
-    // Get server config
-    const storeLattice = getStoreLattice("default", "metrics");
-    const store: MetricsServerConfigStore = storeLattice.store;
-
-    if (!body.serverKey) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "serverKey is required",
-      };
-    }
-
-    const config = await store.getConfigByKey(tenantId, body.serverKey);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: `Metrics server configuration not found: ${body.serverKey}`,
-      };
-    }
-
-    if (config.config.type !== "semantic") {
-      reply.code(400);
-      return {
-        success: false,
-        message: "This endpoint only supports semantic metrics servers",
-      };
-    }
-
-    if (!body.datasourceId) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "datasourceId is required",
-      };
-    }
-
-    // Get client from manager (queries store for latest config)
-    let client: SemanticMetricsClient;
-    try {
-      client = await metricsServerManager.getClient(tenantId, body.serverKey) as SemanticMetricsClient;
-    } catch {
-      reply.code(400);
-      return {
-        success: false,
-        message: `Metrics server not registered: ${body.serverKey}. Please register the server first.`,
-      };
-    }
-
-    // Execute query based on type
-    if (isSemanticQuery) {
-      return await executeSemanticQuery(client, body, reply);
-    } else {
-      return await executeSqlQuery(client, body, reply);
-    }
-  } catch (error) {
-    console.error("Failed to execute data query:", error);
-    reply.code(500);
-    return {
-      success: false,
-      message: `Failed to execute data query: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-/**
- * Execute semantic query
- */
-async function executeSemanticQuery(
-  client: SemanticMetricsClient,
-  body: DataQueryRequest,
-  reply: FastifyReply
-): Promise<DataQueryResponse> {
-  const semanticFilters: SemanticMetricsFilter[] = (body.filters || []).map(f => ({
-    dimension: f.dimension,
-    operator: f.operator,
-    values: f.values,
-  }));
-
-  const result = await client.semanticQuery({
-    datasourceId: body.datasourceId!,
-    metrics: body.metrics!,
-    groupBy: body.groupBy,
-    filters: semanticFilters,
-    limit: body.limit || 1000,
-  });
-
-  // 直接返回原始数据，不做 ECharts 转换
-  return {
-    success: true,
-    message: "Semantic query executed successfully",
-    data: {
-      semanticModel: result.semanticModel,
-      columns: result.columns,
-      rows: result.rows,
-      rowsObject: result.rowsObject,
-      metadata: {
-        rowCount: result.rowCount,
-        executionTimeMs: result.executionTimeMs,
-      },
-    },
-  };
-}
-
-/**
- * Execute SQL query
- */
-async function executeSqlQuery(
-  client: SemanticMetricsClient,
-  body: DataQueryRequest,
-  reply: FastifyReply
-): Promise<DataQueryResponse> {
-  const result = await client.executeSqlQuery({
-    datasourceId: body.datasourceId!,
-    customSql: body.customSql!,
-    params: body.params,
-    limit: body.limit || 100,
-  });
-
-  // 直接返回原始数据，不做 ECharts 转换
-  return {
-    success: true,
-    message: "SQL query executed successfully",
-    data: {
-      tableName: result.tableName,
-      columns: result.columns.map(name => ({ name, type: 'unknown' })),
-      rows: result.rows,
-      rowsObject: result.rowsObject,
-      executedSql: result.executedSql,
-      metadata: {
-        rowCount: result.rowCount,
-        executionTimeMs: result.executionTimeMs,
-      },
-    },
-  };
-}