@dev-blinq/cucumber_client 1.0.1471-dev → 1.0.1471-stage

package/bin/client/recorderv3/step_utils.js

@@ -1,7 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import path from "path";
-import url from "url";
-import logger from "../../logger.js";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import url from "node:url";
 import { CodePage, getAiConfig } from "../code_gen/page_reflection.js";
 import { generateCode, generatePageName } from "../code_gen/playwright_codeget.js";
 import { invertCodeToCommand } from "../code_gen/code_inversion.js";
@@ -9,8 +8,17 @@ import { Step } from "../cucumber/feature.js";
 import { locateDefinitionPath, StepsDefinitions } from "../cucumber/steps_definitions.js";
 import { Recording } from "../recording.js";
 import { generateApiCode } from "../code_gen/api_codegen.js";
-import { tmpdir } from "os";
-import { createHash } from "crypto";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+import { getErrorMessage } from "../utils/socket_logger.js";
+import {
+  FIXED_FILE_NAMES,
+  FIXED_FOLDER_NAMES,
+  SaveJobErrorType,
+  UpdateStepDefinitionsError,
+  UTF8_ENCODING,
+} from "./constants.js";
+import { handleFileInitOps, potentialErrorWrapper, processScenarioSteps, writeTemplateFiles } from "./utils.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -48,7 +56,7 @@ const replaceLastOccurence = (str, search, replacement) => {
   return str.substring(0, lastIndex) + replacement + str.substring(lastIndex + search.length);
 };
 
