@uarlouski/testrail-mcp-server 1.3.0 → 1.3.1

package/test/tools/get_statuses.test.ts

@@ -1,56 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getStatusesTool } from '../../src/tools/get_statuses.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Status } from '../../src/types/testrail.js';
-
-describe('get_statuses tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getStatusesMock: jest.Mock<() => Promise<Status[]>>;
-
-    const mockStatuses: Status[] = [
-        { id: 1, name: 'passed', label: 'Passed' },
-        { id: 2, name: 'blocked', label: 'Blocked' },
-        { id: 3, name: 'untested', label: 'Untested' },
-        { id: 4, name: 'retest', label: 'Retest' },
-        { id: 5, name: 'failed', label: 'Failed' },
-    ];
-
-    beforeEach(() => {
-        getStatusesMock = jest.fn<() => Promise<Status[]>>().mockResolvedValue(mockStatuses);
-
-        mockClient = {
-            getStatuses: getStatusesMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getStatusesTool.name).toBe('get_statuses');
-        expect(getStatusesTool.description).toContain('statuses');
-        expect(getStatusesTool.parameters).toBeDefined();
-    });
-
-    test('handler fetches and returns statuses', async () => {
-        const result = await getStatusesTool.handler({}, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.statuses).toBeDefined();
-        expect(result.statuses).toHaveLength(5);
-        expect(mockClient.getStatuses).toHaveBeenCalled();
-    });
-
-    test('returns correct status structure', async () => {
-        const result = await getStatusesTool.handler({}, mockClient);
-
-        expect(result.statuses[0]).toEqual({
-            id: 1,
-            name: 'passed',
-            label: 'Passed'
-        });
-    });
-
-    test('handler returns error on failure', async () => {
-        getStatusesMock.mockRejectedValue(new Error('API Error'));
-
-        await expect(getStatusesTool.handler({}, mockClient)).rejects.toThrow('API Error');
-    });
-});

package/test/tools/get_templates.test.ts

@@ -1,38 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getTemplatesTool } from '../../src/tools/get_templates.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Template } from '../../src/types/testrail.js';
-
-describe('get_templates tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getTemplatesMock: jest.Mock<(projectId: string) => Promise<Template[]>>;
-
-    const mockTemplates: Template[] = [
-        { id: 1, name: 'Test Case (Text)', is_default: false },
-        { id: 2, name: 'Test Case (Steps)', is_default: true },
-        { id: 3, name: 'Exploratory Session', is_default: false },
-    ];
-
-    beforeEach(() => {
-        getTemplatesMock = jest.fn<(projectId: string) => Promise<Template[]>>().mockResolvedValue(mockTemplates);
-
-        mockClient = {
-            getTemplates: getTemplatesMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getTemplatesTool.name).toBe('get_templates');
-        expect(getTemplatesTool.description).toContain('template');
-        expect(getTemplatesTool.parameters).toBeDefined();
-        expect(getTemplatesTool.parameters.project_id).toBeDefined();
-    });
-
-    test('handler fetches and returns templates', async () => {
-        const result = await getTemplatesTool.handler({ project_id: '1' }, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.templates).toHaveLength(3);
-        expect(mockClient.getTemplates).toHaveBeenCalledWith('1');
-    });
-});

package/test/tools/get_tests.test.ts

