@api-client/core 0.3.5 → 0.3.8

package/src/lib/parsers/UrlValueParser.ts

@@ -0,0 +1,211 @@
+export interface IUrlValueParserOptions {
+  /**
+   * A query string delimiter to use when processing query parameters.
+   */
+  queryDelimiter?: string;
+}
+
+interface DataValues {
+  /**
+   * A protocol value in format `protocol` + ':'
+   */
+  protocol?: string;
+  /**
+   * The authority part of the URL value
+   */
+  host?: string;
+  /**
+   * Path part of the URL.
+   */
+  path?: string;
+  /**
+   * Anchor part of the URL.
+   */
+  anchor?: string;
+  /**
+   * Search part of the URL.
+   */
+  search?: string;
+  opts?: IUrlValueParserOptions | undefined;
+}
+
+/**
+ * Implements logic for parsing URL string.
+ */
+export class UrlValueParser {
+  protected __data: DataValues;
+
+  constructor(opts?: IUrlValueParserOptions) {
+    this.__data = {};
+    this.opts = opts;
+  }
+
+  /**
+   * @returns Class options.
+   */
+  get opts(): IUrlValueParserOptions {
+    return this.__data.opts || {
+      queryDelimiter: '&',
+    };
+  }
+
+  /**
+   * Sets parser options.
+   * Unknown options are ignored.
+   */
+  set opts(opts: IUrlValueParserOptions | undefined) {
+    const options = (opts || {}) as IUrlValueParserOptions;
+    this.__data.opts = {
+      queryDelimiter: options.queryDelimiter || '&'
+    };
+  }
+
+  /**
+   * Returns protocol value in format `protocol` + ':'
+   *
+   * @param value URL to parse.
+   * @return Value of the protocol or undefined if value not set
+   */
+  protected _parseProtocol(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const delimiterIndex = value.indexOf('://');
+    if (delimiterIndex !== -1) {
+      return value.substring(0, delimiterIndex + 1);
+    }
+    return undefined;
+  }
+
+  /**
+   * Gets a host value from the url.
+   * It reads the whole authority value of given `value`. It doesn't parses it
+   * to host, port and
+   * credentials parts. For URL panel it's enough.
+   *
+   * @param value The URL to parse
+   * @return Value of the host or undefined.
+   */
+  protected _parseHost(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let result = value;
+    const delimiterIndex = result.indexOf('://');
+    if (delimiterIndex !== -1) {
+      result = result.substring(delimiterIndex + 3);
+    }
+    if (!result) {
+      return undefined;
+    }
+    // We don't need specifics here (username, password, port)
+    const host = result.split('/')[0];
+    return host;
+  }
+
+  /**
+   * Parses the path part of the URL.
+   *
+   * @param value URL value
+   * @returns Path part of the URL
+   */
+  protected _parsePath(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let result = value;
+    const isBasePath = result[0] === '/';
+    if (!isBasePath) {
+      const index = result.indexOf('://');
+      if (index !== -1) {
+        result = result.substring(index + 3);
+      }
+    }
+    let index = result.indexOf('?');
+    if (index !== -1) {
+      result = result.substring(0, index);
+    }
+    index = result.indexOf('#');
+    if (index !== -1) {
+      result = result.substring(0, index);
+    }
+    const lastIsSlash = result[result.length - 1] === '/';
+    const parts = result.split('/').filter((part) => !!part);
+    if (!isBasePath) {
+      parts.shift();
+    }
+    let path = `/${  parts.join('/')}`;
+    if (lastIsSlash && parts.length > 1) {
+      path += '/';
+    }
+    return path;
+  }
+
+  /**
+   * Returns query parameters string (without the '?' sign) as a whole.
+   *
+   * @param value The URL to parse
+   * @returns Value of the search string or undefined.
+   */
+  protected _parseSearch(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let index = value.indexOf('?');
+    if (index === -1) {
+      return undefined;
+    }
+    const result = value.substring(index + 1);
+    index = result.indexOf('#');
+    if (index === -1) {
+      return result;
+    }
+    return result.substring(0, index);
+  }
+
+  /**
+   * Reads a value of the anchor (or hash) parameter without the `#` sign.
+   *
+   * @param value The URL to parse
+   * @returns Value of the anchor (hash) or undefined.
+   */
+  protected _parseAnchor(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const index = value.indexOf('#');
+    if (index === -1) {
+      return undefined;
+    }
+    return value.substring(index + 1);
+  }
+
+  /**
+   * Returns an array of items where each item is an array where first
+   * item is param name and second is it's value. Both always strings.
+   *
+   * @param search Parsed search parameter
+   * @returns Always returns an array.
+   */
+  protected _parseSearchParams(search?: string): string[][] {
+    const result: string[][] = [];
+    if (!search) {
+      return result;
+    }
+    const parts = search.split(this.opts.queryDelimiter as string);
+    parts.forEach((item) => {
+      const _part = ['', ''];
+      const _params = item.split('=');
+      let _name = _params.shift();
+      if (!_name && _name !== '') {
+        return;
+      }
+      _name = _name.trim();
+      const _value = _params.join('=').trim();
+      _part[0] = _name;
+      _part[1] = _value;
+      result.push(_part);
+    });
+    return result;
+  }
+}

