@gatling.io/cli 3.11.7 → 3.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.7",
+  "version": "3.13.1",
   "license": "Apache-2.0",
   "bin": {
     "gatling": "target/index.js"
@@ -8,22 +8,24 @@
   "main": "target/index.js",
   "types": "target/index.d.ts",
   "dependencies": {
+    "@jspm/core": "2.1.0",
     "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.24.0",
     "esbuild-plugin-tsc": "0.4.0",
+    "import-meta-resolve": "4.1.0",
     "readline-sync": "1.4.10"
   },
   "devDependencies": {
-    "@types/archiver": "6.0.2",
+    "@types/archiver": "6.0.3",
     "@types/decompress": "4.2.7",
-    "@types/node": "20.14.12",
+    "@types/node": "18.19.64",
     "@types/readline-sync": "1.4.8",
     "prettier": "3.3.3",
     "rimraf": "6.0.1",
-    "typescript": "5.5.4"
+    "typescript": "5.6.3"
   },
   "scripts": {
     "clean": "rimraf target",

package/polyfills/crypto.js

@@ -0,0 +1,87 @@
+import { Buffer } from "buffer"
+
+// limit of Crypto.getRandomValues()
+// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+const MAX_BYTES = 65536;
+
+// Node supports requesting up to this number of bytes
+// https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48
+const MAX_UINT32 = 4294967295;
+
+const JavaCrypto = Java.type("io.gatling.js.polyfills.Crypto");
+
+export const randomBytes = (size, cb) => {
+  // Node supports requesting up to this number of bytes
+  // https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48
+  if (size > MAX_UINT32) {
+    throw new RangeError('requested too many random bytes');
+  }
+  const bytes = Buffer.from(JavaCrypto.randomBytes(size));
+  if (typeof cb === 'function') {
+    return process.nextTick(function () {
+      cb(null, bytes);
+    })
+  }
+  return bytes;
+};
+export const rng = randomBytes;
+export const pseudoRandomBytes = randomBytes;
+export const prng = randomBytes;
+export const getRandomValues = (values) => {
+  const byteView = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+  const bytes = randomBytes(byteView.length);
+  for (let i = 0; i < byteView.length; i++) {
+    // The range of Math.random() is [0, 1) and the ToUint8 abstract operation rounds down
+    byteView[i] = bytes[i];
+  }
+  return values;
+};
+export const randomUUID = () => JavaCrypto.randomUUID();
+
+// export const Cipher = crypto.Cipher;
+// export const Cipheriv = crypto.Cipheriv;
+// export const Decipher = crypto.Decipher;
+// export const Decipheriv = crypto.Decipheriv;
+// export const DiffieHellman = crypto.DiffieHellman;
+// export const DiffieHellmanGroup = crypto.DiffieHellmanGroup;
+// export const Hash = crypto.Hash;
+// export const Hmac = crypto.Hmac;
+// export const Sign = crypto.Sign;
+// export const Verify = crypto.Verify;
+// export const constants = crypto.constants;
+// export const createCipher = crypto.createCipher;
+// export const createCipheriv = crypto.createCipheriv;
+// export const createCredentials = crypto.createCredentials;
+// export const createDecipher = crypto.createDecipher;
+// export const createDecipheriv = crypto.createDecipheriv;
+// export const createDiffieHellman = crypto.createDiffieHellman;
+// export const createDiffieHellmanGroup = crypto.createDiffieHellmanGroup;
+// export const createECDH = crypto.createECDH;
+// export const createHash = crypto.createHash;
+// export const createHmac = crypto.createHmac;
+// export const createSign = crypto.createSign;
+// export const createVerify = crypto.createVerify;
+// export const getCiphers = crypto.getCiphers;
+// export const getDiffieHellman = crypto.getDiffieHellman;
+// export const getHashes = crypto.getHashes;
+// export const listCiphers = crypto.listCiphers;
+// export const pbkdf2 = crypto.pbkdf2;
+// export const pbkdf2Sync = crypto.pbkdf2Sync;
+// export const privateDecrypt = crypto.privateDecrypt;
+// export const privateEncrypt = crypto.privateEncrypt;
+// export const publicDecrypt = crypto.publicDecrypt;
+// export const publicEncrypt = crypto.publicEncrypt;
+// export const randomFill = crypto.randomFill;
+// export const randomFillSync = crypto.randomFillSync;
+
+const crypto = {
+  randomBytes,
+  rng,
+  pseudoRandomBytes,
+  prng,
+  getRandomValues,
+  randomUUID,
+};
+crypto.webcrypto = crypto;
+globalThis.crypto = crypto;
+export default crypto;

package/polyfills/global.js

@@ -0,0 +1,13 @@
+const global = globalThis;
+export { global };
+
+export { Buffer } from "buffer";
+
+// These values are used by some of the JSPM polyfills
+export const navigator = {
+  deviceMemory: 8, // Highest allowed value
+  hardwareConcurrency: 8, // Fairly common default
+  language: "en-US", // Most common default
+};
+
+export * as crypto from "crypto"

package/src/bundle/index.ts

@@ -0,0 +1,43 @@
+import * as esbuild from "esbuild";
+import esbuildPluginTsc from "esbuild-plugin-tsc";
+
+import { polyfill } from "./polyfill";
+import { SimulationFile } from "../simulations";
+import { logger } from "../log";
+
+export interface BundleOptions {
+  sourcesFolder: string;
+  bundleFile: string;
+  postman?: 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 })] : [];
+  if (options.postman !== undefined) {
+    plugins.push(polyfill());
+  }
+  await esbuild.build({
+    stdin: {
+      contents,
+      resolveDir: options.sourcesFolder
+    },
+    outfile: options.bundleFile,
+    platform: "neutral",
+    mainFields: ["main", "module"],
+    bundle: true,
+    minify: false,
+    sourcemap: true,
+    format: "iife",
+    globalName: "gatling",
+    plugins
+  });
+};

