@api-client/core 0.3.3 → 0.3.6

package/src/mocking/legacy/Cookies.ts

@@ -0,0 +1,51 @@
+import { Lorem, Types, Internet } from '@pawel-up/data-mock';
+import { ArcDataMockInit } from '../LegacyInterfaces.js';
+import { ARCCookie } from '../../models/legacy/models/Cookies.js';
+
+export class Cookies {
+  types: Types;
+  lorem: Lorem;
+  internet: Internet;
+
+  constructor(init: ArcDataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.internet = new Internet(init);
+  }
+
+  /**
+   * Generates random Cookie data
+   */
+  cookie(): ARCCookie {
+    const time = this.types.datetime().getTime();
+    const result = {
+      created: time,
+      updated: time,
+      expires: this.types.datetime().getTime(),
+      maxAge: this.types.number({ min: 100, max: 1000 }),
+      name: this.lorem.word(),
+      value: this.lorem.word(),
+      _id: this.types.uuid(),
+      domain: this.internet.domain(),
+      hostOnly: this.types.boolean(),
+      httpOnly: this.types.boolean(),
+      lastAccess: time,
+      path: this.types.boolean() ? '/' : `/${this.lorem.word()}`,
+      persistent: this.types.boolean(),
+    };
+    return result;
+  }
+
+  /**
+   * Generates a list of cookies
+   * 
+   * @return List of datastore entries.
+   */
+  cookies(size = 25): ARCCookie[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.cookie());
+    }
+    return result;
+  }
+}

package/src/mocking/legacy/HostRules.ts

@@ -0,0 +1,43 @@
+import { Lorem, Types, Internet } from '@pawel-up/data-mock';
+import { ArcDataMockInit } from '../LegacyInterfaces.js';
+import { ARCHostRule } from '../../models/legacy/models/HostRule.js';
+
+export class HostRules {
+  types: Types;
+  lorem: Lorem;
+  internet: Internet;
+
+  constructor(init: ArcDataMockInit = {}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.internet = new Internet(init);
+  }
+
+  /**
+   * Generates random host rule data object.
+   */
+  rule(): ARCHostRule {
+    const result: ARCHostRule = {
+      _id: this.types.uuid(),
+      from: this.internet.uri(),
+      to: this.internet.uri(),
+      enabled: this.types.boolean(),
+      comment: this.lorem.paragraph(),
+    };
+    return result;
+  }
+
+  /**
+   * Generates a list of host rules.
+   *
+   * @param size Number of items to generate. Default to 25.
+   * @return List of datastore entries.
+   */
+  rules(size = 25): ARCHostRule[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.rule());
+    }
+    return result;
+  }
+}

package/src/mocking/legacy/Http.ts

