@citrineos/util/dist/cache/redis.js

The OCPP util module which supplies helpful utilities like cache and queue connectors, etc.

"use strict";
// Copyright (c) 2023 S44, LLC
// Copyright Contributors to the CitrineOS Project
//
// SPDX-License-Identifier: Apache 2.0
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedisCache = void 0;
const class_transformer_1 = require("class-transformer");
const redis_1 = require("redis");
/**
 * Implementation of cache interface with redis storage
 */
class RedisCache {
    constructor(clientOptions) {
        this._client = clientOptions ? (0, redis_1.createClient)(clientOptions) : (0, redis_1.createClient)();
        this._client.on('connect', () => console.log('Redis client connected'));
        this._client.on('ready', () => console.log('Redis client ready to use'));
        this._client.on('error', (err) => console.error('Redis error', err));
        this._client.on('end', () => console.log('Redis client disconnected'));
        this._client
            .connect()
            .then()
            .catch((error) => {
            console.log('Error connecting to Redis', error);
        });
    }
    exists(key, namespace) {
        namespace = namespace || 'default';
        key = `${namespace}:${key}`;
        return this._client.exists(key).then((result) => result === 1);
    }
    remove(key, namespace) {
        namespace = namespace || 'default';
        key = `${namespace}:${key}`;
        return this._client.del(key).then((result) => result === 1);
    }
    onChange(key, waitSeconds, namespace, classConstructor) {
        namespace = namespace || 'default';
        key = `${namespace}:${key}`;
        return new Promise((resolve) => {
            // Create a Redis subscriber to listen for operations affecting the key
            const subscriber = (0, redis_1.createClient)();
            // Channel: Key-space, message: the name of the event, which is the command executed on the key
            subscriber
                .subscribe(`__keyspace@0__:${key}`, (channel, message) => {
                switch (message) {
                    case 'set':
                        resolve(this.get(key, namespace, classConstructor));
                        subscriber
                            .quit()
                            .then()
                            .catch((error) => {
                            console.log('Error quitting subscriber', error);
                        });
                        break;
                    case 'del':
                    case 'expire':
                        resolve(null);
                        subscriber
                            .quit()
                            .then()
                            .catch((error) => {
                            console.log('Error quitting subscriber', error);
                        });
                        break;
                    default:
                        // Do nothing
                        break;
                }
            })
                .then()
                .catch((error) => {
                console.log('Error creating Redis subscriber', error);
            });
            setTimeout(() => {
                resolve(this.get(key, namespace, classConstructor));
                subscriber
                    .quit()
                    .then()
                    .catch((error) => {
                    console.log('Error closing Redis subscriber', error);
                });
            }, waitSeconds * 1000);
        });
    }
    get(key, namespace, classConstructor) {
        namespace = namespace || 'default';
        key = `${namespace}:${key}`;
        return this._client.get(key).then((result) => {
            if (result) {
                if (classConstructor) {
                    return (0, class_transformer_1.plainToInstance)(classConstructor(), JSON.parse(result));
                }
                return result;
            }
            return null;
        });
    }
    set(key, value, namespace, expireSeconds) {
        namespace = namespace || 'default';
        key = `${namespace}:${key}`;
        const setOptions = expireSeconds ? { EX: expireSeconds } : undefined;
        return this._client.set(key, value, setOptions).then((result) => {
            if (result) {
                return result === 'OK';
            }
            return false;
        });
    }
    setIfNotExist(key, value, namespace, expireSeconds) {
        namespace = namespace || 'default';
        key = `${namespace}:${key}`;
        return this._client
            .set(key, value, expireSeconds ? { EX: expireSeconds, NX: true } : { NX: true })
            .then((result) => {
            if (result) {
                return result === 'OK';
            }
            return false;
        });
    }
}
exports.RedisCache = RedisCache;
//# sourceMappingURL=redis.js.map