@ixily/activ/src/sdk/node-only/cache-node-storage.module.ts

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

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

import { CacheNodeMemoryStorageModule } from './cache-node-providers/memory-provider.module'

import { CacheNodeRedisStorageModule } from './cache-node-providers/redis-provider.module'

import { CacheNodeLevelStorageModule } from './cache-node-providers/level-provider.module.'

import { CacheNodeNoneStorageModule } from './cache-node-providers/none-provider.module'

const DEFAULT_EXPIRATION = 300 // 5 minutes

const state: ICacheStorageConfig = {
	dbParams: undefined,
	isBrowser: false as boolean,
	module: null as any,
}

let dBProvider: CacheProvider | undefined = 'none'
let storageModule: ICacheStorage

const getStorageModule = (): ICacheStorage => {
	switch (dBProvider) {
		case 'redis':
			storageModule = CacheNodeRedisStorageModule
			break
		case 'memory':
			storageModule = CacheNodeMemoryStorageModule
			break
		case 'level':
			storageModule = CacheNodeLevelStorageModule
			break
		case 'none':
			storageModule = CacheNodeNoneStorageModule
			break
		default:
			storageModule = CacheNodeNoneStorageModule
	}
	return storageModule
}

const init = async () => {
	await config(state)
	storageModule = getStorageModule()
	await storageModule?.config(state)
}

const config = async (_config: ICacheStorageConfig) => {
	state.dbParams = _config.dbParams
	state.isBrowser = _config.isBrowser
	dBProvider = _config?.dbParams?.provider
}

export const addData = async <T>(
	key: string,
	data: T,
	expiration: number = DEFAULT_EXPIRATION,
): Promise<void> => {
	await init()
	await storageModule?.addData(key, data, expiration)
}

export const getData = async <T>(key: string): Promise<T | undefined> => {
	await init()
	return storageModule.getData(key)
}

export const updateData = async <T>(
	key: string,
	data: T,
	expiration: number = DEFAULT_EXPIRATION,
): Promise<void> => {
	await init()
	await storageModule?.updateData(key, data, expiration)
}

export const removeData = async (key: string): Promise<void> => {
	await init()
	await storageModule?.removeData(key)
}

export const removeDataByPattern = async (pattern: string): Promise<void> => {
	await init()
	if ((await storageModule?.removeDataByPattern) !== undefined) {
		await storageModule?.removeDataByPattern!(pattern)
	} else {
		throw new Error('removeDataByPattern is not defined')
	}
}

export const resetData = async (): Promise<void> => {
	await init()
	await storageModule?.resetData()
}

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