package/src/bundle/polyfill.ts

@@ -0,0 +1,91 @@
+import type { Plugin } from "esbuild";
+import { fileURLToPath, pathToFileURL } from "url";
+import { resolve, dirname } from "path";
+
+// This is largely inspired by https://github.com/cyco130/esbuild-plugin-polyfill-node
+
+export const polyfill = (): Plugin => ({
+  name: "gatling-js-polyfill",
+  setup: async (build) => {
+    // modules
+    const jspmResolved = await resolveImport(`@jspm/core/nodelibs/fs`);
+    build.onResolve({ filter: polyfillsFilter }, async ({ path }) => {
+      const [, , moduleName] = path.match(polyfillsFilter)!;
+      const resolved = customPolyfills.find((name) => name === moduleName)
+        ? resolve(dirname(__filename), `../../polyfills/${moduleName}.js`)
+        : resolve(jspmResolved, `../../browser/${moduleName}.js`);
+      return { path: resolved };
+    });
+
+    // Globals
+    build.initialOptions.inject = build.initialOptions.inject || [];
+    const injectGlobal = (name: string) =>
+      (build.initialOptions.inject as string[]).push(resolve(dirname(__filename), `../../polyfills/${name}.js`));
+    injectGlobal("global");
+  }
+});
+
+const customPolyfills = ["crypto"];
+
+const jspmPolyfills = ["buffer", "path", "string_decoder"];
+
+// Other available jspm-core modules:
+// "_stream_duplex"
+// "_stream_passthrough"
+// "_stream_readable"
+// "_stream_transform"
+// "_stream_writable"
+// "assert"
+// "assert/strict"
+// "async_hooks"
+// "child_process"
+// "cluster"
+// "console"
+// "constants"
+// "crypto"
+// "dgram"
+// "diagnostics_channel"
+// "dns"
+// "domain"
+// "events"
+// "fs"
+// "fs/promises"
+// "http"
+// "http2"
+// "https"
+// "module"
+// "net"
+// "os"
+// "perf_hooks"
+// "process"
+// "punycode"
+// "querystring"
+// "readline"
+// "repl"
+// "stream"
+// "sys"
+// "timers"
+// "timers/promises"
+// "tls"
+// "tty"
+// "url"
+// "util"
+// "v8"
+// "vm"
+// "wasi"
+// "worker_threads"
+// "zlib"
+
+const polyfillsFilter = new RegExp(`^(node:)?(${jspmPolyfills.concat(customPolyfills).join("|")})$`);
+
+let importMetaResolve: (specifier: string, parent: string) => string;
+
+const importMetaUrl = pathToFileURL(__filename).href;
+
+const resolveImport = async (specifier: string) => {
+  if (!importMetaResolve) {
+    importMetaResolve = (await import("import-meta-resolve")).resolve;
+  }
+  const resolved = importMetaResolve(specifier, importMetaUrl);
+  return fileURLToPath(resolved);
+};

