@digicroz/node-backend-utils/dist/redis/redisBase.cjs

Backend utilities for Node.js applications - Redis client wrappers and more utilities for TypeScript/JavaScript projects

'use strict';

var redis = require('redis');

// src/redis/redisBase.ts
var RedisDatabase = class _RedisDatabase {
  constructor() {
    this.client = null;
    this.isConnecting = false;
    this.isConnected = false;
    this.initializationAttempted = false;
    this.redisUrl = null;
  }
  static getInstance() {
    if (!_RedisDatabase.instance) {
      _RedisDatabase.instance = new _RedisDatabase();
    }
    return _RedisDatabase.instance;
  }
  async initialize(config) {
    if (this.initializationAttempted) {
      return;
    }
    this.initializationAttempted = true;
    this.redisUrl = config.url;
    try {
      await this.connect();
      console.log("Redis initialized successfully at application startup");
    } catch (error) {
      console.warn(
        "Redis initialization failed (non-critical), app will continue without Redis:",
        error
      );
    }
  }
  getClient() {
    if (this.isConnected && this.client) {
      return this.client;
    }
    return null;
  }
  async connect() {
    if (this.isConnecting || this.isConnected && this.client) {
      return this.client;
    }
    if (!this.redisUrl) {
      throw new Error(
        "Redis URL is required. Call initialize() with config first."
      );
    }
    this.isConnecting = true;
    try {
      this.client = redis.createClient({
        url: this.redisUrl
      });
      this.client.on("error", (err) => {
        console.warn("Redis Client Error (non-critical):", err);
        this.isConnected = false;
      });
      this.client.on("connect", () => {
        console.log("Redis Client Connected");
        this.isConnected = true;
      });
      this.client.on("disconnect", () => {
        console.log("Redis Client Disconnected");
        this.isConnected = false;
      });
      await this.client.connect();
      this.isConnected = true;
      this.isConnecting = false;
      return this.client;
    } catch (error) {
      console.warn("Failed to connect to Redis (non-critical):", error);
      this.isConnecting = false;
      this.isConnected = false;
      this.client = null;
      throw error;
    }
  }
  async disconnect() {
    try {
      if (this.client && this.isConnected) {
        await this.client.quit();
        this.isConnected = false;
        this.client = null;
      }
    } catch (error) {
      console.warn("Error disconnecting from Redis (non-critical):", error);
      this.isConnected = false;
      this.client = null;
    }
  }
  isClientConnected() {
    return this.isConnected && this.client !== null;
  }
  async safeExecute(operation) {
    try {
      const client = this.getClient();
      if (!client) {
        return null;
      }
      return await operation(client);
    } catch (error) {
      console.warn("Redis operation failed (non-critical):", error);
      return null;
    }
  }
  getStatus() {
    return {
      isConnected: this.isConnected,
      isConnecting: this.isConnecting,
      initializationAttempted: this.initializationAttempted
    };
  }
};
var redisBase = RedisDatabase.getInstance();

exports.redisBase = redisBase;
//# sourceMappingURL=redisBase.cjs.map
//# sourceMappingURL=redisBase.cjs.map