squish-qatouch 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# squish-qatouch
+
+> QA Touch reporter for **Squish** (Froglogic / Qt) — reads your Squish result XML and automatically creates modules, test cases, and test runs in QA Touch.
+
+## Supported result formats
+
+| Format | How to generate |
+|--------|----------------|
+| **Squish native XML** | `squishrunner --reportgen xml,results.xml` |
+| **JUnit XML** | `squish2junit results/ junit.xml` or `--reportgen xml.junit,...` |
+
+Auto-detected at runtime by the root element.
+
+## Installation
+
+```bash
+npm install squish-qatouch
+```
+
+No peer dependencies — works standalone in any Node.js project.
+
+## Quick start
+
+```ts
+import { SquishQATouchReporter } from "squish-qatouch";
+
+const reporter = new SquishQATouchReporter({
+  domain:       "mycompany",       // QA Touch domain
+  apiToken:     "YOUR_API_TOKEN",
+  projectKey:   "PROJ",
+  assignTo:     "user-key",
+  resultsFile:  "./results/squish.xml",  // native XML or JUnit XML
+  milestoneName: "Sprint 12",            // created if it does not exist
+  tag:          "squish",
+});
+
+await reporter.run();
+```
+
+Run it after `squishrunner` finishes:
+
+```bash
+npx ts-node upload-results.ts
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `domain` | `string` | — | Your QA Touch domain |
+| `apiToken` | `string` | — | QA Touch API token |
+| `projectKey` | `string` | — | QA Touch project key |
+| `assignTo` | `string` | — | User key to assign the run to |
+| `resultsFile` | `string` | — | Path to the Squish XML result file |
+| `testsuiteId` | `string?` | — | Pin all cases to one module key (skips auto-create) |
+| `milestoneName` | `string?` | `"Squish Automation"` | Milestone name — reused or created |
+| `milestoneKey` | `string?` | — | Use an existing milestone key directly |
+| `createCases` | `boolean?` | `true` | Auto-create missing test cases |
+| `tag` | `string?` | `"squish"` | Tag applied to the test run |
+
+## CI example (GitHub Actions)
+
+```yaml
+- name: Run Squish tests
+  run: squishrunner --testsuite suite_MyApp --reportgen xml,results/squish.xml
+
+- name: Upload to QA Touch
+  run: npx ts-node upload-results.ts
+```
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { SquishQATouchReporter } from "./reporter";
+export type { SquishQATouchReporterOptions } from "./reporter";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquishQATouchReporter = void 0;
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "SquishQATouchReporter", { enumerable: true, get: function () { return reporter_1.SquishQATouchReporter; } });

package/dist/qatouch-client.d.ts

@@ -0,0 +1,27 @@
+export interface QATouchClientOptions {
+    domain: string;
+    apiToken: string;
+    projectKey: string;
+}
+export declare class QATouchClient {
+    private domain;
+    private apiToken;
+    private projectKey;
+    constructor(options: QATouchClientOptions);
+    private request;
+    private multipartRequest;
+    private normalizeList;
+    getTestCases(moduleKey?: string): Promise<any[]>;
+    createTestCase(moduleKey: string, title: string, description: string, reference: string, precondition: string, stepsTemplate: string): Promise<void>;
+    getModules(): Promise<any[]>;
+    createModule(moduleName: string, parentKey?: string): Promise<any>;
+    getMilestones(): Promise<any[]>;
+    createMilestone(name: string): Promise<void>;
+    createTestRun(milestoneKey: string, title: string, assignTo: string, caseKeys: string[], tags?: string): Promise<any>;
+    createTestRunByModules(milestoneKey: string, title: string, assignTo: string, moduleKeys: string[], tags?: string): Promise<any>;
+    updateResults(testRunKey: string, results: Array<{
+        case: string;
+        status: number;
+    }>): Promise<any>;
+    addResultWithComment(testRunKey: string, caseKey: string, statusId: number, comments?: string, screenshotPath?: string): Promise<any>;
+}

package/dist/qatouch-client.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QATouchClient = void 0;
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class QATouchClient {
+    constructor(options) {
+        this.domain = options.domain;
+        this.apiToken = options.apiToken;
+        this.projectKey = options.projectKey;
+    }
+    request(method, endpoint) {
+        return new Promise((resolve, reject) => {
+            const headers = {
+                "api-token": this.apiToken,
+                domain: this.domain,
+                "Content-Type": "application/json",
+            };
+            if (method !== "GET") {
+                headers["Content-Length"] = "0";
+            }
+            const req = https.request({
+                hostname: "api.qatouch.com",
+                path: `/api/v1${endpoint}`,
+                method,
+                headers,
+            }, (res) => {
+                let body = "";
+                res.on("data", (chunk) => {
+                    body += chunk;
+                });
+                res.on("end", () => {
+                    let parsed = {};
+                    if (body) {
+                        try {
+                            parsed = JSON.parse(body);
+                        }
+                        catch {
+                            reject(new Error(`Non-JSON response (${res.statusCode}) for ${endpoint}`));
+                            return;
+                        }
+                    }
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(parsed);
+                        return;
+                    }
+                    reject(new Error(parsed.error_msg ||
+                        parsed.error ||
+                        `API Error ${res.statusCode} for ${endpoint}`));
+                });
+            });
+            req.on("error", reject);
+            req.end();
+        });
+    }
+    multipartRequest(endpoint, filePath) {
+        return new Promise((resolve, reject) => {
+            const boundary = `----QATouchBoundary${Date.now()}`;
+            const fileName = path.basename(filePath);
+            const fileData = fs.readFileSync(filePath);
+            const preamble = Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file[]"; filename="${fileName}"\r\nContent-Type: application/octet-stream\r\n\r\n`);
+            const epilogue = Buffer.from(`\r\n--${boundary}--\r\n`);
+            const body = Buffer.concat([preamble, fileData, epilogue]);
+            const req = https.request({
+                hostname: "api.qatouch.com",
+                path: `/api/v1${endpoint}`,
+                method: "POST",
+                headers: {
+                    "api-token": this.apiToken,
+                    domain: this.domain,
+                    "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                    "Content-Length": body.length,
+                },
+            }, (res) => {
+                let resBody = "";
+                res.on("data", (chunk) => {
+                    resBody += chunk;
+                });
+                res.on("end", () => {
+                    let parsed = {};
+                    if (resBody) {
+                        try {
+                            parsed = JSON.parse(resBody);
+                        }
+                        catch {
+                            reject(new Error(`Non-JSON response (${res.statusCode}) for ${endpoint}`));
+                            return;
+                        }
+                    }
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(parsed);
+                        return;
+                    }
+                    reject(new Error(parsed.error_msg ||
+                        parsed.error ||
+                        `API Error ${res.statusCode} for ${endpoint}`));
+                });
+            });
+            req.on("error", reject);
+            req.write(body);
+            req.end();
+        });
+    }
+    normalizeList(response) {
+        if (Array.isArray(response))
+            return response;
+        if (Array.isArray(response.data))
+            return response.data;
+        if (Array.isArray(response.items))
+            return response.items;
+        return [];
+    }
+    async getTestCases(moduleKey) {
+        const all = [];
+        let page = 1;
+        for (;;) {
+            const query = moduleKey
+                ? `moduleKey=${moduleKey}&page=${page}`
+                : `mode=automation&page=${page}`;
+            const response = await this.request("GET", `/getAllTestCases/${this.projectKey}?${query}`);
+            const batch = this.normalizeList(response);
+            if (batch.length === 0)
+                break;
+            all.push(...batch);
+            const total = Number(response?.meta?.total) || 0;
+            if (total > 0 && all.length >= total)
+                break;
+            if (batch.length < Number(response?.meta?.per_page || 50))
+                break;
+            page++;
+            if (page > 200)
+                break;
+        }
+        return all;
+    }
+    async createTestCase(moduleKey, title, description, reference, precondition, stepsTemplate) {
+        const endpoint = `/testCase/steps?projectKey=${this.projectKey}&sectionKey=${moduleKey}&caseTitle=${encodeURIComponent(title)}&description=${encodeURIComponent(description)}&reference=${encodeURIComponent(reference)}&precondition=${encodeURIComponent(precondition)}&steps_template=${stepsTemplate}&mode=automation`;
+        await this.request("POST", endpoint);
+    }
+    async getModules() {
+        const all = [];
+        let page = 1;
+        for (;;) {
+            const response = await this.request("GET", `/getAllModules/${this.projectKey}?page=${page}`);
+            const batch = this.normalizeList(response);
+            if (batch.length === 0)
+                break;
+            all.push(...batch);
+            const total = Number(response?.meta?.total) || 0;
+            if (total > 0 && all.length >= total)
+                break;
+            if (batch.length < Number(response?.meta?.per_page || 20))
+                break;
+            page++;
+            if (page > 50)
+                break;
+        }
+        return all;
+    }
+    async createModule(moduleName, parentKey) {
+        let endpoint = `/module?projectKey=${this.projectKey}&moduleName=${encodeURIComponent(moduleName)}`;
+        if (parentKey) {
+            endpoint += `&parentKey=${encodeURIComponent(parentKey)}`;
+        }
+        const response = await this.request("POST", endpoint);
+        if (response?.data && typeof response.data === "object" && !Array.isArray(response.data)) {
+            return response.data;
+        }
+        const list = this.normalizeList(response);
+        return list.length > 0 ? list[0] : response;
+    }
+    async getMilestones() {
+        const response = await this.request("GET", `/getAllMilestones/${this.projectKey}`);
+        return this.normalizeList(response);
+    }
+    async createMilestone(name) {
+        await this.request("POST", `/milestone?projectKey=${this.projectKey}&milestone=${encodeURIComponent(name)}`);
+    }
+    async createTestRun(milestoneKey, title, assignTo, caseKeys, tags) {
+        const params = [
+            `projectKey=${this.projectKey}`,
+            `milestoneKey=${encodeURIComponent(milestoneKey)}`,
+            `testRun=${encodeURIComponent(title)}`,
+            `assignTo=${encodeURIComponent(assignTo)}`,
+        ];
+        if (tags)
+            params.push(`tags=${encodeURIComponent(tags)}`);
+        for (const key of caseKeys) {
+            params.push(`caseId[]=${encodeURIComponent(key)}`);
+        }
+        const response = await this.request("POST", `/testRun/specific?${params.join("&")}`);
+        const payload = this.normalizeList(response)[0] ||
+            response.data?.[0] ||
+            response.data ||
+            {};
+        return payload;
+    }
+    async createTestRunByModules(milestoneKey, title, assignTo, moduleKeys, tags) {
+        const params = [
+            `projectKey=${this.projectKey}`,
+            `milestoneKey=${encodeURIComponent(milestoneKey)}`,
+            `testRun=${encodeURIComponent(title)}`,
+            `assignTo=${encodeURIComponent(assignTo)}`,
+            `mode=automation`,
+        ];
+        if (tags)
+            params.push(`tags=${encodeURIComponent(tags)}`);
+        for (const key of moduleKeys) {
+            params.push(`moduleKey[]=${encodeURIComponent(key)}`);
+        }
+        const response = await this.request("POST", `/testRun/specific/module/mode?${params.join("&")}`);
+        const payload = this.normalizeList(response)[0] ||
+            response.data?.[0] ||
+            response.data ||
+            {};
+        return payload;
+    }
+    async updateResults(testRunKey, results) {
+        const casesObj = {};
+        results.forEach((r, i) => {
+            casesObj[String(i)] = r;
+        });
+        const endpoint = `/runresult/updatestatus/multiple?project=${this.projectKey}&test_run=${testRunKey}&cases=${encodeURIComponent(JSON.stringify(casesObj))}`;
+        return this.request("POST", endpoint);
+    }
+    async addResultWithComment(testRunKey, caseKey, statusId, comments, screenshotPath) {
+        const statusName = statusIdToName(statusId);
+        let endpoint = `/testRunResults/add/results?status=${encodeURIComponent(statusName)}&project=${encodeURIComponent(this.projectKey)}&test_run=${encodeURIComponent(testRunKey)}&run_result[]=CASE${encodeURIComponent(caseKey)}`;
+        if (comments) {
+            endpoint += `&comments=${encodeURIComponent(comments)}`;
+        }
+        if (screenshotPath && fs.existsSync(screenshotPath)) {
+            const stat = fs.statSync(screenshotPath);
+            if (stat.size <= 2 * 1024 * 1024) {
+                return this.multipartRequest(endpoint, screenshotPath);
+            }
+        }
+        return this.request("POST", endpoint);
+    }
+}
+exports.QATouchClient = QATouchClient;
+function statusIdToName(id) {
+    switch (id) {
+        case 1: return "passed";
+        case 3: return "blocked";
+        case 4: return "retest";
+        case 5: return "failed";
+        case 6: return "not-applicable";
+        case 7: return "in-progress";
+        default: return "untested";
+    }
+}

