@beecode/msh-util 1.2.0 → 1.2.1

package/src/object-util.ts

@@ -0,0 +1,127 @@
+import cloneDeep from 'lodash.clonedeep'
+import util from 'util'
+
+export type ObjectType = Record<string, any>
+
+export class ObjectUtil {
+	/**
+	 * Deep clone object. Returned object will have no references to the object passed through params
+	 * @template T
+	 * @param {T} objectToClone
+	 * @return {T}
+	 */
+	deepClone<T extends ObjectType>(objectToClone: T): T {
+		return cloneDeep(objectToClone)
+	}
+
+	/**
+	 * Pick only properties from the property list. It is only allowed to pick properties from the first level
+	 * @template T
+	 * @template L
+	 * @param {T} obj
+	 * @param {L[]} keyList
+	 * @return {Pick<T, L>}
+	 */
+	pickByList<T extends object, L extends keyof T>(obj: T, keyList: (L | string)[]): Pick<T, L> {
+		return keyList.reduce((pickedObj, key) => {
+			if (Object.prototype.hasOwnProperty.call(obj, key)) {
+				pickedObj[key as L] = obj[key as L]
+			}
+
+			return pickedObj
+		}, {} as Pick<T, L>) // eslint-disable-line @typescript-eslint/prefer-reduce-type-parameter
+	}
+
+	/**
+	 * Pick objects properties using keys from the second object.
+	 * @template T
+	 * @template L
+	 * @param {T} obj
+	 * @param {Partial<T>} objWithPickKeys
+	 * @return {Pick<T, L>}
+	 */
+	pickByObjectKeys<T extends object, L extends keyof T>(obj: T, objWithPickKeys: Partial<T> | ObjectType): Pick<T, L> {
+		const keys = Object.keys(objWithPickKeys) as L[]
+
+		return this.pickByList<T, L>(obj, keys)
+	}
+
+	/**
+	 * This function will do stringify deeper that JSON.stringify.
+	 * @param {any} entity - entity thant needs to be stringify
+	 * @param {object} [options] - available options
+	 * @param {boolean} [options.isSortable=false] - if object property should be sorted
+	 * @param {boolean} [options.isPrettyPrinted=false] - if object and array properties should be printed in a new row
+	 * @param {number} [options.prettyPrintCompactLevel=0] - if pretty print is on define the level of deepest children that are not
+	 * going to be pretty. It doesn't matter if the siblings doesn't have the same depth.
+	 * @return {string} - strung result
+	 * @example
+	 * console.log(new ObjectUtil().deepStringify(null)) // 'null'
+	 * console.log(new ObjectUtil().deepStringify(undefined)) // 'undefined'
+	 * console.log(new ObjectUtil().deepStringify({ a: 1 })) // '{\n\ta: 1\n}'
+	 * // `{
+	 * //   a:1
+	 * // }`
+	 * console.log(new ObjectUtil().deepStringify({ b: 1, a: 2 }, {isSorted:true, compact: true})) // { a: 2, b: 1 }
+	 */
+	deepStringify(
+		entity: any,
+		options?: { isSorted?: boolean; isPrettyPrinted?: boolean; prettyPrintCompactLevel?: number }
+	): string {
+		const { isSorted = false, isPrettyPrinted = false, prettyPrintCompactLevel = 0 } = options ?? {}
+
+		const compact = this._deepStringifyCompact({ isPrettyPrinted, prettyPrintCompactLevel })
+
+		return util.inspect(entity, {
+			breakLength: Infinity,
+			compact,
+			depth: Infinity,
+			maxArrayLength: Infinity,
+			maxStringLength: Infinity,
+			sorted: isSorted,
+		})
+	}
+
+	protected _deepStringifyCompact(params: { isPrettyPrinted: boolean; prettyPrintCompactLevel: number }): number | boolean {
+		const { isPrettyPrinted, prettyPrintCompactLevel } = params
+
+		if (!isPrettyPrinted) {
+			return true
+		}
+
+		return prettyPrintCompactLevel
+	}
+
+	/**
+	 * We are converting objects to string (or null or undefined) and comparing if the result is equal
+	 * @param a
+	 * @param b
+	 * @return {boolean}
+	 */
+	deepEqual(a: any, b: any): boolean {
+		return this.deepStringify(a, { isSorted: true }) === this.deepStringify(b, { isSorted: true })
+	}
+
+	/**
+	 * This function is going to convert any null to undefined in the object that is passed to it.
+	 * @template T
+	 * @param {T} objectWithNulls
+	 * @return {T}
+	 * @example
+	 * console.log(new ObjectUtil().deepNullToUndefined({ a: null, b: { c: null } })) // { a: undefined, b: { c: undefined } }
+	 */
+	deepNullToUndefined<T extends ObjectType>(objectWithNulls: T): T {
+		return Object.entries(objectWithNulls).reduce<any>((acc, cur) => {
+			const [key, value] = cur
+			if (value === null) {
+				acc[key] = undefined
+			} else if (typeof value === 'object' && !(value instanceof Date)) {
+				acc[key] = this.deepNullToUndefined(value)
+			} else {
+				acc[key] = value
+			}
+
+			return acc
+		}, {})
+	}
+}

