@loadmill/core 0.3.139 → 0.3.141

package/dist/parameters/parameter-functions/parameter-function-utils.js

@@ -0,0 +1,82 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicParameterFunction = exports.withNumericIO = exports.withNumericInput = exports.withBooleanInput = exports.withParameters = void 0;
+var value_utils_1 = require("../value-utils");
+var parameter_function_1 = require("./parameter-function");
+var errors_1 = require("@loadmill/universal/dist/errors");
+var withParameters = function (fun) { return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var result = fun.apply(void 0, args);
+    if (result != null) {
+        return result.toString();
+    }
+    else {
+        throw new errors_1.PresentableError('Result undefined');
+    }
+}; }, withBooleanInput = function (fun) {
+    var pfun = exports.withParameters(fun);
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return pfun.apply(void 0, args.map(value_utils_1.isTruthyParameterValue));
+    };
+}, withNumericInput = function (fun) {
+    var pfun = exports.withParameters(fun);
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return pfun.apply(void 0, args.map(function (arg, index) {
+            var num = value_utils_1.parameterValueToNumber(arg);
+            if (num == null) {
+                throw new errors_1.PresentableError("Cannot translate '" + arg + "' at index " + index + " to a finite number");
+            }
+            return num;
+        }));
+    };
+}, withNumericIO = function (fun) {
+    return exports.withNumericInput(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var result = fun.apply(void 0, args);
+        if (Number.isFinite(result)) {
+            return result;
+        }
+        else {
+            throw new errors_1.PresentableError("Result '" + result + "' is not a finite number");
+        }
+    });
+};
+exports.withParameters = withParameters, exports.withBooleanInput = withBooleanInput, exports.withNumericInput = withNumericInput, exports.withNumericIO = withNumericIO;
+var BasicParameterFunction = /** @class */ (function (_super) {
+    __extends(BasicParameterFunction, _super);
+    function BasicParameterFunction(operate, minArgs, maxArgs) {
+        return _super.call(this, exports.withParameters(operate), minArgs, maxArgs) || this;
+    }
+    return BasicParameterFunction;
+}(parameter_function_1.ParameterFunction));
+exports.BasicParameterFunction = BasicParameterFunction;
+//# sourceMappingURL=parameter-function-utils.js.map

package/dist/parameters/parameter-functions/parameter-function-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-function-utils.js","sourceRoot":"","sources":["../../../src/parameters/parameter-functions/parameter-function-utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,8CAAgF;AAChF,2DAAyD;AACzD,0DAAmE;AAG5D,IAAM,cAAc,GAAG,UAAC,GAAG,IAAK,OAAA;IAAC,cAAO;SAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;QAAP,yBAAO;;IAC3C,IAAM,MAAM,GAAG,GAAG,eAAI,IAAI,CAAC,CAAC;IAE5B,IAAI,MAAM,IAAI,IAAI,EAAE;QAClB,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;KAC1B;SAAM;QACL,MAAM,IAAI,yBAAgB,CAAC,kBAAkB,CAAC,CAAC;KAChD;AACH,CAAC,EARoC,CAQpC,EACD,gBAAgB,GAAG,UAAC,GAAG;IACrB,IAAM,IAAI,GAAG,sBAAc,CAAC,GAAG,CAAC,CAAC;IACjC,OAAO;QAAC,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QAAK,OAAA,IAAI,eAAI,IAAI,CAAC,GAAG,CAAC,oCAAsB,CAAC;IAAxC,CAAyC,CAAC;AAChE,CAAC,EACD,gBAAgB,GAAG,UAAC,GAAG;IACrB,IAAM,IAAI,GAAG,sBAAc,CAAC,GAAG,CAAC,CAAC;IACjC,OAAO;QAAC,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QACb,OAAA,IAAI,eACC,IAAI,CAAC,GAAG,CAAC,UAAC,GAAG,EAAE,KAAK;YACrB,IAAM,GAAG,GAAG,oCAAsB,CAAC,GAAG,CAAC,CAAC;YAExC,IAAI,GAAG,IAAI,IAAI,EAAE;gBACf,MAAM,IAAI,yBAAgB,CACxB,uBAAqB,GAAG,mBAAc,KAAK,wBAAqB,CACjE,CAAC;aACH;YAED,OAAO,GAAG,CAAC;QACb,CAAC,CAAC;IAXJ,CAYC,CAAC;AACN,CAAC,EACD,aAAa,GAAG,UAAC,GAAG;IAClB,OAAA,wBAAgB,CAAC;QAAC,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QACvB,IAAM,MAAM,GAAG,GAAG,eAAI,IAAI,CAAC,CAAC;QAE5B,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;YAC3B,OAAO,MAAM,CAAC;SACf;aAAM;YACL,MAAM,IAAI,yBAAgB,CAAC,aAAW,MAAM,6BAA0B,CAAC,CAAC;SACzE;IACH,CAAC,CAAC;AARF,CAQE,CAAC;AAvCM,QAAA,cAAc,mBASzB,QAAA,gBAAgB,qBAIhB,QAAA,gBAAgB,qBAiBhB,QAAA,aAAa,iBASR;AAEP;IAA4C,0CAAiB;IAC3D,gCACE,OAAgD,EAChD,OAAQ,EACR,OAAQ;eAER,kBAAM,sBAAc,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC;IAClD,CAAC;IACH,6BAAC;AAAD,CAAC,AARD,CAA4C,sCAAiB,GAQ5D;AARY,wDAAsB"}

