@dichovsky/testrail-api-client 1.0.0 → 2.1.0

package/dist/modules/reports.js

@@ -0,0 +1,16 @@
+import { ReportSchema, ReportResultSchema } from '../schemas.js';
+export class ReportModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getReports(projectId) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(ReportSchema.array(), await this.client.request('GET', `get_reports/${projectId}`));
+    }
+    async runReport(reportTemplateId) {
+        this.client.validateId(reportTemplateId, 'reportTemplateId');
+        return this.client.parse(ReportResultSchema, await this.client.request('GET', `run_report/${reportTemplateId}`));
+    }
+}
+//# sourceMappingURL=reports.js.map

package/dist/modules/results.d.ts

@@ -0,0 +1,14 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Result, GetResultsOptions } from '../types.js';
+import type { AddResultPayload, AddResultsForCasesPayload } from '../schemas.js';
+export declare class ResultModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getResults(testId: number, options?: GetResultsOptions): Promise<Result[]>;
+    getResultsForCase(runId: number, caseId: number, options?: GetResultsOptions): Promise<Result[]>;
+    getResultsForRun(runId: number, options?: GetResultsOptions): Promise<Result[]>;
+    addResult(testId: number, payload: AddResultPayload): Promise<Result>;
+    addResultForCase(runId: number, caseId: number, payload: AddResultPayload): Promise<Result>;
+    addResultsForCases(runId: number, payload: AddResultsForCasesPayload): Promise<Result[]>;
+}
+//# sourceMappingURL=results.d.ts.map

package/dist/modules/results.js

