Power Platform QA Solution

Metadata
IDgallery-lookupfilter-performance-issues
Result KeygalleryLookupPerformance
Filegallery-lookupfilter-performance-issues.js
Built-inNo
Analyzer Classification
Category — This determines the type of Analyzer you are building. Categories can be set up under settings.
Test sets — Include this analyzer in predefined runs. Select one or more test sets this analyzer should belong to.
Dataverse test set Some tests
Description
Prompt
Provider
Source Code
gallery-lookupfilter-performance-issues.js · Input data reference ↗
Checking…
/**
 * Analyzer for detecting lookup/filter functions in gallery item properties
 * This is a serious performance issue as these functions execute for every gallery item
 */
export default {
  name: "Gallery Lookup/Filter Performance Issues",
  description: "Detects lookup or filter functions used in gallery item properties that can cause severe performance degradation",
  resultKey: "galleryLookupPerformance",
  resultSchema: {
    keys: [
      { key: 'name',              label: 'Name',              suggestedFormat: 'name-copy' },
      { key: 'type',              label: 'Type',              suggestedFormat: 'badge-info' },
      { key: 'confidence',        label: 'Confidence',        suggestedFormat: 'badge-confidence' },
      { key: 'message',           label: 'Details',           suggestedFormat: 'text-sm' },
      { key: 'locations',         label: 'Locations',         suggestedFormat: 'locations' },
      { key: 'galleryControl',    label: 'Gallery',           suggestedFormat: 'code' },
      { key: 'detectedFunctions', label: 'Detected Functions', suggestedFormat: 'text-sm' }
    ]
  },

  analyze(controlTree, refGraph, extraction) {
    const results = [];

    // Patterns to detect lookup and filter functions
    // These patterns match common PowerApps lookup/filter function calls
    const lookupFilterPatterns = [
      /\bLookUp\s*\(/gi,           // LookUp function
      /\bFilter\s*\(/gi,           // Filter function
      /\bFirst\s*\(\s*Filter\s*\(/gi,  // First(Filter(...)) pattern
      /\bLast\s*\(\s*Filter\s*\(/gi,   // Last(Filter(...)) pattern
      /\bCountRows\s*\(\s*Filter\s*\(/gi, // CountRows(Filter(...)) pattern
      /\bSum\s*\(\s*Filter\s*\(/gi,    // Sum(Filter(...)) pattern
      /\bMax\s*\(\s*Filter\s*\(/gi,    // Max(Filter(...)) pattern
      /\bMin\s*\(\s*Filter\s*\(/gi,    // Min(Filter(...)) pattern
      /\bAverage\s*\(\s*Filter\s*\(/gi // Average(Filter(...)) pattern
    ];

    // Iterate through all formulas to find gallery-related ones
    for (const formulaData of extraction.allFormulas) {
      const { control, property, formula, file } = formulaData;
      
      // Skip if no formula text
      if (!formula || typeof formula !== 'string') {
        continue;
      }

      // Find the control node to check if it's in a gallery context
      const controlNode = controlTree.nodeIndex.get(control);
      if (!controlNode) {
        continue;
      }

      // Check if this control is inside a gallery or is a gallery itself
      const galleryContext = this.findGalleryContext(controlNode, controlTree);
      if (!galleryContext) {
        continue;
      }

      // Check if the formula contains any lookup/filter patterns
      const matchedPatterns = this.findMatchingPatterns(formula, lookupFilterPatterns);
      
      if (matchedPatterns.length > 0) {
        // Create a result for this performance issue
        const result = {
          name: `${control}.${property}`,
          type: "gallery-lookup-filter",
          message: `Gallery item property uses ${matchedPatterns.join(', ')} which executes for every gallery item. This causes severe performance degradation with large datasets. Consider moving the lookup to the gallery's Items property or using delegation-friendly approaches.`,
          locations: [{
            control: control,
            property: property,
            file: file,
            snippet: this.extractRelevantSnippet(formula, matchedPatterns[0])
          }],
          confidence: 'high',
          // Additional context for the result
          galleryControl: galleryContext.name,
          detectedFunctions: matchedPatterns
        };
        
        results.push(result);
      }
    }

    return results;
  },

  /**
   * Find if a control is within a gallery context
   * @param {Object} controlNode - The control node to check
   * @param {Object} controlTree - The control tree structure
   * @returns {Object|null} - Gallery context info or null if not in gallery
   */
  findGalleryContext(controlNode, controlTree) {
    // Check if the control itself is a gallery
    if (controlNode.type === 'Gallery' || controlNode.baseType === 'Gallery') {
      return {
        name: controlNode.name,
        type: 'self',
        isGallery: true
      };
    }

    // Traverse up the parent chain to find a gallery
    let currentNode = controlNode;
    
    // Look for parent gallery by checking the control tree structure
    // Since we don't have direct parent references, we need to search through the tree
    for (const screen of controlTree.screens) {
      const galleryContext = this.searchForGalleryParent(currentNode, screen);
      if (galleryContext) {
        return galleryContext;
      }
    }

    // Also check components if the control might be in a component
    for (const component of controlTree.components) {
      const galleryContext = this.searchForGalleryParent(currentNode, component);
      if (galleryContext) {
        return galleryContext;
      }
    }

    return null;
  },

  /**
   * Recursively search for a gallery parent in the control hierarchy
   * @param {Object} targetNode - The node we're looking for
   * @param {Object} parentNode - Current parent node to search within
   * @returns {Object|null} - Gallery context if found
   */
  searchForGalleryParent(targetNode, parentNode) {
    // Check if current parent is a gallery and contains our target
    if ((parentNode.type === 'Gallery' || parentNode.baseType === 'Gallery')) {
      if (this.isNodeDescendant(targetNode, parentNode)) {
        return {
          name: parentNode.name,
          type: 'parent',
          isGallery: true
        };
      }
    }

    // Recursively check children
    if (parentNode.children && parentNode.children.length > 0) {
      for (const child of parentNode.children) {
        const result = this.searchForGalleryParent(targetNode, child);
        if (result) {
          return result;
        }
      }
    }

    return null;
  },

  /**
   * Check if a node is a descendant of another node
   * @param {Object} targetNode - Node to find
   * @param {Object} ancestorNode - Potential ancestor node
   * @returns {boolean} - True if target is descendant of ancestor
   */
  isNodeDescendant(targetNode, ancestorNode) {
    if (!ancestorNode.children) {
      return false;
    }

    // Direct child check
    if (ancestorNode.children.some(child => child.name === targetNode.name)) {
      return true;
    }

    // Recursive descendant check
    return ancestorNode.children.some(child => 
      this.isNodeDescendant(targetNode, child)
    );
  },

  /**
   * Find which lookup/filter patterns match in the formula
   * @param {string} formula - The formula text to analyze
   * @param {RegExp[]} patterns - Array of regex patterns to test
   * @returns {string[]} - Array of matched function names
   */
  findMatchingPatterns(formula, patterns) {
    const matches = [];
    
    for (const pattern of patterns) {
      const match = formula.match(pattern);
      if (match) {
        // Extract the function name from the match
        const functionName = match[0].replace(/\s*\(/gi, '').trim();
        if (!matches.includes(functionName)) {
          matches.push(functionName);
        }
      }
    }
    
    return matches;
  },

  /**
   * Extract a relevant snippet around the matched pattern
   * @param {string} formula - The full formula text
   * @param {string} matchedFunction - The matched function name
   * @returns {string} - A snippet showing the problematic code
   */
  extractRelevantSnippet(formula, matchedFunction) {
    const index = formula.toLowerCase().indexOf(matchedFunction.toLowerCase());
    if (index === -1) {
      return formula.substring(0, 100) + (formula.length > 100 ? '...' : '');
    }
    
    // Extract context around the match (50 chars before, 100 chars after)
    const start = Math.max(0, index - 50);
    const end = Math.min(formula.length, index + matchedFunction.length + 100);
    
    let snippet = formula.substring(start, end);
    
    // Add ellipsis if we truncated
    if (start > 0) snippet = '...' + snippet;
    if (end < formula.length) snippet = snippet + '...';
    
    return snippet;
  }
};
Report Output Columns
Columns shown in the generated report. Toggle off to hide; pick a declared key or use "Custom…" for dot-paths like locations.0.file.
Enabled	Key	Label	Format	Width
Configure Analyzer — Gallery Lookup/Filter Performance Issues CUSTOM

Test Gallery Lookup/Filter Performance Issues

Test results
