@flow-scanner/lightning-flow-scanner-core 6.17.1 → 6.17.2

package/src/main/models/FlowNode.ts

@@ -1,390 +0,0 @@
-import { MetaType } from "../enums/MetadataTypes";
-import { FlowElement } from "./FlowElement";
-import { FlowElementConnector } from "./FlowElementConnector";
-import { DEFAULT_ICONS, ASCII_ICONS, type NodeIconConfig } from "../config/NodeIcons";
-
-export class FlowNode extends FlowElement {
-  public connectors: FlowElementConnector[] = [];
-  public locationX?: string;
-  public locationY?: string;
-  
-  // Common properties across node types
-  public label?: string;
-  public description?: string;
-  
-  // Action-specific properties
-  public actionType?: string;
-  public actionName?: string;
-  
-  // Record operation properties
-  public object?: string;
-  public inputReference?: string;
-  public outputReference?: string;
-  
-  // Collection processor properties
-  public elementSubtype?: string;
-  public collectionReference?: string;
-  
-  // Subflow properties
-  public flowName?: string;
-  
-  // Decision properties
-  public rules?: any[];
-  public defaultConnectorLabel?: string;
-  
-  // Loop properties
-  public iterationOrder?: string;
-  
-  // Screen properties
-  public fields?: any[];
-  public allowPause?: boolean;
-  public showFooter?: boolean;
-  
-  // Fault handling
-  public faultConnector?: FlowElementConnector;
-
-  // Static icon configuration (can be overridden)
-  private static iconConfig: NodeIconConfig = DEFAULT_ICONS;
-
-  /**
-   * Set custom icon configuration for all FlowNodes
-   * @example
-   * ```typescript
-   * // Use ASCII icons for old terminals
-   * FlowNode.setIconConfig(ASCII_ICONS);
-   * 
-   * // Or provide custom icons
-   * FlowNode.setIconConfig({
-   *   actionCalls: { default: '[ACTION]' },
-   *   decisions: { default: '[IF]' }
-   * });
-   * ```
-   */
-  public static setIconConfig(config: NodeIconConfig): void {
-    FlowNode.iconConfig = config;
-  }
-
-  /**
-   * Use ASCII icons instead of emoji (for older browsers/terminals)
-   */
-  public static useAsciiIcons(): void {
-    FlowNode.iconConfig = ASCII_ICONS;
-  }
-
-  /**
-   * Reset to default emoji icons
-   */
-  public static useDefaultIcons(): void {
-    FlowNode.iconConfig = DEFAULT_ICONS;
-  }
-
-  constructor(provName: string, subtype: string, element: object) {
-    const nodeName = subtype === "start" ? "flowstart" : provName;
-    super(MetaType.NODE, subtype, nodeName, element);
-    
-    // Extract common properties
-    this.label = element["label"];
-    this.description = element["description"];
-    this.locationX = element["locationX"];
-    this.locationY = element["locationY"];
-    
-    // Extract type-specific properties
-    this.extractTypeSpecificProperties(subtype, element);
-    
-    // Extract connectors
-    this.connectors = this.getConnectors(subtype, element);
-    this.faultConnector = this.connectors.find(c => c.type === "faultConnector");
-  }
-
-  private extractTypeSpecificProperties(subtype: string, element: any): void {
-    switch (subtype) {
-      case "actionCalls":
-        this.actionType = element.actionType;
-        this.actionName = element.actionName;
-        break;
-        
-      case "recordCreates":
-      case "recordUpdates":
-      case "recordDeletes":
-      case "recordLookups":
-        this.object = element.object;
-        this.inputReference = element.inputReference;
-        this.outputReference = element.outputReference;
-        break;
-        
-      case "collectionProcessors":
-        this.elementSubtype = element.elementSubtype;
-        this.collectionReference = element.collectionReference;
-        break;
-        
-      case "subflows":
-        this.flowName = element.flowName;
-        break;
-        
-      case "decisions":
-        this.rules = Array.isArray(element.rules) ? element.rules : 
-                     element.rules ? [element.rules] : [];
-        this.defaultConnectorLabel = element.defaultConnectorLabel;
-        break;
-        
-      case "loops":
-        this.collectionReference = element.collectionReference;
-        this.iterationOrder = element.iterationOrder;
-        break;
-        
-      case "screens":
-        this.fields = Array.isArray(element.fields) ? element.fields :
-                      element.fields ? [element.fields] : [];
-        this.allowPause = element.allowPause;
-        this.showFooter = element.showFooter;
-        break;
-    }
-  }
-
-  /**
-   * Get a human-readable summary of this node
-   */
-  public getSummary(): string {
-    const parts: string[] = [];
-    
-    switch (this.subtype) {
-      case "actionCalls":
-        if (this.actionType) parts.push(this.prettifyValue(this.actionType));
-        if (this.actionName) parts.push(this.actionName);
-        break;
-        
-      case "recordCreates":
-      case "recordUpdates":
-      case "recordDeletes":
-      case "recordLookups":
-        if (this.object) parts.push(this.object);
-        break;
-        
-      case "collectionProcessors":
-        if (this.elementSubtype) parts.push(this.prettifyValue(this.elementSubtype));
-        break;
-        
-      case "decisions":
-        parts.push(`${this.rules?.length || 0} rule${this.rules?.length !== 1 ? 's' : ''}`);
-        break;
-        
-      case "loops":
-        if (this.collectionReference) parts.push(`Loop: ${this.collectionReference}`);
-        break;
-        
-      case "subflows":
-        if (this.flowName) parts.push(this.flowName);
-        break;
-    }
-    
-    if (this.description) {
-      parts.push(this.description.substring(0, 50) + (this.description.length > 50 ? '...' : ''));
-    }
-    
-    return parts.join(' • ');
-  }
-
-  /**
-   * Get the icon for this node type
-   */
-  public getIcon(): string {
-    const typeIcons = FlowNode.iconConfig[this.subtype];
-    if (!typeIcons) {
-      // Fallback for unknown types
-      const fallback = FlowNode.iconConfig['default'];
-      return (fallback && 'default' in fallback) ? fallback.default : '\u2022'; // • BULLET
-    }
-    
-    // For nodes with subtypes (like actionCalls or collectionProcessors)
-    const subtype = this.actionType || this.elementSubtype;
-    const icons = typeIcons as Record<string, string>;
-    
-    if (subtype && icons[subtype]) {
-      return icons[subtype];
-    }
-    
-    return icons.default || '\u2022'; // • BULLET fallback
-  }
-
-  /**
-   * Get the display name for this node type
-   */
-  public getTypeLabel(): string {
-    const labelMap: Record<string, string> = {
-      actionCalls: 'Action',
-      assignments: 'Assignment',
-      collectionProcessors: 'Collection',
-      customErrors: 'Error',
-      decisions: 'Decision',
-      loops: 'Loop',
-      recordCreates: 'Create',
-      recordDeletes: 'Delete',
-      recordLookups: 'Get Records',
-      recordUpdates: 'Update',
-      screens: 'Screen',
-      subflows: 'Subflow',
-      transforms: 'Transform',
-    };
-    
-    return labelMap[this.subtype] || this.subtype;
-  }
-
-  private prettifyValue(value: string): string {
-    return value
-      .replace(/([A-Z])/g, ' $1')
-      .replace(/^./, str => str.toUpperCase())
-      .trim();
-  }
-
-  private getConnectors(subtype, element) {
-    const connectors: FlowElementConnector[] = [];
-    if (subtype === "start") {
-      if (element.connector) {
-        connectors.push(new FlowElementConnector("connector", element.connector, {}));
-      }
-      if (Array.isArray(element.scheduledPaths)) {
-        for (const asyncElement of element?.scheduledPaths || []) {
-          if (asyncElement.connector) {
-            connectors.push(
-              new FlowElementConnector("connector", asyncElement.connector, {
-                childName: asyncElement?.name ?? "AsyncAfterCommit",
-                childOf: "scheduledPaths",
-              })
-            );
-          }
-        }
-      } else {
-        if (element.scheduledPaths) {
-          connectors.push(
-            new FlowElementConnector("connector", element.scheduledPaths, {
-              childName: element.scheduledPaths.name,
-              childOf: "scheduledPaths",
-            })
-          );
-        }
-      }
-      return connectors;
-    } else if (subtype === "decisions") {
-      if (element.defaultConnector) {
-        connectors.push(new FlowElementConnector("defaultConnector", element.defaultConnector, {}));
-      }
-      if (element.rules) {
-        if (Array.isArray(element.rules)) {
-          for (const rule of element.rules) {
-            if (rule.connector) {
-              connectors.push(
-                new FlowElementConnector("connector", rule.connector, {
-                  childName: rule.name,
-                  childOf: "rules",
-                })
-              );
-            }
-          }
-        } else {
-          if (element.rules.connector) {
-            connectors.push(
-              new FlowElementConnector("connector", element.rules.connector, {
-                childName: element.rules.name,
-                childOf: "rules",
-              })
-            );
-          }
-        }
-      }
-      return connectors;
-    } else if (
-      subtype === "assignments" ||
-      subtype === "transforms" ||
-      subtype === "customErrors"
-    ) {
-      return element.connector
-        ? [new FlowElementConnector("connector", element.connector, {})]
-        : [];
-    } else if (subtype === "loops") {
-      if (element.nextValueConnector) {
-        connectors.push(
-          new FlowElementConnector("nextValueConnector", element.nextValueConnector, {})
-        );
-      }
-      if (element.noMoreValuesConnector) {
-        connectors.push(
-          new FlowElementConnector("noMoreValuesConnector", element.noMoreValuesConnector, {})
-        );
-      }
-      return connectors;
-    } else if (subtype === "actionCalls") {
-      if (element.connector) {
-        connectors.push(new FlowElementConnector("connector", element.connector, {}));
-      }
-      if (element.faultConnector) {
-        connectors.push(new FlowElementConnector("faultConnector", element.faultConnector, {}));
-      }
-      return connectors;
-    } else if (subtype === "waits") {
-      if (element.defaultConnector) {
-        connectors.push(new FlowElementConnector("defaultConnector", element.defaultConnector, {}));
-      }
-      if (element.faultConnector) {
-        connectors.push(new FlowElementConnector("faultConnector", element.faultConnector, {}));
-      }
-      if (Array.isArray(element.waitEvents)) {
-        for (const waitEvent of element.waitEvents) {
-          if (waitEvent.connector) {
-            connectors.push(
-              new FlowElementConnector("connector", waitEvent.connector, {
-                childName: waitEvent.name,
-                childOf: "waitEvents",
-              })
-            );
-          }
-        }
-      }
-
-      return connectors;
-    } else if (subtype === "recordCreates") {
-      if (element.connector) {
-        connectors.push(new FlowElementConnector("connector", element.connector, {}));
-      }
-      if (element.faultConnector) {
-        connectors.push(new FlowElementConnector("faultConnector", element.faultConnector, {}));
-      }
-      return connectors;
-    } else if (subtype === "recordDeletes") {
-      if (element.connector) {
-        connectors.push(new FlowElementConnector("connector", element.connector, {}));
-      }
-      if (element.faultConnector) {
-        connectors.push(new FlowElementConnector("faultConnector", element.faultConnector, {}));
-      }
-      return connectors;
-    } else if (subtype === "recordLookups") {
-      if (element.connector) {
-        connectors.push(new FlowElementConnector("connector", element.connector, {}));
-      }
-      if (element.faultConnector) {
-        connectors.push(new FlowElementConnector("faultConnector", element.faultConnector, {}));
-      }
-      return connectors;
-    } else if (subtype === "recordUpdates") {
-      if (element.connector) {
-        connectors.push(new FlowElementConnector("connector", element.connector, {}));
-      }
-      if (element.faultConnector) {
-        connectors.push(new FlowElementConnector("faultConnector", element.faultConnector, {}));
-      }
-      return connectors;
-    } else if (subtype === "subflows") {
-      return element.connector
-        ? [new FlowElementConnector("connector", element.connector, {})]
-        : [];
-    } else if (subtype === "screens") {
-      return element.connector
-        ? [new FlowElementConnector("connector", element.connector, {})]
-        : [];
-    } else {
-      return element.connector
-        ? [new FlowElementConnector("connector", element.connector, {})]
-        : [];
-    }
-  }
-}

