Power Platform QA Solution

Metadata

IDonstart-variables-that-could-be-named-formulas

Result KeyonStartVariablesToFormulas

Fileonstart-variables-that-could-be-named-formulas.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

onstart-variables-that-could-be-named-formulas.js · Input data reference ↗

Checking…

export default {
  name: "OnStart Variables That Could Be Named Formulas",
  description: "Finds variables set in OnStart that are never reassigned and could be converted to named formulas for better performance",
  resultKey: "onStartVariablesToFormulas",
  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' }
    ]
  },

  analyze(controlTree, refGraph, extraction) {
    const results = [];
    
    if (!controlTree.appNode) {
      return results;
    }
    
    const onStartFormula = controlTree.appNode.formulas.get('OnStart');
    if (!onStartFormula) {
      return results;
    }
    
    // Find all variable assignments in OnStart
    const onStartVarWrites = new Set();
    for (const [varName, writes] of extraction.variableWrites) {
      for (const write of writes) {
        if (write.control === controlTree.appNode.name && write.property === 'OnStart') {
          onStartVarWrites.add(varName);
        }
      }
    }
    
    if (onStartVarWrites.size === 0) {
      return results;
    }
    
    // Check each variable to see if it's only written in OnStart
    for (const varName of onStartVarWrites) {
      const allWrites = extraction.variableWrites.get(varName) || [];
      
      // Check if all writes are in OnStart
      const onlyWrittenInOnStart = allWrites.every(write => 
        write.control === controlTree.appNode.name && write.property === 'OnStart'
      );
      
      if (onlyWrittenInOnStart) {
        // Check if the variable is actually read somewhere
        const isRead = refGraph.variablesRead.has(varName);
        
        if (isRead) {
          // Find the specific Set statements in OnStart
          const onStartWrites = allWrites.filter(write => 
            write.control === controlTree.appNode.name && write.property === 'OnStart'
          );
          
          // Check if the variable appears to be set to a constant or calculated value
          // (as opposed to being used for accumulation or complex state management)
          const appearsToBeConstant = this.isLikelyConstantAssignment(onStartWrites, onStartFormula);
          
          if (appearsToBeConstant) {
            results.push({
              name: varName,
              type: "onstart-variable-to-formula",
              message: `Variable '${varName}' is only set in OnStart and never reassigned. Consider converting to a named formula for better performance.`,
              locations: onStartWrites.map(write => ({
                control: write.control,
                property: write.property,
                file: write.file,
                snippet: write.snippet
              })),
              confidence: 'medium'
            });
          }
        }
      }
    }
    
    return results;
  },
  
  isLikelyConstantAssignment(writes, onStartFormula) {
    // Simple heuristics to determine if a variable assignment looks like it could be a formula
    for (const write of writes) {
      const snippet = write.snippet || '';
      
      // Skip if it appears to be part of a loop or conditional logic that might reassign
      if (this.containsControlFlow(snippet, onStartFormula)) {
        return false;
      }
      
      // Skip if it uses UpdateContext or other state management functions
      if (snippet.includes('UpdateContext') || snippet.includes('ClearCollect') || snippet.includes('Collect')) {
        return false;
      }
      
      // Skip if it appears to be accumulating or building state over multiple statements
      if (this.appearsToBeStateful(snippet)) {
        return false;
      }
    }
    
    return true;
  },
  
  containsControlFlow(snippet, fullFormula) {
    // Look for control flow patterns that might reassign the variable
    const controlFlowPatterns = [
      /\bFor\s*\(/i,
      /\bForAll\s*\(/i,
      /\bIf\s*\(/i,
      /\bSwitch\s*\(/i,
      /\bWhile\s*\(/i
    ];
    
    return controlFlowPatterns.some(pattern => 
      pattern.test(snippet) || pattern.test(fullFormula)
    );
  },
  
  appearsToBeStateful(snippet) {
    // Check for patterns that suggest the variable is used for state management
    const statefulPatterns = [
      /Set\s*\(\s*\w+\s*,\s*\w+\s*\+/i,  // Incrementing: Set(var, var + ...)
      /Set\s*\(\s*\w+\s*,.*Concat/i,      // Building collections
      /Set\s*\(\s*\w+\s*,.*Append/i,      // Appending to collections
      /Set\s*\(\s*\w+\s*,.*Filter/i       // Dynamic filtering that might change
    ];
    
    return statefulPatterns.some(pattern => pattern.test(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 — OnStart Variables That Could Be Named Formulas CUSTOM

Test OnStart Variables That Could Be Named Formulas

Test results