package/dist/parameters/parameter-functions/parameter-function.d.ts

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

package/dist/parameters/parameter-functions/parameter-function.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterFunction = void 0;
+var ParameterFunction = /** @class */ (function () {
+    function ParameterFunction(operate, minArgs, maxArgs) {
+        Object.defineProperty(this, "operate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: operate
+        });
+        Object.defineProperty(this, "minArgs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: minArgs
+        });
+        Object.defineProperty(this, "maxArgs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: maxArgs
+        });
+    }
+    return ParameterFunction;
+}());
+exports.ParameterFunction = ParameterFunction;
+//# sourceMappingURL=parameter-function.js.map

package/dist/parameters/parameter-functions/parameter-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-function.js","sourceRoot":"","sources":["../../../src/parameters/parameter-functions/parameter-function.ts"],"names":[],"mappings":";;;AAAA;IACE,2BACW,OAAsC,EACtC,OAAgB,EAChB,OAAgB;;;;;mBAFhB;;;;;;mBACA;;;;;;mBACA;;IACR,CAAC;IACN,wBAAC;AAAD,CAAC,AAND,IAMC;AANY,8CAAiB"}

package/dist/parameters/parameter-functions/parameter-functions.d.ts

@@ -0,0 +1,7 @@
+import { ParameterFunction } from './parameter-function';
+export declare const parameterFunctionOperations: ParameterFunctionOperations;
+export declare type ParameterFunctionOperations = {
+    [no__prefix: string]: Function;
+};
+export declare function canHaveNullParameterValue(functionName: string): boolean;
+export declare function getParameterFunction(functionName: string): ParameterFunction | null;

package/dist/parameters/parameter-functions/parameter-functions.js

@@ -0,0 +1,53 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParameterFunction = exports.canHaveNullParameterValue = exports.parameterFunctionOperations = void 0;
+var random_parameter_functions_1 = require("./random-parameter-functions");
+var boolean_parameter_functions_1 = require("./boolean-parameter-functions");
+var numeric_parameter_functions_1 = require("./numeric-parameter-functions");
+var textual_parameter_functions_1 = require("./textual-parameter-functions");
+var numeric_input_parameter_functions_1 = require("./numeric-input-parameter-functions");
+var parameterFunctions = __assign(__assign(__assign(__assign(__assign({}, random_parameter_functions_1.randomParameterFunctions), textual_parameter_functions_1.textualParameterFunctions), boolean_parameter_functions_1.booleanParameterFunctions), numeric_parameter_functions_1.numericParameterFunctions), numeric_input_parameter_functions_1.numericInputParameterFunctions);
+var toOperations = function (paramFunctions) {
+    var operations = {};
+    for (var func in paramFunctions) {
+        var without__prefix = func.substring(2);
+        operations[without__prefix] = paramFunctions[func].operate;
+    }
+    return operations;
+};
+exports.parameterFunctionOperations = toOperations(parameterFunctions);
+/**
+ * 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.
+ */
+var 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: textual_parameter_functions_1.textualParameterFunctions.__escape_quotes,
+    __encode_url: textual_parameter_functions_1.textualParameterFunctions.__encode_url,
+    __decode_url: textual_parameter_functions_1.textualParameterFunctions.__decode_url,
+};
+function canHaveNullParameterValue(functionName) {
+    return nullableParameterVaulesTextFunctions.hasOwnProperty(functionName);
+}
+exports.canHaveNullParameterValue = canHaveNullParameterValue;
+function getParameterFunction(functionName) {
+    return parameterFunctions.hasOwnProperty(functionName)
+        ? parameterFunctions[functionName]
+        : null;
+}
+exports.getParameterFunction = getParameterFunction;
+//# sourceMappingURL=parameter-functions.js.map

