Power Platform QA Solution

Metadata

IDforall-data-source-modifications

Result KeyforAllDataSourceMods

Fileforall-data-source-modifications.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

forall-data-source-modifications.js · Input data reference ↗

Checking…

export default {
  name: "ForAll Data Source Modifications",
  description: "Detects ForAll loops that make individual data source modifications instead of batch operations",
  resultKey: "forAllDataSourceMods",
  resultSchema: {
    keys: [
      { key: "name", label: "Control", suggestedFormat: "name-copy" },
      { key: "type", label: "Type", suggestedFormat: "badge-info" },
      { key: "message", label: "Issue", suggestedFormat: "text" },
      { key: "locations", label: "Locations", suggestedFormat: "locations" },
      { key: "confidence", label: "Confidence", suggestedFormat: "badge-confidence" }
    ]
  },

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

    // Helper function to check if an identifier looks like a local collection
    function isLocalCollection(name) {
      return /^(col|loc)[A-Z]/.test(name) || name.toLowerCase().startsWith('temp');
    }

    // Helper function to parse ForAll expressions with bracket awareness
    function parseForAll(formula) {
      const forAllMatches = [];
      let pos = 0;
      
      while (pos < formula.length) {
        const match = formula.slice(pos).match(/\bForAll\s*\(/i);
        if (!match) break;
        
        const startPos = pos + match.index;
        const openParenPos = startPos + match[0].length - 1;
        
        // Parse the ForAll arguments with bracket awareness
        let depth = 1;
        let currentPos = openParenPos + 1;
        let args = [];
        let currentArg = '';
        let inString = false;
        let stringChar = null;
        
        while (currentPos < formula.length && depth > 0) {
          const char = formula[currentPos];
          
          if (inString) {
            currentArg += char;
            if (char === stringChar && formula[currentPos - 1] !== '\\') {
              inString = false;
              stringChar = null;
            }
          } else {
            if (char === '"' || char === "'") {
              inString = true;
              stringChar = char;
              currentArg += char;
            } else if (char === '(') {
              depth++;
              currentArg += char;
            } else if (char === ')') {
              depth--;
              if (depth === 0) {
                if (currentArg.trim()) args.push(currentArg.trim());
              } else {
                currentArg += char;
              }
            } else if (char === ',' && depth === 1) {
              args.push(currentArg.trim());
              currentArg = '';
            } else {
              currentArg += char;
            }
          }
          currentPos++;
        }
        
        if (args.length >= 2) {
          const source = args[0].trim();
          const body = args[1].trim();
          
          forAllMatches.push({
            startPos,
            endPos: currentPos - 1,
            source,
            body,
            fullMatch: formula.slice(startPos, currentPos)
          });
        }
        
        pos = currentPos;
      }
      
      return forAllMatches;
    }

    // Helper function to find data modification operations in ForAll body
    function findDataModifications(body) {
      const operations = [];
      
      // Look for Patch, Remove, Collect, Update operations
      const operationRegex = /\b(Patch|Remove|Collect|Update)\s*\(/gi;
      let match;
      
      while ((match = operationRegex.exec(body)) !== null) {
        const operation = match[1];
        const startPos = match.index;
        
        // Extract the target (first argument)
        let pos = match.index + match[0].length;
        let depth = 1;
        let target = '';
        let inString = false;
        let stringChar = null;
        
        while (pos < body.length && depth > 0) {
          const char = body[pos];
          
          if (inString) {
            target += char;
            if (char === stringChar && body[pos - 1] !== '\\') {
              inString = false;
              stringChar = null;
            }
          } else {
            if (char === '"' || char === "'") {
              inString = true;
              stringChar = char;
              target += char;
            } else if (char === '(') {
              depth++;
              target += char;
            } else if (char === ')') {
              depth--;
              if (depth > 0) target += char;
            } else if (char === ',' && depth === 1) {
              break;
            } else {
              target += char;
            }
          }
          pos++;
        }
        
        target = target.trim();
        
        // Skip if target looks like a local collection
        const targetName = target.split('.')[0].split('[')[0].trim();
        if (!isLocalCollection(targetName)) {
          operations.push({
            operation,
            target: targetName,
            startPos,
            fullTarget: target
          });
        }
      }
      
      return operations;
    }

    // Helper function to estimate amplification factor
    function getAmplificationFactor(source) {
      // Look for Sequence with numeric literal
      const sequenceMatch = source.match(/\bSequence\s*\(\s*(\d+)/i);
      if (sequenceMatch) {
        return parseInt(sequenceMatch[1], 10);
      }
      
      // Look for other numeric patterns that might indicate size
      const numericMatch = source.match(/\b(\d+)\b/);
      if (numericMatch) {
        const num = parseInt(numericMatch[1], 10);
        if (num > 1 && num < 10000) { // Reasonable bounds
          return num;
        }
      }
      
      return null;
    }

    // Analyze all formulas
    for (const formulaInfo of extraction.allFormulas) {
      const { control, property, formula, file } = formulaInfo;
      
      if (!formula || typeof formula !== 'string') continue;
      
      const forAllMatches = parseForAll(formula);
      
      for (const forAllMatch of forAllMatches) {
        const { source, body, fullMatch } = forAllMatch;
        const modifications = findDataModifications(body);
        
        if (modifications.length > 0) {
          const amplificationFactor = getAmplificationFactor(source);
          const isSequencePattern = /\bSequence\s*\(/i.test(source);
          
          let message = `ForAll loop performs individual ${modifications.map(m => m.operation).join(', ')} operations against data source(s): ${modifications.map(m => m.target).join(', ')}`;
          
          if (isSequencePattern) {
            message += '. This pattern iterates a Sequence and should be replaced with batch operations';
          }
          
          if (amplificationFactor) {
            message += `. Estimated ${amplificationFactor}x request amplification`;
          }
          
          message += '. Consider using a single batch Patch with a shaped table of records to reduce network requests and improve performance.';
          
          results.push({
            name: control,
            type: "forall-data-modification",
            message,
            locations: [{
              control,
              property,
              file,
              snippet: fullMatch.length > 100 ? fullMatch.substring(0, 97) + '...' : fullMatch
            }],
            confidence: "high"
          });
        }
      }
    }

    return results;
  }
};

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 — ForAll Data Source Modifications CUSTOM

Test ForAll Data Source Modifications

Test results