@loadmill/core 0.3.51 → 0.3.54

package/src/echo/stats.ts

@@ -1,84 +0,0 @@
-import isUUID from 'validator/lib/isUUID';
-
-const isNumber = s => /^[0-9]+$/.test(s);
-
-const standardizePath = path => {
-  const parts = path.slice(1).split('/');
-  let newPath = '';
-
-  parts.forEach(part => {
-    newPath += (isUUID(part) || isNumber(part)) ? '/{param}' : `/${part}`;
-  });
-
-  return newPath;
-};
-
-const updateKey = (obj, key, shouldIncr, value) => {
-  obj[key] = shouldIncr ? (obj[key] || 0) + value : value;
-};
-
-export class Stats {
-
-  stats;
-
-  constructor() {
-    this.stats = {
-      lmCode: -1,
-      totalRequests: 0,
-      totalResponseTime: 0,
-      requestsCounter: {},
-      requestsResponseTime: {},
-      isNewSession: false,
-      totalNewSessions: 0
-    };
-  }
-
-  updateStats(key, shouldIncr, value:any = 0, subKey = '') {
-    if (key && value) {
-      if (subKey) {
-        updateKey(this.stats[key], subKey, shouldIncr, value);
-      } else {
-        updateKey(this.stats, key, shouldIncr, value);
-      }
-    }
-  }
-
-  addRequest(request, responseTime) {
-    const convertedPath = standardizePath(new URL(request.url).pathname);
-
-    this.updateStats('totalRequests', true, 1);
-    this.updateStats('totalResponseTime', true, parseInt(responseTime, 10));
-    this.updateStats('requestsCounter', true, 1, `${request.method}:${convertedPath}`);
-    this.updateStats('requestsResponseTime', true, parseInt(responseTime, 10), `${request.method}:${convertedPath}`);
-  }
-
-  clearStats() {
-    this.stats.totalRequests = 0;
-    this.stats.totalResponseTime = 0;
-    this.stats.requestsCounter = {};
-    this.stats.requestsResponseTime = {};
-    this.stats.isNewSession = false;
-    this.stats.totalNewSessions = 0;
-  }
-
-  async push(url) {
-    let isPushed = false;
-    if (this.stats.totalRequests > 0) {
-      // eslint-disable-next-line no-undef
-      const res = await fetch(`${url}/stats`, {
-        method: 'POST',
-        body: JSON.stringify(this.stats),
-        headers: {
-          'Content-Type': 'application/json',
-          Accept: 'application/json'
-        }
-      });
-      if (res.ok) {
-        this.clearStats();
-        isPushed = true;
-      }
-    }
-
-    return isPushed;
-  }
-}

package/src/har/index.ts

@@ -1,81 +0,0 @@
-export interface Har {
-  log: HarLog;
-}
-
-export interface HarLog {
-  version: string;
-  entries: HarEntry[];
-}
-
-export interface HarEntry {
-  time: number;
-  request: HarRequest;
-  response: HarResponse;
-  startedDateTime: string;
-  _resourceType?: ResourceType;
-  _webSocketMessages?: WebSocketMessage[];
-}
-
-type ResourceType = 'main_frame' | 'sub_frame' | 'stylesheet' | 'script' | 'image' | 'font' |
-  'object' | 'xmlhttprequest' | 'ping' | 'csp_report' | 'media' | 'websocket' | 'other';
-
-export type WebSocketMessage = {
-  type: WebSocketMessageType,
-  time: number,
-  opcode: number,
-  data: string,
-};
-
-export type WebSocketMessageType = 'send' | 'receive';
-
-export interface HarRequest {
-  url: string;
-  method: string;
-  headers: HarHeaders;
-  bodySize: number;
-  postData?: HarPostData;
-  cookies: Cookie[]
-  queryString: { name: string, value: string }[];
-}
-
-export type HarHeaders = HarHeader[];
-
-export type HarHeader = {
-  name: string;
-  value: string;
-};
-
-export interface HarResponse {
-  status: number;
-  headers: HarHeaders;
-  statusText: string;
-
-  content: {
-    mimeType: string;
-    text?: string;
-    encoding?: string;
-  };
-}
-
-export type Cookie = {
-  name: string;
-  value: string;
-}
-
-export type HarPostData = {
-  mimeType: string;
-  text?: string;
-  params?: HarParam[];
-}
-
-export type HarParam = {
-  name: string;
-  value?: string;
-  fileName?: string;
-  contentType?: string;
-}
-
-export const isHar = (obj: any) => Boolean(obj.log) &&
-  typeof obj.log.version === 'string' &&
-  obj.log.version.startsWith('1.') &&
-  Array.isArray(obj.log.entries);

