@api-client/core 0.4.0 → 0.4.3

package/src/models/HttpHistory.ts

@@ -48,6 +48,36 @@ export interface IHttpHistory {
   midnight?: number;
 }
 
+/**
+ * An interface used when adding a history in bulk.
+ * The store creates a history object propagating meta values defined here
+ * onto the history objects.
+ * Because of that, bulk operation can only be performed when the requests are made in similar 
+ * context (app, space, project).
+ */
+export interface IHttpHistoryBulkAdd {
+  /**
+   * Optional user space id. Must be set when the originating request belongs to a user space.
+   */
+  space?: string;
+  /**
+   * Optional project id. Must be set when the originating request belongs to a user space.
+   */
+  project?: string;
+  /**
+   * Optional application id. Must be set when the application that created this record does not use the concept of a user space.
+   */
+  app?: string;
+  /**
+   * The optional request id in the project that generated this log.
+   */
+  request?: string;
+  /**
+   * The list of request logs.
+   */
+  log: IRequestLog[];
+}
+
 /**
  * An HTTP history is an object containing an information of a request and response
  * made with the application.

package/src/models/HttpProject.ts

@@ -165,6 +165,38 @@ export interface IProjectRequestIterator {
   ignore?: string[];
 }
 
+export interface IProjectFolderIterator {
+  /**
+   * The parent folder key or name. Sets the starting point to iterate over the folder.
+   */
+  parent?: string
+  /**
+   * When set it includes folders in the current folder and sub-folder according to the order
+   * defined in the folder.
+   */
+  recursive?: boolean;
+  /**
+   * The list of names or keys to ignore.
+   */
+  ignore?: string[];
+}
+
+export interface IProjectFolderIteratorResult {
+  /**
+   * The folder.
+   */
+  folder: ProjectFolder;
+  /**
+   * Optional parent key.
+   */
+  parent?: string;
+  /**
+   * How deep in the structure the folder is located.
+   * The indent is relative to the `parent`.
+   */
+  indent: number;
+}
+
 /**
  * The new definition of a project in API Client.
  * Note, this is not the same as future `ApiProject` which is reserved for building APIs
@@ -1233,7 +1265,7 @@ export class HttpProject extends ProjectParent {
   }
 
   /**
-   * Iterates over requests in the project,
+   * Iterates over requests in the project.
    */
   * requestIterator(opts: IProjectRequestIterator = {}): Generator<ProjectRequest> {
     const { definitions } = this;
@@ -1285,6 +1317,55 @@ export class HttpProject extends ProjectParent {
     }
   }
 
+  /**
+   * Iterates over requests in the project.
+   * @param opts Iterator configuration options
+   * @param indent Used internally to add `indent` to the result
+   */
+  * folderIterator(opts: IProjectFolderIterator={}, indent=0): Generator<IProjectFolderIteratorResult> {
+    const { definitions } = this;
+    const { ignore=[], parent, recursive } = opts;
+    const root = parent ? this.findFolder(parent) : this;
+    if (!root) {
+      throw new Error(`The parent folder not found: ${parent}.`);
+    }
+    const items = root.items;
+    if (!items || !items.length) {
+      return;
+    }
+    for (const item of items) {
+      if (item.kind !== ProjectFolderKind) {
+        continue;
+      }
+      const folder = definitions.folders.find(i => i.key === item.key);
+      if (!folder) {
+        // missing definition.
+        continue;
+      }
+      if (ignore.includes(folder.key) || (folder.info.name && ignore.includes(folder.info.name))) {
+        continue;
+      }
+      const result: IProjectFolderIteratorResult = {
+        folder,
+        indent,
+      }
+      if (parent) {
+        result.parent = parent;
+      }
+      yield result;
+      if (recursive) {
+        const it = this.folderIterator({
+          parent: folder.key,
+          recursive,
+          ignore,
+        }, indent + 1);
+        for (const f of it) {
+          yield f;
+        }
+      }
+    }
+  }
+
   [Symbol.iterator](): Generator<ProjectRequest> {
     return this.requestIterator({
       recursive: true,

package/src/models/RequestLog.ts

@@ -28,6 +28,10 @@ export interface IRequestLog {
    * Request and response size. Some HTTP clients may not give this information.
    */
   size?: IRequestsSize;
+  /**
+   * Optional request ID defined on an HTTP project that triggered this log.
+   */
+  requestId?: string;
 }
 
 /**
@@ -51,6 +55,10 @@ export class RequestLog {
    * Request and response size. Some HTTP clients may not give this information.
    */
   size?: RequestsSize;
+  /**
+   * Optional request ID defined on an HTTP project that triggered this log.
+   */
+  requestId?: string;
 
   static fromRequest(request: ISentRequest): RequestLog {
     return new RequestLog({
@@ -88,7 +96,7 @@ export class RequestLog {
    * Creates a new response clearing anything that is so far defined.
    */
   new(init: IRequestLog): void {
-    const { request, response, redirects, size } = init;
+    const { request, response, redirects, size, requestId } = init;
     this.kind = Kind;
     if (request) {
       this.request = new SentRequest(request);
@@ -112,6 +120,11 @@ export class RequestLog {
     } else {
       this.size = undefined;
     }
+    if (requestId) {
+      this.requestId = requestId;
+    } else {
+      this.requestId = undefined;
+    }
   }
 
   toJSON(): IRequestLog {
@@ -130,6 +143,9 @@ export class RequestLog {
     if (this.response) {
       result.response = this.response.toJSON();
     }
+    if (this.requestId) {
+      result.requestId = this.requestId;
+    }
     return result;
   }
 

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/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;
+  }
+}