Refactor step name generation to use alphabetical indexing (#1646)

<!--
Ensure the title clearly reflects what was changed.
Provide a clear and concise description of the changes made. The PR
should only contain the changes related to the issue, and no other
unrelated changes.
-->

Fixes OPS-3053.

Author: rSnapkoOpenOps

packages/react-ui/src/app/features/builder/blocks-selector/block-selector-utils.ts

@@ -13,7 +13,6 @@ import {
   Trigger,
   TriggerType,
 } from '@openops/shared';
-
 import { createDefaultOptionSettings } from '../step-settings/split-settings/utils';
 
 const defaultCode = `export const code = async (inputs) => {
@@ -37,13 +36,7 @@ const getStepName = (block: StepMetadata, flowVersion: FlowVersion) => {
   if (block.type === TriggerType.BLOCK) {
     return 'trigger';
   }
-  const baseName = 'step_';
-  let number = 1;
-  const steps = flowHelper.getAllSteps(flowVersion.trigger);
-  while (steps.some((step) => step.name === `${baseName}${number}`)) {
-    number++;
-  }
-  return `${baseName}${number}`;
+  return flowHelper.findAvailableStepName(flowVersion, 'step');
 };
 
 const getDefaultStep = ({

packages/react-ui/src/app/features/builder/tests/update-flow-version.test.ts

@@ -52,8 +52,8 @@ describe('updateFlowVersion', () => {
           valid: false,
           displayName: 'Select Trigger',
           nextAction: {
-            id: 'step_1',
-            name: 'step_1',
+            id: 'step_a',
+            name: 'step_a',
             type: ActionType.BLOCK,
             valid: false,
             displayName: 'step1',
@@ -68,7 +68,7 @@ describe('updateFlowVersion', () => {
         valid: false,
         state: FlowVersionState.DRAFT,
       },
-      selectedStep: 'step_1',
+      selectedStep: 'step_a',
       rightSidebar: RightSideBarType.BLOCK_SETTINGS,
       readonly: false,
       loopsIndexes: {},
@@ -124,7 +124,7 @@ describe('updateFlowVersion', () => {
     const operation = {
       type: FlowOperationType.UPDATE_ACTION,
       request: {
-        name: 'step_1',
+        name: 'step_a',
         type: 'BLOCK',
         valid: false,
         settings: { blockVersion: '1.0.0' },
@@ -160,7 +160,7 @@ describe('updateFlowVersion', () => {
           valid: false,
           displayName: 'Select Trigger',
           nextAction: {
-            name: 'step_1',
+            name: 'step_a',
             valid: false,
             type: 'BLOCK',
             displayName: 'Google Cloud CLI',
@@ -175,7 +175,7 @@ describe('updateFlowVersion', () => {
   it('should handle delete action and clear selection when deleting selected step', async () => {
     const operation = {
       type: FlowOperationType.DELETE_ACTION,
-      request: { name: 'step_1' },
+      request: { name: 'step_a' },
     } as FlowOperationRequest;
 
     updateFlowVersion(mockState, operation, mockOnError, mockSet);
@@ -189,26 +189,26 @@ describe('updateFlowVersion', () => {
   it('should handle duplicate action selecting new step', async () => {
     const operation = {
       type: FlowOperationType.DUPLICATE_ACTION,
-      request: { stepName: 'step_1' },
+      request: { stepName: 'step_a' },
     } as FlowOperationRequest;
 
     updateFlowVersion(mockState, operation, mockOnError, mockSet);
 
     await waitFor(() => expect(mockSet).toHaveBeenCalledWith({ saving: true }));
     await waitFor(() =>
-      expect(mockSet).toHaveBeenCalledWith({ selectedStep: 'step_2' }),
+      expect(mockSet).toHaveBeenCalledWith({ selectedStep: 'step_b' }),
     );
   });
 
   it('should call stepTestOutputCache.clearStep when deleting a step', async () => {
     const operation = {
       type: FlowOperationType.DELETE_ACTION,
-      request: { name: 'step_1' },
+      request: { name: 'step_a' },
     } as FlowOperationRequest;
     const clearStepSpy = jest.spyOn(stepTestOutputCache, 'clearStep');
     updateFlowVersion(mockState, operation, mockOnError, mockSet);
 
-    expect(clearStepSpy).toHaveBeenCalledWith('step_1');
+    expect(clearStepSpy).toHaveBeenCalledWith('step_a');
     clearStepSpy.mockRestore();
   });
 });

packages/shared/src/lib/flows/flow-helper.ts

@@ -46,6 +46,9 @@ type GetStepFromSubFlow = {
 const actionSchemaValidator = TypeCompiler.Compile(SingleActionSchema);
 const triggerSchemaValidation = TypeCompiler.Compile(TriggerWithOptionalId);
 
+const ALPHABET_LENGTH = 26;
+const A_CODE_POINT = 97;
+
 export function buildBlockActionKey(
   blockName: string,
   actionName: string,
@@ -1096,16 +1099,44 @@ function doesActionHaveChildren(
   return false;
 }
 
+/**
+ * Converts a zero-based numeric index into a lowercase alphabetical label.
+ * Similar to spreadsheet column naming but using lowercase letters:
+ * 0 -> "a", 25 -> "z", 26 -> "aa", 27 -> "ab", and so on.
+ *
+ * @param index - Zero-based integer to convert.
+ * @returns Alphabetical label corresponding to the index.
+ * @example
+ * indexToAlphabetical(0)   // "a"
+ * indexToAlphabetical(25)  // "z"
+ * indexToAlphabetical(26)  // "aa"
+ * indexToAlphabetical(701) // "zz"
+ */
+function indexToAlphabetical(index: number): string {
+  let n = index + 1;
+  let result = '';
+  while (n > 0) {
+    n--;
+    result =
+      String.fromCodePoint(A_CODE_POINT + (n % ALPHABET_LENGTH)) + result;
+    n = Math.floor(n / ALPHABET_LENGTH);
+  }
+  return result;
+}
+
 function findUnusedName(names: string[], stepPrefix: string): string {
-  let availableNumber = 1;
-  let availableName = `${stepPrefix}_${availableNumber}`;
+  const prefix = `${stepPrefix}_`;
+  const tails = new Set(
+    names
+      .filter((n) => n.startsWith(prefix))
+      .map((n) => n.slice(prefix.length)),
+  );
 
-  while (names.includes(availableName)) {
-    availableNumber++;
-    availableName = `${stepPrefix}_${availableNumber}`;
+  let index = 0;
+  while (tails.has(indexToAlphabetical(index))) {
+    index++;
   }
-
-  return availableName;
+  return `${stepPrefix}_${indexToAlphabetical(index)}`;
 }
 
 function findAvailableStepName(
@@ -1286,4 +1317,6 @@ export const flowHelper = {
   getUsedConnections,
   createTrigger,
   addStepIndices,
+  indexToAlphabetical,
+  findUnusedName,
 };

packages/shared/src/lib/flows/test/flow-helper.test.ts

@@ -2,6 +2,51 @@ import { Action } from '../actions/action';
 import { flowHelper } from '../flow-helper';
 
 describe('flowHelper', () => {
+  describe('indexToAlphabetical', () => {
+    it.each<[number, string]>([
+      [0, 'a'],
+      [25, 'z'],
+      [26, 'aa'],
+      [27, 'ab'],
+      [51, 'az'],
+      [52, 'ba'],
+      [701, 'zz'],
+      [702, 'aaa'],
+    ])('converts %d to %s', (input, expected) => {
+      expect(flowHelper.indexToAlphabetical(input)).toBe(expected);
+    });
+  });
+
+  describe('findUnusedName', () => {
+    it('should return the first alphabetical suffix when none exist', () => {
+      const names: string[] = [];
+      expect(flowHelper.findUnusedName(names, 'step')).toBe('step_a');
+    });
+
+    it('should fill the first gap in the existing names', () => {
+      const names = ['step_a', 'step_b', 'step_d'];
+      expect(flowHelper.findUnusedName(names, 'step')).toBe('step_c');
+    });
+
+    it('should skip unrelated names and prefixes', () => {
+      const names = ['step_a', 'other_a', 'step_b'];
+      expect(flowHelper.findUnusedName(names, 'step')).toBe('step_c');
+    });
+
+    it('should roll over to double letters after z', () => {
+      const names = Array.from(
+        { length: 26 },
+        (_, i) => `step_${flowHelper.indexToAlphabetical(i)}`,
+      );
+      expect(flowHelper.findUnusedName(names, 'step')).toBe('step_aa');
+    });
+
+    it('should work with larger gaps and mixed ordering', () => {
+      const names = ['step_aa', 'step_c', 'step_a', 'step_ab'];
+      expect(flowHelper.findUnusedName(names, 'step')).toBe('step_b');
+    });
+  });
+
   describe('truncateFlow', () => {
     it("should return the same step if it's already the last step", () => {
       const step = { name: 'A', nextAction: undefined } as Action;