package/src/regex-util.test.ts

@@ -0,0 +1,25 @@
+import { regexUtil } from 'src/regex-util'
+
+describe('regexUtil', () => {
+	it.each([
+		['00000000-0000-0000-0000-000000000000'],
+		['b40c3094-a238-4c21-a744-f19b9e476abf'],
+		['7d39e0a8-4ca2-41ff-9ded-312fb08f4dda'],
+		['f9ea83de-c69f-42ff-8764-a6e88d59d75d'],
+		['33f13db5-d427-4ea4-b028-6fc30a84d827'],
+		['f04ec90e-2ff5-4b88-beb3-23b348b8e33b'],
+		['83ad915b-645a-4132-b8c1-ab398701ba66'],
+		['3510e9f1-08f6-4c5a-86a9-66e91c6093b7'],
+		['02f243d8-3225-460b-9df7-30380d96971d'],
+		['f27571d4-8c4a-4c9a-8899-932d0fa7a68c'],
+		['b87a9f9c-c7c2-4aa2-85af-87221cebce9d'],
+	])('%#. should pass regex expression check %s', (uuidString) => {
+		expect(new RegExp(regexUtil.uuid).test(uuidString)).toBeTruthy()
+	})
+	it.each([['a'], ['test'], [123], [{}], [{ uuid: '3510e9f1-08f6-4c5a-86a9-66e91c6093b7' }], [new Date()]])(
+		'%#. should pass regex expression check %s',
+		(uuidString) => {
+			expect(new RegExp(regexUtil.uuid).test(uuidString.toString())).toBeFalsy()
+		}
+	)
+})

package/src/regex-util.ts

@@ -0,0 +1,11 @@
+export const regexUtil = {
+	/**
+	 * This is a UUID regex expression. This is usually used in express router to constrict the values passed as a path parameter (if you are using UUID as your identifier).
+	 * @return {string}
+	 * @example
+	 * const { uuid } = regexUtil
+	 * router.route(`/users/:userId(${uuid})`).get(getUsersById)
+	 * //...
+	 */
+	uuid: `\\b[0-9a-f]{8}\\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\\b[0-9a-f]{12}\\b` as const,
+}

package/src/single-threshold-promise.test.ts

@@ -0,0 +1,91 @@
+import { SingleThresholdPromise } from 'src/single-threshold-promise'
+import { timeout } from 'src/timeout'
+
+describe('SingleThresholdPromise', () => {
+	describe('promise', () => {
+		let callCounter = 0
+		const fake_asyncFactoryFn = jest.fn()
+		const fake_asyncRejectFactoryFn = jest.fn()
+
+		beforeEach(() => {
+			callCounter = 0
+			jest.useFakeTimers()
+			fake_asyncFactoryFn.mockImplementation(async (): Promise<{ callCount: number }> => {
+				await timeout(1000)
+
+				return { callCount: ++callCounter }
+			})
+			fake_asyncRejectFactoryFn.mockImplementation(async (): Promise<{ callCount: number }> => {
+				await timeout(1000)
+				throw new Error()
+			})
+		})
+
+		afterEach(() => {
+			jest.clearAllTimers()
+			jest.useRealTimers()
+			jest.resetAllMocks()
+		})
+
+		it('should return result of the factory function when promise called', async () => {
+			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+
+			const promise = singleThresholdPromiseImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise).toEqual({ callCount: 1 })
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+		})
+
+		it('should return the same promise result to multiple calls before the first promise is resolved ', async () => {
+			const expected = { callCount: 1 }
+
+			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncFactoryFn)
+			const promise1 = singleThresholdPromiseImplementation.promise()
+			const promise2 = singleThresholdPromiseImplementation.promise()
+			const promise3 = singleThresholdPromiseImplementation.promise()
+
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise1).toEqual(expected)
+			expect(await promise2).toEqual(expected)
+			expect(await promise3).toEqual(expected)
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+		})
+
+		it('should return different promise result to multiple calls if they are called after the promise is resolved', async () => {
+			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncFactoryFn)
+
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+
+			const promise1 = singleThresholdPromiseImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise1).toEqual({ callCount: 1 })
+
+			const promise2 = singleThresholdPromiseImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(2)
+			jest.runAllTimers()
+			expect(await promise2).toEqual({ callCount: 2 })
+
+			const promise3 = singleThresholdPromiseImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(3)
+			jest.runAllTimers()
+			expect(await promise3).toEqual({ callCount: 3 })
+		})
+
+		it('should reject all if promise is rejected', async () => {
+			const singleThresholdPromiseImplementation = new SingleThresholdPromise(fake_asyncRejectFactoryFn)
+			const promise1 = singleThresholdPromiseImplementation.promise()
+			const promise2 = singleThresholdPromiseImplementation.promise()
+			const promise3 = singleThresholdPromiseImplementation.promise()
+			expect(fake_asyncRejectFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			await promise1.then(() => expect.fail('test failed')).catch(() => undefined)
+			await promise2.then(() => expect.fail('test failed')).catch(() => undefined)
+			await promise3.then(() => expect.fail('test failed')).catch(() => undefined)
+			expect(fake_asyncRejectFactoryFn).toHaveBeenCalledTimes(1)
+		})
+	})
+})

