@api-client/core 0.3.3 → 0.3.4

package/src/lib/logging/DefaultLogger.ts

@@ -0,0 +1,19 @@
+import { Logger } from './Logger.js';
+
+export class DefaultLogger extends Logger {
+  warn(...args: unknown[]): void {
+    console.warn(...args);
+  }
+  info(...args: unknown[]): void {
+    console.info(...args);
+  }
+  error(...args: unknown[]): void {
+    console.error(...args);
+  }
+  log(...args: unknown[]): void {
+    console.log(...args);
+  }
+  debug(...args: unknown[]): void {
+    console.debug(...args);
+  }
+}

package/src/lib/logging/DummyLogger.ts

@@ -0,0 +1,21 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Logger } from './Logger.js';
+
+export class DummyLogger extends Logger {
+  warn(...args: unknown[]): void {
+    // ...
+  }
+  info(...args: unknown[]): void {
+    // ...
+  }
+  error(...args: unknown[]): void {
+    // ...
+  }
+  log(...args: unknown[]): void {
+    // ...
+  }
+  debug(...args: unknown[]): void {
+    // ...
+  }
+}

package/src/lib/logging/Logger.ts

@@ -0,0 +1,16 @@
+/* eslint-disable no-unused-vars */
+export interface ILogger {
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  log: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+}
+
+export abstract class Logger {
+  abstract warn(...args: unknown[]): void;
+  abstract info(...args: unknown[]): void;
+  abstract error(...args: unknown[]): void;
+  abstract log(...args: unknown[]): void;
+  abstract debug(...args: unknown[]): void;
+}

package/src/lib/transformers/PayloadSerializer.ts

