@smartbear/mcp 0.19.2 → 0.21.1

package/dist/qmetry/client/tools/testsuite-tools.js

@@ -926,8 +926,8 @@ const TESTSUITE_TOOLS = [
           entityType: "TCR",
           qmTsRunId: "2720260",
           runStatusID: 123266,
-          username: "dhaval.mistry",
-          password: "Ispl123#",
+          username: "test.user",
+          password: "password",
           isBulkOperation: false
         },
         expectedOutput: "Test case run status updated with Part 11 Compliance authentication"

package/dist/qmetry/client.js

@@ -13,7 +13,7 @@ const ConfigurationSchema = zod__default.object({
 });
 class QmetryClient {
   name = "QMetry";
-  toolPrefix = "qmetry";
+  capabilityPrefix = "qmetry";
   configPrefix = "Qmetry";
   config = ConfigurationSchema;
   token;

package/dist/qtm4j/client.js

@@ -0,0 +1,109 @@
+import zod__default from "zod";
+import { getRequestHeader } from "../common/request-context.js";
+import { CONFIG_KEYS, API_CONFIG, SCHEMA_DESCRIPTIONS, CLIENT_CONFIG, ERROR_MESSAGES } from "./config/constants.js";
+import { ApiClient } from "./http/api-client.js";
+import { ResolverRegistry } from "./resolver/resolver-registry.js";
+const ConfigurationSchema = zod__default.object({
+  [CONFIG_KEYS.API_KEY]: zod__default.string().describe(SCHEMA_DESCRIPTIONS.API_KEY),
+  [CONFIG_KEYS.BASE_URL]: zod__default.string().url().optional().default(API_CONFIG.DEFAULT_BASE_URL).describe(SCHEMA_DESCRIPTIONS.BASE_URL)
+});
+class Qtm4jClient {
+  name = CLIENT_CONFIG.NAME;
+  capabilityPrefix = CLIENT_CONFIG.TOOL_PREFIX;
+  configPrefix = CLIENT_CONFIG.CONFIG_PREFIX;
+  config = ConfigurationSchema;
+  _apiKey;
+  baseUrl = API_CONFIG.DEFAULT_BASE_URL;
+  apiClient;
+  resolverRegistry;
+  /**
+   * Configure the QTM4J client with API credentials
+   * @param server - MCP Server instance
+   * @param config - Configuration object containing API key and optional base URL
+   */
+  async configure(server, config) {
+    this._apiKey = config[CONFIG_KEYS.API_KEY];
+    if (config[CONFIG_KEYS.BASE_URL]) {
+      this.baseUrl = config[CONFIG_KEYS.BASE_URL];
+    }
+    this.apiClient = new ApiClient(() => this.getAuthToken(), this.baseUrl);
+    this.resolverRegistry = new ResolverRegistry(
+      this.apiClient,
+      server.getCache()
+    );
+  }
+  /**
+   * Get authentication token with request-scoped override support
+   * Checks request headers first, then falls back to configured API key
+   * @returns API key or null if not found
+   */
+  getAuthToken() {
+    const contextHeader = getRequestHeader("Qtm4j-Api-Key") || getRequestHeader("apiKey") || getRequestHeader("Authorization");
+    if (contextHeader) {
+      let token = Array.isArray(contextHeader) ? contextHeader[0] : contextHeader;
+      if (token.startsWith("Bearer ")) {
+        token = token.substring(7);
+      }
+      return token;
+    }
+    return this._apiKey || null;
+  }
+  /**
+   * Check if the client is properly configured
+   * @returns true if API key is set and client is ready
+   */
+  isConfigured() {
+    return this.apiClient !== void 0;
+  }
+  /**
+   * Get the configured API client instance
+   * @returns ApiClient instance
+   * @throws Error if client is not configured
+   */
+  getApiClient() {
+    if (!this.apiClient) {
+      throw new Error(ERROR_MESSAGES.CLIENT_NOT_CONFIGURED);
+    }
+    return this.apiClient;
+  }
+  getResolverRegistry() {
+    if (!this.resolverRegistry) {
+      throw new Error(ERROR_MESSAGES.CLIENT_NOT_CONFIGURED);
+    }
+    return this.resolverRegistry;
+  }
+  requireProjectContext() {
+    return this.getResolverRegistry().requireProjectContext();
+  }
+  /**
+   * Register all QTM4J tools with the MCP server
+   *
+   * This method creates tool instances and registers them with the MCP server.
+   * Each tool is prefixed with 'qtm4j_' (e.g., qtm4j_get_projects)
+   *
+   * @param register - Function to register tools with MCP server
+   * @param _getInput - Function to get user input (not used currently)
+   */
+  async registerTools(register, _getInput) {
+    const { GetProjects } = await import("./tool/project/get-projects.js");
+    const { SetProjectContext } = await import("./tool/project/set-project-context.js");
+    const { CreateTestCase } = await import("./tool/test-case/create-test-case.js");
+    const { GetTestCases } = await import("./tool/test-case/get-test-cases.js");
+    const { GetTestSteps } = await import("./tool/test-case/get-test-steps.js");
+    const { UpdateTestCase } = await import("./tool/test-case/update-test-case.js");
+    const tools = [
+      new GetProjects(this),
+      new SetProjectContext(this),
+      new CreateTestCase(this),
+      new GetTestCases(this),
+      new GetTestSteps(this),
+      new UpdateTestCase(this)
+    ];
+    for (const tool of tools) {
+      register(tool.specification, tool.handle);
+    }
+  }
+}
+export {
+  Qtm4jClient
+};

package/dist/qtm4j/config/constants.js

@@ -0,0 +1,169 @@
+const API_CONFIG = {
+  /** Default base URL for QTM4J Cloud */
+  DEFAULT_BASE_URL: "https://qtmcloud.qmetry.com",
+  /** API version prefix */
+  API_VERSION: "/rest/api/latest"
+};
+const ENDPOINTS = {
+  /** Projects endpoint */
+  PROJECTS: `${API_CONFIG.API_VERSION}/projects`,
+  /** Create test case endpoint */
+  CREATE_TEST_CASE: `${API_CONFIG.API_VERSION}/testcases`,
+  /** Search test cases endpoint */
+  SEARCH_TEST_CASES: `${API_CONFIG.API_VERSION}/testcases/search`,
+  /** Resolve test case keys → internal UIDs for a given project */
+  RESOLVE_TEST_CASE_IDS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/testcases/resolve-ids`,
+  /** Update test case endpoint */
+  UPDATE_TEST_CASE: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}`,
+  /** Test steps search endpoint */
+  TEST_STEPS: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}/teststeps/search`,
+  /** Common attributes endpoint (priority, statuses) */
+  COMMON_ATTRIBUTES: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/common-attributes`,
+  /** Labels search endpoint */
+  LABELS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/labels`,
+  /** Components search endpoint */
+  COMPONENTS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/components`
+};
+const HTTP_HEADERS = {
+  /** API key header name */
+  API_KEY: "apiKey",
+  /** Content type header */
+  CONTENT_TYPE: "Content-Type",
+  /** User agent header */
+  USER_AGENT: "User-Agent",
+  /** Accept header */
+  ACCEPT: "Accept",
+  /** Content length header */
+  CONTENT_LENGTH: "content-length"
+};
+const CONTENT_TYPES = {
+  /** JSON content type */
+  JSON: "application/json"
+};
+const HTTP_METHODS = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT"
+};
+const HTTP_STATUS = {
+  /** No content status code */
+  NO_CONTENT: 204
+};
+const CLIENT_CONFIG = {
+  /** Client name */
+  NAME: "QTM4J",
+  /** Tool prefix for all QTM4J tools */
+  TOOL_PREFIX: "qtm4j",
+  /** Configuration prefix */
+  CONFIG_PREFIX: "Qtm4j"
+};
+const PAGINATION = {
+  /** Default starting position for pagination */
+  DEFAULT_START_AT: 0,
+  /** Default maximum results for projects */
+  DEFAULT_MAX_RESULTS_PROJECTS: 100,
+  /** Default maximum results for test cases */
+  DEFAULT_MAX_RESULTS_TEST_CASES: 50,
+  /** Maximum allowed results per request */
+  MAX_ALLOWED_RESULTS: 100,
+  /** Maximum allowed results per request for test cases (backend enforced) */
+  MAX_ALLOWED_RESULTS_TEST_CASES: 50,
+  /** Default maximum results for test steps */
+  DEFAULT_MAX_RESULTS_TEST_STEPS: 50,
+  /** Maximum allowed results per request for test steps */
+  MAX_ALLOWED_RESULTS_TEST_STEPS: 100,
+  /** Minimum allowed results per request */
+  MIN_ALLOWED_RESULTS: 1
+};
+const ERROR_MESSAGES = {
+  /** Client not configured error */
+  CLIENT_NOT_CONFIGURED: "QTM4J client not configured. Please set API key.",
+  /** Request failed template */
+  REQUEST_FAILED: (status, errorText) => `Request failed with status ${status}: ${errorText}`
+};
+const TOOL_NAMES = {
+  /** Get Projects tool */
+  GET_PROJECTS: {
+    TITLE: "Get Projects",
+    SUMMARY: "Get all projects from QTM4J with optional filtering"
+  },
+  /** Set Project Context tool */
+  SET_PROJECT_CONTEXT: {
+    TITLE: "Set Project Context",
+    SUMMARY: "Set the active QTM4J project for the current session. Must be called before any project-specific operation. Pre-loads priority and status values so you can map user-provided names to valid options via NLP."
+  },
+  /** Create Test Case tool */
+  CREATE_TEST_CASE: {
+    TITLE: "Create Test Case",
+    SUMMARY: "Create a new test case in a QTM4J project. Supports auto-resolving human-readable names for priority, status, labels, and components."
+  },
+  /** Search Test Cases tool */
+  SEARCH_TEST_CASES: {
+    TITLE: "Search Test Cases",
+    SUMMARY: "Search and filter test cases in a QTM4J project with support for pagination, field selection, and sorting."
+  },
+  /** Get Test Steps tool */
+  GET_TEST_STEPS: {
+    TITLE: "Get Test Steps",
+    SUMMARY: "Get test steps for a test case by its key and version. Accepts the human-readable key (e.g. 'SCRUM-TC-145') and resolves it to the internal ID automatically."
+  },
+  /** Update Test Case tool */
+  UPDATE_TEST_CASE: {
+    TITLE: "Update Test Case",
+    SUMMARY: "Update an existing test case in QTM4J. Supports auto-resolving human-readable names for priority, status, labels, and components. Labels and components support add/delete operations."
+  }
+};
+const CONFIG_KEYS = {
+  /** API key configuration key */
+  API_KEY: "api_key",
+  /** Base URL configuration key */
+  BASE_URL: "base_url"
+};
+const SCHEMA_DESCRIPTIONS = {
+  /** API key description */
+  API_KEY: "QTM4J API key for authentication",
+  /** Base URL description */
+  BASE_URL: "QTM4J base URL (default: https://qtmcloud.qmetry.com). Can be customized for on-premise installations.",
+  /** Start at description */
+  START_AT: "Zero-indexed starting position for pagination",
+  /** Max results projects description */
+  MAX_RESULTS_PROJECTS: "Maximum number of results per page (1-100)",
+  /** Search text description */
+  SEARCH_TEXT: "Search text for project key or project name",
+  /** QMetry enabled description */
+  QMETRY_ENABLED: "Filter by QMetry enabled status",
+  /** Project object description */
+  PROJECT_OBJECT: "Project object"
+};
+const RESPONSE_FIELDS = {
+  /** Start at field */
+  START_AT: "startAt",
+  /** Max results field */
+  MAX_RESULTS: "maxResults",
+  FIELDS: "fields",
+  SORT: "sort"
+};
+const EMPTY_VALUES = {
+  /** Empty object */
+  OBJECT: {},
+  /** Empty string */
+  STRING: "",
+  /** Zero value */
+  ZERO: 0
+};
+export {
+  API_CONFIG,
+  CLIENT_CONFIG,
+  CONFIG_KEYS,
+  CONTENT_TYPES,
+  EMPTY_VALUES,
+  ENDPOINTS,
+  ERROR_MESSAGES,
+  HTTP_HEADERS,
+  HTTP_METHODS,
+  HTTP_STATUS,
+  PAGINATION,
+  RESPONSE_FIELDS,
+  SCHEMA_DESCRIPTIONS,
+  TOOL_NAMES
+};

