@gatling.io/cli 3.11.7 → 3.13.1

package/target/commands/runOnly.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("./options");
+const run_1 = require("../run");
+exports.default = (program) => {
+    program
+        .command("run-only")
+        .description("Run a Gatling simulation from an already built bundle")
+        .addOption(options_1.graalvmHomeMandatoryOption)
+        .addOption(options_1.jvmClasspathMandatoryOption)
+        .addOption(options_1.simulationMandatoryOption)
+        .addOption(options_1.bundleFileOption)
+        .addOption(options_1.resourcesFolderOption)
+        .addOption(options_1.resultsFolderOption)
+        .addOption(options_1.memoryOption)
+        .addArgument(options_1.runParametersArgument)
+        .action(async (args, options) => {
+        const graalvmHome = (0, options_1.graalvmHomeMandatoryOptionValue)(options);
+        const jvmClasspath = (0, options_1.jvmClasspathMandatoryOptionValue)(options);
+        const simulation = (0, options_1.simulationMandatoryOptionValue)(options);
+        const bundleFile = (0, options_1.bundleFileOptionValue)(options);
+        const resourcesFolder = (0, options_1.resourcesFolderOptionValue)(options);
+        const resultsFolder = (0, options_1.resultsFolderOptionValue)(options);
+        const memory = (0, options_1.memoryOptionValue)(options);
+        const runParameters = (0, options_1.parseRunParametersArgument)(args);
+        await (0, run_1.runSimulation)({
+            graalvmHome,
+            jvmClasspath,
+            simulation: simulation,
+            bundleFile,
+            resourcesFolder,
+            resultsFolder,
+            memory,
+            runParameters
+        });
+    });
+};

package/target/dependencies/coursier.d.ts

@@ -1,3 +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 resolveGatlingJsDependencies: (coursierPath: string, javaHome: string, postmanVersion?: string) => Promise<string>;
 export declare const resolveRecorderDependencies: (coursierPath: string, javaHome: string) => Promise<string>;

package/target/dependencies/coursier.js

