@beecode/msh-util 1.2.0 → 1.2.1

package/src/joi-util.test.ts

@@ -0,0 +1,192 @@
+import Joi from 'joi'
+import { JoiUtil } from 'src/joi-util'
+
+describe('JoiUtil', () => {
+	const joiUtil = new JoiUtil()
+
+	const validObject = { a: 'string', b: true, c: 123, d: new Date() }
+	const invalidObject = { invalid: true }
+
+	const joiSchema = Joi.object().keys({
+		a: Joi.string().required(),
+		b: Joi.boolean().required(),
+		c: Joi.number().required(),
+		d: Joi.date().required(),
+	})
+
+	describe('sanitize', () => {
+		it('should return valid object', () => {
+			const result = joiUtil.sanitize(validObject, joiSchema)
+			expect(result).toEqual(validObject)
+		})
+		it('should return valid object and remove properties that are not defined in schema', () => {
+			const result = joiUtil.sanitize({ ...validObject, test: true }, joiSchema)
+			expect(result).toEqual(validObject)
+			expect(result.test).toBeUndefined()
+		})
+		it('should throw error if object is not valid, return first error', () => {
+			try {
+				joiUtil.sanitize(invalidObject, joiSchema)
+				expect.fail('test failed')
+			} catch (err: any) {
+				expect(err.message).toEqual("'a' is required")
+				expect(err.payload.details).toEqual([
+					{
+						context: {
+							key: 'a',
+							label: 'a',
+						},
+						message: '"a" is required',
+						path: ['a'],
+						type: 'any.required',
+					},
+				])
+			}
+		})
+		it('should throw error if object is not valid, return all errors', () => {
+			try {
+				joiUtil.sanitize(invalidObject, joiSchema, { abortEarly: false })
+				expect.fail('test failed')
+			} catch (err: any) {
+				expect(err.message).toEqual("'a' is required. 'b' is required. 'c' is required. 'd' is required")
+				expect(err.payload.details).toEqual([
+					{
+						context: {
+							key: 'a',
+							label: 'a',
+						},
+						message: '"a" is required',
+						path: ['a'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							key: 'b',
+							label: 'b',
+						},
+						message: '"b" is required',
+						path: ['b'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							key: 'c',
+							label: 'c',
+						},
+						message: '"c" is required',
+						path: ['c'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							key: 'd',
+							label: 'd',
+						},
+						message: '"d" is required',
+						path: ['d'],
+						type: 'any.required',
+					},
+				])
+			}
+		})
+	})
+
+	describe('validate', () => {
+		it('should return valid object', () => {
+			const result = joiUtil.validate(validObject, joiSchema)
+			expect(result).toEqual(validObject)
+		})
+
+		it('should throw error if there are unknown properties', () => {
+			try {
+				joiUtil.validate({ ...validObject, test: true }, joiSchema)
+				expect.fail('test failed')
+			} catch (err: any) {
+				expect(err.message).toEqual("'test' is not allowed")
+			}
+		})
+		it('should throw error if object is not valid, return first error', () => {
+			try {
+				joiUtil.validate(invalidObject, joiSchema)
+				expect.fail('test failed')
+			} catch (err: any) {
+				expect(err.message).toEqual("'a' is required")
+				expect(err.payload.details).toEqual([
+					{
+						context: {
+							key: 'a',
+							label: 'a',
+						},
+						message: '"a" is required',
+						path: ['a'],
+						type: 'any.required',
+					},
+				])
+			}
+		})
+		it('should throw error if object is not valid, return all errors', () => {
+			try {
+				joiUtil.validate(invalidObject, joiSchema, { abortEarly: false })
+				expect.fail('test failed')
+			} catch (err: any) {
+				expect(err.message).toEqual(
+					"'a' is required. 'b' is required. 'c' is required. 'd' is required. 'invalid' is not allowed"
+				)
+				expect(err.payload.details).toEqual([
+					{
+						context: {
+							key: 'a',
+							label: 'a',
+						},
+						message: '"a" is required',
+						path: ['a'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							key: 'b',
+							label: 'b',
+						},
+						message: '"b" is required',
+						path: ['b'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							key: 'c',
+							label: 'c',
+						},
+						message: '"c" is required',
+						path: ['c'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							key: 'd',
+							label: 'd',
+						},
+						message: '"d" is required',
+						path: ['d'],
+						type: 'any.required',
+					},
+					{
+						context: {
+							child: 'invalid',
+							key: 'invalid',
+							label: 'invalid',
+							value: true,
+						},
+						message: '"invalid" is not allowed',
+						path: ['invalid'],
+						type: 'object.unknown',
+					},
+				])
+			}
+		})
+
+		it('should allow unknown if flag is set and call logger with warn message', () => {
+			const result = joiUtil.validate({ ...validObject, unknownProp: 'test' }, joiSchema, { allowUnknown: true })
+			expect(result).toEqual({ ...validObject, unknownProp: 'test' })
+		})
+	})
+})