@@ -0,0 +1,236 @@
+import { Http as Base, Types, Lorem, Time, HttpRequestInit } from '@pawel-up/data-mock';
+import { randomValue } from '@pawel-up/data-mock/src/lib/Http.js';
+import { ArcDataMockInit } from '../LegacyInterfaces.js';
+import { HttpResponse } from './HttpResponse.js';
+import { ARCHistoryRequest, ARCSavedRequest, TransportRequest } from '../../models/legacy/request/ArcRequest.js';
+import { ARCProject } from '../../models/legacy/models/ArcLegacyProject.js';
+
+export interface RequestHistoryInit extends HttpRequestInit {
+  noId?: boolean;
+}
+
+export interface RequestSavedInit extends HttpRequestInit {
+  forceDescription?: boolean;
+  noDescription?: boolean;
+  project?: string;
+  projects?: ARCProject[];
+  forceProject?: boolean;
+}
+
+export interface ProjectCreateInit {
+  /**
+   * Request id to add to `requests` array
+   */
+  requestId?: string;
+  /**
+   * If set it generates request ID to add to `requests` array
+   */
+  autoRequestId?: boolean;
+}
+
+export declare interface GenerateSavedResult {
+  projects: ARCProject[];
+  requests: ARCSavedRequest[];
+}
+
+export interface TransportRequestInit extends HttpRequestInit {
+  noHttpMessage?: boolean;
+}
+
+export class Http extends Base {
+  LAST_TIME: number;
+  types: Types;
+  lorem: Lorem;
+  response: HttpResponse;
+  time: Time;
+
+  constructor(init: ArcDataMockInit={}) {
+    super(init);
+    this.LAST_TIME = Date.now();
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.response = new HttpResponse(init);
+    this.time = new Time(init);
+  }
+
+  history(opts: RequestHistoryInit={}): ARCHistoryRequest {
+    const base = this.request(opts);
+    this.LAST_TIME -= this.types.datetime().getTime();
+    const midnight = this.time.midnight(this.LAST_TIME);
+
+    const item: ARCHistoryRequest = {
+      ...base,
+      created: this.LAST_TIME,
+      updated: this.LAST_TIME,
+      type: 'history',
+      midnight,
+    };
+    if (!opts.noId) {
+      item._id = this.types.uuid();
+    }
+    return item;
+  }
+
+  saved(opts: RequestSavedInit={}): ARCSavedRequest {
+    const base = this.request(opts);
+    const time = this.types.datetime().getTime();
+    const requestName = this.lorem.words(2);
+    const description = this.description(opts);
+    const midnight = this.time.midnight(this.LAST_TIME);
+    const item: ARCSavedRequest = {
+      ...base,
+      created: time,
+      updated: time,
+      type: 'saved',
+      name: requestName,
+      midnight,
+    };
+    if (description) {
+      item.description = description;
+    }
+    item._id = this.types.uuid();
+    if (opts.project) {
+      item.projects = [opts.project];
+    }
+    return item;
+  }
+
+  /**
+   * Generates a description for a request.
+   *
+   * @param opts Configuration options
+   * @returns Items description.
+   */
+  description(opts: RequestSavedInit={}): string|undefined {
+    const { noDescription, forceDescription } = opts;
+    if (noDescription) {
+      return undefined;
+    }
+    if (forceDescription) {
+      return this.lorem.paragraph();
+    }
+    return this.types.boolean({ likelihood: 70 }) ? this.lorem.paragraph() : undefined;
+  }
+
+  /**
+   * @param size The number of requests to generate.
+   * @param init History init options.
+   */
+  listHistory(size = 25, init: RequestHistoryInit={}): ARCHistoryRequest[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.history(init));
+    }
+    return result;
+  }
+
+  /**
+   * @param size The number of requests to generate.
+   * @param init Saved init options
+   */
+  listSaved(size = 25, init: RequestSavedInit = {}): ARCSavedRequest[] {
+    const list = [];
+    for (let i = 0; i < size; i++) {
+      const project = this.pickProject(init);
+      const opts = { ...init };
+      if (project && project._id) {
+        opts.project = project._id;
+      }
+      const item = this.saved(opts);
+      if (project) {
+        if (!project.requests) {
+          project.requests = [];
+        }
+        project.requests.push(item._id as string);        
+      }
+      list.push(item);
+    }
+    return list;
+  }
+
+  /**
+   * Picks a random project from the list of passed in `opts` projects.
+   *
+   * @param opts
+   * @returns A project or undefined.
+   */
+  pickProject(opts: RequestSavedInit = {}): ARCProject|undefined {
+    if (!opts.projects || !opts.projects.length) {
+      return undefined;
+    }
+    let allow;
+    if (opts.forceProject) {
+      allow = true;
+    } else {
+      allow = this.types.boolean();
+    }
+    if (allow) {
+      return this[randomValue].pickOne(opts.projects);
+    }
+    return undefined;
+  }
+
+  project(init: ProjectCreateInit={}): ARCProject {
+    const project: ARCProject = {
+      _id: this.types.uuid(),
+      name: this.lorem.sentence({ words: 2 }),
+      order: 0,
+      description: this.lorem.paragraph(),
+      requests: [],
+    };
+    if (init.requestId) {
+      project.requests!.push(init.requestId);
+    } else if (init.autoRequestId) {
+      project.requests!.push(this.types.uuid());
+    }
+    return project;
+  }
+
+  listProjects(size = 5, init: ProjectCreateInit = {}): ARCProject[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.project(init));
+    }
+    return result;
+  }
+
+  /**
+   * @returns A map with `projects` and `requests` arrays.
+   */
+  savedData(requestsSize = 25, projectsSize = 5, requestsInit: RequestSavedInit = {}, projectInit: ProjectCreateInit = {}): GenerateSavedResult {
+    const projects = this.listProjects(projectsSize, projectInit);
+    const rCopy = { ...requestsInit };
+    rCopy.projects = projects;
+    const requests = this.listSaved(requestsSize, rCopy);
+    return {
+      requests,
+      projects,
+    };
+  }
+
+  /**
+   * Generates a transport request object.
+   * @param opts Generate options
+   * @returns The transport request object
+   */
+  transportRequest(opts: TransportRequestInit={}): TransportRequest {
+    const base = this.request(opts);
+    const request: TransportRequest = {
+      ...base,
+      startTime: Date.now() - 1000,
+      endTime: Date.now(),
+      httpMessage: '',
+    };
+    if (!opts.noHttpMessage) {
+      request.httpMessage = `GET / HTTP 1.1\n${request.headers}\n`;
+      if (request.payload) {
+        request.httpMessage += `\n${request.payload}\n`;
+      }
+      request.httpMessage += '\n';
+    } else {
+      // @ts-ignore
+      delete request.httpMessage;
+    }
+    return request;
+  }
+}