package/dist/qtm4j/config/field-resolution.types.js

@@ -0,0 +1,34 @@
+const ResolverKeys = {
+  /**
+   * Fields fetched from the common-attributes API (batch-loaded on project context set).
+   * Values are cached per project and eagerly available for tools.
+   */
+  CommonAttribute: {
+    TESTCASE_STATUS: "testcase_status",
+    TEST_PLAN_STATUS: "testplan_status",
+    TEST_CYCLE_STATUS: "testcycle_status",
+    PRIORITY: "priority",
+    TESTCASE_FOLDER: "testcase_folder"
+  },
+  /**
+   * Fields with dedicated search APIs (fetched on-demand, not batch-loaded).
+   * Resolved lazily when tools reference them — no eager preloading.
+   */
+  SearchableField: {
+    LABEL: "label",
+    COMPONENTS: "components",
+    TEST_CASE_KEY_TO_UID: "testCaseKeyToUid"
+  }
+};
+var InputField = /* @__PURE__ */ ((InputField2) => {
+  InputField2["PRIORITY"] = "priority";
+  InputField2["STATUS"] = "status";
+  InputField2["COMPONENTS"] = "components";
+  InputField2["LABELS"] = "labels";
+  InputField2["FOLDER"] = "folderId";
+  return InputField2;
+})(InputField || {});
+export {
+  InputField,
+  ResolverKeys
+};

