@smartbear/mcp 0.12.0 → 0.13.1

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

@@ -1,106 +1,85 @@
 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.CREATE_TEST_CASE,
-        folderIdPath: "rootFolders.TC.id",
-        folderIdField: "tcFolderID",
-        moduleName: "Test Cases",
-    },
-    {
-        handler: QMetryToolsHandlers.FETCH_REQUIREMENTS,
-        viewIdPath: "latestViews.RQ.viewId",
-        moduleName: "Requirements",
-    },
-    {
-        handler: QMetryToolsHandlers.FETCH_TEST_SUITES,
-        viewIdPath: "latestViews.TS.viewId",
-        moduleName: "Test Suites",
-    },
-    {
-        handler: QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN,
-        viewIdPath: "latestViews.TE.viewId",
-        moduleName: "Test Case Run By Test Suite Run",
-    },
-    {
-        handler: QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE,
-        viewIdPath: "latestViews.TEL.viewId",
-        moduleName: "Executions By Test Suites",
-    },
-    {
-        handler: QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE,
-        viewIdPath: "latestViews.TSFS.viewId",
-        folderIdPath: "rootFolders.TS.id",
-        folderIdField: "tsFolderID",
-        moduleName: "Test Suites",
-    },
-    {
-        handler: QMetryToolsHandlers.CREATE_TEST_SUITE,
-        folderIdPath: "rootFolders.TS.id",
-        folderIdField: "parentFolderId",
-        moduleName: "Test Suites",
-    },
-    {
-        handler: QMetryToolsHandlers.FETCH_ISSUES,
-        viewIdPath: "latestViews.IS.viewId",
-        moduleName: "Issues",
-    },
+const AUTO_RESOLVE_MODULES = [
+  {
+    handler: QMetryToolsHandlers.FETCH_TEST_CASES,
+    viewIdPath: "latestViews.TC.viewId",
+    moduleName: "Test Cases"
+  },
+  {
+    handler: QMetryToolsHandlers.CREATE_TEST_CASE,
+    folderIdPath: "rootFolders.TC.id",
+    folderIdField: "tcFolderID",
+    moduleName: "Test Cases"
+  },
+  {
+    handler: QMetryToolsHandlers.FETCH_REQUIREMENTS,
+    viewIdPath: "latestViews.RQ.viewId",
+    moduleName: "Requirements"
+  },
+  {
+    handler: QMetryToolsHandlers.FETCH_TEST_SUITES,
+    viewIdPath: "latestViews.TS.viewId",
+    moduleName: "Test Suites"
+  },
+  {
+    handler: QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN,
+    viewIdPath: "latestViews.TE.viewId",
+    moduleName: "Test Case Run By Test Suite Run"
+  },
+  {
+    handler: QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE,
+    viewIdPath: "latestViews.TEL.viewId",
+    moduleName: "Executions By Test Suites"
+  },
+  {
+    handler: QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE,
+    viewIdPath: "latestViews.TSFS.viewId",
+    folderIdPath: "rootFolders.TS.id",
+    folderIdField: "tsFolderID",
+    moduleName: "Test Suites"
+  },
+  {
+    handler: QMetryToolsHandlers.CREATE_TEST_SUITE,
+    folderIdPath: "rootFolders.TS.id",
+    folderIdField: "parentFolderId",
+    moduleName: "Test Suites"
+  },
+  {
+    handler: QMetryToolsHandlers.FETCH_ISSUES,
+    viewIdPath: "latestViews.IS.viewId",
+    moduleName: "Issues"
+  }
 ];