@@ -1,47 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getTestsTool } from '../../src/tools/get_tests.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Test } from '../../src/types/testrail.js';
-
-describe('get_tests tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getTestsMock: jest.Mock<(runId: number, statusId?: number[]) => Promise<Test[]>>;
-
-    const mockTests: Test[] = [
-        { id: 1, case_id: 101, status_id: 1, title: 'Test 1', run_id: 1 },
-        { id: 2, case_id: 102, status_id: 2, title: 'Test 2', run_id: 1 },
-    ];
-
-    beforeEach(() => {
-        getTestsMock = jest.fn<(runId: number, statusId?: number[]) => Promise<Test[]>>().mockResolvedValue(mockTests);
-
-        mockClient = {
-            getTests: getTestsMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getTestsTool.name).toBe('get_tests');
-        expect(getTestsTool.description).toBeDefined();
-        expect(getTestsTool.parameters).toBeDefined();
-    });
-
-    test('handler fetches and returns tests', async () => {
-        const result = await getTestsTool.handler({ run_id: 1 }, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.tests).toBeDefined();
-        expect(result.tests).toHaveLength(2);
-        expect(mockClient.getTests).toHaveBeenCalledWith(1, undefined);
-    });
-
-    test('handler passes status_id filter', async () => {
-        const result = await getTestsTool.handler({ run_id: 1, status_id: [1, 5] }, mockClient);
-        expect(mockClient.getTests).toHaveBeenCalledWith(1, [1, 5]);
-    });
-
-    test('handler returns error on failure', async () => {
-        getTestsMock.mockRejectedValue(new Error('API Error'));
-        await expect(getTestsTool.handler({ run_id: 1 }, mockClient)).rejects.toThrow('API Error');
-    });
-});

package/test/tools/update_case.test.ts

@@ -1,102 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { updateCaseTool } from '../../src/tools/update_case.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Case } from '../../src/types/testrail.js';
-
-describe('update_case tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let updateCaseMock: jest.Mock<(caseId: string, fields: Record<string, any>) => Promise<Case>>;
-
-    const mockUpdatedCase: Case = {
-        id: 123,
-        title: 'Updated Title',
-        section_id: 1,
-        template_id: 1,
-        type_id: 1,
-        priority_id: 2,
-        milestone_id: null,
-        refs: null,
-        created_by: 1,
-        created_on: 1700000000,
-        updated_by: 1,
-        updated_on: 1700000001,
-        estimate: null,
-        estimate_forecast: null,
-        suite_id: 1,
-        display_order: 1,
-        is_deleted: 0,
-        labels: [],
-    };
-
-    beforeEach(() => {
-        updateCaseMock = jest.fn<(caseId: string, fields: Record<string, any>) => Promise<Case>>()
-            .mockResolvedValue(mockUpdatedCase);
-
-        mockClient = {
-            updateCase: updateCaseMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(updateCaseTool.name).toBe('update_case');
-        expect(updateCaseTool.description).toContain('Update');
-        expect(updateCaseTool.parameters).toBeDefined();
-        expect(updateCaseTool.parameters.case_id).toBeDefined();
-        expect(updateCaseTool.parameters.fields).toBeDefined();
-    });
-
-    test('handler updates case and returns success response', async () => {
-        const result = await updateCaseTool.handler(
-            { case_id: '123', fields: { title: 'Updated Title' } },
-            mockClient
-        );
-
-        expect(result).toBeDefined();
-        expect(result.success).toBe(true);
-        expect(result.case_id).toBe(123);
-        expect(result.message).toContain('C123');
-        expect(mockClient.updateCase).toHaveBeenCalledWith('123', { title: 'Updated Title' });
-    });
-
-    test('strips C prefix from case_id', async () => {
-        await updateCaseTool.handler(
-            { case_id: 'C456', fields: { title: 'New Title' } },
-            mockClient
-        );
-
-        expect(mockClient.updateCase).toHaveBeenCalledWith('456', { title: 'New Title' });
-    });
-
-    test('handles lowercase c prefix', async () => {
-        await updateCaseTool.handler(
-            { case_id: 'c789', fields: { priority_id: 3 } },
-            mockClient
-        );
-
-        expect(mockClient.updateCase).toHaveBeenCalledWith('789', { priority_id: 3 });
-    });
-
-    test('passes multiple fields correctly', async () => {
-        const fields = {
-            title: 'New Title',
-            priority_id: 2,
-            custom_automation_priority: 1,
-            refs: 'JIRA-123',
-        };
-
-        await updateCaseTool.handler({ case_id: '123', fields }, mockClient);
-
-        expect(mockClient.updateCase).toHaveBeenCalledWith('123', fields);
-    });
-
-    test('handler throws error on failure', async () => {
-        updateCaseMock.mockRejectedValue(new Error('API Error'));
-
-        await expect(
-            updateCaseTool.handler(
-                { case_id: '123', fields: { title: 'Test' } },
-                mockClient
-            )
-        ).rejects.toThrow('API Error');
-    });
-});

