@dev-blinq/cucumber_client 1.0.1732-dev → 1.0.1733-dev

package/bin/client/cucumber/steps_definitions.js

@@ -100,18 +100,10 @@ class StepsDefinitions {
       this.initPage(codePage, mjsFile);
     }
     let stepCount = Object.keys(this.steps).length;
-    if (this.steps["Before"]) {
-      stepCount--;
-    }
-    if (this.steps["After"]) {
-      stepCount--;
-    }
-    if (this.steps["BeforeAll"]) {
-      stepCount--;
-    }
-    if (this.steps["AfterAll"]) {
-      stepCount--;
-    }
+    if (this.steps["Before"]) stepCount--;
+    if (this.steps["After"]) stepCount--;
+    if (this.steps["BeforeAll"]) stepCount--;
+    if (this.steps["AfterAll"]) stepCount--;
     if (print) {
       logger.info("total steps definitions found", stepCount);
     }

package/bin/client/recorderv3/constants.js

@@ -0,0 +1,45 @@
+export const FIXED_FOLDER_NAMES = {
+  STEP_DEFINITIONS: "step_definitions",
+  FEATURES: "features",
+  ASSETS: "assets",
+  TEMPLATES: "templates",
+  BLINQ_TEMP_ROUTES: "blinq_temp_routes",
+  DATA: "data",
+  ROUTES: "routes",
+};
+
+export const FIXED_FILE_NAMES = {
+  UTILS: "utils.mjs",
+  UTILS_TEMPLATE: "utils_template.txt",
+  HOOKS_TEMPLATE: "_hooks_template.txt",
+  HOOKS: "_hooks.mjs",
+};
+
+export const UTF8_ENCODING = "utf8";
+
+export class UpdateStepDefinitionsError extends Error {
+  constructor({ type, message, statusCode = 500, meta } = {}) {
+    super(message);
+
+    this.name = "UpdateStepDefinitionsError";
+    this.type = type;
+    this.statusCode = statusCode;
+    this.meta = meta;
+
+    if (typeof Object.setPrototypeOf === "function") {
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  }
+}
+export const SaveJobErrorType = {
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  STEP_ERROR: "STEP_ERROR",
+  GIT_ERROR: "GIT_ERROR",
+  UNKNOWN: "UNKNOWN",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  STEP_DEFINITION_UPDATE_FAILED: "STEP_DEFINITION_UPDATE_FAILED",
+  FILE_SYSTEM_ERROR: "FILE_SYSTEM_ERROR",
+  STEP_DEFINITIONS_LOADING_FAILED: "STEP_DEFINITIONS_LOADING_FAILED",
+  STEP_COMMANDS_PROCESSING_FAILED: "STEP_COMMANDS_PROCESSING_FAILED",
+  STEP_INITIALIZATION_FAILED: "STEP_INITIALIZATION_FAILED",
+};

package/bin/client/recorderv3/step_utils.js

@@ -11,6 +11,14 @@ import { generateApiCode } from "../code_gen/api_codegen.js";
 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));
 
@@ -454,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;
@@ -508,6 +516,7 @@ export async function saveRecording({
   stepsDefinitions,
   parametersMap,
   logger,
+  bvtSnapshotsDir,
 }) {
   if (step.commands && Array.isArray(step.commands)) {
     step.commands = step.commands.map((cmd) => toRecordingStep(cmd, parametersMap, step.text));
@@ -762,7 +771,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);
@@ -863,40 +872,101 @@ 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 }) {
-  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 utilsTemplateFilePath = path.join(__dirname, "../../assets", "templates", "utils_template.txt");
-    const utilsContent = readFileSync(utilsTemplateFilePath, "utf8");
-    writeFileSync(utilsFilePath, utilsContent, "utf8");
+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");
+  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;
 
-    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 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;
+      }
+    }
+    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 });
+        }
+        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);
+      }
+      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", 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");
+}
 
+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);
-    const featureFolder = path.join(projectDir, "features");
 
-    stepsDefinitions.load(false);
+    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];
@@ -908,66 +978,104 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir,
           }
         }
 