@@ -0,0 +1,69 @@
+import { ResultSchema } from '../schemas.js';
+import { serializeIdList } from '../utils.js';
+import { z } from 'zod';
+export class ResultModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getResults(testId, options) {
+        this.client.validateId(testId, 'testId');
+        this.client.validatePaginationParams(options?.limit, options?.offset);
+        const endpoint = this.client.buildEndpoint(`get_results/${testId}`, {
+            created_after: options?.created_after,
+            created_before: options?.created_before,
+            created_by: serializeIdList(options?.created_by),
+            status_id: serializeIdList(options?.status_id),
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+        const raw = await this.client.request('GET', endpoint);
+        return (this.client.parse(z.object({ results: z.array(ResultSchema).optional() }), raw)
+            .results ?? []);
+    }
+    async getResultsForCase(runId, caseId, options) {
+        this.client.validateId(runId, 'runId');
+        this.client.validateId(caseId, 'caseId');
+        this.client.validatePaginationParams(options?.limit, options?.offset);
+        const endpoint = this.client.buildEndpoint(`get_results_for_case/${runId}/${caseId}`, {
+            created_after: options?.created_after,
+            created_before: options?.created_before,
+            created_by: serializeIdList(options?.created_by),
+            status_id: serializeIdList(options?.status_id),
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+        const raw = await this.client.request('GET', endpoint);
+        return (this.client.parse(z.object({ results: z.array(ResultSchema).optional() }), raw)
+            .results ?? []);
+    }
+    async getResultsForRun(runId, options) {
+        this.client.validateId(runId, 'runId');
+        this.client.validatePaginationParams(options?.limit, options?.offset);
+        const endpoint = this.client.buildEndpoint(`get_results_for_run/${runId}`, {
+            created_after: options?.created_after,
+            created_before: options?.created_before,
+            created_by: serializeIdList(options?.created_by),
+            status_id: serializeIdList(options?.status_id),
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+        const raw = await this.client.request('GET', endpoint);
+        return (this.client.parse(z.object({ results: z.array(ResultSchema).optional() }), raw)
+            .results ?? []);
+    }
+    async addResult(testId, payload) {
+        this.client.validateId(testId, 'testId');
+        return this.client.parse(ResultSchema, await this.client.request('POST', `add_result/${testId}`, payload));
+    }
+    async addResultForCase(runId, caseId, payload) {
+        this.client.validateId(runId, 'runId');
+        this.client.validateId(caseId, 'caseId');
+        return this.client.parse(ResultSchema, await this.client.request('POST', `add_result_for_case/${runId}/${caseId}`, payload));
+    }
+    async addResultsForCases(runId, payload) {
+        this.client.validateId(runId, 'runId');
+        return this.client.parse(z.array(ResultSchema), await this.client.request('POST', `add_results_for_cases/${runId}`, payload));
+    }
+}
+//# sourceMappingURL=results.js.map

package/dist/modules/runs.d.ts

@@ -0,0 +1,14 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Run, GetRunsOptions } from '../types.js';
+import type { AddRunPayload, UpdateRunPayload } from '../schemas.js';
+export declare class RunModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getRun(runId: number): Promise<Run>;
+    getRuns(projectId: number, options?: GetRunsOptions): Promise<Run[]>;
+    addRun(projectId: number, payload: AddRunPayload): Promise<Run>;
+    updateRun(runId: number, payload: UpdateRunPayload): Promise<Run>;
+    closeRun(runId: number): Promise<Run>;
+    deleteRun(runId: number): Promise<void>;
+}
+//# sourceMappingURL=runs.d.ts.map

package/dist/modules/runs.js

@@ -0,0 +1,57 @@
+import { RunSchema } from '../schemas.js';
+import { z } from 'zod';
+export class RunModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getRun(runId) {
+        this.client.validateId(runId, 'runId');
+        return this.client.parse(RunSchema, await this.client.request('GET', `get_run/${runId}`));
+    }
+    async getRuns(projectId, options) {
+        this.client.validateId(projectId, 'projectId');
+        const { createdAfter, createdBefore, createdBy, isCompleted, milestoneId, refsFilter, suiteId, limit, offset } = options ?? {};
+        this.client.validatePaginationParams(limit, offset);
+        if (milestoneId !== undefined) {
+            this.client.validateId(milestoneId, 'milestoneId');
+        }
+        if (suiteId !== undefined) {
+            this.client.validateId(suiteId, 'suiteId');
+        }
+        if (createdBy !== undefined) {
+            createdBy.forEach((userId) => this.client.validateId(userId, 'createdBy'));
+        }
+        const createdByFilter = createdBy && createdBy.length > 0 ? createdBy.join(',') : undefined;
+        const endpoint = this.client.buildEndpoint(`get_runs/${projectId}`, {
+            created_after: createdAfter,
+            created_before: createdBefore,
+            created_by: createdByFilter,
+            is_completed: isCompleted !== undefined ? (isCompleted ? 1 : 0) : undefined,
+            milestone_id: milestoneId,
+            refs_filter: refsFilter,
+            suite_id: suiteId,
+            limit,
+            offset,
+        });
+        const raw = await this.client.request('GET', endpoint);
+        return this.client.parse(z.object({ runs: z.array(RunSchema).optional() }), raw).runs ?? [];
+    }
+    async addRun(projectId, payload) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(RunSchema, await this.client.request('POST', `add_run/${projectId}`, payload));
+    }
+    async updateRun(runId, payload) {
+        this.client.validateId(runId, 'runId');
+        return this.client.parse(RunSchema, await this.client.request('POST', `update_run/${runId}`, payload));
+    }
+    async closeRun(runId) {
+        this.client.validateId(runId, 'runId');
+        return this.client.parse(RunSchema, await this.client.request('POST', `close_run/${runId}`));
+    }
+    async deleteRun(runId) {
+        this.client.validateId(runId, 'runId');
+        await this.client.request('POST', `delete_run/${runId}`);
+    }
+}
+//# sourceMappingURL=runs.js.map

package/dist/modules/sections.d.ts

@@ -0,0 +1,16 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Section, AddSectionPayload, UpdateSectionPayload } from '../types.js';
+export declare class SectionModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getSection(sectionId: number): Promise<Section>;
+    getSections(projectId: number, options?: {
+        suiteId?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<Section[]>;
+    addSection(projectId: number, payload: AddSectionPayload): Promise<Section>;
+    updateSection(sectionId: number, payload: UpdateSectionPayload): Promise<Section>;
+    deleteSection(sectionId: number): Promise<void>;
+}
+//# sourceMappingURL=sections.d.ts.map

package/dist/modules/sections.js

@@ -0,0 +1,37 @@
+import { SectionSchema } from '../schemas.js';
+import { z } from 'zod';
+export class SectionModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getSection(sectionId) {
+        this.client.validateId(sectionId, 'sectionId');
+        return this.client.parse(SectionSchema, await this.client.request('GET', `get_section/${sectionId}`));
+    }
+    async getSections(projectId, options) {
+        this.client.validateId(projectId, 'projectId');
+        const { suiteId, limit, offset } = options ?? {};
+        if (suiteId !== undefined) {
+            this.client.validateId(suiteId, 'suiteId');
+        }
+        this.client.validatePaginationParams(limit, offset);
+        const endpoint = this.client.buildEndpoint(`get_sections/${projectId}`, { suite_id: suiteId, limit, offset });
+        const raw = await this.client.request('GET', endpoint);
+        return (this.client.parse(z.object({ sections: z.array(SectionSchema).optional() }), raw)
+            .sections ?? []);
+    }
+    async addSection(projectId, payload) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(SectionSchema, await this.client.request('POST', `add_section/${projectId}`, payload));
+    }
+    async updateSection(sectionId, payload) {
+        this.client.validateId(sectionId, 'sectionId');
+        return this.client.parse(SectionSchema, await this.client.request('POST', `update_section/${sectionId}`, payload));
+    }
+    async deleteSection(sectionId) {
+        this.client.validateId(sectionId, 'sectionId');
+        await this.client.request('POST', `delete_section/${sectionId}`);
+    }
+}
+//# sourceMappingURL=sections.js.map