package/src/joi-util.ts

@@ -0,0 +1,65 @@
+import { ObjectSchema, Schema, ValidationOptions } from 'joi'
+
+export class ErrorWithPayload<T> extends Error {
+	payload: T
+
+	constructor(message: string, payload: T) {
+		super(message)
+		this.payload = payload
+	}
+}
+
+/**
+ * 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 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 {
+		return this._validate<T>(objectToValidate, schema, { ...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
+	 */
+	validate<T>(objectToValidate: any, schema: Schema | ObjectSchema<T>, validationOptions?: ValidationOptions): T {
+		return this._validate<T>(objectToValidate, schema, validationOptions)
+	}
+
+	protected _validate<T>(objectToValidate: any, schema: Schema | ObjectSchema<T>, validationOptions?: ValidationOptions): T {
+		const { error: validationError, value } = schema.validate(objectToValidate, validationOptions)
+		if (validationError) {
+			throw new ErrorWithPayload(validationError.message.split('"').join("'"), validationError)
+		}
+
+		return value as T
+	}
+}

package/src/memoize-factory.test.ts

@@ -0,0 +1,40 @@
+import { memoizeFactory } from 'src/memoize-factory'
+
+describe('memoizeFactory', () => {
+	const fake_factoryFn = jest.fn()
+
+	beforeEach(() => {
+		fake_factoryFn.mockImplementation((a: number, b: number): number => {
+			return a + b
+		})
+	})
+
+	afterEach(() => {
+		jest.resetAllMocks()
+	})
+
+	it('should only call factory function once if the same argument is passed', () => {
+		const memoizedImplementation = memoizeFactory(fake_factoryFn)
+		expect(fake_factoryFn).not.toHaveBeenCalled()
+
+		expect(memoizedImplementation(1, 2)).toEqual(3)
+		expect(fake_factoryFn).toHaveBeenCalledTimes(1)
+
+		expect(memoizedImplementation(1, 2)).toEqual(3)
+		expect(fake_factoryFn).toHaveBeenCalledTimes(1)
+	})
+
+	it('should call factory as many times as it is called if the arguments are different', () => {
+		const memoizedImplementation = memoizeFactory(fake_factoryFn)
+		expect(fake_factoryFn).not.toHaveBeenCalled()
+
+		expect(memoizedImplementation(1, 2)).toEqual(3)
+		expect(fake_factoryFn).toHaveBeenCalledTimes(1)
+
+		expect(memoizedImplementation(1, 3)).toEqual(4)
+		expect(fake_factoryFn).toHaveBeenCalledTimes(2)
+
+		expect(memoizedImplementation(1, 4)).toEqual(5)
+		expect(fake_factoryFn).toHaveBeenCalledTimes(3)
+	})
+})

package/src/memoize-factory.ts