package/src/main/models/FlowResource.ts

@@ -1,8 +0,0 @@
-import { MetaType } from "../enums/MetadataTypes";
-import { FlowElement } from "./FlowElement";
-
-export class FlowResource extends FlowElement {
-  constructor(name: string, subtype: string, element: object) {
-    super(MetaType.RESOURCE, subtype, name, element);
-  }
-}

package/src/main/models/FlowType.ts

@@ -1,53 +0,0 @@
-/**
- * Represents the different types of Salesforce Flows and provides utility methods
- * to categorize and retrieve them.
- *
- * @remarks
- * This class defines static properties for various flow types, including backend,
- * process builder, survey, visual, and unsupported types. It also provides a method
- * to retrieve all supported flow types.
- *
- * @example
- * ```typescript
- * const allFlowTypes = FlowType.allTypes();
- * ```
- */
-export class FlowType {
-  public static readonly autolaunchedType = "AutoLaunchedFlow";
-
-  public static readonly backEndTypes = [
-    this.autolaunchedType,
-    "CustomEvent",
-    "InvocableProcess",
-    "Orchestrator",
-    "EvaluationFlow",
-    "ActionCadenceAutolaunchedFlow",
-  ];
-  public static readonly processBuilder = ["Workflow"];
-  public static readonly surveyTypes = ["Survey"];
-  public static readonly unsupportedTypes = [
-    "ActionPlan",
-    "UserProvisioningFlow",
-    "CheckoutFlow",
-    "FSCLending",
-    "LoyaltyManagementFlow",
-    "JourneyBuilderIntegration",
-  ];
-  public static readonly visualTypes = [
-    "Flow",
-    "IndividualObjectLinkingFlow",
-    "LoginFlow",
-    "RoutingFlow",
-    "Appointments",
-    "ActionCadenceStepFlow",
-    "ContactRequestFlow",
-    "CustomerLifecycle",
-    "FieldServiceMobile",
-    "FieldServiceWeb",
-    "SurveyEnrich",
-  ];
-
-  public static readonly allTypes = function () {
-    return [...this.backEndTypes, ...this.visualTypes, ...this.surveyTypes];
-  };
-}