package/dist/modules/sharedSteps.d.ts

@@ -0,0 +1,12 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { SharedStep, AddSharedStepPayload, UpdateSharedStepPayload } from '../types.js';
+export declare class SharedStepModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getSharedStep(sharedStepId: number): Promise<SharedStep>;
+    getSharedSteps(projectId: number): Promise<SharedStep[]>;
+    addSharedStep(projectId: number, payload: AddSharedStepPayload): Promise<SharedStep>;
+    updateSharedStep(sharedStepId: number, payload: UpdateSharedStepPayload): Promise<SharedStep>;
+    deleteSharedStep(sharedStepId: number): Promise<void>;
+}
+//# sourceMappingURL=sharedSteps.d.ts.map

package/dist/modules/sharedSteps.js

@@ -0,0 +1,28 @@
+import { SharedStepSchema } from '../schemas.js';
+export class SharedStepModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getSharedStep(sharedStepId) {
+        this.client.validateId(sharedStepId, 'sharedStepId');
+        return this.client.parse(SharedStepSchema, await this.client.request('GET', `get_shared_step/${sharedStepId}`));
+    }
+    async getSharedSteps(projectId) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(SharedStepSchema.array(), await this.client.request('GET', `get_shared_steps/${projectId}`));
+    }
+    async addSharedStep(projectId, payload) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(SharedStepSchema, await this.client.request('POST', `add_shared_step/${projectId}`, payload));
+    }
+    async updateSharedStep(sharedStepId, payload) {
+        this.client.validateId(sharedStepId, 'sharedStepId');
+        return this.client.parse(SharedStepSchema, await this.client.request('POST', `update_shared_step/${sharedStepId}`, payload));
+    }
+    async deleteSharedStep(sharedStepId) {
+        this.client.validateId(sharedStepId, 'sharedStepId');
+        await this.client.request('POST', `delete_shared_step/${sharedStepId}`);
+    }
+}
+//# sourceMappingURL=sharedSteps.js.map

package/dist/modules/suites.d.ts