@@ -0,0 +1,332 @@
+import { blobToDataUrl } from './Utils.js';
+
+export type PayloadTypes = 'string' | 'file' | 'blob' | 'buffer' | 'arraybuffer' | 'formdata' | 'x-www-form-urlencoded';
+export type DeserializedPayload = string | Blob | File | FormData | Buffer | ArrayBuffer | undefined;
+
+export interface IMultipartBody {
+  /**
+   * When true a this entry represent a file part
+   */
+  isFile: boolean;
+  /**
+   * The name of the filed
+   */
+  name: string;
+  /**
+   * Converted value
+   */
+  value: string;
+  /**
+   * A content type entered by the user to the text part of the text part input.
+   * This can only be set when `isFile` is false.
+   */
+  type?: string;
+  /**
+   * The original file name used with the part
+   */
+  fileName?: string;
+  /**
+   * Whether the parameter is enabled. Default to true.
+   */
+  enabled?: boolean;
+}
+
+/**
+ * Represents a payload that is safe to store in a data store.
+ * The `string` goes without any transformations.
+ * The `file` and the `blob` are data URLs encoded as string.
+ * The `buffer` and `arraybuffer` are UInt8Arrays.
+ */
+export interface ISafePayload {
+  /**
+   * The type od the originating payload object.
+   */
+  type: PayloadTypes;
+  data: string | number[] | IMultipartBody[];
+  /**
+   * Optionally the original mime type of the payload.
+   * This is used with files.
+   */
+  mime?: string;
+}
+/**
+ * The request payload. When not a string then it has to go through a 
+ * transformation from a store safe object to the original data object.
+ * For example, a file is stored as type 'file' and data with the file's data URL.
+ * A Buffer / ArrayBuffer is stored as type 'buffer' / 'arraybuffer' respectively 
+ * with the `data` being an UInt8Array of the content.
+ */
+export type Payload = string | ISafePayload;
+
+export const hasFormData: boolean = typeof FormData === 'function';
+export const hasBlob: boolean = typeof Blob === 'function';
+export const hasBuffer: boolean = typeof Buffer === 'function';
+
+export class PayloadSerializer {
+  /**
+   * Transforms the payload into a data store safe object.
+   */
+  static async serialize(payload: DeserializedPayload): Promise<ISafePayload | string | undefined> {
+    if (typeof payload === 'undefined' || payload === null) {
+      return undefined;
+    }
+    if (typeof payload === 'string') {
+      return payload;
+    }
+    if (hasBlob && payload instanceof Blob) {
+      return PayloadSerializer.stringifyBlob(payload);
+    }
+    if (hasBuffer && payload instanceof Buffer) {
+      return PayloadSerializer.stringifyBuffer(payload);
+    }
+    if (payload instanceof ArrayBuffer) {
+      return PayloadSerializer.stringifyArrayBuffer(payload);
+    }
+    if (hasFormData && payload instanceof FormData) {
+      try {
+        const result = await PayloadSerializer.stringifyFormData((payload as unknown) as Iterable<(string | File)[]>);
+        return result;
+      } catch (e: unknown) {
+        console.warn(`Unable to transform FormData: ${(e as Error).message}`);
+      }
+    }
+    return '';
+  }
+
+  /**
+   * Converts blob data to base64 string.
+   *
+   * @param blob File or blob object to be translated to string
+   * @return Promise resolved to a base64 string data from the file.
+   */
+  static async stringifyBlob(blob: Blob): Promise<ISafePayload> {
+    const typedFile = blob as File;
+    const data = await blobToDataUrl(blob);
+    const result: ISafePayload = {
+      type: 'blob',
+      data,
+      mime: typedFile.type,
+    };
+    return result;
+  }
+
+  /**
+   * When the passed argument is a NodeJS buffer it creates an object describing the buffer
+   * in a safe to store object.
+   * 
+   * @returns The buffer metadata or undefined if the passed argument is not a Buffer.
+   */
+  static stringifyBuffer(payload: Buffer): ISafePayload | undefined {
+    if (typeof payload.copy === 'function') {
+      return {
+        type: 'buffer',
+        data: [...payload],
+      };
+    }
+    return undefined;
+  }
+
+  /**
+   * When the passed argument is an ArrayBuffer it creates an object describing the object in a safe to store object.
+   * 
+   * @param {any} payload 
+   * @returns {TransformedPayload|undefined} The buffer metadata or undefined if the passed argument is not an ArrayBuffer.
+   */
+  static stringifyArrayBuffer(payload: ArrayBuffer): ISafePayload | undefined {
+    if (payload.byteLength) {
+      const view = new Uint8Array(payload);
+      return {
+        type: 'arraybuffer',
+        data: Array.from(view),
+      };
+    }
+    return undefined;
+  }
+
+  /**
+   * Transforms the FormData object to a serialized object describing the data.
+   *
+   * @param payload A `FormData` object
+   * @return A promise resolved to a datastore safe entries.
+   */
+  static async stringifyFormData(payload: Iterable<(string | File)[]>): Promise<ISafePayload> {
+    const promises: Promise<IMultipartBody>[] = [];
+    for (const part of payload) {
+      promises.push(PayloadSerializer.serializeFormDataEntry(part[0] as string, part[1]));
+    }
+    const items = await Promise.all(promises);
+    return {
+      type: 'formdata',
+      data: items,
+    }
+  }
+
+  /**
+   * Transforms a FormData entry into a safe-to-store text entry
+   *
+   * @param {string} name The part name
+   * @param {string|File} file The part value
+   * @return {Promise<IMultipartBody>} Transformed FormData part to a datastore safe entry.
+   */
+  static async serializeFormDataEntry(name: string, file: string | File): Promise<IMultipartBody> {
+    if (typeof file === 'string') {
+      // when adding an item to the FormData object without 3rd parameter of the append function
+      // then  the value is a string.
+      return {
+        isFile: false,
+        name,
+        value: file,
+        enabled: true,
+      };
+    }
+
+    const value = await blobToDataUrl(file);
+    const part: IMultipartBody = {
+      isFile: false,
+      name,
+      value,
+      enabled: true,
+    };
+    if (file.name === 'blob') {
+      // ARC adds the "blob" filename when the content type is set on the editor.
+      // otherwise it wouldn't be possible to set the content type value.
+      part.type = file.type;
+    } else {
+      part.isFile = true;
+      part.fileName = file.name;
+    }
+    return part;
+  }
+
+  /**
+   * Restores the payload into its original format.
+   */
+  static async deserialize(payload: ISafePayload | string | undefined): Promise<DeserializedPayload> {
+    if (typeof payload === 'undefined' || payload === null) {
+      return undefined;
+    }
+    if (typeof payload === 'string') {
+      return payload;
+    }
+    if (hasBuffer && !hasBlob) {
+      // we are in the nodejs environment. 
+      // We mostly gonna return a Buffer here.
+      switch (payload.type) {
+        case 'string': return payload.data as string;
+        case 'file':
+        case 'blob': return PayloadSerializer.deserializeBlobBuffer(payload.data as string);
+        case 'buffer': return PayloadSerializer.deserializeBuffer(payload.data as number[]);
+        case 'arraybuffer': return PayloadSerializer.deserializeArrayBufferBuffer(payload.data as number[]);
+        case 'formdata': return undefined;
+        default: return undefined;
+      }
+    }
+    switch (payload.type) {
+      case 'string': return payload.data as string;
+      case 'file':
+      case 'blob': return PayloadSerializer.deserializeBlob(payload.data as string);
+      case 'buffer': return PayloadSerializer.deserializeBuffer(payload.data as number[]);
+      case 'arraybuffer': return PayloadSerializer.deserializeArrayBuffer(payload.data as number[]);
+      case 'formdata': return PayloadSerializer.deserializeFormData(payload.data as IMultipartBody[]);
+      default: return undefined;
+    }
+  }
+
+  /**
+   * Converts data-url string to blob
+   *
+   * @param dataUrl Data url from blob value.
+   * @return Restored blob value
+   */
+  static deserializeBlob(dataUrl: string): Blob | undefined {
+    const arr = dataUrl.split(',');
+    const matchedMime = arr[0].match(/:(.*?);/);
+    if (!matchedMime) {
+      return undefined;
+    }
+    const mime = matchedMime[1];
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+    return new Blob([u8arr], { type: mime });
+  }
+
+  /**
+   * Converts data-url string to blob
+   *
+   * @param dataUrl Data url from blob value.
+   * @return Restored blob value
+   */
+  static deserializeBlobBuffer(dataUrl: string): Buffer {
+    const arr = dataUrl.split(',');
+    const value = arr[1];
+    return Buffer.from(value, 'base64url');
+  }
+
+  /**
+   * Converts UInt8Array to a Buffer.
+   *
+   * @param data Previously serialized buffer.
+   * @return Restored blob value
+   */
+  static deserializeBuffer(data: number[]): Buffer {
+    return Buffer.from(data);
+  }
+
+  /**
+   * Converts UInt8Array to an ArrayBuffer.
+   *
+   * @param data Previously serialized buffer.
+   */
+  static deserializeArrayBuffer(data: number[]): ArrayBuffer {
+    const { buffer } = new Uint8Array(data);
+    return buffer;
+  }
+
+  /**
+   * Converts UInt8Array to a Buffer.
+   *
+   * @param data Previously serialized buffer.
+   */
+  static deserializeArrayBufferBuffer(data: number[]): Buffer {
+    const ab = this.deserializeArrayBuffer(data);
+    return Buffer.from(ab);
+  }
+
+  /**
+   * Deserializes FormData from ARC data model.
+   *
+   * @param {IMultipartBody[]} model ARC model for multipart.
+   * @return {FormData} Restored form data
+   */
+  static deserializeFormData(parts: IMultipartBody[]): FormData {
+    const fd = new FormData();
+    if (!Array.isArray(parts) || !parts.length) {
+      return fd;
+    }
+    parts.forEach((part) => {
+      const { isFile, name, value, type, fileName, enabled } = part;
+      if (enabled === false) {
+        return;
+      }
+      let blob;
+      if (isFile) {
+        blob = PayloadSerializer.deserializeBlob(value);
+        if (blob) {
+          fd.append(name, blob, fileName);
+        }
+      } else if (type) {
+        blob = PayloadSerializer.deserializeBlob(value);
+        if (blob) {
+          fd.append(name, blob, 'blob');
+        }
+      } else {
+        fd.append(name, value);
+      }
+    });
+    return fd;
+  }
+}

