chore(core): introduces getStartProperty on RuleCommon and deprecates legacy start node implementation

Author: RubenHalman

packages/core/src/main/models/Flow.ts

@@ -45,22 +45,50 @@ export class Flow {
   public static readonly RESOURCE_TAGS = ["textTemplates", "stages"] as const;
   public static readonly VARIABLE_TAGS = ["choices", "constants", "dynamicChoiceSets", "formulas", "variables"] as const;
 
+  // Flow elements (excludes legacy start nodes)
   public elements: FlowElement[] = [];
-  public fsPath?: string;
-  public uri?: string;
-  public interviewLabel?: string;
+
+  // Path properties
+  public fsPath?: string; // Resolved absolute path (Node.js only)
+  public uri?: string;    // Input path (could be relative, absolute, or virtual)
+
+  // Flow metadata
   public label: string = "";
+  public interviewLabel?: string;
   public name: string = "unnamed";
   public processMetadataValues?: any;
   public processType: string = "AutoLaunchedFlow";
-  public type: string = "";
-  public root?: any;
+  public type: string = ""; // Alias for processType (backward compatibility)
+  public status: string = "";
+  public triggerOrder?: number;
+
+  // Start-related properties
+  /**
+   * @deprecated Use startNode.element instead. Kept for backward compatibility.
+   */
   public start?: any;
+  
+  /**
+   * Direct reference to first element (from XML attribute).
+   * Used in newer flows as an alternative to the start element.
+   */
   public startElementReference?: string;
+  
+  /**
+   * Computed reference to the first element to execute.
+   * This is what rules should use for traversal.
+   */
   public startReference?: string;
+  
+  /**
+   * Parsed FlowNode object of the start element.
+   * Contains trigger information and connectors.
+   * Access start element data via startNode.element
+   */
   public startNode?: FlowNode;
-  public status: string = "";
-  public triggerOrder?: number;
+
+  // Legacy/internal
+  public root?: any;
   public xmldata: any;
 
   constructor(path?: string, data?: unknown) {
@@ -113,7 +141,6 @@ export class Flow {
     this.type = this.processType;
     this.processMetadataValues = this.xmldata.processMetadataValues;
     this.startElementReference = this.xmldata.startElementReference;
-    this.start = this.xmldata.start;
     this.status = this.xmldata.status || "Draft";
     this.triggerOrder = this.xmldata.triggerOrder;
 
@@ -127,14 +154,14 @@ export class Flow {
 
       const data = this.xmldata[nodeType];
 
-      // Handle start node separately - store in startNode, don't add to elements
+      // Handle start nodes separately - store in startNode, don't add to elements
       if (nodeType === "start") {
         if (Array.isArray(data) && data.length > 0) {
           this.startNode = new FlowNode(data[0].name || "start", "start", data[0]);
         } else if (!Array.isArray(data)) {
           this.startNode = new FlowNode(data.name || "start", "start", data);
         }
-        continue;
+        continue; // Don't add to elements array
       }
 
       // Process other node types
@@ -168,39 +195,44 @@ export class Flow {
     }
   }
 
+  /**
+   * Find the name of the first element to execute.
+   * Priority order:
+   * 1. startElementReference (newer flows, direct XML attribute)
+   * 2. Start node connector (older flows, points to first element)
+   * 3. Start node scheduledPaths (async flows)
+   */
   private findStart(): string {
-  // Priority 1: Explicit startElementReference
-  if (this.startElementReference) {
-    return this.startElementReference;
-  }
+    // Priority 1: Explicit startElementReference
+    if (this.startElementReference) {
+      return this.startElementReference;
+    }
 
-  // Priority 2: Start node with regular connector
-  if (this.startNode && this.startNode.connectors && this.startNode.connectors.length > 0) {
-    const connector = this.startNode.connectors[0];
-    // FlowElementConnector stores targetReference in the 'reference' property
-    if (connector.reference) {
-      return connector.reference;
+    // Priority 2: Start node with regular connector
+    if (this.startNode && this.startNode.connectors && this.startNode.connectors.length > 0) {
+      const connector = this.startNode.connectors[0];
+      if (connector.reference) {
+        return connector.reference;
+      }
     }
-  }
 
-  // Priority 3: Start node with scheduledPaths (async flows)
-  // scheduledPaths can be an array or a single object
-  if (this.startNode?.element) {
-    const scheduledPaths = this.startNode.element['scheduledPaths'];
-    if (scheduledPaths) {
-      const paths = Array.isArray(scheduledPaths) ? scheduledPaths : [scheduledPaths];
-      if (paths.length > 0 && paths[0]?.connector) {
-        const targetRef = paths[0].connector.targetReference;
-        if (targetRef) {
-          return targetRef;
+    // Priority 3: Start node with scheduledPaths (async flows)
+    if (this.startNode?.element) {
+      const scheduledPaths = this.startNode.element['scheduledPaths'];
+      if (scheduledPaths) {
+        const paths = Array.isArray(scheduledPaths) ? scheduledPaths : [scheduledPaths];
+        if (paths.length > 0 && paths[0]?.connector) {
+          const targetRef = paths[0].connector.targetReference;
+          if (targetRef) {
+            return targetRef;
+          }
         }
       }
     }
-  }
 
-  // No valid start found
-  return "";
-}
+    // No valid start found
+    return "";
+  }
 
   public toXMLString(): string {
     try {

packages/core/src/main/models/RuleCommon.ts

@@ -11,7 +11,7 @@ export abstract class RuleCommon {
   public supportedTypes: string[];
   public suppressionElement?: string;
   public uri?: string;
-
+  
   constructor(info: RuleInfo, optional?: { severity?: string }) {
     this.name = info.name;
     this.supportedTypes = info.supportedTypes;
@@ -37,6 +37,7 @@ export abstract class RuleCommon {
     options?: object,
     suppressions: string[] = []
   ): core.RuleResult {
+    // Wildcard suppression disables entire rule
     if (suppressions.includes("*")) {
       return new core.RuleResult(this as any, []);
     }
@@ -93,4 +94,18 @@ export abstract class RuleCommon {
     }
     return flowElements.findIndex(n => n.name === startRef);
   }
+
+  /**
+   * Safely get a property from the start element.
+   * 
+   * @param flow - The Flow instance
+   * @param propertyName - The property to retrieve (e.g., 'triggerType', 'object')
+   * @returns The property value or undefined
+   */
+  protected getStartProperty(flow: core.Flow, propertyName: string): any {
+    if (flow.startNode?.element) {
+      return (flow.startNode.element as Record<string, unknown>)?.[propertyName];
+    }
+    return undefined;
+  }
 }

packages/core/src/main/rules/MissingFaultPath.ts

@@ -1,4 +1,3 @@
-
 import * as core from "../internals/internals";
 import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
@@ -35,6 +34,7 @@ export class MissingFaultPath extends RuleCommon implements IRuleDefinition {
       return false;
     }
 
+    // Exclude specific wait element subtypes that don't need fault paths
     if (proxyNode.subtype === "waits") {
       const elementSubtype: string = (proxyNode.element as Record<string, unknown>)?.["elementSubtype"] as string;
       const excludedSubtypes: string[] = ["WaitDuration", "WaitDate"];
@@ -59,14 +59,15 @@ export class MissingFaultPath extends RuleCommon implements IRuleDefinition {
       }) as core.FlowNode[]
     ).map((e) => e.name);
 
-    // Safely check if this is a RecordBeforeSave flow
+    // Check if this is a RecordBeforeSave flow
     const isRecordBeforeSave = this.isRecordBeforeSaveFlow(flow);
 
     const visitCallback = (element: core.FlowNode) => {
       if (
         !element?.connectors?.find((connector) => connector.type === "faultConnector") &&
         elementsWhereFaultPathIsApplicable.includes(element.name)
       ) {
+        // Skip record updates in before-save flows (they're safe by design)
         if (isRecordBeforeSave && element.subtype === "recordUpdates") {
           return;
         }
@@ -79,32 +80,23 @@ export class MissingFaultPath extends RuleCommon implements IRuleDefinition {
       }
     };
 
-    const startRef = this.getStartReference(flow);
-    if (startRef) {
-      compiler.traverseFlow(flow, startRef, visitCallback);
+    if (flow.startReference) {
+      compiler.traverseFlow(flow, flow.startReference, visitCallback);
     }
 
     return results;
   }
 
   /**
-   * Safely determine if this is a RecordBeforeSave flow.
-   * Checks the startNode property for trigger type.
+   *  Determine if this is a RecordBeforeSave flow.
    */
   private isRecordBeforeSaveFlow(flow: core.Flow): boolean {
-    const startNode = this.getStartNode(flow);
-    
-    if (startNode?.element) {
-      const triggerType = (startNode.element as Record<string, unknown>)?.["triggerType"];
-      return triggerType === "RecordBeforeSave";
-    }
-
-    // Fallback: check raw start data if startNode is not available
-    if (flow.start && typeof flow.start === "object") {
-      const triggerType = (flow.start as Record<string, unknown>)?.["triggerType"];
-      return triggerType === "RecordBeforeSave";
+    if (flow.startNode?.element) {
+      const triggerType = (flow.startNode.element as Record<string, unknown>)?.["triggerType"];
+      if (triggerType === "RecordBeforeSave") {
+        return true;
+      }
     }
-
     return false;
   }
 

packages/core/src/main/rules/MissingFilterRecordTrigger.ts

@@ -21,13 +21,14 @@ export class MissingFilterRecordTrigger extends RuleCommon implements IRuleDefin
 ): core.Violation[] {
   const violations: core.Violation[] = [];
   // Check if this is a record-triggered flow
-  const triggerType = flow.xmldata?.start?.triggerType;
+  const triggerType = this.getStartProperty(flow, 'triggerType');
   // Only check flows with record trigger types
   if (!triggerType || !["RecordAfterSave", "RecordBeforeSave"].includes(triggerType)) {
     return violations;
   }
   // Check if the flow has filters or entry conditions at the flow level
-  const filters = flow.xmldata?.start?.filters;
+  const filters = this.getStartProperty(flow, 'filters');
+
   const hasFilters = !!filters;
   const scheduledPaths = flow.xmldata?.start?.scheduledPaths;
   const hasScheduledPaths = !!scheduledPaths;

packages/core/src/main/rules/RecordIdAsString.ts

@@ -30,9 +30,11 @@ export class RecordIdAsString extends RuleCommon implements IRuleDefinition {
   const violations: core.Violation[] = [];
 
   // Skip record-triggered flows - they don't support this pattern
+  const triggerType = this.getStartProperty(flow, 'triggerType');
   const isRecordTriggered = 
-    flow.start?.triggerType === "RecordAfterSave" || 
-    flow.start?.triggerType === "RecordBeforeSave";
+    triggerType === "RecordAfterSave" || 
+    triggerType === "RecordBeforeDelete" || 
+    triggerType === "RecordBeforeSave";
 
   if (isRecordTriggered) {
     return violations;

packages/core/src/main/rules/RecursiveAfterUpdate.ts

@@ -31,10 +31,13 @@ export class RecursiveAfterUpdate extends RuleCommon implements IRuleDefinition
     suppressions: Set<string>
   ): core.Violation[] {
     const results: core.Violation[] = [];
-    const isAfterSave = flow.start?.triggerType === "RecordAfterSave";
-    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(
-      flow.start?.recordTriggerType
-    );
+
+    const triggerType = this.getStartProperty(flow, 'triggerType');
+    const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
+
+    const isAfterSave = triggerType === "RecordAfterSave";
+    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
+
     if (!isAfterSave || !isQualifiedTriggerTypes) {
       return results;
     }
@@ -57,13 +60,14 @@ export class RecursiveAfterUpdate extends RuleCommon implements IRuleDefinition
       }
     }
     // === Lookup → same object type updates ===
+    const flowObject = this.getStartProperty(flow, 'object');
     const lookupElementsWithTheSameObjectType = flow.elements
       ?.filter(
         (node) =>
           node.subtype === "recordLookups" &&
           typeof node.element === "object" &&
           "object" in node.element &&
-          flow.start.object === node.element["object"]
+          flowObject  === node.element["object"]
       )
       ?.map((node) => node.name);
     if (

packages/core/src/main/rules/SameRecordFieldUpdates.ts

@@ -34,11 +34,11 @@ export class SameRecordFieldUpdates extends RuleCommon implements IRuleDefinitio
     _suppressions: Set<string>
   ): core.Violation[] {
     const results: core.Violation[] = [];
-    const isBeforeSaveType = flow.start?.triggerType === "RecordBeforeSave";
-    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(
-      flow.start?.recordTriggerType
-    );
+    const triggerType = this.getStartProperty(flow, 'triggerType');
+    const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
 
+    const isBeforeSaveType = triggerType === "RecordBeforeSave";
+    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
     if (!isBeforeSaveType || !isQualifiedTriggerTypes) {
       return results;
     }

packages/core/src/main/rules/TriggerOrder.ts

@@ -3,15 +3,16 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 
 export class TriggerOrder extends RuleCommon implements IRuleDefinition {
-  protected qualifiedRecordTriggerTypes: Set<string> = new Set<string>(["Create", "Update"]);
 
   constructor() {
     super(
       {
         name: "TriggerOrder",
         label: "Trigger Order",
         description:
-          "With flow trigger ordering, introduced in Spring '22, admins can now assign a priority value to their flows and guarantee their execution order. This priority value is not an absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
+          "With flow trigger ordering, introduced in Spring '22, admins can now assign a priority " +
+          "value to their flows and guarantee their execution order. This priority value is not an " +
+          "absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
         supportedTypes: [core.FlowType.autolaunchedType],
         docRefs: [
           {
@@ -29,8 +30,14 @@ export class TriggerOrder extends RuleCommon implements IRuleDefinition {
     _options: object | undefined,
     _suppressions: Set<string>
   ): core.Violation[] {
-    if (!("object" in flow.start)) return [];
 
+    const startObject = this.getStartProperty(flow, "object");
+    // If there's no `object` on the start node, this is NOT a record-triggered flow
+    if (!startObject) {
+      return [];
+    }
+
+    // This *is* a record-triggered flow → should have triggerOrder
     if (!flow.triggerOrder) {
       return [
         new core.Violation(

packages/core/tests/HardcodedUrl.test.ts

@@ -28,6 +28,7 @@ describe("HardcodedUrl", () => {
         {
           flow: {
             type: "AutoLaunchedFlow",
+            status: "Active",
             elements: [
               {
                 name: "hardcodedUrl",