-/**
- * 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);
+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;
-        }
+function autoResolveViewIdAndFolderPath(args, projectInfo, config) {
+  const updatedArgs = { ...args };
+  let viewId = updatedArgs.viewId;
+  const folderPath = updatedArgs.folderPath;
+  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 = "";
+  }
+  if (folderPath === void 0) {
+    updatedArgs.folderPath = "";
+  }
+  if (config.folderIdPath && config.folderIdField && !updatedArgs[config.folderIdField]) {
+    const folderId = getNestedProperty(projectInfo, config.folderIdPath);
+    if (folderId) {
+      updatedArgs[config.folderIdField] = folderId;
     }
-    // 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;
+  }
+  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);
+function findAutoResolveConfig(handler) {
+  return AUTO_RESOLVE_MODULES.find((module) => module.handler === handler);
 }
+export {
+  AUTO_RESOLVE_MODULES,
+  autoResolveViewIdAndFolderPath,
+  findAutoResolveConfig,
+  getNestedProperty
+};

package/dist/qmetry/client/automation.js

@@ -4,168 +4,145 @@ import { QMETRY_PATHS } from "../config/rest-endpoints.js";
 import { DEFAULT_IMPORT_AUTOMATION_PAYLOAD } from "../types/automation.js";
 import { qmetryRequest } from "./api/client-api.js";
 import { handleQMetryApiError } from "./api/error-handler.js";
-/**
- * Imports automation test results into QMetry
- *
- * This function handles file upload via FormData to import automation test results
- * from various frameworks (TestNG, JUnit, Cucumber, Robot, etc.)
- *
- * CRITICAL NOTES:
- * - User MUST provide a valid result file (.json, .xml, or .zip up to 30 MB)
- * - File should be base64 encoded or provided as file path
- * - EntityType is required and determines the framework format
- * - Various parameters control test case/suite creation and linking behavior
- *
- * @param token - QMetry API authentication token
- * @param baseUrl - QMetry instance base URL
- * @param project - Project key (used in header, can be overridden by projectID in payload)
- * @param payload - Import configuration including file data, entityType, and optional parameters
- * @returns Promise resolving to import result with test suite and execution details
- */
-export async function importAutomationResults(token, baseUrl, project, payload) {
-    // Merge with defaults
-    const finalPayload = {
-        ...DEFAULT_IMPORT_AUTOMATION_PAYLOAD,
-        ...payload,
-    };
-    // Create FormData for multipart/form-data upload
-    const formData = new FormData();
-    // Handle file upload
-    // The file should be provided as base64 string or file content
-    let fileBlob;
-    if (finalPayload.file.startsWith("data:")) {
-        // Base64 data URI format
-        const base64Data = finalPayload.file.split(",")[1];
-        const binaryData = atob(base64Data);
-        const bytes = new Uint8Array(binaryData.length);
-        for (let i = 0; i < binaryData.length; i++) {
-            bytes[i] = binaryData.charCodeAt(i);
-        }
-        fileBlob = new Blob([bytes]);
-    }
-    else if (finalPayload.file.startsWith("/") ||
-        finalPayload.file.includes(":\\")) {
-        // File path - read file from filesystem (Node.js only)
-        try {
-            const fs = await import("node:fs/promises");
-            const fileBuffer = await fs.readFile(finalPayload.file);
-            fileBlob = new Blob([new Uint8Array(fileBuffer)]);
-        }
-        catch (error) {
-            throw new Error(`Failed to read file from path: ${finalPayload.file}. Error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    else {
-        // Assume raw base64 string
-        try {
-            const binaryData = atob(finalPayload.file);
-            const bytes = new Uint8Array(binaryData.length);
-            for (let i = 0; i < binaryData.length; i++) {
-                bytes[i] = binaryData.charCodeAt(i);
-            }
-            fileBlob = new Blob([bytes]);
-        }
-        catch (_error) {
-            throw new Error("Invalid file format. Please provide base64 encoded file content or file path.");
-        }
-    }
-    // Add file to FormData
-    formData.append("file", fileBlob, finalPayload.fileName);
-    // Add required entityType
-    formData.append("entityType", finalPayload.entityType);
-    // Add optional parameters
-    if (finalPayload.automationHierarchy) {
-        formData.append("automationHierarchy", finalPayload.automationHierarchy);
-    }
-    if (finalPayload.testsuiteName) {
-        formData.append("testsuiteName", finalPayload.testsuiteName);
-    }
-    if (finalPayload.testsuiteId) {
-        formData.append("testsuiteId", finalPayload.testsuiteId);
-    }
-    if (finalPayload.tsFolderPath) {
-        formData.append("tsFolderPath", finalPayload.tsFolderPath);
-    }
-    if (finalPayload.tcFolderPath) {
-        formData.append("tcFolderPath", finalPayload.tcFolderPath);
-    }
-    if (finalPayload.platformID) {
-        formData.append("platformID", finalPayload.platformID);
-    }
-    if (finalPayload.projectID) {
-        formData.append("projectID", finalPayload.projectID);
-    }
-    if (finalPayload.releaseID) {
-        formData.append("releaseID", finalPayload.releaseID);
-    }
-    if (finalPayload.cycleID) {
-        formData.append("cycleID", finalPayload.cycleID);
-    }
-    if (finalPayload.buildID) {
-        formData.append("buildID", finalPayload.buildID);
-    }
-    if (finalPayload.testcase_fields) {
-        formData.append("testcase_fields", finalPayload.testcase_fields);
-    }
-    if (finalPayload.testsuite_fields) {
-        formData.append("testsuite_fields", finalPayload.testsuite_fields);
-    }
-    if (finalPayload.skipWarning) {
-        formData.append("skipWarning", finalPayload.skipWarning);
-    }
-    if (finalPayload.is_matching_required) {
-        formData.append("is_matching_required", finalPayload.is_matching_required);
-    }
-    // Make API request
-    const url = `${baseUrl || QMETRY_DEFAULTS.BASE_URL}${QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS}`;
-    const headers = {
-        apikey: token,
-        project: finalPayload.projectID || project || QMETRY_DEFAULTS.PROJECT_KEY,
-        "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
-        // Note: Content-Type will be set automatically by fetch for FormData
-    };
-    let res;
+async function importAutomationResults(token, baseUrl, project, payload) {
+  const finalPayload = {
+    ...DEFAULT_IMPORT_AUTOMATION_PAYLOAD,
+    ...payload
+  };
+  const formData = new FormData();
+  let fileBlob;
+  if (finalPayload.file.startsWith("data:")) {
+    const base64Data = finalPayload.file.split(",")[1];
+    const binaryData = atob(base64Data);
+    const bytes = new Uint8Array(binaryData.length);
+    for (let i = 0; i < binaryData.length; i++) {
+      bytes[i] = binaryData.charCodeAt(i);
+    }
+    fileBlob = new Blob([bytes]);
+  } else if (finalPayload.file.startsWith("/") || finalPayload.file.includes(":\\")) {
     try {
-        res = await fetch(url, {
-            method: "POST",
-            headers,
-            body: formData,
-        });
-    }
-    catch (error) {
-        throw new Error(`Failed to import automation results. Network error: ${error instanceof Error ? error.message : String(error)}\n\nPlease check:\n- QMetry server is accessible\n- File size is under 30 MB\n- File format is .json, .xml, or .zip`);
-    }
-    if (!res.ok) {
-        await handleQMetryApiError(res, baseUrl || QMETRY_DEFAULTS.BASE_URL, project || QMETRY_DEFAULTS.PROJECT_KEY, QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS);
-    }
-    return await res.json();
-}
-/**
- * Fetches automation status by request ID from QMetry
- * @param token - QMetry API authentication token
- * @param baseUrl - QMetry instance base URL
- * @param requestID - Numeric request ID from import automation response
- * @returns Promise resolving to automation status
- */
-export async function getAutomationStatus(token, baseUrl, project, requestID) {
-    let numericRequestID;
-    if (typeof requestID === "object" &&
-        requestID !== null &&
-        "requestID" in requestID &&
-        typeof requestID.requestID !== "undefined") {
-        numericRequestID = Number(requestID.requestID);
-    }
-    else {
-        numericRequestID = Number(requestID);
-    }
-    if (!numericRequestID || Number.isNaN(numericRequestID)) {
-        throw new Error("requestID must be a valid number");
-    }
-    return qmetryRequest({
-        method: "GET",
-        path: QMETRY_PATHS.AUTOMATION.GET_STATUS.replace(":requestID", String(numericRequestID)),
-        token,
-        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
-        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+      const fs = await import("node:fs/promises");
+      const fileBuffer = await fs.readFile(finalPayload.file);
+      fileBlob = new Blob([new Uint8Array(fileBuffer)]);
+    } catch (error) {
+      throw new Error(
+        `Failed to read file from path: ${finalPayload.file}. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } else {
+    try {
+      const binaryData = atob(finalPayload.file);
+      const bytes = new Uint8Array(binaryData.length);
+      for (let i = 0; i < binaryData.length; i++) {
+        bytes[i] = binaryData.charCodeAt(i);
+      }
+      fileBlob = new Blob([bytes]);
+    } catch (_error) {
+      throw new Error(
+        "Invalid file format. Please provide base64 encoded file content or file path."
+      );
+    }
+  }
+  formData.append("file", fileBlob, finalPayload.fileName);
+  formData.append("entityType", finalPayload.entityType);
+  if (finalPayload.automationHierarchy) {
+    formData.append("automationHierarchy", finalPayload.automationHierarchy);
+  }
+  if (finalPayload.testsuiteName) {
+    formData.append("testsuiteName", finalPayload.testsuiteName);
+  }
+  if (finalPayload.testsuiteId) {
+    formData.append("testsuiteId", finalPayload.testsuiteId);
+  }
+  if (finalPayload.tsFolderPath) {
+    formData.append("tsFolderPath", finalPayload.tsFolderPath);
+  }
+  if (finalPayload.tcFolderPath) {
+    formData.append("tcFolderPath", finalPayload.tcFolderPath);
+  }
+  if (finalPayload.platformID) {
+    formData.append("platformID", finalPayload.platformID);
+  }
+  if (finalPayload.projectID) {
+    formData.append("projectID", finalPayload.projectID);
+  }
+  if (finalPayload.releaseID) {
+    formData.append("releaseID", finalPayload.releaseID);
+  }
+  if (finalPayload.cycleID) {
+    formData.append("cycleID", finalPayload.cycleID);
+  }
+  if (finalPayload.buildID) {
+    formData.append("buildID", finalPayload.buildID);
+  }
+  if (finalPayload.testcase_fields) {
+    formData.append("testcase_fields", finalPayload.testcase_fields);
+  }
+  if (finalPayload.testsuite_fields) {
+    formData.append("testsuite_fields", finalPayload.testsuite_fields);
+  }
+  if (finalPayload.skipWarning) {
+    formData.append("skipWarning", finalPayload.skipWarning);
+  }
+  if (finalPayload.is_matching_required) {
+    formData.append("is_matching_required", finalPayload.is_matching_required);
+  }
+  const url = `${baseUrl || QMETRY_DEFAULTS.BASE_URL}${QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS}`;
+  const headers = {
+    apikey: token,
+    project: finalPayload.projectID || project || QMETRY_DEFAULTS.PROJECT_KEY,
+    "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`
+    // Note: Content-Type will be set automatically by fetch for FormData
+  };
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: formData
     });
+  } catch (error) {
+    throw new Error(
+      `Failed to import automation results. Network error: ${error instanceof Error ? error.message : String(error)}
+
+Please check:
+- QMetry server is accessible
+- File size is under 30 MB
+- File format is .json, .xml, or .zip`
+    );
+  }
+  if (!res.ok) {
+    await handleQMetryApiError(
+      res,
+      baseUrl || QMETRY_DEFAULTS.BASE_URL,
+      project || QMETRY_DEFAULTS.PROJECT_KEY,
+      QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS
+    );
+  }
+  return await res.json();
+}
+async function getAutomationStatus(token, baseUrl, project, requestID) {
+  let numericRequestID;
+  if (typeof requestID === "object" && requestID !== null && "requestID" in requestID && typeof requestID.requestID !== "undefined") {
+    numericRequestID = Number(requestID.requestID);
+  } else {
+    numericRequestID = Number(requestID);
+  }
+  if (!numericRequestID || Number.isNaN(numericRequestID)) {
+    throw new Error("requestID must be a valid number");
+  }
+  return qmetryRequest({
+    method: "GET",
+    path: QMETRY_PATHS.AUTOMATION.GET_STATUS.replace(
+      ":requestID",
+      String(numericRequestID)
+    ),
+    token,
+    baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+    project: project || QMETRY_DEFAULTS.PROJECT_KEY
+  });
 }
