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

package/bin/client/recorderv3/step_runner.js

@@ -1,6 +1,5 @@
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import path from "path";
-import fs from "fs";
 import { generatePageName } from "../code_gen/playwright_codeget.js";
 import {
   executeStep,
@@ -9,43 +8,69 @@ import {
   getUtilsCodePage,
   loadStepDefinitions,
   saveRecording,
+  saveRoutes,
 } from "./step_utils.js";
 import { escapeString, getExamplesContent } from "./update_feature.js";
+import fs from "fs";
 import { locateDefinitionPath } from "../cucumber/steps_definitions.js";
+import { tmpdir } from "os";
 
-// let copiedCodeToTemp = false;
-async function withAbort(fn, signal) {
-  if (!signal) {
-    return await fn();
-  }
-
-  const abortPromise = new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(new Error("Aborted")), { once: true });
-  });
-
-  return await Promise.race([fn(), abortPromise]);
-}
 export class BVTStepRunner {
-  #currentStepController;
+  #currentStepController = null;
   #port;
-  constructor({ projectDir }) {
+  #lastAttemptedCmdId = null;
+
+  constructor({ projectDir, sendExecutionStatus, bvtContext }) {
     this.projectDir = projectDir;
+    this.sendExecutionStatus = sendExecutionStatus;
+    this.bvtContext = bvtContext;
+    this.liveExecutionMap = new Map();
   }
+
   setRemoteDebugPort(port) {
     this.#port = port;
   }
+
+  // Abort the current cucumber step execution by signaling the wrapper
   async abortExecution() {
+    if (this.bvtContext.web.pausedCmd) {
+      this.bvtContext.web.pausedCmd = null;
+    }
+    this.liveExecutionMap.clear();
     if (this.#currentStepController) {
       this.#currentStepController.abort();
     }
   }
 
+  async pauseExecution(cmdId) {
+    if (this.bvtContext.web) {
+      this.bvtContext.web.pausedCmd = this.liveExecutionMap.get(cmdId);
+    }
+  }
+
+  async resumeExecution(cmdId) {
+    if (this.bvtContext.web.pausedCmd) {
+      const { resolve } = this.bvtContext.web.pausedCmd;
+      if (resolve) {
+        resolve();
+      }
+      this.bvtContext.web.pausedCmd = null;
+    } else {
+      if (this.liveExecutionMap.has(cmdId)) {
+        const { resolve } = this.liveExecutionMap.get(cmdId);
+        if (resolve) {
+          resolve();
+        }
+      } else {
+        console.warn(`No paused command found for cmdId: ${cmdId}`);
+      }
+    }
+  }
+
   async copyCodetoTempFolder({ step, parametersMap, tempFolderPath }) {
-    // const tempFolderPath = path.join(this.projectDir, "__temp_features");
     if (!fs.existsSync(tempFolderPath)) {
       fs.mkdirSync(tempFolderPath);
     }
-    //copy all files from "./features" "./temp" folder
     if (fs.existsSync(tempFolderPath)) {
       fs.rmSync(tempFolderPath, { recursive: true });
     }
@@ -53,14 +78,13 @@ export class BVTStepRunner {
       overwrite: true,
       recursive: true,
     });
-    // copiedCodeToTemp = true;
   }
 
-  async writeTempFeatureFile({ step, parametersMap, tempFolderPath }) {
+  async writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags }) {
     const tFilePath = path.join(tempFolderPath, "__temp.feature");
-    // console.log(tFilePath);
     let tFileContent = `# temp feature file
     Feature: Temp feature
+    ${tags ? tags.join(" ") : ""}
     Scenario Outline: Temp Scenario
       Given ${escapeString(step.text)}
     `;
@@ -68,67 +92,295 @@ export class BVTStepRunner {
     writeFileSync(tFilePath, tFileContent);
     return tFilePath;
   }
-  async runStep({ step, parametersMap, envPath }, bvtContext, options) {
-    let codePage; // = getCodePage();
-    // const tempFolderPath = process.env.tempFeaturesFolderPath;
-    const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
-    const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
-    process.env.tempFeaturesFolderPath = __temp_features_FolderName;
-    process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
-    // if (!copiedCodeToTemp) {
-    // await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
-    // }
-    await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
-    // console.log({ feature_file_path });
-    let stepsDefinitions = loadStepDefinitions(this.projectDir, false, true);
-    // console.log({ stepsDefinitions });
-    const cucumberStep = getCucumberStep({ step });
-    if (cucumberStep.parameters && Array.isArray(cucumberStep.parameters)) {
-      cucumberStep.parameters.forEach((param) => {
-        if (param.variableName) {
-          param.callValue = parametersMap[param.variableName];
-        }
+
+  // Generate wrapper code that integrates AbortSignal into cucumber step definitions
+  generateWrapperCode() {
+    return `
+    import {setDefinitionFunctionWrapper} from "@dev-blinq/cucumber-js";
+    
+    setDefinitionFunctionWrapper((fn) => {
+  return async function (...args) {
+    const signal = global.__BVT_STEP_ABORT_SIGNAL;
+    if (signal) {
+      signal.throwIfAborted?.();
+      const abortHandler = () => {
+        throw new Error("Aborted");
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      try {
+        return await fn.apply(this, args);
+      } finally {
+        signal.removeEventListener("abort", abortHandler);
+      }
+    }
+    return await fn.apply(this, args);
+  };
+});
+
+    `;
+  }
+
+  // Write the wrapper code to temp folder
+  async writeWrapperCode(tempFolderPath, abortSignal) {
+    // tempFolderPath/step_definitions/utils.mjs -> Make a file name that follows this file but always before the next file
+    let fileName = "utils" + Math.random().toString(36).substring(2, 7) + ".mjs";
+    while (existsSync(path.join(tempFolderPath, "step_definitions", fileName))) {
+      fileName = "utils" + Math.random().toString(36).substring(2, 7) + ".mjs";
+    }
+    const wrapperCode = this.generateWrapperCode();
+
+    // Ensure directory exists
+    const stepDefinitionFolderPath = path.join(tempFolderPath, "step_definitions");
+    if (!existsSync(stepDefinitionFolderPath)) {
+      mkdirSync(stepDefinitionFolderPath, { recursive: true });
+    }
+
+    writeFileSync(path.join(stepDefinitionFolderPath, fileName), wrapperCode);
+
+    // Set the abort signal globally so the wrapper can access it
+    global.__BVT_STEP_ABORT_SIGNAL = abortSignal;
+
+    return path.join(stepDefinitionFolderPath, fileName);
+  }
+
+  // Execute cucumber step - simplified without abort signal handling at this level
+  async executeStepWithAbort({ feature_file_path, scenario, tempFolderPath, stepText, config }, options) {
+    const { skipAfter = true, skipBefore = true } = options || {};
+
+    const environment = { ...process.env };
+    const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
+
+    const { runConfiguration } = await loadConfiguration(
+      {
+        provided: {
+          name: [scenario],
+          paths: [feature_file_path],
+          import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
+        },
+      },
+      { cwd: process.cwd(), env: environment }
+    );
+
+    const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
+
+    support.afterTestRunHookDefinitions = [];
+    if (skipAfter) {
+      support.afterTestCaseHookDefinitions = [];
+    }
+    if (skipBefore && !config.legacySyntax) {
+      support.beforeTestCaseHookDefinitions = support.beforeTestCaseHookDefinitions.filter((hook) => {
+        return hook.uri.endsWith("utils.mjs");
       });
     }
+    support.beforeTestRunHookDefinitions = [];
 
-    if (!step.isImplemented && step.commands.length > 0) {
-      const pageName = generatePageName(step.startFrame?.url ?? "default");
-      const stepDefinitionFolderPath = path.join(tempFolderPath, "step_definitions");
-      if (!existsSync(stepDefinitionFolderPath)) {
-        mkdirSync(stepDefinitionFolderPath, { recursive: true });
-      }
-      const stepDefsFilePath = locateDefinitionPath(tempFolderPath, pageName);
-      //path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
-      codePage = getCodePage(stepDefsFilePath);
-      codePage = await saveRecording({ step, cucumberStep, codePage, projectDir: this.projectDir, stepsDefinitions });
-      if (codePage) {
-        await codePage.save(stepDefsFilePath);
-        // console.log("saved code page: ", stepDefsFilePath);
+    let errorMessage = null;
+    let info = null;
+    let errInfo = null;
+
+    const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
+      if (message.testStepFinished) {
+        const { testStepFinished } = message;
+        const { testStepResult } = testStepFinished;
+        if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
+          if (!errorMessage) {
+            errorMessage = testStepResult.message;
+            if (info) {
+              errInfo = info;
+            }
+          }
+        }
+        if (testStepResult.status === "UNDEFINED") {
+          if (!errorMessage) {
+            errorMessage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+            if (info) {
+              errInfo = info;
+            }
+          }
+        }
       }
-      if (!codePage) {
-        codePage = getUtilsCodePage(this.projectDir);
+      if (message.attachment) {
+        const attachment = message.attachment;
+        if (attachment.mediaType === "application/json" && attachment.body) {
+          const body = JSON.parse(attachment.body);
+          info = body.info;
+          const result = body.result;
+
+          if (result.status === "PASSED") {
+            this.sendExecutionStatus({
+              type: "cmdExecutionSuccess",
+              cmdId: body.cmdId,
+              selectedStrategy: info?.selectedStrategy,
+            });
+          } else {
+            this.sendExecutionStatus({
+              type: "cmdExecutionError",
+              cmdId: body.cmdId,
+              error: {
+                message: result.message,
+                info,
+              },
+            });
+          }
+        } else if (attachment.mediaType === "application/json+intercept-results" && attachment.body) {
+          const body = JSON.parse(attachment.body);
+          if (body) {
+            this.sendExecutionStatus({
+              type: "interceptResults",
+              interceptResults: body,
+            });
+          }
+        }
       }
+    });
+
+    if (errorMessage) {
+      const bvtError = new Error(errorMessage);
+      Object.assign(bvtError, { info: errInfo });
+      throw bvtError;
     }
-    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath });
-    // console.log({ feature_file_path, step_text: step.text });
 
-    const stepExecController = new AbortController();
-    this.#currentStepController = stepExecController;
-    await withAbort(async () => {
-      await stepsDefinitions.executeStepRemote(
+    return { result, info };
+  }
+
+  async runStep({ step, parametersMap, envPath, tags, config }, bvtContext, options) {
+    // Create a new AbortController for this specific step execution
+    this.#currentStepController = new AbortController();
+    const { signal } = this.#currentStepController;
+
+    try {
+      this.#lastAttemptedCmdId = null;
+      let cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+      bvtContext.web.pausedCmd = null;
+
+      // Clear the liveExecutionMap and set up new entries for this step
+      this.liveExecutionMap.clear();
+
+      for (const cmdId of cmdIDs) {
+        this.liveExecutionMap.set(cmdId, {
+          resolve: () => {},
+          reject: () => {},
+        });
+      }
+
+      if (bvtContext.web) {
+        bvtContext.web.getCmdId = () => {
+          if (cmdIDs.length === 0) {
+            cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+          }
+          const cId = cmdIDs.shift();
+          this.sendExecutionStatus({
+            type: "cmdExecutionStart",
+            cmdId: cId,
+          });
+          this.#lastAttemptedCmdId = cId;
+          return cId;
+        };
+      }
+
+      const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+      const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+      process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+      process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+
+      await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
+
+      // Write abort wrapper code with this step's signal
+      await this.writeWrapperCode(tempFolderPath, signal);
+
+      let stepsDefinitions = loadStepDefinitions(this.projectDir, false, true);
+      const cucumberStep = getCucumberStep({ step });
+
+      if (cucumberStep.parameters && Array.isArray(cucumberStep.parameters)) {
+        cucumberStep.parameters.forEach((param) => {
+          if (param.variableName) {
+            param.callValue = parametersMap[param.variableName];
+          }
+        });
+      }
+
+      if (!step.isImplemented && step.commands.length > 0) {
+        const pageName = generatePageName(step.startFrame?.url ?? "default");
+        const stepDefinitionFolderPath = path.join(tempFolderPath, "step_definitions");
+        if (!existsSync(stepDefinitionFolderPath)) {
+          mkdirSync(stepDefinitionFolderPath, { recursive: true });
+        }
+        const stepDefsFilePath = locateDefinitionPath(tempFolderPath, pageName);
+        let codePage = getCodePage(stepDefsFilePath);
+        codePage = await saveRecording({
+          step,
+          cucumberStep,
+          codePage,
+          projectDir: this.projectDir,
+          stepsDefinitions,
+        });
+        if (codePage) {
+          await codePage.save(stepDefsFilePath);
+        }
+        if (!codePage) {
+          codePage = getUtilsCodePage(this.projectDir);
+        }
+      } else {
+        let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+        if (process.env.TEMP_RUN === "true") {
+          if (existsSync(routesPath)) {
+            rmSync(routesPath, { recursive: true });
+          }
+          mkdirSync(routesPath, { recursive: true });
+          saveRoutes({ step, folderPath: routesPath });
+        } else {
+          if (existsSync(routesPath)) {
+            try {
+              rmSync(routesPath, { recursive: true });
+            } catch (error) {
+              console.error("Error removing temp_routes folder", error);
+            }
+          }
+          routesPath = path.join(this.projectDir, "data", "routes");
+          if (!existsSync(routesPath)) {
+            mkdirSync(routesPath, { recursive: true });
+          }
+          saveRoutes({ step, folderPath: routesPath });
+        }
+      }
+
+      const feature_file_path = await this.writeTempFeatureFile({
+        step,
+        parametersMap,
+        tempFolderPath,
+        tags,
+      });
+
+      // Execute the cucumber step - if wrapper throws "Aborted", it will propagate up
+      const { result, info } = await this.executeStepWithAbort(
         {
           feature_file_path,
           tempFolderPath,
           stepText: step.text,
           scenario: "Temp Scenario",
+          config,
         },
         options
       );
-    }, stepExecController.signal).finally(() => {
-      // rm temp folder
-      if (fs.existsSync(tempFolderPath)) {
-        fs.rmSync(tempFolderPath, { recursive: true });
+
+      return { result, info };
+    } catch (error) {
+      if (error.message && error.message.includes("Aborted")) {
+        throw new Error("Aborted");
+      } else throw error;
+    } finally {
+      // Clean up this step's controller and global reference
+      this.#currentStepController = null;
+      global.__BVT_STEP_ABORT_SIGNAL = null;
+
+      // Clean up temp folder
+      const __temp_features_FolderName = process.env.tempFeaturesFolderPath;
+      if (__temp_features_FolderName) {
+        const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+        if (fs.existsSync(tempFolderPath)) {
+          fs.rmSync(tempFolderPath, { recursive: true });
+        }
       }
-    });
+    }
   }
 }

package/bin/client/recorderv3/step_utils.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import url from "url";
 import logger from "../../logger.js";
@@ -9,6 +9,8 @@ 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";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -69,19 +71,74 @@ function makeStepTextUnique(step, stepsDefinitions) {
 }
 
 export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
-  // console.log("saveRecording", step.text);
+  let routesPath = path.join(tmpdir(), "blinq_temp_routes");
+
+  if (process.env.TEMP_RUN) {
+    if (existsSync(routesPath)) {
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    saveRoutes({ step, folderPath: routesPath });
+  } 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);
+      }
+      routesPath = path.join(projectDir, "data", "routes");
+      if (!existsSync(routesPath)) {
+        mkdirSync(routesPath, { recursive: true });
+      }
+      saveRoutes({ step, folderPath: routesPath });
+    }
+  }
+
   if (step.isImplementedWhileRecording && !process.env.TEMP_RUN) {
     return;
   }