package/test/tools/update_cases.test.ts

@@ -1,89 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { updateCasesTool } from '../../src/tools/update_cases.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Case } from '../../src/types/testrail.js';
-
-describe('update_cases tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let updateCasesMock: jest.Mock<(caseIds: number[], fields: Record<string, any>) => Promise<Case[]>>;
-
-    const mockUpdatedCases: Case[] = [
-        {
-            id: 1, title: 'Test Case 1', section_id: 1, template_id: 1, type_id: 1,
-            priority_id: 3, milestone_id: null, refs: null, created_on: 1700000000,
-            updated_by: 1, updated_on: 1700000001, estimate: null,
-            suite_id: 1, labels: []
-        },
-        {
-            id: 2, title: 'Test Case 2', section_id: 1, template_id: 1, type_id: 1,
-            priority_id: 3, milestone_id: null, refs: null, created_on: 1700000000,
-            updated_by: 1, updated_on: 1700000001, estimate: null,
-            suite_id: 1, labels: []
-        },
-        {
-            id: 3, title: 'Test Case 3', section_id: 1, template_id: 1, type_id: 1,
-            priority_id: 3, milestone_id: null, refs: null, created_on: 1700000000,
-            updated_by: 1, updated_on: 1700000001, estimate: null,
-            suite_id: 1, labels: []
-        },
-    ];
-
-    beforeEach(() => {
-        updateCasesMock = jest.fn<(caseIds: number[], fields: Record<string, any>) => Promise<Case[]>>()
-            .mockResolvedValue(mockUpdatedCases);
-
-        mockClient = {
-            updateCases: updateCasesMock,
-            getCase: jest.fn(),
-        } as unknown as jest.Mocked<TestRailClient>;
-
-        // Default mock for getCase to avoid failures in unrelated tests
-        (mockClient.getCase as jest.Mock<any>).mockResolvedValue({ suite_id: 1 });
-    });
-
-    test('exports correct tool definition', () => {
-        expect(updateCasesTool.name).toBe('update_cases');
-        expect(updateCasesTool.description).toContain('Bulk');
-        expect(updateCasesTool.parameters).toBeDefined();
-        expect(updateCasesTool.parameters.case_ids).toBeDefined();
-        expect(updateCasesTool.parameters.fields).toBeDefined();
-    });
-
-    test('handler updates cases and returns success response', async () => {
-        const result = await updateCasesTool.handler(
-            { case_ids: [1, 2, 3], fields: { priority_id: 3 } },
-            mockClient
-        );
-
-        expect(result).toBeDefined();
-        expect(result.success).toBe(true);
-        expect(result.updated_count).toBe(3);
-        expect(result.case_ids).toEqual([1, 2, 3]);
-        expect(result.message).toContain('3 test cases');
-    });
-
-    test('passes case_ids and fields correctly', async () => {
-        const fields = { priority_id: 2, type_id: 1 };
-        const mockCase = { suite_id: 5 } as Case;
-        (mockClient.getCase as jest.Mock<any>).mockResolvedValue(mockCase);
-
-        await updateCasesTool.handler(
-            { case_ids: [10, 20, 30], fields },
-            mockClient
-        );
-
-        expect(mockClient.getCase).toHaveBeenCalledWith('10');
-        expect(mockClient.updateCases).toHaveBeenCalledWith(5, [10, 20, 30], fields);
-    });
-
-    test('handler throws error on failure', async () => {
-        updateCasesMock.mockRejectedValue(new Error('API Error'));
-
-        await expect(
-            updateCasesTool.handler(
-                { case_ids: [1, 2], fields: { priority_id: 2 } },
-                mockClient
-            )
-        ).rejects.toThrow('API Error');
-    });
-});

