@gatling.io/core 3.11.7 → 3.12.0

package/src/structure/during.ts

@@ -0,0 +1,182 @@
+import { Duration, isDuration, toJvmDuration } from "../utils/duration";
+import { SessionTo, underlyingSessionToDuration } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmDuring = io.gatling.javaapi.core.loop.During;
+
+export interface DuringFunction<T extends During<T>> {
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: Duration): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: Duration, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: Duration, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: Duration, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+   * either a number, then the unit will be seconds, or an object with an explicit time unit.
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: string): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+   * either a number, then the unit will be seconds, or an object with an explicit time unit.
+   * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+   * either a number, then the unit will be seconds, or an object with an explicit time unit.
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: string, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+   * either a number, then the unit will be seconds, or an object with an explicit time unit.
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: string, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a function
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: SessionTo<Duration>): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a function
+   * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: SessionTo<Duration>, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: SessionTo<Duration>, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+   * the loop.
+   *
+   * @param duration - the maximum duration as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (duration: SessionTo<Duration>, counterName: string, exitASAP: boolean): On<T>;
+}
+
+export interface During<T extends During<T>> {
+  during: DuringFunction<T>;
+}
+
+export const duringImpl =
+  <J2, J1 extends JvmDuring<J2, any>, T extends During<T>>(
+    jvmDuring: J1,
+    wrap: (wrapped: J2) => T
+  ): DuringFunction<T> =>
+  (duration: Duration | SessionTo<Duration> | string, arg1?: boolean | string, arg2?: boolean) => {
+    if (arg2 !== undefined && typeof arg1 === "string") {
+      // during(duration, counterName, exitASAP)
+      if (isDuration(duration)) {
+        return wrapOn(jvmDuring.during(toJvmDuration(duration), arg1, arg2), wrap);
+      } else if (typeof duration === "function") {
+        return wrapOn(jvmDuring.during(underlyingSessionToDuration(duration), arg1, arg2), wrap);
+      } else {
+        return wrapOn(jvmDuring.during(duration, arg1, arg2), wrap);
+      }
+    } else if (typeof arg1 === "string") {
+      // during(duration, counterName)
+      if (isDuration(duration)) {
+        return wrapOn(jvmDuring.during(toJvmDuration(duration), arg1), wrap);
+      } else if (typeof duration === "function") {
+        return wrapOn(jvmDuring.during(underlyingSessionToDuration(duration), arg1), wrap);
+      } else {
+        return wrapOn(jvmDuring.during(duration, arg1), wrap);
+      }
+    } else if (typeof arg1 === "boolean") {
+      // during(duration, exitASAP)
+      if (isDuration(duration)) {
+        return wrapOn(jvmDuring.during(toJvmDuration(duration), arg1), wrap);
+      } else if (typeof duration === "function") {
+        return wrapOn(jvmDuring.during(underlyingSessionToDuration(duration), arg1), wrap);
+      } else {
+        return wrapOn(jvmDuring.during(duration, arg1), wrap);
+      }
+    } else if (arg1 === undefined) {
+      // during(duration)
+      if (isDuration(duration)) {
+        return wrapOn(jvmDuring.during(toJvmDuration(duration)), wrap);
+      } else if (typeof duration === "function") {
+        return wrapOn(jvmDuring.during(underlyingSessionToDuration(duration)), wrap);
+      } else {
+        return wrapOn(jvmDuring.during(duration), wrap);
+      }
+    }
+
+    throw Error(`during() called with invalid arguments ${duration}, ${arg1}, ${arg2}`);
+  };

package/src/structure/errors.ts

