@beecode/msh-util 2.0.0-alpha → 2.0.0

package/lib/array-util.d.ts

@@ -0,0 +1,23 @@
+export declare const arrayUtil: {
+    /**
+     * Check if array element is not empty
+     * @template T
+     * @param {T | null | undefined} value
+     * @return {value is T}
+     * @example
+     * const notEmptyArray = [0, 1, 2, null, undefined, ''].filter(arrayUtil.notEmpty)
+     * console.log(notEmptyArray)// [0, 1, 2, '']
+     */
+    notEmpty: <T>(value: T | null | undefined) => value is T;
+    /**
+     * Check if array element is not falsy
+     * @template T
+     * @param {T | null | undefined} value
+     * @return {value is T}
+     * @example
+     * const notFalsyArray = [0, 1, 2, null, undefined, ''].filter(arrayUtil.notFalsy)
+     * console.log(notFalsyArray)// [1, 2]
+     */
+    notFalsy: <T_1>(value: T_1 | null | undefined) => value is T_1;
+};
+//# sourceMappingURL=array-util.d.ts.map

package/lib/array-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-util.d.ts","sourceRoot":"","sources":["../src/array-util.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;IACrB;;;;;;;;OAQG;yBACkB,CAAC,GAAG,IAAI,GAAG,SAAS;IAGzC;;;;;;;;OAQG;;CAIH,CAAA"}

package/lib/array-util.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayUtil = void 0;
+var arrayUtil = exports.arrayUtil = {
+  /**
+   * Check if array element is not empty
+   * @template T
+   * @param {T | null | undefined} value
+   * @return {value is T}
+   * @example
+   * const notEmptyArray = [0, 1, 2, null, undefined, ''].filter(arrayUtil.notEmpty)
+   * console.log(notEmptyArray)// [0, 1, 2, '']
+   */
+  notEmpty: function notEmpty(value) {
+    return value !== null && value !== undefined;
+  },
+  /**
+   * Check if array element is not falsy
+   * @template T
+   * @param {T | null | undefined} value
+   * @return {value is T}
+   * @example
+   * const notFalsyArray = [0, 1, 2, null, undefined, ''].filter(arrayUtil.notFalsy)
+   * console.log(notFalsyArray)// [1, 2]
+   */
+  notFalsy: function notFalsy(value) {
+    return !!value;
+  }
+};

package/lib/class-factory-pattern.d.ts

@@ -0,0 +1,25 @@
+export type ClassType<T = object> = new (...args: T extends {
+    new (...args: infer P): any;
+} ? P : never[]) => T;
+/**
+ * This is a wrapper that easily converts class constructor call (`new className(..constructorParams)`) into function call (`classNameFactory(..constructorParams)`)
+ * @param {C} classType
+ * @template C
+ * @return {(...args: ConstructorParameters<C>) => InstanceType<C>}
+ * @example
+ * export class SomeClass {
+ *   protected _a: string
+ *
+ *   constructor(params: { a: string }) {
+ *     const { a } = params
+ *     this._a = a
+ *   }
+ * }
+ *
+ * export const someClassFactory = classFactoryPattern(SomeClass)
+ *
+ * // using
+ * const someClassInstance = someClassFactory({ a: 'test' })
+ */
+export declare const classFactoryPattern: <C extends ClassType<object>>(classType: C) => (...args: ConstructorParameters<C>) => InstanceType<C>;
+//# sourceMappingURL=class-factory-pattern.d.ts.map

package/lib/class-factory-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-factory-pattern.d.ts","sourceRoot":"","sources":["../src/class-factory-pattern.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,SAAS,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,CAAC,SAAS;IAAE,KAAK,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,GAAG,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,CAAA;AAE/G;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB,2CACpB,CAAC,eACC,sBAAsB,CAAC,CAAC,KAAK,aAAa,CAAC,CAIxD,CAAA"}

package/lib/class-factory-pattern.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.classFactoryPattern = void 0;
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * This is a wrapper that easily converts class constructor call (`new className(..constructorParams)`) into function call (`classNameFactory(..constructorParams)`)
+ * @param {C} classType
+ * @template C
+ * @return {(...args: ConstructorParameters<C>) => InstanceType<C>}
+ * @example
+ * export class SomeClass {
+ *   protected _a: string
+ *
+ *   constructor(params: { a: string }) {
+ *     const { a } = params
+ *     this._a = a
+ *   }
+ * }
+ *
+ * export const someClassFactory = classFactoryPattern(SomeClass)
+ *
+ * // using
+ * const someClassInstance = someClassFactory({ a: 'test' })
+ */
+var classFactoryPattern = exports.classFactoryPattern = function classFactoryPattern(classType) {
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _construct(classType, args);
+  };
+};

