@api-client/core 0.3.12 → 0.4.2

package/src/runtime/modules/RequestCookies.ts

@@ -4,10 +4,11 @@ import { Headers } from '../../lib/headers/Headers.js';
 import { IHttpRequest } from '../../models/HttpRequest.js';
 import { ExecutionContext } from './ModulesRegistry.js';
 import { IResponseRedirect } from '../../models/ResponseRedirect.js';
-import { IArcResponse } from '../../models/ArcResponse.js';
+import { IResponse } from '../../models/Response.js';
 import { IErrorResponse } from '../../models/ErrorResponse.js';
 import { IRequestLog } from '../../models/RequestLog.js';
 import { HttpCookie } from '../../models/HttpCookie.js';
+import { Kind as RequestConfigKind } from '../../models/RequestConfig.js';
 import { Cookie } from '../../lib/cookies/Cookie.js';
 
 /**
@@ -51,7 +52,7 @@ function applyCookieHeader(header: string, request: IHttpRequest): void {
  * @param redirects List of redirect responses 
  * @returns An object with `cookies` and `expired` arrays of cookies.
  */
-function extract(response: IArcResponse, url: string, redirects?: IResponseRedirect[]): Record<'expired'|'cookies', Cookie[]> {
+function extract(response: IResponse, url: string, redirects?: IResponseRedirect[]): Record<'expired'|'cookies', Cookie[]> {
   let expired: Cookie[] = [];
   let parser;
   let exp;
@@ -100,7 +101,7 @@ function extract(response: IArcResponse, url: string, redirects?: IResponseRedir
  * 
  * Unregister this module when the application settings change to not to use session storage.
  * 
- * In ARC electron the session storage is a chrome persistent partition with a session shared with the "log in to a web service".
+ * In electron the session storage is a chrome persistent partition with a session shared with the "log in to a web service".
  * This way cookies can be acquired in through the browser login and store in the application to use them with the request.
  */
 export async function processRequestCookies(request: IHttpRequest, context: ExecutionContext): Promise<void> {
@@ -126,7 +127,7 @@ export async function processResponseCookies(log: IRequestLog, context: Executio
     return;
   }
   const config = context.config || {
-    kind: 'ARC#RequestConfig',
+    kind: RequestConfigKind,
     enabled: false,
   };
   let ignore = false; 
@@ -137,7 +138,7 @@ export async function processResponseCookies(log: IRequestLog, context: Executio
   if (ignore) {
     return;
   }
-  const typedResponse = log.response as IArcResponse;
+  const typedResponse = log.response as IResponse;
   const result = extract(typedResponse, log.request.url, log.redirects);
   if (result.cookies.length) {
     await CookieEvents.updateBulk(context.eventsTarget, result.cookies.map(c => HttpCookie.fromCookieParser(c).toJSON()));

package/src/runtime/node/InteropInterfaces.ts

@@ -0,0 +1,121 @@
+import { IProjectRequestIterator, IHttpProject } from '../../models/HttpProject.js';
+import { Environment } from '../../models/Environment.js';
+import { Logger } from '../../lib/logging/Logger.js';
+import { IRequestLog } from '../../models/RequestLog.js';
+
+export interface ProjectRunnerOptions {
+  /**
+   * When provided it overrides any project / folder defined environment.
+   */
+  environment?: Environment;
+  /**
+   * Additional variables to pass to the selected environment.
+   * This can be use to pass system variables, when needed.
+   * 
+   * To use system variables tou can use `init.variables = process.env`;
+   */
+  variables?: Record<string, string>;
+  /**
+   * Overrides the default logger (console).
+   */
+  logger?: Logger;
+  /**
+   * The event target to use.
+   * By default it creates its own target.
+   */
+  eventTarget?: EventTarget;
+}
+
+export interface ProjectRunnerRunOptions extends IProjectRequestIterator {
+}
+
+export interface RunResult {
+  /**
+   * The key of the request from the HttpProject that was executed.
+   */
+  key: string;
+  /**
+   * The key of parent folder of the executed request.
+   */
+  parent?: string;
+  /**
+   * Set when a fatal error occurred so the request couldn't be executed.
+   * This is not the same as error reported during a request. The log's response can still be IResponseError.
+   */
+  error?: boolean;
+  /**
+   * The error message. Always set when the `error` is `true`.
+   */
+  errorMessage?: string;
+  /**
+   * The request log.
+   * Always set when the `error` is `false`.
+   */
+  log?: IRequestLog;
+}
+
+export interface IProjectParallelRunnerOptions extends IProjectRunnerOptions {
+}
+
+export interface IProjectParallelWorkerOptions extends IProjectRunnerOptions {
+  project: IHttpProject;
+}
+
+export interface IProjectRunnerOptions {
+  /**
+   * The environment to use.
+   * This can be a name or the key of the environment located under the parent or root.
+   * It can also be a path to the environment definition. If the file exists it is used. Otherwise it tried to 
+   * find the environment in the project.
+   */
+  environment?: string;
+  /**
+   * The parent folder to execute.
+   */
+  parent?: string;
+  /**
+   * The names or the keys of requests to execute.
+   * This can be used to limit the number of requests.
+   */
+  request?: string[];
+  /**
+   * The number of times the execution should be repeated.
+   * Default to 1.
+   */
+  iterations?: number;
+  /**
+   * The number of milliseconds to wait between each iteration.
+   * Default to the next frame (vary from 1 to tens of milliseconds).
+   */
+  iterationDelay?: number;
+  /**
+   * When set it performs parallel execution for each iteration.
+   * The number of executions at the same time depends on the number of processor cores
+   * available on the current machine. The maximum of the parallel execution
+   * is the number of available cores. When the `iterations` number is higher
+   * then the "rest" is added to the iterations per each core.
+   */
+  parallel?: boolean;
+  /**
+   * When set it includes requests in the current folder and sub-folder according to the order
+   * defined in the folder.
+   */
+  recursive?: boolean;
+  /**
+   * The opposite of the `requests`. The list of names or keys of requests or folders to ignore.
+   * Note, ignore is tested before the `requests`.
+   */
+  ignore?: string[];
+  /**
+   * The logger to use with the request factory.
+   * When not set it uses the dummy logger (no output).
+   */
+  logger?: Logger;
+  /**
+   * When true it copies all system variables to the execution environment.
+   * When an array of strings, only takes system variables that are listed in the array.
+   * When a map, it uses this map as a list of variables.
+   * When not set it does not read system variables.
+   */
+  variables?: boolean | string[] | Record<string, string>;
+}

package/src/runtime/node/ProjectParallelRunner.ts

@@ -2,10 +2,10 @@ import cluster, { Worker } from 'cluster';
 import { cpus } from 'os';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { HttpProject, IHttpProject } from '../../models/HttpProject.js';
-import { IProjectRunnerOptions } from './ProjectRunner.js';
+import { HttpProject } from '../../models/HttpProject.js';
 import { IProjectExecutionLog, IProjectExecutionIteration } from '../reporters/Reporter.js';
 import { BaseRunner } from './BaseRunner.js';
+import { IProjectParallelRunnerOptions, IProjectParallelWorkerOptions } from './InteropInterfaces.js'
 
 const numCPUs = cpus().length;
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -40,13 +40,6 @@ export interface IWorkerMessage {
   data?: unknown;
 }
 
-export interface IProjectParallelRunnerOptions extends IProjectRunnerOptions {
-}
-
-export interface IProjectParallelWorkerOptions extends IProjectRunnerOptions {
-  project: IHttpProject;
-}
-
 export interface ProjectParallelRunner {
   /**
    * Dispatched when a status of a worker change.

package/src/runtime/node/ProjectRequestRunner.ts

@@ -6,64 +6,14 @@ import { Property } from '../../models/Property.js';
 import { ProjectFolder, Kind as ProjectFolderKind } from '../../models/ProjectFolder.js';
 import { ProjectRequest } from '../../models/ProjectRequest.js';
 import { IHttpRequest } from '../../models/HttpRequest.js';
-import { HttpProject, IProjectRequestIterator } from '../../models/HttpProject.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';
-
-export interface ProjectRunnerOptions {
-  /**
-   * When provided it overrides any project / folder defined environment.
-   */
-  environment?: Environment;
-  /**
-   * Additional variables to pass to the selected environment.
-   * This can be use to pass system variables, when needed.
-   * 
-   * To use system variables tou can use `init.variables = process.env`;
-   */
-  variables?: Record<string, string>;
-  /**
-   * Overrides the default logger (console).
-   */
-  logger?: Logger;
-  /**
-   * The event target to use.
-   * By default it creates its own target.
-   */
-  eventTarget?: EventTarget;
-}
-
-export interface ProjectRunnerRunOptions extends IProjectRequestIterator {
-}
-
-export interface RunResult {
-  /**
-   * The key of the request from the HttpProject that was executed.
-   */
-  key: string;
-  /**
-   * The key of parent folder of the executed request.
-   */
-  parent?: string;
-  /**
-   * Set when a fatal error occurred so the request couldn't be executed.
-   * This is not the same as error reported during a request. The log's response can still be IResponseError.
-   */
-  error?: boolean;
-  /**
-   * The error message. Always set when the `error` is `true`.
-   */
-  errorMessage?: string;
-  /**
-   * The request log.
-   * Always set when the `error` is `false`.
-   */
-  log?: IRequestLog;
-}
+import { ProjectRunnerOptions, ProjectRunnerRunOptions, RunResult } from './InteropInterfaces.js';
 
 export interface ProjectRequestRunner {
   /**
@@ -130,20 +80,50 @@ export class ProjectRequestRunner extends EventEmitter {
     const { project } = this;
     const executed: RunResult[] = [];
     for (const request of project.requestIterator(options)) {
-      const parent = request.getParent() || 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 info = await this._runItem(request);
       executed.push(info);
     }
     return executed;
   }
 
+  /**
+   * Allows to iterate over project requests recursively and execute each request
+   * in order. The generator yields the `RunResult` for the request.
+   * 
+   * Example:
+   * 
+   * ```javascript
+   * const runner = new ProjectRequestRunner(...);
+   * for await (let runResult of runner) {
+   *  console.log(runResult);
+   * }
+   * ```
+   */
+  async* [Symbol.asyncIterator](): AsyncGenerator<RunResult> {
+    const { project } = this;
+    for (const request of project.requestIterator({ recursive: true })) {
+      const info = await this._runItem(request);
+      yield info;
+    }
+  }
+
+  private async _runItem(request: ProjectRequest): Promise<RunResult> {
+    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);
+    if (folder && folder !== this.project) {
+      info.parent = folder.key;
+    }
+    return info;
+  } 
+
   protected async execute(request: ProjectRequest, variables: Record<string, string>): Promise<RunResult> {
     const config = request.getConfig();
     const factory = new RequestFactory(this.eventTarget);
@@ -189,6 +169,7 @@ export class ProjectRequestRunner extends EventEmitter {
       this.emit('request', request.key, { ...requestCopy });
       await factory.processRequestLogic(requestCopy);
       const result = await factory.executeRequest(requestCopy);
+      result.requestId = request.key;
       await factory.processResponse(result);
       request.setLog(result);
       info.log = result;

package/src/runtime/node/ProjectRunner.ts

@@ -3,75 +3,16 @@ import { HttpProject } from '../../models/HttpProject.js';
 import { ProjectFolder } from '../../models/ProjectFolder.js';
 import { Environment, IEnvironment } from '../../models/Environment.js';
 import { DummyLogger } from '../../lib/logging/DummyLogger.js';
-import { Logger } from '../../lib/logging/Logger.js';
 import { IRequestLog } from '../../models/RequestLog.js';
 import { IHttpRequest } from '../../models/HttpRequest.js';
 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';
 
 type ProjectParent = HttpProject | ProjectFolder;
 
-export interface IProjectRunnerOptions {
-  /**
-   * The environment to use.
-   * This can be a name or the key of the environment located under the parent or root.
-   * It can also be a path to the environment definition. If the file exists it is used. Otherwise it tried to 
-   * find the environment in the project.
-   */
-  environment?: string;
-  /**
-   * The parent folder to execute.
-   */
-  parent?: string;
-  /**
-   * The names or the keys of requests to execute.
-   * This can be used to limit the number of requests.
-   */
-  request?: string[];
-  /**
-   * The number of times the execution should be repeated.
-   * Default to 1.
-   */
-  iterations?: number;
-  /**
-   * The number of milliseconds to wait between each iteration.
-   * Default to the next frame (vary from 1 to tens of milliseconds).
-   */
-  iterationDelay?: number;
-  /**
-   * When set it performs parallel execution for each iteration.
-   * The number of executions at the same time depends on the number of processor cores
-   * available on the current machine. The maximum of the parallel execution
-   * is the number of available cores. When the `iterations` number is higher
-   * then the "rest" is added to the iterations per each core.
-   */
-  parallel?: boolean;
-  /**
-   * When set it includes requests in the current folder and sub-folder according to the order
-   * defined in the folder.
-   */
-  recursive?: boolean;
-  /**
-   * The opposite of the `requests`. The list of names or keys of requests or folders to ignore.
-   * Note, ignore is tested before the `requests`.
-   */
-  ignore?: string[];
-  /**
-   * The logger to use with the request factory.
-   * When not set it uses the dummy logger (no output).
-   */
-  logger?: Logger;
-  /**
-   * When true it copies all system variables to the execution environment.
-   * When an array of strings, only takes system variables that are listed in the array.
-   * When a map, it uses this map as a list of variables.
-   * When not set it does not read system variables.
-   */
-  variables?: boolean | string[] | Record<string, string>;
-}
-
 export interface ProjectRunner {
   /**
    * Event dispatched when an iteration is about to start.

package/src/runtime/node/ProjectRunnerWorker.ts

@@ -3,7 +3,8 @@ import process from 'process';
 import cluster from 'cluster';
 import { HttpProject } from '../../models/HttpProject.js';
 import { IProjectExecutionLog } from '../reporters/Reporter.js';
-import { IWorkerMessage, IProjectParallelWorkerOptions } from './ProjectParallelRunner.js';
+import { IWorkerMessage } from './ProjectParallelRunner.js';
+import { IProjectParallelWorkerOptions } from './InteropInterfaces.js';
 import { sleep } from '../../lib/timers/Timers.js';
 import { ProjectRunner } from './ProjectRunner.js';
 

package/src/runtime/node/RequestFactory.ts

@@ -11,14 +11,14 @@ import { Action } from '../../models/actions/Action.js';
 import { RunnableCondition } from '../actions/RunnableCondition.js';
 import { ActionRunner } from '../actions/ActionRunner.js';
 import { HttpEngineOptions } from '../http-engine/HttpEngine.js';
-import { ArcEngine } from '../http-engine/ArcEngine.js';
+import { CoreEngine } from '../http-engine/CoreEngine.js';
 import { ModulesRegistry, RegisteredRequestModule, RegisteredResponseModule, ExecutionContext, RegistryPermission } from '../modules/ModulesRegistry.js';
 import { ExecutionResponse } from '../modules/ExecutionResponse.js';
 import { Events } from '../../events/Events.js';
 import { Logger } from '../../lib/logging/Logger.js';
 
 /**
- * The main class to make HTTP requests in the API Client / ARC.
+ * The main class to make HTTP requests in the API Client.
  * This factory includes all logic components to perform the entire HTTP request lifecycle. This includes:
  * 
  * - variables evaluation on the request object
@@ -294,7 +294,7 @@ export class RequestFactory {
    */
   async executeRequest(request: IHttpRequest): Promise<IRequestLog> {
     const opts = await this.prepareEngineConfig();
-    const engine = new ArcEngine(request, opts);
+    const engine = new CoreEngine(request, opts);
     return engine.send();
   }
 

package/src/runtime/reporters/ProjectRunCliReporter.ts

@@ -1,7 +1,7 @@
 import { Table } from 'console-table-printer';
 import chalk from 'chalk';
 import { ErrorResponse, IErrorResponse } from '../../models/ErrorResponse.js';
-import { IArcResponse } from '../../models/ArcResponse.js';
+import { IResponse } from '../../models/Response.js';
 import { ISerializedError } from '../../models/SerializableError.js';
 import { Reporter } from './Reporter.js';
 
@@ -70,7 +70,7 @@ export class ProjectRunCliReporter extends Reporter {
           process.stdout.write('Request not executed.\n');
           return;
         }
-        const response = log.response as IArcResponse;
+        const response = log.response as IResponse;
         process.stdout.write(`${prefix} Status code is: ${response.status}\n`);
       });
       process.stdout.write('\n\n');

package/src/runtime/reporters/Reporter.ts

@@ -1,5 +1,5 @@
 import { IRequestLog } from '../../models/RequestLog.js';
-import { IArcResponse } from '../../models/ArcResponse.js';
+import { IResponse } from '../../models/Response.js';
 import { ErrorResponse } from '../../models/ErrorResponse.js';
 
 export interface IProjectExecutionIteration {
@@ -56,7 +56,7 @@ export abstract class Reporter {
     if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
       return true;
     }
-    const response = log.response as IArcResponse;
+    const response = log.response as IResponse;
     if (response.status >= 400) {
       return true;
     }
@@ -93,7 +93,7 @@ export abstract class Reporter {
         if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
           return;
         }
-        const response = log.response as IArcResponse;
+        const response = log.response as IResponse;
         if (response.status < 400) {
           result++;
         }
@@ -114,7 +114,7 @@ export abstract class Reporter {
         if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
           return;
         }
-        const response = log.response as IArcResponse;
+        const response = log.response as IResponse;
         if (response.loadingTime && response.loadingTime > 0) {
           result += response.loadingTime;
         }

package/src/runtime/store/AuthSdk.ts

@@ -0,0 +1,126 @@
+import { SdkBase, IStoreTokenInfo } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { Headers } from '../../lib/headers/Headers.js';
+import WebSocketNode from 'ws';
+
+export class AuthSdk extends SdkBase {
+  protected getExpires(headers: Headers): number | undefined {
+    const expires = headers.get('expires');
+    if (!expires) {
+      return undefined;
+    }
+    const d = new Date(expires);
+    const time = d.getTime();
+    if (Number.isNaN(time)) {
+      console.warn(`Invalid session response: the expires header cannot be parsed.`);
+      return undefined;
+    }
+    return time;
+  }
+
+  /**
+   * Creates unauthenticated session in the backend.
+   * @returns The JWT for unauthenticated user.
+   */
+  async createSession(): Promise<IStoreTokenInfo> {
+    const url = this.sdk.getUrl(RouteBuilder.sessions());
+    // console.log('Create session: ', url);
+    const result = await this.sdk.http.post(url.toString());
+    this.inspectCommonStatusCodes(result.status);
+    if (result.status !== 200) {
+      throw new Error(`Unable to create the session. Invalid response status: ${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`Unable to create the session. Response has no token.`);
+    }
+    const info: IStoreTokenInfo = {
+      token: result.body,
+    };
+    const expires = this.getExpires(result.headers);
+    if (expires) {
+      info.expires = expires;
+    }
+    return info;
+  }
+
+  /**
+   * Initializes the authentication session.
+   * @param token The unauthenticated session JWT. Required when not set on the class.
+   * @returns The location of the authorization endpoint.
+   */
+  async createAuthSession(token?: string, loginPath = '/auth/login'): Promise<string> {
+    const url = this.sdk.getUrl(loginPath);
+    const result = await this.sdk.http.post(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const loc = result.headers.get('location');
+    if (!loc) {
+      throw new Error(`The location header not returned by the server.`);
+    }
+    return loc;
+  }
+
+  /**
+   * Listens to the first message coming to the client from the auth endpoint.
+   * @param authPath The authorization path returned by the server info or 401 response.
+   * @param token Optional token to use.
+   */
+  async listenAuth(authPath: string, token?: string): Promise<void> {
+    const url = this.sdk.getUrl(authPath);
+    const client = await this.sdk.ws.createAndConnect(url.toString(), token);
+    return new Promise((resolve, reject) => {
+      const { sdk } = this;
+      async function finishData(data: any): Promise<void> {
+        let message: any;
+        try {
+          message = JSON.parse(data.toString());
+          await sdk.ws.disconnect(client);
+        } catch (cause) {
+          reject(cause);
+          return;
+        }
+        if (message.status === 'OK') {
+          resolve();
+        } else {
+          reject(new Error(message.message || 'Unknown error'));
+        }
+      }
+      const typedNode = client as WebSocketNode;
+      if (typeof typedNode.on === 'function') {
+        typedNode.on('message', (data: Buffer) => {
+          finishData(data);
+        });
+      } else {
+        const typedWeb = client as WebSocket;
+        typedWeb.addEventListener('message', (event) => {
+          finishData(event.data);
+        });
+      }
+    });
+  }
+
+  /**
+   * Renews authenticated token to a new one when the token expires.
+   * @param token Optional token to use.
+   * @returns 
+   */
+  async renewToken(token = this.sdk.token): Promise<IStoreTokenInfo> {
+    const authPath = RouteBuilder.sessionRenew();
+    const url = this.sdk.getUrl(authPath);
+    const result = await this.sdk.http.post(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    if (result.status !== 200) {
+      throw new Error(`Unable to renew the token. Invalid response status: ${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`Unable to create the session. Response has no token.`);
+    }
+    const info: IStoreTokenInfo = {
+      token: result.body,
+    };
+    const expires = this.getExpires(result.headers);
+    if (expires) {
+      info.expires = expires;
+    }
+    return info;
+  }
+}

package/src/runtime/store/BackendSdk.ts

@@ -0,0 +1,25 @@
+import { SdkBase } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { IBackendInfo } from '../../models/Backend.js';
+
+export class BackendSdk extends SdkBase {
+  /**
+   * @returns Client information about the store configuration.
+   */
+  async getInfo(): Promise<IBackendInfo> {
+    const url = this.sdk.getUrl(RouteBuilder.backend());
+    const result = await this.sdk.http.get(url.toString());
+    this.inspectCommonStatusCodes(result.status);
+    if (result.status !== 200) {
+      throw new Error(`Invalid store response. Expected 200 status and ${result.status} received.`);
+    }
+    const body = result.body as string;
+    let data;
+    try {
+      data = JSON.parse(body);
+    } catch (e) {
+      throw new Error(`The server returned invalid response. Unable to read store status.`);
+    }
+    return data as IBackendInfo;
+  }
+}