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

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/implemented_steps.js

@@ -235,6 +235,7 @@ export const getImplementedSteps = async (projectDir) => {
         pattern: template.pattern,
         paths: template.paths,
         routeItems: step.routeItems,
+        isApiStep: template.source === "api",
       };
 
       implementedSteps.push(implementedStep);
@@ -260,6 +261,7 @@ export const getImplementedSteps = async (projectDir) => {
           mjsFile: template.mjsFile,
           pattern: template.pattern,
           paths: template.paths,
+          isApiStep: template.source === "api",
         };
         // reconstruct the parameters
         const parameters = [];

package/bin/client/recorderv3/index.js

@@ -1,298 +1,5 @@
 import { loadArgs, showUsage, validateCLIArg } from "../cli_helpers.js";
-import { io } from "socket.io-client";
-import { BVTRecorder } from "./bvt_recorder.js";
-import { compareWithScenario } from "../code_gen/duplication_analysis.js";
-import { getAppDataDir } from "./app_dir.js";
-import { readdir } from "fs/promises";
-import socketLogger from "../utils/socket_logger.js";
-
-let port = process.env.EDITOR_PORT || 3003;
-const WS_URL = "http://localhost:" + port;
-
-const responseSize = (response) => {
-  try {
-    if (typeof response !== "string") {
-      return new Blob([JSON.stringify(response)]).size;
-    } else {
-      return new Blob([response]).size;
-    }
-  } catch {
-    return -1;
-  }
-};
-
-class PromisifiedSocketServer {
-  constructor(socket, routes) {
-    this.socket = socket;
-    this.routes = routes;
-  }
-  init() {
-    this.socket.on("request", async (data) => {
-      const { event, input, id, roomId, socketId } = data;
-      if (event !== "recorderWindow.getCurrentChromiumPath") {
-        socketLogger.info("Received request", { event, input, id, roomId, socketId });
-      }
-      try {
-        const handler = this.routes[event];
-        if (!handler) {
-          console.error(`No handler found for event: ${event}`);
-          return;
-        }
-        const response = await handler(input);
-        if (event !== "recorderWindow.getCurrentChromiumPath") {
-          socketLogger.info(`Sending response for ${event}, ${responseSize(response)} bytes`);
-        }
-        this.socket.emit("response", { id, value: response, roomId, socketId });
-      } catch (error) {
-        socketLogger.error("Error handling request", {
-          event,
-          input,
-          id,
-          roomId,
-          socketId,
-          error: error instanceof Error ? `${error.message}\n${error.stack}` : error,
-        });
-        this.socket.emit("response", {
-          id,
-          error: {
-            message: error?.message,
-            code: error?.code,
-            info: error?.info,
-            stack: error?.stack,
-          },
-          roomId,
-          socketId,
-        });
-      }
-    });
-  }
-}
-
-const init = ({ envName, projectDir, roomId, TOKEN }) => {
-  console.log("Connecting to " + WS_URL);
-  const socket = io(WS_URL);
-  socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
-  socket.on("connect", () => {
-    socketLogger.info("Connected to BVTRecorder server");
-    console.log("Connected to BVTRecorder server");
-  });
-  socket.on("disconnect", () => {
-    socketLogger.info("Disconnected from server");
-    console.log("Disconnected from server");
-  });
-  socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
-  const recorder = new BVTRecorder({
-    envName,
-    projectDir,
-    TOKEN,
-    sendEvent: (event, data) => {
-      socketLogger.info("Sending event", { event, data, roomId });
-      socket.emit(event, data, roomId);
-    },
-    logger: socketLogger,
-  });
-  recorder
-    .openBrowser()
-    .then(() => {
-      socketLogger.info("BVTRecorder.browserOpened");
-      socket.emit("BVTRecorder.browserOpened", null, roomId);
-    })
-    .catch((e) => {
-      socketLogger.error("BVTRecorder.browserLaunchFailed", e);
-      socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
-    });
-  const timeOutForFunction = async (promise, timeout = 5000) => {
-    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
-
-    try {
-      const res = await Promise.race([promise, timeoutPromise]);
-      return res;
-    } catch (error) {
-      console.error(error);
-      socketLogger.error(error);
-      throw error;
-    }
-  };
-
-  const promisifiedSocketServer = new PromisifiedSocketServer(socket, {
-    "recorderWindow.openBrowser": async (input) => {
-      return recorder
-        .openBrowser(input)
-        .then(() => {
-          socketLogger.info("BVTRecorder.browserOpened");
-          console.info("BVTRecorder.browserOpened");
-          socket.emit("BVTRecorder.browserOpened", { roomId, window: "cucumber_client/bvt_recorder" });
-        })
-        .catch((e) => {
-          socketLogger.error("Error opening browser", e);
-          console.error("BVTRecorder.browserLaunchFailed", e);
-          socket.emit("BVTRecorder.browserLaunchFailed", { roomId, window: "cucumber_client/bvt_recorder" });
-        });
-    },
-    "recorderWindow.closeBrowser": async (input) => {
-      return recorder.closeBrowser(input);
-    },
-    "recorderWindow.reOpenBrowser": async (input) => {
-      return recorder
-        .reOpenBrowser(input)
-        .then(() => {
-          socketLogger.info("BVTRecorder.browserOpened");
-          console.log("BVTRecorder.browserOpened");
-          socket.emit("BVTRecorder.browserOpened", null, roomId);
-        })
-        .catch((e) => {
-          socketLogger.info("BVTRecorder.browserLaunchFailed");
-          console.error("BVTRecorder.browserLaunchFailed", e);
-          socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
-        });
-    },
-    "recorderWindow.startRecordingInput": async (input) => {
-      return timeOutForFunction(recorder.startRecordingInput(input));
-    },
-    "recorderWindow.stopRecordingInput": async (input) => {
-      return timeOutForFunction(recorder.stopRecordingInput(input));
-    },
-    "recorderWindow.startRecordingText": async (input) => {
-      // console.log("--- {{ }} -- : recorderWindow.startRecordingText", input);
-      return timeOutForFunction(recorder.startRecordingText(input));
-    },
-    "recorderWindow.stopRecordingText": async (input) => {
-      return timeOutForFunction(recorder.stopRecordingText(input));
-    },
-    "recorderWindow.startRecordingContext": async (input) => {
-      return timeOutForFunction(recorder.startRecordingContext(input));
-    },
-    "recorderWindow.stopRecordingContext": async (input) => {
-      return timeOutForFunction(recorder.stopRecordingContext(input));
-    },
-    "recorderWindow.runStep": async (input) => {
-      return recorder.runStep(input);
-    },
-    "recorderWindow.saveScenario": async (input) => {
-      return recorder.saveScenario(input);
-    },
-    "recorderWindow.getImplementedSteps": async (input) => {
-      // console.log("recorderWindow.getImplementedSteps", input);
-      return (await recorder.getImplementedSteps(input)).implementedSteps;
-    },
-    "recorderWindow.getImplementedScenarios": async (input) => {
-      // console.log("recorderWindow.getImplementedScenarios", input);
-      return (await recorder.getImplementedSteps(input)).scenarios;
-    },
-    "recorderWindow.getCurrentChromiumPath": async () => {
-      // console.log("recorderWindow.getCurrentChromiumPath");
-      return await recorder.getCurrentChromiumPath();
-    },
-    "recorderWindow.overwriteTestData": async (input) => {
-      // console.log("recorderWindow.overwriteTestData");
-      return await recorder.overwriteTestData(input);
-    },
-    "recorderWindow.generateStepName": async (input) => {
-      return recorder.generateStepName(input);
-    },
-    "recorderWindow.getFeatureAndScenario": async (input) => {
-      return recorder.generateScenarioAndFeatureNames(input);
-    },
-    "recorderWindow.generateCommandName": async (input) => {
-      return recorder.generateCommandName(input);
-    },
-    "recorderWindow.loadTestData": async (input) => {
-      return recorder.loadTestData(input);
-    },
-    "recorderWindow.discard": async (input) => {
-      return await recorder.discardTestData(input);
-    },
-    "recorderWindow.addToTestData": async (input) => {
-      return await recorder.addToTestData(input);
-    },
-    "recorderWindow.getScenarios": async () => {
-      return recorder.getScenarios();
-    },
-    "recorderWindow.setShouldTakeScreenshot": async (input) => {
-      return recorder.setShouldTakeScreenshot(input);
-    },
-    "recorderWindow.compareWithScenario": async ({ projectDir, scenario }, roomId) => {
-      return await compareWithScenario(getAppDataDir(projectDir), scenario);
-    },
-    "recorderWindow.getCommandsForImplementedStep": async (input) => {
-      return recorder.getCommandsForImplementedStep(input);
-    },
-    "recorderWindow.getNumberOfOccurrences": async (input) => {
-      return recorder.getNumberOfOccurrences(input);
-    },
-    "recorderWindow.abortExecution": async (input) => {
-      return recorder.abortExecution(input);
-    },
-    "recorderWindow.pauseExecution": async (input) => {
-      return recorder.pauseExecution(input);
-    },
-    "recorderWindow.resumeExecution": async (input) => {
-      return recorder.resumeExecution(input);
-    },
-    "recorderWindow.loadExistingScenario": async (input) => {
-      return recorder.loadExistingScenario(input);
-    },
-    "recorderWindow.findRelatedTextInAllFrames": async (input) => {
-      return recorder.findRelatedTextInAllFrames(input);
-    },
-    "recorderWindow.getReportFolder": async (input) => {
-      return recorder.getReportFolder();
-    },
-    "recorderWindow.getSnapshotFiles": async (input) => {
-      const snapshotFolder = recorder.getSnapshotFolder();
-      if (snapshotFolder) {
-        const files = await readdir(snapshotFolder);
-        const ymlFiles = files.filter((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
-        return { folder: snapshotFolder, files: ymlFiles };
-      } else return { folder: null, files: [] };
-    },
-    "recorderWindow.getCurrentPageTitle": async (input) => {
-      return await recorder.getCurrentPageTitle();
-    },
-    "recorderWindow.getCurrentPageUrl": async (input) => {
-      return await recorder.getCurrentPageUrl();
-    },
-    "recorderWindow.sendAriaSnapshot": async (input) => {
-      const snapshot = input?.snapshot;
-      const deselect = input?.deselect;
-      if (deselect === true) {
-        return await recorder.deselectAriaElements();
-      }
-      if (snapshot !== null) {
-        return await recorder.processAriaSnapshot(snapshot);
-      }
-    },
-    "recorderWindow.revertMode": async (input) => {
-      await recorder.revertMode();
-    },
-    "recorderWindow.setMode": async (input) => {
-      const mode = input?.mode;
-      return recorder.setMode(mode);
-    },
-    "recorderWindow.getStepsAndCommandsForScenario": async (input) => {
-      return await recorder.getStepsAndCommandsForScenario(input);
-    },
-    "recorderWindow.getNetworkEvents": async (input) => {
-      return await recorder.getNetworkEvents(input);
-    },
-    "recorderWindow.initExecution": async (input) => {
-      return await recorder.initExecution(input);
-    },
-    "recorderWindow.cleanupExecution": async (input) => {
-      return await recorder.cleanupExecution(input);
-    },
-    "recorderWindow.resetExecution": async (input) => {
-      return await recorder.resetExecution(input);
-    },
-    "recorderWindow.stopRecordingNetwork": async (input) => {
-      return recorder.stopRecordingNetwork(input);
-    },
-  });
-  socket.on("targetBrowser.command.event", async (input) => {
-    return recorder.onAction(input);
-  });
-  promisifiedSocketServer.init();
-};
+import { BVTRecorderInit } from "./bvt_init.js";
 
 const usage = `Usage: node bvt_recorder.js <projectDir> <envName> <roomId>`;
 const args = loadArgs();
@@ -301,6 +8,7 @@ const envName = args[1].split("=")[1];
 const roomId = args[2];
 const shouldTakeScreenshot = args[3];
 const TOKEN = process.env.TOKEN;
+
 try {
   validateCLIArg(projectDir, "projectDir");
   validateCLIArg(envName, "envName");
@@ -312,14 +20,4 @@ try {
 } catch (error) {
   showUsage(error, usage);
 }
-try {
-  init({
-    envName,
-    projectDir,
-    roomId,
-    TOKEN,
-    shouldTakeScreenshot: shouldTakeScreenshot ? shouldTakeScreenshot === "true" : false,
-  });
-} catch (error) {
-  console.error(error);
-}
+BVTRecorderInit({ envName, projectDir, roomId, TOKEN });

package/bin/client/recorderv3/mixpanel.js

@@ -0,0 +1,39 @@
+import mixpanel from "mixpanel";
+let mixpanelClient = null;
+let mixPaneltoken = getMixpanelToken();
+function getMixpanelToken() {
+    if (process.env.MIXPANEL_TOKEN) {
+        const token = process.env.MIXPANEL_TOKEN;
+        if (["local-worker", "cloud-worker"].includes(process.env.CC_SOURCE || "")) {
+            delete process.env.MIXPANEL_TOKEN;
+        }
+        return token;
+    }
+    return null;
+}
+if (mixPaneltoken && process.env.NODE_ENV_BLINQ === "prod") {
+    mixpanelClient = mixpanel.init(mixPaneltoken, {});
+    console.log("✅Mixpanel client initialized.");
+}
+else {
+    console.info("MIXPANEL_TOKEN is not defined.");
+}
+export function mixpanelTrackEvent(event, distinctId, properties = {}) {
+    if (mixpanelClient === null)
+        return;
+    mixpanelClient.track(event, {
+        distinct_id: distinctId,
+        env: process.env.NODE_ENV_BLINQ || "local",
+        ...properties,
+    });
+}
+export function mixpanelTrackEventIdentifyUser(distinctId, properties = {}) {
+    if (mixpanelClient === null)
+        return;
+    mixpanelClient.people.set(distinctId, properties);
+}
+export const MIXPANEL_EVENTS = {
+    STEP_IN_SCENARIO: "There is a step in the scenario",
+    RECORDER_CONNECTED: "Recorder session initiated",
+    CHROMIUM_LOADED: "Chromium loaded",
+};