@mhmdhammoud/meritt-utils 1.6.2 → 1.6.3

package/src/__tests__/formatter.test.ts

@@ -1,96 +0,0 @@
-import { Formatter } from '../lib'
-
-describe('Formatter', () => {
-	describe('toUpperFirst method', () => {
-		it('should format string with - and upper first letter', () => {
-			const formattedString = Formatter.toUpperFirst('hello world')
-			expect(formattedString).toBe('Hello-world')
-		})
-
-		it('should format string with spaces and upper first letter of every word', () => {
-			const formattedString = Formatter.toUpperFirst('hello_world+test')
-			expect(formattedString).toBe('Hello-world-test')
-		})
-
-		it('should throw an error for non-string input', () => {
-			expect(() => Formatter.toUpperFirst(123)).toThrowError(
-				'Provide a valid string'
-			)
-		})
-	})
-
-	describe('camelToKebab method', () => {
-		it('should convert camelCase to kebab-case', () => {
-			const kebabString = Formatter.camelToKebab('camelCaseString')
-			expect(kebabString).toBe('camel-case-string')
-		})
-
-		it('should handle spaces and underscores', () => {
-			const kebabString = Formatter.camelToKebab('hello World_with Spaces')
-			expect(kebabString).toBe('hello-world_with-spaces')
-		})
-
-		it('should throw an error for non-string input', () => {
-			expect(() => Formatter.camelToKebab(123)).toThrowError(
-				'Invalid input. Please provide a valid string.'
-			)
-		})
-	})
-
-	describe('obfuscate method', () => {
-		it('should obfuscate email address', () => {
-			const obfuscatedEmail = Formatter.obfuscate('johndoe@email.com')
-			expect(obfuscatedEmail).toMatch(/^jo.*@.*$/)
-		})
-
-		it('should throw an error for non-string input', () => {
-			//@ts-ignore
-			expect(() => Formatter.obfuscate(123)).toThrowError(
-				'Provide a valid string'
-			)
-		})
-
-		it('should throw an error for an invalid email address', () => {
-			expect(() => Formatter.obfuscate('invalid-email')).toThrowError(
-				'Provide a valid email address'
-			)
-		})
-	})
-
-	describe('toUpperTitle method', () => {
-		it('should capitalize first letter of each word and remove non-alphanumeric characters', () => {
-			const upperTitle = Formatter.toUpperTitle('this is34354345a---sentence')
-			expect(upperTitle).toBe('This Is A Sentence')
-		})
-
-		it('should throw an error for non-string input', () => {
-			expect(() => Formatter.toUpperTitle(123)).toThrowError(
-				'Provide a valid string'
-			)
-		})
-
-		it('should throw an error for empty string', () => {
-			expect(() => Formatter.toUpperTitle('')).toThrowError(
-				'Provide a valid string'
-			)
-		})
-	})
-
-	describe('slugify method', () => {
-		it('should generate a slug from the given string', () => {
-			const slug = Formatter.slugify('Hello World')
-			expect(slug).toBe('hello-world')
-		})
-
-		it('should handle special characters and spaces', () => {
-			const slug = Formatter.slugify('Special Characters % #$ & Space')
-			expect(slug).toBe('special-characters-space')
-		})
-
-		it('should throw an error for non-string input', () => {
-			expect(() => Formatter.slugify(123)).toThrowError(
-				'Provide a valid string'
-			)
-		})
-	})
-})

package/src/__tests__/logger.test.ts

