@dev-blinq/cucumber_client 1.0.1450-dev → 1.0.1450-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,11 +8,438 @@ 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";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
+const convertToIdentifier = (text) => {
+  // replace all invalid characters with _
+  return text.replace(/[^a-zA-Z0-9_]/g, "_");
+};
+
+export const isVariable = (text) => {
+  if (typeof text !== "string") return false;
+  const isParametric = text.startsWith("<") && text.endsWith(">");
+  if (!isParametric) return false;
+  const l = text.length;
+  if (l < 2) return false;
+  const leftindex = text.indexOf("<");
+  const rightindex = text.indexOf(">");
+  return leftindex === 0 && rightindex === l - 1;
+};
+
+export const extractQuotes = (text) => {
+  const stringRegex = /"([^"]*)"/g;
+  const matches = text.match(stringRegex);
+  if (!matches) return [];
+  const quotes = [];
+  for (const match of matches) {
+    const value = match.slice(1, -1);
+    quotes.push(value);
+  }
+  return quotes;
+};
+
+const replaceLastOccurence = (str, search, replacement) => {
+  const lastIndex = str.lastIndexOf(search);
+  if (lastIndex === -1) return str;
+  return str.substring(0, lastIndex) + replacement + str.substring(lastIndex + search.length);
+};
+
+const _toRecordingStep = (cmd, stepText) => {
+  switch (cmd.type) {
+    case "hover_element": {
+      return {
+        type: "hover_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "click_element": {
+      return {
+        type: "click_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        count: cmd.count ?? 1,
+      };
+    }
+    case "context_click": {
+      return {
+        type: "context_click",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        label: cmd.label,
+        value: cmd.value,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        text: cmd.text,
+        count: cmd.count ?? 1,
+      };
+    }
+    case "parameterized_click": {
+      return {
+        type: "parameterized_click",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        label: cmd.label,
+        value: cmd.value,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        count: cmd.count ?? 1,
+      };
+    }
+    case "fill_element": {
+      return {
+        type: "fill_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.value, cmd.enter ?? false],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "select_combobox": {
+      return {
+        type: "select_combobox",
+        element: {
+          role: "combobox",
+          name: cmd.label,
+        },
+        selectMode: "select",
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_page_contains_text": {
+      return {
+        type: "verify_page_contains_text",
+        parameters: [cmd.value, cmd.isRegex],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_element_contains_text": {
+      return {
+        type: "verify_element_contains_text",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.value, cmd.climb],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "close_page": {
+      return {
+        type: "close_page",
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "check_element": {
+      return {
+        type: "check_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        check: cmd.check,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "press_key": {
+      return {
+        type: "press_key",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        key: cmd.value,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "load_user": {
+      return {
+        type: "load_data",
+        parameters: ["users", cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "load_csv": {
+      return {
+        type: "load_data",
+        parameters: ["csv", `${cmd.label}:${cmd.value}`],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "set_date_time": {
+      return {
+        type: "set_date_time",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "set_input": {
+      return {
+        type: "set_input",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        value: cmd.value,
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "extract_attribute": {
+      return {
+        type: "extract_attribute",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.variableName],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        regex: cmd.regex,
+        trimSpaces: cmd.trimSpaces,
+      };
+    }
+    case "extract_property": {
+      return {
+        type: "extract_property",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.variableName],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        regex: cmd.regex,
+        trimSpaces: cmd.trimSpaces,
+      };
+    }
+    case "verify_element_attribute": {
+      return {
+        type: "verify_element_attribute",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_element_property": {
+      return {
+        type: "verify_element_property",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        valueInStepText: stepText && typeof stepText === "string" ? stepText.includes(`"${cmd.value}"`) : false,
+      };
+    }
+    case "conditional_wait": {
+      return {
+        type: "conditional_wait",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.timeout, cmd.selectedField, cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        valueInStepText: stepText && typeof stepText === "string" ? stepText.includes(`"${cmd.value}"`) : false,
+      };
+    }
+    case "navigate": {
+      return {
+        type: "navigate",
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "browser_go_back": {
+      return {
+        type: "browser_go_back",
+      };
+    }
+    case "browser_go_forward": {
+      return {
+        type: "browser_go_forward",
+      };
+    }
+    case "set_input_files": {
+      return {
+        type: "set_input_files",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.files],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_page_snapshot": {
+      return {
+        type: "verify_page_snapshot",
+        parameters: [cmd.value],
+        selectors: cmd.selectors,
+        data: cmd.data,
+        valueInStepText: stepText && typeof stepText === "string" ? stepText.includes(`"${cmd.value}"`) : false,
+      };
+    }
+    default: {
+      return {
+        type: cmd.type,
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+  }
+};
+
+function getBestStrategy(allStrategyLocators) {
+  const orderedPriorities = ["custom", "context", "basic", "text_with_index", "ignore_digit", "no_text"];
+  for (const strategy of orderedPriorities) {
+    if (allStrategyLocators[strategy] && allStrategyLocators[strategy].length > 0) {
+      return strategy;
+    }
+  }
+  return null;
+}
+
+const _parameterizeLocators = (locators, replacementFromValue, replacementToValue) => {
+  for (const loc of locators) {
+    if (loc?.css?.includes(replacementFromValue)) {
+      loc.css = loc.css.replaceAll(replacementFromValue, replacementToValue);
+    }
+    if (loc?.text?.includes(replacementFromValue)) {
+      loc.text = loc.text.replaceAll(replacementFromValue, replacementToValue);
+    }
+    if (loc?.climb && typeof loc.climb === "string" && loc.climb?.includes(replacementFromValue)) {
+      loc.climb = loc.climb.replaceAll(replacementFromValue, replacementToValue);
+    }
+  }
+  return locators;
+};
+const parameterizeLocators = ({ cmd, locs, isValueVariable, isTargetValueVariable, parametersMap }) => {
+  if (isValueVariable) {
+    const variable = cmd.value.slice(1, -1);
+    // 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, stepText) => {
+  if (cmd.type === "api") {
+    return {
+      type: "api",
+      value: cmd.value,
+    };
+  }
+  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 isTargetValueVariable = isVariable(cmd.targetValue);
+  const allStrategyLocators = JSON.parse(JSON.stringify(cmd?.allStrategyLocators ?? null));
+  step.locators = locatorsObject;
+  step.allStrategyLocators = allStrategyLocators;
+  step.isLocatorsAssigned = true;
+
+  if (!isValueVariable && !isTargetValueVariable) {
+    return step;
+  }
+
+  if (isValueVariable) {
+    step.dataSource = "parameters";
+    step.dataKey = convertToIdentifier(cmd.value.slice(1, -1));
+  }
+
+  if (!allStrategyLocators) {
+    let locs = locatorsObject.locators;
+    locs = parameterizeLocators({
+      cmd,
+      locs,
+      isValueVariable,
+      isTargetValueVariable,
+      parametersMap,
+    });
+    locatorsObject.locators = locs;
+    return {
+      ...step,
+      locators: locatorsObject,
+    };
+  }
+
+  for (const key in allStrategyLocators) {
+    if (key === "strategy") continue;
+    if (key === "no_text" || key === "custom") continue;
+    const locators = allStrategyLocators[key];
+    if (locators.length === 0) continue;
+    parameterizeLocators({
+      cmd,
+      locs: locators,
+      isValueVariable,
+      isTargetValueVariable,
+      parametersMap,
+    });
+  }
+
+  locatorsObject.locators = allStrategyLocators[allStrategyLocators.strategy] ?? locatorsObject.locators;
+
+  return {
+    ...step,
+    locators: locatorsObject,
+    allStrategyLocators,
+    isLocatorsAssigned: true,
+  };
+};
+
 export const toMethodName = (str) => {
   // Remove any non-word characters (excluding underscore) and trim spaces
   let cleanStr = str.trim().replace(/[^\w\s]/gi, "");
@@ -36,7 +462,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: [],
@@ -54,12 +480,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("default_page.mjs")) &&
+    !step.shouldMakeStepTextUnique
+  ) {
     return true;
   }
   while (stepDef) {
@@ -70,7 +500,18 @@ function makeStepTextUnique(step, stepsDefinitions) {
   step.text = stepText;
 }
 
-export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
+export async function saveRecording({
+  step,
+  cucumberStep,
+  codePage,
+  projectDir,
+  stepsDefinitions,
+  parametersMap,
+  logger,
+}) {
+  if (step.commands && Array.isArray(step.commands)) {
+    step.commands = step.commands.map((cmd) => toRecordingStep(cmd, parametersMap, step.text));
+  }
   let routesPath = path.join(tmpdir(), "blinq_temp_routes");
 
   if (process.env.TEMP_RUN === "true") {
@@ -78,21 +519,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);
     }
   }
 
@@ -100,48 +539,63 @@ 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("default_page.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;
   const recording = new Recording();
+
   const steps = step.commands;
 
   recording.loadFromObject({ steps, step: cucumberStep });
@@ -192,7 +646,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,
@@ -204,13 +658,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;
@@ -223,15 +680,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,
@@ -241,7 +726,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,
@@ -250,6 +735,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     }
 
     codePage.removeUnusedElements();
+    codePage.mergeSimilarElements();
     cucumberStep.methodName = methodName;
     if (generateCodeResult.locatorsMetadata) {
       codePage.addLocatorsMetadata(generateCodeResult.locatorsMetadata);
@@ -293,7 +779,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 } =
@@ -301,26 +787,35 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
     if (error) {
       throw new Error(error);
     }
+    isUtilStep = codePage.sourceFileName.endsWith("utils.mjs") || codePage.sourceFileName.endsWith("default_page.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);
@@ -368,7 +863,7 @@ export async function executeStep({ stepsDefinitions, cucumberStep, context, cod
   }
 }
 
-export async function updateStepDefinitions({ scenario, featureName, projectDir }) {
+export async function updateStepDefinitions({ 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");
@@ -399,44 +894,46 @@ 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 stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
-    // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
-    codePage = await saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions });
+    codePage = await saveRecording({
+      step,
+      cucumberStep,
+      codePage,
+      projectDir,
+      stepsDefinitions,
+      parametersMap: scenario.parametersMap,
+    });
     if (!codePage) {
       continue;
     }
@@ -448,7 +945,7 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
 
-export function saveRoutes({ step, folderPath }) {
+export function saveRoutes({ step, folderPath }, logger) {
   const routeItems = step.routeItems;
   if (!routeItems || routeItems.length === 0) {
     return;
@@ -471,21 +968,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);
   } catch (error) {
-    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+    logger.error(`Error saving routes to ${routesFilePath}: ${getErrorMessage(error)}`);
   }
 }