package/src/lib/transformers/Utils.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts blob data to base64 string.
+ *
+ * @param blob File or blob object to be translated to string
+ * @return Promise resolved to a base64 string data from the file.
+ */
+export function blobToDataUrl(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = (): void => {
+      resolve(String(reader.result));
+    };
+    reader.onerror = (): void => {
+      reject(new Error('Unable to convert blob to string.'));
+    };
+    reader.readAsDataURL(blob);
+  });
+}

package/src/lib/uuid.ts

@@ -0,0 +1,40 @@
+const lut: string[] = [];
+for (let i = 0; i < 256; i++) {
+  lut[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+
+/**
+ * Generate a RFC4122, version 4 ID.
+ *
+ * @see http://stackoverflow.com/a/21963136/1127848
+ * @example "92329D39-6F5C-4520-ABFC-AAB64544E172"
+ * @return {string} Generated value
+ */
+export default function v4(): string {
+  const d0 = (Math.random() * 0xffffffff) | 0;
+  const d1 = (Math.random() * 0xffffffff) | 0;
+  const d2 = (Math.random() * 0xffffffff) | 0;
+  const d3 = (Math.random() * 0xffffffff) | 0;
+  return (
+    lut[d0 & 0xff] +
+    lut[(d0 >> 8) & 0xff] +
+    lut[(d0 >> 16) & 0xff] +
+    lut[(d0 >> 24) & 0xff] +
+    '-' +
+    lut[d1 & 0xff] +
+    lut[(d1 >> 8) & 0xff] +
+    '-' +
+    lut[((d1 >> 16) & 0x0f) | 0x40] +
+    lut[(d1 >> 24) & 0xff] +
+    '-' +
+    lut[(d2 & 0x3f) | 0x80] +
+    lut[(d2 >> 8) & 0xff] +
+    '-' +
+    lut[(d2 >> 16) & 0xff] +
+    lut[(d2 >> 24) & 0xff] +
+    lut[d3 & 0xff] +
+    lut[(d3 >> 8) & 0xff] +
+    lut[(d3 >> 16) & 0xff] +
+    lut[(d3 >> 24) & 0xff]
+  );
+}

package/src/mocking/LegacyInterfaces.ts

@@ -0,0 +1,52 @@
+import { DataMockInit, HarTimingInit, HttpRequestInit, HttpResponseRedirectStatusInit } from '@pawel-up/data-mock/types'
+
+export interface ArcDataMockInit extends DataMockInit {
+}
+
+export interface VariableInit {
+  defaultEnv?: boolean;
+  randomEnv?: boolean;
+}
+
+export declare interface RestApiIndexInit {
+  versionSize?: number;
+  order?: number;
+}
+
+export declare interface HttpResponseArcInit extends 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;
+  /**
+   * When set it ignores size information
+   */
+  noSize?: boolean;
+  /**
+   * Adds redirects to the request
+   */
+  redirects?: boolean;
+}
+
+export declare interface HttpResponseRedirectInit extends HttpResponseRedirectStatusInit, HarTimingInit {
+  /**
+   * When set it adds body to the response
+   */
+  body?: boolean;
+  /**
+   * The redirection code. Otherwise a random pick is used
+   */
+  code?: number;
+  /**
+   * Whether to generate timings object
+   */
+  timings?: boolean;
+}

package/src/mocking/LegacyMock.ts

@@ -0,0 +1,37 @@
+import { DataMock } from '@pawel-up/data-mock';
+import { Authorization } from './legacy/Authorization.js';
+import { Certificates } from './legacy/Certificates.js';
+import { Cookies } from './legacy/Cookies.js';
+import { HostRules } from './legacy/HostRules.js';
+import { Http } from './legacy/Http.js';
+import { RestApi } from './legacy/RestApi.js';
+import { Urls } from './legacy/Urls.js';
+import { Variables } from './legacy/Variables.js';
+import { ArcDataMockInit } from './LegacyInterfaces.js';
+
+export class LegacyMock extends DataMock {
+  http: Http;
+  variables: Variables;
+  cookies: Cookies;
+  hostRules: HostRules;
+  certificates: Certificates;
+  urls: Urls;
+  authorization: Authorization;
+  restApi: RestApi;
+  
+  /**
+   * @param init The library init options.
+   */
+  constructor(init?: ArcDataMockInit) {
+    super(init);
+
+    this.http = new Http(init);
+    this.variables = new Variables(init);
+    this.cookies = new Cookies(init);
+    this.hostRules = new HostRules(init);
+    this.certificates = new Certificates(init);
+    this.urls = new Urls(init);
+    this.authorization = new Authorization(init);
+    this.restApi = new RestApi(init);
+  }
+}

package/src/mocking/legacy/Authorization.ts

@@ -0,0 +1,39 @@
+import { Internet, Types } from '@pawel-up/data-mock';
+import { ArcDataMockInit } from '../LegacyInterfaces.js';
+import { ARCAuthData } from '../../models/legacy/models/AuthData.js';
+
+export class Authorization {
+  types: Types;
+  internet: Internet;
+
+  constructor(init: ArcDataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.internet = new Internet(init);
+  }
+
+  /**
+   * Generates random Basic authorization object.
+   */
+  basic(): ARCAuthData {
+    const result: ARCAuthData = {
+      _id: `basic/${this.types.string()}`,
+      username: this.internet.userName(),
+      password: this.types.hash(),
+    };
+    return result;
+  }
+
+  /**
+   * Generates basic authorization data
+   *
+   * @param size Number of items to generate. Default to 25.
+   * @return List of datastore entries.
+   */
+  basicList(size = 25): ARCAuthData[] {
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.basic());
+    }
+    return result;
+  }
+}