@uarlouski/testrail-mcp-server 1.1.0 → 1.2.0

package/src/tools/update_case.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.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')"),
@@ -11,22 +11,15 @@ export const updateCaseTool: ToolDefinition<typeof parameters, TestRailClient> =
     name: "update_case",
     description: "Update a test case in TestRail. Supports partial updates - only specify the fields you want to change. Use get_case_fields to see available fields and their types.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ case_id, fields }, client) => {
+    handler: async ({ case_id, fields }, client) => {
         const id = case_id.toUpperCase().startsWith("C") ? case_id.substring(1) : case_id;
 
         const updatedCase = await client.updateCase(id, fields);
 
         return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify({
-                        success: true,
-                        case_id: updatedCase.id,
-                        message: `Test case C${updatedCase.id} updated successfully`,
-                    }, null, 2),
-                },
-            ],
+            success: true,
+            case_id: updatedCase.id,
+            message: `Test case C${updatedCase.id} updated successfully`,
         };
-    })
+    }
 };

package/src/tools/update_cases.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.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])"),
@@ -11,21 +11,14 @@ export const updateCasesTool: ToolDefinition<typeof parameters, TestRailClient>
     name: "update_cases",
     description: "Bulk update multiple test cases with the same field values. More efficient than calling update_case multiple times. All cases will receive the same field values.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ case_ids, fields }, client) => {
+    handler: async ({ case_ids, fields }, client) => {
         const updatedCases = await client.updateCases(case_ids, fields);
 
         return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify({
-                        success: true,
-                        updated_count: updatedCases.length,
-                        case_ids: updatedCases.map(c => c.id),
-                        message: `Successfully updated ${updatedCases.length} test cases`,
-                    }, null, 2),
-                },
-            ],
+            success: true,
+            updated_count: updatedCases.length,
+            case_ids: updatedCases.map(c => c.id),
+            message: `Successfully updated ${updatedCases.length} test cases`,
         };
-    })
+    }
 };

package/src/types/custom.ts

@@ -15,20 +15,5 @@ export interface ToolDefinition<T extends z.ZodRawShape, Context = any> {
     name: string;
     description: string;
     parameters: T;
-    handler: (args: z.infer<z.ZodObject<T>>, context: Context) => Promise<any>;
-}
-
-export function withErrorHandling<T extends z.ZodRawShape, Context = any>(
-    handler: (args: z.infer<z.ZodObject<T>>, context: Context) => Promise<any>
-): (args: z.infer<z.ZodObject<T>>, context: Context) => Promise<any> {
-    return async (args, context) => {
-        try {
-            return await handler(args, context);
-        } catch (error: any) {
-            return {
-                content: [{ type: "text", text: `Error: ${error.message}` }],
-                isError: true,
-            };
-        }
-    };
+    handler: (args: z.infer<z.ZodObject<T>>, context: Context) => Promise<Record<string, any>>;
 }

package/src/types/testrail.ts

@@ -1,87 +1,87 @@
-export interface Case {
-    id: number;
-    title: string;
-    section_id: number;
-    template_id: number;
-    type_id: number;
-    priority_id: number;
-    milestone_id: number | null;
-    refs: string | null;
-    created_by: number;
-    created_on: number;
-    updated_by: number;
-    updated_on: number;
-    estimate: string | null;
-    estimate_forecast: string | null;
-    suite_id: number;
-    display_order: number;
-    is_deleted: number;
-    labels: any[];
-    [key: string]: any;
-}
-
-export interface Section {
-    id: number;
-    name: string;
-    description: string | null;
-    parent_id: number | null;
-    depth: number;
-    display_order: number;
-    suite_id: number;
-}
-
-export interface Priority {
-    id: number;
-    is_default: boolean;
-    name: string;
-    priority: number;
-    short_name: string;
-}
-
-export interface CaseType {
-    id: number;
-    is_default: boolean;
-    name: string;
-}
-
-export interface CaseField {
-    id: number;
-    name: string;
-    system_name: string;
-    label: string;
-    type_id: number;
-    template_ids: number[];
-    is_active: boolean;
-    display_order: number;
-    description: string | null;
-    include_all: boolean;
-    configs: CaseFieldConfig[];
-}
-
-export interface CaseFieldConfig {
-    context: {
-        is_global: boolean;
-        project_ids: number[] | null;
-    };
-    options: {
-        default_value?: string;
-        format?: string;
-        is_required?: boolean;
-        rows?: string;
-        items?: string;
-    };
-}
-
-export interface Template {
-    id: number;
-    name: string;
-    is_default: boolean;
-}
-
-export interface Project {
-    id: number;
-    name: string;
-    announcement: string | null;
-    is_completed: boolean;
-    suite_mode: number;
-}
+import { z } from "zod";
+
+export const CaseFieldConfigSchema = z.object({
+    options: z.object({
+        default_value: z.string().optional(),
+        is_required: z.boolean().optional(),
+        items: z.string().optional(),
+    }),
+});
+
+export type CaseFieldConfig = z.infer<typeof CaseFieldConfigSchema>;
+
+export const CaseFieldSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    system_name: z.string(),
+    label: z.string(),
+    type_id: z.number(),
+    template_ids: z.array(z.number()),
+    is_active: z.boolean(),
+    description: z.string().nullable(),
+    include_all: z.boolean(),
+    configs: z.array(CaseFieldConfigSchema),
+});
+
+export type CaseField = z.infer<typeof CaseFieldSchema>;
+
+export const CaseSchema = z.object({
+    id: z.number(),
+    title: z.string(),
+    section_id: z.number(),
+    template_id: z.number(),
+    type_id: z.number(),
+    priority_id: z.number(),
+    milestone_id: z.number().nullable(),
+    refs: z.string().nullable(),
+    created_on: z.number(),
+    updated_on: z.number(),
+    estimate: z.string().nullable(),
+    suite_id: z.number(),
+    labels: z.array(z.any()),
+}).loose();
+
+export type Case = z.infer<typeof CaseSchema>;
+
+export const SectionSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    description: z.string().nullish(),
+    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>;

package/src/utils/sanitizer.ts

@@ -19,3 +19,32 @@ export function sanitizeValue(value: any): any {
     }
     return value;
 }
+
+/**
+ * Recursively removes null and undefined values from objects and arrays.
+ * For arrays, filters nested object items as well.
+ */
+export function removeNullish(value: any): any {
+    if (value == null) {
+        return value;
+    }
+
+    if (Array.isArray(value)) {
+        return value
+            .map(item => removeNullish(item))
+            .filter(item => item != null);
+    }
+
+    if (typeof value === 'object') {
+        const result: Record<string, any> = {};
+        for (const [key, val] of Object.entries(value)) {
+            const cleanedVal = removeNullish(val);
+            if (cleanedVal != null) {
+                result[key] = cleanedVal;
+            }
+        }
+        return result;
+    }
+
+    return value;
+}