@uarlouski/testrail-mcp-server 3.3.0 → 3.3.1

package/README.md

@@ -17,6 +17,7 @@
   <a href="https://github.com/uarlouski/testrail-mcp-server"><img src="https://img.shields.io/github/stars/uarlouski/testrail-mcp-server.svg?style=social&label=Star" alt="GitHub stars"></a>
   <a href="https://glama.ai/mcp/servers/uarlouski/testrail-mcp-server"><img src="https://glama.ai/mcp/servers/uarlouski/testrail-mcp-server/badges/score.svg" alt="Score Badge"></a>
   <a href="https://m8ven.ai/mcp/uarlouski/testrail-mcp-server"><img src="https://m8ven.ai/badge/mcp/uarlouski/testrail-mcp-server" alt="M8ven Score"></a>
+  <a href="https://m8ven.ai/mcp/uarlouski-testrail-mcp-server-xt4olk?s=readme"><img src="https://m8ven.ai/badge/mcp/uarlouski-testrail-mcp-server-xt4olk?variant=verified&amp;v=c5887a2e4d6d35e25160ec11bdc4e593" alt="M8ven Verified"></a>
   <a href="https://smithery.ai/servers/uarlouski/testrail-mcp-server"><img src="https://smithery.ai/badge/uarlouski/testrail-mcp-server" alt="Smithery badge"></a>
 </p>
 

package/dist/client/testrail.js

@@ -1,4 +1,5 @@
 import { isActive } from "../utils/sanitizer.js";
+import { TestRailUrl } from "../utils/testrail_url.js";
 import * as fs from "fs";
 import * as path from "path";
 const API_INDEX = '/index.php?';
@@ -62,41 +63,54 @@ export class TestRailClient {
         }
         return this.paginateAll(url, 'cases');
     }