package/src/multipart-form-data/form-data-utils.ts

@@ -1,81 +0,0 @@
-import { HarParam } from '../har';
-import { PostFormData, PostFormDataEntry } from '../request';
-import { getBinaryOrTextValue, multipartFormDataTextToPostFormData } from './multipart-text-to-post-form-data';
-
-export class Form {
-  entries: HarParam[];
-  boundary: string;
-  constructor(entries?: HarParam[], boundary?: string) {
-    this.entries = entries || [];
-    this.boundary = boundary || this.generateBoundary();
-  }
-
-  generateBoundary = (): string => {
-    let boundary = '-'.repeat(26);
-    for (let i = 0; i < 24; i++) {
-      boundary += Math.floor(Math.random() * 10).toString(16);
-    }
-    return boundary;
-  };
-
-  append = (name: string, value: string, fileName?: string) => {
-    const entry: HarParam = { name, value };
-    fileName && (entry.fileName = fileName);
-    this.entries.push(entry);
-  };
-
-  toString = (): string => {
-    let result = '';
-    for (const { name, value, fileName, contentType } of this.entries) {
-      result += '--' + this.boundary + '\r\n';
-      result += `Content-Disposition: form-data; name="${name}"${this.addFileName(fileName)}${this.addContentType(contentType)}\r\n\r\n${value || ''}\r\n`;
-    }
-    result += '--' + this.boundary + '--\r\n';
-
-    return result;
-  };
-
-  private addFileName(fileName: string = '') {
-    let formattedFileName = '';
-    if (fileName) {
-      formattedFileName = `; filename="${fileName}"`;
-    }
-    return formattedFileName;
-  }
-
-  private addContentType = (contentType: string = ''): string => {
-    let formattedContentType = '';
-    if (contentType) {
-      formattedContentType = `\r\ncontent-type: ${contentType}`;
-    }
-    return formattedContentType;
-  }
-}
-
-export type FormEntry = { name: string, value: string, [other: string]: string };
-
-export function mapToMultipartFormData(request) {
-  const { postData: { params, text } } = request;
-  if (text) {
-    request.postFormData = multipartFormDataTextToPostFormData(text);
-  } else if (params) {
-    request.postFormData = multipartParamsToPostFormData(params);
-  }
-  delete request.postData;
-}
-
-const multipartParamsToPostFormData = (params: HarParam[] = []) => {
-  const postFormData: PostFormData = [];
-  for (const p of params) {
-    const { name, value = '', fileName, contentType } = p;
-    const entry: PostFormDataEntry = { name, value };
-    if (fileName) {
-      entry.fileName = fileName;
-      entry.value = getBinaryOrTextValue({ value, fileName, contentType });
-    }
-    postFormData.push(entry);
-  }
-  return postFormData;
-};
-
-export { multipartFormDataTextToPostFormData };

package/src/multipart-form-data/is-binary-file.ts

