@di-zed/yandex-smart-home/dist/providers/redisProvider.js

The Yandex Smart Home skills for the different device types.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedisProvider = void 0;
/**
 * @author DiZed Team
 * @copyright Copyright (c) DiZed Team (https://github.com/di-zed/)
 */
const fs_1 = __importDefault(require("fs"));
const redis_1 = require("redis");
const configProvider_1 = __importDefault(require("./configProvider"));
/**
 * Redis Provider.
 */
class RedisProvider {
    constructor() {
        /**
         * Redis Client.
         *
         * @protected
         */
        this.client = undefined;
    }
    /**
     * Get Redis Client.
     *
     * @returns RedisClientType | undefined
     */
    getClient() {
        return this.client;
    }
    /**
     * Get Redis Client.
     * Async method with reconnect possibility.
     *
     * @returns Promise<RedisClientType>
     */
    getClientAsync() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.client === undefined) {
                this.client = yield this.connect();
            }
            return this.client;
        });
    }
    /**
     * Connection.
     *
     * @returns Promise<RedisClientType>
     * @see https://github.com/redis/node-redis?tab=readme-ov-file#usage
     */
    connect() {
        return __awaiter(this, void 0, void 0, function* () {
            const username = process.env.REDIS_USERNAME.trim();
            const password = process.env.REDIS_PASSWORD.trim();
            const host = process.env.REDIS_HOST.trim();
            const port = parseInt(process.env.REDIS_CONTAINER_PORT, 10);
            const dbNumber = parseInt(process.env.REDIS_DB_NUMBER, 10);
            const tls = process.env.REDIS_TLS.trim();
            const ca = process.env.REDIS_CA.trim();
            const cert = process.env.REDIS_CERT.trim();
            const key = process.env.REDIS_KEY.trim();
            const rejectUnauthorized = process.env.REDIS_REJECT_UNAUTHORIZED.trim();
            let connectionString = tls === '1' ? 'rediss://' : 'redis://';
            if (username && password) {
                connectionString += username + ':' + password + '@';
            }
            connectionString += host + ':' + port;
            if (!isNaN(dbNumber)) {
                connectionString += '/' + dbNumber;
            }
            const socketOptions = {};
            if (tls === '1') {
                socketOptions.tls = true;
                if (ca) {
                    socketOptions.ca = fs_1.default.readFileSync(ca);
                }
                if (cert) {
                    socketOptions.cert = fs_1.default.readFileSync(cert);
                }
                if (key) {
                    socketOptions.key = fs_1.default.readFileSync(key);
                }
                if (rejectUnauthorized) {
                    socketOptions.rejectUnauthorized = rejectUnauthorized === '1';
                }
            }
            const client = (0, redis_1.createClient)({
                url: connectionString,
                socket: socketOptions,
            });
            client.on('error', (err) => console.log('ERROR! Redis Connect.', err));
            // client.on('connect', (): void => console.log('Redis Connected!'));
            // client.on('reconnecting', (): void => console.log('Redis Reconnecting...'));
            client.on('ready', () => {
                const callbackRedisIsReady = configProvider_1.default.getConfigOption('callbackRedisIsReady');
                if (typeof callbackRedisIsReady === 'function') {
                    callbackRedisIsReady(client);
                }
                console.log('Redis is Ready!');
            });
            this.client = yield client.connect();
            return this.client;
        });
    }
}
exports.RedisProvider = RedisProvider;
exports.default = new RedisProvider();