@loadmill/core 0.3.50 → 0.3.53

package/src/conf/validate.ts

@@ -1,548 +0,0 @@
-import URI from 'urijs';
-import jsonpath from 'jsonpath';
-import validator from 'validator';
-import { validateHeaderName } from 'http-headers-validation';
-import isEmpty from 'lodash/isEmpty';
-import uniq from 'lodash/uniq';
-import {
-  isReservedHeader,
-  supportedMethods,
-  ALLOWED_RESPONSE_STATUSES,
-  EXCLUDES
-} from '../request';
-import { NotificationMode, NotificationTypes } from './types';
-import { Parameters, parameterUtils, LEGAL_PARAM_CHARS, CAPTURE_REGEX, MAX_PARAM_ARRAY_SIZE } from '../parameters';
-import * as cronUtils from '@loadmill/universal/dist/cron-utils';
-import * as enumUtils from '@loadmill/universal/dist/enum-utils';
-import isBoolean from 'lodash/isBoolean';
-
-export const validate = {
-  invalid: invalid,
-
-  positive(value, name: string) {
-    if (typeof value !== 'number' || value <= 0) {
-      return invalid(name, 'Must be a positive number');
-    }
-  },
-
-  email(value, name: string) {
-    if (!validator.isEmail(value)) {
-      return invalid(name, 'invalid email');
-    }
-  },
-
-  integer(
-    value,
-    name: string | false,
-    min: number = 0,
-    max: number = Number.MAX_SAFE_INTEGER
-  ) {
-    if (!Number.isSafeInteger(Number(value))) {
-      return invalid(name, 'Must be an integer');
-    }
-
-    if (value < min) {
-      return invalid(name, 'Cannot be less than ' + min);
-    }
-
-    if (max < value) {
-      return invalid(name, 'Cannot be more than ' + max);
-    }
-  },
-
-  nonemptyArray(value, name: string) {
-    const message = 'Must be a nonempty array';
-    let res = array(value, name, message);
-
-    if (!res && isEmpty(value)) {
-      res = invalid(name, message);
-    }
-
-    return res;
-  },
-
-  array: array,
-
-  string: string,
-
-  jsonFormat: jsonFormat,
-
-  isTrue: isTrue,
-
-  uuid(value, name: string) {
-    if (!validator.isUUID(value)) {
-      return invalid(name, 'Must be a valid UUID');
-    }
-  },
-
-  nonemptyString: nonemptyString,
-
-  stringIfExists(value, name: string, message: string = 'Must be a string') {
-    if (value != null) {
-      return string(value, name, message);
-    }
-  },
-
-  notification(notification) {
-    const { email, destination, notifyWhen } = notification;
-    let res;
-
-    if (email) {
-      res = this.email(email, 'destination');
-    } else if (destination.type === NotificationTypes.EMAIL) {
-      res = this.email(destination.target, 'destination');
-    }
-
-    if (!res) {
-      if (!NotificationMode.hasOwnProperty(notifyWhen)) {
-        res = {
-          value: `Must be one of [${enumUtils.stringValues(NotificationMode)}]`,
-        };
-      }
-    }
-    return res;
-  },
-
-  parameter(name: string, value: string | string[]) {
-    const nameName = 'name';
-    let res = validate.parameterName(name, nameName);
-
-    //todo itay: perhaps limit length as well
-    if (!res) {
-      const valid = Array.isArray(value)
-        ? !isEmpty(value) && isEmpty(value.filter((item) => string(item)))
-        : !string(value);
-
-      if (!valid) {
-        res = { value: 'Must be a string or a nonempty string array' };
-      } else if (Array.isArray(value) && value.length > MAX_PARAM_ARRAY_SIZE) {
-        res = {
-          value: `No more than ${MAX_PARAM_ARRAY_SIZE} possible values are allowed`,
-        };
-      }
-    }
-
-    return res;
-  },
-
-  hasOnlyAcceptableCharacters: hasOnlyAcceptableCharacters,
-
-  parameterDoesntExist: parameterDoesntExist,
-
-  extractedValue: extractedValue,
-
-  isUrl: isUrl,
-
-  url(url: string, name = 'url') {
-    let res = nonemptyString(url, name, 'Required');
-
-    if (!res) {
-      res = isUrl(url, name);
-      if (!res) {
-        const uriObj = new URI(url);
-
-        const hostname = uriObj.hostname();
-
-        if (!uriObj.protocol() || !hostname) {
-          res = invalid(name, 'Missing protocol or host name');
-        }
-      }
-    }
-
-    return res;
-  },
-
-  isUrlLocalHost(url: string, name = 'url') {
-    const uriObj = new URI(url);
-    const hostname = uriObj.hostname();
-    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname.includes('ngrok')) {
-      return invalid(
-        name,
-        'Note: to test a local API use the Loadmill local agent - '
-      );
-    }
-  },
-
-  isMethodSupported(method) {
-    return supportedMethods.hasOwnProperty(method);
-  },
-
-  isHttpStatusSupported(expectedHttpStatus) {
-    return ALLOWED_RESPONSE_STATUSES.hasOwnProperty(expectedHttpStatus);
-  },
-
-  method(method) {
-    if (!validate.isMethodSupported(method)) {
-      return invalid('method', 'Not a valid HTTP method');
-    }
-  },
-
-  expectedHttpStatus(expectedHttpStatus) {
-    if (!validate.isHttpStatusSupported(expectedHttpStatus)) {
-      return invalid(
-        'expectedStatus',
-        'Not a valid HTTP response status option'
-      );
-    }
-  },
-
-  header(_headerName: string, headerValue: string) {
-    let res: any = headerName(_headerName);
-
-    if (!res) {
-      res = string(headerValue, 'value');
-    }
-
-    return res;
-  },
-
-  headerName: headerName,
-
-  mimeType(value: string, name: string) {
-    return string(value, name);
-  },
-
-  regex(value: string, name = 'regex') {
-    const message = 'Invalid JS regular expression';
-    let res = nonemptyString(value, name, 'Required');
-
-    if (!res && !parameterUtils.isParametrized(value)) {
-      try {
-        RegExp(value);
-      } catch (e) {
-        // log.debug('regex parse error:', e);
-        res = invalid(name, message);
-      }
-    }
-
-    return res;
-  },
-
-  regexCapture(value: string, name = 'regex') {
-    const message = 'Warning - your regex doesn\'t contain a capturing group';
-    const withoutQuotes = value.replace(/^'/, '').replace(/'$/, '');
-    const captureRegex = CAPTURE_REGEX;
-
-    let res;
-    try {
-      const captures = withoutQuotes.match(captureRegex);
-      if (!captures) {
-        res = invalid(name, message);
-      }
-    }
-    catch { }
-
-    return res;
-  },
-
-  jsonPath(value: string) {
-    const name = 'jsonPath';
-    const message = 'Invalid JSONPath expression';
-    let res = nonemptyString(value, name, 'Required');
-
-    if (!res && !parameterUtils.isParametrized(value)) {
-      try {
-        jsonpath.parse(value);
-      } catch (e) {
-        // log.debug('jsonPath parse error:', e);
-        res = invalid(name, message);
-      }
-    }
-
-    return res;
-  },
-
-  jQuery(value, name = 'jQuery') {
-    let query, attr;
-
-    if (typeof value === 'string') {
-      query = value;
-    } else if (value == null) {
-      return invalid(name, 'Must not be null');
-    } else {
-      attr = value.attr;
-      query = value.query;
-    }
-
-    //todo itay: figure out how to validate using Cheerio
-    const queryRes = nonemptyString(query, 'query', 'Required');
-
-    if (queryRes) {
-      return { [name]: queryRes };
-    } else {
-      const attrRes = attr != null && string(attr, 'attr');
-
-      if (attrRes) {
-        return { [name]: attrRes };
-      }
-    }
-  },
-
-  externalIntegration(integration) {
-    const { description, domain, username, token, project } = integration;
-    const res = Object.assign(
-      {},
-      validate.string(description, 'description'),
-      validate.url(domain, 'domain'),
-      validate.nonemptyString(username, 'username'),
-      validate.nonemptyString(token, 'token'),
-      validate.nonemptyString(project, 'project')
-    );
-    return res;
-  },
-
-  validateCron(cron: string) {
-    let res;
-    const name = 'cron error';
-    try {
-      if (!cron) {
-        res = invalid(name, `Empty - ${cron}`);
-      }
-      else {
-        cronUtils.parseCron(cron);
-        if (!cronUtils.isAllowedExpression(cron)) {
-          res = invalid(name, `Cron is not allowed - ${cron}`);
-        }
-        else if (isCronHasTooManyTokens(cron)) {
-          res = invalid(name, `Too many tokens - ${cron}`);
-        }
-      }
-    } catch (err) {
-      res = invalid(name, 'Can\'t parse cron expression');
-    }
-
-    return res;
-  },
-
-  validateParameterNames(names: string[]) {
-    return Object.assign(
-      {},
-      ...names.map((name, index) => validate.parameterName(name, '' + index))
-    );
-  },
-
-  validateObjOrArray<T>(
-    name: string,
-    objOrArray: T | T[],
-    singleValidation,
-  ) {
-    let res;
-
-    if (Array.isArray(objOrArray)) {
-      objOrArray.forEach((obj, index) => {
-        const temp = singleValidation(obj);
-
-        if (temp) {
-          res = { ...res, [index]: temp };
-        }
-      });
-    } else {
-      res = singleValidation(objOrArray);
-    }
-
-    if (res) {
-      return { [name]: res };
-    }
-  },
-
-  parameterName(
-    parameterName: string,
-    fieldName: string | false
-  ) {
-    let res = nonemptyString(
-      parameterName,
-      fieldName,
-      'Parameter name can\'t be empty'
-    );
-
-    if (!res) {
-      const firstChar = parameterName.charAt(0);
-
-      if (validator.isNumeric(firstChar)) {
-        res = invalid(fieldName, `May not start with '${firstChar}'`);
-      } else {
-        res = hasOnlyAcceptableCharacters(parameterName, fieldName);
-      }
-    }
-
-    return res;
-  },
-
-  label(labelParams) {
-    const { description, color } = labelParams;
-    const res = Object.assign(
-      {},
-      string(description, 'description'),
-      isColor(color),
-    );
-    return res;
-  },
-
-  boolean(value, name: string) {
-    if (!isBoolean(value)) {
-      return invalid(name, 'Must be a boolean');
-    }
-  }
-};
-
-function hasOnlyAcceptableCharacters(value: string, fieldName: string | false) {
-  const invalidMatch = new RegExp(`.*([^${LEGAL_PARAM_CHARS}]).*`).exec(value);
-
-  if (invalidMatch != null) {
-    return invalid(fieldName, `Unacceptable character: '${invalidMatch[1]}'`);
-  }
-}
-
-function parameterDoesntExist(
-  parameterName,
-  entityName: string,
-  collection: Array<Parameters>
-) {
-  if (!parameterName || isEmpty(collection)) {
-    return;
-  }
-
-  const entityExists = collection.some(
-    (e) => e[parameterName] || e[parameterName] === ''
-  );
-
-  if (entityExists) {
-    return invalid(entityName, `${entityName} ${parameterName} already exists`);
-  }
-}
-
-function extractedValue(extractedVal: string, fieldName: string | false) {
-  let res = nonemptyString(
-    extractedVal,
-    fieldName,
-    'Extracted value can\'t be empty'
-  );
-
-  if (!res) {
-    const invalidMatch = new RegExp('{|}|[$]').exec(extractedVal);
-
-    if (invalidMatch != null) {
-      return invalid(fieldName, `Unacceptable character: '${invalidMatch}'`);
-    }
-
-    const hasBannedWords = EXCLUDES.some((ex) => ex === extractedVal.trim());
-    if (hasBannedWords) {
-      res = invalid(
-        fieldName,
-        'Can\'t extract reserved HTTP words - URL, headers etc...'
-      );
-    }
-  }
-
-  return res;
-}
-
-function invalid(name: string | false, message: string): any {
-  return name ? { [name]: message } : message;
-}
-
-function array(value, name: string, message: string = 'Must be an array') {
-  if (!Array.isArray(value)) {
-    return invalid(name, message);
-  }
-}
-
-function isUrl(url: string, name: string = 'url') {
-  if (
-    !validator.isURL((url || ''), {
-      require_tld: false,
-      protocols: ['http', 'https', 'ftp', 'ws', 'wss']
-    })
-  ) {
-    return invalid(name, 'Invalid URL');
-  }
-}
-
-function nonemptyString(
-  value,
-  name: string | false,
-  message: string = 'May not be empty'
-) {
-  if (value == null) {
-    return invalid(name, message);
-  }
-
-  let res = string(value, name);
-
-  if (!res && value.trim().length === 0) {
-    res = invalid(name, message);
-  }
-
-  return res;
-}
-
-function string(
-  value,
-  name: string | false = 'value',
-  message: string = 'Must be a string'
-) {
-  if (typeof value !== 'string') {
-    return invalid(name, message);
-  }
-}
-
-function jsonFormat(
-  value: string,
-  name: string,
-  message: string = 'Invalid JSON format'
-) {
-  try {
-    const withoutParams = value.replace(/\$\{.+?(?=\})\}/g, 'null');
-    JSON.parse(withoutParams);
-  }
-  catch (_e) {
-    return invalid(name, message);
-  }
-}
-
-function isTrue(
-  value,
-  name: string,
-  message: string = 'Must be a true boolean'
-) {
-  if (value !== true && value !== 'true') {
-    return invalid(name, message);
-  }
-}
-
-function headerName(headerName: string, nameName = 'name') {
-  if (!headerName) {
-    return { [nameName]: 'Required' };
-  } else if (!validateHeaderName(headerName)) {
-    return { [nameName]: 'Invalid header name' };
-  } else if (isReservedHeader(headerName.toLowerCase())) {
-    return { [nameName]: 'This header may not be set manually' };
-  }
-}
-
-function isColor(value) {
-  const isHexColor = new RegExp('^#(?:[0-9a-fA-F]{3,4}){1,2}$').test(value);
-  if (!isHexColor) {
-    return invalid('color', 'Must be in hex color format');
-  }
-}
-
-export interface EntryValidations {
-  [name: string]:
-  | string
-  | {
-    name?: string;
-    value?: string;
-  };
-}
-
-const MAX_CRON_TOKENS = 5;
-const isCronHasTooManyTokens = (cron) =>
-  cron.split(' ').length > MAX_CRON_TOKENS;
-
-export const gitBranchName = (branchName: string) => {
-  const validation = branchName.match(/^[./]|\.\.|@{|[/.]$|^@$|[~^:\x00-\x20\x7F\s?*[\\]/g); // eslint-disable-line
-  if (validation) {
-    return 'Invalid characters: ' + uniq(validation.map(c => c == ' ' ? '(space)' : c)).join(' ');
-  }
-};

package/src/distributed-logger-reporter.ts

@@ -1,19 +0,0 @@
-import superagent from 'superagent';
-
-const url = process.env.DISTRIBUTED_LOGGER_URL || 'https://loadmill-distributed-logger.herokuapp.com/agent-events/report';
-
-export const distributedLoggerReporter = {
-
-  async report (body: string) {
-    if (process.env.STOP_REPORT === 'true') {
-      return;
-    }
-    try {
-      await superagent
-        .post(url)
-        .type('text/plain')
-        .send(body);
-    }
-    catch {}
-  }
-};

package/src/echo/firehose.ts

@@ -1,64 +0,0 @@
-import { FirehoseClient, PutRecordBatchCommand } from '@aws-sdk/client-firehose';
-import { CognitoIdentity } from '@aws-sdk/client-cognito-identity';
-
-const FIREHOSE_API_VERSION = '2015-08-04';
-const REGION = 'us-east-1';
-const STREAM_NAME = 'fhs-test1';
-
-let firehose: FirehoseClient;
-const cognito = new CognitoIdentity({ region: REGION });
-
-export class FirehoseRecords {
-  records;
-
-  constructor() {
-    this.clearRecords();
-  }
-
-  addRecord(record) {
-    const enc = new TextEncoder(); // always utf-8
-    const encodedRecord = enc.encode(`${JSON.stringify(record)}\n`);
-    this.records.push({ Data:  encodedRecord });
-  }
-
-  async pushRecords() {
-    try {
-
-      if (!this.records.length) {
-        return;
-      }
-
-      const identity = await cognito.getId({ IdentityPoolId: 'us-east-1:79372411-2664-431b-aa0b-aad9f938f6e9' });
-      const credentialResponse = await cognito.getCredentialsForIdentity({ IdentityId: identity.IdentityId });
-      firehose = new FirehoseClient({
-        region: REGION,
-        apiVersion: FIREHOSE_API_VERSION,
-        credentials: {
-          accessKeyId: credentialResponse.Credentials!.AccessKeyId!,
-          secretAccessKey:credentialResponse.Credentials!.SecretKey!,
-          sessionToken:credentialResponse.Credentials!.SessionToken!,
-          expiration:credentialResponse.Credentials!.Expiration!
-        }
-      });
-
-      const command = new PutRecordBatchCommand({
-        Records: this.records,
-        DeliveryStreamName: STREAM_NAME
-      });
-
-      await firehose.send(command);
-    }
-    catch (err) {
-      // eslint-disable-next-line no-console
-      console.error(err);
-    }
-    finally {
-      this.clearRecords();
-    }
-  }
-
-  clearRecords() {
-    this.records = [];
-  }
-
-}

package/src/echo/index.ts

@@ -1,4 +0,0 @@
-import { Stats } from './stats';
-import { FirehoseRecords } from './firehose';
-
-export { Stats, FirehoseRecords };

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