package/src/single-threshold-promise.ts

@@ -0,0 +1,56 @@
+import { AnyFunctionPromiseNoParams } from 'src/types/any-function/promise-no-params'
+
+/**
+ * SingleThresholdPromise returns a single promise, and subsequent calls made before the promise resolves will return the same promise.
+ * @example
+ * export const refreshTokenSingleThreshold = new SingleThresholdPromise(async () => {
+ *   const oldRefreshToken = await refreshTokenService.get()
+ *   const { accessToken, refreshToken } = await authService.refreshToken({
+ *     refreshToken: oldRefreshToken,
+ *   })
+ *   return { accessToken, refreshToken }
+ * })
+ *
+ * export const authService = {
+ *   refreshToken: async (): Promise<{ accessToken: string; refreshToken:string }> => {
+ *     return refreshTokenSingleThreshold.promise()
+ *   }
+ * }
+ */
+export class SingleThresholdPromise<T> {
+	protected _cache: {
+		promises?: { resolve: (value: T | PromiseLike<T>) => void; reject: (reason?: any) => void }[]
+	} = {}
+
+	protected _factoryFn: AnyFunctionPromiseNoParams<T>
+
+	constructor(factoryFn: AnyFunctionPromiseNoParams<T>) {
+		this._factoryFn = factoryFn
+	}
+
+	protected _rejectPromises(): void {
+		if (this._cache.promises) {
+			this._cache.promises.forEach((promise) => promise.reject(new Error('Cache was cleaned')))
+		}
+		delete this._cache.promises
+	}
+
+	async promise(): Promise<T> {
+		if ('promises' in this._cache) {
+			return new Promise<T>((resolve, reject) => {
+				this._cache.promises!.push({ reject, resolve })
+			})
+		}
+
+		this._cache.promises = []
+		const result = await this._factoryFn().catch((err) => {
+			this._rejectPromises()
+			throw err
+		})
+
+		this._cache.promises.forEach((promise) => promise.resolve(result))
+		delete this._cache.promises
+
+		return result
+	}
+}

package/src/singleton/async.test.ts