@@ -0,0 +1,266 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmErrors = io.gatling.javaapi.core.error.Errors;
+
+export interface ExitBlockOnFailFunction<T extends Errors<T>> {
+  /**
+   * Define a block that is interrupted for a given virtual user if it experiences a failure.
+   *
+   * @returns a DSL component for defining the tried block
+   */
+  (): On<T>;
+}
+
+export interface TryMaxFunction<T extends Errors<T>> {
+  /**
+   * Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
+   *
+   * @param times - the maximum number of tries, including the first one (hence number of retries + 1)
+   * @returns a DSL component for defining the tried block
+   */
+  (times: number | string | SessionTo<number>): On<T>;
+
+  /**
+   * Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
+   *
+   * @param times - the maximum number of tries, including the first one (hence number of retries + 1)
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the tried block
+   */
+  (times: number | string | SessionTo<number>, counterName: string): On<T>;
+}
+
+export interface ExitHereIfFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user exit here if the condition holds true
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (condition: string): T;
+
+  /**
+   * Have the virtual user exit here if the condition holds true
+   *
+   * @param condition - the condition, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (condition: SessionTo<boolean>): T;
+}
+
+export interface ExitHereFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user exit here
+   *
+   * @returns a new StructureBuilder
+   */
+  (): T;
+}
+
+export interface ExitHereIfFailedFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user exit here if the state of its Session is failed
+   *
+   * @returns a new StructureBuilder
+   */
+  (): T;
+}
+
+export interface StopLoadGeneratorFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user abruptly stop the load generator with a successful status
+   *
+   * @param message - the message, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (message: string): T;
+
+  /**
+   * Have the virtual user abruptly stop the load generator with a successful status
+   *
+   * @param message - the message, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (message: SessionTo<string>): T;
+}
+
+export interface StopLoadGeneratorIfFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user abruptly stop the load generator with a successful status if a condition
+   * is met
+   *
+   * @param message - the message, expressed as a Gatling Expression Language String
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (message: string, condition: string): T;
+
+  /**
+   * Have the virtual user abruptly stop the load generator with a successful status if a condition
+   * is met
+   *
+   * @param message - the message, expressed as a Gatling Expression Language String
+   * @param condition - the condition, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (message: string, condition: SessionTo<boolean>): T;
+
+  /**
+   * Have the virtual user abruptly stop the load generator with a successful status if a condition
+   * is met
+   *
+   * @param message - the message, expressed as a function
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (message: SessionTo<string>, condition: string): T;
+
+  /**
+   * Have the virtual user abruptly stop the load generator with a successful status if a condition
+   * is met
+   *
+   * @param message - the message, expressed as a function
+   * @param condition - the condition, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (message: SessionTo<string>, condition: SessionTo<boolean>): T;
+}
+
+export interface CrashLoadGeneratorFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user abruptly stop the load generator with a failed status
+   *
+   * @param message - the message, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (message: string): T;
+
+  /**
+   * Have the virtual user abruptly crash the load generator with a failed status
+   *
+   * @param message - the message, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (message: SessionTo<string>): T;
+}
+
+export interface CrashLoadGeneratorIfFunction<T extends Errors<T>> {
+  /**
+   * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+   * met
+   *
+   * @param message - the message, expressed as a Gatling Expression Language String
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (message: string, condition: string): T;
+
+  /**
+   * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+   * met
+   *
+   * @param message - the message, expressed as a Gatling Expression Language String
+   * @param condition - the condition, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (message: string, condition: SessionTo<boolean>): T;
+
+  /**
+   * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+   * met
+   *
+   * @param message - the message, expressed as a function
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @returns a new StructureBuilder
+   */
+  (message: SessionTo<string>, condition: string): T;
+
+  /**
+   * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+   * met
+   *
+   * @param message - the message, expressed as a function
+   * @param condition - the condition, expressed as a function
+   * @returns a new StructureBuilder
+   */
+  (message: SessionTo<string>, condition: SessionTo<boolean>): T;
+}
+
+export interface Errors<T extends Errors<T>> {
+  exitBlockOnFail: ExitBlockOnFailFunction<T>;
+  tryMax: TryMaxFunction<T>;
+  exitHereIf: ExitHereIfFunction<T>;
+  exitHere: ExitHereFunction<T>;
+  exitHereIfFailed: ExitHereIfFailedFunction<T>;
+  stopLoadGenerator: StopLoadGeneratorFunction<T>;
+  stopLoadGeneratorIf: StopLoadGeneratorIfFunction<T>;
+  crashLoadGenerator: CrashLoadGeneratorFunction<T>;
+  crashLoadGeneratorIf: CrashLoadGeneratorIfFunction<T>;
+}
+
+export const errorsImpl = <J2, J1 extends JvmErrors<J2, any>, T extends Errors<T>>(
+  jvmErrors: J1,
+  wrap: (wrapped: J2) => T
+): Errors<T> => ({
+  exitBlockOnFail: (): On<T> => wrapOn(jvmErrors.exitBlockOnFail(), wrap),
+  tryMax: (times: string | number | SessionTo<number>): On<T> =>
+    wrapOn(
+      typeof times === "function"
+        ? jvmErrors.tryMax(underlyingSessionTo(times))
+        : typeof times === "string"
+          ? jvmErrors.tryMax(times)
+          : jvmErrors.tryMax(times),
+      wrap
+    ),
+  exitHereIf: (condition: string | SessionTo<boolean>): T =>
+    wrap(
+      typeof condition === "function"
+        ? jvmErrors.exitHereIf(underlyingSessionTo(condition))
+        : jvmErrors.exitHereIf(condition)
+    ),
+  exitHere: (): T => wrap(jvmErrors.exitHere()),
+  exitHereIfFailed: (): T => wrap(jvmErrors.exitHereIfFailed()),
+  stopLoadGenerator: (message: string | SessionTo<string>): T =>
+    wrap(
+      typeof message === "function"
+        ? jvmErrors.stopLoadGenerator(underlyingSessionTo(message))
+        : jvmErrors.stopLoadGenerator(message)
+    ),
+  stopLoadGeneratorIf: (message: string | SessionTo<string>, condition: string | SessionTo<boolean>): T => {
+    if (typeof message === "function") {
+      if (typeof condition === "function") {
+        return wrap(jvmErrors.stopLoadGeneratorIf(underlyingSessionTo(message), underlyingSessionTo(condition)));
+      } else {
+        return wrap(jvmErrors.stopLoadGeneratorIf(underlyingSessionTo(message), condition));
+      }
+    } else {
+      if (typeof condition === "function") {
+        return wrap(jvmErrors.stopLoadGeneratorIf(message, underlyingSessionTo(condition)));
+      } else {
+        return wrap(jvmErrors.stopLoadGeneratorIf(message, condition));
+      }
+    }
+  },
+  crashLoadGenerator: (message: string | SessionTo<string>): T =>
+    wrap(
+      typeof message === "function"
+        ? jvmErrors.crashLoadGenerator(underlyingSessionTo(message))
+        : jvmErrors.crashLoadGenerator(message)
+    ),
+  crashLoadGeneratorIf: (message: string | SessionTo<string>, condition: string | SessionTo<boolean>): T => {
+    if (typeof message === "function") {
+      if (typeof condition === "function") {
+        return wrap(jvmErrors.crashLoadGeneratorIf(underlyingSessionTo(message), underlyingSessionTo(condition)));
+      } else {
+        return wrap(jvmErrors.crashLoadGeneratorIf(underlyingSessionTo(message), condition));
+      }
+    } else {
+      if (typeof condition === "function") {
+        return wrap(jvmErrors.crashLoadGeneratorIf(message, underlyingSessionTo(condition)));
+      } else {
+        return wrap(jvmErrors.crashLoadGeneratorIf(message, condition));
+      }
+    }
+  }
+});