@@ -46,12 +46,17 @@ const installCoursier = async (gatlingHomeDir, downloadDir) => {
     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 gatlingEnterprisePluginCommonsDep = `"io.gatling:gatling-enterprise-plugin-commons:${versions_1.versions.gatling.enterprisePluginCommons}"`;
-    const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`;
-    return await resolveDependencies(coursierPath, javaHome, gatlingDep, gatlingAdapterDep, gatlingEnterprisePluginCommonsDep, graalvmJsDep);
+const resolveGatlingJsDependencies = async (coursierPath, javaHome, postmanVersion) => {
+    const dependencies = [
+        `"io.gatling.highcharts:gatling-charts-highcharts:${versions_1.versions.gatling.core}"`,
+        `"io.gatling:gatling-jvm-to-js-adapter:${versions_1.versions.gatling.jsAdapter}"`,
+        `"io.gatling:gatling-enterprise-plugin-commons:${versions_1.versions.gatling.enterprisePluginCommons}"`,
+        `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`
+    ];
+    if (postmanVersion !== undefined) {
+        dependencies.push(`"io.gatling:gatling-postman-jvm-to-js-adapter:${postmanVersion}"`);
+    }
+    return await resolveDependencies(coursierPath, javaHome, ...dependencies);
 };
 exports.resolveGatlingJsDependencies = resolveGatlingJsDependencies;
 const resolveRecorderDependencies = async (coursierPath, javaHome) => {

package/target/dependencies/index.d.ts

@@ -1,5 +1,7 @@
+export { versions } from "./versions";
 export interface DependenciesOptions {
     gatlingHome: string;
+    postman?: string;
 }
 export interface ResolvedDependencies {
     graalvmHome: string;

package/target/dependencies/index.js

@@ -3,16 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installRecorder = exports.installGatlingJs = void 0;
+exports.installRecorder = exports.installGatlingJs = exports.versions = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const coursier_1 = require("./coursier");
 const graalVm_1 = require("./graalVm");
+var versions_1 = require("./versions");
+Object.defineProperty(exports, "versions", { enumerable: true, get: function () { return versions_1.versions; } });
 const installGatlingJs = 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.resolveGatlingJsDependencies)(coursierPath, graalvmHomePath);
+    const classpath = await (0, coursier_1.resolveGatlingJsDependencies)(coursierPath, graalvmHomePath, options.postman);
     return {
         graalvmHome: graalvmHomePath,
         coursierBinary: coursierPath,

package/target/dependencies/versions.d.ts

@@ -3,6 +3,9 @@ export declare const versions: {
         jdk: string;
         js: string;
     };
+    java: {
+        compilerRelease: string;
+    };
     coursier: string;
     gatling: {
         core: string;

package/target/dependencies/versions.js

@@ -3,13 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.versions = void 0;
 exports.versions = {
     graalvm: {
-        jdk: "22.0.2",
-        js: "24.0.2"
+        jdk: "23.0.0",
+        js: "24.1.1"
     },
-    coursier: "2.1.10",
+    java: {
+        compilerRelease: "21"
+    },
+    coursier: "2.1.12",
     gatling: {
-        core: "3.11.5",
-        enterprisePluginCommons: "1.9.6",
-        jsAdapter: "3.11.7"
+        core: "3.13.1",
+        enterprisePluginCommons: "1.9.8",
+        jsAdapter: "3.13.1"
     }
 };

package/target/enterprise.d.ts

@@ -11,7 +11,8 @@ export interface EnterprisePluginOptions extends RunJavaProcessOptions {
     bundleFile: string;
     resourcesFolder: string;
     resultsFolder: string;
-    url: string;
+    apiUrl: string;
+    webAppUrl: string;
     apiToken?: string;
     controlPlaneUrl?: string;
     nonInteractive: boolean;

package/target/enterprise.js

@@ -8,7 +8,7 @@ const archiver_1 = __importDefault(require("archiver"));
 const fs_1 = __importDefault(require("fs"));
 const promises_1 = require("stream/promises");
 const zlib_1 = require("zlib");
-const versions_1 = require("./dependencies/versions");
+const dependencies_1 = require("./dependencies");
 const java_1 = require("./java");
 const log_1 = require("./log");
 const enterprisePackage = async (options) => {
@@ -41,11 +41,11 @@ const generateManifest = (simulationNames) => {
         "Manifest-Version: 1.0",
         "Specification-Vendor: GatlingCorp",
         "Gatling-Context: js",
-        `Gatling-Version: ${versions_1.versions.gatling.core}`,
+        `Gatling-Version: ${dependencies_1.versions.gatling.core}`,
         "Gatling-Packager: js-cli",
-        `Gatling-Packager-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        `Gatling-Packager-Version: ${dependencies_1.versions.gatling.jsAdapter}`,
         `Gatling-Simulations: ${simulationNames.join(",")}`,
-        `Java-Version: ${versions_1.versions.graalvm.jdk.split(".")[0]}`
+        `Java-Version: ${dependencies_1.versions.java.compilerRelease}`
     ];
     const pkg = getPackageNameAndVersion();
     lines.push(`Implementation-Title: ${pkg.name}`);