package/lib/express/error-handler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Wrap async express http request end return promise or call next on catch
+ * @param _target
+ * @param _key
+ * @param descriptor
+ * @example
+ * export class RootController {
+ *  /@expressErrorHandler
+ *   async login(req: Request, res: Response): Promise<void> {
+ *     const { username, password } = validationUtil().sanitize(req.body, postLoginBodySchema)
+ *     const result = await authorizationUseCase.login({ username, password })
+ *     res.json(result)
+ *   }
+ * }
+ */
+export declare const expressErrorHandler: (_target: any, _key: string, descriptor: TypedPropertyDescriptor<any>) => any;
+//# sourceMappingURL=error-handler.d.ts.map

package/lib/express/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../src/express/error-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,mBAAmB,YAAa,GAAG,QAAQ,MAAM,cAAc,wBAAwB,GAAG,CAAC,KAAG,GAU1G,CAAA"}

package/lib/express/error-handler.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.expressErrorHandler = void 0;
+/**
+ * Wrap async express http request end return promise or call next on catch
+ * @param _target
+ * @param _key
+ * @param descriptor
+ * @example
+ * export class RootController {
+ *  /@expressErrorHandler
+ *   async login(req: Request, res: Response): Promise<void> {
+ *     const { username, password } = validationUtil().sanitize(req.body, postLoginBodySchema)
+ *     const result = await authorizationUseCase.login({ username, password })
+ *     res.json(result)
+ *   }
+ * }
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var expressErrorHandler = exports.expressErrorHandler = function expressErrorHandler(_target, _key, descriptor) {
+  var originalMethod = descriptor.value;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  descriptor.value = function () {
+    var next = arguments[2]; // eslint-disable-line prefer-rest-params
+
+    return Promise.resolve(originalMethod.apply(this, arguments))["catch"](next); // eslint-disable-line prefer-rest-params
+  };
+  return descriptor;
+};

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export { expressErrorHandler } from './express/error-handler';
+export { SingletonAsync } from './singleton/async';
+export { singletonPattern } from './singleton/pattern';
+export { classFactoryPattern } from './class-factory-pattern';
+export type { ClassType } from './class-factory-pattern';
+export { ErrorWithPayload, JoiUtil } from './joi-util';
+export { memoizeFactory } from './memoize-factory';
+export { ObjectUtil } from './object-util';
+export type { ObjectType } from './object-util';
+export { regexUtil } from './regex-util';
+export { SingleThresholdPromise } from './single-threshold-promise';
+export { stringUtil } from './string-util';
+export { DurationUnit, TimeUtil } from './time-util';
+export type { DurationUnitType } from './time-util';
+export { timeout } from './timeout';
+export { typeUtil } from './type-util';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAEhE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAEhE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEzD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAEtE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEvD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/lib/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DurationUnit", {
+  enumerable: true,
+  get: function get() {
+    return _timeUtil.DurationUnit;
+  }
+});
+Object.defineProperty(exports, "ErrorWithPayload", {
+  enumerable: true,
+  get: function get() {
+    return _joiUtil.ErrorWithPayload;
+  }
+});
+Object.defineProperty(exports, "JoiUtil", {
+  enumerable: true,
+  get: function get() {
+    return _joiUtil.JoiUtil;
+  }
+});
+Object.defineProperty(exports, "ObjectUtil", {
+  enumerable: true,
+  get: function get() {
+    return _objectUtil.ObjectUtil;
+  }
+});
+Object.defineProperty(exports, "SingleThresholdPromise", {
+  enumerable: true,
+  get: function get() {
+    return _singleThresholdPromise.SingleThresholdPromise;
+  }
+});
+Object.defineProperty(exports, "SingletonAsync", {
+  enumerable: true,
+  get: function get() {
+    return _async.SingletonAsync;
+  }
+});
+Object.defineProperty(exports, "TimeUtil", {
+  enumerable: true,
+  get: function get() {
+    return _timeUtil.TimeUtil;
+  }
+});
+Object.defineProperty(exports, "classFactoryPattern", {
+  enumerable: true,
+  get: function get() {
+    return _classFactoryPattern.classFactoryPattern;
+  }
+});
+Object.defineProperty(exports, "expressErrorHandler", {
+  enumerable: true,
+  get: function get() {
+    return _errorHandler.expressErrorHandler;
+  }
+});
+Object.defineProperty(exports, "memoizeFactory", {
+  enumerable: true,
+  get: function get() {
+    return _memoizeFactory.memoizeFactory;
+  }
+});
+Object.defineProperty(exports, "regexUtil", {
+  enumerable: true,
+  get: function get() {
+    return _regexUtil.regexUtil;
+  }
+});
+Object.defineProperty(exports, "singletonPattern", {
+  enumerable: true,
+  get: function get() {
+    return _pattern.singletonPattern;
+  }
+});
+Object.defineProperty(exports, "stringUtil", {
+  enumerable: true,
+  get: function get() {
+    return _stringUtil.stringUtil;
+  }
+});
+Object.defineProperty(exports, "timeout", {
+  enumerable: true,
+  get: function get() {
+    return _timeout.timeout;
+  }
+});
+Object.defineProperty(exports, "typeUtil", {
+  enumerable: true,
+  get: function get() {
+    return _typeUtil.typeUtil;
+  }
+});
+var _errorHandler = require("./express/error-handler");
+var _async = require("./singleton/async");
+var _pattern = require("./singleton/pattern");
+var _classFactoryPattern = require("./class-factory-pattern");
+var _joiUtil = require("./joi-util");
+var _memoizeFactory = require("./memoize-factory");
+var _objectUtil = require("./object-util");
+var _regexUtil = require("./regex-util");
+var _singleThresholdPromise = require("./single-threshold-promise");
+var _stringUtil = require("./string-util");
+var _timeUtil = require("./time-util");
+var _timeout = require("./timeout");
+var _typeUtil = require("./type-util");

package/lib/joi-util.d.ts

@@ -0,0 +1,47 @@
+import { ObjectSchema, Schema, ValidationOptions } from 'joi';
+export declare class ErrorWithPayload<T> extends Error {
+    payload: T;
+    constructor(message: string, payload: T);
+}
+/**
+ * This is a simple wrapper around Joi validation with two functions exposed validate and sanitize. If object is not valid function throws an error.
+ * @example
+ * type SomeType = {
+ *   a: string
+ *   b: number
+ * }
+ * const someSchema = Joi.object<SomeType>().keys({
+ *   a: Joi.string().required(),
+ *   b: Joi.number().required(),
+ * }).required()
+ *
+ * const joiUtil = new JoiUtil()
+ *
+ * // using
+ * const invalidObject = joiUtil.validate({}, someSchema) // validate throws an error
+ * const validObject = joiUtil.validate({ a: 'a', b: 1 }, someSchema)
+ */
+export declare class JoiUtil {
+    /**
+     * Validate and clean object
+     * @template T
+     * @template Joi
+     * @param {any} objectToValidate
+     * @param {Joi.Schema | Joi.ObjectSchema<T>} schema
+     * @param {validationOptions} [validationOptions]
+     * @returns {T} expected object after validation
+     */
+    sanitize<T>(objectToValidate: any, schema: Schema | ObjectSchema<T>, validationOptions?: ValidationOptions): T;
+    /**
+     * Only validate properties specified in validation schema
+     * @template T
+     * @template Joi
+     * @param {any} objectToValidate
+     * @param {Joi.Schema | Joi.ObjectSchema<T>} schema
+     * @param {validationOptions} [validationOptions]
+     * @returns {T} expected object after validation
+     */
+    validate<T>(objectToValidate: any, schema: Schema | ObjectSchema<T>, validationOptions?: ValidationOptions): T;
+    protected _validate<T>(objectToValidate: any, schema: Schema | ObjectSchema<T>, validationOptions?: ValidationOptions): T;
+}
+//# sourceMappingURL=joi-util.d.ts.map