package/src/structure/execs.ts

@@ -0,0 +1,66 @@
+import { Wrapper } from "../common";
+import { SessionTransform, underlyingSessionTransform } from "../session";
+
+import JvmActionBuilder = io.gatling.javaapi.core.ActionBuilder;
+import JvmExecs = io.gatling.javaapi.core.exec.Execs;
+import JvmExecutable = io.gatling.javaapi.core.exec.Executable;
+
+export interface Executable<T extends JvmExecutable> extends Wrapper<T> {}
+
+export interface ActionBuilder extends Executable<JvmActionBuilder> {}
+
+export const wrapActionBuilder = (_underlying: JvmActionBuilder): ActionBuilder => ({
+  _underlying
+});
+
+// interface JvmExecs {
+//   exec<T>(arg0: JvmExecutable, ...arg1: JvmExecutable[]): T;
+//   exec<T>(arg0: JvmChainBuilder[]): T;
+//   exec<T>(arg0: Func<JvmSession, JvmSession>): T;
+// }
+
+export interface ExecFunction<T extends Execs<T>> {
+  /**
+   * Attach some `Executable`s. Chains will be attached sequentially.
+   *
+   * @example
+   * ```ts
+   * const chain1: ChainBuilder = ???
+   * const chain2: ChainBuilder = ???
+   * const chain1ThenChain2 = exec(chain1, chain2)
+   * ```
+   *
+   * @param executable - some `ChainBuilder` or `ActionBuilder`
+   * @param executables - other `ChainBuilder`s or `ActionBuilder`s
+   * @returns a new `StructureBuilder`
+   */
+  (executable: Executable<any>, ...executables: Array<Executable<any>>): T;
+
+  /**
+   * Attach a new action that will execute a function. Important: the function must only perform
+   * fast in-memory operations. In particular, it mustn't perform any long block I/O operation, or
+   * it will hurt Gatling performance badly.
+   *
+   * @example
+   * ```ts
+   * exec(session => session.set("foo", "bar"))
+   * ```
+   *
+   * @param executable - the function
+   * @returns a new `StructureBuilder`
+   */
+  (executable: SessionTransform): T;
+}
+
+export interface Execs<T extends Execs<T>> {
+  exec: ExecFunction<T>;
+}
+
+export const execImpl =
+  <J2, J1 extends JvmExecs<J2, any>, T extends Execs<T>>(jvmExecs: J1, wrap: (wrapped: J2) => T): ExecFunction<T> =>
+  (arg0: Executable<any> | SessionTransform, ...arg1: Array<Executable<any>>) =>
+    wrap(
+      typeof arg0 === "function"
+        ? jvmExecs.exec(underlyingSessionTransform(arg0)) // arg0: SessionTransform
+        : jvmExecs.exec(arg0._underlying, ...arg1.map((e) => e._underlying)) // arg0: Executable, ...arg1: Executable[]
+    );

