@smartbear/mcp 0.8.0 → 0.9.0

package/dist/bugsnag/client/api/base.js

@@ -1,6 +1,9 @@
+import { ToolError } from "../../../common/types.js";
 // Utility to pick only allowed fields from an object
 export function pickFields(obj, keys) {
     const result = {};
+    if (!obj)
+        return result;
     for (const key of keys) {
         if (key in obj) {
             result[key] = obj[key];
@@ -25,7 +28,7 @@ export function getNextUrlPathFromHeader(headers, basePath) {
     return match.replace(basePath, "");
 }
 // Utility to extract total count from headers
-export function getTotalCountFromHeader(headers) {
+function getTotalCountFromHeader(headers) {
     if (!headers)
         return null;
     const totalCount = headers.get("X-Total-Count");
@@ -34,12 +37,47 @@ export function getTotalCountFromHeader(headers) {
     const parsed = parseInt(totalCount, 10);
     return Number.isNaN(parsed) ? null : parsed;
 }
+// Utility to recursively convert object keys from snake_case to camelCase
+function convertKeysToCamelCase(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(convertKeysToCamelCase);
+    }
+    if (typeof obj === "object" && obj.constructor === Object) {
+        const converted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+            converted[camelKey] = convertKeysToCamelCase(value);
+        }
+        return converted;
+    }
+    return obj;
+}
 // Ensure URL is absolute
 // The MCP tools exposed use only the path for pagination
 // For making requests, we need to ensure the URL is absolute
 export function ensureFullUrl(url, basePath) {
     return url.startsWith("http") ? url : `${basePath}${url}`;
 }
+// Merge nextUrl query parameters with options query parameters (usually filters)
+export function getQueryParams(nextUrl, options) {
+    const nextOptions = { query: {} };
+    if (nextUrl) {
+        nextOptions.query = {};
+        if (!nextUrl.includes("?")) {
+            throw new Error("nextUrl must contains query parameters");
+        }
+        new URLSearchParams(nextUrl.split("?")[1]).forEach((value, key) => {
+            nextOptions.query[key] = value;
+        });
+    }
+    if (options) {
+        nextOptions.query = { ...nextOptions.query, ...options.query };
+    }
+    return nextOptions;
+}
 export class BaseAPI {
     configuration;
     filterFields;
@@ -47,53 +85,78 @@ export class BaseAPI {
         this.configuration = configuration;
         this.filterFields = filterFields || [];
     }
-    async request(options, fetchAll = true) {
-        const headers = {
-            ...this.configuration.headers,
-            ...options.headers,
-        };
-        headers.Authorization = `token ${this.configuration.authToken}`;
-        const fetchOptions = {
-            method: options.method,
-            headers,
-            body: options.body ? JSON.stringify(options.body) : undefined,
+    async requestObject(url, options = {}, fields) {
+        if (!this.configuration.basePath) {
+            throw new Error("Base path is not configured for API requests");
+        }
+        if (this.configuration.headers) {
+            options.headers = {
+                ...this.configuration.headers,
+                ...options.headers,
+            };
+        }
+        const response = await fetch(ensureFullUrl(url, this.configuration.basePath), {
+            ...options,
+            headers: {
+                ...options.headers,
+                ...this.configuration.headers,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Request failed with status ${response.status}: ${errorText}`);
+        }
+        const apiResponse = {
+            status: response.status,
+            headers: response.headers,
+            body: convertKeysToCamelCase(await response.json()),
         };
+        if (fields) {
+            apiResponse.body = pickFields(apiResponse.body, fields);
+        }
+        if (this.filterFields) {
+            this.sanitizeResponse(apiResponse.body);
+        }
+        return apiResponse;
+    }
+    async requestArray(url, options = {}, fetchAll = true, fields) {
         let results = [];
-        let nextUrl = options.url;
+        let nextUrl = url;
         let apiResponse;
         do {
-            if (!this.configuration.basePath) {
-                throw new Error("Base path is not configured for API requests");
-            }
             nextUrl = ensureFullUrl(nextUrl, this.configuration.basePath);
-            const response = await fetch(nextUrl, fetchOptions);
+            const response = await fetch(nextUrl, {
+                ...options,
+                headers: {
+                    ...options.headers,
+                    ...this.configuration.headers,
+                },
+            });
             if (!response.ok) {
                 const errorText = await response.text();
-                throw new Error(`Request failed with status ${response.status}: ${errorText}`);
+                throw new ToolError(`Request failed with status ${response.status}: ${errorText}`);
             }
+            const data = convertKeysToCamelCase(await response.json());
+            nextUrl = getNextUrlPathFromHeader(response.headers, this.configuration.basePath);
+            if (!Array.isArray(data)) {
+                throw new Error("Expected response to be an array");
+            }
+            results = results.concat(data);
             apiResponse = {
                 status: response.status,
                 headers: response.headers,
+                nextUrl: nextUrl,
+                totalCount: getTotalCountFromHeader(response.headers),
+                body: results,
             };
-            const data = await response.json();
-            nextUrl = getNextUrlPathFromHeader(response.headers, this.configuration.basePath);
-            if (Array.isArray(data)) {
-                results = results.concat(data);
-                apiResponse.nextUrl = nextUrl;
-            }
-            else {
-                apiResponse.body = data;
-            }
         } while (fetchAll && nextUrl);
-        if (results.length > 0) {
-            apiResponse.body = results;
-            apiResponse.totalCount = getTotalCountFromHeader(apiResponse.headers);
-        }
-        if (Array.isArray(apiResponse.body)) {
-            apiResponse.body.forEach(this.sanitizeResponse.bind(this));
+        if (fields) {
+            apiResponse.body = pickFieldsFromArray(apiResponse.body, fields);
         }
-        else {
-            this.sanitizeResponse(apiResponse.body ?? {});
+        if (this.filterFields) {
+            apiResponse.body.forEach((item) => {
+                this.sanitizeResponse(item);
+            });
         }
         return apiResponse;
     }

package/dist/bugsnag/client/api/configuration.js

@@ -0,0 +1,26 @@
+export class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     * @memberof Configuration
+     */
+    apiKey;
+    /**
+     * override base path
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    basePath;
+    /**
+     * Additional headers for API requests
+     * @type {Record<string, string>}
+     * @memberof Configuration
+     */
+    headers;
+    constructor(param) {
+        this.apiKey = param.apiKey;
+        this.basePath = param.basePath;
+        this.headers = param.headers;
+    }
+}

package/dist/bugsnag/client/api/index.js

@@ -1,2 +1,4 @@
 export { CurrentUserAPI } from "./CurrentUser.js";
+export { Configuration } from "./configuration.js";
 export { ErrorAPI } from "./Error.js";
+export { ProjectAPI } from "./Project.js";

package/dist/bugsnag/client/filters.js

@@ -0,0 +1,28 @@
+/**
+ * Filters utility for BugSnag API
+ *
+ * This file provides utility functions for creating filter URL parameters
+ * based on the BugSnag filtering specification described in the Filtering.md document.
+ */
+import { z } from "zod";
+export const FilterValueSchema = z.object({
+    type: z.enum(["eq", "ne", "empty"]),
+    value: z.union([z.string(), z.boolean(), z.number()]),
+});
+export const FilterObjectSchema = z.record(z.array(FilterValueSchema));
+/**
+ * Converts a FilterObject to URL search parameters
+ *
+ * @param filters The filter object to convert
+ * @returns URLSearchParams object with the encoded filters
+ */
+export function toUrlSearchParams(filters) {
+    const params = new URLSearchParams();
+    Object.entries(filters).forEach(([field, filterValues]) => {
+        filterValues.forEach((filterValue) => {
+            params.append(`filters[${field}][][type]`, filterValue.type);
+            params.append(`filters[${field}][][value]`, filterValue.value.toString());
+        });
+    });
+    return params;
+}