@api-client/core 0.4.0 → 0.4.1

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

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

package/src/runtime/store/HistorySdk.ts

@@ -0,0 +1,157 @@
+import { SdkBase, E_RESPONSE_STATUS, E_RESPONSE_NO_VALUE, E_INVALID_JSON, E_RESPONSE_UNKNOWN, E_RESPONSE_LOCATION } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { IListResponse, HistoryListOptions } from '../../models/Backend.js';
+import { IHttpHistory, IHttpHistoryBulkAdd, Kind as HttpHistoryKind } from '../../models/HttpHistory.js';
+
+export class HistorySdk extends SdkBase {
+  /**
+   * Creates a history object.
+   * A history object can be created per app (type = app) or a store's space/[project/[request]].
+   * 
+   * The user can always read their own history. If the history is created for a space/project then 
+   * history records are shared as any other object in the space.
+   * 
+   * Note, history objects cannot be updated. They can only be created or deleted.
+   * 
+   * @param history The history to create
+   * @returns The key of the created history.
+   */
+  async create(history: IHttpHistory): Promise<string> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.history());
+    const body = JSON.stringify(history);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    const location = result.headers.get('location');
+    if (!location) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_LOCATION}`);
+    }
+    const id = location.split('/').pop();
+    return id as string;
+  }
+
+  /**
+   * Creates a multiple history objects in a batch operation.
+   * 
+   * @param info The bulk create info object.
+   */
+  async createBulk(info: IHttpHistoryBulkAdd): Promise<string[]> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.historyBatchCreate());
+    const body = JSON.stringify(info);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a bulk history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: string[];
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Lists the history.
+   * 
+   * @param options Optional query options.
+   */
+  async list(options: HistoryListOptions): Promise<IListResponse> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.history());
+    this.sdk.appendListOptions(url, options);
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to list history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IListResponse;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!Array.isArray(data.data)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Deletes a history object form the store.
+   * 
+   * @param key The key returned by the store when created the history. Also available via the `key` property on the history object.
+   */
+  delete(key: string): Promise<void>;
+  /**
+   * Deletes a list of history objects in a batch operation.
+   * 
+   * @param keys The keys returned by the store when created the history. Also available via the `key` property on the history object.
+   */
+  delete(keys: string[]): Promise<void>;
+  /**
+   * Deletes a history or a list of history objects from the store.
+   * @param key A key or a list of keys.
+   */
+  async delete(key: string | string[]): Promise<void> {
+    const { token } = this.sdk;
+    const isArray = Array.isArray(key);
+    const path = isArray ? RouteBuilder.historyBatchDelete() : RouteBuilder.historyItem(key);
+    const url = this.sdk.getUrl(path);
+
+    const result = isArray ? await this.sdk.http.post(url.toString(), { token, body: JSON.stringify(key) }) : await this.sdk.http.delete(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to delete history. ';
+    if (result.status !== 204) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+  }
+
+  /**
+   * Reads a history definition from the store.
+   * @param key The history key
+   * @returns The history object
+   */
+  async read(key: string): Promise<IHttpHistory> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.historyItem(key));
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to read a history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IHttpHistory;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (data.kind !== HttpHistoryKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+}

package/src/runtime/store/Http.ts

@@ -0,0 +1,18 @@
+import { SdkBase, IStoreRequestOptions, IStoreResponse } from './SdkBase.js';
+
+export abstract class Http extends SdkBase {
+  /**
+   * Performs the GET request.
+   * 
+   * @param url The request URL
+   * @param opts The request options
+   * @returns The response info.
+   */
+  abstract get(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+
+  abstract post(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+
+  abstract patch(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+
+  abstract delete(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+}

package/src/runtime/store/HttpNode.ts

@@ -0,0 +1,100 @@
+import http from 'http';
+import https from 'https';
+import { Headers } from '../../lib/headers/Headers.js';
+import { Http } from './Http.js';
+import { IStoreRequestOptions, IStoreResponse } from './SdkBase.js';
+
+export class HttpNode extends Http {
+  /**
+   * Performs the GET request.
+   * 
+   * @param url The request URL
+   * @param opts The request options
+   * @returns The response info.
+   */
+  async get(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const result = await this._get(url, opts);
+    if ([301, 302, 308, 307].includes(result.status)) {
+      const loc = result.headers.get('location');
+      if (!loc) {
+        throw new Error('Expected redirection but no "location" header.')
+      }
+      const newUrl = new URL(loc, url);
+      return this.get(newUrl.toString(), opts);
+    }
+    return result;
+  }
+
+  private _get(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    return new Promise((resolve, reject) => {
+      const { method='GET', headers={}, token = this.sdk.token } = opts;
+      if (token) {
+        headers.authorization = `Bearer ${token}`;
+      }
+      const isSsl = url.startsWith('https:');
+      const lib = isSsl ? https : http;
+      // console.log(`${method} ${url}`);
+      const request = lib.request(url, {
+        method,
+        headers,
+        rejectUnauthorized: false,
+      });
+      request.on('response', (response) => {
+        const ro: IStoreResponse = {
+          status: response.statusCode as number,
+          headers: new Headers(response.headers),
+          body: '',
+        };
+        response.on('data', (chunk) => {
+          ro.body += chunk;
+        });
+        response.on('end', () => resolve(ro));
+      });
+      request.on('error', (error) => reject(error));
+      request.end();
+    });
+  }
+
+  post(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    return new Promise((resolve, reject) => {
+      const { method='POST', headers={}, token = this.sdk.token } = opts;
+      if (token) {
+        headers.authorization = `Bearer ${token}`;
+      }
+      const isSsl = url.startsWith('https:');
+      const lib = isSsl ? https : http;
+      const request = lib.request(url, {
+        method,
+        headers,
+      });
+      request.on('response', (response) => {
+        const ro: IStoreResponse = {
+          status: response.statusCode as number,
+          headers: new Headers(response.headers),
+          body: '',
+        };
+        response.on('data', (chunk) => {
+          ro.body += chunk;
+        });
+        response.on('end', () => resolve(ro));
+      });
+      request.on('error', (error) => reject(error));
+      if (opts.body) {
+        request.write(opts.body);
+      }
+      request.end();
+    });
+  }
+
+  patch(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options = { ...opts };
+    options.method = 'PATCH';
+    return this.post(url, options);
+  }
+
+  delete(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options = { ...opts };
+    options.method = 'DELETE';
+    return this.post(url, options);
+  }
+}

package/src/runtime/store/HttpWeb.ts

@@ -0,0 +1,89 @@
+import { Http } from './Http.js';
+import { IStoreRequestOptions, IStoreResponse } from './SdkBase.js';
+import { Headers } from '../../lib/headers/Headers.js';
+
+export class HttpWeb extends Http {
+  /**
+   * Performs the GET request.
+   * 
+   * @param url The request URL
+   * @param opts The request options
+   * @returns The response info.
+   */
+  async get(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const { method='GET', headers={}, token = this.sdk.token } = opts;
+    if (token) {
+      headers.authorization = `Bearer ${token}`;
+    }
+    // eslint-disable-next-line no-undef
+    const init: RequestInit = {
+      method,
+      headers,
+      redirect: 'follow',
+    };
+    const response = await fetch(url, init);
+    let body: string | undefined;
+    try {
+      body = await response.text();
+    } catch (e) {
+      // ...
+    }
+
+    const responseHeaders = new Headers();
+    response.headers.forEach((value: string, key: string) => {
+      responseHeaders.append(key, value);
+    });
+
+    const result: IStoreResponse = {
+      status: response.status,
+      headers: responseHeaders,
+      body,
+    };
+    return result;
+  }
+
+  async post(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const { method='POST', headers={}, token = this.sdk.token } = opts;
+    if (token) {
+      headers.authorization = `Bearer ${token}`;
+    }
+    // eslint-disable-next-line no-undef
+    const init: RequestInit = {
+      method,
+      headers,
+      redirect: 'follow',
+    };
+    if (opts.body) {
+      init.body = opts.body.toString();
+    }
+    const response = await fetch(url, init);
+    let body: string | undefined;
+    try {
+      body = await response.text();
+    } catch (e) {
+      // ...
+    }
+
+    const responseHeaders = new Headers();
+    response.headers.forEach((value: string, key: string) => {
+      responseHeaders.append(key, value);
+    });
+
+    const result: IStoreResponse = {
+      status: response.status,
+      headers: responseHeaders,
+      body,
+    };
+    return result;
+  }
+
+  patch(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options: IStoreRequestOptions = { ...opts, method: 'PATCH' };
+    return this.post(url, options);
+  }
+
+  delete(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options: IStoreRequestOptions = { ...opts, method: 'DELETE' };
+    return this.post(url, options);
+  }
+}