+
   if (step.isImplemented && step.shouldOverride) {
     let stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
   } else {
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
+
     if (isUtilStep) {
       return;
     }
   }
+
+  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 });
+  } 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);
+      }
+    }
+    routesPath = path.join(projectDir, "data", "routes");
+    console.log("Saving routes to:", routesPath);
+    if (!existsSync(routesPath)) {
+      mkdirSync(routesPath, { recursive: true });
+    }
+    saveRoutes({ step, folderPath: routesPath });
+  }
+
   cucumberStep.text = step.text;
   const recording = new Recording();
   const steps = step.commands;
@@ -108,6 +165,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       isStaticToken,
       status,
     } = step.commands[0].value;
+
     const result = await generateApiCode(
       {
         url,
@@ -132,6 +190,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
+
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
         name: step.text,
@@ -139,6 +198,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
         source: "recorder",
       });
     }
+
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -166,7 +226,13 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       path
     );
     const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
-    const stepResult = codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), methodName, steps.length);
+    const stepResult = codePage.addCucumberStep(
+      keyword,
+      cucumberStep.getTemplate(),
+      methodName,
+      steps.length,
+      step.finalTimeout
+    );
 
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
@@ -306,6 +372,12 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   const utilsTemplateFilePath = path.join(__dirname, "../../assets", "templates", "utils_template.txt");
   const utilsContent = readFileSync(utilsTemplateFilePath, "utf8");
   writeFileSync(utilsFilePath, utilsContent, "utf8");