package/dist/reporter.d.ts

@@ -0,0 +1,20 @@
+export interface SquishQATouchReporterOptions {
+    domain: string;
+    apiToken: string;
+    projectKey: string;
+    assignTo: string;
+    resultsFile: string;
+    testsuiteId?: string;
+    milestoneName?: string;
+    milestoneKey?: string;
+    createCases?: boolean;
+    tag?: string;
+}
+export declare class SquishQATouchReporter {
+    private opts;
+    private client;
+    constructor(options: SquishQATouchReporterOptions);
+    run(): Promise<void>;
+    private resolveMilestone;
+    private resolveModules;
+}

package/dist/reporter.js

@@ -0,0 +1,309 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquishQATouchReporter = void 0;
+const fs = __importStar(require("fs"));
+const qatouch_client_1 = require("./qatouch-client");
+function normalizeTitle(t) { return t.replace(/[^a-z0-9\s]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase(); }
+function extractCaseKey(i) { return i.case_key || i.caseKey || i.key || i.api_key || i.apiKey || i.id || null; }
+function extractRunKey(i) { return i.testrun_id || i.key || i.testRunKey || i.testrunkey || i.test_run || null; }
+function extractMilestoneKey(i) { return i.milestone_key || i.key || i.milestoneKey || i.id || null; }
+function extractModuleKey(i) { return i.section_key || i.module_key || i.key || i.sectionKey || i.api_key || i.apiKey || i.id || null; }
+function extractModuleName(i) { return i.section_name || i.module_name || i.name || i.title || i.sectionName || null; }
+function statusToId(s) { switch (s) {
+    case "passed": return 1;
+    case "failed": return 5;
+    case "blocked": return 3;
+    default: return 2;
+} }
+function buildStepsTemplate(title) {
+    const steps = {
+        "0": { steps: `Launch the AUT for: ${title}.`, expected_result: "The AUT starts in the expected initial state." },
+        "1": { steps: `Execute the Squish test case: ${title}.`, expected_result: "All script actions and verifications run without errors." },
+        "2": { steps: `Verify all verification points for: ${title}.`, expected_result: "All verification points pass." },
+    };
+    return encodeURIComponent(JSON.stringify(steps));
+}
+function parseJUnitXml(xml) {
+    const tests = [];
+    const suiteRe = /<testsuite\s([^>]*)>([\s\S]*?)<\/testsuite>/gi;
+    for (const sm of xml.matchAll(suiteRe)) {
+        const sa = sm[1] || "";
+        const si = sm[2] || "";
+        const snm = sa.match(/name="([^"]*)"/i);
+        const sn = snm ? snm[1] : "Default";
+        const caseRe = /<testcase\s([^>]*)(?:\/>|>([\s\S]*?)<\/testcase>)/gi;
+        for (const cm of si.matchAll(caseRe)) {
+            const ca = cm[1] || "";
+            const ci = cm[2] || "";
+            const get = (a) => { const m = ca.match(new RegExp(`${a}="([^"]*)"`, "i")); return m ? m[1] : ""; };
+            const title = get("name");
+            if (!title)
+                continue;
+            let status = "passed";
+            let errorMessage;
+            if (/<failure/i.test(ci) || /<error/i.test(ci)) {
+                status = "failed";
+                const mm = ci.match(/<(?:failure|error)[^>]*message="([^"]*)"/i);
+                if (mm)
+                    errorMessage = mm[1].slice(0, 2000);
+                else {
+                    const tm = ci.match(/<(?:failure|error)[^>]*>([\s\S]*?)<\/(?:failure|error)>/i);
+                    if (tm)
+                        errorMessage = tm[1].replace(/<[^>]+>/g, "").trim().slice(0, 2000);
+                }
+            }
+            else if (/<skipped/i.test(ci))
+                status = "blocked";
+            tests.push({ fullName: `${sn}.${title}`, title, normalizedTitle: normalizeTitle(title), suiteName: sn, status, errorMessage });
+        }
+    }
+    return tests;
+}
+function extractSquishFailMsg(xml) {
+    const m = xml.match(/<message[^>]*type="FAIL"[^>]*text="([^"]*)"/i);
+    if (m)
+        return m[1].slice(0, 2000);
+    const m2 = xml.match(/<message[^>]*type="FAIL"[^>]*>([\s\S]*?)<\/message>/i);
+    if (m2)
+        return m2[1].replace(/<[^>]+>/g, "").trim().slice(0, 2000);
+    return undefined;
+}
+function parseSquishNativeXml(xml) {
+    const tests = [];
+    const testRe = /<test\s([^>]*)>([\s\S]*?)<\/test>/gi;
+    for (const tm of xml.matchAll(testRe)) {
+        const ta = tm[1] || "";
+        const ti = tm[2] || "";
+        const nm = ta.match(/name="([^"]*)"/i);
+        const sn = nm ? nm[1] : "Default";
+        const fnRe = /<function\s([^>]*)>([\s\S]*?)<\/function>/gi;
+        const fns = [...ti.matchAll(fnRe)];
+        if (fns.length === 0) {
+            const fail = /<message[^>]*type="FAIL"/i.test(ti);
+            tests.push({ fullName: sn, title: sn, normalizedTitle: normalizeTitle(sn), suiteName: sn, status: fail ? "failed" : "passed", errorMessage: extractSquishFailMsg(ti) });
+            continue;
+        }
+        for (const fm of fns) {
+            const fa = fm[1] || "";
+            const fi = fm[2] || "";
+            const fnm = fa.match(/name="([^"]*)"/i);
+            const title = fnm ? fnm[1] : sn;
+            const fail = /<message[^>]*type="FAIL"/i.test(fi);
+            const skip = /<message[^>]*type="SKIP"/i.test(fi);
+            let status = "passed";
+            if (fail)
+                status = "failed";
+            else if (skip)
+                status = "blocked";
+            tests.push({ fullName: `${sn}.${title}`, title, normalizedTitle: normalizeTitle(title), suiteName: sn, status, errorMessage: fail ? extractSquishFailMsg(fi) : undefined });
+        }
+    }
+    return tests;
+}
+function parseResultsFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    if (/<SquishReport/i.test(content))
+        return parseSquishNativeXml(content);
+    if (/<testsuites/i.test(content) || /<testsuite/i.test(content))
+        return parseJUnitXml(content);
+    throw new Error(`[squish-qatouch] Unrecognised format (expected Squish XML or JUnit XML): ${filePath}`);
+}
+class SquishQATouchReporter {
+    constructor(options) {
+        this.opts = {
+            domain: options.domain, apiToken: options.apiToken, projectKey: options.projectKey,
+            assignTo: options.assignTo, resultsFile: options.resultsFile,
+            testsuiteId: options.testsuiteId, milestoneName: options.milestoneName || "Squish Automation",
+            milestoneKey: options.milestoneKey, createCases: options.createCases !== false,
+            tag: options.tag || "squish",
+        };
+        this.client = new qatouch_client_1.QATouchClient({ domain: this.opts.domain, apiToken: this.opts.apiToken, projectKey: this.opts.projectKey });
+    }
+    async run() {
+        const tests = parseResultsFile(this.opts.resultsFile);
+        if (tests.length === 0) {
+            console.warn("[squish-qatouch] No test cases found.");
+            return;
+        }
+        const suiteMap = new Map();
+        for (const t of tests) {
+            const l = suiteMap.get(t.suiteName) || [];
+            l.push(t);
+            suiteMap.set(t.suiteName, l);
+        }
+        const mkByS = await this.resolveModules([...suiteMap.keys()]);
+        const caseMap = new Map();
+        for (const mk of new Set(mkByS.values())) {
+            for (const item of await this.client.getTestCases(mk)) {
+                const t = (item.title || item.case_title || "").trim();
+                const k = extractCaseKey(item);
+                if (t && k)
+                    caseMap.set(normalizeTitle(t), k);
+            }
+        }
+        if (this.opts.createCases) {
+            for (const [sn, st] of suiteMap) {
+                const mk = mkByS.get(sn);
+                if (!mk)
+                    continue;
+                for (const test of st) {
+                    if (caseMap.has(test.normalizedTitle))
+                        continue;
+                    await this.client.createTestCase(mk, test.title, `Automated Squish scenario: ${test.title}`, test.fullName, "The Squish AUT is running and accessible.", buildStepsTemplate(test.title));
+                    for (const item of await this.client.getTestCases(mk)) {
+                        const t = (item.title || item.case_title || "").trim();
+                        const k = extractCaseKey(item);
+                        if (t && k)
+                            caseMap.set(normalizeTitle(t), k);
+                    }
+                }
+            }
+        }
+        const milestoneKey = await this.resolveMilestone();
+        if (!milestoneKey)
+            throw new Error("[squish-qatouch] Unable to resolve milestone key.");
+        const bulk = [];
+        const detailed = [];
+        const caseKeys = [];
+        for (const test of tests) {
+            const ck = caseMap.get(test.normalizedTitle);
+            if (!ck) {
+                console.warn(`[squish-qatouch] Unmapped: ${test.title}`);
+                continue;
+            }
+            caseKeys.push(ck);
+            if (test.status === "failed" && test.errorMessage)
+                detailed.push({ caseKey: ck, test });
+            else
+                bulk.push({ case: ck, status: statusToId(test.status) });
+        }
+        if (caseKeys.length === 0) {
+            console.warn("[squish-qatouch] No mapped cases.");
+            return;
+        }
+        const rp = await this.client.createTestRun(milestoneKey, `Squish Run ${new Date().toISOString()}`, this.opts.assignTo, [...new Set(caseKeys)], this.opts.tag);
+        const trk = extractRunKey(rp);
+        if (!trk)
+            throw new Error("[squish-qatouch] Test run returned no key.");
+        for (const { caseKey, test } of detailed) {
+            try {
+                await this.client.addResultWithComment(trk, caseKey, statusToId(test.status), test.errorMessage);
+            }
+            catch (e) {
+                console.error(`[squish-qatouch] ${e.message}`);
+                bulk.push({ case: caseKey, status: statusToId(test.status) });
+            }
+        }
+        if (bulk.length > 0) {
+            try {
+                const r = await this.client.updateResults(trk, bulk);
+                if (r?.error)
+                    throw new Error(r.error);
+            }
+            catch {
+                for (const item of bulk) {
+                    try {
+                        await this.client.addResultWithComment(trk, item.case, item.status);
+                    }
+                    catch (e) {
+                        console.error(`[squish-qatouch] ${e.message}`);
+                    }
+                }
+            }
+        }
+        console.log(`[squish-qatouch] Uploaded ${caseKeys.length} result(s) to run ${trk}.`);
+    }
+    async resolveMilestone() {
+        if (this.opts.milestoneKey)
+            return this.opts.milestoneKey;
+        const name = this.opts.milestoneName;
+        const find = (list) => list.find((m) => (m.milestone_name || m.name || m.title || m.milestone || "") === name);
+        let ms = await this.client.getMilestones();
+        if (find(ms))
+            return extractMilestoneKey(find(ms));
+        await this.client.createMilestone(name);
+        ms = await this.client.getMilestones();
+        return find(ms) ? extractMilestoneKey(find(ms)) : null;
+    }
+    async resolveModules(suiteNames) {
+        const mm = new Map();
+        if (this.opts.testsuiteId) {
+            for (const n of suiteNames)
+                mm.set(n, this.opts.testsuiteId);
+            return mm;
+        }
+        let existing = await this.client.getModules();
+        const byName = new Map();
+        for (const m of existing) {
+            const n = extractModuleName(m);
+            const k = extractModuleKey(m);
+            if (n && k)
+                byName.set(n.toLowerCase().trim(), k);
+        }
+        for (const sn of suiteNames) {
+            const norm = sn.toLowerCase().trim();
+            if (byName.has(norm)) {
+                mm.set(sn, byName.get(norm));
+                continue;
+            }
+            let ck = null;
+            try {
+                ck = extractModuleKey(await this.client.createModule(sn));
+            }
+            catch (e) {
+                console.warn(`[squish-qatouch] createModule: ${e.message}`);
+            }
+            if (!ck) {
+                existing = await this.client.getModules();
+                for (const m of existing) {
+                    const n = extractModuleName(m);
+                    const k = extractModuleKey(m);
+                    if (n && k)
+                        byName.set(n.toLowerCase().trim(), k);
+                }
+                ck = byName.get(norm) || null;
+            }
+            if (ck) {
+                mm.set(sn, ck);
+                byName.set(norm, ck);
+            }
+            else
+                console.error(`[squish-qatouch] Failed to resolve module: ${sn}`);
+        }
+        return mm;
+    }
+}
+exports.SquishQATouchReporter = SquishQATouchReporter;

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "squish-qatouch",
+  "version": "1.0.0",
+  "description": "QA Touch reporter for Squish (Froglogic/Qt) — auto-creates modules, test cases and test runs from Squish native XML or JUnit XML result files.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": { "build": "tsc", "prepare": "npm run build", "prepublishOnly": "npm run build" },
+  "keywords": ["squish","froglogic","qt","qatouch","reporter","test-management","qa"],
+  "author": "UjjwalaMeena",
+  "license": "ISC",
+  "repository": { "type": "git", "url": "git+https://github.com/ujjwala91/squish-qatouch.git" },
+  "homepage": "https://github.com/ujjwala91/squish-qatouch#readme",
+  "bugs": { "url": "https://github.com/ujjwala91/squish-qatouch/issues" },
+  "devDependencies": { "@types/node": "^20.0.0", "typescript": "^5.7.0" }
+}