package/test/utils/mapper.test.ts

@@ -1,112 +0,0 @@
-import { jest, describe, test, expect } from '@jest/globals';
-import { Case, CaseField } from '../../src/types/testrail.js';
-import { processCustomFields } from '../../src/utils/mapper.js';
-
-describe('processCustomFields', () => {
-
-    // Mock CaseField array simulating TestRail API response
-    const mockCaseFields: CaseField[] = [
-        { id: 1, name: 'is_automated', system_name: 'custom_is_automated', label: 'Is Automated', type_id: 1, template_ids: [], include_all: true, is_active: true, description: null, configs: [] },
-        { id: 2, name: 'refs', system_name: 'custom_refs', label: 'Defects', type_id: 1, template_ids: [], include_all: true, is_active: true, description: null, configs: [] },
-        { id: 3, name: 'case_automation_priority', system_name: 'custom_case_automation_priority', label: 'Automation Priority', type_id: 6, template_ids: [], include_all: true, is_active: true, description: null, configs: [{ options: { items: '2, P0\n3, P1\n4, P2\n5, P3\n6, P4' } }] },
-        { id: 4, name: 'preconds', system_name: 'custom_preconds', label: 'Preconditions', type_id: 1, template_ids: [], include_all: true, is_active: true, description: null, configs: [] },
-        { id: 5, name: 'steps', system_name: 'custom_steps', label: 'Steps', type_id: 1, template_ids: [1], include_all: false, is_active: true, description: null, configs: [] },
-        { id: 6, name: 'expected', system_name: 'custom_expected', label: 'Expected', type_id: 1, template_ids: [1], include_all: false, is_active: true, description: null, configs: [] },
-        { id: 7, name: 'steps_separated', system_name: 'custom_steps_separated', label: 'Steps Separated', type_id: 1, template_ids: [2], include_all: false, is_active: true, description: null, configs: [] },
-    ];
-
-    test('maps custom fields using field metadata', () => {
-        const input: Case = {
-            id: 1, title: 'Foo', template_id: 1,
-            section_id: 0, type_id: 0, priority_id: 0,
-            custom_is_automated: true,
-            custom_refs: 'DEF-123',
-            display_order: 1, suite_id: 1, created_on: 1, updated_on: 1,
-            is_deleted: 0, refs: null, labels: [],
-        } as unknown as Case;
-
-        const result = processCustomFields(input, mockCaseFields);
-        expect(result.is_automated).toBe(true);
-        expect(result.defects).toBe('DEF-123');
-    });
-
-    test('maps fields using value mapping from config', () => {
-        const input: Case = {
-            id: 1, title: 'Foo', template_id: 1,
-            section_id: 0, type_id: 0, priority_id: 0,
-            custom_case_automation_priority: 2,
-            display_order: 1, suite_id: 1, created_on: 1, updated_on: 1,
-            is_deleted: 0, refs: null, labels: [],
-        } as unknown as Case;
-
-        const result = processCustomFields(input, mockCaseFields);
-        expect(result.automation_priority).toBe('P0');
-    });
-
-    test('includes only template-specific fields for template 1', () => {
-        const input: Case = {
-            id: 1, title: 'Foo', template_id: 1,
-            custom_steps: 'Step 1...',
-            custom_expected: 'Expectation...',
-            custom_steps_separated: [{ content: 'Should not appear' }], // Template 2 field
-            section_id: 0, type_id: 0, priority_id: 0,
-            display_order: 1, suite_id: 1, created_on: 1, updated_on: 1,
-            is_deleted: 0, refs: null, labels: [],
-        } as unknown as Case;
-
-        const result = processCustomFields(input, mockCaseFields);
-        expect(result.steps).toBe('Step 1...');
-        expect(result.expected).toBe('Expectation...');
-        expect(result.steps_separated).toBeUndefined(); // Not included for template 1
-    });
-
-    test('includes only template-specific fields for template 2', () => {
-        const input: Case = {
-            id: 1, title: 'Foo', template_id: 2,
-            custom_steps: 'Should not appear', // Template 1 field
-            custom_steps_separated: [{ content: 'Step 1' }],
-            section_id: 0, type_id: 0, priority_id: 0,
-            display_order: 1, suite_id: 1, created_on: 1, updated_on: 1,
-            is_deleted: 0, refs: null, labels: [],
-        } as unknown as Case;
-
-        const result = processCustomFields(input, mockCaseFields);
-        expect(result.steps_separated).toEqual([{ content: 'Step 1' }]);
-        expect(result.steps).toBeUndefined(); // Not included for template 2
-    });
-
-    test('keeps unknown fields as-is when no mapping found', () => {
-        const input: Case = {
-            id: 1, title: 'Foo', template_id: 999,
-            custom_unknown_field: 'some value',
-            section_id: 0, type_id: 0, priority_id: 0,
-            display_order: 1, suite_id: 1, created_on: 1, updated_on: 1,
-            is_deleted: 0, refs: null, labels: [],
-        } as unknown as Case;
-
-        const result = processCustomFields(input, mockCaseFields);
-        expect(result.custom_unknown_field).toBe('some value'); // Kept as-is with original key
-    });
-
-    test('throws error when testCase is null', () => {
-        expect(() => processCustomFields(null as any, mockCaseFields)).toThrow('Test case is undefined or null');
-    });
-
-    test('throws error when testCase is undefined', () => {
-        expect(() => processCustomFields(undefined as any, mockCaseFields)).toThrow('Test case is undefined or null');
-    });
-
-    test('returns original value when dropdown option is not found', () => {
-        const input: Case = {
-            id: 1, title: 'Foo', template_id: 1,
-            section_id: 0, type_id: 0, priority_id: 0,
-            custom_case_automation_priority: 999, // Unknown option ID
-            display_order: 1, suite_id: 1, created_on: 1, updated_on: 1,
-            is_deleted: 0, refs: null, labels: [],
-        } as unknown as Case;
-
-        const result = processCustomFields(input, mockCaseFields);
-        expect(result.automation_priority).toBe(999); // Falls back to original value
-    });
-});
-

