@loadmill/core 0.3.50 → 0.3.53

package/src/parameters/parameter-functions/boolean-parameter-functions.ts

@@ -1,24 +0,0 @@
-import { withBooleanInput } from './parameter-function-utils';
-import { ParameterFunction } from './parameter-function';
-
-class BooleanParameterFunction extends ParameterFunction {
-  constructor(operate: (...args: boolean[]) => boolean, minArgs?, maxArgs?) {
-    super(withBooleanInput(operate), minArgs, maxArgs);
-  }
-}
-
-export const booleanParameterFunctions = {
-  __and: new BooleanParameterFunction((...args) =>
-    args.reduce((x, y) => x && y, true)
-  ),
-
-  __or: new BooleanParameterFunction((...args) =>
-    args.reduce((x, y) => x || y, false)
-  ),
-
-  __not: new BooleanParameterFunction((x) => !x, 1, 1),
-
-  __true: new BooleanParameterFunction(() => true, 0, 0),
-
-  __false: new BooleanParameterFunction(() => false, 0, 0),
-};

package/src/parameters/parameter-functions/crypto.ts

@@ -1,55 +0,0 @@
-const CryptoJS = require('crypto-js');
-
-import { PresentableError } from '@loadmill/universal/dist/errors';
-
-export const FORMATS = {
-  UTF8:  'utf-8',
-  HEX: 'hex'
-};
-
-export const HASH = {
-  SHA1: 'SHA1',
-  SHA256: 'SHA256',
-};
-
-export const toSha = (secret: string, alg: string, secretFormat: string) => {
-  try {
-    const hashFunction = toHashFunction(alg);
-    const hashed = hashFunction(toCryptoFormat(secret, secretFormat));
-    return hashed.toString(CryptoJS.enc.Hex);
-  } catch (_e) {
-    throw new PresentableError(`Can't digest ${secret}`);
-  }
-};
-
-export const toHMAC = (secret: string, alg: string, secretFormat: string, salt: string) => {
-  try {
-    const converted = toCryptoFormat(secret, secretFormat);
-    const hmaced = CryptoJS.algo.HMAC.create(CryptoJS.algo[(alg || HASH.SHA256)], converted);
-    salt && hmaced.update(salt);
-    const hashed = hmaced.finalize();
-    return hashed.toString(CryptoJS.enc.Hex);
-  } catch (_e) {
-    throw new PresentableError(`Can't digest ${secret}`);
-  }
-};
-
-const toHashFunction = (type) => {
-  switch (type) {
-  case HASH.SHA1:
-    return CryptoJS.SHA1;
-  case HASH.SHA256:
-  default:
-    return CryptoJS.SHA256;
-  }
-};
-
-const toCryptoFormat = (from, base) => {
-  switch (base) {
-  case FORMATS.HEX:
-    return CryptoJS.enc.Hex.parse(from);
-  case FORMATS.UTF8:
-  default:
-    return CryptoJS.enc.Utf8.parse(from);
-  }
-};

package/src/parameters/parameter-functions/json-schema.ts

@@ -1,29 +0,0 @@
-import { Validator } from 'jsonschema';
-import isEmpty from 'lodash/isEmpty';
-
-import { JSONSchemaAssertionError } from '@loadmill/universal/dist/errors';
-
-export const applyJSONSchema = (instance, schema) => {
-  const v = new Validator();
-  let parsedInstance, parsedSchema;
-
-  try {
-    parsedInstance = JSON.parse(instance);
-  } catch {
-    parsedInstance = instance;
-  }
-
-  try {
-    parsedSchema = JSON.parse(schema);
-  } catch (e) {
-    throw new JSONSchemaAssertionError(`Invalid schema - ${e.message}`);
-  }
-
-  const res = v.validate(parsedInstance, parsedSchema);
-
-  if (!isEmpty(res.errors)) {
-    return false;
-  }
-
-  return true;
-};

package/src/parameters/parameter-functions/numeric-input-parameter-functions.ts

@@ -1,22 +0,0 @@
-import { withNumericInput } from './parameter-function-utils';
-import { ParameterFunction } from './parameter-function';
-
-class NumericInputParameterFunction extends ParameterFunction {
-  constructor(
-    operate: (...args: number[]) => NonNullable<any>,
-    minArgs?,
-    maxArgs?
-  ) {
-    super(withNumericInput(operate), minArgs, maxArgs);
-  }
-}
-
-export const numericInputParameterFunctions = {
-  __lt: new NumericInputParameterFunction((x, y) => x < y, 2, 2),
-
-  __lte: new NumericInputParameterFunction((x, y) => x <= y, 2, 2),
-
-  __gt: new NumericInputParameterFunction((x, y) => x > y, 2, 2),
-
-  __gte: new NumericInputParameterFunction((x, y) => x >= y, 2, 2),
-};

package/src/parameters/parameter-functions/numeric-parameter-functions.ts

@@ -1,37 +0,0 @@
-import { ParameterFunction } from './parameter-function';
-import { withNumericIO } from './parameter-function-utils';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-
-class NumericParameterFunction extends ParameterFunction {
-  constructor(operate: (...args: number[]) => number, minArgs?, maxArgs?) {
-    super(withNumericIO(operate), minArgs, maxArgs);
-  }
-}
-
-export const numericParameterFunctions = {
-  __add: new NumericParameterFunction((...args) =>
-    args.reduce((x, y) => x + y, 0)
-  ),
-
-  __sub: new NumericParameterFunction((v1, v2) => v1 - v2, 2, 2),
-
-  __neg: new NumericParameterFunction((x) => -x, 1, 1),
-
-  __abs: new NumericParameterFunction((x) => Math.abs(x), 1, 1),
-
-  __mult: new NumericParameterFunction((...args) =>
-    args.reduce((x, y) => x * y, 1)
-  ),
-
-  __div: new NumericParameterFunction(
-    (v1, v2) => {
-      if (v2 === 0) {
-        throw new PresentableError('Cannot divide by zero');
-      }
-
-      return v1 / v2;
-    },
-    2,
-    2
-  ),
-};