@@ -1,122 +0,0 @@
-import Logger, { isValidLogLevel } from '../lib/logger'
-import { pino } from 'pino'
-
-jest.mock('pino')
-
-const LOGGER_NAME = 'logger-name'
-const PINO_DESTINATION = {}
-const PINO = {
-	info: jest.fn(),
-}
-
-describe('create logger wrapper', () => {
-	test('initially create & configure logger', () => {
-		//@ts-ignore
-		const mock_pino_destination = jest
-			.spyOn(pino, 'destination')
-			//@ts-ignore
-			.mockReturnValue(PINO_DESTINATION)
-		//@ts-ignore
-		const mock_pino = pino.mockReturnValue(PINO)
-
-		/** create logger */
-		const logger = new Logger(LOGGER_NAME)
-
-		expect(logger).toBeDefined()
-		expect(logger['_name']).toBe(LOGGER_NAME)
-		expect(mock_pino).toHaveBeenCalledTimes(1)
-		expect(mock_pino).toHaveBeenCalledWith(
-			{
-				level: 'info',
-				timestamp: expect.any(Function),
-			},
-			PINO_DESTINATION
-		)
-		expect(mock_pino_destination).toHaveBeenCalledWith({
-			minLength: 1024,
-			sync: true,
-		})
-	})
-	test('create repeatedly - stick to pino singleton', () => {
-		//@ts-ignore
-		jest.spyOn(pino, 'destination').mockReturnValue(PINO_DESTINATION)
-		//@ts-ignore
-		const mock_pino = pino.mockReturnValue(PINO)
-		new Logger(LOGGER_NAME)
-		expect(mock_pino).toHaveBeenCalledTimes(1)
-
-		/** create additional logger */
-		new Logger(LOGGER_NAME)
-		/** no new pino created */
-		expect(mock_pino).toHaveBeenCalledTimes(1)
-	})
-})
-describe('validate log level', () => {
-	test('throw on invalid log level', () => {
-		const INVALID_LOG_LEVEL = 'invalid-log-level'
-		expect(() => {
-			isValidLogLevel(INVALID_LOG_LEVEL)
-		}).toThrowError(
-			`Invalid log level "${INVALID_LOG_LEVEL}": only error, warn, info, debug, trace are valid.`
-		)
-	})
-})
-describe('route and format logs', () => {
-	const LOG_EVENT = {
-		code: 'code',
-		msg: 'message',
-	}
-	const DETAILS = {
-		key0: 'val0',
-		key1: 'val1',
-	}
-	test('log info with structured context (single object in context field)', () => {
-		//@ts-ignore
-		jest.spyOn(pino, 'destination').mockReturnValue(PINO_DESTINATION)
-		//@ts-ignore
-		pino.mockReturnValue(PINO)
-		const logger = new Logger(LOGGER_NAME)
-
-		logger.info(LOG_EVENT, DETAILS)
-
-		expect(PINO.info).toHaveBeenCalledWith(
-			expect.objectContaining({
-				component: LOGGER_NAME,
-				code: LOG_EVENT.code,
-				msg: LOG_EVENT.msg,
-				context: { key0: 'val0', key1: 'val1' },
-			})
-		)
-	})
-
-	test('remap reserved elastic field names in context', () => {
-		//@ts-ignore
-		jest.spyOn(pino, 'destination').mockReturnValue(PINO_DESTINATION)
-		//@ts-ignore
-		pino.mockReturnValue(PINO)
-		const logger = new Logger(LOGGER_NAME)
-
-		logger.info(LOG_EVENT, {
-			_id: 'abc123',
-			nested: {
-				_id: 'nested-1',
-				_index: 'bad-index',
-			},
-		})
-
-		// Context holds sanitized structure; reserved names remapped recursively
-		expect(PINO.info).toHaveBeenCalledWith(
-			expect.objectContaining({
-				context: expect.objectContaining({
-					mongo_id: 'abc123',
-					nested: { mongo_id: 'nested-1', es_index: 'bad-index' },
-				}),
-			})
-		)
-		expect(PINO.info).not.toHaveBeenCalledWith(
-			expect.objectContaining({
-				_id: expect.anything(),
-			})
-		)
-	})
-})

package/src/env.d.ts