package/src/mocking/legacy/HttpResponse.ts

@@ -0,0 +1,106 @@
+import { HttpResponse as Base, headersValue, payloadValue, typesValue, loremValue } from '@pawel-up/data-mock/src/lib/http/HttpResponse.js';
+import { Har, DataMockLocale } from '@pawel-up/data-mock';
+import { ArcDataMockInit, HttpResponseArcInit, HttpResponseRedirectInit } from '../LegacyInterfaces.js';
+import { ResponseRedirect, Response, ErrorResponse } from '../../models/legacy/request/ArcResponse.js';
+
+export class HttpResponse extends Base {
+  har: Har;
+
+  /**
+   * @param init The library init options.
+   */
+  constructor(init: ArcDataMockInit={}) {
+    super(init);
+    this.har = new Har(init);
+  }
+
+  seed(value?: number): void {
+    super.seed(value);
+    this.har.seed(value);
+  }
+
+  /**
+   * @param locale The locale to set. When nothing is passed then it uses the default locale.
+   */
+  locale(locale?: DataMockLocale): void {
+    super.locale(locale);
+    this.har.locale(locale);
+  }
+
+  /**
+   * @returns Generated redirect response.
+   */
+  redirectResponse(init: HttpResponseRedirectInit={}): ResponseRedirect {
+    const ct = init.body ? this[headersValue].contentType() : undefined;
+    let headers = this[headersValue].headers('response', { mime: ct });
+    const url = this[headersValue].link();
+    headers += `\nlocation: ${url}`;
+    const { code, status } = this.redirectStatus(init);
+    const body = init.body ? this[payloadValue].payload(ct) : undefined;
+    const startTime = this[typesValue].datetime().getTime();
+    const duration = this[typesValue].number({ min: 10, max: 4000 });
+    const result: ResponseRedirect = {
+      url: '',
+      response: {
+        status: code,
+        statusText: status,
+        headers,
+      },
+      startTime,
+      endTime: startTime + duration,
+    };
+    if (body) {
+      result.response.payload = body;
+    }
+    if (init.timings) {
+      result.timings = this.har.timing(init);
+    }
+    return result;
+  }
+
+  arcResponse(init: HttpResponseArcInit = {}): Response {
+    const ct = init.noBody ? undefined : this[headersValue].contentType();
+    const body = init.noBody ? undefined : this[payloadValue].payload(ct);
+    const headers = this[headersValue].headers('response', { mime: ct });
+    const statusGroup = init.statusGroup ? init.statusGroup : this[typesValue].number({ min: 2, max: 5 });
+    const sCode = this[typesValue].number({ min: 0, max: 99 }).toString();
+    const code = Number(`${statusGroup}${sCode.padStart(2, '0')}`);
+    const status = this[loremValue].word();
+    const length = this[typesValue].number({ min: 10, max: 4000 });
+    const result: Response = {
+      status: code,
+      statusText: status,
+      headers,
+      loadingTime: length,
+    };
+    if (init.timings) {
+      result.timings = this.har.timing(init);
+    }
+    if (!init.noBody) {
+      result.payload = body;
+    }
+    if (!init.noSize) {
+      const hSize = headers.length;
+      const bSize = body ? body.length : 0;
+      result.size = {
+        request: this[typesValue].number({ min: 10 }),
+        response: hSize + bSize,
+      };
+    }
+    if (init.redirects) {
+      const size = this[typesValue].number({ min: 1, max: 4 });
+      const cnf = { timings: init.timings, body: true };
+      result.redirects = new Array(size).fill(0).map(() => this.redirectResponse(cnf));
+    }
+    return result;
+  }
+
+  arcErrorResponse(): ErrorResponse {
+    const error = new Error(this[loremValue].paragraph());
+    const result: ErrorResponse = {
+      status: 0,
+      error,
+    };
+    return result;
+  }
+}

package/src/mocking/legacy/RestApi.ts

