@elisra-devops/docgen-data-provider 1.61.0 → 1.63.0

package/bin/modules/TicketsDataProvider.js

@@ -9,11 +9,13 @@ const tfs_data_4 = require("../models/tfs-data");
 const tfs_data_5 = require("../models/tfs-data");
 const tfs_data_6 = require("../models/tfs-data");
 const logger_1 = require("../utils/logger");
+const pLimit = require('p-limit');
 class TicketsDataProvider {
     constructor(orgUrl, token) {
         this.orgUrl = '';
         this.token = '';
         this.queriesList = new Array();
+        this.limit = pLimit(10);
         this.orgUrl = orgUrl;
         this.token = token;
     }
@@ -105,6 +107,7 @@ class TicketsDataProvider {
      * @returns
      */
     async GetSharedQueries(project, path, docType = '') {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
         let url;
         try {
             if (path === '')
@@ -113,22 +116,166 @@ class TicketsDataProvider {
                 url = `${this.orgUrl}${project}/_apis/wit/queries/${path}?$depth=2&$expand=all`;
             let queries = await tfs_1.TFSServices.getItemContent(url, this.token);
             logger_1.default.debug(`doctype: ${docType}`);
-            switch (docType === null || docType === void 0 ? void 0 : docType.toLowerCase()) {
-                case 'std':
-                    const reqTestQueries = await this.fetchLinkedReqTestQueries(queries, false);
-                    const linkedMomQueries = await this.fetchLinkedMomQueries(queries);
+            const normalizedDocType = (docType || '').toLowerCase();
+            const queriesWithChildren = await this.ensureQueryChildren(queries);
+            switch (normalizedDocType) {
+                case 'std': {
+                    const { root: stdRoot, found: stdRootFound } = await this.getDocTypeRoot(queriesWithChildren, 'std');
+                    logger_1.default.debug(`[GetSharedQueries][std] using ${stdRootFound ? 'dedicated folder' : 'root queries'}`);
+                    // Each branch describes the dedicated folder names, the fetch routine, and how to validate results.
+                    const stdBranches = await this.fetchDocTypeBranches(queriesWithChildren, stdRoot, [
+                        {
+                            id: 'reqToTest',
+                            label: '[GetSharedQueries][std][req-to-test]',
+                            folderNames: [
+                                'requirement - test',
+                                'requirement to test case',
+                                'requirement to test',
+                                'req to test',
+                            ],
+                            fetcher: (folder) => this.fetchLinkedReqTestQueries(folder, false),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.reqTestTree),
+                        },
+                        {
+                            id: 'testToReq',
+                            label: '[GetSharedQueries][std][test-to-req]',
+                            folderNames: [
+                                'test - requirement',
+                                'test to requirement',
+                                'test case to requirement',
+                                'test to req',
+                            ],
+                            fetcher: (folder) => this.fetchLinkedReqTestQueries(folder, true),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.testReqTree),
+                        },
+                        {
+                            id: 'mom',
+                            label: '[GetSharedQueries][std][mom]',
+                            folderNames: ['linked mom', 'mom'],
+                            fetcher: (folder) => this.fetchLinkedMomQueries(folder),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.linkedMomTree),
+                        },
+                    ]);
+                    const reqToTestResult = stdBranches['reqToTest'];
+                    const testToReqResult = stdBranches['testToReq'];
+                    const momResult = stdBranches['mom'];
+                    const reqTestQueries = {
+                        reqTestTree: (_b = (_a = reqToTestResult === null || reqToTestResult === void 0 ? void 0 : reqToTestResult.result) === null || _a === void 0 ? void 0 : _a.reqTestTree) !== null && _b !== void 0 ? _b : null,
+                        testReqTree: (_f = (_d = (_c = testToReqResult === null || testToReqResult === void 0 ? void 0 : testToReqResult.result) === null || _c === void 0 ? void 0 : _c.testReqTree) !== null && _d !== void 0 ? _d : (_e = reqToTestResult === null || reqToTestResult === void 0 ? void 0 : reqToTestResult.result) === null || _e === void 0 ? void 0 : _e.testReqTree) !== null && _f !== void 0 ? _f : null,
+                    };
+                    const linkedMomQueries = {
+                        linkedMomTree: (_h = (_g = momResult === null || momResult === void 0 ? void 0 : momResult.result) === null || _g === void 0 ? void 0 : _g.linkedMomTree) !== null && _h !== void 0 ? _h : null,
+                    };
                     return { reqTestQueries, linkedMomQueries };
-                case 'str':
-                    const reqTestTrees = await this.fetchLinkedReqTestQueries(queries, false);
-                    const openPcrTestTrees = await this.fetchLinkedOpenPcrTestQueries(queries, false);
+                }
+                case 'str': {
+                    const { root: strRoot, found: strRootFound } = await this.getDocTypeRoot(queriesWithChildren, 'str');
+                    logger_1.default.debug(`[GetSharedQueries][str] using ${strRootFound ? 'dedicated folder' : 'root queries'}`);
+                    const strBranches = await this.fetchDocTypeBranches(queriesWithChildren, strRoot, [
+                        {
+                            id: 'reqToTest',
+                            label: '[GetSharedQueries][str][req-to-test]',
+                            folderNames: [
+                                'requirement - test',
+                                'requirement to test case',
+                                'requirement to test',
+                                'req to test',
+                            ],
+                            fetcher: (folder) => this.fetchLinkedReqTestQueries(folder, false),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.reqTestTree),
+                        },
+                        {
+                            id: 'testToReq',
+                            label: '[GetSharedQueries][str][test-to-req]',
+                            folderNames: [
+                                'test - requirement',
+                                'test to requirement',
+                                'test case to requirement',
+                                'test to req',
+                            ],
+                            fetcher: (folder) => this.fetchLinkedReqTestQueries(folder, true),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.testReqTree),
+                        },
+                        {
+                            id: 'openPcrToTest',
+                            label: '[GetSharedQueries][str][open-pcr-to-test]',
+                            folderNames: ['open pcr to test case', 'open pcr to test', 'open pcr - test', 'open pcr'],
+                            fetcher: (folder) => this.fetchLinkedOpenPcrTestQueries(folder, false),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.OpenPcrToTestTree),
+                        },
+                        {
+                            id: 'testToOpenPcr',
+                            label: '[GetSharedQueries][str][test-to-open-pcr]',
+                            folderNames: ['test case to open pcr', 'test to open pcr', 'test - open pcr', 'open pcr'],
+                            fetcher: (folder) => this.fetchLinkedOpenPcrTestQueries(folder, true),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.TestToOpenPcrTree),
+                        },
+                    ]);
+                    const strReqToTest = strBranches['reqToTest'];
+                    const strTestToReq = strBranches['testToReq'];
+                    const strOpenPcrToTest = strBranches['openPcrToTest'];
+                    const strTestToOpenPcr = strBranches['testToOpenPcr'];
+                    const reqTestTrees = {
+                        reqTestTree: (_k = (_j = strReqToTest === null || strReqToTest === void 0 ? void 0 : strReqToTest.result) === null || _j === void 0 ? void 0 : _j.reqTestTree) !== null && _k !== void 0 ? _k : null,
+                        testReqTree: (_p = (_m = (_l = strTestToReq === null || strTestToReq === void 0 ? void 0 : strTestToReq.result) === null || _l === void 0 ? void 0 : _l.testReqTree) !== null && _m !== void 0 ? _m : (_o = strReqToTest === null || strReqToTest === void 0 ? void 0 : strReqToTest.result) === null || _o === void 0 ? void 0 : _o.testReqTree) !== null && _p !== void 0 ? _p : null,
+                    };
+                    const openPcrTestTrees = {
+                        OpenPcrToTestTree: (_r = (_q = strOpenPcrToTest === null || strOpenPcrToTest === void 0 ? void 0 : strOpenPcrToTest.result) === null || _q === void 0 ? void 0 : _q.OpenPcrToTestTree) !== null && _r !== void 0 ? _r : null,
+                        TestToOpenPcrTree: (_v = (_t = (_s = strTestToOpenPcr === null || strTestToOpenPcr === void 0 ? void 0 : strTestToOpenPcr.result) === null || _s === void 0 ? void 0 : _s.TestToOpenPcrTree) !== null && _t !== void 0 ? _t : (_u = strOpenPcrToTest === null || strOpenPcrToTest === void 0 ? void 0 : strOpenPcrToTest.result) === null || _u === void 0 ? void 0 : _u.TestToOpenPcrTree) !== null && _v !== void 0 ? _v : null,
+                    };
                     return { reqTestTrees, openPcrTestTrees };
-                case 'test-reporter':
-                    const testAssociatedTree = await this.fetchTestReporterQueries(queries);
-                    return { testAssociatedTree };
+                }
+                case 'test-reporter': {
+                    const { root: testReporterRoot, found: testReporterFound } = await this.getDocTypeRoot(queriesWithChildren, 'test-reporter');
+                    logger_1.default.debug(`[GetSharedQueries][test-reporter] using ${testReporterFound ? 'dedicated folder' : 'root queries'}`);
+                    const testReporterBranches = await this.fetchDocTypeBranches(queriesWithChildren, testReporterRoot, [
+                        {
+                            id: 'testReporter',
+                            label: '[GetSharedQueries][test-reporter]',
+                            folderNames: ['test reporter', 'test-reporter'],
+                            fetcher: (folder) => this.fetchTestReporterQueries(folder),
+                            validator: (result) => this.hasAnyQueryTree(result === null || result === void 0 ? void 0 : result.testAssociatedTree),
+                        },
+                    ]);
+                    const testReporterFetch = testReporterBranches['testReporter'];
+                    return (_w = testReporterFetch === null || testReporterFetch === void 0 ? void 0 : testReporterFetch.result) !== null && _w !== void 0 ? _w : { testAssociatedTree: null };
+                }
                 case 'srs':
