@beecode/msh-util 1.2.1 → 2.0.0

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/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)
-	})
-})