package/dist/parameters/parameter-functions/parameter-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-functions.js","sourceRoot":"","sources":["../../../src/parameters/parameter-functions/parameter-functions.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AACA,2EAAwE;AACxE,6EAA0E;AAC1E,6EAA0E;AAC1E,6EAA0E;AAC1E,yFAAqF;AAGrF,IAAM,kBAAkB,oDACnB,qDAAwB,GACxB,uDAAyB,GACzB,uDAAyB,GACzB,uDAAyB,GACzB,kEAA8B,CAClC,CAAC;AAEF,IAAM,YAAY,GAAG,UAAC,cAAyC;IAC7D,IAAM,UAAU,GAAG,EAAE,CAAC;IACtB,KAAK,IAAM,IAAI,IAAI,cAAc,EAAE;QACjC,IAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QAC1C,UAAU,CAAC,eAAe,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;KAC5D;IACD,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEW,QAAA,2BAA2B,GAAG,YAAY,CAAC,kBAAkB,CAAC,CAAC;AAI5E;;;;;GAKG;AACH,IAAM,oCAAoC,GAAG;IAC3C,2GAA2G;IAC3G,2EAA2E;IAC3E,eAAe,EAAE,uDAAyB,CAAC,eAAe;IAC1D,YAAY,EAAE,uDAAyB,CAAC,YAAY;IACpD,YAAY,EAAE,uDAAyB,CAAC,YAAY;CACrD,CAAC;AAEF,SAAgB,yBAAyB,CAAC,YAAoB;IAC5D,OAAO,oCAAoC,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;AAC3E,CAAC;AAFD,8DAEC;AAED,SAAgB,oBAAoB,CAClC,YAAoB;IAEpB,OAAO,kBAAkB,CAAC,cAAc,CAAC,YAAY,CAAC;QACpD,CAAC,CAAC,kBAAkB,CAAC,YAAY,CAAC;QAClC,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAND,oDAMC"}

package/dist/parameters/parameter-functions/random-parameter-functions.d.ts

@@ -0,0 +1 @@
+export declare const randomParameterFunctions: any;

package/dist/parameters/parameter-functions/random-parameter-functions.js

@@ -0,0 +1,43 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomParameterFunctions = void 0;
+var seedrandom = require('seedrandom');
+var RandExp = require('randexp');
+var generate_random_1 = require("../generate-random");
+var parameter_function_utils_1 = require("./parameter-function-utils");
+var errors_1 = require("@loadmill/universal/dist/errors");
+var MAX_NUMBER_OF_DIGITS = 10; // max length of output from seedrandom(seed).int32()
+exports.randomParameterFunctions = Object.assign.apply(Object, __spreadArray(__spreadArray([{}], Object.keys(generate_random_1.RandomTypes).map(function (kind) {
+    var _a;
+    return (_a = {},
+        _a["__random_" + kind] = new parameter_function_utils_1.BasicParameterFunction(function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return generate_random_1.generateRandom.apply(void 0, __spreadArray([kind], args));
+        }),
+        _a);
+})), [{ '__random_seeded_number': new parameter_function_utils_1.BasicParameterFunction(function (seed, length) {
+            if (seed === void 0) { seed = ''; }
+            var rand = Math.abs(new seedrandom(seed).int32());
+            if (length && +length > 0) {
+                var cut = Math.min(+length, rand.toString().length, MAX_NUMBER_OF_DIGITS);
+                return ('' + rand).substring(0, cut);
+            }
+            return rand;
+        }, 0, 2) },
+    { '__random_regex': new parameter_function_utils_1.BasicParameterFunction(function (regexExpression) {
+            try {
+                return new RandExp(regexExpression).gen();
+            }
+            catch (e) {
+                throw new errors_1.PresentableError("Random regex error: " + e.message);
+            }
+        }, 1, 1) }]));
+//# sourceMappingURL=random-parameter-functions.js.map

