@influxdata/influxdb3-mcp-server 1.3.0

package/build/services/query.service.js

@@ -0,0 +1,499 @@
+/**
+ * InfluxDB Query Service
+ *
+ * Handles query operations using InfluxDB v3 SQL API
+ */
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class QueryService {
+    baseService;
+    constructor(baseService) {
+        this.baseService = baseService;
+    }
+    /**
+     * Execute SQL query (single entrypoint for all product types)
+     * For core/enterprise: HTTP API
+     * For cloud-dedicated: influxdb3 client
+     * For clustered: HTTP API (/query)
+     */
+    async executeQuery(query, database, options = {}) {
+        this.baseService.validateDataCapabilities();
+        const format = options.format ?? "json";
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+                return this.executeCloudDedicatedQuery(query, database);
+            case InfluxProductType.Clustered:
+                return this.executeClusteredQuery(query, database);
+            case InfluxProductType.CloudServerless:
+                return this.executeCloudServerlessQuery(query, database);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.executeCoreEnterpriseQuery(query, database, format);
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Query for core/enterprise (HTTP API)
+     */
+    async executeCoreEnterpriseQuery(query, database, format) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const payload = {
+                db: database,
+                q: query,
+                format: format,
+            };
+            let acceptHeader = "application/json";
+            switch (format) {
+                case "json":
+                    acceptHeader = "application/json";
+                    break;
+                case "csv":
+                    acceptHeader = "text/csv";
+                    break;
+                case "parquet":
+                    acceptHeader = "application/vnd.apache.parquet";
+                    break;
+                case "jsonl":
+                    acceptHeader = "application/json";
+                    break;
+                case "pretty":
+                    acceptHeader = "application/json";
+                    break;
+            }
+            const response = await httpClient.post("/api/v3/query_sql", payload, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: acceptHeader,
+                },
+            });
+            return response;
+        }
+        catch (error) {
+            this.handleQueryError(error);
+        }
+    }
+    /**
+     * Query for cloud-dedicated/clustered (influxdb3 client)
+     */
+    async executeCloudDedicatedQuery(query, database) {
+        try {
+            const client = this.baseService.getClient();
+            if (!client)
+                throw new Error("InfluxDB client not initialized");
+            const result = client.queryPoints(query, database, { type: "sql" });
+            const rows = [];
+            for await (const row of result) {
+                rows.push(row);
+            }
+            return rows;
+        }
+        catch (error) {
+            this.handleQueryError(error);
+        }
+    }
+    /**
+     * Query for clustered (HTTP API)
+     */
+    async executeClusteredQuery(query, database) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const response = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: query,
+                },
+            });
+            return response;
+        }
+        catch (error) {
+            this.handleQueryError(error);
+        }
+    }
+    /**
+     * Query for cloud-serverless (influxdb3 client)
+     */
+    async executeCloudServerlessQuery(query, database) {
+        try {
+            const client = this.baseService.getClient();
+            if (!client)
+                throw new Error("InfluxDB client not initialized");
+            const result = client.queryPoints(query, database, { type: "sql" });
+            const rows = [];
+            for await (const row of result) {
+                rows.push(row);
+            }
+            return rows;
+        }
+        catch (error) {
+            this.handleQueryError(error);
+        }
+    }
+    /**
+     * Centralized error handler for query methods
+     */
+    handleQueryError(error) {
+        const errorMessage = error.response?.data?.message ||
+            error.response?.data?.error ||
+            (typeof error.response?.data === "string" ? error.response.data : null) ||
+            error.response?.statusText ||
+            error.message;
+        const statusCode = error.response?.status;
+        console.error(`Status: ${statusCode} \n Message: ${errorMessage}`);
+        switch (statusCode) {
+            case 400:
+                throw new Error(`Bad request: ${errorMessage}`);
+            case 401:
+                throw new Error(`Unauthorized: ${errorMessage}`);
+            case 403:
+                throw new Error(`Access denied: ${errorMessage}`);
+            case 404:
+                throw new Error(`Database not found: ${errorMessage}`);
+            case 405:
+                throw new Error(`Method not allowed: ${errorMessage}`);
+            case 422:
+                throw new Error(`Unprocessable entity: ${errorMessage}`);
+            default:
+                throw new Error(`Query failed: ${errorMessage}`);
+        }
+    }
+    /**
+     * Get all measurements/tables in a database
+     * Uses SHOW MEASUREMENTS for cloud-dedicated/clustered (HTTP), information_schema for others
+     */
+    async getMeasurements(database) {
+        this.baseService.validateDataCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+                return this.getMeasurementsCloudDedicated(database);
+            case InfluxProductType.Clustered:
+                return this.getMeasurementsClustered(database);
+            case InfluxProductType.CloudServerless:
+                return this.getMeasurementsCloudServerless(database);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.getMeasurementsCoreEnterprise(database);
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Get measurements for cloud-dedicated/clustered (HTTP client with InfluxQL)
+     */
+    async getMeasurementsCloudDedicated(database) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const response = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: "SHOW MEASUREMENTS",
+                },
+            });
+            if (response.results &&
+                response.results[0] &&
+                response.results[0].series) {
+                const series = response.results[0].series[0];
+                if (series.name === "measurements" && series.values) {
+                    return series.values.map((value) => ({ name: value[0] }));
+                }
+            }
+            return [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get measurements: ${error.message}`);
+        }
+    }
+    /**
+     * Get measurements for clustered (HTTP client with InfluxQL)
+     */
+    async getMeasurementsClustered(database) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const response = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: "SHOW MEASUREMENTS",
+                },
+            });
+            if (response.results &&
+                response.results[0] &&
+                response.results[0].series) {
+                const series = response.results[0].series[0];
+                if (series.name === "measurements" && series.values) {
+                    return series.values.map((value) => ({ name: value[0] }));
+                }
+            }
+            return [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get measurements: ${error.message}`);
+        }
+    }
+    /**
+     * Get measurements for core/enterprise
+     */
+    async getMeasurementsCoreEnterprise(database) {
+        try {
+            const query = "SELECT DISTINCT table_name FROM information_schema.columns WHERE table_schema = 'iox'";
+            const result = await this.executeQuery(query, database, {
+                format: "json",
+            });
+            if (Array.isArray(result)) {
+                return result.map((row) => ({ name: row.table_name }));
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to get measurements: ${error.message}`);
+        }
+    }
+    /**
+     * Get measurements for cloud-serverless
+     * Parses the Cloud Serverless response format with _fields arrays
+     */
+    async getMeasurementsCloudServerless(database) {
+        try {
+            const query = "SELECT DISTINCT table_name FROM information_schema.columns WHERE table_schema = 'iox'";
+            const result = await this.executeQuery(query, database, {
+                format: "json",
+            });
+            if (Array.isArray(result)) {
+                return result
+                    .map((row) => {
+                    // Cloud Serverless format: { "_fields": { "table_name": ["string", "actual_value"] } }
+                    const tableName = row._fields?.table_name?.[1];
+                    return { name: tableName };
+                })
+                    .filter((item) => item.name); // Filter out undefined names
+            }
+            return [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get measurements: ${error.message}`);
+        }
+    }
+    /**
+     * Get schema information for a measurement/table
+     * Uses SHOW FIELD KEYS + SHOW TAG KEYS for cloud-dedicated/clustered (HTTP), information_schema for others
+     */
+    async getMeasurementSchema(measurement, database) {
+        this.baseService.validateDataCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+                return this.getMeasurementSchemaCloudDedicated(measurement, database);
+            case InfluxProductType.Clustered:
+                return this.getMeasurementSchemaClustered(measurement, database);
+            case InfluxProductType.CloudServerless:
+                return this.getMeasurementSchemaCloudServerless(measurement, database);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.getMeasurementSchemaCoreEnterprise(measurement, database);
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Get measurement schema for cloud-dedicated/clustered (HTTP client with InfluxQL)
+     */
+    async getMeasurementSchemaCloudDedicated(measurement, database) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const fieldKeysResponse = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: `SHOW FIELD KEYS FROM ${measurement}`,
+                },
+            });
+            const tagKeysResponse = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: `SHOW TAG KEYS FROM ${measurement}`,
+                },
+            });
+            const columns = [];
+            if (fieldKeysResponse.results &&
+                fieldKeysResponse.results[0] &&
+                fieldKeysResponse.results[0].series) {
+                const fieldSeries = fieldKeysResponse.results[0].series[0];
+                if (fieldSeries && fieldSeries.values) {
+                    fieldSeries.values.forEach((value) => {
+                        columns.push({
+                            name: value[0],
+                            type: value[1],
+                            category: "field",
+                        });
+                    });
+                }
+            }
+            if (tagKeysResponse.results &&
+                tagKeysResponse.results[0] &&
+                tagKeysResponse.results[0].series) {
+                const tagSeries = tagKeysResponse.results[0].series[0];
+                if (tagSeries && tagSeries.values) {
+                    tagSeries.values.forEach((value) => {
+                        columns.push({
+                            name: value[0],
+                            type: "string",
+                            category: "tag",
+                        });
+                    });
+                }
+            }
+            columns.unshift({
+                name: "time",
+                type: "timestamp",
+                category: "time",
+            });
+            return { columns };
+        }
+        catch (error) {
+            if (error.response?.status === 404 ||
+                error.message.includes("not found")) {
+                throw new Error(`Measurement '${measurement}' does not exist in database '${database}'`);
+            }
+            throw new Error(`Failed to get schema for measurement '${measurement}': ${error.message}`);
+        }
+    }
+    /**
+     * Get measurement schema for clustered (HTTP client with InfluxQL)
+     */
+    async getMeasurementSchemaClustered(measurement, database) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const fieldKeysResponse = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: `SHOW FIELD KEYS FROM ${measurement}`,
+                },
+            });
+            const tagKeysResponse = await httpClient.get("/query", {
+                params: {
+                    db: database,
+                    q: `SHOW TAG KEYS FROM ${measurement}`,
+                },
+            });
+            const columns = [];
+            if (fieldKeysResponse.results &&
+                fieldKeysResponse.results[0] &&
+                fieldKeysResponse.results[0].series) {
+                const fieldSeries = fieldKeysResponse.results[0].series[0];
+                if (fieldSeries && fieldSeries.values) {
+                    fieldSeries.values.forEach((value) => {
+                        columns.push({
+                            name: value[0],
+                            type: value[1],
+                            category: "field",
+                        });
+                    });
+                }
+            }
+            if (tagKeysResponse.results &&
+                tagKeysResponse.results[0] &&
+                tagKeysResponse.results[0].series) {
+                const tagSeries = tagKeysResponse.results[0].series[0];
+                if (tagSeries && tagSeries.values) {
+                    tagSeries.values.forEach((value) => {
+                        columns.push({
+                            name: value[0],
+                            type: "string",
+                            category: "tag",
+                        });
+                    });
+                }
+            }
+            columns.unshift({
+                name: "time",
+                type: "timestamp",
+                category: "time",
+            });
+            return { columns };
+        }
+        catch (error) {
+            if (error.response?.status === 404 ||
+                error.message.includes("not found")) {
+                throw new Error(`Measurement '${measurement}' does not exist in database '${database}'`);
+            }
+            throw new Error(`Failed to get schema for measurement '${measurement}': ${error.message}`);
+        }
+    }
+    /**
+     * Get measurement schema for core/enterprise
+     */
+    async getMeasurementSchemaCoreEnterprise(measurement, database) {
+        try {
+            const query = `SELECT column_name, data_type FROM information_schema.columns WHERE table_name = '${measurement}' AND table_schema = 'iox'`;
+            const result = await this.executeQuery(query, database, {
+                format: "json",
+            });
+            if (Array.isArray(result)) {
+                const columns = result.map((row) => {
+                    let category = "field";
+                    if (row.column_name === "time") {
+                        category = "time";
+                    }
+                    else if (row.data_type === "string" || row.data_type === "text") {
+                        category = "tag";
+                    }
+                    return {
+                        name: row.column_name,
+                        type: row.data_type,
+                        category,
+                    };
+                });
+                return { columns };
+            }
+            return result;
+        }
+        catch (error) {
+            if (error.message.includes("not found")) {
+                throw new Error(`Table '${measurement}' does not exist in database '${database}'`);
+            }
+            throw new Error(`Failed to get schema for measurement '${measurement}': ${error.message}`);
+        }
+    }
+    /**
+     * Get measurement schema for cloud-serverless
+     * Parses the Cloud Serverless response format with _fields arrays
+     */
+    async getMeasurementSchemaCloudServerless(measurement, database) {
+        try {
+            const query = `SELECT column_name, data_type FROM information_schema.columns WHERE table_name = '${measurement}' AND table_schema = 'iox'`;
+            const result = await this.executeQuery(query, database, {
+                format: "json",
+            });
+            if (Array.isArray(result)) {
+                const columns = result
+                    .map((row) => {
+                    const columnName = row._fields?.column_name?.[1];
+                    const dataType = row._fields?.data_type?.[1];
+                    let category = "field";
+                    if (columnName === "time") {
+                        category = "time";
+                    }
+                    else if (dataType?.includes("Dictionary") ||
+                        dataType === "string" ||
+                        dataType === "text") {
+                        category = "tag";
+                    }
+                    return {
+                        name: columnName,
+                        type: dataType,
+                        category,
+                    };
+                })
+                    .filter((col) => col.name);
+                return { columns };
+            }
+            return { columns: [] };
+        }
+        catch (error) {
+            if (error.message.includes("not found")) {
+                throw new Error(`Table '${measurement}' does not exist in database '${database}'`);
+            }
+            throw new Error(`Failed to get schema for measurement '${measurement}': ${error.message}`);
+        }
+    }
+}