+export {
+  getAutomationStatus,
+  importAutomationResults
+};

package/dist/qmetry/client/handlers.js

@@ -1,49 +1,52 @@
 import { QMetryToolsHandlers } from "../config/constants.js";
 import { getAutomationStatus, importAutomationResults } from "./automation.js";
-import { createIssue, fetchIssues, fetchIssuesLinkedToTestCase, linkIssuesToTestcaseRun, updateIssue, } from "./issues.js";
-import { createCycle, createRelease, getBuilds, getPlatforms, getProjectInfo, getProjects, getReleasesCycles, updateCycle, } from "./project.js";
-import { fetchRequirementDetails, fetchRequirements, fetchRequirementsLinkedToTestCase, } from "./requirement.js";
-import { createTestCases, fetchTestCaseDetails, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCases, fetchTestCasesLinkedToRequirement, fetchTestCaseVersionDetails, linkRequirementToTestCase, updateTestCase, } from "./testcase.js";
-import { bulkUpdateExecutionStatus, createTestSuites, fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuites, fetchTestSuitesForTestCase, linkPlatformsToTestSuite, linkTestCasesToTestSuite, reqLinkedTestCasesToTestSuite, updateTestSuite, } from "./testsuite.js";
-export const QMETRY_HANDLER_MAP = {
-    [QMetryToolsHandlers.FETCH_PROJECTS]: getProjects,
-    [QMetryToolsHandlers.SET_PROJECT_INFO]: getProjectInfo,
-    [QMetryToolsHandlers.FETCH_PROJECT_INFO]: getProjectInfo,
-    [QMetryToolsHandlers.FETCH_RELEASES_CYCLES]: getReleasesCycles,
-    [QMetryToolsHandlers.FETCH_BUILDS]: getBuilds,
-    [QMetryToolsHandlers.FETCH_PLATFORMS]: getPlatforms,
-    [QMetryToolsHandlers.CREATE_RELEASE]: createRelease,
-    [QMetryToolsHandlers.CREATE_CYCLE]: createCycle,
-    [QMetryToolsHandlers.UPDATE_CYCLE]: updateCycle,
-    [QMetryToolsHandlers.CREATE_TEST_CASE]: createTestCases,
-    [QMetryToolsHandlers.UPDATE_TEST_CASE]: updateTestCase,
-    [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.LINK_REQUIREMENT_TO_TESTCASE]: linkRequirementToTestCase,
-    [QMetryToolsHandlers.FETCH_REQUIREMENTS]: fetchRequirements,
-    [QMetryToolsHandlers.FETCH_REQUIREMENT_DETAILS]: fetchRequirementDetails,
-    [QMetryToolsHandlers.FETCH_TESTCASES_LINKED_TO_REQUIREMENT]: fetchTestCasesLinkedToRequirement,
-    [QMetryToolsHandlers.FETCH_REQUIREMENTS_LINKED_TO_TESTCASE]: fetchRequirementsLinkedToTestCase,
-    [QMetryToolsHandlers.CREATE_TEST_SUITE]: createTestSuites,
-    [QMetryToolsHandlers.UPDATE_TEST_SUITE]: updateTestSuite,
-    [QMetryToolsHandlers.FETCH_TEST_SUITES]: fetchTestSuites,
-    [QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE]: fetchTestSuitesForTestCase,
-    [QMetryToolsHandlers.LINK_TESTCASES_TO_TESTSUITE]: linkTestCasesToTestSuite,
-    [QMetryToolsHandlers.REQUIREMENTS_LINKED_TESTCASES_TO_TESTSUITE]: reqLinkedTestCasesToTestSuite,
-    [QMetryToolsHandlers.FETCH_TESTCASES_BY_TESTSUITE]: fetchTestCasesByTestSuite,
-    [QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE]: fetchExecutionsByTestSuite,
-    [QMetryToolsHandlers.BULK_UPDATE_EXECUTION_STATUS]: bulkUpdateExecutionStatus,
-    [QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN]: fetchTestCaseRunsByTestSuiteRun,
-    [QMetryToolsHandlers.FETCH_LINKED_ISSUES_BY_TESTCASE_RUN]: fetchLinkedIssuesByTestCaseRun,
-    [QMetryToolsHandlers.FETCH_ISSUES_LINKED_TO_TESTCASE]: fetchIssuesLinkedToTestCase,
-    [QMetryToolsHandlers.CREATE_ISSUE]: createIssue,
-    [QMetryToolsHandlers.UPDATE_ISSUE]: updateIssue,
-    [QMetryToolsHandlers.FETCH_ISSUES]: fetchIssues,
-    [QMetryToolsHandlers.LINK_ISSUES_TO_TESTCASE_RUN]: linkIssuesToTestcaseRun,
-    [QMetryToolsHandlers.LINK_PLATFORMS_TO_TESTSUITE]: linkPlatformsToTestSuite,
-    [QMetryToolsHandlers.IMPORT_AUTOMATION_RESULTS]: importAutomationResults,
-    [QMetryToolsHandlers.FETCH_AUTOMATION_STATUS]: getAutomationStatus,
+import { linkIssuesToTestcaseRun, fetchIssues, updateIssue, createIssue, fetchIssuesLinkedToTestCase } from "./issues.js";
+import { updateCycle, createCycle, createRelease, getPlatforms, getBuilds, getReleasesCycles, getProjectInfo, getProjects } from "./project.js";
+import { fetchRequirementsLinkedToTestCase, fetchRequirementDetails, fetchRequirements } from "./requirement.js";
+import { fetchTestCasesLinkedToRequirement, linkRequirementToTestCase, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCaseVersionDetails, fetchTestCaseDetails, fetchTestCases, updateTestCase, createTestCases } from "./testcase.js";
+import { linkPlatformsToTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, bulkUpdateExecutionStatus, fetchExecutionsByTestSuite, fetchTestCasesByTestSuite, reqLinkedTestCasesToTestSuite, linkTestCasesToTestSuite, fetchTestSuitesForTestCase, fetchTestSuites, updateTestSuite, createTestSuites } from "./testsuite.js";
+const QMETRY_HANDLER_MAP = {
+  [QMetryToolsHandlers.FETCH_PROJECTS]: getProjects,
+  [QMetryToolsHandlers.SET_PROJECT_INFO]: getProjectInfo,
+  [QMetryToolsHandlers.FETCH_PROJECT_INFO]: getProjectInfo,
+  [QMetryToolsHandlers.FETCH_RELEASES_CYCLES]: getReleasesCycles,
+  [QMetryToolsHandlers.FETCH_BUILDS]: getBuilds,
+  [QMetryToolsHandlers.FETCH_PLATFORMS]: getPlatforms,
+  [QMetryToolsHandlers.CREATE_RELEASE]: createRelease,
+  [QMetryToolsHandlers.CREATE_CYCLE]: createCycle,
+  [QMetryToolsHandlers.UPDATE_CYCLE]: updateCycle,
+  [QMetryToolsHandlers.CREATE_TEST_CASE]: createTestCases,
+  [QMetryToolsHandlers.UPDATE_TEST_CASE]: updateTestCase,
+  [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.LINK_REQUIREMENT_TO_TESTCASE]: linkRequirementToTestCase,
+  [QMetryToolsHandlers.FETCH_REQUIREMENTS]: fetchRequirements,
+  [QMetryToolsHandlers.FETCH_REQUIREMENT_DETAILS]: fetchRequirementDetails,
+  [QMetryToolsHandlers.FETCH_TESTCASES_LINKED_TO_REQUIREMENT]: fetchTestCasesLinkedToRequirement,
+  [QMetryToolsHandlers.FETCH_REQUIREMENTS_LINKED_TO_TESTCASE]: fetchRequirementsLinkedToTestCase,
+  [QMetryToolsHandlers.CREATE_TEST_SUITE]: createTestSuites,
+  [QMetryToolsHandlers.UPDATE_TEST_SUITE]: updateTestSuite,
+  [QMetryToolsHandlers.FETCH_TEST_SUITES]: fetchTestSuites,
+  [QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE]: fetchTestSuitesForTestCase,
+  [QMetryToolsHandlers.LINK_TESTCASES_TO_TESTSUITE]: linkTestCasesToTestSuite,
+  [QMetryToolsHandlers.REQUIREMENTS_LINKED_TESTCASES_TO_TESTSUITE]: reqLinkedTestCasesToTestSuite,
+  [QMetryToolsHandlers.FETCH_TESTCASES_BY_TESTSUITE]: fetchTestCasesByTestSuite,
+  [QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE]: fetchExecutionsByTestSuite,
+  [QMetryToolsHandlers.BULK_UPDATE_EXECUTION_STATUS]: bulkUpdateExecutionStatus,
+  [QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN]: fetchTestCaseRunsByTestSuiteRun,
+  [QMetryToolsHandlers.FETCH_LINKED_ISSUES_BY_TESTCASE_RUN]: fetchLinkedIssuesByTestCaseRun,
+  [QMetryToolsHandlers.FETCH_ISSUES_LINKED_TO_TESTCASE]: fetchIssuesLinkedToTestCase,
+  [QMetryToolsHandlers.CREATE_ISSUE]: createIssue,
+  [QMetryToolsHandlers.UPDATE_ISSUE]: updateIssue,
+  [QMetryToolsHandlers.FETCH_ISSUES]: fetchIssues,
+  [QMetryToolsHandlers.LINK_ISSUES_TO_TESTCASE_RUN]: linkIssuesToTestcaseRun,
+  [QMetryToolsHandlers.LINK_PLATFORMS_TO_TESTSUITE]: linkPlatformsToTestSuite,
+  [QMetryToolsHandlers.IMPORT_AUTOMATION_RESULTS]: importAutomationResults,
+  [QMetryToolsHandlers.FETCH_AUTOMATION_STATUS]: getAutomationStatus
+};
+export {
+  QMETRY_HANDLER_MAP
 };