@uarlouski/testrail-mcp-server 1.11.0 → 2.1.0

package/dist/tools/projects/query_project.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { ProjectSchema, GetOneProjectSchema, GetManyProjectsSchema } from "./types.js";
+import { handleQuery } from "../../utils/query_handler.js";
+const parameters = {
+    payload: z.discriminatedUnion("action", [
+        GetOneProjectSchema,
+        GetManyProjectsSchema,
+    ]).describe("The payload containing the action ('one' or 'many') and corresponding parameters"),
+};
+export const queryProjectTool = {
+    name: "query_project",
+    mode: "read",
+    description: "Retrieve a single project or all projects in TestRail. Set payload.action to 'one' or 'many' to specify the operation.",
+    parameters,
+    handler: async (args, client) => {
+        return handleQuery(args.payload, async (p) => {
+            const project = await client.getProject(p.project_id);
+            return {
+                project: ProjectSchema.parse(project),
+            };
+        }, async (p) => {
+            const projects = await client.getProjects();
+            const filteredProjects = projects.filter(prj => !prj.is_completed);
+            return {
+                projects: filteredProjects.map(prj => ProjectSchema.parse(prj)),
+            };
+        });
+    }
+};

package/dist/tools/projects/types.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const ProjectSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    is_completed: z.boolean(),
+    suite_mode: z.number(),
+});
+export const GetOneProjectSchema = z.object({
+    action: z.literal("one").describe("Retrieve a single project by ID"),
+    project_id: z.number().int().describe("The ID of the project"),
+});
+export const GetManyProjectsSchema = z.object({
+    action: z.literal("many").describe("Retrieve all available projects"),
+});

package/dist/tools/registry.js

@@ -0,0 +1,46 @@
+import { casesTools } from "./cases/index.js";
+import { projectsTools } from "./projects/index.js";
+import { suitesTools } from "./suites/index.js";
+import { sectionsTools } from "./sections/index.js";
+import { runsTools } from "./runs/index.js";
+import { sharedStepsTools } from "./shared_steps/index.js";
+import { resultsTools } from "./results/index.js";
+import { commonsTools } from "./commons/index.js";
+export function getToolsToRegister(config) {
+    const tools = [
+        ...projectsTools,
+        ...suitesTools,
+        ...casesTools,
+        ...sectionsTools,
+        ...runsTools,
+        ...resultsTools,
+        ...commonsTools,
+    ];
+    if (config.enableSharedSteps) {
+        tools.push(...sharedStepsTools);
+    }
+    const allowWrite = config.allowWrite !== false;
+    const allowRead = config.allowRead !== false;
+    const allowDelete = config.allowDelete === true;
+    const filteredTools = tools.filter(tool => {
+        if (tool.mode === 'write')
+            return allowWrite;
+        if (tool.mode === 'read')
+            return allowRead;
+        return allowDelete;
+    });
+    return filteredTools.map(tool => {
+        const defaultAnnotations = {
+            readOnlyHint: tool.mode === 'read',
+            destructiveHint: tool.mode === 'delete',
+            idempotentHint: tool.mode === 'read',
+        };
+        return {
+            ...tool,
+            annotations: {
+                ...defaultAnnotations,
+                ...tool.annotations,
+            }
+        };
+    });
+}