@@ -110,7 +110,8 @@ const getPackageNameAndVersion = () => {
 const javaArgsFromPluginOptions = (options) => {
     const javaArgs = [];
     // Base
-    javaArgs.push(`-Dgatling.enterprise.url=${options.url}`);
+    javaArgs.push(`-Dgatling.enterprise.apiUrl=${options.apiUrl}`);
+    javaArgs.push(`-Dgatling.enterprise.webAppUrl=${options.webAppUrl}`);
     if (options.apiToken !== undefined) {
         javaArgs.push(`-Dgatling.enterprise.apiToken=${options.apiToken}`);
     }
@@ -119,7 +120,7 @@ const javaArgsFromPluginOptions = (options) => {
         javaArgs.push(`-Dgatling.enterprise.controlPlaneUrl=${options.controlPlaneUrl}`);
     }
     javaArgs.push("-Dgatling.enterprise.buildTool=js-cli");
-    javaArgs.push(`-Dgatling.enterprise.pluginVersion=${versions_1.versions.gatling.jsAdapter}`);
+    javaArgs.push(`-Dgatling.enterprise.pluginVersion=${dependencies_1.versions.gatling.jsAdapter}`);
     if (options.nonInteractive) {
         javaArgs.push(`-Dgatling.enterprise.batchMode=true`);
     }

package/target/index.js

@@ -1,340 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const os_1 = __importDefault(require("os"));
-const bundle_1 = require("./bundle");
-const dependencies_1 = require("./dependencies");
-const enterprise_1 = require("./enterprise");
-const simulations_1 = require("./simulations");
-const log_1 = require("./log");
-const readline_1 = require("./readline");
-const run_1 = require("./run");
-const program = new commander_1.Command()
-    .name("gatling-js-cli")
-    .version("0.0.1")
-    .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 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: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)");
-const simulationWithDefaults = (options, simulationsFound, interactive) => {
-    if (options.simulation !== undefined) {
-        return options.simulation;
-    }
-    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 = (0, readline_1.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;
-            log_1.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)})`);
-    }
-};
-const simulationRequiredOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").makeOptionMandatory(true);
-const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The target bundle file path when building simulations (must have a .js extension)").default("target/bundle.js");
-const validateBundleFile = (options) => {
-    if (!options.bundleFile.endsWith(".js")) {
-        throw Error(`'${options.bundleFile}' is not a valid bundle file path: should have a .js extension`);
-    }
-    return options.bundleFile;
-};
-const packageFileOption = new commander_1.Option("--package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)").default("target/package.zip");
-const validatePackageFile = (options) => {
-    if (!options.packageFile.endsWith(".zip")) {
-        throw Error(`'${options.packageFile}' is not a valid package file path: should have a .zip extension`);
-    }
-    return options.packageFile;
-};
-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("target/gatling");
-const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code (default: true if the sourcesFolder contains any *.gatling.ts file, false otherwise)");
-const typescriptWithDefaults = (options, simulationsFound) => options.typescript !== undefined
-    ? options.typescript
-    : simulationsFound.findIndex((s) => s.type === "typescript") >= 0;
-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);
-const memoryOption = new commander_1.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;
-});
-const nonInteractiveOption = new commander_1.Option("--non-interactive", "Switch to non-interactive mode and fail if no simulation is explicitly specified").default(false);
-const runParametersArgument = new commander_1.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");
-const parseRunParameters = (args) => {
-    const parsedParameters = {};
-    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;
-};
-program
-    .command("install")
-    .description("Install all required components and dependencies for Gatling")
-    .addOption(gatlingHomeOption)
-    .action(async (options) => {
-    const gatlingHome = gatlingHomeDirWithDefaults(options);
-    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}`);
-});
-program
-    .command("build")
-    .description("Build Gatling simulations")
-    .addOption(sourcesFolderOption)
-    .addOption(bundleFileOption)
-    .addOption(typescriptOption)
-    .action(async (options) => {
-    const sourcesFolder = options.sourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
-});
-program
-    .command("run-only")
-    .description("Run a Gatling simulation from an already built bundle")
-    .addOption(graalvmHomeMandatoryOption)
-    .addOption(jvmClasspathMandatoryOption)
-    .addOption(simulationRequiredOption)
-    .addOption(bundleFileOption)
-    .addOption(resourcesFolderOption)
-    .addOption(resultsFolderOption)
-    .addOption(memoryOption)
-    .addArgument(runParametersArgument)
-    .action(async (args, options) => {
-    const graalvmHome = options.graalvmHome;
-    const jvmClasspath = options.jvmClasspath;
-    const simulation = options.simulation;
-    const bundleFile = validateBundleFile(options);
-    const resourcesFolder = options.resourcesFolder;
-    const resultsFolder = options.resultsFolder;
-    const memory = options.memory;
-    const runParameters = parseRunParameters(args);
-    await (0, run_1.runSimulation)({
-        graalvmHome,
-        jvmClasspath,
-        simulation: simulation,
-        bundleFile,
-        resourcesFolder,
-        resultsFolder,
-        memory,
-        runParameters
-    });
-});
-program
-    .command("run")
-    .description("Build and run a Gatling simulation, after installing all required components and dependencies for Gatling")
-    .addOption(sourcesFolderOption)
-    .addOption(simulationOption)
-    .addOption(typescriptOption)
-    .addOption(bundleFileOption)
-    .addOption(resourcesFolderOption)
-    .addOption(resultsFolderOption)
-    .addOption(gatlingHomeOption)
-    .addOption(memoryOption)
-    .addOption(nonInteractiveOption)
-    .addArgument(runParametersArgument)
-    .action(async (args, options) => {
-    const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const sourcesFolder = options.sourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const resourcesFolder = options.resourcesFolder;
-    const resultsFolder = options.resultsFolder;
-    const memory = options.memory;
-    const nonInteractive = options.nonInteractive;
-    const runParameters = parseRunParameters(args);
-    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    const simulation = simulationWithDefaults(options, simulations, !nonInteractive);
-    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)({ sourcesFolder, bundleFile, typescript, simulations });
-    await (0, run_1.runSimulation)({
-        graalvmHome,
-        jvmClasspath,
-        simulation,
-        bundleFile,
-        resourcesFolder,
-        resultsFolder,
-        memory,
-        runParameters
-    });
-});
-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 simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    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
-    .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 = options.sourcesFolder;
-    const resourcesFolder = options.resourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const packageFile = validatePackageFile(options);
-    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
-    await (0, enterprise_1.enterprisePackage)({ bundleFile, resourcesFolder, packageFile, simulations });
-});
-const urlOption = new commander_1.Option("--url <value>", "URL of Gatling Enterprise")
-    .default("https://cloud.gatling.io")
-    .hideHelp();
-const apiTokenOption = new commander_1.Option("--api-token <value>", "API Token on Gatling Enterprise. Prefer configuration using `GATLING_ENTERPRISE_API_TOKEN` environment variable.");
-// Plugin configuration
-const controlPlaneUrlOption = new commander_1.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.");
-// Descriptor file
-const packageDescriptorFilenameOption = new commander_1.Option("--package-descriptor-filename <value>", "Path to a package descriptor inside the .gatling folder").default("package.conf");
-const enterpriseBundleAndPackage = async (options) => {
-    const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const sourcesFolder = options.sourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const resourcesFolder = options.resourcesFolder;
-    const resultsFolder = options.resultsFolder;
-    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    // Base
-    const url = options.url;
-    const apiToken = options.apiToken;
-    // Plugin configuration
-    const controlPlaneUrl = options.controlPlaneUrl;
-    const nonInteractive = options.nonInteractive;
-    // Descriptor file
-    const packageDescriptorFilename = options.packageDescriptorFilename;
-    // Deployment info
-    const packageFile = validatePackageFile(options);
-    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)({ sourcesFolder, bundleFile, typescript, simulations });
-    await (0, enterprise_1.enterprisePackage)({ bundleFile, resourcesFolder, packageFile, simulations });
-    return {
-        graalvmHome,
-        jvmClasspath,
-        bundleFile,
-        resourcesFolder,
-        resultsFolder,
-        // Base
-        url,
-        apiToken,
-        // Plugin configuration
-        controlPlaneUrl,
-        nonInteractive,
-        // Descriptor file
-        packageDescriptorFilename,
-        // Deployment info
-        packageFile
-    };
-};
-program
-    .command("enterprise-deploy")
-    .description("Deploy a package and configured simulations")
-    .addOption(sourcesFolderOption)
-    .addOption(resourcesFolderOption)
-    .addOption(bundleFileOption)
-    .addOption(resultsFolderOption)
-    // Base
-    .addOption(urlOption)
-    .addOption(apiTokenOption)
-    // Plugin configuration
-    .addOption(controlPlaneUrlOption)
-    .addOption(nonInteractiveOption)
-    // Descriptor file
-    .addOption(packageDescriptorFilenameOption)
-    // Deployment info
-    .addOption(packageFileOption)
-    .action(async (options) => {
-    const deployOptions = await enterpriseBundleAndPackage(options);
-    await (0, enterprise_1.enterpriseDeploy)(deployOptions);
-});
-// Deployment info
-const enterpriseSimulationOption = new commander_1.Option("--enterprise-simulation <value>", "Specify the simulation name directly to bypass the prompt using the following command.");
-const runTitleOption = new commander_1.Option("--run-title <value>", "Allows setting a title for your run reports.");
-const runDescriptionOption = new commander_1.Option("--run-description <value>", "Allows setting a description for your run reports summary.");
-const waitForRunEndOption = new commander_1.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);
-program
-    .command("enterprise-start")
-    .description("Start a simulation deployed with `enterprise-deploy`")
-    .addOption(sourcesFolderOption)
-    .addOption(resourcesFolderOption)
-    .addOption(bundleFileOption)
-    .addOption(resultsFolderOption)
-    // 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 deployOptions = await enterpriseBundleAndPackage(options);
-    if (options.nonInteractive && options.enterpriseSimulation === undefined) {
-        throw new Error(`No simulation specified when using non-interactive mode`);
-    }
-    await (0, enterprise_1.enterpriseStart)({
-        ...deployOptions,
-        // Start
-        enterpriseSimulation: options.enterpriseSimulation,
-        runTitle: options.runTitle,
-        runDescription: options.runDescription,
-        waitForRunEnd: options.waitForRunEnd
-    });
-});
-program.parse(process.argv);
+const commands_1 = require("./commands");
+commands_1.program.parse(process.argv);