package/src/commands/build.ts

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  postmanOption,
+  postmanOptionValueWithDefaults,
+  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(postmanOption)
+    .addOption(typescriptOption)
+    .action(async (options) => {
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const postman = postmanOptionValueWithDefaults(options);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      await bundle({ sourcesFolder, bundleFile, postman, typescript, simulations });
+    });
+};

package/src/commands/enterpriseDeploy.ts

@@ -0,0 +1,97 @@
+import { Command } from "commander";
+
+import {
+  apiTokenOption,
+  apiTokenOptionValue,
+  bundleFileOption,
+  bundleFileOptionValue,
+  controlPlaneUrlOption,
+  controlPlaneUrlOptionValue,
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  nonInteractiveOption,
+  nonInteractiveOptionValue,
+  packageDescriptorFilenameOption,
+  packageDescriptorFilenameOptionValue,
+  packageFileOption,
+  packageFileOptionValue,
+  postmanOption,
+  postmanOptionValueWithDefaults,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults,
+  apiUrlOption,
+  apiUrlOptionValue,
+  webAppUrlOption,
+  webAppUrlOptionValue
+} 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(postmanOption)
+    .addOption(typescriptOption)
+    .addOption(gatlingHomeOption)
+    // Base
+    .addOption(apiUrlOption)
+    .addOption(webAppUrlOption)
+    .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 postman = postmanOptionValueWithDefaults(options);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const apiUrl = apiUrlOptionValue(options);
+      const webAppUrl = webAppUrlOptionValue(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, postman, typescript, simulations });
+      await enterprisePackage({ bundleFile, resourcesFolder, packageFile, simulations });
+      await enterpriseDeploy({
+        graalvmHome,
+        jvmClasspath,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        apiUrl,
+        webAppUrl,
+        apiToken,
+        controlPlaneUrl,
+        nonInteractive,
+        packageDescriptorFilename,
+        packageFile
+      });
+    });
+};

package/src/commands/enterprisePackage.ts

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  packageFileOption,
+  packageFileOptionValue,
+  postmanOption,
+  postmanOptionValueWithDefaults,
+  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(postmanOption)
+    .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 postman = postmanOptionValueWithDefaults(options);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      await bundle({ sourcesFolder, bundleFile, postman, typescript, simulations });
+
+      await enterprisePackage({ bundleFile, resourcesFolder, packageFile, simulations });
+    });
+};

package/src/commands/enterpriseStart.ts

@@ -0,0 +1,122 @@
+import { Command } from "commander";
+
+import {
+  apiTokenOption,
+  apiTokenOptionValue,
+  bundleFileOption,
+  bundleFileOptionValue,
+  controlPlaneUrlOption,
+  controlPlaneUrlOptionValue,
+  enterpriseSimulationOption,
+  enterpriseSimulationOptionValue,
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  nonInteractiveOption,
+  nonInteractiveOptionValue,
+  packageDescriptorFilenameOption,
+  packageDescriptorFilenameOptionValue,
+  packageFileOption,
+  packageFileOptionValue,
+  postmanOption,
+  postmanOptionValueWithDefaults,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  runDescriptionOption,
+  runDescriptionOptionValue,
+  runTitleOption,
+  runTitleOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults,
+  apiUrlOption,
+  apiUrlOptionValue,
+  webAppUrlOption,
+  webAppUrlOptionValue,
+  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(postmanOption)
+    .addOption(typescriptOption)
+    .addOption(gatlingHomeOption)
+    // Base
+    .addOption(apiUrlOption)
+    .addOption(webAppUrlOption)
+    .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 postman = postmanOptionValueWithDefaults(options);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const apiUrl = apiUrlOptionValue(options);
+      const webAppUrl = webAppUrlOptionValue(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, postman, typescript, simulations });
+      await enterprisePackage({ bundleFile, resourcesFolder, packageFile, simulations });
+      await enterpriseStart({
+        graalvmHome,
+        jvmClasspath,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        apiUrl,
+        webAppUrl,
+        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}`);
+    });
+};