+  const hooksTemplateFilePath = path.join(__dirname, "../../assets", "templates", "_hooks_template.txt");
+  if (existsSync(hooksTemplateFilePath)) {
+    const hooksFilePath = path.join(stepDefinitionFolderPath, "_hooks.mjs");
+    const hooksContent = readFileSync(hooksTemplateFilePath, "utf8");
+    writeFileSync(hooksFilePath, hooksContent, "utf8");
+  }
   const steps = scenario.steps;
 
   const stepsDefinitions = new StepsDefinitions(projectDir);
@@ -321,6 +393,34 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
       }
     }
     if ((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);
+          rmSync(routesPath, { recursive: true });
+        }
+        mkdirSync(routesPath, { recursive: true });
+        console.log("Created temp_routes_folder:", routesPath);
+        saveRoutes({ step, folderPath: routesPath });
+      } 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);
+          }
+        }
+        routesPath = path.join(projectDir, "data", "routes");
+        console.log("Saving routes to:", routesPath);
+        if (!existsSync(routesPath)) {
+          mkdirSync(routesPath, { recursive: true });
+        }
+        saveRoutes({ step, folderPath: routesPath });
+      }
       continue;
     }
     const cucumberStep = getCucumberStep({ step });
@@ -328,7 +428,6 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
     const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
     // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
-
     codePage = await saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions });
     if (!codePage) {
       continue;
@@ -340,3 +439,45 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   }
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
+
+export function saveRoutes({ step, folderPath }) {
+  const routeItems = step.routeItems;
+  if (!routeItems || routeItems.length === 0) {
+    return;
+  }
+  const cucumberStep = getCucumberStep({ step });
+  const template = cucumberStep.getTemplate();
+  const stepNameHash = createHash("sha256").update(template).digest("hex");
+  console.log("Saving routes for step:", step.text, "with hash:", stepNameHash);
+
+  const routeItemsWithFilters = routeItems.map((routeItem) => {
+    const oldFilters = routeItem.filters;
+    const queryParamsObject = {};
+    oldFilters.queryParams.forEach((queryParam) => {
+      queryParamsObject[queryParam.key] = queryParam.value;
+    });
+    const newFilters = { path: oldFilters.path, method: oldFilters.method, queryParams: queryParamsObject };
+    return {
+      ...routeItem,
+      filters: newFilters,
+    };
+  });
+
+  const routesFilePath = path.join(folderPath, stepNameHash + ".json");
+  console.log("Routes file path:", routesFilePath);
+  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);
+  }
+}