package/src/structure/feeds.ts

@@ -0,0 +1,62 @@
+import { FeederBuilder } from "../feeders";
+import { SessionTo, underlyingSessionTo } from "../session";
+
+import JvmFeeds = io.gatling.javaapi.core.feed.Feeds;
+
+export interface FeedFunction<T extends Feeds<T>> {
+  // TODO (maybe?): Supplier<Iterator<Map<String, Object>>>, Iterator<Map<String, Object>>
+
+  /**
+   * Attach a feed action.
+   *
+   * @param feederBuilder - a source of records
+   * @returns a new StructureBuilder
+   */
+  (feederBuilder: FeederBuilder<unknown>): T;
+
+  /**
+   * Attach a feed action.
+   *
+   * @param feederBuilder - a source of records
+   * @param numberOfRecords - the number of records to poll from the feeder at once
+   * @returns a new StructureBuilder
+   */
+  (feederBuilder: FeederBuilder<unknown>, numberOfRecords: number): T;
+
+  /**
+   * Attach a feed action.
+   *
+   * @param feederBuilder - a source of records
+   * @param numberOfRecords - the number of records to poll from the feeder at once, expressed as a Gatling Expression
+   * Language String
+   * @returns a new StructureBuilder
+   */
+  (feederBuilder: FeederBuilder<unknown>, numberOfRecords: string): T;
+
+  /**
+   * Attach a feed action.
+   *
+   * @param feederBuilder - a source of records
+   * @param numberOfRecords - the number of records to poll from the feeder at once, as a function
+   * @returns a new StructureBuilder
+   */
+  (feederBuilder: FeederBuilder<unknown>, numberOfRecords: SessionTo<number>): T;
+}
+
+export interface Feeds<T extends Feeds<T>> {
+  feed: FeedFunction<T>;
+}
+
+export const feedImpl =
+  <J2, J1 extends JvmFeeds<J2, any>, T extends Feeds<T>>(jvmFeeds: J1, wrap: (wrapped: J2) => T): FeedFunction<T> =>
+  (feederBuilder: FeederBuilder<unknown>, numberOfRecords?: number | string | SessionTo<number>) => {
+    if (typeof numberOfRecords === "number") {
+      return wrap(jvmFeeds.feed(feederBuilder._underlying, numberOfRecords));
+    } else if (typeof numberOfRecords === "string") {
+      return wrap(jvmFeeds.feed(feederBuilder._underlying, numberOfRecords));
+    } else if (typeof numberOfRecords === "function") {
+      return wrap(jvmFeeds.feed(feederBuilder._underlying, underlyingSessionTo(numberOfRecords)));
+    } else {
+      return wrap(jvmFeeds.feed(feederBuilder._underlying));
+    }
+  };

