@uarlouski/testrail-mcp-server 1.3.0 → 1.4.0

package/{src/tools/create_case.ts → dist/tools/create_case.js}

@@ -1,14 +1,10 @@
 import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {
-    section_id: z.string().describe("The ID of the section where the case should be created. Use get_sections to find available sections"),
+    section_id: z.number().describe("The ID of the section where the case should be created. Use get_sections to find available sections"),
     title: z.string().describe("The title of the test case"),
     fields: z.record(z.string(), z.any()).optional().describe("Optional fields for the test case. First use get_templates to discover available templates, then get_case_fields to see available fields for your template. Example: {\"priority_id\": 2, \"template_id\": 1, \"custom_automation_priority\": 1}"),
 };
-
-export const createCaseTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const createCaseTool = {
     name: "create_case",
     description: "Create a new test case in TestRail",
     parameters,
@@ -17,9 +13,7 @@ export const createCaseTool: ToolDefinition<typeof parameters, TestRailClient> =
             title,
             ...fields,
         };
-
         const createdCase = await client.createCase(section_id, caseData);
-
         return {
             success: true,
             case_id: createdCase.id,

package/{src/tools/get_case.ts → dist/tools/get_case.js}

@@ -1,44 +1,37 @@
 import { z } from "zod";
 import { processCustomFields } from "../utils/mapper.js";
-import { TestRailClient } from "../client/testrail.js";
-import { TestCaseResponse, ToolDefinition } from "../types/custom.js";
-
+import { LabelSchema } from "../types/testrail.js";
 const parameters = {
     case_id: z.string().describe("The ID of the test case (e.g. '123' or 'C123')"),
 };
-
-export const getCaseTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getCaseTool = {
     name: "get_case",
     description: "Get detailed information about a test case including its custom fields",
     parameters,
     handler: async ({ case_id }, client) => {
-        const id = case_id.toUpperCase().startsWith("C") ? case_id.substring(1) : case_id;
+        const idString = case_id.toUpperCase().startsWith("C") ? case_id.substring(1) : case_id;
+        const id = Number(idString);
         const testCase = await client.getCase(id);
-
         const [section, caseTypes, priorities, caseFields] = await Promise.all([
-            client.getSection(testCase.section_id.toString()),
+            client.getSection(Number(testCase.section_id)),
             client.getCaseTypes(),
             client.getPriorities(),
             client.getCaseFields()
         ]);
-
         const caseType = caseTypes.find(t => t.id === testCase.type_id);
         const priority = priorities.find(p => p.id === testCase.priority_id);
-
         const customFields = processCustomFields(testCase, caseFields);
-
-        const response: TestCaseResponse = {
+        const response = {
             id: testCase.id,
             title: testCase.title,
             section: section.name,
             type: caseType ? caseType.name : "Unknown",
             priority: priority ? priority.name : "Unknown",
-            labels: testCase.labels || [],
+            labels: (testCase.labels || []).map((label) => LabelSchema.parse(label)),
             references: testCase.refs,
             updated_on: testCase.updated_on,
             ...customFields
         };
-
         return response;
     }
 };

package/{src/tools/get_case_fields.ts → dist/tools/get_case_fields.js}

@@ -1,24 +1,6 @@
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-import { CaseField } from "../types/testrail.js";
 import { parseDropdownOptions } from "../utils/mapper.js";
-
 const parameters = {};
-
-interface FieldSchema {
-    system_name: string;
-    label: string;
-    type: string;
-    is_required: boolean;
-    template_ids?: number[];
-    options?: string[];
-}
-
-interface CaseFieldsResponse {
-    fields: FieldSchema[];
-}
-
-const FIELD_TYPE_NAMES: Record<number, string> = {
+const FIELD_TYPE_NAMES = {
     1: "String",
     2: "Integer",
     3: "Text",
@@ -33,35 +15,28 @@ const FIELD_TYPE_NAMES: Record<number, string> = {
     12: "Multi-select",
     13: "Scenarios",
 };
-
-function getFieldTypeName(typeId: number): string {
+function getFieldTypeName(typeId) {
     return FIELD_TYPE_NAMES[typeId] || `Unknown (${typeId})`;
 }
-
-function isFieldRequired(field: CaseField): boolean {
+function isFieldRequired(field) {
     return field.configs.some(config => config.options?.is_required === true);
 }
-
-function mapToFieldSchema(field: CaseField): FieldSchema {
-    const schema: FieldSchema = {
+function mapToFieldSchema(field) {
+    const schema = {
         system_name: field.system_name,
         label: field.label,
         type: getFieldTypeName(field.type_id),
         is_required: isFieldRequired(field),
     };
-
     if (!field.include_all && field.template_ids.length > 0) {
         schema.template_ids = field.template_ids;
     }
-
     if (field.type_id === 6 || field.type_id === 12) {
         schema.options = Array.from(parseDropdownOptions(field).values());
     }
-
     return schema;
 }
-
-const SYSTEM_FIELDS: FieldSchema[] = [
+const SYSTEM_FIELDS = [
     { system_name: "title", label: "Title", type: "String", is_required: true },
     { system_name: "section_id", label: "Section", type: "Integer", is_required: true },
     { system_name: "template_id", label: "Template", type: "Integer", is_required: false },
@@ -71,20 +46,16 @@ const SYSTEM_FIELDS: FieldSchema[] = [
     { system_name: "milestone_id", label: "Milestone", type: "Integer", is_required: false },
     { system_name: "refs", label: "References", type: "String", is_required: false },
 ];
-
-export const getCaseFieldsTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getCaseFieldsTool = {
     name: "get_case_fields",
     description: "Get the field schema for test cases. Returns all available fields with their types, descriptions, and options (for dropdown fields). Use this to understand what fields can be set when creating or updating test cases.",
     parameters,
     handler: async (_args, client) => {
         const caseFields = await client.getCaseFields();
-
         const customFieldSchemas = caseFields.filter(field => field.is_active).map(mapToFieldSchema);
-
-        const response: CaseFieldsResponse = {
+        const response = {
             fields: [...SYSTEM_FIELDS, ...customFieldSchemas],
         };
-
         return response;
     }
 };

package/{src/tools/get_cases.ts → dist/tools/get_cases.js}

@@ -1,32 +1,32 @@
 import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-import { Case } from "../types/testrail.js";
-
 const parameters = {
-    project_id: z.string().describe("The ID of the project. Use get_projects to find available projects"),
-    section_id: z.string().optional().describe("Optional section ID to filter cases by section. Use get_sections to find available sections"),
+    project_id: z.number().describe("The ID of the project. Use get_projects to find available projects"),
+    section: z.object({
+        id: z.number(),
+        recursive: z.boolean().optional().default(false).describe("If true, fetches cases from the section and all its child sections"),
+        excludes: z.array(z.string()).optional().describe("List of section names to exclude from the recursive search"),
+    }).optional().describe("Section filter configuration. Use get_sections to find available sections"),
     filter: z.record(z.string(), z.string()).optional().describe("Optional API-side filters (more efficient for large datasets). Supported: priority_id, type_id, created_by, updated_by, milestone_id, refs, created_after, created_before, updated_after, updated_before. Use comma-separated values for IDs. Example: {\"priority_id\": \"1,2\", \"type_id\": \"3\"}"),
     where: z.record(z.string(), z.any()).optional().describe("Optional client-side filter for any field including custom fields (filters after fetching all cases). Supports exact value matching. Example: {\"custom_automation_status\": 1, \"priority_id\": 2}"),
     fields: z.array(z.string()).optional().describe("Additional fields to include in response beyond id, title, and suite_id. Use get_case_fields to see available fields. Example: [\"priority_id\", \"type_id\", \"custom_automation_status\"]"),
 };
-
-interface CasesResponse {
-    cases: Record<string, any>[];
-}
-
-export const getCasesTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getCasesTool = {
     name: "get_cases",
     description: "Get all test cases for a project. Filter by section, API params (priority, type), or any field including custom fields via 'where'. Returns case IDs, titles, and any additional requested fields.",
     parameters,
-    handler: async ({ project_id, section_id, filter, where, fields }, client) => {
-        let cases: Case[] = await client.getCases(project_id, section_id, filter);
-
+    handler: async ({ project_id, section, filter, where, fields }, client) => {
+        let cases;
+        if (section?.recursive) {
+            cases = await client.getCasesRecursively(project_id, section.id, filter, section.excludes);
+        }
+        else {
+            cases = await client.getCases(project_id, section?.id, filter);
+        }
         // Client-side filtering for custom fields and other unsupported API filters
         if (where) {
             cases = cases.filter(c => {
                 for (const [key, value] of Object.entries(where)) {
-                    const caseValue = (c as Record<string, any>)[key];
+                    const caseValue = c[key];
                     if (caseValue !== value) {
                         return false;
                     }
@@ -34,15 +34,13 @@ export const getCasesTool: ToolDefinition<typeof parameters, TestRailClient> = {
                 return true;
             });
         }
-
-        const response: CasesResponse = {
+        const response = {
             cases: cases.map(c => {
-                const result: Record<string, any> = {
+                const result = {
                     id: c.id,
                     title: c.title,
                     suite_id: c.suite_id,
                 };
-
                 if (fields) {
                     for (const field of fields) {
                         if (field in c) {
@@ -50,11 +48,9 @@ export const getCasesTool: ToolDefinition<typeof parameters, TestRailClient> = {
                         }
                     }
                 }
-
                 return result;
             }),
         };
-
         return response;
     }
 };

package/{src/tools/get_projects.ts → dist/tools/get_projects.js}

@@ -1,16 +1,11 @@
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
 import { ProjectSchema } from "../types/testrail.js";
-
 const parameters = {};
-
-export const getProjectsTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getProjectsTool = {
     name: "get_projects",
     description: "Get all available projects in TestRail. Returns project IDs and names that can be used with get_sections, get_templates, get_cases, and add_run",
     parameters,
     handler: async (_args, client) => {
         const projects = await client.getProjects();
-
         return {
             projects: projects
                 .filter(p => !p.is_completed)

package/{src/tools/get_sections.ts → dist/tools/get_sections.js}

@@ -1,19 +1,14 @@
 import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
 import { SectionSchema } from "../types/testrail.js";
-
 const parameters = {
-    project_id: z.string().describe("The ID of the project. Use get_projects to find available projects"),
+    project_id: z.number().describe("The ID of the project. Use get_projects to find available projects"),
 };
-
-export const getSectionsTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getSectionsTool = {
     name: "get_sections",
     description: "Get all sections for a project. Returns section IDs and names that can be used with create_case",
     parameters,
     handler: async ({ project_id }, client) => {
         const sections = await client.getSections(project_id);
-
         return {
             sections: sections.map(s => SectionSchema.parse(s)),
         };

package/{src/tools/get_statuses.ts → dist/tools/get_statuses.js}

@@ -1,15 +1,10 @@
-import { TestRailClient } from "../client/testrail.js";
-import { z } from "zod";
 import { StatusSchema } from "../types/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {};
-
-export const getStatusesTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getStatusesTool = {
     name: "get_statuses",
     description: "Get all available test statuses (e.g. Passed, Failed, Blocked). Returns status IDs and names that can be used with add_result and get_tests",
     parameters,
-    handler: async (args: any, client: TestRailClient) => {
+    handler: async (args, client) => {
         const statuses = await client.getStatuses();
         return {
             statuses: statuses.map(s => StatusSchema.parse(s)),

package/{src/tools/get_templates.ts → dist/tools/get_templates.js}

@@ -1,19 +1,14 @@
 import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
 import { TemplateSchema } from "../types/testrail.js";
-
 const parameters = {
-    project_id: z.string().describe("The ID of the project. Use get_projects to find available projects"),
+    project_id: z.number().describe("The ID of the project. Use get_projects to find available projects"),
 };
-
-export const getTemplatesTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const getTemplatesTool = {
     name: "get_templates",
     description: "Get available test case templates for a project. Template IDs determine which fields are available when creating or updating test cases",
     parameters,
     handler: async ({ project_id }, client) => {
         const templates = await client.getTemplates(project_id);
-
         return {
             templates: templates.map(t => TemplateSchema.parse(t)),
         };

package/{src/tools/get_tests.ts → dist/tools/get_tests.js}

@@ -1,20 +1,15 @@
-import { TestRailClient } from "../client/testrail.js";
 import { z } from "zod";
-import { Test, TestSchema } from "../types/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
+import { TestSchema } from "../types/testrail.js";
 const parameters = {
     run_id: z.number().describe("The ID of the test run"),
     status_id: z.array(z.number()).optional().describe("Optional array of status IDs to filter by. Use get_statuses to retrieve available status IDs"),
-}
-
-export const getTestsTool: ToolDefinition<typeof parameters, TestRailClient> = {
+};
+export const getTestsTool = {
     name: "get_tests",
     description: "Get tests for a test run, optionally filtered by status",
     parameters,
-    handler: async ({ run_id, status_id }, client: TestRailClient) => {
-        const tests: Test[] = await client.getTests(run_id, status_id);
-
+    handler: async ({ run_id, status_id }, client) => {
+        const tests = await client.getTests(run_id, status_id);
         return {
             tests: tests.map(test => TestSchema.parse(test)),
         };

package/{src/tools/update_case.ts → dist/tools/update_case.js}

@@ -1,21 +1,16 @@
 import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {
     case_id: z.string().describe("The ID of the test case to update (e.g. '123' or 'C123')"),
     fields: z.record(z.string(), z.any()).describe("Object containing fields to update. Use get_case_fields to see available fields. Example: {\"title\": \"New title\", \"priority_id\": 2, \"custom_automation_priority\": 1}"),
 };
-
-export const updateCaseTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const updateCaseTool = {
     name: "update_case",
     description: "Update a test case in TestRail. Supports partial updates - only specify the fields you want to change",
     parameters,
     handler: async ({ case_id, fields }, client) => {
-        const id = case_id.toUpperCase().startsWith("C") ? case_id.substring(1) : case_id;
-
+        const idString = case_id.toUpperCase().startsWith("C") ? case_id.substring(1) : case_id;
+        const id = Number(idString);
         const updatedCase = await client.updateCase(id, fields);
-
         return {
             success: true,
             case_id: updatedCase.id,

package/{src/tools/update_cases.ts → dist/tools/update_cases.js}

@@ -1,20 +1,15 @@
 import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
 const parameters = {
     case_ids: z.array(z.number()).describe("Array of case IDs to update (e.g. [123, 456, 789])"),
     fields: z.record(z.string(), z.any()).describe("Object containing fields to update for ALL specified cases. Use get_case_fields to see available fields. Example: {\"priority_id\": 2, \"type_id\": 1}"),
 };
-
-export const updateCasesTool: ToolDefinition<typeof parameters, TestRailClient> = {
+export const updateCasesTool = {
     name: "update_cases",
     description: "Bulk update multiple test cases with the same field values. More efficient than calling update_case multiple times",
     parameters,
     handler: async ({ case_ids, fields }, client) => {
-        const caseData = await client.getCase(String(case_ids[0]));
+        const caseData = await client.getCase(case_ids[0]);
         const updatedCases = await client.updateCases(caseData.suite_id, case_ids, fields);
-
         return {
             success: true,
             updated_count: updatedCases.length,

package/dist/types/custom.js

@@ -0,0 +1 @@
+export {};

package/{src/types/testrail.ts → dist/types/testrail.js}

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 export const CaseFieldConfigSchema = z.object({
     options: z.object({
         default_value: z.string().optional(),
@@ -7,9 +6,6 @@ export const CaseFieldConfigSchema = z.object({
         items: z.string().optional(),
     }),
 });
-
-export type CaseFieldConfig = z.infer<typeof CaseFieldConfigSchema>;
-
 export const CaseFieldSchema = z.object({
     id: z.number(),
     name: z.string(),
@@ -22,9 +18,9 @@ export const CaseFieldSchema = z.object({
     include_all: z.boolean(),
     configs: z.array(CaseFieldConfigSchema),
 });
-
-export type CaseField = z.infer<typeof CaseFieldSchema>;
-
+export const LabelSchema = z.object({
+    title: z.string(),
+});
 export const CaseSchema = z.object({
     id: z.number(),
     title: z.string(),
@@ -38,11 +34,8 @@ export const CaseSchema = z.object({
     updated_on: z.number(),
     estimate: z.string().nullable(),
     suite_id: z.number(),
-    labels: z.array(z.any()),
+    labels: z.array(LabelSchema),
 }).loose();
-
-export type Case = z.infer<typeof CaseSchema>;
-
 export const SectionSchema = z.object({
     id: z.number(),
     name: z.string(),
@@ -50,42 +43,27 @@ export const SectionSchema = z.object({
     parent_id: z.number().nullish(),
     suite_id: z.number(),
 });
-
-export type Section = z.infer<typeof SectionSchema>;
-
 export const PrioritySchema = z.object({
     id: z.number(),
     is_default: z.boolean(),
     name: z.string(),
 });
-
-export type Priority = z.infer<typeof PrioritySchema>;
-
 export const CaseTypeSchema = z.object({
     id: z.number(),
     is_default: z.boolean(),
     name: z.string(),
 });
-
-export type CaseType = z.infer<typeof CaseTypeSchema>;
-
 export const TemplateSchema = z.object({
     id: z.number(),
     name: z.string(),
     is_default: z.boolean(),
 });
-
-export type Template = z.infer<typeof TemplateSchema>;
-
 export const ProjectSchema = z.object({
     id: z.number(),
     name: z.string(),
     is_completed: z.boolean(),
     suite_mode: z.number(),
 });
-
-export type Project = z.infer<typeof ProjectSchema>;
-
 export const RunSchema = z.object({
     id: z.number(),
     name: z.string(),
@@ -100,29 +78,19 @@ export const RunSchema = z.object({
     failed_count: z.number(),
     url: z.string(),
 });
-
-export type Run = z.infer<typeof RunSchema>;
-
 export const StatusSchema = z.object({
     id: z.number(),
     name: z.string(),
     label: z.string(),
 });
-
-export type Status = z.infer<typeof StatusSchema>;
-
 export const TestSchema = z.object({
     id: z.number(),
     case_id: z.number(),
     status_id: z.number(),
     title: z.string(),
     run_id: z.number(),
-})
-
-export const TestsSchema = z.array(TestSchema)
-
-export type Test = z.infer<typeof TestSchema>
-
+});
+export const TestsSchema = z.array(TestSchema);
 export const ResultSchema = z.object({
     id: z.number(),
     test_id: z.number(),
@@ -130,11 +98,6 @@ export const ResultSchema = z.object({
     comment: z.string().nullable(),
     defects: z.string().nullable(),
 });
-
-export type Result = z.infer<typeof ResultSchema>
-
 export const AttachmentSchema = z.object({
     attachment_id: z.number(),
 });
-
-export type Attachment = z.infer<typeof AttachmentSchema>

package/{src/utils/mapper.ts → dist/utils/mapper.js}

@@ -1,73 +1,55 @@
-import { Case, CaseField } from "../types/testrail.js";
 import { sanitizeValue } from "./sanitizer.js";
-
 /**
  * Processes custom fields from a test case, converting system names to human-readable labels
  * and mapping dropdown values to their display text.
  */
-export function processCustomFields(
-    testCase: Case,
-    caseFields: CaseField[]
-): Record<string, any> {
+export function processCustomFields(testCase, caseFields) {
     if (!testCase) {
         throw new Error("Test case is undefined or null");
     }
-
     const templateId = testCase.template_id;
-    const result: Record<string, any> = {};
-
-    const applicableFields = caseFields.filter(field =>
-        field.include_all || field.template_ids.includes(templateId)
-    );
-
-    const fieldNameMap = new Map<string, string>();
-    const dropdownOptionsMap = new Map<string, Map<string, string>>();
-
+    const result = {};
+    const applicableFields = caseFields.filter(field => field.include_all || field.template_ids.includes(templateId));
+    const fieldNameMap = new Map();
+    const dropdownOptionsMap = new Map();
     for (const field of applicableFields) {
         fieldNameMap.set(field.system_name, toSnakeCase(field.label));
-
         const optionsMap = parseDropdownOptions(field);
         if (optionsMap.size > 0) {
             dropdownOptionsMap.set(field.system_name, optionsMap);
         }
     }
-
     for (const [key, value] of Object.entries(testCase)) {
-        if (!key.startsWith("custom_")) continue;
-        if (value === null || value === undefined) continue;
-
+        if (!key.startsWith("custom_"))
+            continue;
+        if (value === null || value === undefined)
+            continue;
         if (!fieldNameMap.has(key)) {
             console.error(`No field mapping found for: ${key}`);
             result[key] = value;
             continue;
         }
-
-        const outputKey = fieldNameMap.get(key)!;
+        const outputKey = fieldNameMap.get(key);
         let finalValue = value;
-
         if (dropdownOptionsMap.has(key)) {
-            const options = dropdownOptionsMap.get(key)!;
+            const options = dropdownOptionsMap.get(key);
             const optionKey = String(value);
             finalValue = options.get(optionKey) || value;
         }
-
         result[outputKey] = sanitizeValue(finalValue);
     }
-
     return result;
 }
-
 /**
  * Parse dropdown options from field configs.
  * Format: "1, First\n2, Second\n3, Third"
  */
-export function parseDropdownOptions(field: CaseField): Map<string, string> {
-    const options = new Map<string, string>();
-
+export function parseDropdownOptions(field) {
+    const options = new Map();
     for (const config of field.configs) {
         const items = config.options?.items;
-        if (!items) continue;
-
+        if (!items)
+            continue;
         const lines = items.split('\n');
         for (const line of lines) {
             const commaIndex = line.indexOf(',');
@@ -78,11 +60,9 @@ export function parseDropdownOptions(field: CaseField): Map<string, string> {
             }
         }
     }
-
     return options;
 }
-
-function toSnakeCase(str: string): string {
+function toSnakeCase(str) {
     return str
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '_')