@dev-blinq/cucumber_client 1.0.1728-dev → 1.0.1729-dev

package/bin/client/recorderv3/services.js

@@ -147,7 +147,7 @@ export class NamesService {
         }
         return result.data;
     }
-    async generateLocatorDescriptions({ locatorsObj }) {
+    async generateLocatorDescriptions({ locatorsObj, }) {
         const url = `${getRunsServiceBaseURL()}/locate/generate_locator_summaries`;
         const result = await axiosClient({
             url,
@@ -172,6 +172,7 @@ export class PublishService {
     constructor(TOKEN) {
         this.TOKEN = TOKEN;
     }
+    //! deprecated
     async saveScenario({ scenario, featureName, override, branch, isEditing, projectId, env, AICode }) {
         const runsURL = getRunsServiceBaseURL();
         const workspaceURL = runsURL.replace("/runs", "/workspace");

package/bin/client/recorderv3/step_utils.js

@@ -863,87 +863,104 @@ export async function executeStep({ stepsDefinitions, cucumberStep, context, cod
     throw new Error(`Step definition not found for "${cucumberStep.text}"`);
   }
 }
-
+class DomainError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = 500; // default, can override in subclasses
+    if (typeof Object.setPrototypeOf === "function") {
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  }
+}
 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");
-  const stepDefinitionFolderPath = path.join(projectDir, "features", "step_definitions");
-  if (!existsSync(stepDefinitionFolderPath)) {
-    mkdirSync(stepDefinitionFolderPath, { recursive: true });
-  }
-  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;
+  try {
+    const utilsFilePath = path.join(projectDir, "features", "step_definitions", "utils.mjs");
+    const stepDefinitionFolderPath = path.join(projectDir, "features", "step_definitions");
+    if (!existsSync(stepDefinitionFolderPath)) {
+      mkdirSync(stepDefinitionFolderPath, { recursive: true });
+    }
 
-  const stepsDefinitions = new StepsDefinitions(projectDir);
-  const featureFolder = path.join(projectDir, "features");
-  stepsDefinitions.load(false);
-  // const parameters = scenario.parameters;
-  // await saveRecordings({ steps, parameters, codePage, projectDir });
-  for (const step of steps) {
-    if (step.internalImplementedStepId) {
-      const si = steps.findIndex((s) => s.id === step.internalImplementedStepId);
-      if (si !== -1) {
-        step.isImplementedWhileRecording = true;
-      }
+    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");
     }
-    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") {
-        if (existsSync(routesPath)) {
-          routesPath = path.join(tmpdir(), `blinq_temp_routes`);
-          rmSync(routesPath, { recursive: true });
+
+    const steps = scenario.steps;
+    const stepsDefinitions = new StepsDefinitions(projectDir);
+    const featureFolder = path.join(projectDir, "features");
+
+    stepsDefinitions.load(false);
+
+    for (const step of steps) {
+      if (step.internalImplementedStepId) {
+        const si = steps.findIndex((s) => s.id === step.internalImplementedStepId);
+        if (si !== -1) {
+          step.isImplementedWhileRecording = 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)}`);
+      }
+
+      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") {
+          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, "data", "routes");
+          if (!existsSync(routesPath)) mkdirSync(routesPath, { recursive: true });
+          saveRoutes({ step, folderPath: routesPath }, logger);
         }
-        routesPath = path.join(projectDir, "data", "routes");
-        if (!existsSync(routesPath)) {
-          mkdirSync(routesPath, { recursive: true });
+
+        if (step.commands && Array.isArray(step.commands)) {
+          step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
         }
-        saveRoutes({ step, folderPath: routesPath }, logger);
+
+        continue;
       }
-      if (step.commands && Array.isArray(step.commands)) {
-        step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
+
+      const cucumberStep = getCucumberStep({ step });
+      const pageName = generatePageName(step.startFrame?.url ?? "default", step.isUtilStep);
+      const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
+      let codePage = getCodePage(stepDefsFilePath);
+
+      codePage = await saveRecording({
+        step,
+        cucumberStep,
+        codePage,
+        projectDir,
+        stepsDefinitions,
+        parametersMap: scenario.parametersMap,
+      });
+
+      if (!codePage) continue;
+
+      const res = await codePage.save();
+      if (!res) {
+        throw new DomainError(
+          `Failed to save step definition for "${cucumberStep.text}" in "${codePage.sourceFileName}"`
+        );
       }
-      continue;
-    }
-    const cucumberStep = getCucumberStep({ step });
-    const pageName = generatePageName(step.startFrame?.url ?? "default", step.isUtilStep);
-    const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
-    let codePage = getCodePage(stepDefsFilePath);
-    codePage = await saveRecording({
-      step,
-      cucumberStep,
-      codePage,
-      projectDir,
-      stepsDefinitions,
-      parametersMap: scenario.parametersMap,
-    });
-    if (!codePage) {
-      continue;
-    }
-    const res = await codePage.save();
-    if (!res) {
-      throw new Error(`Failed to save step definition for "${cucumberStep.text}" in "${codePage.sourceFileName}"`);
     }
+
+    writeFileSync(utilsFilePath, utilsContent, "utf8");
+  } catch (error) {
+    logger.error(`❌ updateStepDefinitions() failed: ${error?.message ?? String(error)}`);
+    throw error instanceof DomainError ? error : new DomainError(error?.message ?? "Unknown error");
   }
-  writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
 
 export function saveRoutes({ step, folderPath }, logger) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1728-dev",
+  "version": "1.0.1729-dev",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",