package/target/run.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRecorder = exports.runSimulation = void 0;
 const log_1 = require("./log");
-const versions_1 = require("./dependencies/versions");
+const dependencies_1 = require("./dependencies");
 const java_1 = require("./java");
 const runSimulation = async (options) => {
     log_1.logger.info(`Running a Gatling simulation with options:
@@ -11,11 +11,13 @@ const runSimulation = async (options) => {
  - resourcesFolder: ${options.resourcesFolder}
  - resultsFolder: ${options.resultsFolder}`);
     const additionalClasspathElements = [options.resourcesFolder];
+    const jitTuningArgs = ["-XX:JVMCINativeLibraryThreadFraction=0.8", "-Dgraal.MethodInlineBailoutLimit=500"];
     const memoryArgs = options.memory !== undefined ? [`-Xms${options.memory}M`, `-Xmx${options.memory}M`] : [];
     const javaArgs = [
         ...Object.entries(options.runParameters).map(([key, value]) => `-D${key}=${value}`),
         `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
         `-Dgatling.js.simulation=${options.simulation}`,
+        ...jitTuningArgs,
         ...memoryArgs
     ];
     const simulationArgs = [
@@ -26,7 +28,7 @@ const runSimulation = async (options) => {
         "--launcher",
         "gatling-js-cli",
         "--build-tool-version",
-        versions_1.versions.gatling.jsAdapter
+        dependencies_1.versions.gatling.jsAdapter
     ];
     return (0, java_1.runJavaProcess)(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
 };

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "rootDir": "src",
+    "outDir": "target",
+    "lib": ["es2021", "dom"],
+    "target": "es2021",
+    "module": "node16",
+    "esModuleInterop": true,
+    "moduleResolution": "node16",
+    "declaration": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.test.ts"]
+}