-                    return await this.fetchSrsQueries(queries);
-                case 'svd':
-                    return await this.fetchAnyQueries(queries);
+                    return await this.fetchSrsQueries(queriesWithChildren);
+                case 'svd': {
+                    const { root: svdRoot, found } = await this.getDocTypeRoot(queriesWithChildren, 'svd');
+                    if (!found) {
+                        logger_1.default.debug('[GetSharedQueries][svd] dedicated folder not found, using fallback tree');
+                    }
+                    const svdBranches = await this.fetchDocTypeBranches(queriesWithChildren, svdRoot, [
+                        {
+                            id: 'systemOverview',
+                            label: '[GetSharedQueries][svd][system-overview]',
+                            folderNames: ['system overview'],
+                            fetcher: async (folder) => {
+                                const { tree1 } = await this.structureAllQueryPath(folder);
+                                return tree1;
+                            },
+                            validator: (result) => !!result,
+                        },
+                        {
+                            id: 'knownBugs',
+                            label: '[GetSharedQueries][svd][known-bugs]',
+                            folderNames: ['known bugs', 'known bug'],
+                            fetcher: async (folder) => {
+                                const { tree2 } = await this.structureAllQueryPath(folder);
+                                return tree2;
+                            },
+                            validator: (result) => !!result,
+                        },
+                    ]);
+                    const systemOverviewFetch = svdBranches['systemOverview'];
+                    const knownBugsFetch = svdBranches['knownBugs'];
+                    return {
+                        systemOverviewQueryTree: (_x = systemOverviewFetch === null || systemOverviewFetch === void 0 ? void 0 : systemOverviewFetch.result) !== null && _x !== void 0 ? _x : null,
+                        knownBugsQueryTree: (_y = knownBugsFetch === null || knownBugsFetch === void 0 ? void 0 : knownBugsFetch.result) !== null && _y !== void 0 ? _y : null,
+                    };
+                }
                 default:
                     break;
             }
