@api-client/core 0.6.29 → 0.7.0

package/src/runtime/node/ProjectRequestRunner.ts

@@ -1,20 +1,21 @@
 import { EventEmitter } from 'events';
-import { Environment } from '../../models/Environment.js';
+import { Environment, Kind as EnvironmentKind } from '../../models/Environment.js';
 import { Logger } from '../../lib/logging/Logger.js';
 import { IRequestLog, RequestLog } from '../../models/RequestLog.js';
 import { Property } from '../../models/Property.js';
 import { ProjectFolder, Kind as ProjectFolderKind } from '../../models/ProjectFolder.js';
-import { ProjectRequest } from '../../models/ProjectRequest.js';
+import { ProjectRequest, Kind as ProjectRequestKind } from '../../models/ProjectRequest.js';
 import { IHttpRequest } from '../../models/HttpRequest.js';
 import { HttpProject } from '../../models/HttpProject.js';
 import { SentRequest } from '../../models/SentRequest.js';
 import { ErrorResponse } from '../../models/ErrorResponse.js';
-import { VariablesStore } from './VariablesStore.js';
 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 { IProjectExecutionResult, IRequestRunnerOptions, IRequestRunnerRunOptions, IRunResult } from './InteropInterfaces.js';
 import { State } from './enums.js';