package/test/utils/sanitizer.test.ts

@@ -1,143 +0,0 @@
-import { describe, test, expect } from '@jest/globals';
-import { sanitizeValue, removeNullish } from '../../src/utils/sanitizer.js';
-
-describe('sanitizeValue', () => {
-    test('strips style attributes from string values', () => {
-        const input = '<p style="color: red; font-size: 14px;">Hello</p>';
-        expect(sanitizeValue(input)).toBe('<p>Hello</p>');
-    });
-
-    test('strips multiple style attributes', () => {
-        const input = '<div style="margin: 10px;"><span style="font-weight: bold;">Text</span></div>';
-        expect(sanitizeValue(input)).toBe('<div><span>Text</span></div>');
-    });
-
-    test('handles single quotes in style', () => {
-        const input = "<p style='color: blue;'>Text</p>";
-        expect(sanitizeValue(input)).toBe('<p>Text</p>');
-    });
-
-    test('preserves other attributes', () => {
-        const input = '<a href="http://example.com" style="color: blue;" class="link">Link</a>';
-        expect(sanitizeValue(input)).toBe('<a href="http://example.com" class="link">Link</a>');
-    });
-
-    test('returns unchanged text without styles', () => {
-        const input = '<p>No styles here</p>';
-        expect(sanitizeValue(input)).toBe('<p>No styles here</p>');
-    });
-    test('sanitizes string values', () => {
-        const input = '<p style="color: red;">Hello</p>';
-        expect(sanitizeValue(input)).toBe('<p>Hello</p>');
-    });
-
-    test('sanitizes nested objects', () => {
-        const input = {
-            content: '<div style="margin: 10px;">Step 1</div>',
-            expected: '<p style="color: green;">Result</p>'
-        };
-        const result = sanitizeValue(input);
-        expect(result.content).toBe('<div>Step 1</div>');
-        expect(result.expected).toBe('<p>Result</p>');
-    });
-
-    test('sanitizes arrays', () => {
-        const input = [
-            { content: '<span style="font-size: 12px;">Item 1</span>' },
-            { content: '<span style="font-size: 14px;">Item 2</span>' }
-        ];
-        const result = sanitizeValue(input);
-        expect(result[0].content).toBe('<span>Item 1</span>');
-        expect(result[1].content).toBe('<span>Item 2</span>');
-    });
-
-    test('preserves non-string values', () => {
-        expect(sanitizeValue(42)).toBe(42);
-        expect(sanitizeValue(true)).toBe(true);
-        expect(sanitizeValue(null)).toBe(null);
-    });
-});
-
-describe('removeNullish', () => {
-    test('removes null values from object', () => {
-        const input = { a: 1, b: null, c: 3 };
-        expect(removeNullish(input)).toEqual({ a: 1, c: 3 });
-    });
-
-    test('removes undefined values from object', () => {
-        const input = { a: 1, b: undefined, c: 3 };
-        expect(removeNullish(input)).toEqual({ a: 1, c: 3 });
-    });
-
-    test('handles nested objects', () => {
-        const input = {
-            name: 'test',
-            metadata: { id: 1, value: null, active: true },
-            count: null
-        };
-        expect(removeNullish(input)).toEqual({
-            name: 'test',
-            metadata: { id: 1, active: true }
-        });
-    });
-
-    test('filters null items from arrays', () => {
-        const input = [1, null, 3, undefined, 5];
-        expect(removeNullish(input)).toEqual([1, 3, 5]);
-    });
-
-    test('cleans nested objects in arrays', () => {
-        const input = [
-            { id: 1, name: 'item1', value: null },
-            { id: 2, name: null, value: 'test' }
-        ];
-        expect(removeNullish(input)).toEqual([
-            { id: 1, name: 'item1' },
-            { id: 2, value: 'test' }
-        ]);
-    });
-
-    test('handles deeply nested structures', () => {
-        const input = {
-            projects: [
-                {
-                    id: 1,
-                    name: 'Project A',
-                    metadata: { created: null, updated: '2024-01-01' },
-                    tags: [null, 'important', undefined, 'urgent']
-                },
-                null
-            ],
-            count: undefined
-        };
-        expect(removeNullish(input)).toEqual({
-            projects: [
-                {
-                    id: 1,
-                    name: 'Project A',
-                    metadata: { updated: '2024-01-01' },
-                    tags: ['important', 'urgent']
-                }
-            ]
-        });
-    });
-
-    test('preserves primitive values', () => {
-        expect(removeNullish(42)).toBe(42);
-        expect(removeNullish('test')).toBe('test');
-        expect(removeNullish(true)).toBe(true);
-        expect(removeNullish(0)).toBe(0);
-        expect(removeNullish('')).toBe('');
-        expect(removeNullish(false)).toBe(false);
-    });
-
-    test('returns null/undefined as-is for root values', () => {
-        expect(removeNullish(null)).toBe(null);
-        expect(removeNullish(undefined)).toBe(undefined);
-    });
-
-    test('handles empty objects and arrays', () => {
-        expect(removeNullish({})).toEqual({});
-        expect(removeNullish([])).toEqual([]);
-    });
-});

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "types": [
-            "node",
-            "jest"
-        ]
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "**/*.test.ts"
-    ]
-}