@elisra-devops/docgen-data-provider 1.63.13 → 1.68.0

package/bin/modules/TicketsDataProvider.d.ts

@@ -200,35 +200,78 @@ export default class TicketsDataProvider {
      * @returns Boolean indicating if the WIQL matches the area path conditions
      */
     private matchesAreaPathCondition;
+    private matchesSourceTargetConditionAsync;
+    private matchesFlatWorkItemTypeConditionAsync;
+    private buildQueryNode;
+    private getProjectFromQueryNode;
+    /**
+     * Normalizes allowed work item types into a lowercase set.
+     */
+    private normalizeAllowedTypes;
+    /**
+     * Returns true when every value in `found` exists in `allowed`.
+     */
+    private areAllAllowed;
     /**
-     * Determines whether the given WIQL (Work Item Query Language) string matches the specified
-     * source and target conditions. It checks if the WIQL contains references to the specified
-     * source and target work item types.
+     * Builds a regex-ready field selector for WIQL.
+     * - Link queries: Source/Target can appear as `Source.[...]` or `[Source].[...]`
+     * - Flat queries: no owner prefix, e.g. `[System.WorkItemType]`
+     */
+    private buildWiqlFieldPattern;
+    /**
+     * Extracts all quoted values used in `=` or `IN (...)` comparisons for a given field.
+     * Returned values are trimmed and lowercased.
      *
-     * Supports both equality (=) and IN operators:
-     * - Source.[System.WorkItemType] = 'Epic'
-     * - Source.[System.WorkItemType] IN ('Epic', 'Feature', 'Requirement')
+     * Examples:
+     * - `<field> = 'Epic'`
+     * - `<field> IN ('Epic','Feature')`
+     */
+    private extractQuotedValuesForField;
+    /**
+     * Extracts all numeric values used in `=` or `IN (...)` comparisons for a given field.
+     * Supports both quoted and unquoted numbers.
      *
-     * @returns A boolean indicating whether the WIQL includes at least one valid source work item type
-     *          and at least one valid target work item type.
+     * Examples:
+     * - `<field> = 123`
+     * - `<field> IN (123, '456')`
      */
-    private matchesSourceTargetCondition;
+    private extractNumericValuesForField;
     /**
-     * Helper method to check if a WIQL contains valid work item types for a given context (Source/Target).
-     * Supports both = and IN operators.
+     * Extracts work item IDs from WIQL.
+     * - Link queries: pass `context` to match `Source.[System.Id]` / `Target.[System.Id]` (with or without `[Source]`)
+     * - Flat queries: omit `context` to match `[System.Id]`
+     */
+    private extractWorkItemIdsFromWiql;
+    /**
+     * Determines if a link-query side (Source/Target) is allowed based on WIQL constraints.
      *
-     * @param wiql - The WIQL string to evaluate
-     * @param context - Either 'Source' or 'Target'
-     * @param allowedTypes - Array of allowed work item types
-     * @returns true if all work item types in the WIQL are in the allowedTypes array
+     * Rules:
+     * - If `allowedTypes` is empty: preserve legacy behavior by requiring that WorkItemType is present for that side.
+     * - If WIQL contains a WorkItemType constraint for that side: all specified types must be within `allowedTypes`.
+     * - Otherwise, if WIQL contains a System.Id constraint for that side: fetch the work item type(s) by id and validate.
+     * - Otherwise: reject.
      */
-    private matchesWorkItemTypeCondition;
-    private buildQueryNode;
+    private isLinkSideAllowedByTypeOrId;
     /**
-     * Matches flat query WIQL against allowed work item types.
-     * Accept when at least one type is present and all found types are within the allowed set.
+     * Determines if a flat query is allowed based on WIQL constraints.
+     *
+     * Rules:
+     * - If `allowedTypes` is empty: preserve legacy behavior by requiring that `[System.WorkItemType]` appears in WIQL.
+     * - If WIQL contains a WorkItemType constraint: all specified types must be within `allowedTypes`.
+     * - Otherwise, if WIQL contains `[System.Id]`: fetch the work item type(s) by id and validate.
+     * - Otherwise: reject.
      */
-    private matchesFlatWorkItemTypeCondition;
+    private isFlatQueryAllowedByTypeOrId;
+    /**
+     * Fetches the work item type for a given work item ID.
+     * Uses caching to avoid repeated API calls.
+     *
+     * @param project The project name
+     * @param id The work item ID
+     * @param workItemTypeCache The cache map for work item types
+     * @returns The work item type or null if not found
+     */
+    private getWorkItemTypeById;
     /**
      * Matches flat query WIQL against an area path filter by checking any referenced [System.AreaPath].
      * Compares only the leaf segment of the path and performs a case-insensitive substring match.
@@ -256,8 +299,4 @@ export default class TicketsDataProvider {
      * @returns An object containing the categorized requirements and total processed count.
      */
     GetCategorizedRequirementsByType(wiqlHref: string): Promise<any>;
-    /**
-     * Helper method to flatten a tree structure into a flat array of work items
-     */
-    private flattenTreeToWorkItems;
 }

