@gatling.io/cli 3.11.6 → 3.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.6",
+  "version": "3.12.0",
   "license": "Apache-2.0",
   "bin": {
     "gatling": "target/index.js"
@@ -9,21 +9,21 @@
   "types": "target/index.d.ts",
   "dependencies": {
     "archiver": "7.0.1",
-    "axios": "1.7.2",
+    "axios": "1.7.7",
     "commander": "12.1.0",
     "decompress": "4.2.1",
-    "esbuild": "0.23.0",
+    "esbuild": "0.23.1",
     "esbuild-plugin-tsc": "0.4.0",
     "readline-sync": "1.4.10"
   },
   "devDependencies": {
     "@types/archiver": "6.0.2",
     "@types/decompress": "4.2.7",
-    "@types/node": "20.14.12",
+    "@types/node": "18.19.50",
     "@types/readline-sync": "1.4.8",
     "prettier": "3.3.3",
     "rimraf": "6.0.1",
-    "typescript": "5.5.3"
+    "typescript": "5.5.4"
   },
   "scripts": {
     "clean": "rimraf target",

package/src/bundle.ts

@@ -0,0 +1,36 @@
+import * as esbuild from "esbuild";
+import esbuildPluginTsc from "esbuild-plugin-tsc";
+
+import { SimulationFile } from "./simulations";
+import { logger } from "./log";
+
+export interface BundleOptions {
+  sourcesFolder: string;
+  bundleFile: string;
+  typescript: boolean;
+  simulations: SimulationFile[];
+}
+
+export const bundle = async (options: BundleOptions): Promise<void> => {
+  logger.info(`Bundling a Gatling simulation with options:
+ - sourcesFolder: ${options.sourcesFolder}
+ - bundleFile: ${options.bundleFile}
+ - typescript: ${options.typescript}`);
+
+  const contents = options.simulations.map((s) => `export { default as "${s.name}" } from "./${s.path}";`).join("\n");
+
+  const plugins = options.typescript ? [esbuildPluginTsc({ force: true })] : [];
+  await esbuild.build({
+    stdin: {
+      contents,
+      resolveDir: options.sourcesFolder
+    },
+    outfile: options.bundleFile,
+    bundle: true,
+    minify: false,
+    sourcemap: true,
+    format: "iife",
+    globalName: "gatling",
+    plugins
+  });
+};

package/src/commands/build.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults
+} from "./options";
+import { findSimulations } from "../simulations";
+import { bundle } from "../bundle";
+
+export default (program: Command): void => {
+  program
+    .command("build")
+    .description("Build Gatling simulations")
+    .addOption(sourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(typescriptOption)
+    .action(async (options) => {
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      await bundle({ sourcesFolder, bundleFile, typescript, simulations });
+    });
+};

package/src/commands/enterpriseDeploy.ts

@@ -0,0 +1,88 @@
+import { Command } from "commander";
+
+import {
+  apiTokenOption,
+  apiTokenOptionValue,
+  bundleFileOption,
+  bundleFileOptionValue,
+  controlPlaneUrlOption,
+  controlPlaneUrlOptionValue,
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  nonInteractiveOption,
+  nonInteractiveOptionValue,
+  packageDescriptorFilenameOption,
+  packageDescriptorFilenameOptionValue,
+  packageFileOption,
+  packageFileOptionValue,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults,
+  urlOption,
+  urlOptionValue
+} from "./options";
+import { findSimulations } from "../simulations";
+import { installGatlingJs } from "../dependencies";
+import { bundle } from "../bundle";
+import { enterpriseDeploy, enterprisePackage } from "../enterprise";
+
+export default (program: Command): void => {
+  program
+    .command("enterprise-deploy")
+    .description("Deploy a package and configured simulations")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(resultsFolderOption)
+    .addOption(typescriptOption)
+    .addOption(gatlingHomeOption)
+    // Base
+    .addOption(urlOption)
+    .addOption(apiTokenOption)
+    // Plugin configuration
+    .addOption(controlPlaneUrlOption)
+    .addOption(nonInteractiveOption)
+    // Descriptor file
+    .addOption(packageDescriptorFilenameOption)
+    // Deployment info
+    .addOption(packageFileOption)
+    .action(async (options) => {
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const url = urlOptionValue(options);
+      const apiToken = apiTokenOptionValue(options);
+      const controlPlaneUrl = controlPlaneUrlOptionValue(options);
+      const nonInteractive = nonInteractiveOptionValue(options);
+      const packageDescriptorFilename = packageDescriptorFilenameOptionValue(options);
+      const packageFile = packageFileOptionValue(options);
+
+      const { graalvmHome, jvmClasspath } = await installGatlingJs({ gatlingHome });
+      await bundle({ sourcesFolder, bundleFile, typescript, simulations });
+      await enterprisePackage({ bundleFile, resourcesFolder, packageFile, simulations });
+      await enterpriseDeploy({
+        graalvmHome,
+        jvmClasspath,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        url,
+        apiToken,
+        controlPlaneUrl,
+        nonInteractive,
+        packageDescriptorFilename,
+        packageFile
+      });
+    });
+};

package/src/commands/enterprisePackage.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  packageFileOption,
+  packageFileOptionValue,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults
+} from "./options";
+import { findSimulations } from "../simulations";
+import { bundle } from "../bundle";
+import { enterprisePackage } from "../enterprise";
+
+export default (program: Command): void => {
+  program
+    .command("enterprise-package")
+    .description("Build Gatling simulations and package them for Gatling Enterprise")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(packageFileOption)
+    .addOption(typescriptOption)
+    .action(async (options) => {
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const packageFile = packageFileOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      await bundle({ sourcesFolder, bundleFile, typescript, simulations });
+
+      await enterprisePackage({ bundleFile, resourcesFolder, packageFile, simulations });
+    });
+};

package/src/commands/enterpriseStart.ts

@@ -0,0 +1,113 @@
+import { Command } from "commander";
+
+import {
+  apiTokenOption,
+  apiTokenOptionValue,
+  bundleFileOption,
+  bundleFileOptionValue,
+  controlPlaneUrlOption,
+  controlPlaneUrlOptionValue,
+  enterpriseSimulationOption,
+  enterpriseSimulationOptionValue,
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  nonInteractiveOption,
+  nonInteractiveOptionValue,
+  packageDescriptorFilenameOption,
+  packageDescriptorFilenameOptionValue,
+  packageFileOption,
+  packageFileOptionValue,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  runDescriptionOption,
+  runDescriptionOptionValue,
+  runTitleOption,
+  runTitleOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults,
+  urlOption,
+  urlOptionValue,
+  waitForRunEndOption,
+  waitForRunEndOptionValue
+} from "./options";
+import { findSimulations } from "../simulations";
+import { installGatlingJs } from "../dependencies";
+import { bundle } from "../bundle";
+import { enterprisePackage, enterpriseStart } from "../enterprise";
+
+export default (program: Command): void => {
+  program
+    .command("enterprise-start")
+    .description("Start a simulation deployed with `enterprise-deploy`")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(resultsFolderOption)
+    .addOption(typescriptOption)
+    .addOption(gatlingHomeOption)
+    // Base
+    .addOption(urlOption)
+    .addOption(apiTokenOption)
+    // Plugin configuration
+    .addOption(controlPlaneUrlOption)
+    .addOption(nonInteractiveOption)
+    // Descriptor file
+    .addOption(packageDescriptorFilenameOption)
+    // Deployment info
+    .addOption(packageFileOption)
+    // Start
+    .addOption(enterpriseSimulationOption)
+    .addOption(runTitleOption)
+    .addOption(runDescriptionOption)
+    .addOption(waitForRunEndOption)
+    .action(async (options) => {
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const url = urlOptionValue(options);
+      const apiToken = apiTokenOptionValue(options);
+      const controlPlaneUrl = controlPlaneUrlOptionValue(options);
+      const nonInteractive = nonInteractiveOptionValue(options);
+      const packageDescriptorFilename = packageDescriptorFilenameOptionValue(options);
+      const packageFile = packageFileOptionValue(options);
+      const enterpriseSimulation = enterpriseSimulationOptionValue(options);
+      const runTitle = runTitleOptionValue(options);
+      const runDescription = runDescriptionOptionValue(options);
+      const waitForRunEnd = waitForRunEndOptionValue(options);
+
+      if (nonInteractiveOptionValue(options) && enterpriseSimulation === undefined) {
+        throw new Error(`No simulation specified when using non-interactive mode`);
+      }
+
+      const { graalvmHome, jvmClasspath } = await installGatlingJs({ gatlingHome });
+      await bundle({ sourcesFolder, bundleFile, typescript, simulations });
+      await enterprisePackage({ bundleFile, resourcesFolder, packageFile, simulations });
+      await enterpriseStart({
+        graalvmHome,
+        jvmClasspath,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        url,
+        apiToken,
+        controlPlaneUrl,
+        nonInteractive,
+        packageDescriptorFilename,
+        packageFile,
+        enterpriseSimulation,
+        runTitle,
+        runDescription,
+        waitForRunEnd
+      });
+    });
+};

package/src/commands/index.ts

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+
+import registerInstallCommand from "./install";
+import registerBuildCommand from "./build";
+import registerRunOnlyCommand from "./runOnly";
+import registerRunCommand from "./run";
+import registerRecorderCommand from "./recorder";
+import registerEnterprisePackageCommand from "./enterprisePackage";
+import registerEnterpriseDeployCommand from "./enterpriseDeploy";
+import registerEnterpriseStartCommand from "./enterpriseStart";
+import { versions } from "../dependencies";
+
+export const program: Command = new Command()
+  .name("gatling-js-cli")
+  .version(versions.gatling.jsAdapter)
+  .description("The Gatling Javascript run & packaging tool");
+
+registerInstallCommand(program);
+registerBuildCommand(program);
+registerRunOnlyCommand(program);
+registerRunCommand(program);
+registerRecorderCommand(program);
+registerEnterprisePackageCommand(program);
+registerEnterpriseDeployCommand(program);
+registerEnterpriseStartCommand(program);

package/src/commands/install.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+
+import { gatlingHomeOption, gatlingHomeOptionValueWithDefaults } from "./options";
+import { installGatlingJs } from "../dependencies";
+import { logger } from "../log";
+
+export default (program: Command): void => {
+  program
+    .command("install")
+    .description("Install all required components and dependencies for Gatling")
+    .addOption(gatlingHomeOption)
+    .action(async (options) => {
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const { graalvmHome, coursierBinary, jvmClasspath } = await installGatlingJs({ gatlingHome });
+      logger.info(`graalvmHome=${graalvmHome}`);
+      logger.info(`coursierBinary=${coursierBinary}`);
+      logger.info(`jvmClasspath=${jvmClasspath}`);
+    });
+};

package/src/commands/options.ts

@@ -0,0 +1,263 @@
+import { Option, Argument } from "commander";
+import os from "os";
+
+import { SimulationFile } from "../simulations";
+import { keyInSelectPaginated } from "../readline";
+import { logger } from "../log";
+
+const getStringValueOptional =
+  (option: Option) =>
+  (options: any): string | undefined => {
+    const value = options[option.attributeName()];
+    if (typeof value === "string" || typeof value === "undefined") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type string|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getStringValueMandatory =
+  (option: Option) =>
+  (options: any): string => {
+    const value = options[option.attributeName()];
+    if (typeof value === "string") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type string for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getBooleanValueOptional =
+  (option: Option) =>
+  (options: any): boolean | undefined => {
+    const value = options[option.attributeName()];
+    if (typeof value === "boolean" || typeof value === "undefined") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type boolean|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getBooleanValueMandatory =
+  (option: Option) =>
+  (options: any): boolean => {
+    const value = options[option.attributeName()];
+    if (typeof value === "boolean") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type boolean for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getNumberValueOptional =
+  (option: Option) =>
+  (options: any): number | undefined => {
+    const value = options[option.attributeName()];
+    if (typeof value === "number" || typeof value === "undefined") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type number|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+
+export const gatlingHomeOption = new Option(
+  "--gatling-home <value>",
+  'The folder used to download and install Gatling components (default: "~/.gatling")'
+);
+export const gatlingHomeOptionValueWithDefaults = (options: any): string =>
+  getStringValueOptional(gatlingHomeOption)(options) || `${os.homedir()}/.gatling`;
+
+export const sourcesFolderOption = new Option("--sources-folder <value>", "The sources folder path").default("src");
+export const sourcesFolderOptionValue = getStringValueMandatory(sourcesFolderOption);
+
+export const simulationOption = new Option(
+  "--simulation <value>",
+  "The simulation entry point function name (default: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)"
+);
+export const simulationOptionValueWithDefaults = (
+  options: any,
+  simulationsFound: SimulationFile[],
+  interactive: boolean
+): string => {
+  const declaredSimulation = getStringValueOptional(simulationOption)(options);
+  if (declaredSimulation !== undefined) {
+    return declaredSimulation;
+  } else if (simulationsFound.length === 1) {
+    return simulationsFound[0].name;
+  } else if (simulationsFound.length === 0) {
+    throw new Error(
+      "No simulation found, simulations must be defined in a <simulation name>.gatling.js or <simulation name>.gatling.ts file)"
+    );
+  } else if (interactive) {
+    const idx = keyInSelectPaginated(
+      simulationsFound.map((s) => s.name).sort((a, b) => a.localeCompare(b)),
+      "Choose a simulation to run"
+    );
+    if (idx >= 0) {
+      const simulation = simulationsFound[idx].name;
+      logger.info(`Simulation '${simulation}' was chosen.`);
+      return simulation;
+    } else {
+      throw new Error("Simulation choice was cancelled.");
+    }
+  } else {
+    throw new Error(
+      `Several simulations found, specify one using the --simulation option (available simulations: ${simulationsFound.map((s) => s.name)})`
+    );
+  }
+};
+
+export const simulationMandatoryOption = new Option(
+  "--simulation <value>",
+  "The simulation entry point function name"
+).makeOptionMandatory(true);
+export const simulationMandatoryOptionValue = getStringValueMandatory(simulationMandatoryOption);
+
+export const bundleFileOption = new Option(
+  "--bundle-file <value>",
+  "The target bundle file path when building simulations (must have a .js extension)"
+)
+  .default("target/bundle.js")
+  .argParser((value) => {
+    if (!value.endsWith(".js")) {
+      throw Error(`'${value}' is not a valid bundle file path: should have a .js extension`);
+    }
+    return value;
+  });
+export const bundleFileOptionValue = getStringValueMandatory(bundleFileOption);
+
+export const packageFileOption = new Option(
+  "--package-file <value>",
+  "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)"
+)
+  .default("target/package.zip")
+  .argParser((value) => {
+    if (!value.endsWith(".zip")) {
+      throw Error(`'${value}' is not a valid package file path: should have a .zip extension`);
+    }
+    return value;
+  });
+export const packageFileOptionValue = getStringValueMandatory(packageFileOption);
+
+export const resourcesFolderOption = new Option("--resources-folder <value>", "The resources folder path").default(
+  "resources"
+);
+export const resourcesFolderOptionValue = getStringValueMandatory(resourcesFolderOption);
+
+export const resultsFolderOption = new Option("--results-folder <value>", "The results folder path").default(
+  "target/gatling"
+);
+export const resultsFolderOptionValue = getStringValueMandatory(resultsFolderOption);
+
+export const typescriptOption = new Option(
+  "--typescript",
+  "Use the typescript compiler to compile your code (default: true if the sourcesFolder contains any *.gatling.ts file, false otherwise)"
+);
+export const typescriptOptionValueWithDefaults = (options: any, simulationsFound: SimulationFile[]): boolean => {
+  const value = getBooleanValueOptional(typescriptOption)(options);
+  return value !== undefined ? value : simulationsFound.findIndex((s) => s.type === "typescript") >= 0;
+};
+
+export const graalvmHomeMandatoryOption = new Option(
+  "--graalvm-home <value>",
+  "Path to the GraalVM home"
+).makeOptionMandatory(true);
+export const graalvmHomeMandatoryOptionValue = getStringValueMandatory(graalvmHomeMandatoryOption);
+
+export const jvmClasspathMandatoryOption = new Option(
+  "--jvm-classpath <value>",
+  "The classpath containing all Gatling JVM components"
+).makeOptionMandatory(true);
+export const jvmClasspathMandatoryOptionValue = getStringValueMandatory(jvmClasspathMandatoryOption);
+
+export const memoryOption = new Option(
+  "--memory <value>",
+  "Heap space memory size in MiB for Gatling. Half the total available memory is usually a good default, as the Gatling process will use more memory than just the heap space."
+).argParser((value) => {
+  const parsedValue = parseInt(value, 10);
+  if (isNaN(parsedValue)) {
+    throw new Error(`${value} is not a valid memory size, must be an integer number`);
+  }
+  return parsedValue;
+});
+export const memoryOptionValue = getNumberValueOptional(memoryOption);
+
+export const nonInteractiveOption = new Option(
+  "--non-interactive",
+  "Switch to non-interactive mode and fail if no simulation is explicitly specified"
+).default(false);
+export const nonInteractiveOptionValue = getBooleanValueMandatory(nonInteractiveOption);
+
+export const runParametersArgument = new Argument(
+  "[optionKey=optionValue...]",
+  "Specify one or more parameter which can be read in the simulation script with the getParameter() function; format must be key=value"
+);
+export const parseRunParametersArgument = (args: string[]): Record<string, string> => {
+  const parsedParameters: Record<string, string> = {};
+  for (const arg of args) {
+    const i = arg.indexOf("=");
+    if (i < 0) {
+      throw Error(`Parameter '${arg}' is not valid: format should be key=value`);
+    } else {
+      const key = arg.slice(0, i).trim();
+      parsedParameters[key] = arg.slice(i + 1);
+    }
+  }
+  return parsedParameters;
+};
+
+export const urlOption = new Option("--url <value>", "URL of Gatling Enterprise")
+  .default("https://cloud.gatling.io")
+  .hideHelp();
+export const urlOptionValue = getStringValueMandatory(urlOption);
+
+export const apiTokenOption = new Option(
+  "--api-token <value>",
+  "API Token on Gatling Enterprise. Prefer configuration using `GATLING_ENTERPRISE_API_TOKEN` environment variable."
+);
+export const apiTokenOptionValue = getStringValueOptional(apiTokenOption);
+
+// Plugin configuration
+
+export const controlPlaneUrlOption = new Option(
+  "--control-plane-url <value>",
+  "URL of a control plane for Gatling Enterprise providing a private repository. If this parameter is provided, packages will be registered as private packages and uploaded through this private control plane."
+);
+export const controlPlaneUrlOptionValue = getStringValueOptional(controlPlaneUrlOption);
+
+// Descriptor file
+
+export const packageDescriptorFilenameOption = new Option(
+  "--package-descriptor-filename <value>",
+  "Path to a package descriptor inside the .gatling folder"
+).default("package.conf");
+export const packageDescriptorFilenameOptionValue = getStringValueMandatory(packageDescriptorFilenameOption);
+
+// Deployment info
+
+export const enterpriseSimulationOption = new Option(
+  "--enterprise-simulation <value>",
+  "Specify the simulation name directly to bypass the prompt using the following command."
+);
+export const enterpriseSimulationOptionValue = getStringValueOptional(enterpriseSimulationOption);
+
+export const runTitleOption = new Option("--run-title <value>", "Allows setting a title for your run reports.");
+export const runTitleOptionValue = getStringValueOptional(runTitleOption);
+
+export const runDescriptionOption = new Option(
+  "--run-description <value>",
+  "Allows setting a description for your run reports summary."
+);
+export const runDescriptionOptionValue = getStringValueOptional(runDescriptionOption);
+
+export const waitForRunEndOption = new Option(
+  "--wait-for-run-end",
+  "Wait for the result after starting the simulation on Gatling Enterprise, and complete with an error if the simulation ends with any error status"
+).default(false);
+export const waitForRunEndOptionValue = getBooleanValueMandatory(waitForRunEndOption);