@api-client/core 0.5.26 → 0.5.27

package/src/runtime/node/ProjectRequestRunner.ts

@@ -14,6 +14,7 @@ import { VariablesProcessor } from '../variables/VariablesProcessor.js';
 import { RequestFactory } from './RequestFactory.js';
 import { EventTypes } from '../../events/EventTypes.js';
 import { ProjectRunnerOptions, ProjectRunnerRunOptions, RunResult } from './InteropInterfaces.js';
+import { State } from './enums.js';
 
 export interface ProjectRequestRunner {
   /**
@@ -62,6 +63,12 @@ export class ProjectRequestRunner extends EventEmitter {
    */
   protected variablesProcessor = new VariablesProcessor();
 
+  protected _state: State = State.Idle;
+
+  get state(): State {
+    return this._state;
+  }
+
   constructor(project: HttpProject, opts: ProjectRunnerOptions = {}) {
     super();
     this.project = project;
@@ -77,15 +84,25 @@ export class ProjectRequestRunner extends EventEmitter {
    * @returns A promise with the run result.
    */
   async run(options?: ProjectRunnerRunOptions): Promise<RunResult[]> {
+    this._state = State.Running as State;
     const { project } = this;
     const executed: RunResult[] = [];
     for (const request of project.requestIterator(options)) {
       const info = await this._runItem(request);
       executed.push(info);
     }
+    this._state = State.Idle;
     return executed;
   }
 
+  /**
+   * Aborts the current run.
+   * The promise returned by the `run()` method will reject if not yet resolved.
+   */
+  abort(): void {
+    this._state = State.Aborted;
+  }
+
   /**
    * Allows to iterate over project requests recursively and execute each request
    * in order. The generator yields the `RunResult` for the request.
@@ -101,13 +118,18 @@ export class ProjectRequestRunner extends EventEmitter {
    */
   async* [Symbol.asyncIterator](): AsyncGenerator<RunResult> {
     const { project } = this;
+    this._state = State.Running as State;
     for (const request of project.requestIterator({ recursive: true })) {
       const info = await this._runItem(request);
       yield info;
     }
+    this._state = State.Idle;
   }
 
   private async _runItem(request: ProjectRequest): Promise<RunResult> {
+    if (this._state === State.Aborted) {
+      throw new Error(`The execution has been aborted.`);
+    }
     const folder = request.getParent();
     const parent = folder || this.project;
     let variables: Record<string, string>;

package/src/runtime/node/ProjectRunner.ts

@@ -10,6 +10,7 @@ import { IProjectExecutionIteration, IProjectExecutionLog } from '../reporters/R
 import { pathExists, readJson } from '../../lib/fs/Fs.js';
 import { BaseRunner } from './BaseRunner.js';
 import { IProjectRunnerOptions } from './InteropInterfaces.js';
+import { State } from './enums.js';
 
 type ProjectParent = HttpProject | ProjectFolder;
 
@@ -127,11 +128,48 @@ export abstract class ProjectRunner extends BaseRunner {
    */
   noEmit = false;
 
+  /**
+   * When executing, this is the last user request runner.
+   */
+  protected _runner?: ProjectRequestRunner;
+
+  protected _state: State = State.Idle;
+
+  get state(): State {
+    return this._state;
+  }
+
+  protected _signal?: AbortSignal;
+
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   * @type {(AbortSignal | undefined)}
+   */
+  get signal(): AbortSignal | undefined {
+    return this._signal;
+  }
+
+  set signal(value: AbortSignal | undefined) {
+    const old = this._signal;
+    if (old === value) {
+      return;
+    }
+    this._signal = value;
+    if (old) {
+      old.removeEventListener('abort', this._abortHandler);
+    }
+    if (value) {
+      value.addEventListener('abort', this._abortHandler);
+    }
+  }
+
   constructor() {
     super();
     this._requestHandler = this._requestHandler.bind(this);
     this._responseHandler = this._responseHandler.bind(this);
     this._errorHandler = this._errorHandler.bind(this);
+    this._abortHandler = this._abortHandler.bind(this);
   }
 
   /**
@@ -152,6 +190,9 @@ export abstract class ProjectRunner extends BaseRunner {
     }
     this.root = root;
     this.environment = await this.getEnvironment();
+    if (opts.signal) {
+      this.signal = opts.signal;
+    }
   }
 
   /**
@@ -160,6 +201,24 @@ export abstract class ProjectRunner extends BaseRunner {
    */
   abstract execute(): Promise<IProjectExecutionLog>;
 
+  /**
+   * Aborts the current run.
+   * The promise returned by the `execute()` method will reject if not yet resolved.
+   */
+  abort(): void {
+    this._state = State.Aborted;
+    if (this._runner) {
+      this._runner.abort();
+    }
+  }
+
+  /**
+   * Handler for the `abort` event on the `AbortSignal`.
+   */
+  protected _abortHandler(): void {
+    this.abort();
+  }
+
   /**
    * Creates the report of the execution.
    */
@@ -207,6 +266,9 @@ export abstract class ProjectRunner extends BaseRunner {
    * Runs the requests from the project as configured.
    */
   protected async executeIteration(): Promise<void> {
+    if (this._state === State.Aborted) {
+      throw new Error(`The execution has been aborted.`);
+    }
     const { environment, project, options, hasIterations, index, noEmit } = this;
     if (!options || !project) {
       throw new Error(`Run configure() first.`);
@@ -221,6 +283,7 @@ export abstract class ProjectRunner extends BaseRunner {
       eventTarget: this.target,
       variables: this.getSystemVariables(),
     });
+    this._runner = runner;
     
     runner.on('request', this._requestHandler);
     runner.on('response', this._responseHandler);

package/src/runtime/node/ProjectRunnerWorker.ts

@@ -7,6 +7,7 @@ import { IWorkerMessage } from './ProjectParallelRunner.js';
 import { IProjectParallelWorkerOptions } from './InteropInterfaces.js';
 import { sleep } from '../../lib/timers/Timers.js';
 import { ProjectRunner } from './ProjectRunner.js';
+import { State } from './enums.js';
 
 class ProjectExeWorker extends ProjectRunner {
   initialize(): void {
@@ -40,6 +41,7 @@ class ProjectExeWorker extends ProjectRunner {
     }
     function unhandledRejection(): void {}
     process.on('unhandledRejection', unhandledRejection);
+    this._state = State.Running as State;
     this.startTime = Date.now();
     while (this.remaining > 0) {
       this.remaining--;
@@ -54,6 +56,7 @@ class ProjectExeWorker extends ProjectRunner {
 
     const log = await this.createReport();
     process.send!({ cmd: 'result', data: log.iterations });
+    this._state = State.Idle as State;
     return log;
   }
 }

package/src/runtime/node/ProjectSerialRunner.ts

@@ -2,6 +2,7 @@ import { SerializableError } from '../../models/SerializableError.js';
 import { sleep } from '../../lib/timers/Timers.js';
 import { ProjectRunner } from './ProjectRunner.js';
 import { IProjectExecutionLog } from '../reporters/Reporter.js';
+import { State } from './enums.js';
 
 /**
  * Project runner that runs the requests in the project one-by-one.
@@ -15,7 +16,7 @@ export class ProjectSerialRunner extends ProjectRunner {
     if (!root) {
       throw new SerializableError(`The project runner is not configured.`, 'ECONFIGURE');
     }
-    
+    this._state = State.Running as State;
     this.startTime = Date.now();
     while (this.remaining > 0) {
       this.remaining--;
@@ -29,7 +30,7 @@ export class ProjectSerialRunner extends ProjectRunner {
         await sleep(0);
       }
     }
-
+    this._state = State.Idle as State;
     this.endTime = Date.now();
     return this.createReport();
   }

package/src/runtime/node/RequestFactory.ts

@@ -73,6 +73,13 @@ export class RequestFactory {
 
   logger?: Logger;
 
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   * @type {(AbortSignal | undefined)}
+   */
+  signal?: AbortSignal;
+
   /**
    * Creates an instance from the IRequest object with setting the corresponding variables.
    * @param eventTarget The main events bus.
@@ -302,7 +309,7 @@ export class RequestFactory {
    * Creates a configuration options for the HTTP engine.
    */
   async prepareEngineConfig(): Promise<HttpEngineOptions> {
-    const { certificates, logger } = this;
+    const { certificates, logger, signal } = this;
     const auth = await this.readAuthorization();
     const config = await this.readConfig();
     const opts: HttpEngineOptions = {};
@@ -315,6 +322,9 @@ export class RequestFactory {
     if (logger) {
       opts.logger = logger;
     }
+    if (signal) {
+      opts.signal = signal;
+    }
     if (!config || config.enabled === false) {
       return opts;
     }

package/src/runtime/node/enums.ts

@@ -0,0 +1,8 @@
+/**
+ * The request execution state.
+ */
+export enum State {
+  Idle,
+  Running,
+  Aborted,
+}