+import { HttpRequestRunner } from '../http-runner/HttpRequestRunner.js';
+import { CookieJar } from '../../cookies/CookieJar.js';
+import { AppProject, AppProjectFolder, AppProjectFolderKind, AppProjectItem, AppProjectRequest, AppProjectRequestKind } from '../../models/AppProject.js';
+import { ProjectItem } from '../../models/ProjectItem.js';
 
 export interface ProjectRequestRunner {
   /**
@@ -51,9 +52,12 @@ export interface ProjectRequestRunner {
  * Requests are executed in order defined in the folder.
  */
 export class ProjectRequestRunner extends EventEmitter {
-  eventTarget: EventTarget;
   logger?: Logger;
-  project: HttpProject;
+  project: HttpProject | AppProject;
+  /**
+   * An instance of a cookie jar (store) to put/read cookies.
+   */
+  cookies?: CookieJar;
 
   protected masterEnvironment?: Environment;
   protected extraVariables?: Record<string, string>;
@@ -69,13 +73,13 @@ export class ProjectRequestRunner extends EventEmitter {
     return this._state;
   }
 
-  constructor(project: HttpProject, opts: ProjectRunnerOptions = {}) {
+  constructor(project: HttpProject | AppProject, opts: IRequestRunnerOptions = {}) {
     super();
     this.project = project;
     this.logger = opts.logger;
-    this.eventTarget = opts.eventTarget || new EventTarget();
     this.masterEnvironment = opts.environment;
     this.extraVariables = opts.variables;
+    this.cookies = opts.cookies;
   }
 
   /**
@@ -83,16 +87,104 @@ export class ProjectRequestRunner extends EventEmitter {
    * @param options Run options.
    * @returns A promise with the run result.
    */
-  async run(options?: ProjectRunnerRunOptions): Promise<RunResult[]> {
-    this._state = State.Running as State;
+  async run(options: IRequestRunnerRunOptions = {}): Promise<IProjectExecutionResult> {
     const { project } = this;
-    const executed: RunResult[] = [];
-    for (const request of project.requestIterator(options)) {
-      const info = await this._runItem(request);
-      executed.push(info);
+    const root = options.parent ? project.findFolder(options.parent) : project;
+    if (!root) {
+      throw new Error(`The parent folder not found: ${options.parent}.`);
+    }
+    const variables = await this.getVariables(root);
+    const executed: IRunResult[] = [];
+    for await (const result of this.runIterator(options, variables)) {
+      executed.push(result);
+    }
+    return {
+      items: executed,
+      variables,
+    };
+  }
+
+  /**
+   * Creates an async iterator that allows to iterate over execution results.
+   * The result is yielded after the request is executed.
+   * 
+   * @param options The iterator configuration.
+   */
+  protected async * runIterator(options: IRequestRunnerRunOptions = {}, variables?: Record<string, string>): AsyncGenerator<IRunResult> {
+    const { project } = this;
+    const root = options.parent ? project.findFolder(options.parent) : project;
+    if (!root) {
+      throw new Error(`The parent folder not found: ${options.parent}.`);
+    }
+    
+    this._state = State.Running as State;
+    const envVariables = variables || await this.getVariables(root);
+    const { items } = root;
+    const it = this._runIterator(items, envVariables, options);
+    for await (const request of it) {
+      yield request;
+    }
+  }
+
+  protected async * _runIterator(items: (ProjectItem | AppProjectItem)[], variables: Record<string, string>, options: IRequestRunnerRunOptions): AsyncGenerator<IRunResult> {
+    for (const item of items) {
+      const current = item.getItem();
+      if (!current) {
+        continue;
+      }
+      if (current.kind === AppProjectRequestKind || current.kind === ProjectRequestKind) {
+        if (Array.isArray(options.ignore) && options.ignore.includes(current.key)) {
+          continue;
+        }
+        if (Array.isArray(options.requests) && !options.requests.includes(current.key) && !options.requests.includes(current.info.name || '')) {
+          continue;
+        }
+        const info = await this._runItem(current as AppProjectRequest | ProjectRequest, variables);
+        yield info;
+      } else if (current.kind === ProjectFolderKind || current.kind === AppProjectFolderKind) {
+        if (!options.recursive) {
+          continue;
+        }
+        const parent = current as ProjectFolder | AppProjectFolder;
+        // make a copy so the variables executed in the encapsulated environment won't leak out to the current environment.
+        let encapsulated = false;
+        // we restore the `baseUri` after exiting the folder.
+        const currentBaseUri = variables.baseUri;
+        const { items: parentItems } = parent;
+        const envItem = (parentItems as (ProjectItem | AppProjectItem)[]).find(i => i.kind === EnvironmentKind);
+        let parentVariables: Record<string, string> = {};
+        let childVariables = variables;
+        if (envItem) {
+          const parentEnv = envItem.getItem() as Environment | undefined;
+          if (parentEnv) {
+            encapsulated = parentEnv.encapsulated;
+            parentVariables = await this.applyVariables([parentEnv]);
+            if (encapsulated) {
+              childVariables = parentVariables;
+            } else {
+              childVariables = { ...childVariables, ...parentVariables };
+            }
+          }
+        }
+
+        const it = this._runIterator(parentItems, childVariables, options);
+        for await (const request of it) {
+          yield request;
+        }
+        if (!encapsulated) {
+          // now we set the variables set on children to the main variables object, except for these
+          // declared on the child environments, so these won't leak to other folders.
+          // However, variables set by a request in a folder always is propagated to the main environment.
+          const ignore: string[] = Object.keys(parentVariables);
+          Object.keys(childVariables).forEach((key) => {
+            if (!ignore.includes(key)) {
+              variables[key] = childVariables[key]
+            }
+          });
+        }
+        variables.baseUri = currentBaseUri;
+      }
     }
-    this._state = State.Idle;
-    return executed;
   }
 
   /**
@@ -116,46 +208,33 @@ 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;
+  async* [Symbol.asyncIterator](): AsyncGenerator<IRunResult> {
+    for await (const result of this.runIterator({ recursive: true })) {
+      yield result;
     }
-    this._state = State.Idle;
   }
 
-  private async _runItem(request: ProjectRequest): Promise<RunResult> {
+  private async _runItem(request: ProjectRequest | AppProjectRequest, variables: Record<string, string>): Promise<IRunResult> {
     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>;
-    if (VariablesStore.has(parent)) {
-      variables = VariablesStore.get(parent);
-    } else {
-      variables = await this.getVariables(parent);
-      VariablesStore.set(parent, variables);
-    }
     const info = await this.execute(request, variables);
+    const folder = request.getParent();
     if (folder && folder !== this.project) {
       info.parent = folder.key;
     }
     return info;
   } 
 
-  protected async execute(request: ProjectRequest, variables: Record<string, string>): Promise<RunResult> {
+  protected async execute(request: ProjectRequest | AppProjectRequest, variables: Record<string, string>): Promise<IRunResult> {
     const config = request.getConfig();
-    const factory = new RequestFactory(this.eventTarget);
-
+    const factory = new HttpRequestRunner();
     factory.variables = variables;
     if (request.authorization) {
       factory.authorization = request.authorization.map(i => i.toJSON());
     }
-    if (request.actions) {
-      factory.actions = request.actions.toJSON();
+    if (request.flows) {
+      factory.flows = request.flows;
     }
     if (request.clientCertificate) {
       factory.certificates = [request.clientCertificate.toJSON()];
@@ -166,30 +245,23 @@ export class ProjectRequestRunner extends EventEmitter {
     if (this.logger) {
       factory.logger = this.logger;
     }
-    const info: RunResult = {
+    if (this.cookies) {
+      factory.cookies = this.cookies;
+    }
+    const info: IRunResult = {
       key: request.key,
     };
     const requestData = request.expects.toJSON();
     requestData.url = this.prepareRequestUrl(requestData.url, variables);
 
-    function variableHandler(e: CustomEvent): void {
-      if (e.defaultPrevented) {
-        return;
-      }
-      const { name, value } = e.detail;
-      variables[name] = value;
-      e.preventDefault();
-      e.detail.result = Promise.resolve();
-    }
-
-    this.eventTarget.addEventListener(EventTypes.Environment.set, variableHandler as any);
-
     try {
       // Below replaces the single call to the `run()` function of the factory to 
       // report via the events a request object that has evaluated with the Jexl library.
-      const requestCopy = await factory.processRequestVariables(requestData);
+      const requestCopy = await factory.applyVariables(requestData);
+      await factory.applyAuthorization(requestCopy);
+      await factory.applyCookies(requestCopy);
       this.emit('request', request.key, { ...requestCopy });
-      await factory.processRequestLogic(requestCopy);
+      await factory.runRequestFlows(requestCopy);
       const result = await factory.executeRequest(requestCopy);
       result.requestId = request.key;
       await factory.processResponse(result);
@@ -205,19 +277,17 @@ export class ProjectRequestRunner extends EventEmitter {
       const log = RequestLog.fromRequestResponse(sent.toJSON(), response.toJSON()).toJSON();
       this.emit('error', request.key, log, info.errorMessage);
     }
-
-    this.eventTarget.removeEventListener(EventTypes.Environment.set, variableHandler as any);
     return info;
   }
 
-  protected async getVariables(parent: HttpProject | ProjectFolder): Promise<Record<string, string>> {
+  protected async getVariables(parent: HttpProject | AppProject | ProjectFolder | AppProjectFolder): Promise<Record<string, string>> {
     if (this.masterEnvironment) {
       return this.applyVariables([this.masterEnvironment]);
     }
     return this.createEnvironment(parent);
   }
 
-  protected async createEnvironment(parent: HttpProject | ProjectFolder): Promise<Record<string, string>> {
+  protected async createEnvironment(parent: HttpProject | AppProject | ProjectFolder | AppProjectFolder): Promise<Record<string, string>> {
     const envs = await this.readEnvironments(parent);
     return this.applyVariables(envs);
   }
@@ -225,7 +295,7 @@ export class ProjectRequestRunner extends EventEmitter {
   /**
    * Reads the list of the environments to apply to this runtime.
    */
-  protected async readEnvironments(parent: HttpProject | ProjectFolder): Promise<Environment[]> {
+  protected async readEnvironments(parent: HttpProject | AppProject | ProjectFolder | AppProjectFolder): Promise<Environment[]> {
     const folderKey = parent.kind === ProjectFolderKind ? (parent as ProjectFolder).key : undefined;
     return this.project.readEnvironments({ parent: folderKey });
   }

package/src/runtime/node/ProjectRunner.ts

@@ -9,8 +9,9 @@ import { ProjectRequestRunner } from './ProjectRequestRunner.js';
 import { IProjectExecutionIteration, IProjectExecutionLog } from '../reporters/Reporter.js';
 import { pathExists, readJson } from '../../lib/fs/Fs.js';
 import { BaseRunner } from './BaseRunner.js';
-import { IProjectRunnerOptions } from './InteropInterfaces.js';
+import { IProjectRunnerOptions, IRequestRunnerOptions } from './InteropInterfaces.js';
 import { State } from './enums.js';
+import { AppProject } from '../../models/AppProject.js';
 
 type ProjectParent = HttpProject | ProjectFolder;
 
@@ -89,7 +90,7 @@ export abstract class ProjectRunner extends BaseRunner {
   /**
    * The HTTP project to run requests from.
    */
-  project?: HttpProject;
+  project?: HttpProject | AppProject;
   /**
    * The execution options for the project.
    */
@@ -102,10 +103,6 @@ export abstract class ProjectRunner extends BaseRunner {
    * The selected environment to apply to the requests.
    */
   environment?: Environment;
-  /**
-   * The events target instance for events dispatched by the request factory.
-   */
-  target = new EventTarget();
   /**
    * This is used with `--iterations`. The index of the current iteration.
    */
@@ -262,6 +259,28 @@ export abstract class ProjectRunner extends BaseRunner {
     return env;
   }
 
+  protected async getProjectRunnerOptions(): Promise<IRequestRunnerOptions> {
+    const { environment, options } = this;
+    if (!options) {
+      throw new Error(`Run configure() first.`);
+    }
+    const result: IRequestRunnerOptions = {
+      variables: this.prepareVariables(),
+    };
+    if (environment) {
+      result.environment = environment;
+    }
+    if (options.logger) {
+      result.logger = options.logger;
+    } else {
+      result.logger = new DummyLogger();
+    }
+    if (options.cookies) {
+      result.cookies = options.cookies;
+    }
+    return result;
+  }
+
   /**
    * Runs the requests from the project as configured.
    */
@@ -269,39 +288,35 @@ export abstract class ProjectRunner extends BaseRunner {
     if (this._state === State.Aborted) {
       throw new Error(`The execution has been aborted.`);
     }
-    const { environment, project, options, hasIterations, index, noEmit } = this;
+    const { project, options, hasIterations, index, noEmit } = this;
     if (!options || !project) {
       throw new Error(`Run configure() first.`);
     }
     if (!noEmit) {
       this.emit('before-iteration', index, hasIterations);
     }
-    
-    const runner = new ProjectRequestRunner(project, {
-      environment,
-      logger: options.logger ? options.logger : new DummyLogger(),
-      eventTarget: this.target,
-      variables: this.getSystemVariables(),
-    });
+    const runnerOptions = await this.getProjectRunnerOptions();
+    const runner = new ProjectRequestRunner(project, runnerOptions);
     this._runner = runner;
-    
     runner.on('request', this._requestHandler);
     runner.on('response', this._responseHandler);
     runner.on('error', this._errorHandler);
     this.currentIteration = {
       index: this.index,
       executed: [],
+      variables: {},
     };
     try {
-      await runner.run({ 
-        parent: options.parent, 
-        requests: options.request, 
-        ignore: options.ignore, 
-        recursive: options.recursive 
+      const info = await runner.run({
+        parent: options.parent,
+        requests: options.request,
+        ignore: options.ignore,
+        recursive: options.recursive
       });
+      this.currentIteration.variables = info.variables;
     } catch (e) {
       const cause = e as Error;
-      console.error(e);
+      this.options?.logger?.error(e);
       this.currentIteration.error = cause.message || 'Unknown error ocurred';
       // ...
     }
@@ -343,7 +358,7 @@ export abstract class ProjectRunner extends BaseRunner {
   /**
    * @returns Reads the system variables based on the library configuration.
    */
-  protected getSystemVariables(): Record<string, string> {
+  protected prepareVariables(): Record<string, string> {
     const result: Record<string, string> = {};
     const { options } = this;
     if (!options) {

package/src/runtime/node/ProjectRunnerWorker.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
 /* eslint-disable no-unused-vars */
 import process from 'process';
 import cluster from 'cluster';
@@ -8,6 +9,7 @@ import { IProjectParallelWorkerOptions } from './InteropInterfaces.js';
 import { sleep } from '../../lib/timers/Timers.js';
 import { ProjectRunner } from './ProjectRunner.js';
 import { State } from './enums.js';
+import { InMemoryCookieJar } from '../../cookies/InMemoryCookieJar.js';
 
 class ProjectExeWorker extends ProjectRunner {
   initialize(): void {
@@ -25,6 +27,7 @@ class ProjectExeWorker extends ProjectRunner {
   }
 
   async run(options: IProjectParallelWorkerOptions): Promise<void> {
+    options.cookies = new InMemoryCookieJar();
     try {
       await this.configure(new HttpProject(options.project), options);
       await this.execute();

package/src/runtime/reporters/Reporter.ts

@@ -11,6 +11,11 @@ export interface IProjectExecutionIteration {
    * The list of requests executed in the iteration.
    */
   executed: IRequestLog[];
+  /**
+   * The variables evaluated during the run. 
+   * These variables have values set by requests' HTTP flows.
+   */
+  variables: Record<string, string>;
   /**
    * Optional general error message.
    */

package/src/runtime/store/FilesSdk.ts

@@ -73,7 +73,7 @@ export class FilesSdk extends SdkBase {
     } catch (e) {
       throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
     }
-    if (!Array.isArray(data.data)) {
+    if (!Array.isArray(data.items)) {
       throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
     }
     return data;
@@ -241,7 +241,7 @@ export class FilesSdk extends SdkBase {
    */
   async readBulk(keys: string[], request: ISdkRequestOptions = {}): Promise<IListResponse<IFile|undefined>> {
     const token = request.token || this.sdk.token;
-    const url = this.sdk.getUrl(RouteBuilder.filesBulk());
+    const url = this.sdk.getUrl(RouteBuilder.filesBatch());
     const body = JSON.stringify(keys);
     const result = await this.sdk.http.post(url.toString(), { token, body });
     this.inspectCommonStatusCodes(result.status, result.body);
@@ -264,7 +264,7 @@ export class FilesSdk extends SdkBase {
     } catch (e) {
       throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
     }
-    if (!Array.isArray(data.data)) {
+    if (!Array.isArray(data.items)) {
       throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
     }
     return data;
@@ -408,7 +408,7 @@ export class FilesSdk extends SdkBase {
     } catch (e) {
       throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
     }
-    if (!Array.isArray(data.data)) {
+    if (!Array.isArray(data.items)) {
       throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
     }
     return data;

package/src/runtime/store/HistorySdk.ts

@@ -91,7 +91,7 @@ export class HistorySdk extends SdkBase {
     } catch (e) {
       throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
     }
-    if (!Array.isArray(data.data)) {
+    if (!Array.isArray(data.items)) {
       throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
     }
     return data;