package/src/main/models/FlowVariable.ts

@@ -1,157 +0,0 @@
-import { MetaType } from "../enums/MetadataTypes";
-import { FlowElement } from "./FlowElement";
-import { DEFAULT_VARIABLE_ICONS, ASCII_VARIABLE_ICONS, type VariableIconConfig } from "../config/VariableIcons";
-
-export class FlowVariable extends FlowElement {
-  public dataType?: string;
-  public isCollection?: boolean;
-  public isInput?: boolean;
-  public isOutput?: boolean;
-  public objectType?: string;
-  public description?: string;
-  public value?: any;
-
-  // Static icon configuration (can be overridden)
-  private static iconConfig: VariableIconConfig = DEFAULT_VARIABLE_ICONS;
-
-  /**
-   * Set custom icon configuration for all FlowVariables
-   * @example
-   * ```typescript
-   * // Use ASCII icons
-   * FlowVariable.setIconConfig(ASCII_VARIABLE_ICONS);
-   * 
-   * // Or provide custom icons
-   * FlowVariable.setIconConfig({
-   *   subtypes: {
-   *     variables: '[VAR]',
-   *     constants: '[CONST]'
-   *   },
-   *   boolean: {
-   *     true: '[YES]',
-   *     false: '[NO]'
-   *   }
-   * });
-   * ```
-   */
-  public static setIconConfig(config: VariableIconConfig): void {
-    FlowVariable.iconConfig = config;
-  }
-
-  /**
-   * Use ASCII icons instead of emoji
-   */
-  public static useAsciiIcons(): void {
-    FlowVariable.iconConfig = ASCII_VARIABLE_ICONS;
-  }
-
-  /**
-   * Reset to default emoji icons
-   */
-  public static useDefaultIcons(): void {
-    FlowVariable.iconConfig = DEFAULT_VARIABLE_ICONS;
-  }
-
-  constructor(name: string, subtype: string, element: object) {
-    super(MetaType.VARIABLE, subtype, name, element);
-    
-    // Extract properties based on variable subtype
-    this.dataType = element["dataType"];
-    this.isCollection = element["isCollection"];
-    this.isInput = element["isInput"];
-    this.isOutput = element["isOutput"];
-    this.objectType = element["objectType"];
-    this.description = element["description"];
-    
-    // Different subtypes have different value properties
-    if (subtype === "constants") {
-      this.value = element["value"];
-    } else if (subtype === "formulas") {
-      this.value = element["expression"];
-    }
-  }
-
-  /**
-   * Get the icon for this variable subtype
-   */
-  public getIcon(): string {
-    return FlowVariable.iconConfig.subtypes[this.subtype] || '\uD83D\uDCCA'; // 📊 default
-  }
-
-  /**
-   * Get icon for a boolean value
-   */
-  private getBooleanIcon(value?: boolean): string {
-    if (value === true) {
-      return FlowVariable.iconConfig.boolean.true;
-    } else if (value === false) {
-      return FlowVariable.iconConfig.boolean.false;
-    }
-    return ''; // undefined/null
-  }
-
-  /**
-   * Get a human-readable type label
-   */
-  public getTypeLabel(): string {
-    const labelMap: Record<string, string> = {
-      variables: 'Variable',
-      constants: 'Constant',
-      formulas: 'Formula',
-      choices: 'Choice',
-      dynamicChoiceSets: 'Dynamic Choice',
-    };
-    return labelMap[this.subtype] || this.subtype;
-  }
-
-  /**
-   * Get a markdown table row for this variable
-   */
-  public toTableRow(): string {
-    const parts = [
-      this.name,
-      this.dataType || '',
-      this.getBooleanIcon(this.isCollection),
-      this.getBooleanIcon(this.isInput),
-      this.getBooleanIcon(this.isOutput),
-      this.objectType || '',
-      this.description || ''
-    ];
-    return `| ${parts.join(' | ')} |`;
-  }
-
-  /**
-   * Get a detailed markdown table for this variable
-   */
-  public toMarkdownTable(): string {
-    let table = '| Property | Value |\n|:---|:---|\n';
-    
-    table += `| Name | ${this.name} |\n`;
-    table += `| Type | ${this.getIcon()} ${this.getTypeLabel()} |\n`;
-    
-    if (this.dataType) table += `| Data Type | ${this.dataType} |\n`;
-    if (this.objectType) table += `| Object Type | ${this.objectType} |\n`;
-    if (this.isCollection !== undefined) {
-      table += `| Collection | ${this.getBooleanIcon(this.isCollection)} |\n`;
-    }
-    if (this.isInput !== undefined) {
-      table += `| Input | ${this.getBooleanIcon(this.isInput)} |\n`;
-    }
-    if (this.isOutput !== undefined) {
-      table += `| Output | ${this.getBooleanIcon(this.isOutput)} |\n`;
-    }
-    if (this.value !== undefined) {
-      table += `| Value | ${this.formatValue(this.value)} |\n`;
-    }
-    if (this.description) table += `| Description | ${this.description} |\n`;
-    
-    return table;
-  }
-
-  private formatValue(value: any): string {
-    if (typeof value === 'object') {
-      return JSON.stringify(value, null, 2);
-    }
-    return String(value);
-  }
-}