@@ -0,0 +1,37 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Suite, AddSuitePayload, UpdateSuitePayload } from '../types.js';
+export declare class SuiteModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    /**
+     * Get a suite by ID.
+     * @throws {TestRailValidationError} When suiteId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    getSuite(suiteId: number): Promise<Suite>;
+    /**
+     * Get all suites for a project.
+     * @throws {TestRailValidationError} When projectId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    getSuites(projectId: number): Promise<Suite[]>;
+    /**
+     * Add a suite to a project.
+     * @throws {TestRailValidationError} When projectId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    addSuite(projectId: number, payload: AddSuitePayload): Promise<Suite>;
+    /**
+     * Update a suite.
+     * @throws {TestRailValidationError} When suiteId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    updateSuite(suiteId: number, payload: UpdateSuitePayload): Promise<Suite>;
+    /**
+     * Delete a suite.
+     * @throws {TestRailValidationError} When suiteId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    deleteSuite(suiteId: number): Promise<void>;
+}
+//# sourceMappingURL=suites.d.ts.map

package/dist/modules/suites.js

@@ -0,0 +1,54 @@
+import { SuiteSchema } from '../schemas.js';
+import { z } from 'zod';
+export class SuiteModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a suite by ID.
+     * @throws {TestRailValidationError} When suiteId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    async getSuite(suiteId) {
+        this.client.validateId(suiteId, 'suiteId');
+        return this.client.parse(SuiteSchema, await this.client.request('GET', `get_suite/${suiteId}`));
+    }
+    /**
+     * Get all suites for a project.
+     * @throws {TestRailValidationError} When projectId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    async getSuites(projectId) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(z.array(SuiteSchema), await this.client.request('GET', `get_suites/${projectId}`));
+    }
+    /**
+     * Add a suite to a project.
+     * @throws {TestRailValidationError} When projectId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    async addSuite(projectId, payload) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(SuiteSchema, await this.client.request('POST', `add_suite/${projectId}`, payload));
+    }
+    /**
+     * Update a suite.
+     * @throws {TestRailValidationError} When suiteId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    async updateSuite(suiteId, payload) {
+        this.client.validateId(suiteId, 'suiteId');
+        return this.client.parse(SuiteSchema, await this.client.request('POST', `update_suite/${suiteId}`, payload));
+    }
+    /**
+     * Delete a suite.
+     * @throws {TestRailValidationError} When suiteId is invalid
+     * @throws {TestRailApiError} When the API request fails
+     */
+    async deleteSuite(suiteId) {
+        this.client.validateId(suiteId, 'suiteId');
+        await this.client.request('POST', `delete_suite/${suiteId}`);
+    }
+}
+//# sourceMappingURL=suites.js.map

package/dist/modules/tests.d.ts

@@ -0,0 +1,9 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Test, GetTestsOptions } from '../types.js';
+export declare class TestModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getTest(testId: number): Promise<Test>;
+    getTests(runId: number, options?: GetTestsOptions): Promise<Test[]>;
+}
+//# sourceMappingURL=tests.d.ts.map

package/dist/modules/tests.js

@@ -0,0 +1,25 @@
+import { TestSchema } from '../schemas.js';
+import { serializeIdList } from '../utils.js';
+import { z } from 'zod';
+export class TestModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getTest(testId) {
+        this.client.validateId(testId, 'testId');
+        return this.client.parse(TestSchema, await this.client.request('GET', `get_test/${testId}`));
+    }
+    async getTests(runId, options) {
+        this.client.validateId(runId, 'runId');
+        this.client.validatePaginationParams(options?.limit, options?.offset);
+        const endpoint = this.client.buildEndpoint(`get_tests/${runId}`, {
+            status_id: serializeIdList(options?.status_id),
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+        const raw = await this.client.request('GET', endpoint);
+        return (this.client.parse(z.object({ tests: z.array(TestSchema).optional() }), raw).tests ?? []);
+    }
+}
+//# sourceMappingURL=tests.js.map

package/dist/modules/users.d.ts

@@ -0,0 +1,18 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { AddGroupPayload, AddUserPayload, Group, UpdateGroupPayload, UpdateUserPayload, User } from '../types.js';
+export declare class UsersModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getUser(userId: number): Promise<User>;
+    getUserByEmail(email: string): Promise<User>;
+    getUsers(limit?: number, offset?: number, projectId?: number): Promise<User[]>;
+    getCurrentUser(): Promise<User>;
+    addUser(payload: AddUserPayload): Promise<User>;
+    updateUser(userId: number, payload: UpdateUserPayload): Promise<User>;
+    getGroup(groupId: number): Promise<Group>;
+    getGroups(): Promise<Group[]>;
+    addGroup(payload: AddGroupPayload): Promise<Group>;
+    updateGroup(groupId: number, payload: UpdateGroupPayload): Promise<Group>;
+    deleteGroup(groupId: number): Promise<void>;
+}
+//# sourceMappingURL=users.d.ts.map

