@smartbear/mcp 0.8.0 → 0.9.0

package/dist/qmetry/client/api/client-api.js

@@ -1,5 +1,16 @@
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../../../common/info.js";
 import { QMETRY_DEFAULTS } from "../../config/constants.js";
+import { handleQMetryApiError, handleQMetryFetchError, } from "./error-handler.js";
+/**
+ * QMetry API request function with centralized error handling.
+ *
+ * Handles authentication, project access, CORS, and generic API errors with
+ * user-friendly messages and troubleshooting guidance.
+ *
+ * @param options Request configuration including authentication token
+ * @returns Parsed JSON response from QMetry API
+ * @throws User-friendly errors with detailed troubleshooting steps for various scenarios
+ */
 export async function qmetryRequest({ method = "GET", path, token, project, baseUrl, body, }) {
     const url = `${baseUrl}${path}`;
     const headers = {
@@ -17,23 +28,17 @@ export async function qmetryRequest({ method = "GET", path, token, project, base
     if (body && ["POST", "PUT", "PATCH"].includes(method)) {
         init.body = JSON.stringify(body);
     }
-    const res = await fetch(url, init);
+    let res;
+    try {
+        res = await fetch(url, init);
+    }
+    catch (error) {
+        // Handle fetch errors (CORS, network issues, SSL certificate issues, etc.)
+        handleQMetryFetchError(error instanceof Error ? error : new Error(String(error)), baseUrl, project, path);
+    }
     if (!res.ok) {
-        let errorText;
-        try {
-            const contentType = res.headers.get("content-type");
-            if (contentType?.includes("application/json")) {
-                const json = await res.json();
-                errorText = JSON.stringify(json);
-            }
-            else {
-                errorText = await res.text();
-            }
-        }
-        catch {
-            errorText = res.statusText;
-        }
-        throw new Error(`QMetry API request failed (${res.status}): ${errorText}`);
+        // Use centralized error handling
+        await handleQMetryApiError(res, baseUrl, project, path);
     }
     return (await res.json());
 }

package/dist/qmetry/client/api/error-handler.js

@@ -0,0 +1,329 @@
+/**
+ * QMetry API Error Handling Utilities
+ *
+ * This module provides centralized error handling for QMetry API operations,
+ * including user-friendly error messages and troubleshooting guidance.
+ *
+ * Handles common error scenarios:
+ * - SSL/TLS Certificate errors (corporate proxies like Zscaler)
+ * - Authentication/Authorization failures
+ * - CORS (Cross-Origin Resource Sharing) issues
+ * - Project access errors
+ * - Network connectivity problems
+ * - Generic API errors with helpful troubleshooting
+ */
+/**
+ * Error message templates for common QMetry API issues
+ */
+const ERROR_TEMPLATES = {
+    AUTHENTICATION_FAILED: (baseUrl, errorText) => `QMetry API Authentication Failed: Invalid or expired API key.\n\n` +
+        `To resolve this issue:\n` +
+        `1. Log into your QMetry Test Management instance: ${baseUrl}\n` +
+        `2. Search Open API → Go To Open API Page\n` +
+        `3. Generate a new API key OR copy an existing valid key\n` +
+        `4. Copy the API key to your clipboard\n` +
+        `5. Restart VS Code or reload the MCP server\n` +
+        `6. When prompted, paste the new API key for 'QMetry Open API Key'\n\n` +
+        `Note: API keys may expire or be revoked. Always use the latest key from your QMetry instance.\n` +
+        `Original error: ${errorText}`,
+    AUTHORIZATION_ERROR: (errorText) => `QMetry Authorization Error: Insufficient permissions.\n\n` +
+        `Your API key is valid but lacks the necessary permissions for this operation.\n\n` +
+        `Possible causes:\n` +
+        `1. Your user role doesn't have access to this resource\n` +
+        `2. The project permissions are restricted\n` +
+        `3. The specific operation requires higher privileges\n\n` +
+        `To resolve:\n` +
+        `1. Contact your QMetry administrator to review your permissions\n` +
+        `2. Verify you have the correct project access\n` +
+        `3. Check if your user role includes the required privileges\n\n` +
+        `Original error: ${errorText}`,
+    PROJECT_ACCESS_ERROR: (project, errorText) => `QMetry Project Access Error: Cannot access project '${project}'.\n\n` +
+        `Possible causes:\n` +
+        `1. API key lacks permissions for this project\n` +
+        `2. Project key '${project}' doesn't exist or is archived\n` +
+        `3. Your user account doesn't have access to this project\n\n` +
+        `To resolve:\n` +
+        `1. Verify the project key is correct\n` +
+        `2. Check your QMetry permissions for this project\n` +
+        `3. Contact your QMetry administrator if needed\n\n` +
+        `Original error: ${errorText}`,
+    GENERIC_API_ERROR: (status, baseUrl, errorText) => `QMetry API request failed (${status}): ${errorText}\n\n` +
+        `Troubleshooting tips:\n` +
+        `Verify your QMetry instance URL: ${baseUrl}\n` +
+        `Check if your API key is valid and not expired\n` +
+        `Ensure you have the necessary permissions\n` +
+        `Try accessing QMetry directly in your browser to confirm connectivity`,
+    CORS_ERROR: (baseUrl, errorText) => `QMetry API CORS Error: Cross-Origin Request Blocked.\n\n` +
+        `CORS (Cross-Origin Resource Sharing) issue detected:\n` +
+        `Your browser is blocking the request due to CORS policy\n` +
+        `The QMetry server may not be configured to allow requests from this origin\n\n` +
+        `Possible solutions:\n` +
+        `1. Contact your QMetry administrator to configure CORS headers\n` +
+        `2. Ensure the QMetry instance URL is correct: ${baseUrl}\n` +
+        `3. If using a proxy, verify proxy CORS configuration\n` +
+        `4. Try accessing QMetry from the same domain/protocol\n` +
+        `5. Check if browser extensions are blocking the request\n\n` +
+        `Technical details: ${errorText}`,
+    SSL_CERTIFICATE_ERROR: (baseUrl, errorText) => `QMetry API SSL Certificate Error: Unable to verify certificate.\n\n` +
+        `SSL/TLS Certificate verification failed - Common in corporate networks:\n` +
+        `• Corporate proxy/firewall (Zscaler, Forcepoint, etc.) is intercepting HTTPS traffic\n` +
+        `• Self-signed or corporate certificates are being used\n` +
+        `• Certificate chain validation is failing\n\n` +
+        `Solution for corporate network environments:\n` +
+        `Contact your IT administrator to:\n` +
+        `• Add QMetry domain to certificate bypass list\n` +
+        `• Configure corporate certificates properly\n` +
+        `• Whitelist the QMetry API endpoints\n` +
+        `Target URL: ${baseUrl}\n` +
+        `Technical details: ${errorText}`,
+    INVALID_URL_ERROR: (baseUrl, path, errorText) => `QMetry API Invalid URL Error: The API endpoint appears to be incorrect.\n\n` +
+        `Request details:\n` +
+        `• Base URL: ${baseUrl}\n` +
+        `• API Path: ${path}\n` +
+        `• Full URL: ${baseUrl}${path}\n\n` +
+        `Common URL issues:\n` +
+        `1. Wrong API endpoint path (check QMetry API documentation)\n` +
+        `2. Typo in the URL path (missing '/', wrong spelling)\n` +
+        `3. API version mismatch (v1, v2, etc.)\n` +
+        `4. Incorrect base URL (should end with QMetry instance domain)\n` +
+        `5. Body stream errors (often caused by malformed URLs or wrong HTTP method)\n\n` +
+        `Troubleshooting steps:\n` +
+        `1. Verify the API endpoint in QMetry documentation\n` +
+        `2. Check the QMetry instance URL is correct\n` +
+        `3. Test the endpoint manually using a REST client\n` +
+        `4. Ensure the API path matches the expected format\n` +
+        `5. If you see 'Body is unusable' errors, check for URL typos or wrong endpoints\n\n` +
+        `Expected URL format: https://your-qmetry-instance.com/rest/...\n` +
+        `Server response: ${errorText}`,
+};
+/**
+ * Checks if the error is related to authentication (invalid/expired API key)
+ */
+function isAuthenticationError(context) {
+    const { status, errorData } = context;
+    return (status === 401 ||
+        errorData?.code === "CO.INVALID_API_KEY" ||
+        errorData?.message?.toLowerCase().includes("invalid api key"));
+}
+/**
+ * Checks if the error is related to authorization (insufficient permissions)
+ */
+function isAuthorizationError(context) {
+    const { status } = context;
+    return status === 403;
+}
+/**
+ * Checks if the error is related to project access
+ */
+function isProjectAccessError(context) {
+    const { status, path } = context;
+    return status === 404 && (path?.includes("project") ?? false);
+}
+/**
+ * Checks if the error is related to CORS (Cross-Origin Resource Sharing)
+ */
+function isCorsError(context) {
+    const { status, errorText, isCorsError } = context;
+    // Explicit CORS flag from fetch error
+    if (isCorsError) {
+        return true;
+    }
+    // Common CORS indicators
+    const corsIndicators = [
+        "cors",
+        "cross-origin",
+        "cross origin",
+        "preflight",
+        "access-control-allow-origin",
+        "network error when attempting to fetch resource",
+        "failed to fetch",
+    ];
+    const lowercaseErrorText = errorText.toLowerCase();
+    // Status 0 often indicates CORS issues
+    if (status === 0) {
+        return true;
+    }
+    // Check error text for CORS-related keywords
+    return corsIndicators.some((indicator) => lowercaseErrorText.includes(indicator));
+}
+/**
+ * Checks if the error is related to SSL/TLS certificate issues
+ */
+function isSslCertificateError(context) {
+    const { errorText } = context;
+    // Common SSL certificate error indicators
+    const sslErrorIndicators = [
+        "unable to get local issuer certificate",
+        "unable_to_get_issuer_cert_locally",
+        "self signed certificate",
+        "certificate verify failed",
+        "ssl certificate problem",
+        "certificate has expired",
+        "certificate authority is invalid",
+        "untrusted certificate",
+        "cert authority invalid",
+        "tls certificate verification failed",
+        "certificate validation error",
+    ];
+    const lowercaseErrorText = errorText.toLowerCase();
+    // Check for specific error codes that indicate SSL issues
+    if (lowercaseErrorText.includes("unable_to_get_issuer_cert_locally") ||
+        lowercaseErrorText.includes("cert_untrusted") ||
+        lowercaseErrorText.includes("cert_authority_invalid") ||
+        lowercaseErrorText.includes("certificate verify failed")) {
+        return true;
+    }
+    // Check error text for SSL-related keywords
+    return sslErrorIndicators.some((indicator) => lowercaseErrorText.includes(indicator));
+}
+/**
+ * Checks if the error is related to invalid/wrong API URL
+ */
+function isInvalidUrlError(context) {
+    const { status, errorText, errorData } = context;
+    const lowercaseErrorText = errorText.toLowerCase();
+    // HTTP 404 is the most common indicator of wrong URL/endpoint
+    if (status === 404) {
+        return true;
+    }
+    // Check for specific error messages that indicate wrong URL
+    const urlErrorIndicators = [
+        "not found",
+        "resource not found",
+        "endpoint not found",
+        "path not found",
+        "url not found",
+        "route not found",
+        "invalid endpoint",
+        "unknown endpoint",
+        "method not allowed",
+        "no handler found",
+        "404",
+        // Body stream errors that often indicate wrong URL/malformed requests
+        "body is unusable",
+        "body has already been read",
+        "request body already read",
+        "body stream already consumed",
+        "invalid request body",
+        "malformed request",
+    ];
+    // Check error text for URL-related keywords
+    if (urlErrorIndicators.some((indicator) => lowercaseErrorText.includes(indicator))) {
+        return true;
+    }
+    // Check if error data indicates invalid endpoint
+    if (errorData?.error?.toLowerCase().includes("not found") ||
+        errorData?.message?.toLowerCase().includes("not found")) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Creates an appropriate error message based on the error context
+ */
+export function createQMetryError(context) {
+    const { status, errorText, baseUrl, project } = context;
+    // SSL certificate errors should be checked first as they're network-level issues
+    if (isSslCertificateError(context)) {
+        return new Error(ERROR_TEMPLATES.SSL_CERTIFICATE_ERROR(baseUrl, errorText));
+    }
+    if (isCorsError(context)) {
+        return new Error(ERROR_TEMPLATES.CORS_ERROR(baseUrl, errorText));
+    }
+    if (isAuthenticationError(context)) {
+        return new Error(ERROR_TEMPLATES.AUTHENTICATION_FAILED(baseUrl, errorText));
+    }
+    if (isAuthorizationError(context)) {
+        return new Error(ERROR_TEMPLATES.AUTHORIZATION_ERROR(errorText));
+    }
+    if (isProjectAccessError(context) && project) {
+        return new Error(ERROR_TEMPLATES.PROJECT_ACCESS_ERROR(project, errorText));
+    }
+    // Check for invalid URL/endpoint errors (404, wrong paths, etc.)
+    if (isInvalidUrlError(context)) {
+        const path = context.path || "";
+        return new Error(ERROR_TEMPLATES.INVALID_URL_ERROR(baseUrl, path, errorText));
+    }
+    return new Error(ERROR_TEMPLATES.GENERIC_API_ERROR(status, baseUrl, errorText));
+}
+/**
+ * Handles QMetry API errors in a standardized way
+ *
+ * @param response - The failed HTTP response
+ * @param baseUrl - The QMetry base URL
+ * @param project - Optional project context
+ * @param path - Optional API path context
+ */
+export async function handleQMetryApiError(response, baseUrl, project, path) {
+    let errorData;
+    let errorText;
+    try {
+        errorData = await response.json();
+        errorText = JSON.stringify(errorData);
+    }
+    catch {
+        errorText = (await response.text()) || `HTTP ${response.status}`;
+    }
+    const context = {
+        status: response.status,
+        errorData,
+        errorText,
+        baseUrl,
+        project,
+        path,
+    };
+    throw createQMetryError(context);
+}
+/**
+ * Handles fetch errors that occur before receiving a response (e.g., CORS, network issues)
+ *
+ * @param error - The fetch error
+ * @param baseUrl - The QMetry base URL
+ * @param project - Optional project context
+ * @param path - Optional API path context
+ */
+export function handleQMetryFetchError(error, baseUrl, project, path) {
+    // Extract comprehensive error information
+    let errorText = error.message || error.toString();
+    // Check if error has a cause property with more details (common for SSL errors)
+    if (error.cause && typeof error.cause === "object") {
+        const cause = error.cause;
+        if (cause.message) {
+            errorText += ` | Cause: ${cause.message}`;
+        }
+        if (cause.code) {
+            errorText += ` | Code: ${cause.code}`;
+        }
+        // Add the full cause details for better debugging
+        if (cause.toString && typeof cause.toString === "function") {
+            errorText += ` | Details: ${cause.toString()}`;
+        }
+    }
+    // Check for specific SSL error patterns in the full error
+    const fullErrorString = JSON.stringify(error, Object.getOwnPropertyNames(error));
+    if (fullErrorString.includes("unable to get local issuer certificate") ||
+        fullErrorString.includes("UNABLE_TO_GET_ISSUER_CERT_LOCALLY")) {
+        errorText +=
+            " | SSL Certificate Error: Corporate proxy/firewall intercepting HTTPS";
+    }
+    // Check if this is an SSL certificate error first
+    const tempContext = {
+        status: 0,
+        errorText,
+        baseUrl,
+        project,
+        path,
+    };
+    const isSSLError = isSslCertificateError(tempContext);
+    const isURLError = isInvalidUrlError(tempContext);
+    const context = {
+        status: 0, // Status 0 typically indicates network/CORS/SSL issues
+        errorText,
+        baseUrl,
+        project,
+        path,
+        // Only assume CORS if it's not an SSL or URL error
+        isCorsError: !isSSLError && !isURLError,
+    };
+    throw createQMetryError(context);
+}

package/dist/qmetry/client/auto-resolve.js

@@ -0,0 +1,74 @@
+import { QMetryToolsHandlers } from "../config/constants.js";
+/**
+ * Registry of all modules that support auto-resolution
+ * Add new modules here to automatically support viewId/folderPath resolution
+ */
+export const AUTO_RESOLVE_MODULES = [
+    {
+        handler: QMetryToolsHandlers.FETCH_TEST_CASES,
+        viewIdPath: "latestViews.TC.viewId",
+        moduleName: "Test Cases",
+    },
+    {
+        handler: QMetryToolsHandlers.FETCH_REQUIREMENTS,
+        viewIdPath: "latestViews.RQ.viewId",
+        moduleName: "Requirements",
+    },
+    {
+        handler: QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE,
+        viewIdPath: "latestViews.TSFS.viewId",
+        folderIdPath: "rootFolders.TS.id",
+        folderIdField: "tsFolderID",
+        moduleName: "Test Suites",
+    },
+];
+/**
+ * Helper function to safely get nested property value using dot notation
+ * @param obj - Object to traverse
+ * @param path - Dot notation path (e.g., 'latestViews.TC.viewId')
+ * @returns The value at the path or undefined if not found
+ */
+export function getNestedProperty(obj, path) {
+    return path.split(".").reduce((current, key) => current?.[key], obj);
+}
+/**
+ * Generic auto-resolve function for viewId, folderPath, and folderID
+ * @param args - Tool arguments that may contain viewId/folderPath/folderID
+ * @param projectInfo - Project information from QMetry API
+ * @param config - Module configuration for this specific handler
+ * @returns Updated args with resolved values
+ */
+export function autoResolveViewIdAndFolderPath(args, projectInfo, config) {
+    const updatedArgs = { ...args };
+    let viewId = updatedArgs.viewId;
+    const folderPath = updatedArgs.folderPath;
+    // Auto-resolve viewId if not provided and config has viewIdPath
+    if (!viewId && config.viewIdPath) {
+        viewId = getNestedProperty(projectInfo, config.viewIdPath);
+        if (viewId) {
+            updatedArgs.viewId = viewId;
+        }
+    }
+    // Auto-resolve folderPath if not provided (defaults to root)
+    if (folderPath === undefined) {
+        updatedArgs.folderPath = "";
+    }
+    // Auto-resolve folder ID if not provided and config has folderIdPath
+    if (config.folderIdPath &&
+        config.folderIdField &&
+        !updatedArgs[config.folderIdField]) {
+        const folderId = getNestedProperty(projectInfo, config.folderIdPath);
+        if (folderId) {
+            updatedArgs[config.folderIdField] = folderId;
+        }
+    }
+    return updatedArgs;
+}
+/**
+ * Find the auto-resolve configuration for a given handler
+ * @param handler - The handler name to find config for
+ * @returns Module configuration or undefined if not found
+ */
+export function findAutoResolveConfig(handler) {
+    return AUTO_RESOLVE_MODULES.find((module) => module.handler === handler);
+}

package/dist/qmetry/client/handlers.js

@@ -1,11 +1,28 @@
 import { QMetryToolsHandlers } from "../config/constants.js";
-import { getProjectInfo } from "./project.js";
-import { fetchTestCaseDetails, fetchTestCaseSteps, fetchTestCases, fetchTestCaseVersionDetails, } from "./testcase.js";
+import { fetchIssuesLinkedToTestCase } from "./issues.js";
+import { getBuilds, getPlatforms, getProjectInfo, getReleasesCycles, } from "./project.js";
+import { fetchRequirementDetails, fetchRequirements, fetchRequirementsLinkedToTestCase, } from "./requirement.js";
+import { fetchTestCaseDetails, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCases, fetchTestCasesLinkedToRequirement, fetchTestCaseVersionDetails, } from "./testcase.js";
+import { fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuitesForTestCase, } from "./testsuite.js";
 export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.SET_PROJECT_INFO]: getProjectInfo,
     [QMetryToolsHandlers.FETCH_PROJECT_INFO]: getProjectInfo,
+    [QMetryToolsHandlers.FETCH_RELEASES_CYCLES]: getReleasesCycles,
+    [QMetryToolsHandlers.FETCH_BUILDS]: getBuilds,
+    [QMetryToolsHandlers.FETCH_PLATFORMS]: getPlatforms,
     [QMetryToolsHandlers.FETCH_TEST_CASES]: fetchTestCases,
     [QMetryToolsHandlers.FETCH_TEST_CASE_DETAILS]: fetchTestCaseDetails,
     [QMetryToolsHandlers.FETCH_TEST_CASE_VERSION_DETAILS]: fetchTestCaseVersionDetails,
     [QMetryToolsHandlers.FETCH_TEST_CASE_STEPS]: fetchTestCaseSteps,
+    [QMetryToolsHandlers.FETCH_TEST_CASE_EXECUTIONS]: fetchTestCaseExecutions,
+    [QMetryToolsHandlers.FETCH_REQUIREMENTS]: fetchRequirements,
+    [QMetryToolsHandlers.FETCH_REQUIREMENT_DETAILS]: fetchRequirementDetails,
+    [QMetryToolsHandlers.FETCH_TESTCASES_LINKED_TO_REQUIREMENT]: fetchTestCasesLinkedToRequirement,
+    [QMetryToolsHandlers.FETCH_REQUIREMENTS_LINKED_TO_TESTCASE]: fetchRequirementsLinkedToTestCase,
+    [QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE]: fetchTestSuitesForTestCase,
+    [QMetryToolsHandlers.FETCH_TESTCASES_BY_TESTSUITE]: fetchTestCasesByTestSuite,
+    [QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE]: fetchExecutionsByTestSuite,
+    [QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN]: fetchTestCaseRunsByTestSuiteRun,
+    [QMetryToolsHandlers.FETCH_LINKED_ISSUES_BY_TESTCASE_RUN]: fetchLinkedIssuesByTestCaseRun,
+    [QMetryToolsHandlers.FETCH_ISSUES_LINKED_TO_TESTCASE]: fetchIssuesLinkedToTestCase,
 };

package/dist/qmetry/client/issues.js

@@ -0,0 +1,26 @@
+import { QMETRY_PATHS } from "../config/rest-endpoints.js";
+import { DEFAULT_FETCH_ISSUES_LINKED_TO_TESTCASE_PAYLOAD, } from "../types/issues.js";
+import { qmetryRequest } from "./api/client-api.js";
+import { resolveDefaults } from "./utils.js";
+/**
+ * Fetches issues linked to a specific test case.
+ * @throws If `tcID` is missing/invalid.
+ */
+export async function fetchIssuesLinkedToTestCase(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_FETCH_ISSUES_LINKED_TO_TESTCASE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.tcID !== "number") {
+        throw new Error("[fetchIssuesLinkedToTestCase] Missing or invalid required parameter: 'tcID'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.ISSUES.GET_ISSUES_LINKED_TO_TC,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}

package/dist/qmetry/client/project.js

@@ -1,5 +1,6 @@
 import { QMETRY_DEFAULTS } from "../config/constants.js";
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
+import { DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, } from "../types/project.js";
 import { qmetryRequest } from "./api/client-api.js";
 /**
  * Retrieves project information from QMetry
@@ -25,3 +26,58 @@ export async function getProjectInfo(token, baseUrl, project) {
         project: project || QMETRY_DEFAULTS.PROJECT_KEY,
     });
 }
+export async function getReleasesCycles(token, baseUrl, project, payload = {}) {
+    let showArchiveValue;
+    if (payload.showArchive !== undefined) {
+        showArchiveValue = payload.showArchive;
+    }
+    else {
+        showArchiveValue = false;
+    }
+    const body = {
+        showArchive: showArchiveValue,
+    };
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.GET_RELEASES_CYCLES,
+        token,
+        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+        body,
+    });
+}
+/**
+ * Fetches a List of Builds of the current project.
+ */
+export async function getBuilds(token, baseUrl, project, payload) {
+    const body = {
+        ...DEFAULT_FETCH_BUILD_PAYLOAD,
+        ...payload,
+    };
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.GET_BUILD,
+        token,
+        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+        body,
+    });
+}
+/**
+ * Fetches platforms from the current QMetry project
+ *
+ */
+export async function getPlatforms(token, baseUrl, project, payload) {
+    const body = {
+        ...DEFAULT_FETCH_PLATFORMS_PAYLOAD,
+        ...payload,
+    };
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.GET_PLATFORMS,
+        token,
+        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+        body,
+    });
+}