package/src/lib/timers/Timers.ts

@@ -0,0 +1,9 @@
+/**
+ * Awaits the set number of milliseconds before resolving the promise.
+ * @param timeout The number of milliseconds to wait.
+ */
+export function sleep(timeout = 0): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), timeout);
+  });
+}

package/src/mocking/LegacyInterfaces.ts

@@ -1,4 +1,4 @@
-import { DataMockInit, HarTimingInit, HttpRequestInit, HttpResponseRedirectStatusInit } from '@pawel-up/data-mock/types'
+import { DataMockInit, HarTimingInit, HttpResponseRedirectStatusInit } from '@pawel-up/data-mock/types'
 
 export interface ArcDataMockInit extends DataMockInit {
 }

package/src/mocking/ProjectMock.ts

@@ -0,0 +1,20 @@
+import { DataMock, DataMockInit } from '@pawel-up/data-mock';
+import { Request } from './lib/Request.js';
+import { Response } from './lib/Response.js';
+
+export { IRequestLogInit } from './lib/Request.js';
+export { IArcResponseInit } from './lib/Response.js';
+
+export class ProjectMock extends DataMock {
+  projectRequest: Request;
+  response: Response;
+  
+  /**
+   * @param init The library init options.
+   */
+  constructor(init?: DataMockInit) {
+    super(init);
+    this.projectRequest = new Request(init);
+    this.response = new Response(init);
+  }
+}

package/src/mocking/lib/Request.ts