@@ -0,0 +1,122 @@
+import { SingletonAsync } from 'src/singleton/async'
+import { timeout } from 'src/timeout'
+
+describe('SingletonAsync', () => {
+	const fakeResult = { sucessful: true }
+	const fake_asyncFactoryFn = jest.fn()
+	const fake_asyncRejectFactoryFn = jest.fn()
+	beforeEach(() => {
+		jest.useFakeTimers()
+		fake_asyncFactoryFn.mockImplementation(async (): Promise<{ sucessful: boolean }> => {
+			await timeout(1000)
+
+			return fakeResult
+		})
+		fake_asyncRejectFactoryFn.mockImplementation(async (): Promise<{ sucessful: boolean }> => {
+			await timeout(1000)
+			throw new Error()
+		})
+	})
+
+	afterEach(() => {
+		jest.clearAllTimers()
+		jest.useRealTimers()
+		jest.resetAllMocks()
+	})
+	describe('promise', () => {
+		it('should return promised value', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+			const promise = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise).toBe(fakeResult)
+		})
+
+		it('should subscribe multiple calls to the same promise if promise still not resolved', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+			const promise1 = singletonImplementation.promise()
+			const promise2 = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+
+			jest.runAllTimers()
+			expect(await promise1).toBe(fakeResult)
+			expect(await promise2).toBe(fakeResult)
+		})
+
+		it('should second call after promise is resolved should return cache value', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+			const promise1 = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+
+			jest.runAllTimers()
+			expect(await promise1).toBe(fakeResult)
+
+			const promise2 = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise2).toBe(fakeResult)
+		})
+
+		it('should reject all subscribers to promise if it is rejected', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncRejectFactoryFn)
+			expect(fake_asyncRejectFactoryFn).not.toHaveBeenCalled()
+			const promise1 = singletonImplementation.promise()
+			const promise2 = singletonImplementation.promise()
+			expect(fake_asyncRejectFactoryFn).toHaveBeenCalledTimes(1)
+
+			jest.runAllTimers()
+			await promise1.then(() => expect.fail('test failed')).catch(() => undefined)
+			await promise2.then(() => expect.fail('test failed')).catch(() => undefined)
+		})
+	})
+	describe('cached', () => {
+		it('should return undefined if promise is never called', () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+			expect(singletonImplementation.cached()).toBeUndefined()
+		})
+		it('should cache result of the promise', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+
+			const promise = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise).toBe(fakeResult)
+			expect(singletonImplementation.cached()).toBe(fakeResult)
+		})
+	})
+	describe('cleanCache', () => {
+		it('should reject all subscribers to the promise if cleanCache is called before promise is resolved', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+			const promise1 = singletonImplementation.promise().catch(() => undefined)
+			const promise2 = singletonImplementation.promise().catch(() => undefined)
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			singletonImplementation.cleanCache()
+			jest.runAllTimers()
+			await promise1.then(() => expect.fail('test failed'))
+			await promise2.then(() => expect.fail('test failed'))
+		})
+
+		it('should clean cache and after the clean cache factory should be called again on promise', async () => {
+			const singletonImplementation = new SingletonAsync(fake_asyncFactoryFn)
+			expect(fake_asyncFactoryFn).not.toHaveBeenCalled()
+			const promise1 = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(1)
+			jest.runAllTimers()
+			expect(await promise1).toBe(fakeResult)
+			expect(singletonImplementation.cached()).toBe(fakeResult)
+			singletonImplementation.cleanCache()
+			expect(singletonImplementation.cached()).toBeUndefined()
+
+			const promise2 = singletonImplementation.promise()
+			expect(fake_asyncFactoryFn).toHaveBeenCalledTimes(2)
+			jest.runAllTimers()
+			expect(await promise2).toBe(fakeResult)
+		})
+	})
+})

package/src/singleton/async.ts

@@ -0,0 +1,90 @@
+import { AnyFunctionPromiseNoParams } from 'src/types/any-function/promise-no-params'
+
+/**
+ * This is a singleton wrapper that is used to wrap around async function. We have additional functionality to clear the cache
+ * and reject any subscriptions to initial promise. And we can also check if there is anything i cache
+ * @example
+ * export const configSingleton = new SingletonAsync(async () => {
+ *   await timeout(3000)
+ *   return {
+ *     env: process.env.NODE_ENV
+ *   } as const
+ * })
+ *
+ * // using
+ * // cache value before we call promise
+ * console.log(configSingleton().cache()) // undefined
+ * console.log('NODE_ENV: ', await configSingleton().promise().env) // NODE_ENV: prod
+ * // cache value after we call promise
+ * console.log(configSingleton().cache()) // { env: 'prod' }
+ */
+export class SingletonAsync<T> {
+	protected _cache: {
+		singleton?: T
+		promises?: { resolve: (value: T | PromiseLike<T>) => void; reject: (reason?: any) => void }[]
+	} = {}
+
+	protected _factory: AnyFunctionPromiseNoParams<T>
+
+	constructor(factory: AnyFunctionPromiseNoParams<T>) {
+		this._factory = factory
+	}
+
+	/**
+	 * Empty cached value and reject any subscribed promise that is waiting for the initial promise to be resolved.
+	 */
+	cleanCache(): void {
+		delete this._cache.singleton
+		this._rejectPromises({ error: new Error('Cache was cleaned') })
+	}
+
+	protected _rejectPromises(params: { error: Error }): void {
+		const { error } = params
+
+		if (this._cache.promises) {
+			this._cache.promises.forEach((promise) => promise.reject(error))
+		}
+		delete this._cache.promises
+	}
+
+	/**
+	 * Return singleton value in a promise. If there is no cached value then try to get it from factory.
+	 * @template T
+	 * @returns {Promise<T>}
+	 */
+	async promise(): Promise<T> {
+		if ('singleton' in this._cache) {
+			return this._cache.singleton!
+		}
+		if ('promises' in this._cache) {
+			return new Promise<T>((resolve, reject) => {
+				this._cache.promises!.push({ reject, resolve })
+			})
+		}
+
+		this._cache.promises = []
+		const result = await this._factory().catch((error) => {
+			this._rejectPromises({ error })
+			throw error
+		})
+		this._cache.singleton = result
+
+		this._cache.promises.forEach((promise) => promise.resolve(result))
+		delete this._cache.promises
+
+		return result
+	}
+
+	/**
+	 * Return cached value, if there is no value cached return undefined.
+	 * @template T
+	 * @returns {T | undefined}
+	 */
+	cached(): T | undefined {
+		if ('singleton' in this._cache) {
+			return this._cache.singleton!
+		}
+
+		return undefined
+	}
+}