@@ -203,6 +350,30 @@ class TicketsDataProvider {
         ]);
         return { linkedMomTree };
     }
+    hasAnyQueryTree(result) {
+        const inspect = (value) => {
+            if (!value) {
+                return false;
+            }
+            if (Array.isArray(value)) {
+                return value.some(inspect);
+            }
+            if (typeof value === 'object') {
+                if (value.isValidQuery || value.wiql || value.queryType) {
+                    return true;
+                }
+                if ('roots' in value && Array.isArray(value.roots) && value.roots.length > 0) {
+                    return true;
+                }
+                if ('children' in value && Array.isArray(value.children) && value.children.length > 0) {
+                    return true;
+                }
+                return Object.values(value).some(inspect);
+            }
+            return false;
+        };
+        return inspect(result);
+    }
     /**
      * Fetches and structures linked queries related to open PCR (Problem Change Request) tests.
      *
@@ -229,10 +400,6 @@ class TicketsDataProvider {
         const { tree1: tree1, tree2: testAssociatedTree } = await this.structureFetchedQueries(queries, true, null, ['Requirement', 'Bug', 'Change Request'], ['Test Case']);
         return { testAssociatedTree };
     }
-    async fetchAnyQueries(queries) {
-        const { tree1: systemOverviewQueryTree, tree2: knownBugsQueryTree } = await this.structureAllQueryPath(queries);
-        return { systemOverviewQueryTree, knownBugsQueryTree };
-    }
     async fetchSystemRequirementQueries(queries, excludedFolderNames = []) {
         const { tree1: systemRequirementsQueryTree } = await this.structureFetchedQueries(queries, false, null, ['Epic', 'Feature', 'Requirement'], [], undefined, undefined, true, // Enable processing of both tree and direct link queries (excluding flat queries)
         excludedFolderNames);
@@ -328,6 +495,219 @@ class TicketsDataProvider {
         const normalizedName = childName.toLowerCase();
         return (parentWithChildren.children.find((child) => child.isFolder && (child.name || '').toLowerCase() === normalizedName) || null);
     }
+    /**
+     * Performs a breadth-first walk starting at `parent` to locate the nearest folder whose
+     * name matches any of the provided candidates (case-insensitive). Exact matches win; if none
+     * are found the first partial match encountered is returned. When no candidates are located,
+     * the method yields `null`.
+     */
+    async findChildFolderByPossibleNames(parent, possibleNames) {
+        var _a, _b, _c, _d;
+        if (!parent || !(possibleNames === null || possibleNames === void 0 ? void 0 : possibleNames.length)) {
+            return null;
+        }
+        const normalizedNames = possibleNames.map((name) => name.toLowerCase());
+        const isMatch = (candidate, value) => value === candidate;
+        const isPartialMatch = (candidate, value) => value.includes(candidate);
+        const tryMatch = (folder, matcher) => {
+            const folderName = ((folder === null || folder === void 0 ? void 0 : folder.name) || '').toLowerCase();
+            return normalizedNames.some((candidate) => matcher(candidate, folderName));
+        };
+        const parentWithChildren = await this.ensureQueryChildren(parent);
+        if (!((_a = parentWithChildren === null || parentWithChildren === void 0 ? void 0 : parentWithChildren.children) === null || _a === void 0 ? void 0 : _a.length)) {
+            return null;
+        }
+        const queue = [];
+        const visited = new Set();
+        let partialCandidate = null;
+        // Seed the queue with direct children so we prefer closer matches before walking deeper.
+        for (const child of parentWithChildren.children) {
+            if (!(child === null || child === void 0 ? void 0 : child.isFolder)) {
+                continue;
+            }
+            const childId = (_b = child.id) !== null && _b !== void 0 ? _b : `${child.name}-${Math.random()}`;
+            queue.push(child);
+            visited.add(childId);
+        }
+        const considerFolder = async (folder) => {
+            if (tryMatch(folder, isMatch)) {
+                return await this.ensureQueryChildren(folder);
+            }
+            if (!partialCandidate && tryMatch(folder, isPartialMatch)) {
+                partialCandidate = await this.ensureQueryChildren(folder);
+            }
+            return null;
+        };
+        for (const child of queue) {
+            const match = await considerFolder(child);
+            if (match) {
+                return match;
+            }
+        }
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            const currentWithChildren = await this.ensureQueryChildren(current);
+            if (!currentWithChildren) {
+                continue;
+            }
+            const match = await considerFolder(currentWithChildren);
+            if (match) {
+                return match;
+            }
+            // Breadth-first expansion so we climb the hierarchy gradually.
+            if ((_c = currentWithChildren.children) === null || _c === void 0 ? void 0 : _c.length) {
+                for (const child of currentWithChildren.children) {
+                    if (!(child === null || child === void 0 ? void 0 : child.isFolder)) {
+                        continue;
+                    }
+                    const childId = (_d = child.id) !== null && _d !== void 0 ? _d : `${child.name}-${Math.random()}`;
+                    if (!visited.has(childId)) {
+                        visited.add(childId);
+                        queue.push(child);
+                    }
+                }
+            }
+        }
+        return partialCandidate;
+    }
+    /**
+     * Executes `fetcher` against `startingFolder` and, if the validator deems the result empty,
+     * climbs ancestor folders toward `rootQueries` until a satisfactory result is produced.
+     * The first successful folder short-circuits the search; otherwise the final attempt is
+     * returned to preserve legacy behavior.
+     */
+    async fetchWithAncestorFallback(rootQueries, startingFolder, fetcher, logContext, validator) {
+        var _a;
+        const rootWithChildren = await this.ensureQueryChildren(rootQueries);
+        const candidates = await this.buildFallbackChain(rootWithChildren, startingFolder);
+        const evaluate = validator !== null && validator !== void 0 ? validator : ((res) => this.hasAnyQueryTree(res));
+        let lastResult = null;
+        let lastFolder = startingFolder !== null && startingFolder !== void 0 ? startingFolder : rootWithChildren;
+        for (const candidate of candidates) {
+            const enrichedCandidate = await this.ensureQueryChildren(candidate);
+            const candidateName = (_a = enrichedCandidate === null || enrichedCandidate === void 0 ? void 0 : enrichedCandidate.name) !== null && _a !== void 0 ? _a : '<root>';
+            logger_1.default.debug(`${logContext} trying folder: ${candidateName}`);
+            lastResult = await fetcher(enrichedCandidate);
+            lastFolder = enrichedCandidate;
+            if (evaluate(lastResult)) {
+                logger_1.default.debug(`${logContext} using folder: ${candidateName}`);
+                return { result: lastResult, usedFolder: enrichedCandidate };
+            }
+            logger_1.default.debug(`${logContext} folder ${candidateName} produced no results, ascending`);
+        }
+        logger_1.default.debug(`${logContext} no folders yielded results, returning last attempt`);
+        return { result: lastResult, usedFolder: lastFolder };
+    }
+    /**
+     * Applies `fetchWithAncestorFallback` to each configured branch, resolving dedicated folders
+     * when available and emitting a map keyed by branch id. Each outcome includes both the
+     * resulting payload and the specific folder that satisfied the fallback chain.
+     */
+    async fetchDocTypeBranches(queriesWithChildren, docRoot, branches) {
+        var _a, _b, _c, _d, _e, _f;
+        const results = {};
+        const effectiveDocRoot = docRoot !== null && docRoot !== void 0 ? docRoot : queriesWithChildren;
+        for (const branch of branches) {
+            const fallbackStart = (_a = branch.fallbackStart) !== null && _a !== void 0 ? _a : effectiveDocRoot;
+            let startingFolder = fallbackStart;
+            let startingName = (_b = startingFolder === null || startingFolder === void 0 ? void 0 : startingFolder.name) !== null && _b !== void 0 ? _b : '<root>';
+            // Attempt to locate a more specific child folder, falling back to the provided root if absent.
+            if (((_c = branch.folderNames) === null || _c === void 0 ? void 0 : _c.length) && effectiveDocRoot) {
+                const resolvedFolder = await this.findChildFolderByPossibleNames(effectiveDocRoot, branch.folderNames);
+                if (resolvedFolder) {
+                    startingFolder = resolvedFolder;
+                    startingName = (_d = resolvedFolder === null || resolvedFolder === void 0 ? void 0 : resolvedFolder.name) !== null && _d !== void 0 ? _d : '<root>';
+                }
+            }
+            logger_1.default.debug(`${branch.label} starting folder: ${startingName}`);
+            const fetchOutcome = await this.fetchWithAncestorFallback(queriesWithChildren, startingFolder, branch.fetcher, branch.label, branch.validator);
+            logger_1.default.debug(`${branch.label} final folder: ${(_f = (_e = fetchOutcome.usedFolder) === null || _e === void 0 ? void 0 : _e.name) !== null && _f !== void 0 ? _f : '<root>'}`);
+            results[branch.id] = fetchOutcome;
+        }
+        return results;
+    }
+    /**
+     * Constructs an ordered list of folders to probe during fallback. The sequence starts at
+     * `startingFolder` (if provided) and walks upward through ancestors to the root query tree,
+     * ensuring no folder id appears twice.
+     */
+    async buildFallbackChain(rootQueries, startingFolder) {
+        const chain = [];
+        const seen = new Set();
+        const pushUnique = (node) => {
+            var _a;
+            if (!node) {
+                return;
+            }
+            const id = (_a = node.id) !== null && _a !== void 0 ? _a : '__root__';
+            if (seen.has(id)) {
+                return;
+            }
+            seen.add(id);
+            chain.push(node);
+        };
+        if (startingFolder === null || startingFolder === void 0 ? void 0 : startingFolder.id) {
+            const path = await this.findPathToNode(rootQueries, startingFolder.id);
+            if (path) {
+                for (let i = path.length - 1; i >= 0; i--) {
+                    pushUnique(path[i]);
+                }
+            }
+            else {
+                pushUnique(startingFolder);
+            }
+        }
+        else if (startingFolder) {
+            pushUnique(startingFolder);
+        }
+        pushUnique(rootQueries);
+        return chain;
+    }
+    /**
+     * Recursively searches the query tree for the node with the provided id and returns the
+     * path (root → target). Nodes are enriched with children on demand and a visited set guards
+     * against cycles within malformed data.
+     */
+    async findPathToNode(currentNode, targetId, visited = new Set()) {
+        var _a;
+        if (!currentNode) {
+            return null;
+        }
+        const currentId = (_a = currentNode.id) !== null && _a !== void 0 ? _a : '__root__';
+        if (visited.has(currentId)) {
+            return null;
+        }
+        visited.add(currentId);
+        if (currentNode.id === targetId) {
+            return [currentNode];
+        }
+        const enrichedNode = await this.ensureQueryChildren(currentNode);
+        const children = enrichedNode === null || enrichedNode === void 0 ? void 0 : enrichedNode.children;
+        if (!(children === null || children === void 0 ? void 0 : children.length)) {
+            return null;
+        }
+        for (const child of children) {
+            const path = await this.findPathToNode(child, targetId, visited);
+            if (path) {
+                return [enrichedNode, ...path];
+            }
+        }
+        return null;
+    }
+    async getDocTypeRoot(rootQueries, docTypeName) {
+        if (!rootQueries) {
+            return { root: rootQueries, found: false };
+        }
+        const docTypeFolder = await this.findQueryFolderByName(rootQueries, docTypeName);
+        if (docTypeFolder) {
+            const folderWithChildren = await this.ensureQueryChildren(docTypeFolder);
+            return { root: folderWithChildren, found: true };
+        }
+        return { root: rootQueries, found: false };
+    }
     async ensureQueryChildren(node) {
         if (!node || !node.hasChildren || node.children) {
             return node;
@@ -392,29 +772,74 @@ class TicketsDataProvider {
         const sourceTargetsMap = new Map();
         const lookupMap = new Map();
         if (workItemRelations) {
+            // Step 1: Collect all unique work item IDs that need to be fetched
+            const sourceIds = new Set();
+            const targetIds = new Set();
+            for (const relation of workItemRelations) {
+                if (!relation.source) {
+                    // Root link - target is actually the source
+                    sourceIds.add(relation.target.id);
+                }
+                else {
+                    sourceIds.add(relation.source.id);
+                    if (relation.target) {
+                        targetIds.add(relation.target.id);
+                    }
+                }
+            }
+            // Step 2: Fetch all work items in parallel with concurrency limit
+            const allSourcePromises = Array.from(sourceIds).map((id) => this.limit(() => {
+                const relation = workItemRelations.find((r) => { var _a; return (!r.source && r.target.id === id) || ((_a = r.source) === null || _a === void 0 ? void 0 : _a.id) === id; });
+                return this.fetchWIForQueryResult(relation, columnsToShowMap, columnSourceMap, true);
+            }));
+            const allTargetPromises = Array.from(targetIds).map((id) => this.limit(() => {
+                const relation = workItemRelations.find((r) => { var _a; return ((_a = r.target) === null || _a === void 0 ? void 0 : _a.id) === id; });
+                return this.fetchWIForQueryResult(relation, columnsToShowMap, columnTargetsMap, true);
+            }));
+            // Wait for all fetches to complete in parallel (with concurrency control)
+            const [sourceWorkItems, targetWorkItems] = await Promise.all([
+                Promise.all(allSourcePromises),
+                Promise.all(allTargetPromises),
+            ]);
+            // Build lookup maps
+            const sourceWorkItemMap = new Map();
+            sourceWorkItems.forEach((wi) => {
+                sourceWorkItemMap.set(wi.id, wi);
+                if (!lookupMap.has(wi.id)) {
+                    lookupMap.set(wi.id, wi);
+                }
+            });
+            const targetWorkItemMap = new Map();
+            targetWorkItems.forEach((wi) => {
+                targetWorkItemMap.set(wi.id, wi);
+                if (!lookupMap.has(wi.id)) {
+                    lookupMap.set(wi.id, wi);
+                }
+            });
+            // Step 3: Build the sourceTargetsMap using the fetched work items
             for (const relation of workItemRelations) {
-                //if relation.Source is null and target has a valid value then the target is the source
                 if (!relation.source) {
                     // Root link
-                    const wi = await this.fetchWIForQueryResult(relation, columnsToShowMap, columnSourceMap, true);
-                    if (!lookupMap.has(wi.id)) {
+                    const wi = sourceWorkItemMap.get(relation.target.id);
+                    if (wi && !sourceTargetsMap.has(wi)) {
                         sourceTargetsMap.set(wi, []);
-                        lookupMap.set(wi.id, wi);
                     }
-                    continue; // Move to the next relation
+                    continue;
                 }
                 if (!relation.target) {
                     throw new Error('Target relation is missing');
                 }
-                // Get relation source from lookup
-                const sourceWorkItem = lookupMap.get(relation.source.id);
+                const sourceWorkItem = sourceWorkItemMap.get(relation.source.id);
                 if (!sourceWorkItem) {
                     throw new Error('Source relation has no mapping');
                 }
-                const targetWi = await this.fetchWIForQueryResult(relation, columnsToShowMap, columnTargetsMap, true);
-                //In case if source is a test case
+                const targetWi = targetWorkItemMap.get(relation.target.id);
+                if (!targetWi) {
+                    throw new Error('Target work item not found');
+                }
+                // In case if source is a test case
                 this.mapTestCaseToRelatedItem(sourceWorkItem, targetWi, testCaseToRelatedWiMap);
-                //In case of target is a test case
+                // In case of target is a test case
                 this.mapTestCaseToRelatedItem(targetWi, sourceWorkItem, testCaseToRelatedWiMap);
                 const targets = sourceTargetsMap.get(sourceWorkItem) || [];
                 targets.push(targetWi);
@@ -460,13 +885,12 @@ class TicketsDataProvider {
                 columnsToShowMap.set(referenceName, name);
             }
         });
-        // Initialize maps
+        // Fetch all work items in parallel with concurrency limit
         const wiSet = new Set();
         if (workItems) {
-            for (const workItem of workItems) {
-                const wi = await this.fetchWIForQueryResult(workItem, columnsToShowMap, fieldsToIncludeMap, false);
-                wiSet.add(wi);
-            }
+            const fetchPromises = workItems.map((workItem) => this.limit(() => this.fetchWIForQueryResult(workItem, columnsToShowMap, fieldsToIncludeMap, false)));
+            const fetchedWorkItems = await Promise.all(fetchPromises);
+            fetchedWorkItems.forEach((wi) => wiSet.add(wi));
         }
         columnsToShowMap.clear();
         return {
@@ -1238,7 +1662,6 @@ class TicketsDataProvider {
                 logger_1.default.warn('No work item IDs extracted from query result');
                 return { categories: {}, totalCount: 0 };
             }
-            logger_1.default.debug(`Found ${workItemIds.length} work items to categorize`);
             // Define the mapping from requirement type keys to standard headers
             const typeToHeaderMap = {
                 Adaptation: 'Adaptation Requirements',
@@ -1289,25 +1712,20 @@ class TicketsDataProvider {
             for (const workItemId of workItemIds) {
                 try {
                     // Fetch full work item with all fields
-                    const wiUrl = `${this.orgUrl}_apis/wit/workitems/${workItemId}?$expand=All&api-version=6.0`;
+                    const wiUrl = `${this.orgUrl}_apis/wit/workitems/${workItemId}?$expand=All`;
                     const fullWi = await tfs_1.TFSServices.getItemContent(wiUrl, this.token);
                     // Check if it's a Requirement work item type
                     const workItemType = fullWi.fields['System.WorkItemType'];
-                    logger_1.default.debug(`Work item ${workItemId} type: ${workItemType}`);
                     if (workItemType !== 'Requirement') {
-                        logger_1.default.debug(`Skipping work item ${workItemId} - not a Requirement type`);
                         continue; // Skip non-requirement work items
                     }
-                    // Get the requirement type field (check both possible reference names)
-                    const rawRequirementType = fullWi.fields['Custom.Requirement_Type'] ||
-                        fullWi.fields['Microsoft.VSTS.CMMI.RequirementType'] ||
-                        '';
-                    logger_1.default.debug(`Work item ${workItemId} requirement type: "${rawRequirementType}"`);
+                    // Get the requirement type field
+                    const rawRequirementType = fullWi.fields['Microsoft.VSTS.CMMI.RequirementType'] || '';
                     // Normalize and trim the requirement type
                     const trimmedType = String(rawRequirementType).trim();
-                    // Map to standard header or use "Other Requirements" as default
-                    const categoryHeader = trimmedType
-                        ? typeToHeaderMap[trimmedType] || 'Other Requirements'
+                    // Map to the standard category header
+                    const categoryHeader = typeToHeaderMap[trimmedType]
+                        ? typeToHeaderMap[trimmedType]
                         : 'Other Requirements';
                     // Create the requirement object
                     const requirementItem = {