@dev-blinq/cucumber_client 1.0.1469-stage → 1.0.1470-stage

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/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

@@ -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));
@@ -761,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);
@@ -863,7 +872,7 @@ export async function executeStep({ stepsDefinitions, cucumberStep, context, cod
   }
 }
 
-export async function updateStepDefinitions({ scenario, featureName, projectDir, logger }) {
+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");
@@ -945,6 +954,130 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir,
   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);
+    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 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) {
@@ -978,8 +1111,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.js";
+
+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.1469-stage",
+  "version": "1.0.1470-stage",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",