@@ -0,0 +1,85 @@
+import { Http, Types, Lorem, Time, DataMockInit, HttpRequestInit } from '@pawel-up/data-mock';
+// import { randomValue } from '@pawel-up/data-mock/src/lib/Http.js';
+import { IHttpRequest, Kind as HttpRequestKind } from '../../models/HttpRequest.js';
+import { IRequest, Kind as RequestKind } from '../../models/Request.js';
+import { ISentRequest } from '../../models/SentRequest.js';
+import { IRequestLog } from '../../models/RequestLog.js';
+import { IArcResponseInit, Response } from './Response.js';
+
+export interface IRequestLogInit {
+  request?: HttpRequestInit;
+  response?: IArcResponseInit;
+  /**
+   * When set it ignores size information
+   */
+  noSize?: boolean;
+  /**
+   * Adds redirects to the request
+   */
+  redirects?: boolean;
+  noResponse?: boolean;
+  noRequest?: boolean;
+}
+
+export class Request {
+  types: Types;
+  lorem: Lorem;
+  time: Time;
+  http: Http;
+  response: Response;
+
+  constructor(init: DataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.time = new Time(init);
+    this.http = new Http(init);
+    this.response = new Response(init);
+  }
+
+  request(init?: HttpRequestInit): IRequest {
+    return {
+      kind: RequestKind,
+      expects: this.httpRequest(init),
+      info: {
+        name: this.lorem.words(2),
+        description: this.lorem.paragraph(),
+      },
+    }
+  }
+
+  httpRequest(init?: HttpRequestInit): IHttpRequest {
+    const request = this.http.request(init);
+    return {
+      kind: HttpRequestKind,
+      ...request,
+    }
+  }
+
+  sentRequest(init?: HttpRequestInit): ISentRequest {
+    const start = this.time.timestamp();
+    return {
+      startTime: start,
+      endTime: this.time.timestamp({ min: start + 1 }),
+      ...this.httpRequest(init),
+    };
+  }
+
+  log(init: IRequestLogInit = {}): IRequestLog {
+    const result: IRequestLog = {
+      kind: 'ARC#ResponseLog',
+    };
+    if (!init.noRequest) {
+      result.request = this.sentRequest(init.request);
+    }
+    if (!init.noResponse) {
+      result.response = this.response.arcResponse(init.response);
+    }
+    if (init.redirects) {
+      result.redirects = this.response.redirects();
+    }
+    if (!init.noSize) {
+      result.size = this.response.size();
+    }
+    return result;
+  }
+}

package/src/mocking/lib/Response.ts

@@ -0,0 +1,101 @@
+import { Http, Har, Types, Lorem, Time, DataMockInit, HttpResponseInit, HarTimingInit, Internet } from '@pawel-up/data-mock';
+import { IHttpResponse, Kind as HttpResponseKind } from '../../models/HttpResponse.js';
+import { IArcResponse, Kind as ArcResponseKind } from '../../models/ArcResponse.js';
+import { IRequestsSize } from '../../models/RequestsSize.js';
+import { IResponseRedirect, Kind as ResponseRedirectKind  } from '../../models/ResponseRedirect.js';
+
+export interface IArcResponseInit extends HttpResponseInit, HarTimingInit {
+  /**
+   * When set it does not generate a response payload.
+   */
+  noBody?: boolean;
+  /**
+   * The first number of the status group. Other 2 are auto generated
+   */
+  statusGroup?: number;
+  /**
+   * Whether to generate timings object
+   */
+  timings?: boolean;
+}
+
+export class Response {
+  types: Types;
+  lorem: Lorem;
+  time: Time;
+  http: Http;
+  har: Har;
+  internet: Internet;
+
+  constructor(init: DataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.time = new Time(init);
+    this.http = new Http(init);
+    this.har = new Har(init);
+    this.internet = new Internet(init);
+  }
+
+  response(init: IArcResponseInit = {}): IHttpResponse {
+    const ct = init.noBody ? undefined : this.http.headers.contentType();
+    const body = init.noBody ? undefined : this.http.payload.payload(ct);
+    const headers = this.http.headers.headers('response', { mime: ct });
+    const statusGroup = init.statusGroup ? init.statusGroup : this.types.number({ min: 2, max: 5 });
+    const sCode = this.types.number({ min: 0, max: 99 }).toString();
+    const code = Number(`${statusGroup}${sCode.padStart(2, '0')}`);
+    const status = this.lorem.word();
+    const result: IHttpResponse = {
+      kind: HttpResponseKind,
+      status: code,
+      statusText: status,
+      headers,
+    };
+    if (!init.noBody) {
+      result.payload = body;
+    }
+    return result;
+  }
+
+  arcResponse(init: IArcResponseInit={}): IArcResponse {
+    const base = this.response(init);
+    const length = this.types.number({ min: 10, max: 4000 });
+    const result: IArcResponse = {
+      ...base,
+      kind: ArcResponseKind,
+      loadingTime: length,
+    };
+    if (init.timings) {
+      result.timings = this.har.timing(init);
+    }
+    return result;
+  }
+
+  size(): IRequestsSize {
+    const result: IRequestsSize = {
+      request: this.types.number({ min: 10 }),
+      response: this.types.number({ min: 10 }),
+    };
+    return result;
+  }
+
+  redirect(init?: IArcResponseInit): IResponseRedirect {
+    const start = this.time.timestamp();
+    const end = this.time.timestamp({ min: start + 1 })
+    const info: IResponseRedirect = {
+      kind: ResponseRedirectKind,
+      startTime: start,
+      endTime: end,
+      url: this.internet.uri(),
+      response: this.response({ ...init, statusGroup: 3}),
+    };
+    return info;
+  }
+
+  redirects(size=1, init?: IArcResponseInit): IResponseRedirect[] {
+    const result: IResponseRedirect[] = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.redirect(init));
+    }
+    return result;
+  }
+}