package/bin/modules/TicketsDataProvider.js

@@ -1420,8 +1420,10 @@ class TicketsDataProvider {
      * @returns A promise resolving to an object with `tree1` and `tree2` nodes, or `null` for each when none match.
      * @throws Logs an error if an exception occurs during processing.
      */
-    async structureFetchedQueries(rootQuery, onlyTestReq, parentId = null, sources, targets, sourceAreaFilter, targetAreaFilter, includeTreeQueries = false, excludedFolderNames = [], includeFlatQueries = false) {
+    async structureFetchedQueries(rootQuery, onlyTestReq, parentId = null, sources, targets, sourceAreaFilter, targetAreaFilter, includeTreeQueries = false, excludedFolderNames = [], includeFlatQueries = false, workItemTypeCache) {
         try {
+            // Per-invocation cache for ID->WorkItemType lookups; avoids global state and is safe for concurrency.
+            const typeCache = workItemTypeCache !== null && workItemTypeCache !== void 0 ? workItemTypeCache : new Map();
             const shouldSkipFolder = (rootQuery === null || rootQuery === void 0 ? void 0 : rootQuery.isFolder) &&
                 excludedFolderNames.some((folderName) => folderName.toLowerCase() === (rootQuery.name || '').toLowerCase());
             if (shouldSkipFolder) {
@@ -1438,7 +1440,7 @@ class TicketsDataProvider {
                     let tree2Node = null;
                     if (rootQuery.queryType === 'flat' && includeFlatQueries) {
                         const allTypes = Array.from(new Set([...(sources || []), ...(targets || [])]));
-                        const typesOk = this.matchesFlatWorkItemTypeCondition(wiql, allTypes);
+                        const typesOk = await this.matchesFlatWorkItemTypeConditionAsync(rootQuery, wiql, allTypes, typeCache);
                         if (typesOk) {
                             const allowTree1 = !onlyTestReq &&
                                 (sourceAreaFilter ? this.matchesFlatAreaCondition(wiql, sourceAreaFilter || '') : true);
@@ -1454,7 +1456,12 @@ class TicketsDataProvider {
                         }
                     }
                     else {
-                        if (!onlyTestReq && this.matchesSourceTargetCondition(wiql, sources, targets)) {
+                        let matchesForward = false;
+                        if (!onlyTestReq) {
+                            matchesForward = await this.matchesSourceTargetConditionAsync(rootQuery, wiql, sources, targets, typeCache);
+                        }
+                        const matchesReverse = await this.matchesSourceTargetConditionAsync(rootQuery, wiql, targets, sources, typeCache);
+                        if (matchesForward) {
                             const matchesAreaPath = sourceAreaFilter || targetAreaFilter
                                 ? this.matchesAreaPathCondition(wiql, sourceAreaFilter || '', targetAreaFilter || '')
                                 : true;
@@ -1462,7 +1469,7 @@ class TicketsDataProvider {
                                 tree1Node = this.buildQueryNode(rootQuery, parentId);
                             }
                         }
-                        if (this.matchesSourceTargetCondition(wiql, targets, sources)) {
+                        if (matchesReverse) {
                             const matchesReverseAreaPath = sourceAreaFilter || targetAreaFilter
                                 ? this.matchesAreaPathCondition(wiql, targetAreaFilter || '', sourceAreaFilter || '')
                                 : true;
@@ -1481,12 +1488,13 @@ class TicketsDataProvider {
             if (!rootQuery.children) {
                 const queryUrl = `${rootQuery.url}?$depth=2&$expand=all`;
                 const currentQuery = await tfs_1.TFSServices.getItemContent(queryUrl, this.token);
-                return currentQuery
-                    ? await this.structureFetchedQueries(currentQuery, onlyTestReq, currentQuery.id, sources, targets, sourceAreaFilter, targetAreaFilter, includeTreeQueries, excludedFolderNames, includeFlatQueries)
-                    : { tree1: null, tree2: null };
+                if (!currentQuery) {
+                    return { tree1: null, tree2: null };
+                }
+                return await this.structureFetchedQueries(currentQuery, onlyTestReq, currentQuery.id, sources, targets, sourceAreaFilter, targetAreaFilter, includeTreeQueries, excludedFolderNames, includeFlatQueries, typeCache);
             }
             // Process children recursively
-            const childResults = await Promise.all(rootQuery.children.map((child) => this.structureFetchedQueries(child, onlyTestReq, rootQuery.id, sources, targets, sourceAreaFilter, targetAreaFilter, includeTreeQueries, excludedFolderNames, includeFlatQueries)));
+            const childResults = await Promise.all(rootQuery.children.map((child) => this.structureFetchedQueries(child, onlyTestReq, rootQuery.id, sources, targets, sourceAreaFilter, targetAreaFilter, includeTreeQueries, excludedFolderNames, includeFlatQueries, typeCache)));
             // Build tree1
             const tree1Children = childResults.map((res) => res.tree1).filter((child) => child !== null);
             const tree1Node = tree1Children.length > 0
@@ -1528,7 +1536,8 @@ class TicketsDataProvider {
         const srcFilter = (sourceAreaFilter || '').toLowerCase().trim();
         const tgtFilter = (targetAreaFilter || '').toLowerCase().trim();
         const extractAreaPaths = (owner) => {
-            const re = new RegExp(`${owner}\\.\\[system\\.areapath\\][^']*'([^']+)'`, 'gi');
+            const ownerPattern = `(?:${owner}|\\[${owner}\\])`;
+            const re = new RegExp(`${ownerPattern}\\.\\[system\\.areapath\\][^']*'([^']+)'`, 'gi');
             const results = [];
             let match;
             while ((match = re.exec(wiqlLower)) !== null) {
@@ -1548,73 +1557,21 @@ class TicketsDataProvider {
         const hasTargetAreaPath = !tgtFilter || targetAreaPaths.some((p) => getLeaf(p).includes(tgtFilter));
         return hasSourceAreaPath && hasTargetAreaPath;
     }
-    /**
-     * Determines whether the given WIQL (Work Item Query Language) string matches the specified
-     * source and target conditions. It checks if the WIQL contains references to the specified
-     * source and target work item types.
-     *
-     * Supports both equality (=) and IN operators:
-     * - Source.[System.WorkItemType] = 'Epic'
-     * - Source.[System.WorkItemType] IN ('Epic', 'Feature', 'Requirement')
-     *
-     * @returns A boolean indicating whether the WIQL includes at least one valid source work item type
-     *          and at least one valid target work item type.
-     */
-    matchesSourceTargetCondition(wiql, source, target) {
-        const isSourceIncluded = this.matchesWorkItemTypeCondition(wiql, 'Source', source);
-        const isTargetIncluded = this.matchesWorkItemTypeCondition(wiql, 'Target', target);
-        return isSourceIncluded && isTargetIncluded;
-    }
-    /**
-     * Helper method to check if a WIQL contains valid work item types for a given context (Source/Target).
-     * Supports both = and IN operators.
-     *
-     * @param wiql - The WIQL string to evaluate
-     * @param context - Either 'Source' or 'Target'
-     * @param allowedTypes - Array of allowed work item types
-     * @returns true if all work item types in the WIQL are in the allowedTypes array
-     */
-    matchesWorkItemTypeCondition(wiql, context, allowedTypes) {
-        const wiqlStr = String(wiql || '');
-        // If allowedTypes is empty, accept any work item type (for backward compatibility)
-        if (!allowedTypes || allowedTypes.length === 0) {
-            const fieldPresenceRegex = new RegExp(`${context}\\.\\[System.WorkItemType\\]`, 'i');
-            return fieldPresenceRegex.test(wiqlStr);
-        }
-        const fieldPattern = `${context}.\\[System.WorkItemType\\]`;
-        // Pattern for equality: Source.[System.WorkItemType] = 'Epic'
-        const equalityRegex = new RegExp(`${fieldPattern}\\s*=\\s*'([^']+)'`, 'gi');
-        // Pattern for IN operator: Source.[System.WorkItemType] IN ('Epic', 'Feature', 'Requirement')
-        const inRegex = new RegExp(`${fieldPattern}\\s+IN\\s*\\(([^)]+)\\)`, 'gi');
-        const foundTypes = new Set();
-        let match;
-        // Extract types from equality operators
-        while ((match = equalityRegex.exec(wiqlStr)) !== null) {
-            foundTypes.add(String(match[1]).trim().toLowerCase());
-        }
-        // Extract types from IN operators
-        while ((match = inRegex.exec(wiqlStr)) !== null) {
-            const typesString = match[1];
-            // Extract all quoted values from the IN clause
-            const typeMatches = typesString.matchAll(/'([^']+)'/g);
-            for (const typeMatch of typeMatches) {
-                foundTypes.add(String(typeMatch[1]).trim().toLowerCase());
-            }
-        }
-        // If no work item types found in WIQL, return false
-        if (foundTypes.size === 0) {
+    async matchesSourceTargetConditionAsync(queryNode, wiql, source, target, workItemTypeCache) {
+        /**
+         * Matches source+target constraints for link WIQL.
+         * For each side (Source/Target) we accept either:
+         * - explicit `[System.WorkItemType]` constraints (all types must be within the allowed list), or
+         * - explicit `[System.Id]` constraints when no type constraint exists (type is fetched by id and validated).
+         */
+        const sourceOk = await this.isLinkSideAllowedByTypeOrId(queryNode, wiql, 'Source', source, workItemTypeCache);
+        if (!sourceOk)
             return false;
-        }
-        // Check if all found types are in the allowedTypes array (case-insensitive)
-        const allowedSet = new Set(allowedTypes.map((t) => String(t).toLowerCase()));
-        for (const type of foundTypes) {
-            if (!allowedSet.has(type)) {
-                // Found a type that's not in the allowed list - reject this query
-                return false;
-            }
-        }
-        // All found types are valid
-        return true;
+        const targetOk = await this.isLinkSideAllowedByTypeOrId(queryNode, wiql, 'Target', target, workItemTypeCache);
+        return targetOk;
+    }
+    async matchesFlatWorkItemTypeConditionAsync(queryNode, wiql, allowedTypes, workItemTypeCache) {
+        return this.isFlatQueryAllowedByTypeOrId(queryNode, wiql, allowedTypes, workItemTypeCache);
     }
     // Build a normalized node object for tree outputs
     buildQueryNode(rootQuery, parentId) {
@@ -1630,38 +1587,205 @@ class TicketsDataProvider {
             isValidQuery: true,
         };
     }
+    getProjectFromQueryNode(queryNode) {
+        var _a, _b, _c, _d, _e, _f;
+        const href = ((_b = (_a = queryNode === null || queryNode === void 0 ? void 0 : queryNode._links) === null || _a === void 0 ? void 0 : _a.wiql) === null || _b === void 0 ? void 0 : _b.href) ||
+            ((_d = (_c = queryNode === null || queryNode === void 0 ? void 0 : queryNode._links) === null || _c === void 0 ? void 0 : _c.self) === null || _d === void 0 ? void 0 : _d.href) ||
+            (queryNode === null || queryNode === void 0 ? void 0 : queryNode.url) ||
+            ((_f = (_e = queryNode === null || queryNode === void 0 ? void 0 : queryNode._links) === null || _e === void 0 ? void 0 : _e.html) === null || _f === void 0 ? void 0 : _f.href);
+        if (!href)
+            return null;
+        return this.getProjectFromWiqlHref(String(href));
+    }
     /**
-     * Matches flat query WIQL against allowed work item types.
-     * Accept when at least one type is present and all found types are within the allowed set.
+     * Normalizes allowed work item types into a lowercase set.
      */
-    matchesFlatWorkItemTypeCondition(wiql, allowedTypes) {
-        // If allowedTypes is empty, accept any work item type reference
-        if (!allowedTypes || allowedTypes.length === 0) {
-            return /\[System\.WorkItemType\]/i.test(wiql || '');
+    normalizeAllowedTypes(allowedTypes) {
+        return new Set((allowedTypes || []).map((t) => String(t).trim().toLowerCase()).filter(Boolean));
+    }
+    /**
+     * Returns true when every value in `found` exists in `allowed`.
+     */
+    areAllAllowed(found, allowed) {
+        for (const v of found) {
+            if (!allowed.has(v))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Builds a regex-ready field selector for WIQL.
+     * - Link queries: Source/Target can appear as `Source.[...]` or `[Source].[...]`
+     * - Flat queries: no owner prefix, e.g. `[System.WorkItemType]`
+     */
+    buildWiqlFieldPattern(owner, fieldRef) {
+        const escapedField = String(fieldRef).replace(/\./g, '\\.');
+        if (!owner) {
+            return `\\[${escapedField}\\]`;
         }
+        const ownerPattern = `(?:${owner}|\\[${owner}\\])`;
+        return `${ownerPattern}\\.\\[${escapedField}\\]`;
+    }
+    /**
+     * Extracts all quoted values used in `=` or `IN (...)` comparisons for a given field.
+     * Returned values are trimmed and lowercased.
+     *
+     * Examples:
+     * - `<field> = 'Epic'`
+     * - `<field> IN ('Epic','Feature')`
+     */
+    extractQuotedValuesForField(wiql, fieldPattern) {
         const wiqlStr = String(wiql || '');
-        const eqRe = /\[System\.WorkItemType\]\s*=\s*'([^']+)'/gi;
-        const inRe = /\[System\.WorkItemType\]\s+IN\s*\(([^)]+)\)/gi;
         const found = new Set();
-        let m;
-        while ((m = eqRe.exec(wiqlStr)) !== null) {
-            found.add(m[1].trim().toLowerCase());
+        const eqRe = new RegExp(`${fieldPattern}\\s*=\\s*'([^']+)'`, 'gi');
+        const inRe = new RegExp(`${fieldPattern}\\s+IN\\s*\\(([^)]+)\\)`, 'gi');
+        let match;
+        while ((match = eqRe.exec(wiqlStr)) !== null) {
+            found.add(String(match[1]).trim().toLowerCase());
         }
-        while ((m = inRe.exec(wiqlStr)) !== null) {
-            const inner = m[1];
+        while ((match = inRe.exec(wiqlStr)) !== null) {
+            const inner = String(match[1] || '');
             for (const mm of inner.matchAll(/'([^']+)'/g)) {
                 found.add(String(mm[1]).trim().toLowerCase());
             }
         }
-        if (found.size === 0)
+        return found;
+    }
+    /**
+     * Extracts all numeric values used in `=` or `IN (...)` comparisons for a given field.
+     * Supports both quoted and unquoted numbers.
+     *
+     * Examples:
+     * - `<field> = 123`
+     * - `<field> IN (123, '456')`
+     */
+    extractNumericValuesForField(wiql, fieldPattern) {
+        const wiqlStr = String(wiql || '');
+        const found = new Set();
+        const eqRe = new RegExp(`${fieldPattern}\\s*=\\s*'?([0-9]+)'?`, 'gi');
+        const inRe = new RegExp(`${fieldPattern}\\s+IN\\s*\\(([^)]+)\\)`, 'gi');
+        let match;
+        while ((match = eqRe.exec(wiqlStr)) !== null) {
+            found.add(String(match[1]));
+        }
+        while ((match = inRe.exec(wiqlStr)) !== null) {
+            const inner = String(match[1] || '');
+            for (const mm of inner.matchAll(/'?([0-9]+)'?/g)) {
+                found.add(String(mm[1]));
+            }
+        }
+        return found;
+    }
+    /**
+     * Extracts work item IDs from WIQL.
+     * - Link queries: pass `context` to match `Source.[System.Id]` / `Target.[System.Id]` (with or without `[Source]`)
+     * - Flat queries: omit `context` to match `[System.Id]`
+     */
+    extractWorkItemIdsFromWiql(wiql, context) {
+        const fieldPattern = this.buildWiqlFieldPattern(context !== null && context !== void 0 ? context : null, 'System.Id');
+        return [...this.extractNumericValuesForField(String(wiql || ''), fieldPattern).values()];
+    }
+    /**
+     * Determines if a link-query side (Source/Target) is allowed based on WIQL constraints.
+     *
+     * Rules:
+     * - If `allowedTypes` is empty: preserve legacy behavior by requiring that WorkItemType is present for that side.
+     * - If WIQL contains a WorkItemType constraint for that side: all specified types must be within `allowedTypes`.
+     * - Otherwise, if WIQL contains a System.Id constraint for that side: fetch the work item type(s) by id and validate.
+     * - Otherwise: reject.
+     */
+    async isLinkSideAllowedByTypeOrId(queryNode, wiql, context, allowedTypes, workItemTypeCache) {
+        const wiqlStr = String(wiql || '');
+        // Preserve existing behavior when no allowedTypes are provided.
+        if (!allowedTypes || allowedTypes.length === 0) {
+            const fieldPresenceRegex = new RegExp(`${this.buildWiqlFieldPattern(context, 'System.WorkItemType')}`, 'i');
+            return fieldPresenceRegex.test(wiqlStr);
+        }
+        const allowed = this.normalizeAllowedTypes(allowedTypes);
+        const typeFieldPattern = this.buildWiqlFieldPattern(context, 'System.WorkItemType');
+        const typesInWiql = this.extractQuotedValuesForField(wiqlStr, typeFieldPattern);
+        if (typesInWiql.size > 0) {
+            return this.areAllAllowed(typesInWiql, allowed);
+        }
+        const ids = this.extractWorkItemIdsFromWiql(wiqlStr, context);
+        if (ids.length === 0)
+            return false;
+        const project = this.getProjectFromQueryNode(queryNode);
+        if (!project)
+            return false;
+        for (const id of ids) {
+            const wiType = await this.getWorkItemTypeById(project, id, workItemTypeCache);
+            if (!wiType)
+                return false;
+            if (!allowed.has(String(wiType).toLowerCase()))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Determines if a flat query is allowed based on WIQL constraints.
+     *
+     * Rules:
+     * - If `allowedTypes` is empty: preserve legacy behavior by requiring that `[System.WorkItemType]` appears in WIQL.
+     * - If WIQL contains a WorkItemType constraint: all specified types must be within `allowedTypes`.
+     * - Otherwise, if WIQL contains `[System.Id]`: fetch the work item type(s) by id and validate.
+     * - Otherwise: reject.
+     */
+    async isFlatQueryAllowedByTypeOrId(queryNode, wiql, allowedTypes, workItemTypeCache) {
+        const wiqlStr = String(wiql || '');
+        // Preserve existing behavior when no allowedTypes are provided.
+        if (!allowedTypes || allowedTypes.length === 0) {
+            return /\[System\.WorkItemType\]/i.test(wiqlStr);
+        }
+        const allowed = this.normalizeAllowedTypes(allowedTypes);
+        const typeFieldPattern = this.buildWiqlFieldPattern(null, 'System.WorkItemType');
+        const typesInWiql = this.extractQuotedValuesForField(wiqlStr, typeFieldPattern);
+        if (typesInWiql.size > 0) {
+            return this.areAllAllowed(typesInWiql, allowed);
+        }
+        const ids = this.extractWorkItemIdsFromWiql(wiqlStr);
+        if (ids.length === 0)
             return false;
-        const allowed = new Set(allowedTypes.map((t) => String(t).toLowerCase()));
-        for (const t of found) {
-            if (!allowed.has(t))
+        const project = this.getProjectFromQueryNode(queryNode);
+        if (!project)
+            return false;
+        for (const id of ids) {
+            const wiType = await this.getWorkItemTypeById(project, id, workItemTypeCache);
+            if (!wiType)
+                return false;
+            if (!allowed.has(String(wiType).toLowerCase()))
                 return false;
         }
         return true;
     }
+    /**
+     * Fetches the work item type for a given work item ID.
+     * Uses caching to avoid repeated API calls.
+     *
+     * @param project The project name
+     * @param id The work item ID
+     * @param workItemTypeCache The cache map for work item types
+     * @returns The work item type or null if not found
+     */
+    async getWorkItemTypeById(project, id, workItemTypeCache) {
+        var _a, _b;
+        const cacheKey = `${project}:${id}`;
+        if (workItemTypeCache.has(cacheKey)) {
+            return (_a = workItemTypeCache.get(cacheKey)) !== null && _a !== void 0 ? _a : null;
+        }
+        try {
+            const url = `${this.orgUrl}${project}/_apis/wit/workitems/${id}?fields=System.WorkItemType`;
+            const wi = await this.limit(() => tfs_1.TFSServices.getItemContent(url, this.token));
+            const wiType = (_b = wi === null || wi === void 0 ? void 0 : wi.fields) === null || _b === void 0 ? void 0 : _b['System.WorkItemType'];
+            const normalized = wiType ? String(wiType) : null;
+            workItemTypeCache.set(cacheKey, normalized);
+            return normalized;
+        }
+        catch (e) {
+            workItemTypeCache.set(cacheKey, null);
+            return null;
+        }
+    }
     /**
      * Matches flat query WIQL against an area path filter by checking any referenced [System.AreaPath].
      * Compares only the leaf segment of the path and performs a case-insensitive substring match.
@@ -1919,28 +2043,6 @@ class TicketsDataProvider {
             throw err;
         }
     }
-    /**
-     * Helper method to flatten a tree structure into a flat array of work items
-     */
-    flattenTreeToWorkItems(roots) {
-        const result = [];
-        const traverse = (node) => {
-            if (!node)
-                return;
-            result.push({
-                id: node.id,
-                title: node.title,
-                description: node.description,
-                htmlUrl: node.htmlUrl,
-                url: node.htmlUrl, // Some nodes might use url instead
-            });
-            if (Array.isArray(node.children)) {
-                node.children.forEach(traverse);
-            }
-        };
-        roots.forEach(traverse);
-        return result;
-    }
 }
 exports.default = TicketsDataProvider;
 //# sourceMappingURL=TicketsDataProvider.js.map