@gravityai-dev/gravity-server/dist/RedisManager.js

Integration SDK for the Gravity AI orchestration platform - Connect any AI platform in minutes

"use strict";
/**
 * Redis Connection Manager
 *
 * Centralizes Redis connection management to avoid redundant connections.
 * Maintains separate pools for standard and pub/sub connections.
 */
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Redis = void 0;
exports.getStandardConnection = getStandardConnection;
exports.getPubSubConnection = getPubSubConnection;
exports.getRedisOptions = getRedisOptions;
exports.getOptionsFromConfig = getOptionsFromConfig;
exports.closeAllConnections = closeAllConnections;
const ioredis_1 = __importDefault(require("ioredis"));
exports.Redis = ioredis_1.default;
// Connection pools
const standardConnections = new Map();
const pubsubConnections = new Map();
/**
 * Get a unique key based on connection options
 */
function getConnectionKey(options) {
    return `${options.host}:${options.port}:${options.db || 0}:${options.username || ""}`;
}
/**
 * Create a Redis configuration with sensible defaults
 */
function createConfig(options) {
    const config = {
        host: options.host,
        port: options.port,
        db: options.db || 0,
        retryStrategy: (times) => Math.min(times * 50, 2000),
        maxRetriesPerRequest: 3,
        enableOfflineQueue: true,
        // Add other common options here
    };
    // Handle authentication - token takes precedence over username/password
    if (options.token) {
        // For token authentication, use 'default' as username and token as password
        config.username = 'default';
        config.password = options.token;
    }
    else if (options.username && options.password) {
        config.username = options.username;
        config.password = options.password;
    }
    else if (options.password) {
        // Legacy mode: password only (no username)
        config.password = options.password;
    }
    // Handle TLS configuration
    if (options.tls !== undefined) {
        config.tls = options.tls === true ? {} : options.tls;
    }
    return config;
}
/**
 * Get a Redis connection for standard commands
 * Reuses existing connections when possible
 */
function getStandardConnection(options) {
    // Create a unique key for the connection pool based on connection parameters
    const connectionKey = getConnectionKey(options);
    if (standardConnections.has(connectionKey)) {
        return standardConnections.get(connectionKey);
    }
    // Use the centralized config creation
    const config = createConfig(options);
    const client = new ioredis_1.default(config);
    standardConnections.set(connectionKey, client);
    return client;
}
/**
 * Get a dedicated Redis connection for pub/sub operations
 * Always creates a new connection for pub/sub to avoid conflicts
 */
function getPubSubConnection(options) {
    const connectionKey = `${options.host}:${options.port}:${options.db || 0}:${options.username || 'default'}`;
    if (pubsubConnections.has(connectionKey)) {
        return pubsubConnections.get(connectionKey);
    }
    const config = createConfig(options);
    const client = new ioredis_1.default(config);
    pubsubConnections.set(connectionKey, client);
    return client;
}
/**
 * Get Redis options from environment variables
 */
function getRedisOptions() {
    return {
        host: process.env.REDIS_HOST,
        port: parseInt(process.env.REDIS_PORT, 10),
        username: process.env.REDIS_USERNAME,
        password: process.env.REDIS_PASSWORD,
        token: process.env.REDIS_TOKEN,
    };
}
/**
 * Create RedisOptions from server config values
 * Preferred method for proper Redis configuration
 */
function getOptionsFromConfig(host, port, username, password, token) {
    return {
        host,
        port,
        username: username || undefined,
        password: password || undefined,
        token: token || undefined,
    };
}
/**
 * Close all connections in the pool
 * Useful for cleanup or tests
 */
async function closeAllConnections() {
    const closePromises = [];
    standardConnections.forEach((client, key) => {
        closePromises.push(client.quit().then(() => {
            standardConnections.delete(key);
            return `Standard connection ${key}`;
        }));
    });
    pubsubConnections.forEach((client, key) => {
        closePromises.push(client.quit().then(() => {
            pubsubConnections.delete(key);
            return `PubSub connection ${key}`;
        }));
    });
    await Promise.all(closePromises);
}
//# sourceMappingURL=RedisManager.js.map