-const _toRecordingStep = (cmd) => {
+export const _toRecordingStep = (cmd, stepText) => {
   switch (cmd.type) {
     case "hover_element": {
       return {
@@ -250,6 +258,7 @@ const _toRecordingStep = (cmd) => {
         },
         parameters: [cmd.selectedField, cmd.value],
         lastKnownUrlPath: cmd.lastKnownUrlPath,
+        valueInStepText: stepText && typeof stepText === "string" ? stepText.includes(`"${cmd.value}"`) : false,
       };
     }
     case "conditional_wait": {
@@ -261,6 +270,7 @@ const _toRecordingStep = (cmd) => {
         },
         parameters: [cmd.timeout, cmd.selectedField, cmd.value],
         lastKnownUrlPath: cmd.lastKnownUrlPath,
+        valueInStepText: stepText && typeof stepText === "string" ? stepText.includes(`"${cmd.value}"`) : false,
       };
     }
     case "navigate": {
@@ -296,6 +306,8 @@ const _toRecordingStep = (cmd) => {
         type: "verify_page_snapshot",
         parameters: [cmd.value],
         selectors: cmd.selectors,
+        data: cmd.data,
+        valueInStepText: stepText && typeof stepText === "string" ? stepText.includes(`"${cmd.value}"`) : false,
       };
     }
     default: {
@@ -332,49 +344,62 @@ const _parameterizeLocators = (locators, replacementFromValue, replacementToValu
   }
   return locators;
 };
-const parameterizeLocators = ({ cmd, locs, isValueVariable, isTextVariable, parametersMap }) => {
+const parameterizeLocators = ({ cmd, locs, isValueVariable, isTargetValueVariable, parametersMap }) => {
   if (isValueVariable) {
     const variable = cmd.value.slice(1, -1);
-    const val = parametersMap[variable];
-    const replacementFromValue = val.trim();
-    const replacementToValue = `{${variable}}`;
-    locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
-  }
-  if (isTextVariable) {
-    const variable = cmd.text.slice(1, -1);
-    const val = parametersMap[variable];
-    const replacementFromValue = val.trim();
-    const replacementToValue = `{${variable}}`;
-    locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
+    // const val = parametersMap[variable];
+    if (typeof cmd.text === "string") {
+      const replacementFromValue = cmd.text.trim().replace(/\s+/g, " ") ?? ""; // val.trim();
+      if (replacementFromValue.length > 0) {
+        const replacementToValue = `{${variable}}`;
+        locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
+      }
+    }
+  }
+  if (isTargetValueVariable) {
+    const variable = cmd.targetValue.slice(1, -1);
+    // const val = parametersMap[variable];
+    if (typeof cmd.targetText === "string") {
+      const replacementFromValue = cmd.targetText.trim().replace(/\s+/g, " ") ?? ""; // val.trim();
+      if (replacementFromValue.length > 0) {
+        const replacementToValue = `{${variable}}`;
+        locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
+      }
+    }
   }
   return locs;
 };
 
 //TODO: IMPORTAN
-export const toRecordingStep = (cmd, parametersMap) => {
+export const toRecordingStep = (cmd, parametersMap, stepText) => {
   if (cmd.type === "api") {
     return {
       type: "api",
       value: cmd.value,
     };
   }
-  const step = _toRecordingStep(cmd);
+  const step = _toRecordingStep(cmd, stepText);
   const cmdID = {
     cmdId: cmd.id,
+    options: cmd.options ?? null,
   };
   Object.assign(step, cmdID);
 
   const locatorsObject = JSON.parse(JSON.stringify(cmd.locators ?? null));
 
   if (!locatorsObject) return step;
+
+  const element_name = cmd?.locators?.element_name ?? `${cmd.label} ${cmd.role ?? "Text"}`;
+  locatorsObject.element_name = element_name;
+
   const isValueVariable = isVariable(cmd.value);
-  const isTextVariable = isVariable(cmd.text);
+  const isTargetValueVariable = isVariable(cmd.targetValue);
   const allStrategyLocators = JSON.parse(JSON.stringify(cmd?.allStrategyLocators ?? null));
   step.locators = locatorsObject;
   step.allStrategyLocators = allStrategyLocators;
   step.isLocatorsAssigned = true;
 
-  if (!isValueVariable && !isTextVariable) {
+  if (!isValueVariable && !isTargetValueVariable) {
     return step;
   }
 
@@ -389,7 +414,7 @@ export const toRecordingStep = (cmd, parametersMap) => {
       cmd,
       locs,
       isValueVariable,
-      isTextVariable,
+      isTargetValueVariable,
       parametersMap,
     });
     locatorsObject.locators = locs;
@@ -408,7 +433,7 @@ export const toRecordingStep = (cmd, parametersMap) => {
       cmd,
       locs: locators,
       isValueVariable,
-      isTextVariable,
+      isTargetValueVariable,
       parametersMap,
     });
   }
@@ -437,7 +462,7 @@ export function getCodePage(stepDefsFilePath) {
     return codePage;
   }
   // const templateFile = path.join(__dirname, "../../assets", "templates", "page_template.txt");
-  // const initialCode = readFileSync(templateFile, "utf8");
+  // const initialCode = readFileSync(templateFile, UTF8_ENCODING);
   const codePage = new CodePage();
   codePage.generateModel();
   return codePage;
@@ -445,7 +470,7 @@ export function getCodePage(stepDefsFilePath) {
 export function getCucumberStep({ step }) {
   const cucumberStep = new Step();
   cucumberStep.loadFromJson({
-    text: step.text,
+    text: step.renamedText ? step.renamedText : step.text,
     keyword: step.keyword,
     keywordType: step.keywordType,
     parameters: [],
@@ -463,12 +488,16 @@ export function getCucumberStep({ step }) {
 
 function makeStepTextUnique(step, stepsDefinitions) {
   // const utilsFilePath = path.join("features", "step_definitions", "utils.mjs");
-  let stepText = step.text;
+  let stepText = step.renamedText ? step.renamedText : step.text;
   let stepIndex = 1;
   // console.log("makeStepTextUnique", step.text);
   let stepDef = stepsDefinitions.findMatchingStep(stepText);
   // console.log({ stepDef });
-  if (stepDef && stepDef?.file.endsWith("utils.mjs")) {
+  if (
+    stepDef &&
+    (stepDef?.file.endsWith("utils.mjs") || stepDef?.file.endsWith("renamed_util.mjs")) &&
+    !step.shouldMakeStepTextUnique
+  ) {
     return true;
   }
   while (stepDef) {
@@ -479,9 +508,18 @@ function makeStepTextUnique(step, stepsDefinitions) {
   step.text = stepText;
 }
 
-export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions, parametersMap }) {
+export async function saveRecording({
+  step,
+  cucumberStep,
+  codePage,
+  projectDir,
+  stepsDefinitions,
+  parametersMap,
+  logger,
+  bvtSnapshotsDir,
+}) {
   if (step.commands && Array.isArray(step.commands)) {
-    step.commands = step.commands.map((cmd) => toRecordingStep(cmd, parametersMap));
+    step.commands = step.commands.map((cmd) => toRecordingStep(cmd, parametersMap, step.text));
   }
   let routesPath = path.join(tmpdir(), "blinq_temp_routes");
 
@@ -490,21 +528,19 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       rmSync(routesPath, { recursive: true });
     }
     mkdirSync(routesPath, { recursive: true });
-    saveRoutes({ step, folderPath: routesPath });
+    saveRoutes({ step, folderPath: routesPath }, logger);
   } else {
     if (existsSync(routesPath)) {
-      // remove the folder
       try {
         rmSync(routesPath, { recursive: true });
-        console.log("Removed temp_routes_folder:", routesPath);
       } catch (error) {
-        console.error("Error removing temp_routes folder", error);
+        logger.error(`Error removing temp routes folder: ${getErrorMessage(error)}`);
       }
       routesPath = path.join(projectDir, "data", "routes");
       if (!existsSync(routesPath)) {
         mkdirSync(routesPath, { recursive: true });
       }
-      saveRoutes({ step, folderPath: routesPath });
+      saveRoutes({ step, folderPath: routesPath }, logger);
     }
   }
 
@@ -512,44 +548,58 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     return;
   }
 
+  let isUtilStep = false;
+  let isChangedUtilStepName = false;
+
   if (step.isImplemented && step.shouldOverride) {
-    let stepDef = stepsDefinitions.findMatchingStep(step.text);
+    const stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
   } else {
-    const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
+    isUtilStep = makeStepTextUnique(step, stepsDefinitions);
 
     if (isUtilStep) {
-      return;
+      isChangedUtilStepName =
+        step.renamedText && stepsDefinitions.findMatchingStep(step.renamedText)?.file.endsWith("renamed_util.mjs");
+
+      if (!isChangedUtilStepName) {
+        const isUtilStep = stepsDefinitions.findMatchingStep(step.text)?.file.endsWith("utils.mjs");
+        if (!step.renamedText || step.renamedText === step.text || isUtilStep) {
+          return;
+        }
+        step.text = step.text.trim();
+        const { functionName } = stepsDefinitions.findMatchingStep(step.renamedText);
+        step.renamedText = functionName;
+        const newImportLine = `import { ${functionName} } from "./utils.mjs";\n`;
+
+        if (!codePage.fileContent.includes(newImportLine)) {
+          codePage.fileContent = newImportLine + codePage.fileContent;
+        }
+      }
     }
   }
 
+  const renamedUtil = step.renamedText && isUtilStep;
+
   routesPath = path.join(tmpdir(), "blinq_temp_routes");
   if (process.env.TEMP_RUN === "true") {
-    console.log("Save routes in temp folder for running:", routesPath);
     if (existsSync(routesPath)) {
-      console.log("Removing existing temp_routes_folder:", routesPath);
       rmSync(routesPath, { recursive: true });
     }
     mkdirSync(routesPath, { recursive: true });
-    console.log("Created temp_routes_folder:", routesPath);
-    saveRoutes({ step, folderPath: routesPath });
+    saveRoutes({ step, folderPath: routesPath }, logger);
   } else {
-    console.log("Saving routes in project directory:", projectDir);
     if (existsSync(routesPath)) {
-      // remove the folder
       try {
         rmSync(routesPath, { recursive: true });
-        console.log("Removed temp_routes_folder:", routesPath);
       } catch (error) {
-        console.error("Error removing temp_routes folder", error);
+        logger.error(`Error removing temp routes folder: ${getErrorMessage(error)}`);
       }
     }
     routesPath = path.join(projectDir, "data", "routes");
-    console.log("Saving routes to:", routesPath);
     if (!existsSync(routesPath)) {
       mkdirSync(routesPath, { recursive: true });
     }
-    saveRoutes({ step, folderPath: routesPath });
+    saveRoutes({ step, folderPath: routesPath }, logger);
   }
 
   cucumberStep.text = step.text;
@@ -605,7 +655,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       stepsDefinitions
     );
 
-    if (!step.isImplemented) {
+    if (!renamedUtil && !(step.isImplemented && step.shouldOverride)) {
       stepsDefinitions.addStep({
         name: step.text,
         file: result.codePage.sourceFileName,
@@ -617,13 +667,16 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     return result.codePage;
   } else {
     const generateCodeResult = generateCode(recording, codePage, userData, projectDir, methodName);
-    if (generateCodeResult.noCode === true) {
-      logger.log("No code generated for step: " + step.text);
+    console.log("Generated code for step:", step.text);
+    if (!isUtilStep && generateCodeResult.noCode === true) {
       return generateCodeResult.page;
     }
     codePage = generateCodeResult.page;
     methodName = generateCodeResult.methodName;
-    codePage.insertElements(generateCodeResult.elements);
+
+    if (!renamedUtil) {
+      codePage.insertElements(generateCodeResult.elements);
+    }
 
     const description = cucumberStep.text;
     let path = null;
@@ -636,15 +689,43 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
         protect = true;
       }
     }
-    const infraResult = codePage.addInfraCommand(
-      methodName,
-      description,
-      cucumberStep.getVariablesList(),
-      generateCodeResult.codeLines,
-      protect,
-      "recorder",
-      path
-    );
+
+    if (renamedUtil) {
+      if (isChangedUtilStepName) {
+        const newFileContent = codePage.fileContent
+          .replace(`async function ${step.renamedText}`, `async function ${methodName}`)
+          .replace(`Then("${step.renamedText}"`, `// Then("${step.renamedText}"`)
+          .replace(`When("${step.renamedText}"`, `// When("${step.renamedText}"`)
+          .replace(`Given("${step.renamedText}"`, `// Given("${step.renamedText}"`);
+
+        codePage._init();
+        codePage.generateModel(newFileContent);
+      } else {
+        codePage.addInfraCommandUtil(
+          methodName,
+          description,
+          cucumberStep.parameters,
+          generateCodeResult.codeLines,
+          step.renamedText,
+          step.text,
+          parametersMap,
+          protect,
+          "recorder",
+          path
+        );
+      }
+    } else {
+      codePage.addInfraCommand(
+        methodName,
+        description,
+        cucumberStep.getVariablesList(),
+        generateCodeResult.codeLines,
+        protect,
+        "recorder",
+        path
+      );
+    }
+
     const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
     const stepResult = codePage.addCucumberStep(
       keyword,
@@ -654,7 +735,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.finalTimeout
     );
 
-    if (!step.isImplemented) {
+    if (!renamedUtil && !(step.isImplemented && step.shouldOverride)) {
       stepsDefinitions.addStep({
         name: step.text,
         file: codePage.sourceFileName,
@@ -689,7 +770,7 @@ const getLocatorsJson = (file) => {
     return {};
   }
   try {
-    const locatorsJson = readFileSync(locatorsFilePath, "utf8");
+    const locatorsJson = readFileSync(locatorsFilePath, UTF8_ENCODING);
     return JSON.parse(locatorsJson);
   } catch (error) {
     console.error(error);
@@ -707,7 +788,7 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
     const file = step?.file;
     const locatorsJson = getLocatorsJson(file);
     if (!step) {
-      throw new Error("Step definition not found" + stepName);
+      throw new Error(`Step definition not found: ${stepName}`);
     }
     isImplemented = true;
     const { codeCommands, codePage, elements, parametersNames, error } =
@@ -715,26 +796,35 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
     if (error) {
       throw new Error(error);
     }
+    isUtilStep = codePage.sourceFileName.endsWith("utils.mjs") || codePage.sourceFileName.endsWith("renamed_util.mjs");
 
     if (parametersNames.length !== stepParams.length) {
       // console.log("Parameters mismatch", parametersNames, stepParams);
       throw new Error("Parameters mismatch");
     }
-    for (let i = 0; i < parametersNames.length; i++) {
-      stepParams[i].argumentName = parametersNames[i];
-    }
 
-    isUtilStep = codePage.sourceFileName.endsWith("utils.mjs");
-    for (const { code } of codeCommands) {
-      const command = invertCodeToCommand(code, elements, stepParams, stepsDefinitions, codePage, stepName)[0];
-      if (command === undefined || command.type === null) continue;
-      if (command.element) {
-        const key = command.element.key;
-        if (key && locatorsJson[key]) {
-          command.allStrategyLocators = locatorsJson[key];
+    const pattern = step.name;
+    if (isUtilStep && pattern === "Verify the file {string} exists") {
+      commands.push({
+        type: "verify_file_exists",
+        parameters: [stepParams[0].text],
+      });
+    } else {
+      for (let i = 0; i < parametersNames.length; i++) {
+        stepParams[i].argumentName = parametersNames[i];
+      }
+
+      for (const { code } of codeCommands) {
+        const command = invertCodeToCommand(code, elements, stepParams, stepsDefinitions, codePage, stepName)[0];
+        if (command === undefined || command.type === null) continue;
+        if (command.element) {
+          const key = command.element.key;
+          if (key && locatorsJson[key]) {
+            command.allStrategyLocators = locatorsJson[key];
+          }
         }
+        commands.push(command);
       }
-      commands.push(command);
     }
   } catch (error) {
     console.error(error);
@@ -782,7 +872,7 @@ export async function executeStep({ stepsDefinitions, cucumberStep, context, cod
   }
 }
 
-export async function updateStepDefinitions({ scenario, featureName, projectDir }) {
+export async function updateStepDefinitionsOld({ scenario, featureName, projectDir, logger }) {
   // set the candidate step definition file name
   // set the utils file path
   const utilsFilePath = path.join(projectDir, "features", "step_definitions", "utils.mjs");
@@ -813,42 +903,37 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
         step.isImplementedWhileRecording = true;
       }
     }
-    if ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0) {
+    if (!step.isUtilStep && ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0)) {
       let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
       if (process.env.TEMP_RUN === "true") {
-        console.log("Save routes in temp folder for running:", routesPath);
         if (existsSync(routesPath)) {
-          console.log("Removing existing temp_routes_folder:", routesPath);
           routesPath = path.join(tmpdir(), `blinq_temp_routes`);
           rmSync(routesPath, { recursive: true });
         }
         mkdirSync(routesPath, { recursive: true });
-        console.log("Created temp_routes_folder:", routesPath);
-        saveRoutes({ step, folderPath: routesPath });
+        saveRoutes({ step, folderPath: routesPath }, logger);
       } else {
-        console.log("Saving routes in project directory:", projectDir);
         if (existsSync(routesPath)) {
-          // remove the folder
           try {
             rmSync(routesPath, { recursive: true });
-            console.log("Removed temp_routes_folder:", routesPath);
           } catch (error) {
-            console.error("Error removing temp_routes folder", error);
+            logger.error(`Error removing temp routes folder: ${getErrorMessage(error)}`);
           }
         }
         routesPath = path.join(projectDir, "data", "routes");
-        console.log("Saving routes to:", routesPath);
         if (!existsSync(routesPath)) {
           mkdirSync(routesPath, { recursive: true });
         }
-        saveRoutes({ step, folderPath: routesPath });
+        saveRoutes({ step, folderPath: routesPath }, logger);
+      }
+      if (step.commands && Array.isArray(step.commands)) {
+        step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
       }
       continue;
     }
     const cucumberStep = getCucumberStep({ step });
-    const pageName = generatePageName(step.startFrame?.url ?? "default");
+    const pageName = generatePageName(step.startFrame?.url ?? "default", step.isUtilStep);
     const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
-    // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
     codePage = await saveRecording({
       step,
@@ -869,7 +954,133 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
 
-export function saveRoutes({ step, folderPath }) {
+export async function updateStepDefinitions({ scenario, featureName, projectDir, logger, bvtSnapshotsDir }) {
+  try {
+    const { featureFolder, utilsFilePath, utilsContent } = handleFileInitOps(projectDir);
+    const steps = scenario.steps;
+
+    const stepsDefinitions = new StepsDefinitions(projectDir);
+    await potentialErrorWrapper(
+      () => stepsDefinitions.load(false),
+      "Failed to load step definitions",
+      SaveJobErrorType.STEP_DEFINITIONS_LOADING_FAILED,
+      logger
+    );
+
+    for (let index = 0; index < steps.length; index++) {
+      const step = steps[index];
+      try {
+        if (step.internalImplementedStepId) {
+          const si = steps.findIndex((s) => s.id === step.internalImplementedStepId);
+          if (si !== -1) {
+            step.isImplementedWhileRecording = true;
+          }
+        }
+
+        const processed = await potentialErrorWrapper(
+          () => {
+            if (!step.isUtilStep && ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0)) {
+              let routesPath = path.join(tmpdir(), FIXED_FOLDER_NAMES.BLINQ_TEMP_ROUTES);
+              if (process.env.TEMP_RUN === "true") {
+                if (existsSync(routesPath)) rmSync(routesPath, { recursive: true });
+                mkdirSync(routesPath, { recursive: true });
+                saveRoutes({ step, folderPath: routesPath }, logger);
+              } else {
+                if (existsSync(routesPath)) {
+                  try {
+                    rmSync(routesPath, { recursive: true });
+                  } catch (error) {
+                    logger.error(`❌ Error removing temp routes folder: ${getErrorMessage(error)}`);
+                  }
+                }
+                routesPath = path.join(projectDir, FIXED_FOLDER_NAMES.DATA, FIXED_FOLDER_NAMES.ROUTES);
+                if (!existsSync(routesPath)) mkdirSync(routesPath, { recursive: true });
+                saveRoutes({ step, folderPath: routesPath }, logger);
+              }
+
+              if (step.commands && Array.isArray(step.commands)) {
+                step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
+              }
+
+              return true;
+            } else {
+              return false;
+            }
+          },
+          "Failed to process step commands and routes",
+          SaveJobErrorType.STEP_COMMANDS_PROCESSING_FAILED,
+          logger
+        );
+        if (processed) continue;
+
+        const { cucumberStep, stepDefsFilePath } = await potentialErrorWrapper(
+          () => {
+            const cucumberStep = getCucumberStep({ step });
+            const pageName = generatePageName(step.startFrame?.url ?? "default", step.isUtilStep);
+            const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
+            return { cucumberStep, stepDefsFilePath };
+          },
+          "Failed to initialize cucumber step and locate definition path",
+          SaveJobErrorType.STEP_INITIALIZATION_FAILED,
+          logger
+        );
+
+        const codePage = await potentialErrorWrapper(
+          async () => {
+            let codePage = getCodePage(stepDefsFilePath);
+            codePage = await saveRecording({
+              step,
+              cucumberStep,
+              codePage,
+              projectDir,
+              stepsDefinitions,
+              parametersMap: scenario.parametersMap,
+              bvtSnapshotsDir,
+            });
+            return codePage;
+          },
+          "Failed to generate and save step definition",
+          SaveJobErrorType.STEP_DEFINITION_UPDATE_FAILED,
+          logger
+        );
+
+        if (!codePage) continue;
+
+        const res = await codePage.save();
+        if (!res) {
+          throw new UpdateStepDefinitionsError({
+            type: SaveJobErrorType.STEP_DEFINITION_UPDATE_FAILED,
+            message: `Failed to save step definition for "${cucumberStep.text}" in "${codePage.sourceFileName}"`,
+          });
+        }
+      } catch (error) {
+        throw error instanceof UpdateStepDefinitionsError
+          ? error
+          : new UpdateStepDefinitionsError({
+              type: SaveJobErrorType.STEP_DEFINITION_UPDATE_FAILED,
+              message: "Failed to update step definition",
+              meta: {
+                stepIndex: index,
+                stepText: step.text,
+                reason: getErrorMessage(error),
+              },
+            });
+      }
+    }
+
+    writeFileSync(utilsFilePath, utilsContent, UTF8_ENCODING);
+  } catch (error) {
+    logger.error(`❌ updateStepDefinitions() failed: ${error?.message ?? String(error)}`);
+    throw error instanceof UpdateStepDefinitionsError
+      ? error
+      : new UpdateStepDefinitionsError({
+          type: SaveJobErrorType.INTERNAL_ERROR,
+          message: error?.message ?? "Unknown error",
+        });
+  }
+}
+
+export function saveRoutes({ step, folderPath }, logger) {
   const routeItems = step.routeItems;
   if (!routeItems || routeItems.length === 0) {
     return;
@@ -892,21 +1103,18 @@ export function saveRoutes({ step, folderPath }) {
     };
   });
 
-  const routesFilePath = path.join(folderPath, stepNameHash + ".json");
-  console.log("Routes file path:", routesFilePath);
+  const routesFilePath = path.join(folderPath, `${stepNameHash}.json`);
   const routesData = {
     template,
     routes: routeItemsWithFilters,
   };
-  console.log("Routes data to save:", routesData);
 
   if (!existsSync(folderPath)) {
     mkdirSync(folderPath, { recursive: true });
   }
   try {
-    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
-    console.log("Saved routes to", routesFilePath);
+    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), UTF8_ENCODING);
   } catch (error) {
-    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+    logger.error(`❌ Error saving routes to ${routesFilePath}: ${getErrorMessage(error)}`);
   }
 }