@api-client/core 0.3.3 → 0.3.4

package/src/mocking/legacy/Certificates.ts

@@ -0,0 +1,145 @@
+import { Lorem, Random, Types, Utils } from '@pawel-up/data-mock';
+import { ArcDataMockInit } from '../LegacyInterfaces.js';
+import { Certificate, CertificateIndex, ClientCertificate } from '../../models/legacy/models/ClientCertificate.js';
+import { ExportArcClientCertificateData } from '../../models/legacy/DataExport.js';
+
+export declare interface CertificateCreateInit {
+  binary?: boolean;
+  noPassphrase?: boolean;
+  noKey?: boolean;
+  noCreated?: boolean;
+  type?: 'p12' | 'pem';
+}
+
+export class Certificates {
+  lorem: Lorem;
+  types: Types;
+  random: Random;
+
+  constructor(init: ArcDataMockInit={}) {
+    this.lorem = new Lorem(init);
+    this.types = new Types(init.seed);
+    this.random = new Random(init.seed);
+  }
+
+  /**
+   * Creates a certificate definition.
+   */
+  certificate(opts: CertificateCreateInit = {}): Certificate {
+    const data = this.lorem.paragraph();
+    const result: Certificate = {
+      data,
+    };
+    if (opts.binary) {
+      result.data = Utils.strToBuffer(data);
+    }
+    if (!opts.noPassphrase) {
+      result.passphrase = this.lorem.word();
+    }
+    return result;
+  }
+
+  /**
+   * Generates a Client Certificate index object.
+   * @param opts Create options
+   */
+  certificateIndex(opts: CertificateCreateInit = {}): CertificateIndex {
+    const type = opts.type ? opts.type : this.random.pickOne(['p12', 'pem']);
+    const result: CertificateIndex = {
+      type,
+      name: this.lorem.word(),
+    };
+    if (!opts.noCreated) {
+      result.created = this.types.datetime().getTime();
+    }
+    return result;
+  }
+
+  /**
+   * @param opts Create options
+   */
+  requestCertificate(opts: CertificateCreateInit = {}): ClientCertificate {
+    const type = opts.type ? opts.type : this.random.pickOne(['p12', 'pem']);
+    const cert = this.certificate(opts);
+    const name = this.lorem.word();
+    const result: ClientCertificate = {
+      type,
+      name,
+      cert,
+    };
+    if (!opts.noKey) {
+      result.key = this.certificate(opts);
+    }
+    return result;
+  }
+
+  /**
+   * Creates a ClientCertificate object that is used to create a new certificate.
+   * @param opts Create options
+   */
+  clientCertificate(opts: CertificateCreateInit = {}): ClientCertificate {
+    const index = this.certificateIndex(opts);
+    const data = this.requestCertificate(opts) as any;
+    const result: ClientCertificate = {
+      ...index,
+      cert: data.cert,
+    };
+    if (data.key) {
+      result.key = data.key;
+    }
+    return result;
+  }
+
+  /**
+   * Creates a list of ClientCertificate objects that are used to create a new certificates.
+   * 
+   * @param size The number of certificates to generate.
+   * @param opts Create options
+   */
+  clientCertificates(size = 15, opts: CertificateCreateInit = {}): ClientCertificate[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result[result.length] = this.clientCertificate(opts);
+    }
+    return result;
+  }
+
+  /**
+   * Creates a ClientCertificate transformed to the export object.
+   */
+  exportClientCertificate(opts: CertificateCreateInit = {}): ExportArcClientCertificateData {
+    const item = (this.clientCertificate(opts)) as any;
+    if (item.key) {
+      item.pKey = item.key;
+    }
+    item.key = this.types.uuid();
+    item.kind = 'ARC#ClientCertificate';
+    return item;
+  }
+
+  /**
+   * Creates a list of ClientCertificates transformed for the export object.
+   */
+  exportClientCertificates(size = 15, opts: CertificateCreateInit = {}): ExportArcClientCertificateData[] {
+    const result: ExportArcClientCertificateData[] = [];
+    for (let i = 0; i < size; i++) {
+      result[result.length] = this.exportClientCertificate(opts);
+    }
+    return result;
+  }
+
+  /**
+   * @param cert Certificate definition. See class description.
+   */
+  toStore(cert: Certificate|Certificate[]): Certificate|Certificate[] {
+    if (Array.isArray(cert)) {
+      return (cert.map(info => this.toStore(info))) as Certificate[];
+    }
+    if (typeof cert.data === 'string') {
+      return cert;
+    }
+    const data = Utils.bufferToBase64(cert.data);
+    const copy = { ...cert, type: 'buffer', data };
+    return copy;
+  }
+}

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