package/dist/parameters/parameter-functions/random-parameter-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-parameter-functions.js","sourceRoot":"","sources":["../../../src/parameters/parameter-functions/random-parameter-functions.ts"],"names":[],"mappings":";;;;;;;;AAAA,IAAM,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACzC,IAAM,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;AACnC,sDAAiE;AACjE,uEAAoE;AACpE,0DAAmE;AAEnE,IAAM,oBAAoB,GAAG,EAAE,CAAC,CAAC,qDAAqD;AAEzE,QAAA,wBAAwB,GAAG,MAAM,CAAC,MAAM,OAAb,MAAM,+BAC5C,EAAE,GACC,MAAM,CAAC,IAAI,CAAC,6BAAW,CAAC,CAAC,GAAG,CAAC,UAAC,IAAI;;IAAK,OAAA;QACxC,GAAC,cAAY,IAAM,IAAG,IAAI,iDAAsB,CAAC;YAAC,cAAO;iBAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;gBAAP,yBAAO;;YACvD,OAAA,gCAAc,8BAAC,IAAI,GAAK,IAAI;QAA5B,CAA6B,CAC9B;WACD;AAJwC,CAIxC,CAAC,IACH,EAAE,wBAAwB,EAAE,IAAI,iDAAsB,CAAC,UAAC,IAAS,EAAE,MAAM;YAAjB,qBAAA,EAAA,SAAS;YAC/D,IAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;YACpD,IAAI,MAAM,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;gBACzB,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;gBAC5E,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;aACtC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE;IACV,EAAE,gBAAgB,EAAE,IAAI,iDAAsB,CAAC,UAAC,eAAe;YAC7D,IAAI;gBACF,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC,GAAG,EAAE,CAAC;aAC3C;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,yBAAgB,CAAC,yBAAuB,CAAC,CAAC,OAAS,CAAC,CAAC;aAChE;QACH,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,IACV"}

package/dist/parameters/parameter-functions/textual-parameter-functions.d.ts

@@ -0,0 +1,72 @@
+import { BasicParameterFunction } from './parameter-function-utils';
+export declare const base64decode: (text?: string) => string;
+export declare const base64encode: (str?: string | undefined, encoding?: string | undefined) => string;
+export declare const hexToBase64: (hex: string) => string;
+export declare const textualParameterFunctions: {
+    __usd: BasicParameterFunction;
+    __eq: BasicParameterFunction;
+    __neq: BasicParameterFunction;
+    __eqi: BasicParameterFunction;
+    __neqi: BasicParameterFunction;
+    __to_number: BasicParameterFunction;
+    __matches: BasicParameterFunction;
+    __replace: BasicParameterFunction;
+    __replace_all: BasicParameterFunction;
+    __array_matches: BasicParameterFunction;
+    __delimited_list_includes: BasicParameterFunction;
+    __list_includes: BasicParameterFunction;
+    __array_pluck: BasicParameterFunction;
+    __array_in_range: BasicParameterFunction;
+    __array_includes: BasicParameterFunction;
+    __array_sum: BasicParameterFunction;
+    __array_sort: BasicParameterFunction;
+    __array_sort_numbers: BasicParameterFunction;
+    __array_is_unique: BasicParameterFunction;
+    __array_missing_element: BasicParameterFunction;
+    __sequence_array: BasicParameterFunction;
+    __contains: BasicParameterFunction;
+    __containsi: BasicParameterFunction;
+    __is_uuid: BasicParameterFunction;
+    __is_number: BasicParameterFunction;
+    __length: BasicParameterFunction;
+    __array_length: BasicParameterFunction;
+    __escape_regexp: BasicParameterFunction;
+    __escape_quotes: BasicParameterFunction;
+    __encode_url: BasicParameterFunction;
+    __decode_url: BasicParameterFunction;
+    __decode_base64: BasicParameterFunction;
+    __encode_base64: BasicParameterFunction;
+    __hex_to_base64: BasicParameterFunction;
+    __lower: BasicParameterFunction;
+    __upper: BasicParameterFunction;
+    __pad_start: BasicParameterFunction;
+    __if_then_else: BasicParameterFunction;
+    __switch: BasicParameterFunction;
+    __switchi: BasicParameterFunction;
+    __pick: BasicParameterFunction;
+    __pick_random: BasicParameterFunction;
+    __sha1: BasicParameterFunction;
+    __sha256: BasicParameterFunction;
+    __hmacSha1: BasicParameterFunction;
+    __hmacSha256: BasicParameterFunction;
+    __riskifiedHmac: BasicParameterFunction;
+    __split_pick: BasicParameterFunction;
+    __slice: BasicParameterFunction;
+    __regexp: BasicParameterFunction;
+    __json_keys: BasicParameterFunction;
+    __jsonpath_keys: BasicParameterFunction;
+    __jsonpath: BasicParameterFunction;
+    __jsonpath_all: BasicParameterFunction;
+    __jsonpath_apply: BasicParameterFunction;
+    __jsonschema: BasicParameterFunction;
+    __jquery: BasicParameterFunction;
+    __jquery_xml: BasicParameterFunction;
+    __now: BasicParameterFunction;
+    __now_ms: BasicParameterFunction;
+    __now_iso: BasicParameterFunction;
+    __date_iso: BasicParameterFunction;
+    __formatted_date: BasicParameterFunction;
+    __aws_cognito_get_srp: BasicParameterFunction;
+    __aws_cognito_get_signature: BasicParameterFunction;
+    __aws_cognito_get_now_timestamp: BasicParameterFunction;
+};