package/src/runtime/node/BaseRunner.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'events';
+import { IProjectExecutionIteration, IProjectExecutionLog } from '../reporters/Reporter.js';
+
+export abstract class BaseRunner extends EventEmitter {
+  /**
+   * Iteration start time.
+   */
+  protected startTime?: number;
+  /**
+   * Iteration end time.
+   */
+  protected endTime?: number;
+  /**
+   * A list of already executed iterations.
+   */
+  protected executed: IProjectExecutionIteration[] = [];
+
+  /**
+   * Creates the report of the execution.
+   */
+  protected async createReport(): Promise<IProjectExecutionLog> {
+    const log: IProjectExecutionLog = {
+      started: this.startTime as number,
+      ended: this.endTime as number,
+      iterations: this.executed,
+    };
+    return log;
+  }
+}

package/src/runtime/node/ProjectParallelRunner.ts

@@ -0,0 +1,234 @@
+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 { IProjectExecutionLog, IProjectExecutionIteration } from '../reporters/Reporter.js';
+import { BaseRunner } from './BaseRunner.js';
+
+const numCPUs = cpus().length;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export type WorkerStatus = 'initializing' | 'ready' | 'running' | 'finished' | 'error';
+
+export interface IWorkerInfo {
+  /**
+   * Whether the worker is online.
+   */
+  online: boolean;
+  /**
+   * The number of iterations the worker is performing.
+   */
+  iterations: number;
+  /**
+   * The current status of the worker.
+   */
+  status: WorkerStatus;
+  /**
+   * Optional error message received from the worker.
+   */
+  message?: string;
+}
+
+interface WorkerInfoInternal extends IWorkerInfo {
+  worker: Worker;
+}
+
+export interface IWorkerMessage {
+  cmd: string;
+  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.
+   * This can be used to render the current status.
+   */
+  on(event: 'status', listener: (info: IWorkerInfo[]) => void): this;
+  /**
+   * Dispatched when a status of a worker change.
+   * This can be used to render the current status.
+   */
+  once(event: 'status', listener: (info: IWorkerInfo[]) => void): this;
+}
+
+/**
+ * Runs a project in parallel.
+ * It creates a number of workers determined by the number of CPUs available on the current machine
+ * and the number of iterations defined in the configuration options.
+ * 
+ * When the number of iterations is greater then the number of CPUs then 
+ * the program distributes the remaining iterations among created workers.
+ * 
+ * The program dispatched the `status` event. It is dispatched each time when the worker status
+ * change. This event can be user to refresh the UI to reflect the newest state.
+ */
+export class ProjectParallelRunner extends BaseRunner {
+  project: HttpProject;
+  options: IProjectParallelRunnerOptions;
+  workers: WorkerInfoInternal[] = [];
+  private mainResolver?: (report: IProjectExecutionLog) => void;
+  private mainRejecter?: (err: Error) => void;
+
+  constructor(project: HttpProject, opts: IProjectParallelRunnerOptions = {}) {
+    super();
+    this.project = project;
+    this.options = opts || {};
+
+    this._exitHandler = this._exitHandler.bind(this);
+  }
+
+  execute(): Promise<IProjectExecutionLog> {
+    return new Promise((resolve, reject) => {
+      this.mainResolver = resolve;
+      this.mainRejecter = reject;
+      this._execute();
+    });
+  }
+
+  private _execute(): void {
+    try {
+      cluster.setupPrimary({
+        exec: join(__dirname, 'ProjectRunnerWorker.js'),
+        silent: true,
+      });
+      const { iterations = 1 } = this.options;
+      const poolSize = Math.min(iterations, numCPUs);
+      for (let i = 0; i < poolSize; i++) {
+        const worker = cluster.fork();
+        this.setupWorker(worker);
+      }
+      this.distributeIterations();
+      this.emit('status', this.getStatusWorkers());
+      cluster.on('exit', this._exitHandler);
+    } catch (e) {
+      const cause = e as Error;
+      this.mainRejecter!(cause);
+    }
+  }
+
+  private getStatusWorkers(): IWorkerInfo[] {
+    const { workers } = this;
+    const result: IWorkerInfo[] = [];
+    workers.forEach((info) => {
+      const cp = { ...info } as any;
+      delete cp.worker;
+      result.push(cp);
+    });
+    return result;
+  }
+
+  private distributeIterations(): void {
+    const workers = this.workers.length;
+    const { iterations = 1 } = this.options;
+    let iterationsRemaining = iterations - workers;
+    let currentIndex = 0;
+    while (iterationsRemaining > 0) {
+      this.workers[currentIndex].iterations += 1;
+      iterationsRemaining--;
+      currentIndex++;
+      if (currentIndex + 1 === workers) {
+        currentIndex = 0;
+      }
+    }
+  }
+
+  private setupWorker(worker: Worker): void {
+    this.workers.push({
+      worker,
+      online: false,
+      iterations: 1,
+      status: 'initializing',
+    });
+    worker.on('message', this._messageHandler.bind(this, worker));
+  }
+
+  private _messageHandler(worker: Worker, message: IWorkerMessage): void {
+    switch (message.cmd) {
+      case 'online': this.setOnline(worker); break;
+      case 'result': this.setRunResult(worker, message); break;
+      case 'error': this.setRunError(worker, message); break;
+    }
+  }
+
+  private _exitHandler(worker: Worker): void {
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    this.finishWhenReady();
+  }
+
+  private setOnline(worker: Worker): void {
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    info.online = true;
+    info.status = 'ready';
+    this.runWhenReady();
+    this.emit('status', this.getStatusWorkers());
+  }
+
+  private setRunResult(worker: Worker, message: IWorkerMessage): void {
+    const reports = message.data as IProjectExecutionIteration[];
+    this.executed = this.executed.concat(reports);
+    worker.destroy();
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    info.status = 'finished';
+    this.emit('status', this.getStatusWorkers());
+  }
+
+  private runWhenReady(): void {
+    const waiting = this.workers.some(i => !i.online);
+    if (waiting) {
+      return;
+    }
+    this.startTime = Date.now();
+    this.workers.forEach((info) => {
+      const opts: IProjectParallelWorkerOptions = { ...this.options, project: this.project.toJSON() };
+      opts.iterations = info.iterations;
+      info.status = 'running';
+      info.worker.send({
+        cmd: 'run',
+        data: opts,
+      });
+    });
+  }
+
+  private async finishWhenReady(): Promise<void> {
+    if (this.endTime) {
+      return;
+    }
+    const working = this.workers.some(i => !['finished', 'error'].includes(i.status));
+    if (working || !this.mainResolver) {
+      return;
+    }
+    this.endTime = Date.now();
+    const report = await this.createReport();
+    this.mainResolver(report);
+    cluster.off('exit', this._exitHandler);
+  }
+
+  private setRunError(worker: Worker, message: IWorkerMessage): void {
+    worker.destroy();
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    info.status = 'error';
+    info.message = message.data as string;
+    this.emit('status', this.getStatusWorkers());
+  }
+}