package/src/parameters/parameter-functions/parameter-function-utils.ts

@@ -1,55 +0,0 @@
-import { isTruthyParameterValue, parameterValueToNumber } from '../value-utils';
-import { ParameterFunction } from './parameter-function';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-
-
-export const withParameters = (fun) => (...args) => {
-    const result = fun(...args);
-
-    if (result != null) {
-      return result.toString();
-    } else {
-      throw new PresentableError('Result undefined');
-    }
-  },
-  withBooleanInput = (fun) => {
-    const pfun = withParameters(fun);
-    return (...args) => pfun(...args.map(isTruthyParameterValue));
-  },
-  withNumericInput = (fun) => {
-    const pfun = withParameters(fun);
-    return (...args) =>
-      pfun(
-        ...args.map((arg, index) => {
-          const num = parameterValueToNumber(arg);
-
-          if (num == null) {
-            throw new PresentableError(
-              `Cannot translate '${arg}' at index ${index} to a finite number`
-            );
-          }
-
-          return num;
-        })
-      );
-  },
-  withNumericIO = (fun) =>
-    withNumericInput((...args) => {
-      const result = fun(...args);
-
-      if (Number.isFinite(result)) {
-        return result;
-      } else {
-        throw new PresentableError(`Result '${result}' is not a finite number`);
-      }
-    });
-
-export class BasicParameterFunction extends ParameterFunction {
-  constructor(
-    operate: (...args: string[]) => NonNullable<any>,
-    minArgs?,
-    maxArgs?
-  ) {
-    super(withParameters(operate), minArgs, maxArgs);
-  }
-}

package/src/parameters/parameter-functions/parameter-function.ts

@@ -1,7 +0,0 @@
-export class ParameterFunction {
-  constructor(
-    readonly operate: (...args: string[]) => string,
-    readonly minArgs?: number,
-    readonly maxArgs?: number
-  ) {}
-}

package/src/parameters/parameter-functions/parameter-functions.ts

@@ -1,54 +0,0 @@
-import { ParameterFunction } from './parameter-function';
-import { randomParameterFunctions } from './random-parameter-functions';
-import { booleanParameterFunctions } from './boolean-parameter-functions';
-import { numericParameterFunctions } from './numeric-parameter-functions';
-import { textualParameterFunctions } from './textual-parameter-functions';
-import { numericInputParameterFunctions } from './numeric-input-parameter-functions';
-import { BasicParameterFunction } from './parameter-function-utils';
-
-const parameterFunctions: { [name: string]: BasicParameterFunction } = {
-  ...randomParameterFunctions,
-  ...textualParameterFunctions,
-  ...booleanParameterFunctions,
-  ...numericParameterFunctions,
-  ...numericInputParameterFunctions,
-};
-
-const toOperations = (paramFunctions: typeof parameterFunctions): ParameterFunctionOperations => {
-  const operations = {};
-  for (const func in paramFunctions) {
-    const without__prefix = func.substring(2);
-    operations[without__prefix] = paramFunctions[func].operate;
-  }
-  return operations;
-};
-
-export const parameterFunctionOperations = toOperations(parameterFunctions);
-
-export type ParameterFunctionOperations = { [no__prefix: string]: Function };
-
-/**
- * This is a list of all the functions we allow to accept a parameter with null value.
- * For example, __encode_url(${url_param}) when url_param has a null value.
- *
- * We are using these functions in Orca so in case one of the functions is changed we must changed in Orca as well.
- */
-const nullableParameterVaulesTextFunctions = {
-  // true / false would have suffice but I want hard refernce to avoid mistakes if a function name is changed
-  // so if you change the name of the function - you must change the key name
-  __escape_quotes: textualParameterFunctions.__escape_quotes,
-  __encode_url: textualParameterFunctions.__encode_url,
-  __decode_url: textualParameterFunctions.__decode_url,
-};
-
-export function canHaveNullParameterValue(functionName: string): boolean {
-  return nullableParameterVaulesTextFunctions.hasOwnProperty(functionName);
-}
-
-export function getParameterFunction(
-  functionName: string
-): ParameterFunction | null {
-  return parameterFunctions.hasOwnProperty(functionName)
-    ? parameterFunctions[functionName]
-    : null;
-}

package/src/parameters/parameter-functions/random-parameter-functions.ts

@@ -1,22 +0,0 @@
-const seedrandom = require('seedrandom');
-import { generateRandom, RandomTypes } from '../generate-random';
-import { BasicParameterFunction } from './parameter-function-utils';
-
-const MAX_NUMBER_OF_DIGITS = 10; // max length of output from seedrandom(seed).int32()
-
-export const randomParameterFunctions = Object.assign(
-  {},
-  ...Object.keys(RandomTypes).map((kind) => ({
-    [`__random_${kind}`]: new BasicParameterFunction((...args) =>
-      generateRandom(kind, ...args)
-    ),
-  })),
-  { '__random_seeded_number': new BasicParameterFunction((seed = '', length) => {
-    const rand= Math.abs(new seedrandom(seed).int32());
-    if (length && +length > 0) {
-      const cut = Math.min(+length, rand.toString().length, MAX_NUMBER_OF_DIGITS);
-      return ('' + rand).substring(0, cut);
-    }
-    return rand;
-  } , 0, 2) }
-);