-    async getSection(sectionId) {
-        if (!this.sectionsPromiseMap.has(sectionId.toString())) {
-            this.sectionsPromiseMap.set(sectionId.toString(), this.get(`${API_BASE_V2}/get_section/${sectionId}`));
+    /**
+     * Shares one in-flight lookup among concurrent callers. A resolved value stays
+     * cached. A rejection is removed so the next call issues a new request.
+     */
+    memoize(read, write, factory) {
+        const current = read();
+        if (current) {
+            return current;
         }
-        return this.sectionsPromiseMap.get(sectionId.toString());
+        let promise;
+        promise = factory().catch((error) => {
+            if (read() === promise) {
+                write(null);
+            }
+            throw error;
+        });
+        write(promise);
+        return promise;
+    }
+    memoizeMap(map, key, factory) {
+        return this.memoize(() => map.get(key), (next) => {
+            if (next) {
+                map.set(key, next);
+            }
+            else {
+                map.delete(key);
+            }
+        }, factory);
+    }
+    async getSection(sectionId) {
+        const key = sectionId.toString();
+        return this.memoizeMap(this.sectionsPromiseMap, key, () => this.get(`${API_BASE_V2}/get_section/${sectionId}`));
     }
     async getPriorities() {
-        if (!this.prioritiesPromise) {
-            this.prioritiesPromise = this.get(`${API_BASE_V2}/get_priorities`);
-        }
-        return this.prioritiesPromise;
+        return this.memoize(() => this.prioritiesPromise, (promise) => { this.prioritiesPromise = promise; }, () => this.get(`${API_BASE_V2}/get_priorities`));
     }
     async getCaseTypes() {
-        if (!this.caseTypesPromise) {
-            this.caseTypesPromise = this.get(`${API_BASE_V2}/get_case_types`);
-        }
-        return this.caseTypesPromise;
+        return this.memoize(() => this.caseTypesPromise, (promise) => { this.caseTypesPromise = promise; }, () => this.get(`${API_BASE_V2}/get_case_types`));
     }
     async getCaseFields() {
-        if (!this.caseFieldsPromise) {
-            this.caseFieldsPromise = this.get(`${API_BASE_V2}/get_case_fields`);
-        }
-        return this.caseFieldsPromise;
+        return this.memoize(() => this.caseFieldsPromise, (promise) => { this.caseFieldsPromise = promise; }, () => this.get(`${API_BASE_V2}/get_case_fields`));
     }
     async getStatuses() {
-        if (!this.statusesPromise) {
-            this.statusesPromise = this.get(`${API_BASE_V2}/get_statuses`);
-        }
-        return this.statusesPromise;
+        return this.memoize(() => this.statusesPromise, (promise) => { this.statusesPromise = promise; }, () => this.get(`${API_BASE_V2}/get_statuses`));
     }
     async getTemplates(projectId) {
-        if (!this.templatesPromiseMap.has(projectId.toString())) {
-            this.templatesPromiseMap.set(projectId.toString(), this.get(`${API_BASE_V2}/get_templates/${projectId}`));
-        }
-        return this.templatesPromiseMap.get(projectId.toString());
+        const key = projectId.toString();
+        return this.memoizeMap(this.templatesPromiseMap, key, () => this.get(`${API_BASE_V2}/get_templates/${projectId}`));
     }
     async updateCase(caseId, fields) {
         return this.post(`${API_BASE_V2}/update_case/${caseId}`, fields);
@@ -166,10 +180,7 @@ export class TestRailClient {
         return this.get(`${API_BASE_V2}/get_project/${projectId}`);
     }
     async getProjects() {
-        if (!this.projectsPromise) {
-            this.projectsPromise = this.paginateAll(`${API_BASE_V2}/get_projects`, 'projects');
-        }
-        return this.projectsPromise;
+        return this.memoize(() => this.projectsPromise, (promise) => { this.projectsPromise = promise; }, () => this.paginateAll(`${API_BASE_V2}/get_projects`, 'projects'));
     }
     async getLabels(projectId) {
         const url = `${API_BASE_V2}/get_labels/${projectId}`;
@@ -254,22 +265,21 @@ export class TestRailClient {
     }
     async paginateAll(url, dataKey) {
         const allItems = [];
-        let nextUrl = url;
-        while (nextUrl) {
-            const response = await this.get(nextUrl);
+        let page = TestRailUrl.parse(url).withValidPageLimit();
+        while (page) {
+            const requestedUrl = page.toString();
+            const response = await this.get(requestedUrl);
             // Handle older TestRail versions (pre-7.x) that return flat arrays
             // instead of paginated objects like { "suites": [...], "_links": {...} }
             if (Array.isArray(response)) {
                 allItems.push(...response);
                 break;
             }
-            if (response[dataKey] && Array.isArray(response[dataKey])) {
+            if (response?.[dataKey] && Array.isArray(response[dataKey])) {
                 allItems.push(...response[dataKey]);
             }
-            nextUrl = response._links?.next || null;
-            if (nextUrl) {
-                nextUrl = `${API_INDEX}${nextUrl}`;
-            }
+            const rawNext = typeof response?._links?.next === 'string' ? response._links.next : '';
+            page = page.follow(rawNext, response?.limit, response?.size);
         }
         return allItems;
     }

package/dist/utils/testrail_url.js

@@ -0,0 +1,99 @@
+const API_INDEX = "/index.php?";
+/** TestRail rejects `limit` below 1 and caps a page at 250. */
+export const TESTRAIL_MAX_PAGE_LIMIT = 250;
+/**
+ * TestRail list URL.
+ *
+ * The route sits after `?` and parameters follow with `&`
+ * (`/index.php?/api/v2/get_cases/1&suite_id=5&limit=250`). `_links.next`
+ * omits the `/index.php?` prefix. Parameter values are read with `URLSearchParams`.
+ * Other parameters are left as TestRail sent them, so rewriting `limit` does
+ * not re-encode the rest of the link.
+ *
+ * Workaround for https://github.com/uarlouski/testrail-mcp-server/issues/139:
+ * some self-hosted instances answer a list call with `limit=0` and a next
+ * link that repeats it. Requesting that link fails with 400 "Field :limit is
+ * too small (minimum 1)". `withValidPageLimit` sends 250 when `limit` is
+ * missing or below 1. `follow` skips a next link that does not advance `offset`.
+ */
+export class TestRailUrl {
+    raw;
+    params;
+    constructor(raw, params) {
+        this.raw = raw;
+        this.params = params;
+    }
+    static parse(url) {
+        const queryAt = url.indexOf("&");
+        const query = queryAt === -1 ? "" : url.slice(queryAt + 1);
+        return new TestRailUrl(url, new URLSearchParams(query));
+    }
+    get(name) {
+        return this.params.has(name) ? this.params.get(name) : null;
+    }
+    offset() {
+        return readNonNegativeInt(this.get("offset")) ?? 0;
+    }
+    /**
+     * Returns this URL with a `limit` TestRail will accept.
+     * An explicit limit of 1 or more is kept.
+     */
+    withValidPageLimit(limit = TESTRAIL_MAX_PAGE_LIMIT) {
+        const current = readNonNegativeInt(this.get("limit"));
+        if (current !== null && current >= 1) {
+            return this;
+        }
+        return TestRailUrl.parse(this.writeLimit(limit));
+    }
+    /** Request path, prefixing `/index.php?` onto a `_links.next` value. */
+    toString() {
+        if (this.raw.startsWith(API_INDEX) || this.raw.includes("://")) {
+            return this.raw;
+        }
+        return `${API_INDEX}${this.raw}`;
+    }
+    /**
+     * Next page to request, or `null` when there is no next link, this page is
+     * already shorter than its limit, or `offset` does not move forward.
+     */
+    follow(nextLink, reportedLimit, reportedSize) {
+        if (!nextLink || isLastPage(reportedLimit, reportedSize)) {
+            return null;
+        }
+        const next = TestRailUrl.parse(nextLink).withValidPageLimit();
+        if (next.offset() <= this.offset() || next.toString() === this.toString()) {
+            return null;
+        }
+        return next;
+    }
+    writeLimit(limit) {
+        if (!this.params.has("limit")) {
+            return `${this.raw}&limit=${limit}`;
+        }
+        const queryAt = this.raw.indexOf("&");
+        if (queryAt === -1) {
+            return `${this.raw}&limit=${limit}`;
+        }
+        const route = this.raw.slice(0, queryAt);
+        const parts = this.raw.slice(queryAt + 1).split("&").map((part) => {
+            const eq = part.indexOf("=");
+            const key = eq === -1 ? part : part.slice(0, eq);
+            return key === "limit" ? `limit=${limit}` : part;
+        });
+        return `${route}&${parts.join("&")}`;
+    }
+}
+function isLastPage(reportedLimit, reportedSize) {
+    const limit = readNonNegativeInt(reportedLimit);
+    const size = readNonNegativeInt(reportedSize);
+    return limit !== null && size !== null && limit >= 1 && size > 0 && size < limit;
+}
+function readNonNegativeInt(value) {
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    if (typeof value === "string" && /^\d+$/.test(value)) {
+        return Number(value);
+    }
+    return null;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "3.3.0";
+export const VERSION = "3.3.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uarlouski/testrail-mcp-server",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "mcpName": "io.github.uarlouski/testrail-mcp-server",
   "description": "Model Context Protocol (MCP) server for TestRail: let Claude, Cursor, and Windsurf manage test cases, runs, results, and attachments.",
   "main": "dist/index.js",