package/dist/qtm4j/http/api-client.js

@@ -0,0 +1,123 @@
+import { ToolError } from "../../common/tools.js";
+import { EMPTY_VALUES, ERROR_MESSAGES, HTTP_METHODS, CONTENT_TYPES, HTTP_HEADERS, HTTP_STATUS } from "../config/constants.js";
+import { AuthService } from "./auth-service.js";
+class ApiClient {
+  baseUrl;
+  tokenProvider;
+  constructor(tokenOrProvider, baseUrl) {
+    this.baseUrl = baseUrl.trim().replace(/\/$/, EMPTY_VALUES.STRING);
+    if (typeof tokenOrProvider === "string") {
+      this.tokenProvider = () => tokenOrProvider;
+    } else {
+      this.tokenProvider = tokenOrProvider;
+    }
+  }
+  /**
+   * Get authentication headers for current request
+   * Calls token provider to support request-scoped credentials
+   * @returns Record of HTTP headers including API key
+   * @throws ToolError if token is not available
+   */
+  getHeaders() {
+    const token = this.tokenProvider();
+    if (!token) {
+      throw new ToolError(ERROR_MESSAGES.CLIENT_NOT_CONFIGURED);
+    }
+    return new AuthService(token).getAuthHeaders();
+  }
+  /**
+   * Construct full URL with query parameters
+   * @param endpoint - API endpoint path
+   * @param params - Optional query parameters
+   * @returns Complete URL string
+   */
+  getUrl(endpoint, params) {
+    const url = new URL(this.baseUrl + endpoint);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Perform GET request
+   * @param endpoint - API endpoint path
+   * @param params - Optional query parameters
+   * @returns Parsed response data
+   */
+  async get(endpoint, params) {
+    const response = await fetch(this.getUrl(endpoint, params), {
+      method: HTTP_METHODS.GET,
+      headers: this.getHeaders()
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Perform POST request
+   * @param endpoint - API endpoint path
+   * @param body - Request body object
+   * @returns Parsed response data
+   */
+  async post(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: HTTP_METHODS.POST,
+      headers: {
+        ...this.getHeaders(),
+        [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON
+      },
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Perform PUT request
+   * @param endpoint - API endpoint path
+   * @param body - Request body object
+   * @returns Parsed response data
+   */
+  async put(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: HTTP_METHODS.PUT,
+      headers: {
+        ...this.getHeaders(),
+        [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON
+      },
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Validate HTTP response and extract body
+   * Handles various response types: JSON, text, empty responses
+   * @param response - HTTP response object
+   * @returns Parsed response data or error
+   * @throws ToolError if request fails
+   */
+  async validateAndGetResponseBody(response) {
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ToolError(
+        ERROR_MESSAGES.REQUEST_FAILED(response.status, errorText)
+      );
+    }
+    const contentLength = response.headers.get(HTTP_HEADERS.CONTENT_LENGTH);
+    if (response.status === HTTP_STATUS.NO_CONTENT || contentLength === String(EMPTY_VALUES.ZERO)) {
+      return EMPTY_VALUES.OBJECT;
+    }
+    const text = await response.text();
+    if (!text?.trim()) {
+      return EMPTY_VALUES.OBJECT;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { data: text };
+    }
+  }
+}
+export {
+  ApiClient
+};

package/dist/qtm4j/http/auth-service.js

@@ -0,0 +1,23 @@
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../../common/info.js";
+import { CONTENT_TYPES, HTTP_HEADERS } from "../config/constants.js";
+class AuthService {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey.trim();
+  }
+  /**
+   * Get authentication headers for QTM4J API requests
+   * @returns Record of HTTP headers including API key authorization
+   */
+  getAuthHeaders() {
+    return {
+      [HTTP_HEADERS.API_KEY]: this.apiKey,
+      [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON,
+      [HTTP_HEADERS.USER_AGENT]: `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+      [HTTP_HEADERS.ACCEPT]: CONTENT_TYPES.JSON
+    };
+  }
+}
+export {
+  AuthService
+};

package/dist/qtm4j/resolver/cache/cache.js

@@ -0,0 +1,52 @@
+class Cache {
+  trackedKeys = /* @__PURE__ */ new Map();
+  cacheService;
+  constructor(cacheService) {
+    this.cacheService = cacheService;
+  }
+  compositeKey(projectKey, fieldKey) {
+    return `qtm4j:${projectKey}:${fieldKey}`;
+  }
+  get(projectKey, fieldKey) {
+    return this.cacheService.get(
+      this.compositeKey(projectKey, fieldKey)
+    );
+  }
+  set(projectKey, fieldKey, values) {
+    const key = this.compositeKey(projectKey, fieldKey);
+    const existing = this.cacheService.get(key) ?? {};
+    this.cacheService.set(key, { ...existing, ...values });
+    if (!this.trackedKeys.has(projectKey)) {
+      this.trackedKeys.set(projectKey, /* @__PURE__ */ new Set());
+    }
+    this.trackedKeys.get(projectKey).add(key);
+  }
+  has(projectKey, fieldKey) {
+    return this.cacheService.get(this.compositeKey(projectKey, fieldKey)) !== void 0;
+  }
+  clear(projectKey) {
+    if (projectKey) {
+      const keys = this.trackedKeys.get(projectKey);
+      if (keys) {
+        for (const key of keys) {
+          this.cacheService.del(key);
+        }
+        this.trackedKeys.delete(projectKey);
+      }
+    } else {
+      for (const keys of this.trackedKeys.values()) {
+        for (const key of keys) {
+          this.cacheService.del(key);
+        }
+      }
+      this.trackedKeys.clear();
+    }
+  }
+  /** Case-insensitive lookup of a name within a cached field. */
+  matchValue(projectKey, fieldKey, name) {
+    return this.get(projectKey, fieldKey)?.[name.toLowerCase()];
+  }
+}
+export {
+  Cache
+};

package/dist/qtm4j/resolver/resolver-registry.js

@@ -0,0 +1,70 @@
+import { CommonAttributeResolver } from "./resolvers/common-attribute-resolver.js";
+import { ComponentResolver } from "./resolvers/component-resolver.js";
+import { LabelResolver } from "./resolvers/label-resolver.js";
+import { TestCaseUidResolver } from "./resolvers/test-case-uid-resolver.js";
+const ERROR_NO_PROJECT_CONTEXT = "No active project set. Please call set_project_context before performing this operation.";
+class ResolverRegistry {
+  resolverByKey;
+  commonAttributes;
+  testCaseUidResolver;
+  projectContext;
+  constructor(apiClient, cacheService) {
+    this.commonAttributes = new CommonAttributeResolver(
+      apiClient,
+      cacheService
+    );
+    this.testCaseUidResolver = new TestCaseUidResolver(apiClient);
+    const labelResolver = new LabelResolver(apiClient, cacheService);
+    const componentResolver = new ComponentResolver(apiClient, cacheService);
+    this.resolverByKey = /* @__PURE__ */ new Map();
+    for (const resolver of [
+      this.commonAttributes,
+      labelResolver,
+      componentResolver,
+      this.testCaseUidResolver
+    ]) {
+      for (const key of resolver.fieldKeys) {
+        this.resolverByKey.set(key, resolver);
+      }
+    }
+  }
+  /**
+   * Returns the resolver responsible for the given resolver key.
+   * Tools use this with their FIELD_CONFIG map to dispatch field resolution.
+   */
+  getResolver(resolverKey) {
+    const resolver = this.resolverByKey.get(resolverKey);
+    if (!resolver)
+      throw new Error(`No resolver registered for key '${resolverKey}'`);
+    return resolver;
+  }
+  /**
+   * Direct typed access to the CommonAttributeResolver, used by set_project_context to
+   * eagerly load all common attribute fields (priority, statuses) for LLM NLP mapping.
+   */
+  getCommonAttributeResolver() {
+    return this.commonAttributes;
+  }
+  setProjectContext(context) {
+    this.projectContext = context;
+  }
+  requireProjectContext() {
+    if (!this.projectContext) {
+      throw new Error(ERROR_NO_PROJECT_CONTEXT);
+    }
+    return this.projectContext;
+  }
+  clearCache() {
+    for (const resolver of new Set(this.resolverByKey.values())) {
+      resolver.clearCache();
+    }
+  }
+  clearProjectCache(projectKey) {
+    for (const resolver of new Set(this.resolverByKey.values())) {
+      resolver.clearCache(projectKey);
+    }
+  }
+}
+export {
+  ResolverRegistry
+};

package/dist/qtm4j/resolver/resolvers/common-attribute-resolver.js

@@ -0,0 +1,56 @@
+import { ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { Cache } from "../cache/cache.js";
+import { Resolver } from "./resolver.js";
+class CommonAttributeResolver extends Resolver {
+  fieldKeys = Object.values(
+    ResolverKeys.CommonAttribute
+  );
+  cache;
+  apiClient;
+  constructor(apiClient, cacheService) {
+    super();
+    this.apiClient = apiClient;
+    this.cache = new Cache(cacheService);
+  }
+  // Priority and status are always single values — no array handling needed.
+  async resolve(inputField, resolverKey, body, context, warnings) {
+    const name = body[inputField];
+    if (name == null) return;
+    const id = await this.resolveAndReturn(
+      context.projectKey,
+      context.projectId,
+      resolverKey,
+      name
+    );
+    if (id !== void 0) {
+      body[inputField] = Number(id);
+    } else {
+      warnings.push(
+        `Skipped ${inputField} '${name}' — not available in the current project.`
+      );
+    }
+  }
+  async resolveAndReturn(projectKey, projectId, resolverKey, name) {
+    const cached = this.cache.matchValue(projectKey, resolverKey, name);
+    if (cached !== void 0) return cached;
+    await this.preload(projectKey, projectId);
+    return this.cache.matchValue(projectKey, resolverKey, name);
+  }
+  async preload(projectKey, projectId) {
+    const response = await this.apiClient.get(
+      ENDPOINTS.COMMON_ATTRIBUTES(projectId)
+    );
+    const attributes = response;
+    for (const [key, values] of Object.entries(attributes)) {
+      this.cache.set(projectKey, key, values);
+    }
+    return attributes;
+  }
+  clearCache(projectKey) {
+    this.cache.clear(projectKey);
+  }
+}
+export {
+  CommonAttributeResolver
+};