Power Platform QA Solution

Metadata
IDforall-loops-with-nested-filter
Result KeyforAllWithFilter
Fileforall-loops-with-nested-filter.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-loops-with-nested-filter.js · Input data reference ↗
Checking…
export default {
  name: "ForAll Loops with Nested Filter",
  description: "Detects ForAll loops that contain a Filter function call within the loop body, which may indicate an N+1 query pattern or inefficient data access that could be optimized.",
  resultKey: "forAllWithFilter",
  resultSchema: {
    keys: [
      { key: "name",        label: "Control",         suggestedFormat: "name-copy"   },
      { key: "property",    label: "Property",        suggestedFormat: "badge-info"  },
      { key: "type",        label: "Issue Type",      suggestedFormat: "deadcode-type" },
      { key: "confidence",  label: "Confidence",      suggestedFormat: "badge-confidence" },
      { key: "message",     label: "Description",     suggestedFormat: "truncate:120" },
      { key: "snippet",     label: "Formula Snippet", suggestedFormat: "code"        },
      { key: "locations",   label: "Locations",       suggestedFormat: "locations"   }
    ]
  },
 
  analyze(controlTree, refGraph, extraction) {
    const results = [];

    /**
     * Tokenise a Power Fx formula into a flat array of tokens.
     * We only need: identifiers, open-paren, close-paren, comma, string literals,
     * line comments, block comments – enough to walk call structure.
     */
    function tokenize(formula) {
      const tokens = [];
      let i = 0;
      const len = formula.length;

      while (i < len) {
        // Skip whitespace
        if (/\s/.test(formula[i])) { i++; continue; }

        // Line comment  //…
        if (formula[i] === '/' && formula[i + 1] === '/') {
          let j = i + 2;
          while (j < len && formula[j] !== '\n') j++;
          i = j;
          continue;
        }

        // Block comment  /*…*/
        if (formula[i] === '/' && formula[i + 1] === '*') {
          let j = i + 2;
          while (j < len && !(formula[j] === '*' && formula[j + 1] === '/')) j++;
          i = j + 2;
          continue;
        }

        // String literal  "…"  (with "" escape)
        if (formula[i] === '"') {
          let j = i + 1;
          while (j < len) {
            if (formula[j] === '"' && formula[j + 1] === '"') { j += 2; continue; }
            if (formula[j] === '"') { j++; break; }
            j++;
          }
          tokens.push({ type: 'string', value: formula.slice(i, j), pos: i });
          i = j;
          continue;
        }

        // Identifier / keyword  (including dots for chained calls)
        if (/[A-Za-z_]/.test(formula[i])) {
          let j = i;
          while (j < len && /[\w]/.test(formula[j])) j++;
          tokens.push({ type: 'ident', value: formula.slice(i, j), pos: i });
          i = j;
          continue;
        }

        // Single-character punctuation we care about
        if (formula[i] === '(') { tokens.push({ type: '(', pos: i }); i++; continue; }
        if (formula[i] === ')') { tokens.push({ type: ')', pos: i }); i++; continue; }
        if (formula[i] === ',') { tokens.push({ type: ',', pos: i }); i++; continue; }
        if (formula[i] === '.') { tokens.push({ type: '.', pos: i }); i++; continue; }

        // Everything else (operators, brackets, semicolons, …)
        tokens.push({ type: 'other', value: formula[i], pos: i });
        i++;
      }

      return tokens;
    }

    /**
     * Build a simple call-tree from tokens.
     * Each node: { fn: string, start: tokenIndex, end: tokenIndex, children: [] }
     * children = direct nested call nodes (not arbitrarily deep – we recurse).
     *
     * Returns an array of top-level call nodes.
     */
    function buildCallTree(tokens) {
      let pos = 0;

      function parseExpr() {
        const calls = [];
        while (pos < tokens.length) {
          const tok = tokens[pos];

          // End of a parent argument list
          if (tok.type === ')' || tok.type === ',') break;

          // Identifier immediately followed by '(' → function call
          if (tok.type === 'ident' && tokens[pos + 1] && tokens[pos + 1].type === '(') {
            const fnName = tok.value;
            const startPos = pos;
            pos += 2; // consume ident + '('

            // Parse arguments (comma-separated sub-expressions)
            const children = [];
            while (pos < tokens.length && tokens[pos].type !== ')') {
              const subCalls = parseExpr();
              children.push(...subCalls);
              if (pos < tokens.length && tokens[pos].type === ',') pos++; // consume comma
            }
            if (pos < tokens.length) pos++; // consume ')'

            calls.push({ fn: fnName, startPos, endPos: pos - 1, children });
          } else {
            pos++;
          }
        }
        return calls;
      }

      return parseExpr();
    }

    /**
     * Recursively search a call-tree for all nodes whose fn matches `targetName`
     * (case-insensitive).
     */
    function findCalls(nodes, targetName) {
      const found = [];
      for (const node of nodes) {
        if (node.fn.toLowerCase() === targetName.toLowerCase()) {
          found.push(node);
        }
        found.push(...findCalls(node.children, targetName));
      }
      return found;
    }

    /**
     * Given a ForAll call node, check whether its *second argument* (the loop
     * body / lambda) contains any Filter calls.
     *
     * Power Fx:  ForAll( <table> , <formula> )
     * The first argument is the data source; the second is the body.
     * We reconstruct the body tokens by finding the comma that separates arg1
     * from arg2 at the top level of this call, then look for Filter in arg2's
     * sub-calls.
     */
    function filterCallsInForAllBody(forAllNode) {
      // forAllNode.children contains ALL call-nodes found anywhere inside the
      // ForAll's argument list.  We need only those that appear in the *body*
      // (second argument) not in the table expression (first argument).
      //
      // Strategy: find the first top-level comma token between startPos+1
      // (opening paren) and endPos (closing paren), then restrict to children
      // whose startPos is beyond that comma.
      //
      // We don't have direct access to the token array here, but we can infer:
      // the children list already has all nested calls with their startPos.
      // The "first argument" calls will have smaller startPos values.
      //
      // Since we don't know the comma position, we use a simpler heuristic:
      // any Filter whose fn is a *direct* child is checked – if there are
      // multiple ForAll arguments, the Filter in the body will appear after
      // the first top-level data-source argument.  In practice we just return
      // all Filter children and let the caller decide.
      return findCalls(forAllNode.children, 'Filter');
    }

    /**
     * Extract a short readable snippet from the formula around a token position.
     */
    function extractSnippet(formula, approxCharPos, length = 120) {
      const start = Math.max(0, approxCharPos - 10);
      const end   = Math.min(formula.length, start + length);
      let snippet = formula.slice(start, end).replace(/\s+/g, ' ').trim();
      if (start > 0) snippet = '…' + snippet;
      if (end < formula.length) snippet = snippet + '…';
      return snippet;
    }

    // ── Main pass: iterate every formula in the app ──────────────────────────

    for (const { control, property, formula, file } of extraction.allFormulas) {
      if (!formula || formula.trim().length === 0) continue;

      // Quick pre-filter: both keywords must appear somewhere in the formula
      const lf = formula.toLowerCase();
      if (!lf.includes('forall') || !lf.includes('filter')) continue;

      let tokens;
      try {
        tokens = tokenize(formula);
      } catch {
        continue;
      }

      let callTree;
      try {
        callTree = buildCallTree(tokens);
      } catch {
        continue;
      }

      // Find every ForAll in the formula (including nested ones)
      const forAllNodes = findCalls(callTree, 'ForAll');
      if (forAllNodes.length === 0) continue;

      for (const forAllNode of forAllNodes) {
        const filterNodes = filterCallsInForAllBody(forAllNode);
        if (filterNodes.length === 0) continue;

        // Reconstruct approximate char position from token pos
        const forAllToken = tokens[forAllNode.startPos];
        const charPos     = forAllToken ? forAllToken.pos : 0;
        const snippet     = extractSnippet(formula, charPos, 150);

        // Build a readable list of Filter call locations
        const filterDescriptions = filterNodes
          .map(fn => {
            const ft = tokens[fn.startPos];
            return ft ? `Filter() at char ~${ft.pos}` : 'Filter()';
          })
          .join(', ');

        const filterCount = filterNodes.length;
        const plural      = filterCount === 1 ? '' : 's';

        results.push({
          name:       control,
          property,
          type:       'forall-nested-filter',
          confidence: 'high',
          message:    `ForAll loop contains ${filterCount} nested Filter call${plural} (${filterDescriptions}). `
                    + `This may cause repeated data-source queries for every iteration, leading to poor performance. `
                    + `Consider pre-fetching the filtered data into a collection before the ForAll, or restructuring using AddColumns / LookUp.`,
          snippet,
          locations: [{ control, property, file, snippet }]
        });
      }
    }

    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 Loops with Nested Filter CUSTOM

Test ForAll Loops with Nested Filter

Test results
