@beecode/msh-util 1.2.1 → 2.0.0-alpha

package/src/array-util.test.ts

@@ -1,50 +0,0 @@
-import { arrayUtil } from 'src/array-util'
-
-describe('arrayUtil', () => {
-	describe('notEmpty', () => {
-		it.each([
-			[
-				[1, 2, undefined, 4, null, 5],
-				[1, 2, 4, 5],
-			],
-			[
-				['', 0],
-				['', 0],
-			],
-			[[undefined, null], []],
-			[[undefined, 4, null], [4]],
-			[
-				[[1], [2], [undefined], [4], [null], [5]],
-				[[1], [2], [undefined], [4], [null], [5]],
-			],
-			[
-				[{ a: 1 }, { a: 2 }, { a: undefined }, { a: 4 }, { a: null }, { a: 5 }],
-				[{ a: 1 }, { a: 2 }, { a: undefined }, { a: 4 }, { a: null }, { a: 5 }],
-			],
-		])('%#. should filter not empty values from array %s to be %s', (arr: any, expected) => {
-			expect(arr.filter(arrayUtil.notEmpty)).toEqual(expected)
-		})
-	})
-
-	describe('notFalsy', () => {
-		it.each([
-			[
-				[1, 2, undefined, 4, null, 5],
-				[1, 2, 4, 5],
-			],
-			[['', 0], []],
-			[[undefined, null], []],
-			[[undefined, 4, null], [4]],
-			[
-				[[1], [2], [undefined], [4], [null], [5]],
-				[[1], [2], [undefined], [4], [null], [5]],
-			],
-			[
-				[{ a: 1 }, { a: 2 }, { a: undefined }, { a: 4 }, { a: null }, { a: 5 }],
-				[{ a: 1 }, { a: 2 }, { a: undefined }, { a: 4 }, { a: null }, { a: 5 }],
-			],
-		])('%#. should filter not empty values from array %s to be %s', (arr: any, expected) => {
-			expect(arr.filter(arrayUtil.notFalsy)).toEqual(expected)
-		})
-	})
-})

package/src/array-util.ts

@@ -1,26 +0,0 @@
-export 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 => {
-		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: <T>(value: T | null | undefined): value is T => {
-		return !!value
-	},
-}

package/src/class-factory-pattern.test.ts

@@ -1,39 +0,0 @@
-import { classFactoryPattern } from 'src/class-factory-pattern'
-
-describe('factoryPattern', () => {
-	const fakeClassMock = jest.fn()
-
-	beforeEach(() => {
-		fakeClassMock.mockImplementation((a: string) => {
-			return { a }
-		})
-	})
-
-	afterEach(() => jest.resetAllMocks())
-
-	it('should return result from factory function', () => {
-		const expectedAValue = 'test'
-		const factoryPatternImplementation = classFactoryPattern(fakeClassMock)
-		expect(fakeClassMock).not.toHaveBeenCalled()
-		const result = factoryPatternImplementation(expectedAValue)
-		expect(fakeClassMock).toHaveBeenCalledTimes(1)
-		expect(result.a).toEqual(expectedAValue)
-	})
-
-	it('should call factory function every time the factory implementation is called', () => {
-		const expectedAValue = 'test'
-		const factoryPatternImplementation = classFactoryPattern(fakeClassMock)
-		expect(fakeClassMock).not.toHaveBeenCalled()
-		const result1 = factoryPatternImplementation(expectedAValue)
-		expect(fakeClassMock).toHaveBeenCalledTimes(1)
-		expect(result1.a).toEqual(expectedAValue)
-
-		const result2 = factoryPatternImplementation(expectedAValue)
-		expect(fakeClassMock).toHaveBeenCalledTimes(2)
-		expect(result2.a).toEqual(expectedAValue)
-
-		const result3 = factoryPatternImplementation(expectedAValue)
-		expect(fakeClassMock).toHaveBeenCalledTimes(3)
-		expect(result3.a).toEqual(expectedAValue)
-	})
-})

package/src/class-factory-pattern.ts

@@ -1,29 +0,0 @@
-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 const classFactoryPattern = <C extends ClassType>(
-	classType: C
-): ((...args: ConstructorParameters<C>) => InstanceType<C>) => {
-	return (...args: ConstructorParameters<C>): InstanceType<C> => {
-		return new classType(...args) as InstanceType<C>
-	}
-}

package/src/express/error-handler.test.ts

@@ -1,44 +0,0 @@
-import { expressErrorHandler } from 'src/express/error-handler'
-
-describe('expressErrorHandler', () => {
-	const fake_fn = jest.fn()
-	const fake_req = jest.fn()
-	const fake_res = jest.fn()
-	const fake_next = jest.fn()
-
-	class FakeExpressController {
-		@expressErrorHandler
-		async login(_req: any, _res: any, _next: any): Promise<any> {
-			return await fake_fn()
-		}
-	}
-	const fakeExpressControllerInstance = new FakeExpressController()
-
-	afterEach(() => jest.resetAllMocks())
-
-	it('should call next with error if async function throws error', async () => {
-		const error = new Error()
-		fake_fn.mockRejectedValue(error)
-
-		await fakeExpressControllerInstance.login(fake_req, fake_res, fake_next)
-
-		expect(fake_fn).toHaveBeenCalledTimes(1)
-		expect(fake_req).not.toHaveBeenCalled()
-		expect(fake_res).not.toHaveBeenCalled()
-		expect(fake_next).toHaveBeenCalledTimes(1)
-		expect(fake_next).toHaveBeenCalledOnceWith(error)
-	})
-
-	it('should work as usual if async function resolves promise', async () => {
-		const expected = { successful: true }
-		fake_fn.mockResolvedValue(expected)
-
-		const result = await fakeExpressControllerInstance.login(fake_req, fake_res, fake_next)
-
-		expect(fake_fn).toHaveBeenCalledTimes(1)
-		expect(fake_req).not.toHaveBeenCalled()
-		expect(fake_res).not.toHaveBeenCalled()
-		expect(fake_next).not.toHaveBeenCalled()
-		expect(result).toBe(expected)
-	})
-})

package/src/express/error-handler.ts

@@ -1,25 +0,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)
- *   }
- * }
- */
-export const expressErrorHandler = (_target: any, _key: string, descriptor: TypedPropertyDescriptor<any>): any => {
-	const originalMethod = descriptor.value
-	descriptor.value = function (): any {
-		const 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/src/index.ts

@@ -1,25 +0,0 @@
-export * from 'src/express/error-handler'
-
-export * from 'src/singleton/async'
-
-export * from 'src/singleton/pattern'
-
-export * from 'src/class-factory-pattern'
-
-export * from 'src/joi-util'
-
-export * from 'src/memoize-factory'
-
-export * from 'src/object-util'
-
-export * from 'src/regex-util'
-
-export * from 'src/single-threshold-promise'
-
-export * from 'src/string-util'
-
-export * from 'src/time-util'
-
-export * from 'src/timeout'
-
-export * from 'src/type-util'

package/src/joi-util.test.ts

@@ -1,192 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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
-}