package/src/structure/forEach.ts

@@ -0,0 +1,68 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmForEach = io.gatling.javaapi.core.loop.ForEach;
+
+export interface ForEachFunction<T extends ForEach<T>> {
+  /**
+   * Define a loop that will iterate over a list of values.
+   *
+   * @param seq - the static list of values to iterate over
+   * @param attributeName - the key to store the current element in the Session
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component to define the loop content
+   */
+  (seq: unknown[], attributeName: string, counterName?: string): On<T>;
+
+  /**
+   * Define a loop that will iterate over a list of values.
+   *
+   * @param seq - the list of values to iterate over, expressed as a Gatling Expression Language String, must evaluate
+   * to an array
+   * @param attributeName - the key to store the current element in the Session
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component to define the loop content
+   */
+  (seq: string, attributeName: string, counterName?: string): On<T>;
+
+  /**
+   * Define a loop that will iterate over a list of values.
+   *
+   * @param seq - the list of values to iterate over, expressed as a function
+   * @param attributeName - the key to store the current element in the Session
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component to define the loop content
+   */
+  (seq: SessionTo<Array<unknown>>, attributeName: string, counterName?: string): On<T>;
+}
+
+export interface ForEach<T extends ForEach<T>> {
+  foreach: ForEachFunction<T>;
+}
+
+export const foreachImpl =
+  <J2, J1 extends JvmForEach<J2, any>, T extends ForEach<T>>(
+    jvmForEach: J1,
+    wrap: (wrapped: J2) => T
+  ): ForEachFunction<T> =>
+  (seq: unknown[] | string | SessionTo<Array<unknown>>, attributeName: string, counterName?: string) => {
+    if (typeof seq === "function") {
+      if (counterName !== undefined) {
+        return wrapOn(jvmForEach.foreach(underlyingSessionTo(seq), attributeName, counterName), wrap);
+      } else {
+        return wrapOn(jvmForEach.foreach(underlyingSessionTo(seq), attributeName), wrap);
+      }
+    } else if (typeof seq === "string") {
+      if (counterName !== undefined) {
+        return wrapOn(jvmForEach.foreach(seq, attributeName, counterName), wrap);
+      } else {
+        return wrapOn(jvmForEach.foreach(seq, attributeName), wrap);
+      }
+    } else {
+      if (counterName !== undefined) {
+        return wrapOn(jvmForEach.foreach(seq, attributeName, counterName), wrap);
+      } else {
+        return wrapOn(jvmForEach.foreach(seq, attributeName), wrap);
+      }
+    }
+  };

package/src/structure/forever.ts

@@ -0,0 +1,25 @@
+import JvmForever = io.gatling.javaapi.core.loop.Forever;
+
+import { On, wrapOn } from "./on";
+
+export interface ForeverFunction<T extends Forever<T>> {
+  /**
+   * Define a loop that will iterate forever.
+   *
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (counterName?: string): On<T>;
+}
+
+export interface Forever<T extends Forever<T>> {
+  forever: ForeverFunction<T>;
+}
+
+export const foreverImpl =
+  <J2, J1 extends JvmForever<J2, any>, T extends Forever<T>>(
+    jvmForever: J1,
+    wrap: (wrapped: J2) => T
+  ): ForeverFunction<T> =>
+  (counterName?: string) =>
+    wrapOn(counterName !== undefined ? jvmForever.forever(counterName) : jvmForever.forever(), wrap);