@api-client/core 0.3.4 → 0.3.7

package/src/lib/parsers/UrlParser.ts

@@ -0,0 +1,201 @@
+import { UrlValueParser, IUrlValueParserOptions } from './UrlValueParser.js';
+
+/**
+ * A class to parse URL string.
+ */
+export class UrlParser extends UrlValueParser {
+  /**
+   * @param value The URL value
+   */
+  constructor(value: string, opts?: IUrlValueParserOptions) {
+    super(opts);
+    this.value = value;
+  }
+
+  /**
+   * Returns protocol value in format `protocol` + ':'
+   *
+   * @return The value of the protocol or `undefined` if the value is not set
+   */
+  get protocol(): string | undefined {
+    return this.__data.protocol;
+  }
+
+  /**
+   * Sets value of the `protocol`
+   *
+   * @param value Protocol value.
+   */
+  set protocol(value: string | undefined) {
+    this.__data.protocol = value;
+  }
+
+  /**
+   * It reads the authority part of the URL value. It doesn't parses it
+   * to host, port and credentials parts.
+   *
+   * @return The value of the host or `undefined` if the value is not set
+   */
+  get host(): string | undefined {
+    return this.__data.host;
+  }
+
+  /**
+   * Sets value of the `host`
+   *
+   * @param value Host value.
+   */
+  set host(value: string | undefined) {
+    this.__data.host = value;
+  }
+
+  /**
+   * Returns path part of the URL.
+   *
+   * @returns The value of the path or `undefined` if the value not set
+   */
+  get path(): string | undefined {
+    return this.__data.path || '/';
+  }
+
+  /**
+   * Sets value of the `path`
+   *
+   * @param value Path value.
+   */
+  set path(value: string | undefined) {
+    this.__data.path = value;
+  }
+
+  /**
+   * Returns anchor part of the URL.
+   *
+   * @returns The value of the anchor or `undefined` if the value not set
+   */
+  get anchor(): string | undefined {
+    return this.__data.anchor;
+  }
+
+  /**
+   * Sets value of the `anchor`
+   *
+   * @param value The anchor value.
+   */
+  set anchor(value: string | undefined) {
+    this.__data.anchor = value;
+  }
+
+  /**
+   * Returns search part of the URL.
+   *
+   * @returns the value of the search or `undefined` if the value not set
+   */
+  get search(): string | undefined {
+    return this.__data.search;
+  }
+
+  /**
+   * Sets value of the `search`
+   *
+   * @param value Search value.
+   */
+  set search(value: string | undefined) {
+    this.__data.search = value;
+  }
+
+  /**
+   * The URL value. It is the same as calling `toString()`.
+   *
+   * @return The URL value for current configuration.
+   */
+  get value(): string {
+    return this.toString();
+  }
+
+  /**
+   * Sets value of the URL.
+   * It parses the url and sets properties.
+   *
+   * @param value The URL value.
+   */
+  set value(value: string) {
+    this.protocol = this._parseProtocol(value);
+    this.host = this._parseHost(value);
+    this.path = this._parsePath(value);
+    this.anchor = this._parseAnchor(value);
+    this.search = this._parseSearch(value);
+  }
+
+  /**
+   * Returns an array of search params.
+   *
+   * @returns The list of search params. Each item contains an
+   * array where the first item is the name of the parameter and the second item is the
+   * value.
+   */
+  get searchParams(): string[][] {
+    return this._parseSearchParams(this.search);
+  }
+
+  /**
+   * Sets the value of `search` and `searchParams`.
+   *
+   * @param value Search params list.
+   */
+  set searchParams(value: string[][]) {
+    if (!value || !value.length) {
+      this.search = undefined;
+      return;
+    }
+    this.search = value.map((item) => {
+      let itemValue = item[1];
+      if (!item[0] && !itemValue) {
+        return '';
+      }
+      if (itemValue === undefined) {
+        itemValue = '';
+      } else if (typeof itemValue !== 'string') {
+        itemValue = String(itemValue);
+      }
+      return `${item[0]}=${itemValue}`;
+    })
+    .join(this.opts.queryDelimiter);
+  }
+
+  /**
+   * Returns the URL for current settings.
+   *
+   * @return The URL value.
+   */
+  toString(): string {
+    let result = '';
+    if (this.protocol) {
+      result += this.protocol;
+      result += '//';
+    }
+    if (this.host) {
+      result += this.host;
+    }
+    if (this.path) {
+      if (this.path === '/' && !this.host && !this.search && !this.anchor) {
+        // ???
+      } else {
+        if (this.path[0] !== '/') {
+          result += '/';
+        }
+        result += this.path;
+      }
+    } else if (this.search || this.anchor) {
+        result += '/';
+      }
+    if (this.search) {
+      const p = this.searchParams;
+      this.searchParams = p;
+      result += `?${this.search}`;
+    }
+    if (this.anchor) {
+      result += `#${this.anchor}`;
+    }
+    return result;
+  }
+}

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/models/ErrorResponse.ts

@@ -2,31 +2,38 @@ import { IHttpResponse, HttpResponse, Kind } from './HttpResponse.js';
 import { ErrorResponse as LegacyErrorResponse } from './legacy/request/ArcResponse.js';
 import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
 import { Normalizer } from './legacy/Normalizer.js';
+import { SerializableError, ISerializedError } from './SerializableError.js';
 
 export interface IErrorResponse extends IHttpResponse {
   /**
    * An error associated with the response
    */
-  error: string | Error;
+  error: string | ISerializedError;
 }
 
 export class ErrorResponse extends HttpResponse {
   /**
    * An error associated with the response
    */
-  error = new Error('Unknown error');
+  error = new SerializableError('Unknown error');
 
   /**
    * @returns The same Error or new Error instance when passed string.
    */
-  static ensureError(error: string | Error): Error {
-    return typeof error === 'string' ? new Error(error) : error;
+  static ensureError(error: string | Error | SerializableError): SerializableError {
+    if (typeof error === 'string') {
+      return new SerializableError(error);
+    }
+    if (error.name === 'SerializableError') {
+      return error as SerializableError;
+    }
+    return new SerializableError(error);
   }
 
   /**
    * @param error The error message or Error object to use.
    */
-  static fromError(error: Error | string): ErrorResponse {
+  static fromError(error: Error | SerializableError | string): ErrorResponse {
     const err = ErrorResponse.ensureError(error);
     return new ErrorResponse({
       kind: Kind,
@@ -39,7 +46,7 @@ export class ErrorResponse extends HttpResponse {
     const init: IErrorResponse = {
       kind: Kind,
       status: input.status || 0,
-      error: input.error ? ErrorResponse.ensureError(input.error) : new Error('Unknown error'),
+      error: input.error ? ErrorResponse.ensureError(input.error) : new SerializableError('Unknown error'),
     };
     if (input.headers) {
       init.headers = input.headers;
@@ -70,7 +77,7 @@ export class ErrorResponse extends HttpResponse {
       init = {
         kind: Kind,
         status: 0,
-        error: new Error('Unknown error'),
+        error: new SerializableError('Unknown error'),
       };
     }
     this.new(init);
@@ -84,7 +91,12 @@ export class ErrorResponse extends HttpResponse {
   new(init: IErrorResponse): void {
     super.new(init);
     if (init.error) {
-      this.error = ErrorResponse.ensureError(init.error);
+      if (typeof init.error === 'string') {
+        this.error = new SerializableError(init.error);
+      } else {
+        this.error = new SerializableError();
+        this.error.new(init.error);
+      }
     }
   }