@@ -1,206 +0,0 @@
-const MAX_BYTES = 512;
-
-// A very basic non-exception raising reader. Read bytes and
-// at the end use hasError() to check whether this worked.
-class Reader {
-  public fileBuffer: Buffer;
-  public size: number;
-  public offset: number;
-  public error: boolean;
-
-  constructor(fileBuffer: Buffer, size: number) {
-    this.fileBuffer = fileBuffer;
-    this.size = size;
-    this.offset = 0;
-    this.error = false;
-  }
-
-  public hasError(): boolean {
-    return this.error;
-  }
-
-  public nextByte(): number {
-    if (this.offset === this.size || this.hasError()) {
-      this.error = true;
-      return 0xff;
-    }
-    return this.fileBuffer[this.offset++];
-  }
-
-  public next(len: number): number[] {
-    const n = new Array();
-    for (let i = 0; i < len; i++) {
-      n[i] = this.nextByte();
-    }
-    return n;
-  }
-}
-
-// Read a Google Protobuf var(iable)int from the buffer.
-function readProtoVarInt(reader: Reader): number {
-  let idx = 0;
-  let varInt = 0;
-
-  while (!reader.hasError()) {
-    const b = reader.nextByte();
-    varInt = varInt | ((b & 0x7f) << (7 * idx));
-    if ((b & 0x80) === 0) {
-      break;
-    }
-    idx++;
-  }
-
-  return varInt;
-}
-
-// Attempt to taste a full Google Protobuf message.
-function readProtoMessage(reader: Reader): boolean {
-  const varInt = readProtoVarInt(reader);
-  const wireType = varInt & 0x7;
-
-  switch (wireType) {
-  case 0:
-    readProtoVarInt(reader);
-    return true;
-  case 1:
-    reader.next(8);
-    return true;
-  case 2: {
-    const len = readProtoVarInt(reader);
-    reader.next(len);
-    return true;
-  }
-  case 5:
-    reader.next(4);
-    return true;
-  }
-  return false;
-}
-
-// Check whether this seems to be a valid protobuf file.
-function isBinaryProto(fileBuffer: Buffer, totalBytes: number): boolean {
-  const reader = new Reader(fileBuffer, totalBytes);
-  let numMessages = 0;
-
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    // Definitely not a valid protobuf
-    if (!readProtoMessage(reader) && !reader.hasError()) {
-      return false;
-    }
-    // Short read?
-    if (reader.hasError()) {
-      break;
-    }
-    numMessages++;
-  }
-
-  return numMessages > 0;
-}
-
-export function isBinaryFile(file: Buffer, size?: number): boolean {
-  if (size === undefined) {
-    size = file.length;
-  }
-  return isBinaryCheck(file, size);
-}
-
-function isBinaryCheck(fileBuffer: Buffer, bytesRead: number): boolean {
-  // empty file. no clue what it is.
-  if (bytesRead === 0) {
-    return false;
-  }
-
-  let suspiciousBytes = 0;
-  const totalBytes = Math.min(bytesRead, MAX_BYTES);
-
-  // UTF-8 BOM
-  if (bytesRead >= 3 && fileBuffer[0] === 0xef && fileBuffer[1] === 0xbb && fileBuffer[2] === 0xbf) {
-    return false;
-  }
-
-  // UTF-32 BOM
-  if (
-    bytesRead >= 4 &&
-    fileBuffer[0] === 0x00 &&
-    fileBuffer[1] === 0x00 &&
-    fileBuffer[2] === 0xfe &&
-    fileBuffer[3] === 0xff
-  ) {
-    return false;
-  }
-
-  // UTF-32 LE BOM
-  if (
-    bytesRead >= 4 &&
-    fileBuffer[0] === 0xff &&
-    fileBuffer[1] === 0xfe &&
-    fileBuffer[2] === 0x00 &&
-    fileBuffer[3] === 0x00
-  ) {
-    return false;
-  }
-
-  // GB BOM
-  if (
-    bytesRead >= 4 &&
-    fileBuffer[0] === 0x84 &&
-    fileBuffer[1] === 0x31 &&
-    fileBuffer[2] === 0x95 &&
-    fileBuffer[3] === 0x33
-  ) {
-    return false;
-  }
-
-  if (totalBytes >= 5 && fileBuffer.slice(0, 5).toString() === '%PDF-') {
-    /* PDF. This is binary. */
-    return true;
-  }
-
-  // UTF-16 BE BOM
-  if (bytesRead >= 2 && fileBuffer[0] === 0xfe && fileBuffer[1] === 0xff) {
-    return false;
-  }
-
-  // UTF-16 LE BOM
-  if (bytesRead >= 2 && fileBuffer[0] === 0xff && fileBuffer[1] === 0xfe) {
-    return false;
-  }
-
-  for (let i = 0; i < totalBytes; i++) {
-    if (fileBuffer[i] === 0) {
-      // NULL byte--it's binary!
-      return true;
-    } else if ((fileBuffer[i] < 7 || fileBuffer[i] > 14) && (fileBuffer[i] < 32 || fileBuffer[i] > 127)) {
-      // UTF-8 detection
-      if (fileBuffer[i] > 193 && fileBuffer[i] < 224 && i + 1 < totalBytes) {
-        i++;
-        if (fileBuffer[i] > 127 && fileBuffer[i] < 192) {
-          continue;
-        }
-      } else if (fileBuffer[i] > 223 && fileBuffer[i] < 240 && i + 2 < totalBytes) {
-        i++;
-        if (fileBuffer[i] > 127 && fileBuffer[i] < 192 && fileBuffer[i + 1] > 127 && fileBuffer[i + 1] < 192) {
-          i++;
-          continue;
-        }
-      }
-
-      suspiciousBytes++;
-      // Read at least 32 fileBuffer before making a decision
-      if (i >= 32 && (suspiciousBytes * 100) / totalBytes > 10) {
-        return true;
-      }
-    }
-  }
-
-  if ((suspiciousBytes * 100) / totalBytes > 10) {
-    return true;
-  }
-
-  if (suspiciousBytes > 1 && isBinaryProto(fileBuffer, totalBytes)) {
-    return true;
-  }
-
-  return false;
-}