@@ -0,0 +1,68 @@
+import { Lorem, Types, Internet } from '@pawel-up/data-mock';
+import { ArcDataMockInit, RestApiIndexInit } from '../LegacyInterfaces.js';
+import { ARCRestApi, ARCRestApiIndex } from '../../models/legacy/models/RestApi.js';
+
+export class RestApi {
+  types: Types;
+  lorem: Lorem;
+  internet: Internet;
+
+  constructor(init: ArcDataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.internet = new Internet(init);
+  }
+
+  apiIndex(opts: RestApiIndexInit = {}): ARCRestApiIndex {
+    const result: ARCRestApiIndex = {
+      order: opts.order || 0,
+      title: this.lorem.sentence({ words: 2 }),
+      type: 'RAML 1.0',
+      _id: this.internet.uri(),
+      versions: [],
+      latest: '',
+    };
+    const versionsSize = opts.versionSize ? opts.versionSize : this.types.number({ min: 1, max: 5 });
+    const versions = [];
+    let last = '';
+    for (let i = 0; i < versionsSize; i++) {
+      last = `v${i}`;
+      versions[versions.length] = last;
+    }
+    result.versions = versions;
+    result.latest = last;
+    return result;
+  }
+
+  apiIndexList(size=25, opts: RestApiIndexInit = {}): ARCRestApiIndex[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.apiIndex({ ...opts, order: i }));
+    }
+    return result;
+  }
+
+  apiData(index: ARCRestApiIndex): ARCRestApi[] {
+    const result: ARCRestApi[] = [];
+    index.versions.forEach((version) => {
+      const item: ARCRestApi = {
+        data: '[{}]',
+        indexId: index._id || '',
+        version,
+        _id: `${index._id}|${version}`,
+      };
+      result[result.length] = item;
+    });
+    return result;
+  }
+
+  apiDataList(indexes: ARCRestApiIndex[]): ARCRestApi[] {
+    const size = indexes.length;
+    let result: ARCRestApi[] = [];
+    for (let i = 0; i < size; i++) {
+      const data = this.apiData(indexes[i]);
+      result = result.concat(data);
+    }
+    return result;
+  }
+}

package/src/mocking/legacy/Urls.ts

@@ -0,0 +1,44 @@
+import { Internet, Types, Time } from '@pawel-up/data-mock';
+import { ArcDataMockInit } from '../LegacyInterfaces.js';
+import { ARCUrlHistory } from '../../models/legacy/models/UrlHistory.js';
+
+export class Urls {
+  types: Types;
+  internet: Internet;
+  time: Time;
+
+  constructor(init: ArcDataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.internet = new Internet(init);
+    this.time = new Time(init);
+  }
+
+  /**
+   * Generates a single ARC URL model item.
+   */
+  url(): ARCUrlHistory {
+    const url = this.internet.uri();
+    const time = this.types.datetime().getTime();
+    const result: ARCUrlHistory = {
+      time,
+      cnt: this.types.number({ min: 100, max: 1000 }),
+      _id: url,
+      url,
+      midnight: this.time.midnight(time),
+    };
+    return result;
+  }
+
+  /**
+   * Generates list of ARC URL models.
+   *
+   * @returns List of datastore entries.
+   */
+  urls(size = 25): ARCUrlHistory[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.url());
+    }
+    return result;
+  }
+}

package/src/mocking/legacy/Variables.ts

@@ -0,0 +1,53 @@
+import { Lorem, Types } from '@pawel-up/data-mock';
+import { ArcDataMockInit, VariableInit } from '../LegacyInterfaces.js';
+import { ARCVariable } from '../../models/legacy/models/Variable.js';
+
+export class Variables {
+  types: Types;
+  lorem: Lorem;
+
+  constructor(init: ArcDataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+  }
+
+  /**
+   * Generates a random variable
+   */
+  variable(init: VariableInit={}): ARCVariable {
+    let isDefault;
+    if (init.defaultEnv) {
+      isDefault = true;
+    } else if (init.randomEnv) {
+      isDefault = false;
+    } else {
+      isDefault = this.types.boolean();
+    }
+    
+    const result = /** @type ARCVariable */ ({
+      enabled: this.types.boolean({ likelihood: 85 }),
+      value: this.lorem.sentence({ words: 2 }),
+      name: this.lorem.word(),
+      _id: this.types.uuid(),
+      environment: '',
+    });
+    if (isDefault) {
+      result.environment = 'default';
+    } else {
+      result.environment = this.lorem.sentence({ words: 2 });
+    }
+    return result;
+  }
+
+  /**
+   * Generates a number of variables.
+   * @param size The number of variables to generate.
+   */
+  listVariables(size = 25, init: VariableInit={}): ARCVariable[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.variable(init));
+    }
+    return result;
+  }
+}

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