@gatling.io/core 3.11.7 → 3.12.0

package/src/openInjection.ts

@@ -0,0 +1,286 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+
+import { Duration, toJvmDuration } from "./utils/duration";
+import { Wrapper } from "./common";
+
+import JvmOpenInjectionStep = io.gatling.javaapi.core.OpenInjectionStep;
+import JvmOpenInjectionStepRamp = io.gatling.javaapi.core.OpenInjectionStep$Ramp;
+import JvmOpenInjectionStepStressPeak = io.gatling.javaapi.core.OpenInjectionStep$StressPeak;
+import JvmOpenInjectionStepConstantRate = io.gatling.javaapi.core.OpenInjectionStep$ConstantRate;
+import JvmOpenInjectionStepConstantRateConstantRateOpenInjectionStep = io.gatling.javaapi.core.ConstantRate$ConstantRateOpenInjectionStep;
+import JvmOpenInjectionStepRampRate = io.gatling.javaapi.core.OpenInjectionStep$RampRate;
+import JvmOpenInjectionStepRampRateDuring = io.gatling.javaapi.core.RampRate$During;
+import JvmOpenInjectionStepRampRateRampRateOpenInjectionStep = io.gatling.javaapi.core.RampRate$RampRateOpenInjectionStep;
+import JvmOpenInjectionStepStairs = io.gatling.javaapi.core.OpenInjectionStep$Stairs;
+import JvmOpenInjectionStepStairsTimes = io.gatling.javaapi.core.Stairs$Times;
+import JvmOpenInjectionStepStairsComposite = io.gatling.javaapi.core.Stairs$Composite;
+
+/**
+ * An injection profile step for using an open workload model where you control the arrival rate of
+ * new users. In 99.99% of the cases, the right choice, over closed workload model.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface OpenInjectionStep extends Wrapper<JvmOpenInjectionStep> {}
+
+const wrapOpenInjectionStep = (_underlying: JvmOpenInjectionStep): OpenInjectionStep => ({ _underlying });
+
+export interface ConstantRateOpenInjectionStep extends OpenInjectionStep {
+  randomized(): OpenInjectionStep;
+}
+
+const wrapConstantRateOpenInjectionStep = (
+  _underlying: JvmOpenInjectionStepConstantRateConstantRateOpenInjectionStep
+): ConstantRateOpenInjectionStep => ({
+  _underlying,
+  randomized: () => wrapOpenInjectionStep(_underlying.randomized())
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject a stock of users distributed
+ * evenly on a given period of time. Strictly equivalent to {@link ConstantRateOpenInjectionStep}
+ */
+export interface OpenInjectionStepRamp extends Wrapper<JvmOpenInjectionStepRamp> {
+  /**
+   * Define the duration of the ramp
+   *
+   * @param duration - the ramp duration
+   * @returns a new OpenInjectionStep
+   */
+  during(duration: Duration): OpenInjectionStep;
+}
+
+const wrapOpenInjectionStepRamp = (_underlying: JvmOpenInjectionStepRamp): OpenInjectionStepRamp => ({
+  _underlying,
+  during: (duration: Duration) => wrapOpenInjectionStep(_underlying.during(toJvmDuration(duration)))
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject a stock of users distributed
+ * with a <a hreh="https://en.wikipedia.org/wiki/Heaviside_step_function">Heaviside</a>
+ * distribution on a given period of time. Strictly equivalent to {@link OpenInjectionStepConstantRate}
+ */
+export interface OpenInjectionStepStressPeak extends Wrapper<JvmOpenInjectionStepStressPeak> {
+  /**
+   * Define the duration of the Heaviside distribution
+   *
+   * @param duration - the duration
+   * @returns a new OpenInjectionStep
+   */
+  during(duration: Duration): OpenInjectionStep;
+}
+
+const wrapOpenInjectionStepStressPeak = (_underlying: JvmOpenInjectionStepStressPeak): OpenInjectionStepStressPeak => ({
+  _underlying,
+  during: (duration: Duration) => wrapOpenInjectionStep(_underlying.during(toJvmDuration(duration)))
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users at a constant rate for a
+ * given duration.
+ */
+export interface OpenInjectionStepConstantRate extends Wrapper<JvmOpenInjectionStepConstantRate> {
+  /**
+   * Define the duration of the step
+   *
+   * @param duration - the duration
+   * @returns a new OpenInjectionStep
+   */
+  during(duration: Duration): ConstantRateOpenInjectionStep;
+}
+
+const wrapOpenInjectionStepConstantRate = (
+  _underlying: JvmOpenInjectionStepConstantRate
+): OpenInjectionStepConstantRate => ({
+  _underlying,
+  during: (duration: Duration) => wrapConstantRateOpenInjectionStep(_underlying.during(toJvmDuration(duration)))
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users at a rate that will
+ * increase linearly for a given duration.
+ */
+export interface OpenInjectionStepRampRate extends Wrapper<JvmOpenInjectionStepRampRate> {
+  /**
+   * Define the target rate at the end of the ramp
+   *
+   * @param to - the target rate
+   * @returns the next DSL step
+   */
+  to(to: number): OpenInjectionStepRampRateDuring;
+}
+
+const wrapOpenInjectionStepRampRate = (_underlying: JvmOpenInjectionStepRampRate): OpenInjectionStepRampRate => ({
+  _underlying,
+  to: (to: number) => wrapOpenInjectionStepRampRateDuring(_underlying.to(to))
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users at a rate that will
+ * increase linearly for a given duration.
+ */
+export interface OpenInjectionStepRampRateDuring extends Wrapper<JvmOpenInjectionStepRampRateDuring> {
+  /**
+   * Define the duration of the ramp
+   *
+   * @param duration - the duration
+   * @returns a new OpenInjectionStep
+   */
+  during(duration: Duration): RampRateOpenInjectionStep;
+}
+
+const wrapOpenInjectionStepRampRateDuring = (
+  _underlying: JvmOpenInjectionStepRampRateDuring
+): OpenInjectionStepRampRateDuring => ({
+  _underlying,
+  during: (duration: Duration) => wrapRampRateOpenInjectionStep(_underlying.during(toJvmDuration(duration)))
+});
+
+/**
+ * A special {@link OpenInjectionStep} that supports "randomized".
+ */
+export interface RampRateOpenInjectionStep extends OpenInjectionStep {
+  randomized(): OpenInjectionStep;
+}
+
+const wrapRampRateOpenInjectionStep = (
+  _underlying: JvmOpenInjectionStepRampRateRampRateOpenInjectionStep
+): ConstantRateOpenInjectionStep => ({
+  _underlying,
+  randomized: () => wrapOpenInjectionStep(_underlying.randomized())
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users with stairs rates.
+ */
+export interface OpenInjectionStepStairs extends Wrapper<JvmOpenInjectionStepStairs> {
+  /**
+   * Define the number of levels
+   *
+   * @param levels - the number of levels in the stairs
+   * @returns the next DSL step
+   */
+  times(levels: number): OpenInjectionStepStairsTimes;
+}
+
+const wrapOpenInjectionStepStairs = (_underlying: JvmOpenInjectionStepStairs): OpenInjectionStepStairs => ({
+  _underlying,
+  times: (levels: number) => wrapOpenInjectionStepStairsTimes(_underlying.times(levels))
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users with stairs rates.
+ */
+export interface OpenInjectionStepStairsTimes extends Wrapper<JvmOpenInjectionStepStairsTimes> {
+  /**
+   * Define the duration of each level
+   *
+   * @param duration - the duration
+   * @returns the next DSL step
+   */
+  eachLevelLasting(duration: Duration): OpenInjectionStepStairsComposite;
+}
+
+const wrapOpenInjectionStepStairsTimes = (
+  _underlying: JvmOpenInjectionStepStairsTimes
+): OpenInjectionStepStairsTimes => ({
+  _underlying,
+  eachLevelLasting: (duration: Duration) =>
+    wrapOpenInjectionStepStairsComposite(_underlying.eachLevelLasting(toJvmDuration(duration)))
+});
+
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users with stairs rates.
+ */
+export interface OpenInjectionStepStairsComposite extends OpenInjectionStep {
+  /**
+   * Define the initial number of users per second rate (optional)
+   *
+   * @param startingRate - the initial rate
+   * @returns a usable {@link OpenInjectionStep}
+   */
+  startingFrom(startingRate: number): OpenInjectionStepStairsComposite;
+
+  /**
+   * Define ramps separating levels (optional)
+   *
+   * @param duration - the duration
+   * @returns a usable {@link OpenInjectionStep}
+   */
+  separatedByRampsLasting(duration: Duration): OpenInjectionStepStairsComposite;
+}
+
+const wrapOpenInjectionStepStairsComposite = (
+  _underlying: JvmOpenInjectionStepStairsComposite
+): OpenInjectionStepStairsComposite => ({
+  _underlying,
+  startingFrom: (startingRate: number) => wrapOpenInjectionStepStairsComposite(_underlying.startingFrom(startingRate)),
+  separatedByRampsLasting: (duration: Duration) =>
+    wrapOpenInjectionStepStairsComposite(_underlying.separatedByRampsLasting(toJvmDuration(duration)))
+});
+
+/**
+ * Bootstrap a new open workload rampUsers injection profile, see {@link OpenInjectionStepRamp}
+ *
+ * @param users - the total number of users to inject
+ * @returns the next DSL step
+ */
+export const rampUsers = (users: number): OpenInjectionStepRamp =>
+  wrapOpenInjectionStepRamp(JvmCoreDsl.rampUsers(users));
+
+/**
+ * Bootstrap a new open workload stress peak injection profile, see {@link
+ * OpenInjectionStepStressPeak}
+ *
+ * @param users - the total number of users to inject
+ * @returns the next DSL step
+ */
+export const stressPeakUsers = (users: number): OpenInjectionStepStressPeak =>
+  wrapOpenInjectionStepStressPeak(JvmCoreDsl.stressPeakUsers(users));
+
+/**
+ * Inject a bunch of users at the same time.
+ *
+ * @param users - the number of users to inject
+ * @returns a new OpenInjectionStep
+ */
+export const atOnceUsers = (users: number): OpenInjectionStep => wrapOpenInjectionStep(JvmCoreDsl.atOnceUsers(users));
+
+/**
+ * Bootstrap a new open workload constantUsersPerSec injection profile, see {@link
+ * OpenInjectionStepConstantRate}
+ *
+ * @param rate - the users per second rate
+ * @returns the next DSL step
+ */
+export const constantUsersPerSec = (rate: number): OpenInjectionStepConstantRate =>
+  wrapOpenInjectionStepConstantRate(JvmCoreDsl.constantUsersPerSec(rate));
+
+/**
+ * Bootstrap a new open workload rampUsersPerSec injection profile, see {@link
+ * OpenInjectionStepRampRate}
+ *
+ * @param rate - the users per second start rate
+ * @returns the next DSL step
+ */
+export const rampUsersPerSec = (rate: number): OpenInjectionStepRampRate =>
+  wrapOpenInjectionStepRampRate(JvmCoreDsl.rampUsersPerSec(rate));
+
+/**
+ * Don't inject any new user for a given duration
+ *
+ * @param duration - the duration
+ * @returns a new OpenInjectionStep
+ */
+export const nothingFor = (duration: Duration): OpenInjectionStep =>
+  wrapOpenInjectionStep(JvmCoreDsl.nothingFor(toJvmDuration(duration)));
+
+/**
+ * Bootstrap a new open workload incrementUsersPerSec injection profile, see {@link
+ * OpenInjectionStepStairs}
+ *
+ * @param rateIncrement - the difference of users per second rate between levels of the stairs
+ * @returns the next DSL step
+ */
+export const incrementUsersPerSec = (rateIncrement: number): OpenInjectionStepStairs =>
+  wrapOpenInjectionStepStairs(JvmCoreDsl.incrementUsersPerSec(rateIncrement));

package/src/parameters.ts

@@ -0,0 +1,38 @@
+import { System as JvmSystem } from "@gatling.io/jvm-types";
+
+export interface GetWithDefault {
+  (name: string): string | undefined;
+  (name: string, defaultValue: string): string;
+}
+
+/**
+ * Gets the parameter indicated by the specified name.
+ *
+ * Parameters can be specified in the `gatling run` command by passing arguments with the format `key=value`, e.g.
+ * `gatling run parameter1=foo parameter2=bar`. You would then retrieve them in your simulation by calling
+ * `getParameter("parameter1")` and `getParameter("parameter2")`.
+ *
+ * @param key - the key of the parameter.
+ * @param defaultValue - a default value
+ * @returns the string value of the parameter if it is defined, or else `defaultValue` if provided, or else `undefined`.
+ */
+export const getParameter: GetWithDefault = (key: string, defaultValue?: string) =>
+  getOrElse(JvmSystem.getProperty(key), defaultValue) as any;
+
+/**
+ * @deprecated Use {@link getParameter} instead.
+ */
+export const getOption: GetWithDefault = getParameter;
+
+/**
+ * Gets the environment variable indicated by the specified name.
+ *
+ * @param name - the name of the environment variable.
+ * @param defaultValue - a default value
+ * @returns the string value of the environment variable if it is defined, or else `defaultValue` if provided, or else `undefined`.
+ */
+export const getEnvironmentVariable: GetWithDefault = (name: string, defaultValue?: string) =>
+  getOrElse(JvmSystem.getenv(name), defaultValue) as any;
+
+const getOrElse = (value: string | null, defaultValue?: string): string | undefined =>
+  typeof value === "string" ? value : defaultValue;

package/src/population.ts

@@ -0,0 +1,105 @@
+import { Duration, toJvmDuration } from "./utils/duration";
+import { PauseType, toJvmPauseType } from "./structure/pauses";
+import { Wrapper } from "./common";
+import { ProtocolBuilder } from "./protocol";
+import { SessionTo, underlyingSessionTo } from "./session";
+import { ThrottleStep } from "./throttling";
+
+import JvmPopulationBuilder = io.gatling.javaapi.core.PopulationBuilder;
+
+/**
+ * A builder for a Population = a Scenario + an injection profile.
+ *
+ * Immutable, meaning each method doesn't mutate the current instance but return a new one.
+ */
+export interface PopulationBuilder extends Wrapper<JvmPopulationBuilder> {
+  /**
+   * Define the optional protocols for this PopulationBuilder
+   *
+   * @param protocols - the protocols
+   * @returns a new PopulationBuilder
+   */
+  protocols(...protocols: ProtocolBuilder[]): PopulationBuilder;
+
+  /**
+   * Define some other PopulationBuilder to be executed once all the users of this PopulationBuilder
+   * complete their Scenario.
+   *
+   * @param children - the children PopulationBuilder
+   * @returns a new PopulationBuilder
+   */
+  andThen(...children: PopulationBuilder[]): PopulationBuilder;
+
+  /**
+   * Disable the pauses
+   *
+   * @return a new PopulationBuilder
+   */
+  disablePauses(): PopulationBuilder;
+
+  /**
+   * Use constant pauses
+   *
+   * @return a new PopulationBuilder
+   */
+  constantPauses(): PopulationBuilder;
+
+  /**
+   * Use exponential pauses
+   *
+   * @return a new PopulationBuilder
+   */
+  exponentialPauses(): PopulationBuilder;
+
+  /**
+   * Use custom pauses
+   *
+   * @return a new PopulationBuilder
+   */
+  customPauses(f: SessionTo<number>): PopulationBuilder;
+
+  /**
+   * Use uniform pauses with a standard deviation percentage
+   *
+   * @return a new PopulationBuilder
+   */
+  uniformPauses(plusOrMinus: Duration): PopulationBuilder;
+
+  /**
+   * Use pauses configured with a given strategy
+   *
+   * @param pauseType the pause type
+   * @return a new PopulationBuilder
+   */
+  pauses(pauseType: PauseType): PopulationBuilder;
+
+  /**
+   * Define the optional throttling profile
+   *
+   * @param throttleSteps the throttling profile steps
+   * @return a new PopulationBuilder
+   */
+  throttle(...throttleSteps: ThrottleStep[]): PopulationBuilder;
+
+  /**
+   * Disable the injection profile sharding that happens normally when running with Gatling
+   * Enterprise. Only effective when the test is running with Gatling Enterprise, noop otherwise.
+   *
+   * @return a new PopulationBuilder
+   */
+  noShard(): PopulationBuilder;
+}
+
+export const wrapPopulationBuilder = (_underlying: JvmPopulationBuilder): PopulationBuilder => ({
+  _underlying,
+  protocols: (...protocols) => wrapPopulationBuilder(_underlying.protocols(protocols.map((p) => p._underlying))),
+  andThen: (...children) => wrapPopulationBuilder(_underlying.andThen(children.map((c) => c._underlying))),
+  disablePauses: () => wrapPopulationBuilder(_underlying.disablePauses()),
+  constantPauses: () => wrapPopulationBuilder(_underlying.constantPauses()),
+  exponentialPauses: () => wrapPopulationBuilder(_underlying.exponentialPauses()),
+  customPauses: (f) => wrapPopulationBuilder(_underlying.customPauses(underlyingSessionTo(f))),
+  uniformPauses: (plusOrMinus) => wrapPopulationBuilder(_underlying.uniformPauses(toJvmDuration(plusOrMinus))),
+  pauses: (pauseType) => wrapPopulationBuilder(_underlying.pauses(toJvmPauseType(pauseType))),
+  throttle: (...throttleSteps) => wrapPopulationBuilder(_underlying.throttle(throttleSteps.map((t) => t._underlying))),
+  noShard: () => wrapPopulationBuilder(_underlying.noShard())
+});

package/src/protocol.ts

@@ -0,0 +1,5 @@
+import { Wrapper } from "./common";
+
+import JvmProtocolBuilder = io.gatling.javaapi.core.ProtocolBuilder;
+
+export interface ProtocolBuilder extends Wrapper<JvmProtocolBuilder> {}

package/src/scenario.ts

@@ -0,0 +1,37 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+
+import { ClosedInjectionStep } from "./closedInjection";
+import { OpenInjectionStep } from "./openInjection";
+import { PopulationBuilder, wrapPopulationBuilder } from "./population";
+import { StructureBuilder, structureBuilderImpl } from "./structure";
+
+import JvmScenarioBuilder = io.gatling.javaapi.core.ScenarioBuilder;
+
+/**
+ * Javascript wrapper of a Java ScenarioBuilder.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface ScenarioBuilder extends StructureBuilder<ScenarioBuilder> {
+  injectOpen(...steps: OpenInjectionStep[]): PopulationBuilder;
+  injectClosed(...steps: ClosedInjectionStep[]): PopulationBuilder;
+}
+
+const wrapScenarioBuilder = (jvmScenarioBuilder: JvmScenarioBuilder): ScenarioBuilder => ({
+  injectOpen: (...steps: OpenInjectionStep[]): PopulationBuilder =>
+    wrapPopulationBuilder(jvmScenarioBuilder.injectOpen(steps.map((s) => s._underlying))),
+  injectClosed: (...steps: ClosedInjectionStep[]): PopulationBuilder =>
+    wrapPopulationBuilder(jvmScenarioBuilder.injectClosed(steps.map((s) => s._underlying))),
+  ...structureBuilderImpl(jvmScenarioBuilder, wrapScenarioBuilder)
+});
+
+/**
+ * Create a new immutable Scenario builder
+ *
+ * @param name - the scenario name
+ * @returns a new Scenario builder
+ */
+export const scenario = (name: string): ScenarioBuilder => {
+  const jvmScenarioBuilder = JvmCoreDsl.scenario(name);
+  return wrapScenarioBuilder(jvmScenarioBuilder);
+};

package/src/session.ts

@@ -0,0 +1,182 @@
+import { asByteArray } from "./gatlingJvm/byteArrays";
+import { asJava } from "./gatlingJvm/collections";
+import { Duration, toJvmDuration } from "./utils/duration";
+import { Wrapper } from "./common";
+
+import JvmSession = io.gatling.javaapi.core.Session;
+
+/**
+ * The state of a given virtual user.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface Session extends Wrapper<JvmSession> {
+  /**
+   * Get a stored value by its key
+   *
+   * @param key - the storage key
+   * @typeParam T - the type of the desired value
+   * @returns the value if it exists, null otherwise
+   */
+  get<T>(key: string): T;
+
+  /**
+   * Create a new instance updated with a given attribute, possibly overriding an existing one
+   *
+   * @param key - the attribute key
+   * @param value - the attribute value
+   * @returns a new instance with the new stored attribute
+   */
+  set(key: string, value: any): Session;
+
+  /**
+   * Create a new instance updated with a given byte array (number[]), possibly overriding an existing one
+   *
+   * @param key - the attribute key
+   * @param value - the attribute value
+   * @returns a new instance with the new stored attribute
+   */
+  setByteArray(key: string, value: number[]): Session;
+
+  /**
+   * Create a new instance updated with multiple attributes, possibly overriding existing ones
+   *
+   * @param newAttributes - the new attributes
+   * @returns a new instance with the new stored attributes
+   */
+  setAll(newAttributes: Record<string, any>): Session;
+
+  /**
+   * Create a new instance updated with an attribute removed
+   *
+   * @param key - the key of the attribute to remove
+   * @returns a new instance with the attribute removed
+   */
+  remove(key: string): Session;
+
+  /**
+   * Create a new instance updated with all attributes removed except Gatling internal ones
+   *
+   * @returns a new instance with a reset user state
+   */
+  reset(): Session;
+
+  /**
+   * Create a new instance updated with multiple attributes removed
+   *
+   * @param keys - the keys of the attributes to remove
+   * @returns a new instance with the attributes removed
+   */
+  removeAll(...keys: string[]): Session;
+
+  /**
+   * Check if the Session contains a given attribute key
+   *
+   * @param key - the attribute key
+   * @returns true is the key is defined
+   */
+  contains(key: string): boolean;
+
+  /**
+   * @returns if the Session's status is failure
+   */
+  isFailed(): boolean;
+
+  /**
+   * Create a new instance with the status forced to "succeeded"
+   *
+   * @returns a new instance with the new status
+   */
+  markAsSucceeded(): Session;
+
+  /**
+   * Create a new instance with the status forced to "failed"
+   *
+   * @returns a new instance with the new status
+   */
+  markAsFailed(): Session;
+
+  /**
+   * Provide the name of the scenario of the virtual user
+   *
+   * @returns the virtual user's scenario name
+   */
+  scenario(): string;
+
+  /**
+   * Provide the list of groups at the current position for the virtual user
+   *
+   * @returns the list of groups, from shallowest to deepest
+   */
+  groups(): string[];
+
+  /**
+   * Provide the unique (for this injector) id of the virtual user
+   *
+   * @returns the virtual user's id
+   */
+  userId(): number;
+
+  /**
+   * Provide a representation of the Session content
+   *
+   * @returns the Session content as a pretty printed string
+   */
+  toString(): string;
+}
+
+export const wrapSession = (_underlying: JvmSession): Session => ({
+  _underlying,
+  get: <T>(key: string): T => _underlying.get(key),
+  set: (key: string, value: any): Session => {
+    return wrapSession(_underlying.set(key, asJava(value)));
+  },
+  setByteArray: (key: string, value: number[]): Session => wrapSession(_underlying.set(key, asByteArray(value))),
+  setAll: (newAttributes: Record<string, any>): Session => {
+    let session = _underlying;
+    for (const key in newAttributes) {
+      session = session.set(key, asJava(newAttributes[key]));
+    }
+    return wrapSession(session);
+  },
+  remove: (key: string): Session => wrapSession(_underlying.remove(key)),
+  reset: (): Session => wrapSession(_underlying.reset()),
+  removeAll: (...keys: string[]): Session => wrapSession(_underlying.removeAll(...keys)),
+  contains: (key: string): boolean => _underlying.contains(key),
+  isFailed: (): boolean => _underlying.isFailed(),
+  markAsSucceeded: (): Session => wrapSession(_underlying.markAsSucceeded()),
+  markAsFailed: (): Session => wrapSession(_underlying.markAsFailed()),
+  scenario: (): string => _underlying.scenario(),
+  groups: (): string[] => _underlying.groups(),
+  userId: (): number => _underlying.userId(),
+  toString: (): string => _underlying.toString()
+});
+
+export type Expression<T> = T | ((session: Session) => T);
+
+export type SessionTransform = (session: Session) => Session;
+export const underlyingSessionTransform =
+  (f: SessionTransform): ((jvmSession: JvmSession) => JvmSession) =>
+  (jvmSession: JvmSession) =>
+    f(wrapSession(jvmSession))._underlying;
+
+export type SessionTo<T> = (session: Session) => T;
+export const underlyingSessionTo =
+  <T>(f: SessionTo<T>): ((jvmSession: JvmSession) => T) =>
+  (jvmSession: JvmSession) =>
+    f(wrapSession(jvmSession));
+
+export const underlyingSessionToJava =
+  <T>(f: SessionTo<T>): ((jvmSession: JvmSession) => unknown) =>
+  (jvmSession: JvmSession) =>
+    asJava(f(wrapSession(jvmSession)));
+
+export const underlyingSessionToDuration =
+  (f: SessionTo<Duration>): ((jvmSession: JvmSession) => java.time.Duration) =>
+  (jvmSession: JvmSession) =>
+    toJvmDuration(f(wrapSession(jvmSession)));
+
+export const underlyingXWithSessionTo =
+  <X, X2>(f: (x: X, session: Session) => X2): ((x: X, jvmSession: JvmSession) => X2) =>
+  (x: X, jvmSession: JvmSession) =>
+    f(x, wrapSession(jvmSession));