@@ -0,0 +1,27 @@
+import { AnyFunction } from 'src/types/any-function'
+
+/**
+ * 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 const memoizeFactory = <F extends AnyFunction<R>, R>(factoryFn: F): F => {
+	const cache: { [k: string]: R } = {}
+
+	return ((...args: Parameters<F>): R => {
+		const key = JSON.stringify(args)
+		if (key in cache) {
+			return cache[key]
+		}
+
+		return (cache[key] = factoryFn(...args))
+	}) as F
+}

package/src/object-util.test.ts

@@ -0,0 +1,360 @@
+import { ObjectUtil } from 'src/object-util'
+
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+describe('objectUtil', () => {
+	const objectUtil = new ObjectUtil()
+
+	const everyType = {
+		number: 1,
+		decimal: 1.12345,
+		string: 'string',
+		undefined: undefined,
+		notANumber: NaN,
+		emptyObj: {},
+		date: new Date('2020-01-01'),
+		boolean: true,
+		nestedObject: { obj: 'test' },
+	}
+
+	const everyTypeReversed = {
+		nestedObject: { obj: 'test' },
+		boolean: true,
+		date: new Date('2020-01-01'),
+		emptyObj: {},
+		notANumber: NaN,
+		undefined: undefined,
+		string: 'string',
+		decimal: 1.12345,
+		number: 1,
+	}
+
+	describe('deepClone', () => {
+		it.each([
+			[{ test: 'string' }],
+			[{ deep: { test: 'string' } }],
+			[{ deeper: { deep: { test: 'string' } } }],
+			[everyType],
+			[{ deep: everyType }],
+			[{ deeper: { deep: everyType } }],
+		])('%#. should clone %j', (obj) => {
+			expect(objectUtil.deepClone(obj)).not.toBe(obj)
+		})
+	})
+
+	describe('pickByList', () => {
+		it.each([
+			[['a', 'b'], { a: 1, b: '2', c: 3 }, { a: 1, b: '2' }],
+			[['a', 'c'], { a: 1, b: '2', c: 3 }, { a: 1, c: 3 }],
+		])('%#. should pick only this properties [%s] from object %s and return object %s', (propList, obj, result) => {
+			expect(objectUtil.pickByList(obj, propList)).toEqual(result)
+		})
+	})
+
+	describe('pickByObjectKeys', () => {
+		it.each([
+			[
+				{ a: 1, b: '2', c: 3 },
+				{ a: '', b: '' },
+				{ a: 1, b: '2' },
+			],
+			[
+				{ a: 1, b: '2', c: 3 },
+				{ a: '', c: '' },
+				{ a: 1, c: 3 },
+			],
+		])('%#. should pick form this %s using keys from %s and return %s', (obj, objWithPickKeys, result) => {
+			expect(objectUtil.pickByObjectKeys(obj, objWithPickKeys)).toEqual(result)
+		})
+	})
+
+	describe('deepStringify', () => {
+		it.each([
+			[{}, '{}'],
+			[{ a: 1, b: 2 }, `{ a: 1, b: 2 }`],
+			[
+				everyType,
+				`{ boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined }`,
+			],
+			[
+				{ deep: everyType },
+				`{ deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } }`,
+			],
+			[
+				{ deeper: { deep: everyType } },
+				`{ deeper: { deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } } }`,
+			],
+		])('%#. should compare %j and sort with result %j', (value, expected) => {
+			expect(objectUtil.deepStringify(value, { isSorted: true })).toEqual(expected)
+		})
+
+		it.each([
+			[{ b: 2, a: 1 }, `{ a: 1, b: 2 }`],
+			[
+				everyType,
+				`{ boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined }`,
+			],
+			[
+				{ deep: everyType },
+				`{ deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } }`,
+			],
+			[
+				{ deeper: { deep: everyType } },
+				`{ deeper: { deep: { boolean: true, date: 2020-01-01T00:00:00.000Z, decimal: 1.12345, emptyObj: {}, nestedObject: { obj: 'test' }, notANumber: NaN, number: 1, string: 'string', undefined: undefined } } }`,
+			],
+		])('%#. should compare %j with result %j and not be equal because it is not sorted', (value, expected) => {
+			expect(objectUtil.deepStringify(value, { isSorted: true })).toEqual(expected)
+			expect(objectUtil.deepStringify(value)).not.toEqual(expected)
+		})
+
+		it.each([
+			[null, 'null'],
+			[undefined, 'undefined'],
+			[123, '123'],
+			[[123], `[ 123 ]`],
+			['test', "'test'"],
+			(() => {
+				const date = new Date()
+
+				return [date, date.toISOString()]
+			})(),
+		])('%#. should compare %j with result %j with compact enabled', (value, expected) => {
+			expect(objectUtil.deepStringify(value)).toEqual(expected)
+		})
+
+		it.each([
+			[['d', 'c', 'b', 'a'], `[ 'a', 'b', 'c', 'd' ]`, `[ 'd', 'c', 'b', 'a' ]`],
+			[{ a: ['d', 'c', 'b', 'a'] }, `{ a: [ 'a', 'b', 'c', 'd' ]`, `{ a: [ 'd', 'c', 'b', 'a' ] }`],
+		])('%# should not sort arrays', (arr, expectSorted, expectUnsorted) => {
+			expect(objectUtil.deepStringify(arr, { isSorted: true })).not.toEqual(expectSorted)
+			expect(objectUtil.deepStringify(arr, { isSorted: true })).toEqual(expectUnsorted)
+		})
+
+		it.each([
+			[
+				0,
+				`{
+  a: {
+    a1: {
+      a2: {
+        a3: {
+          a4: {
+            a5: 'level 5'
+          }
+        }
+      }
+    }
+  },
+  b: {
+    b1: {
+      b2: {
+        b3: {
+          b4: 'level 4'
+        }
+      }
+    }
+  },
+  c: [
+    'c0',
+    [
+      'c1',
+      [
+        'c2',
+        [
+          'c3',
+          [
+            'c4',
+            [
+              'c5'
+            ]
+          ]
+        ]
+      ]
+    ]
+  ]
+}`,
+			],
+			[
+				1,
+				`{
+  a: {
+    a1: {
+      a2: {
+        a3: {
+          a4: { a5: 'level 5' }
+        }
+      }
+    }
+  },
+  b: {
+    b1: {
+      b2: {
+        b3: { b4: 'level 4' }
+      }
+    }
+  },
+  c: [
+    'c0',
+    [
+      'c1',
+      [
+        'c2',
+        [
+          'c3',
+          [
+            'c4',
+            [ 'c5' ]
+          ]
+        ]
+      ]
+    ]
+  ]
+}`,
+			],
+			[
+				2,
+				`{
+  a: {
+    a1: {
+      a2: {
+        a3: { a4: { a5: 'level 5' } }
+      }
+    }
+  },
+  b: {
+    b1: {
+      b2: { b3: { b4: 'level 4' } }
+    }
+  },
+  c: [
+    'c0',
+    [
+      'c1',
+      [
+        'c2',
+        [
+          'c3',
+          [ 'c4', [ 'c5' ] ]
+        ]
+      ]
+    ]
+  ]
+}`,
+			],
+			[
+				3,
+				`{
+  a: {
+    a1: {
+      a2: { a3: { a4: { a5: 'level 5' } } }
+    }
+  },
+  b: {
+    b1: { b2: { b3: { b4: 'level 4' } } }
+  },
+  c: [
+    'c0',
+    [
+      'c1',
+      [
+        'c2',
+        [ 'c3', [ 'c4', [ 'c5' ] ] ]
+      ]
+    ]
+  ]
+}`,
+			],
+			[
+				4,
+				`{
+  a: {
+    a1: { a2: { a3: { a4: { a5: 'level 5' } } } }
+  },
+  b: { b1: { b2: { b3: { b4: 'level 4' } } } },
+  c: [
+    'c0',
+    [
+      'c1',
+      [ 'c2', [ 'c3', [ 'c4', [ 'c5' ] ] ] ]
+    ]
+  ]
+}`,
+			],
+			[
+				5,
+				`{
+  a: { a1: { a2: { a3: { a4: { a5: 'level 5' } } } } },
+  b: { b1: { b2: { b3: { b4: 'level 4' } } } },
+  c: [
+    'c0',
+    [ 'c1', [ 'c2', [ 'c3', [ 'c4', [ 'c5' ] ] ] ] ]
+  ]
+}`,
+			],
+			[
+				6,
+				`{
+  a: { a1: { a2: { a3: { a4: { a5: 'level 5' } } } } },
+  b: { b1: { b2: { b3: { b4: 'level 4' } } } },
+  c: [ 'c0', [ 'c1', [ 'c2', [ 'c3', [ 'c4', [ 'c5' ] ] ] ] ] ]
+}`,
+			],
+		])('%# should take object with 5 levels and compact it to level $s', (level, expected) => {
+			const obj = {
+				a: { a1: { a2: { a3: { a4: { a5: 'level 5' } } } } },
+				b: { b1: { b2: { b3: { b4: 'level 4' } } } },
+				c: ['c0', ['c1', ['c2', ['c3', ['c4', ['c5']]]]]],
+			}
+			expect(objectUtil.deepStringify(obj, { isPrettyPrinted: true, prettyPrintCompactLevel: level })).toEqual(expected)
+		})
+	})
+
+	describe('deepEqual', () => {
+		it.each([
+			[null, null],
+			[undefined, undefined],
+			[{}, {}],
+			[everyType, everyType],
+			[{ deep: everyType }, { deep: everyType }],
+			[{ deeper: { deep: everyType } }, { deeper: { deep: everyType } }],
+		])('%#. should be deep equal compare %j with result %j', (value, result) => {
+			expect(objectUtil.deepEqual(value, result)).toBeTruthy()
+		})
+
+		it.each([
+			[{}, { a: 1 }],
+			[everyType, { ...everyType, a: 1 }],
+			[{ deep: everyType }, { a: 1, deep: everyType }],
+			[{ deeper: { deep: everyType } }, { a: 1, deeper: { deep: everyType } }],
+		])('%#. should not deep equal compare %j with result %j', (value, result) => {
+			expect(objectUtil.deepEqual(value, result)).toBeFalsy()
+		})
+
+		it.each([
+			[
+				{ a: 1, b: 2 },
+				{ a: 1, b: 2 },
+			],
+			[
+				{ a: { a: 1, b: 2 }, b: everyType },
+				{ a: { a: 1, b: 2 }, b: everyTypeReversed },
+			],
+		])('%#. should be deep equal even if in different order compare %j with result %j', (value, result) => {
+			expect(objectUtil.deepEqual(value, result)).toBeTruthy()
+		})
+	})
+
+	describe('deepNullToUndefined', () => {
+		it.each([
+			[{ test: undefined }, { test: undefined }],
+			[{ test: null }, { test: undefined }],
+			[{ deep: { test: null } }, { deep: { test: undefined } }],
+			[{ deeper: { deep: { test: null } } }, { deeper: { deep: { test: undefined } } }],
+			[everyType, everyType],
+			[{ deep: everyType }, { deep: everyType }],
+			[{ deeper: { deep: everyType } }, { deeper: { deep: everyType } }],
+		])('%#. should convert null to undefined for %j', (withNulls, withUndefined) => {
+			expect(objectUtil.deepNullToUndefined(withNulls)).toEqual(withUndefined)
+		})
+	})
+})
+/* eslint-enable sort-keys-fix/sort-keys-fix */