-        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)}`);
+        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);
               }
-            }
-            routesPath = path.join(projectDir, "data", "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));
-          }
+              if (step.commands && Array.isArray(step.commands)) {
+                step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
+              }
 
-          return;
-        }
+              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 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,
-        });
+        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) return;
+        if (!codePage) continue;
 
         const res = await codePage.save();
         if (!res) {
-          throw new DomainError(
-            `Failed to save step definition for "${cucumberStep.text}" in "${codePage.sourceFileName}"`
-          );
+          throw new UpdateStepDefinitionsError({
+            type: SaveJobErrorType.STEP_DEFINITION_UPDATE_FAILED,
+            message: `Failed to save step definition for "${cucumberStep.text}" in "${codePage.sourceFileName}"`,
+          });
         }
       } catch (error) {
-        logger.error(`❌ Failed to update step definition for step "${step.text}": ${getErrorMessage(error)}`);
-        throw new DomainError(
-          `Failed to update step definition for step "${step.text}" at index ${index}: ${getErrorMessage(error)}`
-        );
+        throw 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");
+    writeFileSync(utilsFilePath, utilsContent, UTF8_ENCODING);
   } catch (error) {
     logger.error(`❌ updateStepDefinitions() failed: ${error?.message ?? String(error)}`);
-    throw error instanceof DomainError ? error : new DomainError(error?.message ?? "Unknown error");
+    throw error instanceof UpdateStepDefinitionsError
+      ? error
+      : new UpdateStepDefinitionsError({
+          type: SaveJobErrorType.INTERNAL_ERROR,
+          message: error?.message ?? "Unknown error",
+        });
   }
 }
 
@@ -1004,8 +1112,8 @@ export function saveRoutes({ step, folderPath }, logger) {
     mkdirSync(folderPath, { recursive: true });
   }
   try {
-    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
+    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), UTF8_ENCODING);
   } catch (error) {
-    logger.error(`Error saving routes to ${routesFilePath}: ${getErrorMessage(error)}`);
+    logger.error(`❌ Error saving routes to ${routesFilePath}: ${getErrorMessage(error)}`);
   }
 }

package/bin/client/recorderv3/utils.js

@@ -0,0 +1,74 @@
+import { getErrorMessage } from "../utils/socket_logger.js";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import {
+  FIXED_FILE_NAMES,
+  FIXED_FOLDER_NAMES,
+  SaveJobErrorType,
+  UpdateStepDefinitionsError,
+  UTF8_ENCODING,
+} from "./constants";
+
+export function handleFileInitOps(projectDir) {
+  try {
+    const stepDefinitionFolderPath = path.join(
+      projectDir,
+      FIXED_FOLDER_NAMES.FEATURES,
+      FIXED_FOLDER_NAMES.STEP_DEFINITIONS
+    );
+    if (!existsSync(stepDefinitionFolderPath)) {
+      mkdirSync(stepDefinitionFolderPath, { recursive: true });
+    }
+
+    const utilsFilePath = path.join(
+      projectDir,
+      FIXED_FOLDER_NAMES.FEATURES,
+      FIXED_FOLDER_NAMES.STEP_DEFINITIONS,
+      FIXED_FILE_NAMES.UTILS
+    );
+
+    const utilsTemplateFilePath = path.join(
+      __dirname,
+      `../../${FIXED_FOLDER_NAMES.ASSETS}`,
+      FIXED_FOLDER_NAMES.TEMPLATES,
+      FIXED_FILE_NAMES.UTILS_TEMPLATE
+    );
+    const utilsContent = readFileSync(utilsTemplateFilePath, UTF8_ENCODING);
+    writeFileSync(utilsFilePath, utilsContent, UTF8_ENCODING);
+
+    const hooksTemplateFilePath = path.join(
+      __dirname,
+      `../../${FIXED_FOLDER_NAMES.ASSETS}`,
+      FIXED_FOLDER_NAMES.TEMPLATES,
+      FIXED_FILE_NAMES.HOOKS_TEMPLATE
+    );
+    if (existsSync(hooksTemplateFilePath)) {
+      const hooksFilePath = path.join(stepDefinitionFolderPath, FIXED_FILE_NAMES.HOOKS);
+      const hooksContent = readFileSync(hooksTemplateFilePath, UTF8_ENCODING);
+      writeFileSync(hooksFilePath, hooksContent, UTF8_ENCODING);
+    }
+
+    const featureFolder = path.join(projectDir, FIXED_FOLDER_NAMES.FEATURES);
+
+    return { featureFolder, utilsFilePath, utilsContent };
+  } catch (error) {
+    throw new UpdateStepDefinitionsError({
+      type: SaveJobErrorType.FILE_SYSTEM_ERROR,
+      message: "Failed to initialize step definition folder structure",
+      meta: { reason: getErrorMessage(error) },
+    });
+  }
+}
+
+export async function potentialErrorWrapper(fn, errorMessage, type, logger) {
+  try {
+    return await fn();
+  } catch (error) {
+    logger.error(`❌ ${errorMessage}: ${getErrorMessage(error)}`);
+    throw new UpdateStepDefinitionsError({
+      type: type,
+      message: errorMessage,
+      meta: { reason: getErrorMessage(error) },
+    });
+  }
+}

package/package.json

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