@influxdata/influxdb3-mcp-server 1.3.0

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

@@ -0,0 +1,549 @@
+/**
+ * InfluxDB Database Management Service
+ *
+ * Handles database lifecycle operations: list, create, delete, update
+ */
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class DatabaseManagementService {
+    baseService;
+    constructor(baseService) {
+        this.baseService = baseService;
+    }
+    /**
+     * List all databases (single entrypoint for all product types)
+     * For core/enterprise: GET /api/v3/configure/database?format=json
+     * For cloud-dedicated/clustered: GET /api/v0/accounts/{account_id}/clusters/{cluster_id}/databases
+     * For cloud-serverless: GET /api/v2/buckets (databases are called "buckets" in v2 API)
+     */
+    async listDatabases() {
+        this.baseService.validateManagementCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+            case InfluxProductType.Clustered:
+                return this.listDatabasesCloudDedicated();
+            case InfluxProductType.CloudServerless:
+                return this.listDatabasesCloudServerless();
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.listDatabasesCoreEnterprise();
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Create a new database (single entrypoint for all product types)
+     * For core/enterprise: POST /api/v3/configure/database
+     * For cloud-dedicated/clustered: POST /api/v0/accounts/{account_id}/clusters/{cluster_id}/databases
+     * For cloud-serverless: POST /api/v2/buckets (databases are called "buckets" in v2 API)
+     */
+    async createDatabase(name, config) {
+        if (!name)
+            throw new Error("Database name is required");
+        this.baseService.validateManagementCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+            case InfluxProductType.Clustered:
+                return this.createDatabaseCloudDedicated(name, config);
+            case InfluxProductType.CloudServerless:
+                return this.createDatabaseCloudServerless(name, config);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.createDatabaseCoreEnterprise(name);
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Update database configuration (cloud-dedicated/clustered and cloud-serverless)
+     * For cloud-dedicated/clustered: PATCH /api/v0/accounts/{account_id}/clusters/{cluster_id}/databases/{name}
+     * For cloud-serverless: PATCH /api/v2/buckets/{bucketID}
+     */
+    async updateDatabase(name, config) {
+        if (!name)
+            throw new Error("Database name is required");
+        this.baseService.validateOperationSupport("update_database", [
+            InfluxProductType.CloudDedicated,
+            InfluxProductType.CloudServerless,
+            InfluxProductType.Clustered,
+        ]);
+        this.baseService.validateManagementCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+            case InfluxProductType.Clustered:
+                return this.updateDatabaseCloudDedicated(name, config);
+            case InfluxProductType.CloudServerless:
+                return this.updateDatabaseCloudServerless(name, config);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                throw new Error("Database update is not supported for core/enterprise InfluxDB");
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * Delete a database (single entrypoint for all product types)
+     * For core/enterprise: DELETE /api/v3/configure/database?db={name}
+     * For cloud-dedicated/clustered: DELETE /api/v0/accounts/{account_id}/clusters/{cluster_id}/databases/{name}
+     * For cloud-serverless: DELETE /api/v2/buckets/{bucketID} (databases are called "buckets" in v2 API)
+     */
+    async deleteDatabase(name) {
+        if (!name)
+            throw new Error("Database name is required");
+        this.baseService.validateManagementCapabilities();
+        const connectionInfo = this.baseService.getConnectionInfo();
+        switch (connectionInfo.type) {
+            case InfluxProductType.CloudDedicated:
+            case InfluxProductType.Clustered:
+                return this.deleteDatabaseCloudDedicated(name);
+            case InfluxProductType.CloudServerless:
+                return this.deleteDatabaseCloudServerless(name);
+            case InfluxProductType.Core:
+            case InfluxProductType.Enterprise:
+                return this.deleteDatabaseCoreEnterprise(name);
+            default:
+                throw new Error(`Unsupported InfluxDB product type: ${connectionInfo.type}`);
+        }
+    }
+    /**
+     * List databases for cloud-dedicated/clustered
+     */
+    async listDatabasesCloudDedicated() {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/databases`;
+            const response = await httpClient.get(endpoint);
+            if (!response || typeof response !== "object") {
+                throw new Error("Invalid response format from InfluxDB Cloud API");
+            }
+            let databases = [];
+            if (Array.isArray(response.databases)) {
+                databases = response.databases;
+            }
+            else if (Array.isArray(response)) {
+                databases = response;
+            }
+            else {
+                const possibleDatabases = response.data?.databases ||
+                    response.result?.databases ||
+                    response.databases;
+                if (Array.isArray(possibleDatabases)) {
+                    databases = possibleDatabases;
+                }
+                else {
+                    throw new Error(`Unexpected response structure: ${JSON.stringify(response)}`);
+                }
+            }
+            return databases.map((item) => {
+                if (typeof item === "string") {
+                    return { name: item };
+                }
+                else if (item && typeof item === "object" && item.name) {
+                    return {
+                        name: item.name,
+                        maxTables: item.maxTables,
+                        maxColumnsPerTable: item.maxColumnsPerTable,
+                        retentionPeriod: item.retentionPeriod,
+                    };
+                }
+                else {
+                    return { name: String(item) };
+                }
+            });
+        }
+        catch (error) {
+            this.handleDatabaseError(error, "list databases");
+        }
+    }
+    /**
+     * Create database for cloud-dedicated/clustered
+     */
+    async createDatabaseCloudDedicated(name, config) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const baseConfig = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${baseConfig.influx.account_id}/clusters/${baseConfig.influx.cluster_id}/databases`;
+            const payload = { name };
+            if (config?.maxTables !== undefined) {
+                payload.maxTables = config.maxTables;
+            }
+            else {
+                payload.maxTables = 500;
+            }
+            if (config?.maxColumnsPerTable !== undefined) {
+                payload.maxColumnsPerTable = config.maxColumnsPerTable;
+            }
+            else {
+                payload.maxColumnsPerTable = 200;
+            }
+            if (config?.retentionPeriod !== undefined) {
+                payload.retentionPeriod = config.retentionPeriod;
+            }
+            else {
+                payload.retentionPeriod = 0;
+            }
+            await httpClient.post(endpoint, payload);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `create database '${name}'`);
+        }
+    }
+    /**
+     * Update database configuration for cloud-dedicated/clustered
+     */
+    async updateDatabaseCloudDedicated(name, config) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const baseConfig = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${baseConfig.influx.account_id}/clusters/${baseConfig.influx.cluster_id}/databases/${encodeURIComponent(name)}`;
+            const payload = {};
+            if (config.maxTables !== undefined) {
+                payload.maxTables = config.maxTables;
+            }
+            if (config.maxColumnsPerTable !== undefined) {
+                payload.maxColumnsPerTable = config.maxColumnsPerTable;
+            }
+            if (config.retentionPeriod !== undefined) {
+                payload.retentionPeriod = config.retentionPeriod;
+            }
+            if (Object.keys(payload).length === 0) {
+                throw new Error("No configuration parameters provided for update");
+            }
+            await httpClient.patch(endpoint, payload);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `update database '${name}'`);
+        }
+    }
+    /**
+     * Delete database for cloud-dedicated/clustered
+     */
+    async deleteDatabaseCloudDedicated(name) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const config = this.baseService.getConfig();
+            const endpoint = `/api/v0/accounts/${config.influx.account_id}/clusters/${config.influx.cluster_id}/databases/${encodeURIComponent(name)}`;
+            await httpClient.delete(endpoint);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `delete database '${name}'`);
+        }
+    }
+    /**
+     * List databases for core/enterprise
+     */
+    async listDatabasesCoreEnterprise() {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            const response = await httpClient.get("/api/v3/configure/database?format=json");
+            if (!response || typeof response !== "object") {
+                throw new Error("Invalid response format from InfluxDB API");
+            }
+            let databases = [];
+            if (Array.isArray(response.databases)) {
+                databases = response.databases;
+            }
+            else if (Array.isArray(response)) {
+                databases = response;
+            }
+            else if (response && typeof response === "object") {
+                const possibleDatabases = response.data?.databases ||
+                    response.result?.databases ||
+                    response.databases;
+                if (Array.isArray(possibleDatabases)) {
+                    databases = possibleDatabases;
+                }
+                else {
+                    throw new Error(`Unexpected response structure: ${JSON.stringify(response)}`);
+                }
+            }
+            else {
+                throw new Error(`Unexpected response structure: ${JSON.stringify(response)}`);
+            }
+            return databases.map((item) => {
+                if (typeof item === "string") {
+                    return { name: item };
+                }
+                else if (item && typeof item === "object" && item["iox::database"]) {
+                    return { name: item["iox::database"] };
+                }
+                else if (item && typeof item === "object" && item.name) {
+                    return { name: item.name };
+                }
+                else {
+                    return { name: String(item) };
+                }
+            });
+        }
+        catch (error) {
+            this.handleDatabaseError(error, "list databases");
+        }
+    }
+    /**
+     * Create database for core/enterprise
+     */
+    async createDatabaseCoreEnterprise(name) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            await httpClient.post("/api/v3/configure/database", {
+                db: name,
+            });
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `create database '${name}'`);
+        }
+    }
+    /**
+     * Delete database for core/enterprise
+     */
+    async deleteDatabaseCoreEnterprise(name) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient();
+            await httpClient.delete(`/api/v3/configure/database?db=${encodeURIComponent(name)}`);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `delete database '${name}'`);
+        }
+    }
+    /**
+     * List databases for cloud-serverless (using buckets from /api/v2)
+     */
+    async listDatabasesCloudServerless() {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const response = await httpClient.get("/api/v2/buckets");
+            if (!response || typeof response !== "object") {
+                throw new Error("Invalid response format from InfluxDB Cloud Serverless API");
+            }
+            let buckets = [];
+            if (Array.isArray(response.buckets)) {
+                buckets = response.buckets;
+            }
+            else if (Array.isArray(response)) {
+                buckets = response;
+            }
+            else {
+                const possibleBuckets = response.data?.buckets ||
+                    response.result?.buckets ||
+                    response.buckets;
+                if (Array.isArray(possibleBuckets)) {
+                    buckets = possibleBuckets;
+                }
+                else {
+                    throw new Error(`Unexpected response structure: ${JSON.stringify(response)}`);
+                }
+            }
+            return buckets
+                .filter((bucket) => bucket.type !== "system")
+                .map((bucket) => {
+                if (typeof bucket === "string") {
+                    return { name: bucket };
+                }
+                else if (bucket && typeof bucket === "object" && bucket.name) {
+                    const databaseInfo = {
+                        name: bucket.name,
+                        retentionPeriod: bucket.retentionRules?.[0]?.everySeconds
+                            ? bucket.retentionRules[0].everySeconds * 1000000000
+                            : undefined,
+                    };
+                    if (bucket.id) {
+                        databaseInfo.bucketId = bucket.id;
+                    }
+                    if (bucket.orgID) {
+                        databaseInfo.organizationId = bucket.orgID;
+                    }
+                    if (bucket.storageType) {
+                        databaseInfo.storageType = bucket.storageType;
+                    }
+                    if (bucket.createdAt) {
+                        databaseInfo.createdAt = bucket.createdAt;
+                    }
+                    if (bucket.updatedAt) {
+                        databaseInfo.updatedAt = bucket.updatedAt;
+                    }
+                    if (bucket.description) {
+                        databaseInfo.description = bucket.description;
+                    }
+                    if (bucket.rp) {
+                        databaseInfo.retentionPolicy = bucket.rp;
+                    }
+                    return databaseInfo;
+                }
+                else {
+                    return { name: String(bucket) };
+                }
+            });
+        }
+        catch (error) {
+            this.handleDatabaseError(error, "list databases (buckets)");
+        }
+    }
+    /**
+     * Create database for cloud-serverless (create bucket via /api/v2)
+     */
+    async createDatabaseCloudServerless(name, config) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const orgsResponse = await httpClient.get("/api/v2/orgs");
+            let orgID;
+            if (orgsResponse?.orgs && orgsResponse.orgs.length > 0) {
+                orgID = orgsResponse.orgs[0].id;
+            }
+            else {
+                throw new Error("Could not find organization ID for bucket creation");
+            }
+            const payload = {
+                name,
+                orgID,
+                retentionRules: [
+                    {
+                        type: "expire",
+                        everySeconds: config?.retentionPeriod
+                            ? Math.floor(config.retentionPeriod / 1000000000)
+                            : 2592000,
+                    },
+                ],
+            };
+            if (config?.description) {
+                payload.description = config.description;
+            }
+            await httpClient.post("/api/v2/buckets", payload);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `create database (bucket) '${name}'`);
+        }
+    }
+    /**
+     * Delete database for cloud-serverless (delete bucket via /api/v2)
+     */
+    async deleteDatabaseCloudServerless(name) {
+        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 === name && b.type !== "system");
+                if (bucket) {
+                    bucketID = bucket.id;
+                }
+            }
+            if (!bucketID) {
+                throw new Error(`Database (bucket) '${name}' not found`);
+            }
+            await httpClient.delete(`/api/v2/buckets/${bucketID}`);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `delete database (bucket) '${name}'`);
+        }
+    }
+    /**
+     * Update database (bucket) for cloud-serverless via /api/v2
+     * PATCH /api/v2/buckets/{bucketID}
+     */
+    async updateDatabaseCloudServerless(name, config) {
+        try {
+            const httpClient = this.baseService.getInfluxHttpClient(true);
+            const bucketsResponse = await httpClient.get("/api/v2/buckets");
+            let bucket;
+            if (bucketsResponse?.buckets) {
+                bucket = bucketsResponse.buckets.find((b) => b.name === name && b.type !== "system");
+            }
+            if (!bucket) {
+                throw new Error(`Database (bucket) '${name}' not found`);
+            }
+            const updatePayload = {};
+            if (config.name && config.name !== bucket.name) {
+                updatePayload.name = config.name;
+            }
+            if (config.description !== undefined) {
+                updatePayload.description = config.description;
+            }
+            if (config.retentionPeriod !== undefined) {
+                updatePayload.retentionRules = [
+                    {
+                        type: "expire",
+                        everySeconds: Math.floor(config.retentionPeriod / 1000000000),
+                    },
+                ];
+            }
+            else {
+                updatePayload.retentionRules = bucket.retentionRules || [
+                    {
+                        type: "expire",
+                        everySeconds: 2592000,
+                    },
+                ];
+            }
+            if (!updatePayload.retentionRules ||
+                updatePayload.retentionRules.length === 0) {
+                updatePayload.retentionRules = [
+                    {
+                        type: "expire",
+                        everySeconds: 2592000,
+                    },
+                ];
+            }
+            await httpClient.patch(`/api/v2/buckets/${bucket.id}`, updatePayload);
+            return true;
+        }
+        catch (error) {
+            this.handleDatabaseError(error, `update database (bucket) '${name}'`);
+        }
+    }
+    /**
+     * Common error handling for database operations with comprehensive status code handling
+     */
+    handleDatabaseError(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 statusText = error.response?.statusText || "";
+        const formatError = (userMessage) => {
+            const parts = [`HTTP ${status}`, userMessage];
+            if (originalMessage && originalMessage !== statusText) {
+                parts.push(`Server message: ${originalMessage}`);
+            }
+            return parts.join(" - ");
+        };
+        switch (status) {
+            case 400:
+                throw new Error(formatError("Bad Request: Invalid request parameters or malformed request"));
+            case 401:
+                throw new Error(formatError("Unauthorized: Check your InfluxDB token permissions"));
+            case 403:
+                throw new Error(formatError("Forbidden: Token does not have sufficient permissions for this operation"));
+            case 404:
+                throw new Error(formatError("Not Found: Resource does not exist or endpoint not available"));
+            case 409:
+                throw new Error(formatError("Conflict: Resource already exists or operation conflicts with current state"));
+            case 500:
+                throw new Error(formatError("Internal Server Error: InfluxDB server encountered an error"));
+            default:
+                if (error.code === "ECONNREFUSED") {
+                    throw new Error("Connection refused: Check if InfluxDB is running and URL is correct");
+                }
+                else if (error.code === "ENOTFOUND") {
+                    throw new Error("Host not found: Check your InfluxDB URL");
+                }
+                else if (error.response?.data) {
+                    const message = originalMessage || JSON.stringify(error.response.data);
+                    throw new Error(`HTTP ${status} - InfluxDB API error: ${message}`);
+                }
+                else {
+                    throw new Error(`Failed to ${operation}: ${error.message}`);
+                }
+        }
+    }
+}