package/dist/qmetry/client/requirement.js

@@ -0,0 +1,76 @@
+import { QMETRY_PATHS } from "../config/rest-endpoints.js";
+import { DEFAULT_FETCH_REQUIREMENT_DETAILS_PAYLOAD, DEFAULT_FETCH_REQUIREMENTS_LINKED_TO_TESTCASE_PAYLOAD, DEFAULT_FETCH_REQUIREMENTS_PAYLOAD, } from "../types/requirements.js";
+import { qmetryRequest } from "./api/client-api.js";
+import { resolveDefaults } from "./utils.js";
+/**
+ * Fetches a list of requirements.
+ * @throws If `viewId` or `folderPath` are missing/invalid.
+ */
+export async function fetchRequirements(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_FETCH_REQUIREMENTS_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.viewId !== "number") {
+        throw new Error("[fetchRequirements] Missing or invalid required parameter: 'viewId'.");
+    }
+    if (typeof body.folderPath !== "string") {
+        throw new Error("[fetchRequirements] Missing or invalid required parameter: 'folderPath'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.REQUIREMENT.GET_RQ_LIST,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Fetches requirement details by numeric ID.
+ * @throws If `id` or `version` are missing/invalid.
+ */
+export async function fetchRequirementDetails(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_FETCH_REQUIREMENT_DETAILS_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.id !== "number") {
+        throw new Error("[fetchRequirementDetails] Missing or invalid required parameter: 'id'.");
+    }
+    if (typeof body.version !== "number") {
+        throw new Error("[fetchRequirementDetails] Missing or invalid required parameter: 'version'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.REQUIREMENT.GET_RQ_DETAILS,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Fetches requirements linked to a specific test case.
+ * @throws If `tcID` is missing/invalid.
+ */
+export async function fetchRequirementsLinkedToTestCase(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_FETCH_REQUIREMENTS_LINKED_TO_TESTCASE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.tcID !== "number") {
+        throw new Error("[fetchRequirementsLinkedToTestCase] Missing or invalid required parameter: 'tcID'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.REQUIREMENT.GET_RQ_LINKED_TO_TC,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}