@mhmdhammoud/meritt-utils 1.6.1 → 1.6.3

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

package/src/lib/elastic-transport.ts

@@ -1,307 +0,0 @@
-/**
- * Elasticsearch transport for Pino with connection lifecycle resilience.
- *
- * Based on pino-elasticsearch with a fix for GitHub issue #140:
- * When maxRetries are exceeded and Elasticsearch nodes are DEAD, the bulk helper
- * destroys the splitter stream, causing logs to stop permanently until restart.
- *
- * This implementation overrides splitter.destroy to BOTH resurrect the connection
- * pool AND reinitialize the bulk handler, so logging continues after ES recovers.
- *
- * @see https://github.com/pinojs/pino-elasticsearch/issues/140
- * @see https://github.com/pinojs/pino-elasticsearch/issues/72
- */
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const split = require('split2') as (
-	fn: (line: string) => unknown,
-	opts?: { autoDestroy?: boolean }
-) => NodeJS.ReadWriteStream
-import { Client } from '@elastic/elasticsearch'
-import type { ClientOptions } from '@elastic/elasticsearch'
-
-export interface ElasticTransportOptions extends Pick<
-	ClientOptions,
-	| 'node'
-	| 'auth'
-	| 'cloud'
-	| 'caFingerprint'
-	| 'Connection'
-	| 'ConnectionPool'
-	| 'maxRetries'
-	| 'requestTimeout'
-> {
-	sniffOnConnectionFault?: boolean
-	index?: string | ((logTime: string) => string)
-	flushBytes?: number
-	'flush-bytes'?: number
-	flushInterval?: number
-	'flush-interval'?: number
-	esVersion?: number
-	'es-version'?: number
-	rejectUnauthorized?: boolean
-	tls?: ClientOptions['tls']
-}
-
-interface LogDocument {
-	time?: string
-	'@timestamp'?: string
-	[k: string]: unknown
-}
-
-function setDateTimeString(value: unknown): string {
-	if (value !== null && typeof value === 'object' && 'time' in value) {
-		const t = (value as { time: unknown }).time
-		if (
-			(typeof t === 'string' && t.length > 0) ||
-			(typeof t === 'number' && t >= 0)
-		) {
-			return new Date(t).toISOString()
-		}
-	}
-	return new Date().toISOString()
-}
-
-function getIndexName(
-	index: string | ((logTime: string) => string),
-	time: string
-): string {
-	if (typeof index === 'function') {
-		return index(time)
-	}
-	return index.replace('%{DATE}', time.substring(0, 10))
-}
-
-function createBulkSender(
-	opts: ElasticTransportOptions,
-	client: Client,
-	splitter: NodeJS.ReadWriteStream
-): {
-	add: (doc: unknown) => void
-	flush: () => Promise<void>
-	close: () => Promise<void>
-} {
-	const esVersion = Number(opts.esVersion ?? opts['es-version'] ?? 7)
-	const index = opts.index ?? 'pino'
-	const buildIndexName = typeof index === 'function' ? index : null
-	const opType = esVersion >= 7 ? undefined : undefined
-	const flushBytes = opts.flushBytes ?? opts['flush-bytes'] ?? 1000
-	const flushInterval = opts.flushInterval ?? opts['flush-interval'] ?? 3000
-
-	let buffer: unknown[] = []
-	let bufferedBytes = 0
-	let timer: NodeJS.Timeout | undefined
-	let isFlushing = false
-	let flushAgain = false
-
-	const indexName = (time = new Date().toISOString()) =>
-		buildIndexName ? buildIndexName(time) : getIndexName(index as string, time)
-
-	const clearFlushTimer = () => {
-		if (timer) {
-			clearTimeout(timer)
-			timer = undefined
-		}
-	}
-
-	const scheduleFlush = () => {
-		if (timer || buffer.length === 0) {
-			return
-		}
-		timer = setTimeout(() => {
-			timer = undefined
-			void flush()
-		}, flushInterval)
-		timer.unref?.()
-	}
-
-	const buildOperation = (doc: unknown): [Record<string, unknown>, unknown] => {
-		try {
-			const d = doc as LogDocument
-			const date = d.time ?? d['@timestamp'] ?? new Date().toISOString()
-			if (opType === 'create') {
-				d['@timestamp'] = date
-			}
-			return [
-				{
-					index: {
-						_index: indexName(date),
-						op_type: opType,
-					},
-				},
-				doc,
-			]
-		} catch {
-			return [
-				{
-					index: {
-						_index: indexName(),
-						op_type: opType,
-					},
-				},
-				doc,
-			]
-		}
-	}
-
-	const emitDroppedDocument = (doc: unknown, cause?: unknown) => {
-		const error = new Error('Dropped document') as Error & {
-			document: unknown
-			cause?: unknown
-		}
-		error.document = doc
-		error.cause = cause
-		splitter.emit('insertError', error)
-	}
-
-	const flush = async (): Promise<void> => {
-		if (isFlushing) {
-			flushAgain = true
-			return
-		}
-		clearFlushTimer()
-		if (buffer.length === 0) {
-			return
-		}
-
-		isFlushing = true
-		const batch = buffer
-		buffer = []
-		bufferedBytes = 0
-
-		try {
-			const operations = batch.flatMap(buildOperation)
-			const response = await client.bulk({
-				operations,
-				refresh: false,
-				timeout: opts.requestTimeout ? `${opts.requestTimeout}ms` : undefined,
-			})
-
-			const body = response as {
-				errors?: boolean
-				items?: Array<Record<string, { error?: unknown }>>
-			}
-			if (body.errors && Array.isArray(body.items)) {
-				body.items.forEach((item, index) => {
-					const result = Object.values(item)[0]
-					if (result?.error) {
-						emitDroppedDocument(batch[index], result.error)
-					}
-				})
-			}
-
-			splitter.emit('insert', {
-				successful: batch.length,
-				failed: body.errors ? (body.items?.length ?? 0) : 0,
-			})
-		} catch (err) {
-			splitter.emit('error', err)
-			// Drop the failed batch instead of wedging the stream. The next log line
-			// creates a fresh bulk request and can recover without a process restart.
-			batch.forEach((doc) => emitDroppedDocument(doc, err))
-		} finally {
-			isFlushing = false
-			if (flushAgain || buffer.length > 0) {
-				flushAgain = false
-				scheduleFlush()
-				if (bufferedBytes >= flushBytes) {
-					void flush()
-				}
-			}
-		}
-	}
-
-	return {
-		add(doc: unknown) {
-			buffer.push(doc)
-			bufferedBytes += Buffer.byteLength(JSON.stringify(doc))
-			if (bufferedBytes >= flushBytes) {
-				void flush()
-				return
-			}
-			scheduleFlush()
-		},
-		flush,
-		async close() {
-			clearFlushTimer()
-			await flush()
-		},
-	}
-}
-
-export const createElasticTransport = (
-	opts: ElasticTransportOptions = {}
-): NodeJS.ReadWriteStream => {
-	const splitter = split(
-		function (this: NodeJS.ReadWriteStream, line: string) {
-			let value: unknown
-
-			try {
-				value = JSON.parse(line) as unknown
-			} catch (error) {
-				this.emit('unknown', line, error)
-				return
-			}
-
-			if (typeof value === 'boolean') {
-				this.emit('unknown', line, 'Boolean value ignored')
-				return
-			}
-			if (value === null) {
-				this.emit('unknown', line, 'Null value ignored')
-				return
-			}
-			if (typeof value !== 'object') {
-				value = { data: value, time: setDateTimeString(value) }
-			} else {
-				const obj = value as Record<string, unknown>
-				if (obj['@timestamp'] === undefined) {
-					;(obj as LogDocument).time = setDateTimeString(obj)
-				}
-			}
-			return value
-		},
-		{ autoDestroy: true }
-	)
-
-	const clientOpts: ClientOptions = {
-		node: opts.node,
-		auth: opts.auth,
-		cloud: opts.cloud,
-		tls: { rejectUnauthorized: opts.rejectUnauthorized, ...opts.tls },
-		maxRetries: opts.maxRetries,
-		requestTimeout: opts.requestTimeout,
-		sniffOnConnectionFault: opts.sniffOnConnectionFault,
-	}
-
-	if (opts.caFingerprint) {
-		clientOpts.caFingerprint = opts.caFingerprint
-	}
-	if (opts.Connection) {
-		clientOpts.Connection = opts.Connection
-	}
-	if (opts.ConnectionPool) {
-		clientOpts.ConnectionPool = opts.ConnectionPool
-	}
-
-	const client = new Client(clientOpts)
-	const bulkSender = createBulkSender(opts, client, splitter)
-
-	splitter.on('data', (doc) => {
-		bulkSender.add(doc)
-	})
-	splitter.on('finish', () => {
-		void bulkSender.close()
-	})
-
-	const splitterWithDestroy = splitter as NodeJS.ReadWriteStream & {
-		destroy: (err?: Error) => void
-	}
-	const originalDestroy = splitterWithDestroy.destroy.bind(splitterWithDestroy)
-	splitterWithDestroy.destroy = function (err?: Error) {
-		void bulkSender.close()
-		originalDestroy(err)
-	}
-
-	return splitter
-}