@influxdata/influxdb3-mcp-server 1.3.0

package/build/services/serverless-schema-management.service.js

@@ -0,0 +1,266 @@
+/**
+ * InfluxDB Cloud Serverless Schema Management Service
+ *
+ * NOTE: As of Ocotber 2025, explicit schemas are not supported in InfluxDB v3 (Cloud Serverless).
+ * This service and tools are preserved for potential future compatibility when
+ * explicit schema support may be added to Cloud Serverless.
+ *
+ * For current schema exploration in Cloud Serverless, use the query-based tools:
+ * - get_measurements: Lists all measurements using information_schema
+ * - get_measurement_schema: Shows column details using information_schema
+ *
+ * This service provides schema management capabilities specific to InfluxDB Cloud Serverless,
+ * including listing, creating, updating, and deleting measurement schemas within buckets.
+ */
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class SchemaManagementService {
+    baseService;
+    constructor(baseService) {
+        this.baseService = baseService;
+    }
+    /**
+     * Validate that schema operations are supported (Cloud Serverless only)
+     */
+    validateSchemaOperationSupport() {
+        const connectionInfo = this.baseService.getConnectionInfo();
+        if (connectionInfo.type !== InfluxProductType.CloudServerless) {
+            throw new Error(`Schema management is only supported for Cloud Serverless. Current type: ${connectionInfo.type}`);
+        }
+        this.baseService.validateManagementCapabilities();
+    }
+    /**
+     * List all measurement schemas in a bucket
+     * GET /api/v2/buckets/{bucketID}/schema/measurements
+     */
+    async listSchemas(bucketName) {
+        this.validateSchemaOperationSupport();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            // First, get the bucket ID by name
+            const bucketsResponse = await httpClient.get("/api/v2/buckets");
+            let bucketId;
+            if (bucketsResponse?.buckets) {
+                const bucket = bucketsResponse.buckets.find((b) => b.name === bucketName && b.type !== "system");
+                if (bucket) {
+                    bucketId = bucket.id;
+                }
+            }
+            if (!bucketId) {
+                throw new Error(`Bucket '${bucketName}' not found`);
+            }
+            const endpoint = `/api/v2/buckets/${bucketId}/schema/measurements`;
+            const response = await httpClient.get(endpoint);
+            let schemas = [];
+            if (response && Array.isArray(response.measurementSchemas)) {
+                schemas = response.measurementSchemas;
+            }
+            else if (Array.isArray(response)) {
+                schemas = response;
+            }
+            return schemas.map((schema) => {
+                const schemaInfo = {
+                    name: schema.name,
+                    bucketId: schema.bucketID || bucketId,
+                    bucketName: bucketName,
+                };
+                if (Array.isArray(schema.columns)) {
+                    schemaInfo.columns = schema.columns.map((col) => ({
+                        name: col.name,
+                        type: col.type,
+                        dataType: col.dataType,
+                    }));
+                }
+                if (schema.createdAt) {
+                    schemaInfo.createdAt = schema.createdAt;
+                }
+                if (schema.updatedAt) {
+                    schemaInfo.updatedAt = schema.updatedAt;
+                }
+                return schemaInfo;
+            });
+        }
+        catch (error) {
+            this.handleSchemaError(error, `list schemas for bucket '${bucketName}'`);
+        }
+    }
+    /**
+     * Get detailed information about a specific measurement schema
+     * GET /api/v2/buckets/{bucketID}/schema/measurements/{measurementID}
+     */
+    async getSchema(bucketName, schemaName) {
+        this.validateSchemaOperationSupport();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const bucketsResponse = await httpClient.get("/api/v2/buckets");
+            let bucketId;
+            if (bucketsResponse?.buckets) {
+                const bucket = bucketsResponse.buckets.find((b) => b.name === bucketName && b.type !== "system");
+                if (bucket) {
+                    bucketId = bucket.id;
+                }
+            }
+            if (!bucketId) {
+                throw new Error(`Bucket '${bucketName}' not found`);
+            }
+            const schemasResponse = await httpClient.get(`/api/v2/buckets/${bucketId}/schema/measurements`);
+            let measurementId;
+            if (schemasResponse &&
+                Array.isArray(schemasResponse.measurementSchemas)) {
+                const schema = schemasResponse.measurementSchemas.find((s) => s.name === schemaName);
+                if (schema) {
+                    measurementId = schema.id;
+                }
+            }
+            if (!measurementId) {
+                throw new Error(`Schema '${schemaName}' not found in bucket '${bucketName}'`);
+            }
+            const endpoint = `/api/v2/buckets/${bucketId}/schema/measurements/${measurementId}`;
+            const response = await httpClient.get(endpoint);
+            const schemaInfo = {
+                name: response.name,
+                bucketId: response.bucketID || bucketId,
+                bucketName: bucketName,
+            };
+            if (Array.isArray(response.columns)) {
+                schemaInfo.columns = response.columns.map((col) => ({
+                    name: col.name,
+                    type: col.type,
+                    dataType: col.dataType,
+                }));
+            }
+            if (response.createdAt) {
+                schemaInfo.createdAt = response.createdAt;
+            }
+            if (response.updatedAt) {
+                schemaInfo.updatedAt = response.updatedAt;
+            }
+            return schemaInfo;
+        }
+        catch (error) {
+            this.handleSchemaError(error, `get schema '${schemaName}' from bucket '${bucketName}'`);
+        }
+    }
+    /**
+     * Create a new measurement schema in a bucket
+     * POST /api/v2/buckets/{bucketID}/schema/measurements
+     */
+    async createSchema(config) {
+        this.validateSchemaOperationSupport();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const bucketsResponse = await httpClient.get("/api/v2/buckets");
+            let bucketId;
+            if (bucketsResponse?.buckets) {
+                const bucket = bucketsResponse.buckets.find((b) => b.name === config.bucketName && b.type !== "system");
+                if (bucket) {
+                    bucketId = bucket.id;
+                }
+            }
+            if (!bucketId) {
+                throw new Error(`Bucket '${config.bucketName}' not found`);
+            }
+            const payload = {
+                name: config.name,
+                columns: config.columns.map((col) => {
+                    const column = {
+                        type: col.type,
+                        name: col.name,
+                    };
+                    if (col.type === "field" && col.dataType) {
+                        column.dataType = col.dataType;
+                    }
+                    return column;
+                }),
+            };
+            const endpoint = `/api/v2/buckets/${bucketId}/schema/measurements`;
+            await httpClient.post(endpoint, payload);
+            return true;
+        }
+        catch (error) {
+            this.handleSchemaError(error, `create schema '${config.name}' in bucket '${config.bucketName}'`);
+        }
+    }
+    /**
+     * Add new columns to an existing measurement schema
+     * IMPORTANT: This endpoint only allows ADDING new columns, not modifying existing ones.
+     * The request must include ALL columns (existing + new ones to add).
+     * Get the current schema first to retrieve existing columns, then include them with new columns.
+     * PATCH /api/v2/buckets/{bucketID}/schema/measurements/{measurementName}
+     */
+    async updateSchema(bucketName, schemaName, config) {
+        this.validateSchemaOperationSupport();
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const bucketsResponse = await httpClient.get("/api/v2/buckets");
+            let bucketId;
+            if (bucketsResponse?.buckets) {
+                const bucket = bucketsResponse.buckets.find((b) => b.name === bucketName && b.type !== "system");
+                if (bucket) {
+                    bucketId = bucket.id;
+                }
+            }
+            if (!bucketId) {
+                throw new Error(`Bucket '${bucketName}' not found`);
+            }
+            const schemasResponse = await httpClient.get(`/api/v2/buckets/${bucketId}/schema/measurements`);
+            if (!schemasResponse.measurementSchemas ||
+                !Array.isArray(schemasResponse.measurementSchemas)) {
+                throw new Error(`No schemas found in bucket '${bucketName}'`);
+            }
+            const existingSchema = schemasResponse.measurementSchemas.find((schema) => schema.name === schemaName);
+            if (!existingSchema) {
+                throw new Error(`Schema '${schemaName}' not found in bucket '${bucketName}'`);
+            }
+            const measurementId = existingSchema.id;
+            const updatePayload = {
+                columns: config.columns?.map((col) => ({
+                    name: col.name,
+                    type: col.type,
+                    ...(col.type === "field" &&
+                        col.dataType && { dataType: col.dataType }),
+                })) || [],
+            };
+            await httpClient.patch(`/api/v2/buckets/${bucketId}/schema/measurements/${measurementId}`, updatePayload);
+            return true;
+        }
+        catch (error) {
+            if (error.response?.data) {
+                throw new Error(`Failed to update schema: ${JSON.stringify(error.response.data, null, 2)}`);
+            }
+            else {
+                throw new Error(`Failed to update schema '${schemaName}': ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Common error handling for schema operations
+     */
+    handleSchemaError(error, operation) {
+        const status = error.response?.status;
+        const originalMessage = error.response?.data?.message ||
+            error.response?.data?.error ||
+            (typeof error.response?.data === "string" ? error.response.data : null) ||
+            error.response?.statusText;
+        const formatError = (userMessage) => {
+            const parts = [`HTTP ${status}`, userMessage];
+            if (originalMessage) {
+                parts.push(`Server message: ${originalMessage}`);
+            }
+            return parts.join(" - ");
+        };
+        switch (status) {
+            case 400:
+                throw new Error(formatError("Bad Request: Invalid schema definition or parameters"));
+            case 401:
+                throw new Error(formatError("Unauthorized: Check your InfluxDB token permissions"));
+            case 403:
+                throw new Error(formatError("Forbidden: Token lacks permissions for schema operations"));
+            case 404:
+                throw new Error(formatError("Not Found: Schema or bucket does not exist"));
+            case 409:
+                throw new Error(formatError("Conflict: Schema already exists or conflicts with bucket settings"));
+            default:
+                throw new Error(`Failed to ${operation}: ${error.message}`);
+        }
+    }
+}

package/build/services/token-management.service.js

@@ -0,0 +1,215 @@
+/**
+ * InfluxDB Token Management Service
+ *
+ * Simplified service for essential token operations based on InfluxDB 3 Enterprise API
+ */
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class TokenManagementService {
+    baseService;
+    httpClient;
+    constructor(baseService) {
+        this.baseService = baseService;
+        this.httpClient = baseService.getInfluxHttpClient();
+    }
+    /**
+     * Create a new admin token with full permissions
+     */
+    async createAdminToken(token_name) {
+        this.baseService.validateOperationSupport("create_admin_token", [
+            InfluxProductType.Core,
+            InfluxProductType.Enterprise,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const name = token_name ||
+                `admin-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const requestBody = { token_name: name };
+            const response = await this.httpClient.post("/api/v3/configure/token/named_admin", requestBody);
+            if (response && response.token) {
+                return {
+                    token: response.token,
+                    id: response.id || response.token_id || "unknown",
+                };
+            }
+            else {
+                throw new Error("Admin token creation failed: No token returned in response");
+            }
+        }
+        catch (error) {
+            const errorMessage = error.response?.data || error.message;
+            const statusCode = error.response?.status;
+            throw new Error(`Failed to create admin token: ${errorMessage} (Status: ${statusCode})`);
+        }
+    }
+    /**
+     * List admin tokens with optional filtering
+     */
+    async listAdminTokens(filters) {
+        this.baseService.validateOperationSupport("list_admin_tokens", [
+            InfluxProductType.Core,
+            InfluxProductType.Enterprise,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            let query = "SELECT * FROM system.tokens WHERE permissions LIKE '%*:*:*%'";
+            if (filters?.tokenName) {
+                query += ` AND name LIKE '%${filters.tokenName}%'`;
+            }
+            if (filters?.order) {
+                query += ` ORDER BY ${filters.order.field} ${filters.order.direction}`;
+            }
+            else {
+                query += " ORDER BY token_id ASC";
+            }
+            const payload = {
+                db: "_internal",
+                q: query,
+                format: "json",
+                params: {},
+            };
+            const response = await this.httpClient.post("/api/v3/query_sql", payload, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+            });
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error.response?.data;
+            const _statusCode = error.response?.status;
+            throw new Error(`Failed to list admin tokens: ${errorMessage || error.message}`);
+        }
+    }
+    /**
+     * List resource tokens with optional filtering
+     */
+    async listResourceTokens(filters) {
+        this.baseService.validateOperationSupport("list_resource_tokens", [
+            InfluxProductType.Core,
+            InfluxProductType.Enterprise,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            let query = "SELECT * FROM system.tokens WHERE permissions NOT LIKE '%*:*:*%'";
+            if (filters?.databaseName) {
+                query += ` AND permissions LIKE '%${filters.databaseName}%'`;
+            }
+            if (filters?.tokenName) {
+                query += ` AND name LIKE '%${filters.tokenName}%'`;
+            }
+            if (filters?.order) {
+                query += ` ORDER BY ${filters.order.field} ${filters.order.direction}`;
+            }
+            else {
+                query += " ORDER BY token_id ASC";
+            }
+            const payload = {
+                db: "_internal",
+                q: query,
+                format: "json",
+                params: {},
+            };
+            const response = await this.httpClient.post("/api/v3/query_sql", payload, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+            });
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error.response?.data || error.response?.statusText || error.message;
+            const statusCode = error.response?.status;
+            throw new Error(`Failed to list resource tokens: Status: ${statusCode}, Message: ${errorMessage}`);
+        }
+    }
+    /**
+     * Regenerate the operator token
+     */
+    async regenerateOperatorToken() {
+        this.baseService.validateOperationSupport("regenerate_operator_token", [
+            InfluxProductType.Core,
+            InfluxProductType.Enterprise,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const response = await this.httpClient.post("/api/v3/configure/token/admin/regenerate");
+            if (response && response.token) {
+                return {
+                    token: response.token,
+                    id: response.id || response.token_id || "operator",
+                };
+            }
+            else {
+                throw new Error("Operator token regeneration failed: No token returned in response");
+            }
+        }
+        catch (error) {
+            const errorMessage = error.response?.data || error.message;
+            const statusCode = error.response?.status;
+            throw new Error(`Failed to regenerate operator token: ${errorMessage} (Status: ${statusCode})`);
+        }
+    }
+    /**
+     * Create a new resource token with specific database permissions
+     */
+    async createResourceToken(description, permissions, expiry_secs) {
+        this.baseService.validateOperationSupport("create_resource_token", [
+            InfluxProductType.Core,
+            InfluxProductType.Enterprise,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const requestBody = {
+                token_name: description,
+                permissions: permissions,
+            };
+            if (expiry_secs) {
+                requestBody.expiry_secs = expiry_secs;
+            }
+            const influxType = this.baseService.getConnectionInfo().type;
+            const endpoint = influxType === "enterprise"
+                ? "/api/v3/enterprise/configure/token"
+                : "/api/v3/configure/token";
+            const response = await this.httpClient.post(endpoint, requestBody);
+            if (response && response.token) {
+                return {
+                    token: response.token,
+                    id: response.id || response.token_id || "unknown",
+                };
+            }
+            else {
+                throw new Error("Resource token creation failed: No token returned in response");
+            }
+        }
+        catch (error) {
+            const errorMessage = error.response?.data || error.message;
+            const statusCode = error.response?.status;
+            throw new Error(`Failed to create resource token: ${errorMessage} (Status: ${statusCode})`);
+        }
+    }
+    /**
+     * Delete a token by name
+     */
+    async deleteToken(token_name) {
+        if (!token_name)
+            throw new Error("token_name is required");
+        this.baseService.validateOperationSupport("delete_token", [
+            InfluxProductType.Core,
+            InfluxProductType.Enterprise,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        try {
+            const response = await this.httpClient.delete("/api/v3/configure/token", {
+                params: { token_name },
+            });
+            return response?.success !== false;
+        }
+        catch (error) {
+            const errorMessage = error.response?.data || error.message;
+            const statusCode = error.response?.status;
+            throw new Error(`Failed to delete token: ${errorMessage} (Status: ${statusCode})`);
+        }
+    }
+}

package/build/services/write.service.js

@@ -0,0 +1,153 @@
+/**
+ * InfluxDB Write Service
+ *
+ * Handles write operations using InfluxDB v3 line protocol API
+ * Note: InfluxDB v3 only supports writing via line protocol - no UPDATE/DELETE operations
+ */
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class WriteService {
+    baseService;
+    constructor(baseService) {
+        this.baseService = baseService;
+    }
+    /**
+     * Map full precision names to cloud-compatible short format
+     */
+    mapPrecisionForCloud(precision) {
+        const precisionMap = {
+            nanosecond: "ns",
+            microsecond: "us",
+            millisecond: "ms",
+            second: "s",
+        };
+        return precisionMap[precision];
+    }
+    /**
+     * Write data (single entrypoint for all product types)
+     * For core/enterprise: HTTP API (/api/v3/write_lp)
+     * For cloud-dedicated: influxdb3 client
+     * For clustered: HTTP API (/api/v2/write)
+     * For cloud-serverless: influxdb3 client
+     */
+    async writeLineProtocol(lineProtocolData, database, options) {
+        // Validate we have data capabilities for write operations
+        this.baseService.validateDataCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+                return this.writeCloudDedicated(lineProtocolData, database, options);
+            case InfluxProductType.Clustered:
+                return this.writeClustered(lineProtocolData, database, options);
+            case InfluxProductType.CloudServerless:
+                return this.writeCloudServerless(lineProtocolData, database, options);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.writeCoreEnterprise(lineProtocolData, database, options);
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Write for core/enterprise (HTTP API)
+     */
+    async writeCoreEnterprise(lineProtocolData, database, options) {
+        const { precision, acceptPartial = true, noSync = false } = options;
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const params = new URLSearchParams({
+                db: database,
+                precision,
+                accept_partial: acceptPartial.toString(),
+                no_sync: noSync.toString(),
+            });
+            await httpClient.post(`/api/v3/write_lp?${params.toString()}`, lineProtocolData, {
+                headers: {
+                    "Content-Type": "text/plain; charset=utf-8",
+                    Accept: "application/json",
+                },
+            });
+        }
+        catch (error) {
+            this.handleWriteError(error, database);
+        }
+    }
+    /**
+     * Write for cloud-dedicated/clustered (influxdb3 client)
+     */
+    async writeCloudDedicated(lineProtocolData, database, options) {
+        try {
+            const client = this.baseService.getClient();
+            if (!client)
+                throw new Error("InfluxDB client not initialized");
+            const writeOptions = {};
+            if (options.precision) {
+                writeOptions.precision = options.precision;
+            }
+            await client.write(lineProtocolData, database, undefined, writeOptions);
+        }
+        catch (error) {
+            this.handleWriteError(error, database);
+        }
+    }
+    /**
+     * Write for clustered (HTTP API)
+     */
+    async writeClustered(lineProtocolData, database, options) {
+        const { precision } = options;
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const params = new URLSearchParams({
+                bucket: database,
+                precision: this.mapPrecisionForCloud(precision),
+            });
+            await httpClient.post(`/api/v2/write?${params.toString()}`, lineProtocolData, {
+                headers: {
+                    "Content-Type": "text/plain; charset=utf-8",
+                    Accept: "application/json",
+                },
+            });
+        }
+        catch (error) {
+            this.handleWriteError(error, database);
+        }
+    }
+    /**
+     * Write for cloud-serverless (influxdb3 client)
+     */
+    async writeCloudServerless(lineProtocolData, database, options) {
+        try {
+            const client = this.baseService.getClient();
+            if (!client)
+                throw new Error("InfluxDB client not initialized");
+            const writeOptions = {};
+            if (options.precision) {
+                writeOptions.precision = this.mapPrecisionForCloud(options.precision);
+            }
+            await client.write(lineProtocolData, database, undefined, writeOptions);
+        }
+        catch (error) {
+            this.handleWriteError(error, database);
+        }
+    }
+    /**
+     * Centralized error handler for write methods
+     */
+    handleWriteError(error, database) {
+        if (error.response?.status === 400) {
+            throw new Error(`Bad request: Invalid line protocol format or parameters`);
+        }
+        else if (error.response?.status === 401) {
+            throw new Error("Unauthorized: Check your InfluxDB token permissions");
+        }
+        else if (error.response?.status === 403) {
+            throw new Error("Access denied: Insufficient permissions for database operations");
+        }
+        else if (error.response?.status === 413) {
+            throw new Error("Request entity too large: Reduce the size of your line protocol data");
+        }
+        else if (error.response?.status === 422) {
+            throw new Error("Unprocessable entity: Invalid line protocol syntax");
+        }
+        throw new Error(`Failed to write data to database '${database}': ${error.response?.data || error.message}`);
+    }
+}