@elisra-devops/docgen-data-provider 1.132.0 → 1.134.0

package/bin/modules/TicketsDataProvider.d.ts

@@ -362,5 +362,17 @@ export default class TicketsDataProvider {
      * @returns An object containing the categorized requirements and total processed count.
      */
     GetCategorizedRequirementsByType(wiqlHref: string): Promise<any>;
+    /**
+     * Returns per-side valid column lists for trace analysis Column Settings dialog.
+     * Uses the WIT field schema (~6 ADO calls, constant cost) to determine which
+     * declared query columns are valid for the Requirement side vs the Test Case side.
+     *
+     * Known limitation: assumes one WIT type per side (determined by sampling the first
+     * source + first target work item). Trace queries are single-type per side in practice.
+     */
+    GetTraceColumnsByType(reqTestWiqlHref: string | undefined, testReqWiqlHref: string | undefined, project: string): Promise<{
+        Requirement: any[];
+        'Test Case': any[];
+    }>;
 }
 export {};

package/bin/modules/TicketsDataProvider.js

@@ -2767,6 +2767,122 @@ class TicketsDataProvider {
             throw err;
         }
     }
+    /**
+     * Returns per-side valid column lists for trace analysis Column Settings dialog.
+     * Uses the WIT field schema (~6 ADO calls, constant cost) to determine which
+     * declared query columns are valid for the Requirement side vs the Test Case side.
+     *
+     * Known limitation: assumes one WIT type per side (determined by sampling the first
+     * source + first target work item). Trace queries are single-type per side in practice.
+     */
+    async GetTraceColumnsByType(reqTestWiqlHref, testReqWiqlHref, project) {
+        const normalizeCols = (columns) => (columns || []).map((c) => ({
+            referenceName: c.referenceName,
+            name: c.name,
+        }));
+        const mergeCols = (a, b) => {
+            const seen = new Set();
+            const result = [];
+            for (const col of [...a, ...b]) {
+                if (!seen.has(col.referenceName)) {
+                    seen.add(col.referenceName);
+                    result.push(col);
+                }
+            }
+            return result;
+        };
+        // Sample one work item to read its System.WorkItemType.
+        // In OneHop query relations: !relation.source means root (target = source WI);
+        // relation.source present means link (target = target WI).
+        const sampleWitType = async (relations, isSource) => {
+            var _a, _b, _c;
+            let url;
+            if (isSource) {
+                const rootRel = relations.find((r) => { var _a; return !r.source && ((_a = r.target) === null || _a === void 0 ? void 0 : _a.url); });
+                url = (_a = rootRel === null || rootRel === void 0 ? void 0 : rootRel.target) === null || _a === void 0 ? void 0 : _a.url;
+            }
+            else {
+                const linkRel = relations.find((r) => { var _a; return r.source && ((_a = r.target) === null || _a === void 0 ? void 0 : _a.url); });
+                url = (_b = linkRel === null || linkRel === void 0 ? void 0 : linkRel.target) === null || _b === void 0 ? void 0 : _b.url;
+            }
+            if (!url)
+                return undefined;
+            try {
+                const wi = await tfs_1.TFSServices.getItemContent(url, this.token);
+                return (_c = wi === null || wi === void 0 ? void 0 : wi.fields) === null || _c === void 0 ? void 0 : _c['System.WorkItemType'];
+            }
+            catch (_d) {
+                return undefined;
+            }
+        };
+        const fetchTypeFieldSet = async (typeName) => {
+            var _a;
+            const query = new URLSearchParams({ 'api-version': '5.1' }).toString();
+            const url = `${this.orgUrl}${encodeURIComponent(project)}/_apis/wit/workitemtypes/${encodeURIComponent(typeName)}/fields?${query}`;
+            const res = await tfs_1.TFSServices.getItemContent(url, this.token);
+            const fields = (_a = res === null || res === void 0 ? void 0 : res.value) !== null && _a !== void 0 ? _a : [];
+            return new Set(fields.map((f) => f.referenceName));
+        };
+        try {
+            // Step 1: fetch declared columns from provided query hrefs
+            let reqTestCols = [];
+            let testReqCols = [];
+            let reqTestRelations = [];
+            let testReqRelations = [];
+            if (reqTestWiqlHref) {
+                const qr = await tfs_1.TFSServices.getItemContent(reqTestWiqlHref, this.token);
+                reqTestCols = normalizeCols((qr === null || qr === void 0 ? void 0 : qr.columns) || []);
+                reqTestRelations = (qr === null || qr === void 0 ? void 0 : qr.workItemRelations) || [];
+            }
+            if (testReqWiqlHref) {
+                const qr = await tfs_1.TFSServices.getItemContent(testReqWiqlHref, this.token);
+                testReqCols = normalizeCols((qr === null || qr === void 0 ? void 0 : qr.columns) || []);
+                testReqRelations = (qr === null || qr === void 0 ? void 0 : qr.workItemRelations) || [];
+            }
+            const declaredCols = mergeCols(reqTestCols, testReqCols);
+            if (declaredCols.length === 0) {
+                return { Requirement: [], 'Test Case': [] };
+            }
+            // Step 2: sample WIT type names
+            // reqTest: source = Requirement, target = Test Case
+            // testReq: source = Test Case, target = Requirement
+            let reqTypeName;
+            let tcTypeName;
+            if (reqTestRelations.length > 0) {
+                [reqTypeName, tcTypeName] = await Promise.all([
+                    sampleWitType(reqTestRelations, true),
+                    sampleWitType(reqTestRelations, false),
+                ]);
+            }
+            if ((!reqTypeName || !tcTypeName) && testReqRelations.length > 0) {
+                const [tSrc, tTgt] = await Promise.all([
+                    sampleWitType(testReqRelations, true),
+                    sampleWitType(testReqRelations, false),
+                ]);
+                if (!tcTypeName)
+                    tcTypeName = tSrc;
+                if (!reqTypeName)
+                    reqTypeName = tTgt;
+            }
+            if (!reqTypeName || !tcTypeName) {
+                logger_1.default.warn('GetTraceColumnsByType: could not determine WIT type names — returning merged columns');
+                return { Requirement: declaredCols, 'Test Case': declaredCols };
+            }
+            // Step 3: fetch WIT field schemas and intersect with declared columns
+            const [reqFieldSet, tcFieldSet] = await Promise.all([
+                fetchTypeFieldSet(reqTypeName),
+                fetchTypeFieldSet(tcTypeName),
+            ]);
+            return {
+                Requirement: declaredCols.filter((c) => reqFieldSet.has(c.referenceName)),
+                'Test Case': declaredCols.filter((c) => tcFieldSet.has(c.referenceName)),
+            };
+        }
+        catch (err) {
+            logger_1.default.error(`GetTraceColumnsByType failed: ${err.message}`);
+            return { Requirement: [], 'Test Case': [] };
+        }
+    }
 }
 exports.default = TicketsDataProvider;
 //# sourceMappingURL=TicketsDataProvider.js.map