@a11ywatch/core/database/memory-client.js

a11ywatch central API

"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.redisConnected = exports.closeRedisConnection = exports.initRedisConnection = exports.redisClient = exports.createRedisClient = void 0;
const ioredis_1 = __importDefault(require("ioredis"));
const redisLogEnabled = process.env.REDIS_LOG_ENABLED === "true";
let redisConnected = false;
exports.redisConnected = redisConnected;
let redisClient;
exports.redisClient = redisClient;
const options = {
    host: process.env.REDIS_HOST || "127.0.0.1",
    port: 6379,
    autoResubscribe: false,
    autoResendUnfulfilledCommands: false,
    maxRetriesPerRequest: 0,
    lazyConnect: true,
    enableAutoPipelining: true,
    retryStrategy(times) {
        redisLogEnabled &&
            console.warn(`Retrying redis connection: attempt ${times}`);
        return null;
    },
    reconnectOnError(err) {
        if (err.message.includes("READONLY")) {
            return true;
        }
        return null;
    },
};
const createRedisClient = () => {
    let newClient = null;
    try {
        newClient = new ioredis_1.default(options);
    }
    catch (e) {
    }
    if (newClient) {
        newClient === null || newClient === void 0 ? void 0 : newClient.on("error", (error) => {
            redisLogEnabled && console.error("redis error", error);
            exports.redisConnected = redisConnected = false;
        });
        newClient === null || newClient === void 0 ? void 0 : newClient.on("connect", () => {
            exports.redisConnected = redisConnected = true;
        });
    }
    return newClient;
};
exports.createRedisClient = createRedisClient;
const initRedisConnection = () => __awaiter(void 0, void 0, void 0, function* () {
    return new Promise((resolve) => {
        const client = createRedisClient();
        if (client) {
            exports.redisClient = redisClient = client;
        }
        if (redisClient) {
            redisClient
                .connect()
                .catch((_) => { })
                .finally(() => {
                resolve(redisConnected);
            });
        }
        else {
            exports.redisConnected = redisConnected = false;
            resolve(false);
        }
    });
});
exports.initRedisConnection = initRedisConnection;
const closeRedisConnection = () => {
    if (redisClient) {
        try {
            redisClient === null || redisClient === void 0 ? void 0 : redisClient.disconnect();
        }
        catch (e) {
            console.error(e);
        }
    }
};
exports.closeRedisConnection = closeRedisConnection;
//# sourceMappingURL=memory-client.js.map