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

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

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

let logged = false
let redis: any
let client: any

const DEFAULT_EXPIRATION = 300 // 5 minutes

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

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

	if (isNullOrUndefined(redis)) {
		throw new Error('Redis instance is not defined')
	}

	if (!isNullOrUndefined(redis) && isNullOrUndefined(client)) {
		try {
			client = redis?.createClient({
				url: state.dbParams?.redisSettings?.url,
				password: state.dbParams?.redisSettings?.password,
				database: state.dbParams?.redisSettings?.database,
				disableOfflineQueue: true,
			})

			client.on('error', (error: any) => {
				console.error(`REDIS Error : ${error}`)
				if (!logged) {
					logged = true
				}
			})

			await client.connect()
		} 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 client.set(key, payload)
		if (expiration > 0) {
			await client.expire(key, expiration)
		}
	}
	return Promise.resolve()
}

export const getData = async <T>(key: string): Promise<T | undefined> => {
	const info = await client.get(key)
	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> => {
	await client.del(key)
	await client.set(key, JSON.stringify({ key, data, expiration }))
	if (expiration > 0) {
		await client.expire(key, expiration)
	}
	return Promise.resolve()
}

export const removeData = async (key: string): Promise<void> => {
	await client.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 client.flushAll()
	return Promise.resolve()
}

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