package/src/singleton/pattern.test.ts

@@ -0,0 +1,16 @@
+import { singletonPattern } from 'src/singleton/pattern'
+
+describe('singletonPattern', () => {
+	it('should call factory function only once', () => {
+		const factoryResult = { successful: true }
+		const factoryFn = jest.fn().mockImplementation(() => {
+			return factoryResult
+		})
+		const singletonImplementation = singletonPattern(factoryFn)
+		expect(factoryFn).not.toHaveBeenCalled()
+		expect(singletonImplementation()).toBe(factoryResult)
+		expect(factoryFn).toHaveBeenCalledTimes(1)
+		expect(singletonImplementation()).toBe(factoryResult)
+		expect(factoryFn).toHaveBeenCalledTimes(1)
+	})
+})

package/src/singleton/pattern.ts

@@ -0,0 +1,44 @@
+import { AnyFunctionNoParams } from 'src/types/any-function/no-params'
+
+/**
+ * Singleton patter wrapper function
+ * @param {AnyFunctionNoParams<R>} factoryFn Factory function that is used to generate value that is going to be cached and return by
+ * singleton.
+ * @return {AnyFunctionNoParams<R>} Function result that returns cached value.
+ * @example
+ * export class SomeClass {
+ *   constructor(protected _param: string){ }
+ *   get param(): string {
+ *     return this._param
+ *   }
+ * }
+ * export const someClassSingleton = singletonPattern((): SomeClass => {
+ *   return new SomeClass('some param value')
+ * })
+ *
+ * // using
+ * console.log('param: ', someClassSingleton().param) // param: some param value
+ *
+ * ///////////////////////////////////////////
+ * // Or we can use it with simple function //
+ * ///////////////////////////////////////////
+ * export const config = singletonPattern(() => {
+ *   return {
+ *     env: process.NODE_ENV,
+ *   } as const
+ * })
+ *
+ * // using
+ * console.log('NODE_ENV: ', config().env) // NODE_ENV: prod
+ */
+export const singletonPattern = <R>(factoryFn: AnyFunctionNoParams<R>): AnyFunctionNoParams<R> => {
+	const cache: { singleton?: R } = {}
+
+	return (): R => {
+		if ('singleton' in cache) {
+			return cache.singleton!
+		}
+
+		return (cache.singleton = factoryFn())
+	}
+}

package/src/string-util.test.ts

@@ -0,0 +1,18 @@
+import { regexUtil } from 'src/regex-util'
+import { stringUtil } from 'src/string-util'
+
+describe('stringUtil', () => {
+	it.each([
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+		[stringUtil.generateUUID()],
+	])('%#. should generate valid uuid %s', (uuid) => {
+		expect(new RegExp(regexUtil.uuid).test(uuid)).toBeTruthy()
+	})
+})

package/src/string-util.ts

@@ -0,0 +1,18 @@
+export const stringUtil = {
+	/**
+	 * Generate random UUID
+	 * @return {string}
+	 * @example
+	 * console.log(stringUtil.uuid()) // "69bfda25-df3f-46b4-8bbb-955cf5193426"
+	 */
+	generateUUID: (): string => {
+		return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+			const r = (Math.random() * 16) | 0
+			if (c == 'x') {
+				return r.toString(16)
+			}
+
+			return ((r & 0x3) | 0x8).toString(16)
+		})
+	},
+}