@ixily/activ/src/sdk/node-only/cache-node-providers/level-provider.module..ts

Alpha Capture Trade Idea Verification. Blockchain ownership proven trade ideas and strategies.

import {
	ICacheDBConfig,
	ICacheStorage,
	ICacheStorageConfig,
	isNullOrUndefined,
} from '../../activ-v4'
import fs from 'fs'

let level: any
let db: any

const DEFAULT_EXPIRATION = 300 // 5 minutes

const state = {
	dbParams: {
		provider: 'level',
	} as ICacheDBConfig | undefined,
	isBrowser: false as boolean,
}

const config = async (_config: ICacheStorageConfig) => {
	if (_config.dbParams === undefined) {
		throw new Error('Level instance dbparams are not defined')
	}
	if (_config.dbParams.levelSettings === undefined) {
		throw new Error('Level settings in dbparams are not defined')
	}
	if (_config.dbParams.levelSettings.instance === undefined) {
		throw new Error('Level instance in dbparams are not defined')
	}
	state.dbParams = _config.dbParams!
	state.isBrowser = _config.isBrowser
	level = state.dbParams!.levelSettings!.instance

	if (isNullOrUndefined(level)) {
		throw new Error('Level instance is not defined')
	}

	if (!isNullOrUndefined(level) && isNullOrUndefined(db)) {
		try {
			db = new level(state.dbParams.levelSettings!.database, {
				valueEncoding: 'utf8',
			})
		} catch (err) {
			console.error(`REDIS Error : ${err}`)
		}
	}
}

export const addData = async <T>(
	key: string,
	data: T,
	expiration: number = DEFAULT_EXPIRATION,
): Promise<void> => {
	const payload = data ? JSON.stringify({ key, data, expiration }) : null
	if (payload) {
		await db.put(key, payload)
		// if (expiration > 0) {
		// 	await client.expire(key, expiration)
		// }
	}
	return Promise.resolve()
}

export const getData = async <T>(key: string): Promise<T | undefined> => {
	let info: undefined | string = undefined
	try {
		info = await db.get(key)
	} catch (err) {
		if ((err as unknown as any).notFound === true) {
			info = undefined
		} else {
			throw err
		}
	}
	if (isNullOrUndefined(info)) {
		return undefined
	}
	const result = JSON.parse(info!)
	const dataParsed = result?.data ? (result.data as T) : undefined
	if (dataParsed === null) {
		return undefined
	}
	return dataParsed
}

export const updateData = async <T>(
	key: string,
	data: T,
	expiration: number = DEFAULT_EXPIRATION,
): Promise<void> => {
	addData(key, data, expiration)
}

export const removeData = async (key: string): Promise<void> => {
	await db.del(key)
	return Promise.resolve()
}

// export const removeDataByPattern = async (pattern: string): Promise<void> => {
// 	const data: any = await client.keys(`*${pattern}*`)
// 	data?.map(async (key: any) => {
// 		await removeData(key)
// 	})
// 	return Promise.resolve()
// }

export const resetData = async (): Promise<void> => {
	await db.close()
	fs.rmSync(state.dbParams!.levelSettings!.database, {
		recursive: true,
		force: true,
	})
	await db.open()
	return Promise.resolve()
}

export const CacheNodeLevelStorageModule: ICacheStorage = {
	config,
	addData,
	getData,
	updateData,
	removeData,
	// removeDataByPattern,
	resetData,
}