@@ -1,9 +0,0 @@
-declare namespace NodeJS {
-	export interface ProcessEnv {
-		NODE_ENV: 'development' | 'production' | 'test' | 'local'
-		ELASTICSEARCH_NODE: string
-		ELASTICSEARCH_USERNAME: string
-		ELASTICSEARCH_PASSWORD: string
-		LOG_LEVEL: string
-	}
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './lib'

package/src/lib/colorful.ts

@@ -1,167 +0,0 @@
-/*
-	 Author : Mhmd Hammoud https://github.com/mhmdhammoud
-	 Date : 2024-01-20
-	 Description : Color adapter
-	 Version : 1.0
-*/
-class Colorful {
-	/**
-	 * @remarks
-	 *  Receives a color in RGB format and returns it in HEX format
-	 * @param color - Color in RGB format
-	 * @example
-	 * ```ts
-	 * const color = 'rgb(255, 255, 255)';
-	 * const hexColor = rgbToHex(color);
-	 * console.log(hexColor) // #ffffff
-	 * ```
-	 *
-	 * @returns Color in HEX format string
-	 */
-	rgbToHex = (color: string): string => {
-		const componentToHex = (c: any) => {
-			const hex = c.toString(16)
-			return hex.length == 1 ? '0' + hex : hex
-		}
-
-		const rgbaMatch = color.match(
-			/rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*((\d+\.)?\d+)\)/
-		)
-		const rgbMatch = color.match(/rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)/)
-
-		let redColor, greenColor, blueColor
-
-		if (rgbaMatch) {
-			redColor = parseInt(rgbaMatch[1], 10)
-			greenColor = parseInt(rgbaMatch[2], 10)
-			blueColor = parseInt(rgbaMatch[3], 10)
-		} else if (rgbMatch) {
-			redColor = parseInt(rgbMatch[1], 10)
-			greenColor = parseInt(rgbMatch[2], 10)
-			blueColor = parseInt(rgbMatch[3], 10)
-		} else {
-			// Both patterns failed to match
-			throw new Error(
-				`Invalid color format '${color}'. Please provide a valid RGB or RGBA color.`
-			)
-		}
-
-		const hexColor =
-			'#' +
-			componentToHex(redColor) +
-			componentToHex(greenColor) +
-			componentToHex(blueColor)
-
-		return hexColor
-	}
-
-	/**
-	 * @remarks
-	 *  Receives a color in HEX format and returns it in RGB format
-	 * @param hexColor - Color in HEX format
-	 * @example
-	 * ```ts
-	 * const hexColor = '#ffffff';
-	 * const rgbColor = hexToRgb(hexColor);
-	 * console.log(rgbColor) // 'rgb(255, 255, 255)'
-	 * ```
-	 *
-	 * @returns Color in RGB format string
-	 */
-	hexToRgb = (hexColor: string): string => {
-		const hex = hexColor.replace(/^#/, '')
-		const bigint = parseInt(hex, 16)
-		const red = (bigint >> 16) & 255
-		const green = (bigint >> 8) & 255
-		const blue = bigint & 255
-		return `rgb(${red}, ${green}, ${blue})`
-	}
-
-	/**
-	 * @remarks
-	 *  Checks whether a given HEX color is light or dark
-	 * @param hexColor - Color in HEX format
-	 * @example
-	 * ```ts
-	 * const hexColor = '#ffffff';
-	 * const isLight = isLightColor(hexColor);
-	 * console.log(isLight); // true or false
-	 * ```
-	 *
-	 * @returns True if the color is light, false if it is dark
-	 */
-	isLightColor = (color: string): boolean => {
-		// Remove spaces
-		const trimmedColor = color.replace(/\s/g, '')
-
-		// Check if the color is in RGBA format
-		const rgbaMatch = trimmedColor.match(
-			/^rgba\((\d+),(\d+),(\d+),(\d+(\.\d+)?)\)$/
-		)
-
-		if (rgbaMatch) {
-			// Extract RGB components from RGBA
-			const r = parseInt(rgbaMatch[1], 10)
-			const g = parseInt(rgbaMatch[2], 10)
-			const b = parseInt(rgbaMatch[3], 10)
-
-			// Calculate the relative luminance without considering alpha
-			const luminance = 0.299 * r + 0.587 * g + 0.114 * b
-
-			// You can adjust the threshold to your preference
-			const threshold = 128
-
-			// Determine whether the color is light or dark
-			return luminance > threshold
-		}
-
-		// Check if the color is in RGB format
-		const rgbMatch = trimmedColor.match(/^rgb\((\d+),(\d+),(\d+)\)$/)
-
-		if (rgbMatch) {
-			// Extract RGB components from RGB
-			const r = parseInt(rgbMatch[1], 10)
-			const g = parseInt(rgbMatch[2], 10)
-			const b = parseInt(rgbMatch[3], 10)
-
-			// Calculate the relative luminance of the color
-			// This formula gives more weight to green as the human eye is more sensitive to it
-			const luminance = 0.299 * r + 0.587 * g + 0.114 * b
-
-			// You can adjust the threshold to your preference
-			const threshold = 128
-
-			// Determine whether the color is light or dark
-			return luminance > threshold
-		}
-
-		// Remove the '#' character if present
-		const hexColor = trimmedColor.replace('#', '')
-
-		// Check if the hex color has a valid format
-		if (!/^[0-9A-Fa-f]{6}$/.test(hexColor)) {
-			throw new Error(
-				`Invalid color format '${color}'. Please provide a valid HEX, RGB, or RGBA color.`
-			)
-		}
-
-		// Convert the hex color to RGB components
-		const r = parseInt(hexColor.slice(0, 2), 16)
-		const g = parseInt(hexColor.slice(2, 4), 16)
-		const b = parseInt(hexColor.slice(4, 6), 16)
-
-		// Calculate the relative luminance of the color
-		// This formula gives more weight to green as the human eye is more sensitive to it
-		const luminance = 0.299 * r + 0.587 * g + 0.114 * b
-
-		// You can adjust the threshold to your preference
-		const threshold = 128
-
-		// Determine whether the color is light or dark
-		return luminance > threshold
-	}
-}
-
-const colorful = new Colorful()
-
-export default colorful