package/dist/modules/users.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { TestRailValidationError } from '../errors.js';
+import { UserSchema, GroupSchema } from '../schemas.js';
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export class UsersModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getUser(userId) {
+        this.client.validateId(userId, 'userId');
+        return this.client.parse(UserSchema, await this.client.request('GET', `get_user/${userId}`));
+    }
+    async getUserByEmail(email) {
+        if (!EMAIL_REGEX.test(email)) {
+            throw new TestRailValidationError('Invalid email format');
+        }
+        const endpoint = this.client.buildEndpoint('get_user_by_email', { email });
+        return this.client.parse(UserSchema, await this.client.request('GET', endpoint));
+    }
+    async getUsers(limit, offset, projectId) {
+        this.client.validatePaginationParams(limit, offset);
+        if (projectId !== undefined) {
+            this.client.validateId(projectId, 'projectId');
+        }
+        const endpoint = this.client.buildEndpoint(projectId !== undefined ? `get_users/${projectId}` : 'get_users', {
+            limit,
+            offset,
+        });
+        const raw = await this.client.request('GET', endpoint);
+        return (this.client.parse(z.object({ users: z.array(UserSchema).optional() }), raw).users ?? []);
+    }
+    async getCurrentUser() {
+        return this.client.parse(UserSchema, await this.client.request('GET', 'get_current_user'));
+    }
+    async addUser(payload) {
+        return this.client.parse(UserSchema, await this.client.request('POST', 'add_user', payload));
+    }
+    async updateUser(userId, payload) {
+        this.client.validateId(userId, 'userId');
+        return this.client.parse(UserSchema, await this.client.request('POST', `update_user/${userId}`, payload));
+    }
+    async getGroup(groupId) {
+        this.client.validateId(groupId, 'groupId');
+        return this.client.parse(GroupSchema, await this.client.request('GET', `get_group/${groupId}`));
+    }
+    async getGroups() {
+        return this.client.parse(z.array(GroupSchema), await this.client.request('GET', 'get_groups'));
+    }
+    async addGroup(payload) {
+        return this.client.parse(GroupSchema, await this.client.request('POST', 'add_group', payload));
+    }
+    async updateGroup(groupId, payload) {
+        this.client.validateId(groupId, 'groupId');
+        return this.client.parse(GroupSchema, await this.client.request('POST', `update_group/${groupId}`, payload));
+    }
+    async deleteGroup(groupId) {
+        this.client.validateId(groupId, 'groupId');
+        await this.client.request('POST', `delete_group/${groupId}`);
+    }
+}
+//# sourceMappingURL=users.js.map

package/dist/modules/variables.d.ts

@@ -0,0 +1,11 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Variable, AddVariablePayload, UpdateVariablePayload } from '../types.js';
+export declare class VariableModule {
+    private readonly client;
+    constructor(client: TestRailClientCore);
+    getVariables(projectId: number): Promise<Variable[]>;
+    addVariable(projectId: number, payload: AddVariablePayload): Promise<Variable>;
+    updateVariable(variableId: number, payload: UpdateVariablePayload): Promise<Variable>;
+    deleteVariable(variableId: number): Promise<void>;
+}
+//# sourceMappingURL=variables.d.ts.map

package/dist/modules/variables.js

@@ -0,0 +1,24 @@
+import { VariableSchema } from '../schemas.js';
+export class VariableModule {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getVariables(projectId) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(VariableSchema.array(), await this.client.request('GET', `get_variables/${projectId}`));
+    }
+    async addVariable(projectId, payload) {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse(VariableSchema, await this.client.request('POST', `add_variable/${projectId}`, payload));
+    }
+    async updateVariable(variableId, payload) {
+        this.client.validateId(variableId, 'variableId');
+        return this.client.parse(VariableSchema, await this.client.request('POST', `update_variable/${variableId}`, payload));
+    }
+    async deleteVariable(variableId) {
+        this.client.validateId(variableId, 'variableId');
+        await this.client.request('POST', `delete_variable/${variableId}`);
+    }
+}
+//# sourceMappingURL=variables.js.map