package/lib/joi-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joi-util.d.ts","sourceRoot":"","sources":["../src/joi-util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,CAAA;AAE7D,qBAAa,gBAAgB,CAAC,CAAC,CAAE,SAAQ,KAAK;IAC7C,OAAO,EAAE,CAAC,CAAA;gBAEE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;CAIvC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAO;IACnB;;;;;;;;OAQG;IAEH,QAAQ,CAAC,CAAC,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,CAAC;IAI9G;;;;;;;;OAQG;IAEH,QAAQ,CAAC,CAAC,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,CAAC;IAK9G,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,CAAC;CAQzH"}

package/lib/joi-util.js

@@ -0,0 +1,107 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JoiUtil = exports.ErrorWithPayload = void 0;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var ErrorWithPayload = exports.ErrorWithPayload = /*#__PURE__*/function (_Error) {
+  function ErrorWithPayload(message, payload) {
+    var _this;
+    _classCallCheck(this, ErrorWithPayload);
+    _this = _callSuper(this, ErrorWithPayload, [message]);
+    _this.payload = payload;
+    return _this;
+  }
+  _inherits(ErrorWithPayload, _Error);
+  return _createClass(ErrorWithPayload);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * This is a simple wrapper around Joi validation with two functions exposed validate and sanitize. If object is not valid function throws an error.
+ * @example
+ * type SomeType = {
+ *   a: string
+ *   b: number
+ * }
+ * const someSchema = Joi.object<SomeType>().keys({
+ *   a: Joi.string().required(),
+ *   b: Joi.number().required(),
+ * }).required()
+ *
+ * const joiUtil = new JoiUtil()
+ *
+ * // using
+ * const invalidObject = joiUtil.validate({}, someSchema) // validate throws an error
+ * const validObject = joiUtil.validate({ a: 'a', b: 1 }, someSchema)
+ */
+var JoiUtil = exports.JoiUtil = /*#__PURE__*/function () {
+  function JoiUtil() {
+    _classCallCheck(this, JoiUtil);
+  }
+  return _createClass(JoiUtil, [{
+    key: "sanitize",
+    value:
+    /**
+     * Validate and clean object
+     * @template T
+     * @template Joi
+     * @param {any} objectToValidate
+     * @param {Joi.Schema | Joi.ObjectSchema<T>} schema
+     * @param {validationOptions} [validationOptions]
+     * @returns {T} expected object after validation
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function sanitize(objectToValidate, schema, validationOptions) {
+      return this._validate(objectToValidate, schema, _objectSpread(_objectSpread({}, validationOptions), {}, {
+        stripUnknown: true
+      }));
+    }
+
+    /**
+     * Only validate properties specified in validation schema
+     * @template T
+     * @template Joi
+     * @param {any} objectToValidate
+     * @param {Joi.Schema | Joi.ObjectSchema<T>} schema
+     * @param {validationOptions} [validationOptions]
+     * @returns {T} expected object after validation
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {
+    key: "validate",
+    value: function validate(objectToValidate, schema, validationOptions) {
+      return this._validate(objectToValidate, schema, validationOptions);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {
+    key: "_validate",
+    value: function _validate(objectToValidate, schema, validationOptions) {
+      var _schema$validate = schema.validate(objectToValidate, validationOptions),
+        validationError = _schema$validate.error,
+        value = _schema$validate.value;
+      if (validationError) {
+        throw new ErrorWithPayload(validationError.message.split('"').join("'"), validationError);
+      }
+      return value;
+    }
+  }]);
+}();

package/lib/memoize-factory.d.ts

@@ -0,0 +1,16 @@
+export type AnyFunction<T> = (...args: any[]) => T;
+/**
+ * This is a simple implementation of memoize function that caches result against the parameter passed that are passed to the
+ * function so it never runs the same calculation twice.
+ * @template F
+ * @template R
+ * @param {F} factoryFn
+ * @return {F: AnyFunction<R>}
+ * @example
+ * export const sumTwoNumbersMemoize = memoizeFactory((a:number, b:number): number => a + b)
+ *
+ * // using
+ * sumTwoNumbersMemoize(5 + 10) // 15
+ */
+export declare const memoizeFactory: <F extends AnyFunction<R>, R>(factoryFn: F) => F;
+//# sourceMappingURL=memoize-factory.d.ts.map

package/lib/memoize-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize-factory.d.ts","sourceRoot":"","sources":["../src/memoize-factory.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;AAElD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,2CAA4C,CAAC,KAAG,CAW1E,CAAA"}

package/lib/memoize-factory.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.memoizeFactory = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * This is a simple implementation of memoize function that caches result against the parameter passed that are passed to the
+ * function so it never runs the same calculation twice.
+ * @template F
+ * @template R
+ * @param {F} factoryFn
+ * @return {F: AnyFunction<R>}
+ * @example
+ * export const sumTwoNumbersMemoize = memoizeFactory((a:number, b:number): number => a + b)
+ *
+ * // using
+ * sumTwoNumbersMemoize(5 + 10) // 15
+ */
+var memoizeFactory = exports.memoizeFactory = function memoizeFactory(factoryFn) {
+  var cache = {};
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var key = JSON.stringify(args);
+    if (key in cache) {
+      return cache[key];
+    }
+    return cache[key] = factoryFn.apply(void 0, args);
+  };
+};

package/lib/object-util.d.ts

@@ -0,0 +1,72 @@
+export type ObjectType = Record<string, any>;
+export declare class ObjectUtil {
+    /**
+     * Deep clone object. Returned object will have no references to the object passed through params
+     * @template T
+     * @param {T} objectToClone
+     * @return {T}
+     */
+    deepClone<T extends ObjectType>(objectToClone: T): T;
+    /**
+     * Pick only properties from the property list. It is only allowed to pick properties from the first level
+     * @template T
+     * @template L
+     * @param {T} obj
+     * @param {L[]} keyList
+     * @return {Pick<T, L>}
+     */
+    pickByList<T extends object, L extends keyof T>(obj: T, keyList: (L | string)[]): Pick<T, L>;
+    /**
+     * Pick objects properties using keys from the second object.
+     * @template T
+     * @template L
+     * @param {T} obj
+     * @param {Partial<T>} objWithPickKeys
+     * @return {Pick<T, L>}
+     */
+    pickByObjectKeys<T extends object, L extends keyof T>(obj: T, objWithPickKeys: Partial<T> | ObjectType): Pick<T, L>;
+    /**
+     * This function will do stringify deeper that JSON.stringify.
+     * @param {any} entity - entity thant needs to be stringify
+     * @param {object} [options] - available options
+     * @param {boolean} [options.isSortable=false] - if object property should be sorted
+     * @param {boolean} [options.isPrettyPrinted=false] - if object and array properties should be printed in a new row
+     * @param {number} [options.prettyPrintCompactLevel=0] - if pretty print is on define the level of deepest children that are not
+     * going to be pretty. It doesn't matter if the siblings doesn't have the same depth.
+     * @return {string} - strung result
+     * @example
+     * console.log(new ObjectUtil().deepStringify(null)) // 'null'
+     * console.log(new ObjectUtil().deepStringify(undefined)) // 'undefined'
+     * console.log(new ObjectUtil().deepStringify({ a: 1 })) // '{\n\ta: 1\n}'
+     * // `{
+     * //   a:1
+     * // }`
+     * console.log(new ObjectUtil().deepStringify({ b: 1, a: 2 }, {isSorted:true, compact: true})) // { a: 2, b: 1 }
+     */
+    deepStringify(entity: any, options?: {
+        isSorted?: boolean;
+        isPrettyPrinted?: boolean;
+        prettyPrintCompactLevel?: number;
+    }): string;
+    protected _deepStringifyCompact(params: {
+        isPrettyPrinted: boolean;
+        prettyPrintCompactLevel: number;
+    }): number | boolean;
+    /**
+     * We are converting objects to string (or null or undefined) and comparing if the result is equal
+     * @param a
+     * @param b
+     * @return {boolean}
+     */
+    deepEqual(a: any, b: any): boolean;
+    /**
+     * This function is going to convert any null to undefined in the object that is passed to it.
+     * @template T
+     * @param {T} objectWithNulls
+     * @return {T}
+     * @example
+     * console.log(new ObjectUtil().deepNullToUndefined({ a: null, b: { c: null } })) // { a: undefined, b: { c: undefined } }
+     */
+    deepNullToUndefined<T extends ObjectType>(objectWithNulls: T): T;
+}
+//# sourceMappingURL=object-util.d.ts.map

package/lib/object-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-util.d.ts","sourceRoot":"","sources":["../src/object-util.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAE5C,qBAAa,UAAU;IACtB;;;;;OAKG;IACH,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,aAAa,EAAE,CAAC,GAAG,CAAC;IAIpD;;;;;;;OAOG;IACH,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAa5F;;;;;;;OAOG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAMnH;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CAEZ,MAAM,EAAE,GAAG,EACX,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;KAAE,GAC3F,MAAM;IAeT,SAAS,CAAC,qBAAqB,CAAC,MAAM,EAAE;QAAE,eAAe,EAAE,OAAO,CAAC;QAAC,uBAAuB,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,GAAG,OAAO;IAUxH;;;;;OAKG;IAEH,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO;IAIlC;;;;;;;OAOG;IACH,mBAAmB,CAAC,CAAC,SAAS,UAAU,EAAE,eAAe,EAAE,CAAC,GAAG,CAAC;CAehE"}