package/src/lib/cypto.ts

@@ -1,296 +0,0 @@
-/*
-	 Author : Omar Sawwas https://github.com/omarsawwas
-	 Date : 2023-06-17
-	 Description : RSA algorithm
-	 Version : 1.0
-*/
-class Crypto {
-	// Default variables
-	private _primeNumberP = 17
-	private _primeNumberQ = 19
-	private _phiN = (this._primeNumberP - 1) * (this._primeNumberQ - 1)
-	private _moduloDenominator = this._primeNumberP * this._primeNumberQ
-
-	/**
-	 *
-	 * @param number - The number to check if prime
-	 * @returns The boolean answer of prime checking operation
-	 * @example
-	 * ```typescript
-	 * this._isPrime(5)
-	 * ```
-	 * */
-
-	private _isPrime = (number: number): boolean => {
-		if (number <= 1) {
-			return false
-		}
-
-		if (number <= 3) {
-			return true
-		}
-
-		if (number % 2 === 0 || number % 3 === 0) {
-			return false
-		}
-
-		for (let i = 5; i * i <= number; i += 6) {
-			if (number % i === 0 || number % (i + 2) === 0) {
-				return false
-			}
-		}
-
-		return true
-	}
-
-	/**
-	 * Set the P prime number for the RSA algorithm
-	 * @param primeP - The prime number P of type string
-	 * @returns void
-	 * @example
-	 * ```typescript
-	 * crypto.setPrimeP(17)
-	 * ```
-	 * */
-
-	public setPrimeP(primeP: number) {
-		if (isNaN(primeP) || primeP === 0) {
-			throw new Error('Provide a valid number')
-		}
-
-		if (!this._isPrime(primeP)) {
-			throw new Error('The number is not prime')
-		}
-		this._primeNumberP = primeP
-	}
-
-	/**
-	 * Set the Q prime number for the RSA algorithm
-	 * @param primeQ - The prime number Q of type string
-	 * @returns void
-	 * @example
-	 * ```typescript
-	 * crypto.setPrimeQ(19)
-	 * ```
-	 * */
-
-	public setPrimeQ(primeQ: number) {
-		if (isNaN(primeQ) || primeQ === 0) {
-			throw new Error('Provide a valid number')
-		}
-		if (!this._isPrime(primeQ)) {
-			throw new Error('The number is not prime')
-		}
-		this._primeNumberQ = primeQ
-	}
-
-	/**
-	 *
-	 * @param base - The base number of type number
-	 * @param exponent - The exponent number of type number
-	 * @returns The modular exponentiation of the base and the exponent
-	 * @example
-	 * ```typescript
-	 * this.modularExponentiation(2, 3)
-	 * ```
-	 * */
-
-	private _modularExponentiation = (base: number, exponent: number) => {
-		if (isNaN(base) || isNaN(exponent)) {
-			throw new Error('Provide a valid number')
-		}
-		if (this._moduloDenominator === 1) {
-			return 0
-		}
-		let result = 1
-		base = base % this._moduloDenominator
-		while (exponent > 0) {
-			if (exponent % 2 === 1) {
-				result = (result * base) % this._moduloDenominator
-			}
-			exponent = Math.floor(exponent / 2)
-			base = (base * base) % this._moduloDenominator
-		}
-		return result
-	}
-
-	/**
-	 *
-	 * @param temporaryVarriableOne - The number one
-	 * @param temporaryVarriableTwo- The  number two (phi n)
-	 * @returns The boolean answer of relatively prime checking operation with phi n
-	 * @example
-	 * ```typescript
-	 * this._areRelativelyPrime(5,9)
-	 * ```
-	 * */
-
-	private _areRelativelyPrime = (
-		temporaryVarriableOne: number,
-		temporaryVarriableTwo: number
-	) => {
-		while (temporaryVarriableTwo !== 0) {
-			const temp = temporaryVarriableTwo
-			temporaryVarriableTwo = temporaryVarriableOne % temporaryVarriableTwo
-			temporaryVarriableOne = temp
-		}
-		return temporaryVarriableOne === 1
-	}
-
-	/**
-	 *
-	 * @returns The public and private key number which is a random number generated to match conditions set by RSA algorithm
-	 * @example
-	 * ```typescript
-	 * crypto.generateKeys()
-	 * ```
-	 * */
-
-	public generateKeys = (): Record<'publicKey' | 'privateKey', number> => {
-		const temporaryArray: number[] = []
-		for (let i = 2; i < this._phiN; i++) {
-			if (this._areRelativelyPrime(i, this._phiN)) {
-				temporaryArray.push(i)
-			}
-		}
-		if (temporaryArray.length === 0)
-			throw new Error('No public key options found!')
-		const randomIndex = Math.floor(Math.random() * temporaryArray.length)
-		// return temporaryArray[randomIndex]
-		const publicKey = temporaryArray[randomIndex]
-		const privateKey = this._generatePrivateKey(publicKey)
-		if (privateKey === publicKey) {
-			return this.generateKeys()
-		}
-		return {
-			privateKey: publicKey,
-			publicKey: privateKey,
-		}
-	}
-
-	/**
-	 *
-	 * @param publicKey - The public key number
-	 * @returns The private key number which is the modulus inverse with repect to modulo denominator
-	 * @example
-	 * ```typescript
-	 * crypto.generatePrivateKey(5)
-	 * ```
-	 * */
-
-	private _generatePrivateKey = (publicKey: number): number => {
-		if (publicKey <= 1 || isNaN(publicKey)) {
-			throw new Error('Public key should be a number greater than 1')
-		}
-
-		if (!this._areRelativelyPrime(publicKey, this._phiN)) {
-			throw new Error(
-				'Public key should be relatively prime with respect to phi N'
-			)
-		}
-
-		let t1 = 0
-		let t2 = 1
-		let r1 = this._phiN
-		let r2 = publicKey
-
-		while (r2 !== 0) {
-			const quotient = Math.floor(r1 / r2)
-			const temp1 = t1
-			const temp2 = r1
-
-			t1 = t2
-			r1 = r2
-
-			t2 = temp1 - quotient * t2
-			r2 = temp2 - quotient * r2
-		}
-
-		if (r1 > 1) {
-			throw new Error('The number does not have a modular inverse.')
-		}
-
-		if (t1 < 0) {
-			t1 += this._phiN
-		}
-
-		return t1
-	}
-
-	/**
-	 * Encrypt the message using the public key
-	 * @param message - The message to encrypt of type string|number|Record
-	 * @param publicKey - The public key to encrypt the message with of type number
-	 * @returns The encrypted message of type number[]
-	 * @example
-	 * ```typescript
-	 * crypto.encrypt('Hello World', 7)
-	 * ```
-	 * */
-
-	public encrypt = (
-		message: string | number | Record<any, any>,
-		publicKey: number
-	): number[] => {
-		if (isNaN(publicKey)) {
-			throw new Error('Public key should be a number')
-		}
-		if (publicKey <= 0) {
-			throw new Error(
-				'Private key should be a positive number different than 0'
-			)
-		}
-		if (typeof message === 'number') {
-			message = message.toString()
-		}
-		if (typeof message === 'object') {
-			message = JSON.stringify(message)
-		}
-		const encryptedMessage: number[] = []
-		for (let i = 0; i < message.length; i++) {
-			const a = message.charCodeAt(i)
-			encryptedMessage.push(this._modularExponentiation(a, publicKey))
-		}
-		return encryptedMessage
-	}
-
-	/**
-	 * Decrypt the message using the private key
-	 * @param encryptedMessage - The encryptedMessage to decrypt of type number[]
-	 * @param privateKey - The private key to decrypt the message with of type number
-	 * @returns The decrypted message of type string
-	 * @example
-	 * ```typescript
-	 * crypto.decrypt([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], 23)
-	 * ```
-	 * */
-	public decrypt = (encryptedMessage: number[], privateKey: number): string => {
-		if (isNaN(privateKey)) {
-			throw new Error('Public key should be a number')
-		}
-		if (privateKey <= 0) {
-			throw new Error(
-				'Private key should be a positive number different than 0'
-			)
-		}
-		if (!Array.isArray(encryptedMessage)) {
-			throw new Error('Encrypted message should be an array')
-		}
-		const allValidNumbers = encryptedMessage.every((number) => !isNaN(number))
-		if (!allValidNumbers) {
-			throw new Error('Encrypted message should be an array of numbers')
-		}
-		const decryptedAsciiMessage: number[] = []
-		for (let i = 0; i < encryptedMessage.length; i++) {
-			const a = encryptedMessage[i]
-			decryptedAsciiMessage.push(this._modularExponentiation(a, privateKey))
-		}
-		let finalString = ''
-		for (let i = 0; i < decryptedAsciiMessage.length; i++) {
-			finalString += String.fromCharCode(decryptedAsciiMessage[i])
-		}
-		return finalString
-	}
-}
-const crypto = new Crypto()
-export default crypto