package/src/main/models/LoopRuleCommon.ts

@@ -1,51 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { Flow, FlowNode, Violation } from "../internals/internals";
-import { RuleCommon } from "./RuleCommon";
-import { RuleInfo } from "./RuleInfo";
-
-export abstract class LoopRuleCommon extends RuleCommon implements IRuleDefinition {
-  constructor(info: RuleInfo, optional?: { severity?: string }) {
-    super(info, optional);
-  }
-
-  protected check(
-    flow: Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): Violation[] {
-    const loopElements = flow.graph.getLoopNodes();
-    if (!loopElements.length) {
-      return [];
-    }
-    const statementsInLoops = this.findStatementsInLoops(flow, loopElements);
-    const results = statementsInLoops
-      .filter(det => !suppressions.has(det.name))
-      .map(det => new Violation(det));
-    return results;
-  }
-
-  protected abstract getStatementTypes(): string[];
-
-  private findLoopElements(flow: Flow): FlowNode[] {
-    return flow.graph.getLoopNodes();
-  }
-
-  private findLoopEnd(element: FlowNode): string {
-    return (element.element as any)?.noMoreValuesConnector?.targetReference ?? element.name;
-  }
-
-  private findStatementsInLoops(flow: Flow, loopElements: FlowNode[]): FlowNode[] {
-    const statementsInLoops: FlowNode[] = [];
-    const statementTypes = this.getStatementTypes();
-    for (const element of loopElements) {
-      const loopElems = flow.graph.getLoopElements(element.name);
-      for (const elemName of loopElems) {
-        const node = flow.graph.getNode(elemName);
-        if (node && statementTypes.includes(node.subtype)) {
-          statementsInLoops.push(node);
-        }
-      }
-    }
-    return statementsInLoops;
-  }
-}

package/src/main/models/ParsedFlow.ts

@@ -1,13 +0,0 @@
-import { Flow } from "./Flow";
-export class ParsedFlow {
-  public uri: string;
-  public flow: Flow | undefined;
-  public errorMessage?: string;
-  constructor(uri: string, flow?: Flow, errorMessage?: string) {
-    this.uri = uri;
-    this.flow = flow;
-    if (errorMessage) {
-      this.errorMessage = errorMessage;
-    }
-  }
-}