@gatling.io/cli 3.11.2 → 3.11.3

package/README.md

@@ -0,0 +1,15 @@
+# Gatling JS - CLI
+
+Gatling JS is a JavaScript/TypeScript interface for the [Gatling load testing tool](https://gatling.io/).
+
+This package contains a command-line utility for use with Gatling JS, to allow you to easily build and run you Gatling JS projects.
+
+To get started with Gatling JS, see our [introduction to JavaScript scripting](https://docs.gatling.io/tutorials/scripting-intro-js); or simply have a look at [our demo projects](https://github.com/gatling/gatling-js-demo).
+
+## Questions, help?
+
+Read the [documentation](https://docs.gatling.io).
+
+Join the [Gatling Community Forum](https://community.gatling.io).
+
+Found a real bug? Raise an [issue](https://github.com/gatling/gatling/issues).

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.2",
+  "version": "3.11.3",
   "license": "Apache-2.0",
   "bin": {
-    "gatling-js-cli": "target/index.js"
+    "gatling": "target/index.js"
   },
   "main": "target/index.js",
   "types": "target/index.d.ts",
@@ -22,7 +22,7 @@
     "typescript": "5.4.5"
   },
   "scripts": {
-    "clean": "rimraf target results tmp",
+    "clean": "rimraf target",
     "format": "prettier --write '**/*.ts'",
     "build": "tsc -p . && chmod +x ./target/index.js"
   }

package/target/bundle.d.ts

@@ -1,5 +1,5 @@
 export interface BundleOptions {
-    entrypointFile: string;
+    sourcesFolder: string;
     bundleFile: string;
     typescript: boolean;
 }

package/target/bundle.js

@@ -29,14 +29,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bundle = void 0;
 const esbuild = __importStar(require("esbuild"));
 const esbuild_plugin_tsc_1 = __importDefault(require("esbuild-plugin-tsc"));
+const promises_1 = __importDefault(require("fs/promises"));
 const log_1 = require("./log");
 const bundle = async (options) => {
     log_1.logger.info(`Packaging a Gatling simulation with options:
- - entrypointFile: ${options.entrypointFile}
+ - sourcesFolder: ${options.sourcesFolder}
  - bundleFile: ${options.bundleFile}`);
+    const children = await promises_1.default.readdir(options.sourcesFolder, { recursive: false });
+    const contents = children
+        .filter((f) => (options.typescript ? f.endsWith(".gatling.ts") : f.endsWith(".gatling.js")))
+        .map((f) => `export { default as "${f.slice(0, -11)}" } from "./${f}";`)
+        .join("\n");
     const plugins = options.typescript ? [(0, esbuild_plugin_tsc_1.default)({ force: true })] : [];
     await esbuild.build({
-        entryPoints: [options.entrypointFile],
+        stdin: {
+            contents,
+            resolveDir: options.sourcesFolder
+        },
         outfile: options.bundleFile,
         bundle: true,
         minify: false,

package/target/dependencies/coursier.d.ts

@@ -0,0 +1,3 @@
+export declare const installCoursier: (gatlingHomeDir: string, downloadDir: string) => Promise<string>;
+export declare const resolveGatlingJsDependencies: (coursierPath: string, javaHome: string) => Promise<string>;
+export declare const resolveRecorderDependencies: (coursierPath: string, javaHome: string) => Promise<string>;

package/target/dependencies/coursier.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRecorderDependencies = exports.resolveGatlingJsDependencies = exports.installCoursier = void 0;
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const download_1 = require("./download");
+const log_1 = require("../log");
+const versions_1 = require("./versions");
+const util_1 = require("util");
+const child_process_1 = require("child_process");
+const os_1 = require("./os");
+const installCoursier = async (gatlingHomeDir, downloadDir) => {
+    const coursierRootPath = `${gatlingHomeDir}/coursier/${versions_1.versions.coursier}`;
+    const coursierPath = `${coursierRootPath}/cs`;
+    if (!(0, fs_1.existsSync)(coursierPath)) {
+        const jarUrl = `https://github.com/coursier/coursier/releases/download/v${versions_1.versions.coursier}/coursier`;
+        const windowsBatUrl = `https://github.com/coursier/launchers/raw/master/coursier.bat`;
+        const downloadPath = `${downloadDir}/cs`;
+        if ((0, fs_1.existsSync)(coursierRootPath)) {
+            await promises_1.default.rm(coursierRootPath, { recursive: true });
+        }
+        if ((0, fs_1.existsSync)(downloadPath)) {
+            await promises_1.default.rm(downloadPath);
+        }
+        await promises_1.default.mkdir(coursierRootPath, { recursive: true });
+        log_1.logger.info(`Downloading Coursier ${versions_1.versions.coursier} to ${downloadPath}`);
+        await (0, download_1.downloadFile)(jarUrl, downloadPath);
+        if (os_1.osType === "Windows_NT") {
+            await (0, download_1.downloadFile)(windowsBatUrl, `${downloadPath}.bat`);
+        }
+        else {
+            await promises_1.default.chmod(downloadPath, 0o744);
+        }
+        log_1.logger.info(`Installing Coursier to ${coursierPath}`);
+        await promises_1.default.rename(downloadPath, coursierPath);
+        if (os_1.osType === "Windows_NT") {
+            await promises_1.default.rename(`${downloadPath}.bat`, `${coursierPath}.bat`);
+        }
+    }
+    else {
+        log_1.logger.info(`Coursier ${versions_1.versions.coursier} already installed at ${coursierPath}`);
+    }
+    return coursierPath;
+};
+exports.installCoursier = installCoursier;
+const resolveGatlingJsDependencies = async (coursierPath, javaHome) => {
+    const gatlingDep = `"io.gatling.highcharts:gatling-charts-highcharts:${versions_1.versions.gatling.core}"`;
+    const gatlingAdapterDep = `"io.gatling:gatling-jvm-to-js-adapter:${versions_1.versions.gatling.jsAdapter}"`;
+    const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`;
+    return await resolveDependencies(coursierPath, javaHome, gatlingDep, gatlingAdapterDep, graalvmJsDep);
+};
+exports.resolveGatlingJsDependencies = resolveGatlingJsDependencies;
+const resolveRecorderDependencies = async (coursierPath, javaHome) => {
+    const recorderDep = `io.gatling:gatling-recorder:${versions_1.versions.gatling.core}`;
+    return await resolveDependencies(coursierPath, javaHome, recorderDep);
+};
+exports.resolveRecorderDependencies = resolveRecorderDependencies;
+const resolveDependencies = async (coursierPath, javaHome, ...dependencies) => {
+    const command = `"${coursierPath}" fetch --classpath ${dependencies.join(" ")}`;
+    // TODO could add a timeout
+    log_1.logger.info(`Resolving dependencies with Coursier`);
+    const { stdout } = await execAsync(command, { env: { ...process.env, JAVA_HOME: javaHome } });
+    return stdout;
+};
+const execAsync = (0, util_1.promisify)(child_process_1.exec);

package/target/dependencies/graalVm.d.ts

@@ -0,0 +1 @@
+export declare const installGraalVm: (gatlingHomeDir: string, downloadDir: string) => Promise<string>;

package/target/dependencies/graalVm.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installGraalVm = void 0;
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const decompress_1 = __importDefault(require("decompress"));
+const download_1 = require("./download");
+const log_1 = require("../log");
+const os_1 = require("./os");
+const versions_1 = require("./versions");
+const installGraalVm = async (gatlingHomeDir, downloadDir) => {
+    const { os, arch, extension, homePath, binPath } = graalVmPlatformParams();
+    const graalvmRootPath = `${gatlingHomeDir}/graalvm/${versions_1.versions.graalvm.jdk}`;
+    const graalvmHomePath = `${graalvmRootPath}${homePath}`;
+    const graalvmJavaPath = `${graalvmHomePath}${binPath}`;
+    if (!(0, fs_1.existsSync)(graalvmJavaPath)) {
+        const url = `https://github.com/graalvm/graalvm-ce-builds/releases/download/jdk-${versions_1.versions.graalvm.jdk}/graalvm-community-jdk-${versions_1.versions.graalvm.jdk}_${os}-${arch}_bin.${extension}`;
+        const downloadPath = `${downloadDir}/graalvm.${extension}`;
+        if ((0, fs_1.existsSync)(graalvmRootPath)) {
+            await promises_1.default.rm(graalvmRootPath, { recursive: true });
+        }
+        if ((0, fs_1.existsSync)(downloadPath)) {
+            await promises_1.default.rm(downloadPath);
+        }
+        await promises_1.default.mkdir(graalvmRootPath, { recursive: true });
+        log_1.logger.info(`Downloading GraalVM Community Edition ${versions_1.versions.graalvm.jdk} to ${downloadPath}`);
+        await (0, download_1.downloadFile)(url, downloadPath);
+        log_1.logger.info(`Unpacking GraalVM to ${graalvmRootPath}`);
+        await (0, decompress_1.default)(downloadPath, graalvmRootPath, {
+            map: (file) => {
+                // Remove first level of file name, because it already contains a root directory
+                file.path = file.path.split("/").slice(1).join("/");
+                return file;
+            }
+        });
+        await promises_1.default.rm(downloadPath);
+    }
+    else {
+        log_1.logger.info(`GraalVM Community Edition ${versions_1.versions.graalvm.jdk} already installed at ${graalvmRootPath}`);
+    }
+    return graalvmHomePath;
+};
+exports.installGraalVm = installGraalVm;
+const graalVmPlatformParams = () => {
+    if (os_1.osType === "Linux") {
+        const os = "linux";
+        const extension = "tar.gz";
+        const homePath = "";
+        const binPath = "/bin/java";
+        if (os_1.osArch === "x64") {
+            return { os, arch: "x64", extension, homePath, binPath };
+        }
+        else if (os_1.osArch === "arm64") {
+            return { os, arch: "aarch64", extension, homePath, binPath };
+        }
+    }
+    else if (os_1.osType === "Darwin") {
+        const os = "macos";
+        const extension = "tar.gz";
+        const homePath = "/Contents/Home";
+        const binPath = "/bin/java";
+        if (os_1.osArch === "x64") {
+            return { os, arch: "x64", extension, homePath, binPath };
+        }
+        else if (os_1.osArch === "arm64") {
+            return { os, arch: "aarch64", extension, homePath, binPath };
+        }
+    }
+    else if (os_1.osType === "Windows_NT" && os_1.osArch === "x64") {
+        return { os: "windows", arch: "x64", extension: "zip", homePath: "", binPath: "/bin/java.exe" };
+    }
+    throw Error(`Operating system type '${os_1.osType}' with architecture '${os_1.osArch}' is not currently supported.`);
+};

package/target/dependencies/index.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-import { exec } from "child_process";
-export declare const execAsync: typeof exec.__promisify__;
 export interface DependenciesOptions {
     gatlingHome: string;
 }
@@ -9,4 +6,5 @@ export interface ResolvedDependencies {
     coursierBinary: string;
     jvmClasspath: string;
 }
-export declare const installAll: (options: DependenciesOptions) => Promise<ResolvedDependencies>;
+export declare const installGatlingJs: (options: DependenciesOptions) => Promise<ResolvedDependencies>;
+export declare const installRecorder: (options: DependenciesOptions) => Promise<ResolvedDependencies>;

package/target/dependencies/index.js

@@ -3,125 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installAll = exports.execAsync = void 0;
-const child_process_1 = require("child_process");
-const decompress_1 = __importDefault(require("decompress"));
-const fs_1 = require("fs");
+exports.installRecorder = exports.installGatlingJs = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
-const os_1 = __importDefault(require("os"));
-const util_1 = require("util");
-const download_1 = require("./download");
-const log_1 = require("../log");
-const versions_1 = require("./versions");
-exports.execAsync = (0, util_1.promisify)(child_process_1.exec);
-const installAll = async (options) => {
+const coursier_1 = require("./coursier");
+const graalVm_1 = require("./graalVm");
+const installGatlingJs = async (options) => {
     const downloadDir = `${options.gatlingHome}/tmp/download`;
     await promises_1.default.mkdir(downloadDir, { recursive: true });
-    const graalvmHomePath = await installGraalVm(options.gatlingHome, downloadDir);
-    const coursierPath = await installCoursier(options.gatlingHome, downloadDir);
-    const classpath = await resolveDependencies(coursierPath, graalvmHomePath);
+    const graalvmHomePath = await (0, graalVm_1.installGraalVm)(options.gatlingHome, downloadDir);
+    const coursierPath = await (0, coursier_1.installCoursier)(options.gatlingHome, downloadDir);
+    const classpath = await (0, coursier_1.resolveGatlingJsDependencies)(coursierPath, graalvmHomePath);
     return {
         graalvmHome: graalvmHomePath,
         coursierBinary: coursierPath,
         jvmClasspath: classpath.trim()
     };
 };
-exports.installAll = installAll;
-const installGraalVm = async (gatlingHomeDir, downloadDir) => {
-    // TODO test Linux and Windows
-    const { os, arch, extension, homePath } = graalVmPlatformParams();
-    const graalvmRootPath = `${gatlingHomeDir}/graalvm/${versions_1.versions.graalvm.jdk}`;
-    const graalvmHomePath = `${graalvmRootPath}${homePath}`;
-    const graalvmJavaPath = `${graalvmHomePath}/bin/java`;
-    if (!(0, fs_1.existsSync)(graalvmJavaPath)) {
-        const url = `https://github.com/graalvm/graalvm-ce-builds/releases/download/jdk-${versions_1.versions.graalvm.jdk}/graalvm-community-jdk-${versions_1.versions.graalvm.jdk}_${os}-${arch}_bin.${extension}`;
-        const downloadPath = `${downloadDir}/graalvm.${extension}`;
-        if ((0, fs_1.existsSync)(graalvmRootPath)) {
-            await promises_1.default.rm(graalvmRootPath, { recursive: true });
-        }
-        if ((0, fs_1.existsSync)(downloadPath)) {
-            await promises_1.default.rm(downloadPath);
-        }
-        await promises_1.default.mkdir(graalvmRootPath, { recursive: true });
-        log_1.logger.info(`Downloading GraalVM Community Edition ${versions_1.versions.graalvm.jdk} to ${downloadPath}`);
-        await (0, download_1.downloadFile)(url, downloadPath);
-        log_1.logger.info(`Unpacking GraalVM to ${graalvmRootPath}`);
-        await (0, decompress_1.default)(downloadPath, graalvmRootPath, {
-            map: (file) => {
-                // Remove first level of file name, because it already contains a root directory
-                file.path = file.path.split("/").slice(1).join("/");
-                return file;
-            }
-        });
-        await promises_1.default.rm(downloadPath);
-    }
-    else {
-        log_1.logger.info(`GraalVM Community Edition ${versions_1.versions.graalvm.jdk} already installed at ${graalvmRootPath}`);
-    }
-    return graalvmHomePath;
-};
-const graalVmPlatformParams = () => {
-    const osType = os_1.default.type(); // 'Darwin', 'Linux', 'Windows_NT'
-    const osArch = os_1.default.arch(); // 'x64', 'arm64', etc.
-    if (osType === "Linux") {
-        const os = "linux";
-        const extension = "tar.gz";
-        const homePath = "";
-        if (osArch === "x64") {
-            return { os, arch: "x64", extension, homePath };
-        }
-        else if (osArch === "arm64") {
-            return { os, arch: "aarch64", extension, homePath };
-        }
-    }
-    else if (osType === "Darwin") {
-        const os = "macos";
-        const extension = "tar.gz";
-        const homePath = "/Contents/Home";
-        if (osArch === "x64") {
-            return { os, arch: "x64", extension, homePath };
-        }
-        else if (osArch === "arm64") {
-            return { os, arch: "aarch64", extension, homePath };
-        }
-    }
-    else if (osType === "Windows_NT" && osArch === "x64") {
-        return { os: "windows", arch: "x64", extension: "zip", homePath: "" };
-    }
-    throw Error(`Operating system type '${osType}' with architecture '${osArch}' is not currently supported.`);
-};
-const installCoursier = async (gatlingHomeDir, downloadDir) => {
-    const coursierRootPath = `${gatlingHomeDir}/coursier/${versions_1.versions.coursier}`;
-    const coursierPath = `${coursierRootPath}/cs`;
-    if (!(0, fs_1.existsSync)(coursierPath)) {
-        // TODO test Linux/windows
-        const url = `https://github.com/coursier/coursier/releases/download/v${versions_1.versions.coursier}/coursier`;
-        const downloadPath = `${downloadDir}/cs`;
-        if ((0, fs_1.existsSync)(coursierRootPath)) {
-            await promises_1.default.rm(coursierRootPath, { recursive: true });
-        }
-        if ((0, fs_1.existsSync)(downloadPath)) {
-            await promises_1.default.rm(downloadPath);
-        }
-        await promises_1.default.mkdir(coursierRootPath, { recursive: true });
-        log_1.logger.info(`Downloading Coursier ${versions_1.versions.coursier} to ${downloadPath}`);
-        await (0, download_1.downloadFile)(url, downloadPath);
-        await promises_1.default.chmod(downloadPath, 0o744);
-        log_1.logger.info(`Installing Coursier to ${coursierPath}`);
-        await promises_1.default.rename(downloadPath, coursierPath);
-    }
-    else {
-        log_1.logger.info(`Coursier ${versions_1.versions.coursier} already installed at ${coursierPath}`);
-    }
-    return coursierPath;
-};
-const resolveDependencies = async (coursierPath, javaHome) => {
-    const gatlingDep = `"io.gatling.highcharts:gatling-charts-highcharts:${versions_1.versions.gatling.core}"`;
-    const gatlingAdapterDep = `"io.gatling:gatling-jvm-to-js-adapter:${versions_1.versions.gatling.jsAdapter}"`;
-    const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`;
-    const command = `"${coursierPath}" fetch --classpath ${gatlingDep} ${gatlingAdapterDep} ${graalvmJsDep}`;
-    // TODO could add a timeout
-    log_1.logger.info(`Resolving dependencies with Coursier`);
-    const { stdout } = await (0, exports.execAsync)(command, { env: { ...process.env, JAVA_HOME: javaHome } });
-    return stdout;
+exports.installGatlingJs = installGatlingJs;
+const installRecorder = async (options) => {
+    const downloadDir = `${options.gatlingHome}/tmp/download`;
+    await promises_1.default.mkdir(downloadDir, { recursive: true });
+    const graalvmHomePath = await (0, graalVm_1.installGraalVm)(options.gatlingHome, downloadDir);
+    const coursierPath = await (0, coursier_1.installCoursier)(options.gatlingHome, downloadDir);
+    const classpath = await (0, coursier_1.resolveRecorderDependencies)(coursierPath, graalvmHomePath);
+    return {
+        graalvmHome: graalvmHomePath,
+        coursierBinary: coursierPath,
+        jvmClasspath: classpath.trim()
+    };
 };
+exports.installRecorder = installRecorder;

package/target/dependencies/os.d.ts

@@ -0,0 +1,2 @@
+export declare const osType: "Darwin" | "Linux" | "Windows_NT";
+export declare const osArch: "x64" | "arm64";

package/target/dependencies/os.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.osArch = exports.osType = void 0;
+const os_1 = __importDefault(require("os"));
+const resolveOsType = () => {
+    const t = os_1.default.type();
+    if (t !== "Darwin" && t !== "Linux" && t !== "Windows_NT") {
+        throw Error(`Gatling JS does not support the Operating System '${t}'`);
+    }
+    return t;
+};
+exports.osType = resolveOsType();
+const resolveOsArch = () => {
+    const a = os_1.default.arch();
+    if (a !== "x64" && a !== "arm64") {
+        throw Error(`Gatling JS does not support the architecture '${a}'`);
+    }
+    if (exports.osType === "Windows_NT" && a === "arm64") {
+        // GraalVM distribution not available for Windows on ARM
+        // TODO see if we can recommend a solution
+        throw Error(`Gatling JS does not support Windows on the ARM architecture`);
+    }
+    return a;
+};
+exports.osArch = resolveOsArch();

package/target/dependencies/versions.js

@@ -8,7 +8,7 @@ exports.versions = {
     },
     coursier: "2.1.10",
     gatling: {
-        core: "3.11.2",
-        jsAdapter: "3.11.2"
+        core: "3.11.3",
+        jsAdapter: "3.11.3"
     }
 };

package/target/index.js

@@ -16,12 +16,11 @@ const program = new commander_1.Command()
     .description("The Gatling Javascript run & packaging tool");
 const gatlingHomeOption = new commander_1.Option("--gatling-home <value>", 'The folder used to download and install Gatling components (default: "~/.gatling")');
 const gatlingHomeDirWithDefaults = (options) => options.gatlingHome || `${os_1.default.homedir()}/.gatling`;
-const entrypointFileOption = new commander_1.Option("--entrypoint-file <value>", 'The simulation entry point source file path (default: "src/index.js", or "src/index.ts" when using the "--typescript" option)');
-const simulationNameOption = new commander_1.Option("--simulation-name <value>", "The simulation entry point function name").default("default", '"default", compatible with using "export default"');
-const entrypointFileWithDefaults = (options) => options.entrypointFile || (options.typescript ? "src/index.ts" : "src/index.js");
+const sourcesFolderOption = new commander_1.Option("--sources-folder <value>", "The sources folder path").default("src");
+const simulationOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").default("default", '"default", compatible with using "export default"');
 const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The simulation target bundle file path").default("target/bundle.js");
 const resourcesFolderOption = new commander_1.Option("--resources-folder <value>", "The resources folder path").default("resources");
-const resultsFolderOption = new commander_1.Option("--results-folder <value>", "The results folder path").default("results");
+const resultsFolderOption = new commander_1.Option("--results-folder <value>", "The results folder path").default("target/gatling");
 const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code").default(false);
 const graalvmHomeMandatoryOption = new commander_1.Option("--graalvm-home <value>", "Path to the GraalVM home").makeOptionMandatory(true);
 const jvmClasspathMandatoryOption = new commander_1.Option("--jvm-classpath <value>", "The classpath containing all Gatling JVM components").makeOptionMandatory(true);
@@ -31,7 +30,7 @@ program
     .addOption(gatlingHomeOption)
     .action(async (options) => {
     const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installAll)({ gatlingHome });
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installGatlingJs)({ gatlingHome });
     log_1.logger.info(`graalvmHome=${graalvmHome}`);
     log_1.logger.info(`coursierBinary=${coursierBinary}`);
     log_1.logger.info(`jvmClasspath=${jvmClasspath}`);
@@ -39,38 +38,45 @@ program
 program
     .command("build")
     .description("Build a Gatling simulation")
-    .addOption(entrypointFileOption)
+    .addOption(sourcesFolderOption)
     .addOption(bundleFileOption)
     .addOption(typescriptOption)
     .action(async (options) => {
-    const entrypointFile = entrypointFileWithDefaults(options);
+    const sourcesFolder = options.sourcesFolder;
     const bundleFile = options.bundleFile;
     const typescript = options.typescript;
-    await (0, bundle_1.bundle)({ entrypointFile, bundleFile, typescript });
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript });
 });
 program
     .command("run-only")
     .description("Run a Gatling simulation")
     .addOption(graalvmHomeMandatoryOption)
     .addOption(jvmClasspathMandatoryOption)
-    .addOption(simulationNameOption)
+    .addOption(simulationOption)
     .addOption(bundleFileOption)
     .addOption(resourcesFolderOption)
     .addOption(resultsFolderOption)
     .action(async (options) => {
     const graalvmHome = options.graalvmHome;
     const jvmClasspath = options.jvmClasspath;
-    const simulationName = options.simulationName;
+    const simulation = options.simulation;
     const bundleFile = options.bundleFile;
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
-    await (0, run_1.run)({ graalvmHome, jvmClasspath, simulationName, bundleFile, resourcesFolder, resultsFolder });
+    await (0, run_1.runSimulation)({
+        graalvmHome,
+        jvmClasspath,
+        simulation: simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder
+    });
 });
 program
     .command("run")
     .description("Build and run a Gatling simulation, after installing all required components and dependencies for Gatling")
-    .addOption(entrypointFileOption)
-    .addOption(simulationNameOption)
+    .addOption(sourcesFolderOption)
+    .addOption(simulationOption)
     .addOption(typescriptOption)
     .addOption(bundleFileOption)
     .addOption(resourcesFolderOption)
@@ -78,17 +84,35 @@ program
     .addOption(gatlingHomeOption)
     .action(async (options) => {
     const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const entrypointFile = entrypointFileWithDefaults(options);
-    const simulationName = options.simulationName;
+    const sourcesFolder = options.sourcesFolder;
+    const simulation = options.simulation;
     const bundleFile = options.bundleFile;
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
     const typescript = options.typescript;
-    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installAll)({ gatlingHome });
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installGatlingJs)({ gatlingHome });
     log_1.logger.debug(`graalvmHome=${graalvmHome}`);
     log_1.logger.debug(`coursierBinary=${coursierBinary}`);
     log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
-    await (0, bundle_1.bundle)({ entrypointFile, bundleFile, typescript });
-    await (0, run_1.run)({ graalvmHome, jvmClasspath, simulationName, bundleFile, resourcesFolder, resultsFolder });
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript });
+    await (0, run_1.runSimulation)({ graalvmHome, jvmClasspath, simulation, bundleFile, resourcesFolder, resultsFolder });
+});
+program
+    .command("recorder")
+    .description("Run the Gatling recorder")
+    .addOption(gatlingHomeOption)
+    .addOption(sourcesFolderOption)
+    .addOption(typescriptOption)
+    .addOption(resourcesFolderOption)
+    .action(async (options) => {
+    const gatlingHome = gatlingHomeDirWithDefaults(options);
+    const sourcesFolder = options.sourcesFolder;
+    const resourcesFolder = options.resourcesFolder;
+    const typescript = options.typescript;
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installRecorder)({ gatlingHome });
+    log_1.logger.debug(`graalvmHome=${graalvmHome}`);
+    log_1.logger.debug(`coursierBinary=${coursierBinary}`);
+    log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
+    await (0, run_1.runRecorder)({ graalvmHome, jvmClasspath, sourcesFolder, typescript, resourcesFolder });
 });
 program.parse(process.argv);

package/target/run.d.ts

@@ -1,9 +1,17 @@
 export interface RunOptions {
     graalvmHome: string;
     jvmClasspath: string;
-    simulationName: string;
+}
+export interface RunSimulationOptions extends RunOptions {
+    simulation: string;
     bundleFile: string;
     resourcesFolder: string;
     resultsFolder: string;
 }
-export declare const run: (options: RunOptions) => Promise<void>;
+export interface RunRecorderOptions extends RunOptions {
+    sourcesFolder: string;
+    typescript: boolean;
+    resourcesFolder: string;
+}
+export declare const runSimulation: (options: RunSimulationOptions) => Promise<void>;
+export declare const runRecorder: (options: RunRecorderOptions) => Promise<void>;

package/target/run.js

@@ -1,56 +1,62 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
+exports.runRecorder = exports.runSimulation = void 0;
 const child_process_1 = require("child_process");
-const path = __importStar(require("path"));
 const log_1 = require("./log");
-const run = async (options) => {
+const versions_1 = require("./dependencies/versions");
+const os_1 = require("./dependencies/os");
+const runSimulation = async (options) => {
     log_1.logger.info(`Running a Gatling simulation with options:
- - simulationName: ${options.simulationName}
+ - simulation: ${options.simulation}
  - bundleFile: ${options.bundleFile}`);
-    const bundleFolder = path.parse(options.bundleFile).dir;
-    const bundleFileName = path.parse(options.bundleFile).base;
+    const additionalClasspathElements = [options.resourcesFolder];
+    const javaArgs = [
+        `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
+        `-Dgatling.js.simulation=${options.simulation}`
+    ];
+    const simulationArgs = [
+        "--results-folder",
+        options.resultsFolder,
+        "--simulation",
+        "io.gatling.js.JsSimulation",
+        "--launcher",
+        "gatling-js-cli",
+        "--build-tool-version",
+        versions_1.versions.gatling.jsAdapter
+    ];
+    return run(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
+};
+exports.runSimulation = runSimulation;
+const runRecorder = async (options) => {
+    log_1.logger.info("Running the Gatling Recorder");
+    const recorderArgs = [
+        "--simulations-folder",
+        options.sourcesFolder,
+        "--resources-folder",
+        options.resourcesFolder,
+        "--format",
+        options.typescript ? "typescript" : "javascript"
+    ];
+    return run(options, "io.gatling.recorder.GatlingRecorder", [], [], recorderArgs);
+};
+exports.runRecorder = runRecorder;
+const run = (options, mainClass, additionalClasspathElements, javaArgs, mainClassArgs) => {
     const command = `${options.graalvmHome}/bin/java`;
-    const args = [
+    const classpathSeparator = os_1.osType === "Windows_NT" ? ";" : ":";
+    const classpath = [...additionalClasspathElements, options.jvmClasspath].join(classpathSeparator);
+    const allArgs = [
         "-server",
         "-XX:+HeapDumpOnOutOfMemoryError",
         "-XX:MaxInlineLevel=20",
         "-XX:MaxTrivialSize=12",
         "-Xmx1G",
         "-classpath",
-        `${bundleFolder}:${options.resourcesFolder}:${options.jvmClasspath}`,
-        `-Dgatling.js.bundle.resourcePath=${bundleFileName}`,
-        `-Dgatling.js.simulationName=${options.simulationName}`,
-        "io.gatling.app.Gatling",
-        "--results-folder",
-        options.resultsFolder,
-        "--simulation",
-        "io.gatling.js.JsSimulation"
+        classpath,
+        ...javaArgs,
+        mainClass,
+        ...mainClassArgs
     ];
-    const process = (0, child_process_1.spawn)(command, args);
+    const process = (0, child_process_1.spawn)(command, allArgs);
     return new Promise((resolve, reject) => {
         process.stdout.on("data", (data) => log_1.logger.info(data.toString()));
         process.stderr.on("data", (data) => log_1.logger.error(data.toString()));
@@ -65,4 +71,3 @@ const run = async (options) => {
         });
     });
 };
-exports.run = run;