package/dist/tools/{add_results.js → results/add_results.js}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ResultSchema } from "../types/testrail.js";
+import { ResultSchema } from "./types.js";
 const parameters = {
     run_id: z.number().describe("The ID of the test run"),
     results: z.array(z.object({
@@ -11,6 +11,7 @@ const parameters = {
 };
 export const addResultsTool = {
     name: "add_results",
+    mode: "write",
     description: "Add one or more test results to a test run",
     parameters,
     handler: async ({ run_id, results }, client) => {

package/dist/tools/{add_results_for_cases.js → results/add_results_for_cases.js}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ResultSchema } from "../types/testrail.js";
+import { ResultSchema } from "./types.js";
 const parameters = {
     run_id: z.number().describe("The ID of the test run"),
     results: z.array(z.object({
@@ -11,6 +11,7 @@ const parameters = {
 };
 export const addResultsForCasesTool = {
     name: "add_results_for_cases",
+    mode: "write",
     description: "Add one or more test results to a test run using case IDs instead of test IDs",
     parameters,
     handler: async ({ run_id, results }, client) => {

package/dist/tools/results/get_results.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { ResultSchema } from "./types.js";
+const parameters = {
+    test_id: z.number().int().describe("The ID of the test"),
+};
+export const getResultsTool = {
+    name: "get_results",
+    mode: "read",
+    description: "Get results for a specific test in TestRail.",
+    parameters,
+    handler: async (args, client) => {
+        const { test_id } = args;
+        const results = await client.getResults(test_id);
+        return {
+            results: results.map(r => ResultSchema.parse(r)),
+        };
+    }
+};

package/dist/tools/results/index.js

@@ -0,0 +1,8 @@
+import { addResultsTool } from "./add_results.js";
+import { addResultsForCasesTool } from "./add_results_for_cases.js";
+import { getResultsTool } from "./get_results.js";
+export const resultsTools = [
+    addResultsTool,
+    addResultsForCasesTool,
+    getResultsTool,
+];

package/dist/tools/results/types.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const ResultSchema = z.object({
+    id: z.number(),
+    test_id: z.number(),
+    status_id: z.number(),
+    comment: z.string().nullable(),
+    defects: z.string().nullable(),
+});

package/dist/tools/{add_attachment_to_run.js → runs/add_attachment_to_run.js}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { AttachmentSchema } from "../types/testrail.js";
+import { AttachmentSchema } from "./types.js";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -10,6 +10,7 @@ const parameters = {
 };
 export const addAttachmentToRunTool = {
     name: "add_attachment_to_run",
+    mode: "write",
     description: "Add an attachment to a test run in TestRail. If the file_path points to a directory, it will be automatically zipped before uploading. Maximum upload size is 256MB.",
     parameters,
     handler: async ({ run_id, file_path }, client) => {

package/dist/tools/runs/index.js

@@ -0,0 +1,8 @@
+import { mutateRunTool } from "./mutate_run.js";
+import { queryRunTool } from "./query_run.js";
+import { addAttachmentToRunTool } from "./add_attachment_to_run.js";
+export const runsTools = [
+    mutateRunTool,
+    queryRunTool,
+    addAttachmentToRunTool,
+];

package/dist/tools/runs/mutate_run.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { RunSchema, CreateRunSchema, UpdateRunSchema } from "./types.js";
+import { handleMutate } from "../../utils/mutate_handler.js";
+const parameters = {
+    payload: z.discriminatedUnion("action", [
+        CreateRunSchema,
+        UpdateRunSchema,
+    ]).describe("The mutation payload containing the action (create or update) and the corresponding run attributes"),
+};
+export const mutateRunTool = {
+    name: "mutate_run",
+    mode: "write",
+    description: "Create a new test run or update an existing one in TestRail. Set payload.action to 'create' or 'update' to specify the operation.",
+    parameters,
+    handler: async (args, client) => {
+        const { payload } = args;
+        return handleMutate(payload, async (createPayload) => {
+            const { project_id, action, ...data } = createPayload;
+            const params = { ...data };
+            if (!params.suite_id && params.case_ids && params.case_ids.length > 0) {
+                // Determine suite_id automatically from the first case
+                const caseData = await client.getCase(params.case_ids[0]);
+                params.suite_id = caseData.suite_id;
+                params.include_all = false;
+            }
+            else if (params.suite_id) {
+                // suite_id provided
+                params.include_all = !params.case_ids || params.case_ids.length === 0;
+            }
+            else {
+                // Neither suite_id nor case_ids provided (e.g. single-suite project)
+                params.include_all = true;
+            }
+            return client.addRun(project_id, params);
+        }, async (updatePayload) => {
+            const { run_id, action, ...data } = updatePayload;
+            return client.updateRun(run_id, data);
+        }, RunSchema);
+    }
+};

package/dist/tools/runs/query_run.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { RunSchema, GetOneRunSchema, GetManyRunsSchema } from "./types.js";
+import { handleQuery } from "../../utils/query_handler.js";
+const parameters = {
+    payload: z.discriminatedUnion("action", [
+        GetOneRunSchema,
+        GetManyRunsSchema,
+    ]).describe("The payload containing the action ('one' or 'many') and corresponding parameters"),
+};
+export const queryRunTool = {
+    name: "query_run",
+    mode: "read",
+    description: "Retrieve a single test run or all test runs for a project in TestRail. Set payload.action to 'one' or 'many' to specify the operation.",
+    parameters,
+    handler: async (args, client) => {
+        return handleQuery(args.payload, async (p) => {
+            const run = await client.getRun(p.run_id);
+            return {
+                run: RunSchema.parse(run),
+            };
+        }, async (p) => {
+            const { project_id, action, ...filters } = p;
+            const cleanFilters = {};
+            for (const [key, value] of Object.entries(filters)) {
+                if (value !== undefined && value !== null) {
+                    cleanFilters[key] = value.toString();
+                }
+            }
+            const runs = await client.getRuns(project_id, cleanFilters);
+            return {
+                runs: runs.map(r => RunSchema.parse(r)),
+            };
+        });
+    }
+};

package/dist/tools/runs/types.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export const RunSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    description: z.string().nullable(),
+    suite_id: z.number().nullable(),
+    project_id: z.number(),
+    is_completed: z.boolean(),
+    passed_count: z.number(),
+    blocked_count: z.number(),
+    untested_count: z.number(),
+    retest_count: z.number(),
+    failed_count: z.number(),
+    url: z.string(),
+});
+export const BaseRunFields = z.object({
+    name: z.string().optional().describe("The name of the test run"),
+    description: z.string().optional().describe("The description of the test run"),
+    case_ids: z.array(z.number()).optional().describe("An array of case IDs for the custom case selection"),
+});
+export const CreateRunSchema = BaseRunFields.extend({
+    action: z.literal("create").describe("The operation to perform: create a new test run"),
+    project_id: z.number().describe("The ID of the project the test run should be added to"),
+    suite_id: z.number().optional().describe("The ID of the test suite for the test run"),
+    case_ids: z.array(z.number()).optional().describe("Array of case IDs to include in the run. If provided, the run will only include these cases; otherwise, all cases will be included."),
+});
+export const UpdateRunSchema = BaseRunFields.extend({
+    action: z.literal("update").describe("The operation to perform: update an existing test run"),
+    run_id: z.number().describe("The ID of the test run to update"),
+});
+export const GetOneRunSchema = z.object({
+    action: z.literal("one").describe("Retrieve a single test run by ID"),
+    run_id: z.number().int().describe("The ID of the test run"),
+});
+export const GetManyRunsSchema = z.object({
+    action: z.literal("many").describe("Retrieve all test runs for a project"),
+    project_id: z.number().int().describe("The ID of the project"),
+    suite_id: z.number().int().optional().describe("Filter by suite ID"),
+    is_completed: z.number().int().min(0).max(1).optional().describe("Filter by completion status (1 for completed, 0 for active)"),
+});
+export const AttachmentSchema = z.object({
+    attachment_id: z.number(),
+});

package/dist/tools/{get_sections.js → sections/get_sections.js}

@@ -1,16 +1,20 @@
 import { z } from "zod";
 import fs from "fs";
-import { SectionSchema } from "../types/testrail.js";
+import { SectionSchema } from "./types.js";
+import { validateSuiteId } from "../../utils/validator.js";
 const parameters = {
     project_id: z.number().describe("The ID of the project. Use get_projects to find available projects"),
+    suite_id: z.number().optional().describe("The ID of the test suite (required for multi-suite projects, i.e. suite_mode=3). Use get_suites to find available suites"),
     output_file: z.string().optional().describe("Absolute file path to save the JSON response to. Use this for large datasets to avoid blowing up context limits."),
 };
 export const getSectionsTool = {
     name: "get_sections",
+    mode: "read",
     description: "Get all sections for a project. Returns section IDs and names that can be used with add_case",
     parameters,
-    handler: async ({ project_id, output_file }, client) => {
-        const sections = await client.getSections(project_id);
+    handler: async ({ project_id, suite_id, output_file }, client) => {
+        await validateSuiteId(client, project_id, suite_id);
+        const sections = await client.getSections(project_id, suite_id);
         const response = {
             sections: sections.map(s => SectionSchema.parse(s)),
         };

package/dist/tools/sections/index.js

@@ -0,0 +1,6 @@
+import { getSectionsTool } from "./get_sections.js";
+import { mutateSectionTool } from "./mutate_section.js";
+export const sectionsTools = [
+    getSectionsTool,
+    mutateSectionTool,
+];

package/dist/tools/sections/mutate_section.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { SectionSchema, CreateSectionSchema, UpdateSectionSchema } from "./types.js";
+import { handleMutate } from "../../utils/mutate_handler.js";
+const parameters = {
+    payload: z.discriminatedUnion("action", [
+        CreateSectionSchema,
+        UpdateSectionSchema,
+    ]).describe("The mutation payload containing the action (create or update) and the corresponding section attributes"),
+};
+export const mutateSectionTool = {
+    name: "mutate_section",
+    mode: "write",
+    description: "Create a new section or update an existing section in TestRail. Set payload.action to 'create' or 'update' to specify the operation.",
+    parameters,
+    handler: async (args, client) => {
+        const { payload } = args;
+        return handleMutate(payload, async (createPayload) => {
+            const { project_id, action, ...data } = createPayload;
+            return client.addSection(project_id, data);
+        }, async (updatePayload) => {
+            const { section_id, action, ...data } = updatePayload;
+            return client.updateSection(section_id, data);
+        }, SectionSchema);
+    }
+};

package/dist/tools/sections/types.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+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 const BaseSectionFields = z.object({
+    name: z.string().describe("The name of the section"),
+    description: z.string().optional().describe("The description of the section"),
+});
+export const CreateSectionSchema = BaseSectionFields.extend({
+    action: z.literal("create").describe("The operation to perform: create a new section"),
+    project_id: z.number().describe("The ID of the project the section should be added to"),
+    parent_id: z.number().optional().describe("The ID of the parent section (to build section hierarchies)"),
+});
+export const UpdateSectionSchema = BaseSectionFields.partial().extend({
+    action: z.literal("update").describe("The operation to perform: update an existing section"),
+    section_id: z.number().describe("The ID of the section to update"),
+});

package/dist/tools/shared_steps/add_shared_step.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { SharedStepSchema } from "../../types/testrail.js";
+import { SharedStepSchema } from "./types.js";
 const parameters = {
     project_id: z.number().describe("The ID of the project where the shared step will be created"),
     title: z.string().describe("The title of the shared test step"),
@@ -10,6 +10,7 @@ const parameters = {
 };
 export const addSharedStepTool = {
     name: "add_shared_step",
+    mode: "write",
     description: "Creates a new set of shared test steps.",
     parameters,
     handler: async (args, client) => {

package/dist/tools/shared_steps/get_shared_step.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
-import { SharedStepSchema } from "../../types/testrail.js";
+import { SharedStepSchema } from "./types.js";
 const parameters = {
     shared_step_id: z.number().describe("The ID of the shared test step"),
 };
 export const getSharedStepTool = {
     name: "get_shared_step",
+    mode: "read",
     description: "Returns the details of a specific shared test step.",
     parameters,
     handler: async (args, client) => {

package/dist/tools/shared_steps/get_shared_step_history.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
-import { SharedStepHistorySchema } from "../../types/testrail.js";
+import { SharedStepHistorySchema } from "./types.js";
 const parameters = {
     shared_step_id: z.number().describe("The ID of the shared test step"),
 };
 export const getSharedStepHistoryTool = {
     name: "get_shared_step_history",
+    mode: "read",
     description: "Returns the change history of a set of shared test steps.",
     parameters,
     handler: async (args, client) => {

package/dist/tools/shared_steps/get_shared_steps.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
-import { SharedStepSchema } from "../../types/testrail.js";
+import { SharedStepSchema } from "./types.js";
 const parameters = {
     project_id: z.number().describe("The ID of the project"),
     refs: z.string().optional().describe("Filter by a single Reference ID"),
 };
 export const getSharedStepsTool = {
     name: "get_shared_steps",
+    mode: "read",
     description: "Returns a list of shared test steps for a specified project.",
     parameters,
     handler: async (args, client) => {

package/dist/tools/shared_steps/index.js

@@ -0,0 +1,12 @@
+import { getSharedStepsTool } from "./get_shared_steps.js";
+import { getSharedStepTool } from "./get_shared_step.js";
+import { getSharedStepHistoryTool } from "./get_shared_step_history.js";
+import { addSharedStepTool } from "./add_shared_step.js";
+import { updateSharedStepTool } from "./update_shared_step.js";
+export const sharedStepsTools = [
+    getSharedStepsTool,
+    getSharedStepTool,
+    getSharedStepHistoryTool,
+    addSharedStepTool,
+    updateSharedStepTool
+];

package/dist/tools/shared_steps/types.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const SharedStepContentSchema = z.object({
+    content: z.string(),
+    expected: z.string().nullable().optional(),
+});
+export const SharedStepSchema = z.object({
+    id: z.number(),
+    title: z.string(),
+    project_id: z.number().optional(),
+    custom_steps_separated: z.array(SharedStepContentSchema).optional(),
+    case_ids: z.array(z.number()).optional(),
+});
+export const SharedStepHistorySchema = z.object({
+    id: z.number(),
+    title: z.string(),
+    timestamp: z.number().optional(),
+    custom_steps_separated: z.array(SharedStepContentSchema).optional(),
+});

package/dist/tools/shared_steps/update_shared_step.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { SharedStepSchema } from "../../types/testrail.js";
+import { SharedStepSchema } from "./types.js";
 const parameters = {
     shared_step_id: z.number().describe("The ID of the shared test step to update"),
     title: z.string().optional().describe("The updated title of the shared test step"),
@@ -14,6 +14,7 @@ Updates are propagated automatically to all test cases using these steps.
 `;
 export const updateSharedStepTool = {
     name: "update_shared_step",
+    mode: "write",
     description: description.trim(),
     parameters,
     handler: async (args, client) => {

package/dist/tools/suites/index.js

@@ -0,0 +1,6 @@
+import { mutateSuiteTool } from "./mutate_suite.js";
+import { querySuiteTool } from "./query_suite.js";
+export const suitesTools = [
+    mutateSuiteTool,
+    querySuiteTool,
+];

package/dist/tools/suites/mutate_suite.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { SuiteSchema, CreateSuiteSchema, UpdateSuiteSchema } from "./types.js";
+import { handleMutate } from "../../utils/mutate_handler.js";
+const parameters = {
+    payload: z.discriminatedUnion("action", [
+        CreateSuiteSchema,
+        UpdateSuiteSchema,
+    ]).describe("The mutation payload containing the action (create or update) and the corresponding suite attributes"),
+};
+export const mutateSuiteTool = {
+    name: "mutate_suite",
+    mode: "write",
+    description: "Create a new test suite or update an existing one in TestRail. Set payload.action to 'create' or 'update' to specify the operation.",
+    parameters,
+    handler: async (args, client) => {
+        const { payload } = args;
+        return handleMutate(payload, async (createPayload) => {
+            const { project_id, action, ...data } = createPayload;
+            return client.addSuite(project_id, data);
+        }, async (updatePayload) => {
+            const { suite_id, action, ...data } = updatePayload;
+            return client.updateSuite(suite_id, data);
+        }, SuiteSchema);
+    }
+};

package/dist/tools/suites/query_suite.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { SuiteSchema, GetOneSuiteSchema, GetManySuitesSchema } from "./types.js";
+import { handleQuery } from "../../utils/query_handler.js";
+const parameters = {
+    payload: z.discriminatedUnion("action", [
+        GetOneSuiteSchema,
+        GetManySuitesSchema,
+    ]).describe("The payload containing the action ('one' or 'many') and corresponding parameters"),
+};
+export const querySuiteTool = {
+    name: "query_suite",
+    mode: "read",
+    description: "Retrieve a single test suite or all test suites for a project in TestRail. Set payload.action to 'one' or 'many' to specify the operation.",
+    parameters,
+    handler: async (args, client) => {
+        return handleQuery(args.payload, async (p) => {
+            const suite = await client.getSuite(p.suite_id);
+            return {
+                suite: SuiteSchema.parse(suite),
+            };
+        }, async (p) => {
+            const suites = await client.getSuites(p.project_id);
+            return {
+                suites: suites.map(s => SuiteSchema.parse(s)),
+            };
+        });
+    }
+};

package/dist/tools/suites/types.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export const SuiteSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    description: z.string().nullable().optional(),
+    project_id: z.number(),
+    url: z.string(),
+}).loose();
+export const BaseSuiteFields = z.object({
+    name: z.string().describe("The name of the test suite"),
+    description: z.string().optional().describe("The description of the test suite"),
+});
+export const CreateSuiteSchema = BaseSuiteFields.extend({
+    action: z.literal("create").describe("The operation to perform: create a new test suite"),
+    project_id: z.number().describe("The ID of the project the test suite should be added to"),
+});
+export const UpdateSuiteSchema = BaseSuiteFields.partial().extend({
+    action: z.literal("update").describe("The operation to perform: update an existing test suite"),
+    suite_id: z.number().describe("The ID of the test suite to update"),
+});
+export const GetOneSuiteSchema = z.object({
+    action: z.literal("one").describe("Retrieve a single test suite by ID"),
+    suite_id: z.number().int().describe("The ID of the test suite"),
+});
+export const GetManySuitesSchema = z.object({
+    action: z.literal("many").describe("Retrieve all test suites for a project"),
+    project_id: z.number().int().describe("The ID of the project"),
+});

package/dist/utils/mutate_handler.js

@@ -0,0 +1,22 @@
+/**
+ * Centralized utility to handle mutation actions (create or update) in a type-safe manner.
+ *
+ * @param payload The incoming payload containing the action discriminator
+ * @param onCreate Callback executed when action is "create"
+ * @param onUpdate Callback executed when action is "update"
+ * @returns The mutated entity wrapped in a record
+ */
+export async function handleMutate(payload, onCreate, onUpdate, schema) {
+    let result;
+    if (payload.action === "create") {
+        result = await onCreate(payload);
+    }
+    else if (payload.action === "update") {
+        result = await onUpdate(payload);
+    }
+    else {
+        const unknownAction = payload.action;
+        throw new Error(`Unsupported mutation action: ${unknownAction}`);
+    }
+    return schema ? schema.parse(result) : result;
+}

package/dist/utils/query_handler.js

@@ -0,0 +1,20 @@
+/**
+ * Centralized utility to handle query actions (one or many) in a type-safe manner.
+ *
+ * @param payload The incoming payload containing the action discriminator
+ * @param onQueryOne Callback executed when action is "one"
+ * @param onQueryMany Callback executed when action is "many"
+ * @returns The queried entity or list of entities wrapped in a record
+ */
+export async function handleQuery(payload, onQueryOne, onQueryMany) {
+    if (payload.action === "one") {
+        return onQueryOne(payload);
+    }
+    else if (payload.action === "many") {
+        return onQueryMany(payload);
+    }
+    else {
+        const unknownAction = payload.action;
+        throw new Error(`Unsupported query action: ${unknownAction}`);
+    }
+}