package/src/multipart-form-data/multipart-text-to-post-form-data.ts

@@ -1,149 +0,0 @@
-import { extension } from 'mime-types';
-import { isBase64 } from 'validator';
-
-import { HarParam } from '../har';
-import { PostFormData, PostFormDataEntry } from '../request';
-import { isBinaryFile } from './is-binary-file';
-
-export const multipartFormDataTextToPostFormData = (multipartFormDataText: string = ''): PostFormData =>
-  getLines(multipartFormDataText)
-    .map(line => extractPostFormDataEntry(line));
-
-const getLines = (multipartFormDataText: string = ''): string[] =>
-  removeEmptyLines(
-    multipartFormDataText.split(
-      splitByBoundaryRegex(
-        getBoundary(multipartFormDataText)
-      )
-    )
-  );
-
-const getBoundary = (multipartFormDataText: string): string =>
-  multipartFormDataText.substring(0, multipartFormDataText.indexOf('\r\n'));
-
-const splitByBoundaryRegex = (boundary: string) => {
-  const normalBoundary = boundary + '\r\n';
-  const lastBoundary = boundary + '--\r\n';
-  return new RegExp(`${normalBoundary}|${lastBoundary}`);
-};
-
-const removeEmptyLines = (lines: string[] = []): string[] => lines.filter(Boolean);
-
-const extractPostFormDataEntry = (line: string): PostFormDataEntry => {
-  const indexOfFirst2Newlines = line.indexOf('\r\n\r\n');
-
-  const fields = extractFields(line, indexOfFirst2Newlines);
-  const value = calculateValue(fields, line, indexOfFirst2Newlines);
-
-  const postFormDataEntry: PostFormDataEntry = { name: fields.name, value };
-  fields.fileName && (postFormDataEntry.fileName = fields.fileName);
-  fields.contentType && (postFormDataEntry.contentType = fields.contentType);
-
-  return postFormDataEntry;
-};
-
-type Fields = HarParam;
-
-const extractFields = (line: string, indexOfFirst2Newlines: number): Fields => {
-  const rawFields = extractRawFields(line, indexOfFirst2Newlines);
-  const res: Fields = { name: '' };
-  const fieldsLines = rawFields.split('\r\n');
-  addNameFields(fieldsLines[0], res);
-  fieldsLines.length > 1 && addContentType(fieldsLines[1], res);
-  return res;
-};
-
-const extractRawFields = (line: string, indexOfFieldsValueSeperator: number): string =>
-  line.substring(0, indexOfFieldsValueSeperator);
-
-const removeDoubleQuotes = (v: string): string =>
-  v.replace(/"/g, '');
-
-const calculateValue = ({ fileName, contentType }: Fields, line: string, indexOfFirst2Newlines: number): string | '' => {
-  const value = extractValue(line, indexOfFirst2Newlines);
-  return getBinaryOrTextValue({ value, fileName, contentType });
-};
-
-export const getBinaryOrTextValue = (fields: Omit<Fields, 'name'>): string => {
-  const { value = '', fileName } = fields;
-  if (fileName) {
-    const isBass64 = isBase64(value);
-    const toBinary = isToBinary(fields);
-    if (isBass64 || toBinary) {
-      return myAtob(value, isBass64, toBinary);
-    }
-  }
-  return value;
-};
-
-const myAtob = (target = '', fromBase64?: boolean, toBinary?: boolean) => {
-  const defaultEncoding = 'utf8';
-  const encodingFrom = fromBase64 ? 'base64' : defaultEncoding;
-  const encodingTo = toBinary ? 'binary' : defaultEncoding;
-  return Buffer.from(target, encodingFrom).toString(encodingTo);
-};
-
-const isToBinary = (fields: Omit<Fields, 'name'>): boolean => {
-  const { value = '', fileName, contentType } = fields;
-  if (isAlreadyBinary(value)) {
-    return false;
-  }
-  if (fileName) {
-    const ext = getExtension(fileName);
-    if (ext) {
-      return isBinaryFileExtension(ext);
-    }
-  }
-  if (contentType) {
-    return isBinaryContentType(contentType);
-  }
-  return false;
-};
-
-const isAlreadyBinary = (target = '') => {
-  const bytes = Buffer.from(target);
-  const size = target.length;
-  return isBinaryFile(bytes, size);
-};
-
-const getExtension = (fileName: string): string | undefined =>
-  fileName.split('.').pop();
-
-const isBinaryFileExtension = (ext: string): boolean =>
-  ['docx', 'pdf', 'doc', 'jpg', 'jpeg', 'png'].includes(ext);
-
-const isBinaryContentType = (contentType: string): boolean =>
-  ['docx', 'pdf', 'bin'].includes(extension(contentType) || '');
-
-const extractValue = (line: string, indexOfFieldsValueSeperator: number): string =>
-  removeEndingNewline(
-    line.substring(indexOfFieldsValueSeperator + 4)
-  );
-
-const removeEndingNewline = (s: string): string =>
-  s.endsWith('\r\n') ? removeLast2Chars(s) : s;
-
-const removeLast2Chars = (s: string): string =>
-  s.substring(0, s.length - 2);
-
-const addNameFields = (nameFieldsLine: string, res: HarParam) => {
-  const tokens = extractTokens(nameFieldsLine);
-  for (const token of tokens) {
-    const [k, v] = token.split('=');
-    if (k === 'name') {
-      res.name = removeDoubleQuotes(v);
-    } else if (k === 'filename') {
-      res.fileName = removeDoubleQuotes(v);
-    }
-  }
-};
-
-const extractTokens = (nameFieldsLine: string): string[] =>
-  nameFieldsLine.split(';').map(t => t.trim());
-
-const addContentType = (contentTypeLine: string, res: HarParam) => {
-  const [k, v] = contentTypeLine.split(': ');
-  if (k === 'content-type') {
-    res.contentType = v;
-  }
-};

package/src/parameters/extractions.ts

@@ -1,53 +0,0 @@
-import { Extractions } from '../request';
-import { parameterUtils } from '.';
-const { getParameterName } = parameterUtils;
-
-/**
- * Gets an extractions instance which looks like this: { [paramName]: string }.
- *
- * If it's an assign extraction, i.e { [paramName]: string }
- * OR { [paramName]: { jsonPath/jQuery/...: string } }
- * OR { [paramName]: { jQuery: { query: string, attr?: string } } }}}
- * And spreads this object into its parts.
- *
- * Example:
- * input ext = { my_ext: { jsonPath: '$["users"][0]["id"]' } }
- * output = { name: 'my_ext', value: '$["users"][0]["name"]', type: 'jsonPath' }
- *
- * @param ext The extraction object to take a part
- * @returns The spreaded parts of the given extraction object
- */
-export function getExtractionParts(ext: Extractions): ExtractionParts {
-  const name = getParameterName(ext);
-  const extContent = ext[name];
-  if (typeof extContent === 'string') {
-    return { name, value: extContent };
-  }
-  const [type] = Object.keys(extContent);
-  const value = ext[name][type];
-  return { name, value, type };
-}
-
-export type ExtractionParts = {
-  name: string;
-  value: string | {
-    query: string;
-    attr?: string;
-  };
-  type?: string;
-};
-
-export function requestsExtractionsArr(requests, toIndex: number) {
-  const extractionParamNames = [] as string[];
-  for (let i = 0; i <= toIndex; i++) {
-    if (requests[i].extract) {
-      for (const param of requests[i].extract) {
-        const paramName = Object.keys(param)[0];
-        if (paramName && extractionParamNames.indexOf(paramName) < 0) {
-          extractionParamNames.push(paramName);
-        }
-      }
-    }
-  }
-  return extractionParamNames;
-}

package/src/parameters/extractors/cheerio-extractor.ts

@@ -1,57 +0,0 @@
-import cheerio from 'cheerio';
-import random = require('lodash/random');
-import { parameterValueToNumber, RANDOM_SELECT_OPT } from '../value-utils';
-import { Parameters } from '../type';
-import { ParametrizedExtractor } from './parametrized-extractor';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-
-export class CheerioExtractor extends ParametrizedExtractor {
-  private $;
-
-  constructor(target, parameters: Parameters) {
-    super(parameters);
-    this.$ = cheerio.load(target);
-  }
-
-  extractResolved = (
-    resolvedJQuery: string,
-    selection: string = '0',
-    resolvedAttrName?: string
-  ) => {
-    let jQueryResult;
-
-    const matched = this.$(resolvedJQuery);
-    const numMatched = matched.length;
-
-    if (numMatched === 0) {
-      jQueryResult = null;
-    } else {
-      const index = getIndex(selection, numMatched);
-      const element = matched.eq(index);
-
-      if (resolvedAttrName) {
-        const attr = element.attr(resolvedAttrName);
-        jQueryResult = attr != null ? attr.toString() : null;
-      } else {
-        jQueryResult = element.html();
-      }
-    }
-
-    // log.debug('jQuery extraction:', { resolvedJQuery, jQueryResult });
-
-    return jQueryResult;
-  };
-}
-
-function getIndex(selection: string, len) {
-  let index: number | null;
-  if (selection === RANDOM_SELECT_OPT) {
-    index = random(0, len - 1);
-  } else {
-    index = parameterValueToNumber(selection, { integer: true });
-    if (index == null) {
-      throw new PresentableError('Invalid index: ' + selection);
-    }
-  }
-  return index;
-}