@prashant-neosoft-ecommerce/shared 1.0.3 → 1.0.6

package/middleware/rateLimiter.js

@@ -3,12 +3,25 @@ const { RedisStore } = require("rate-limit-redis");
 const redisClient = require("../utils/redis");
 
 const createRateLimiter = (options = {}) => {
+  // Check if Redis client is connected
+  if (!redisClient.client || !redisClient.isConnected) {
+    console.warn("Redis not connected, using memory store for rate limiting");
+    return rateLimit({
+      windowMs: options.windowMs || 15 * 60 * 1000,
+      max: options.max || 100,
+      message: options.message || "Too many requests, please try again later.",
+      standardHeaders: true,
+      legacyHeaders: false,
+    });
+  }
+
   return rateLimit({
     store: new RedisStore({
-      client: redisClient.client,
-      prefix: "rl:",
+      // Use sendCommand method from ioredis client
+      sendCommand: (...args) => redisClient.client.call(...args),
+      prefix: options.prefix || "rl:",
     }),
-    windowMs: options.windowMs || 15 * 60 * 1000, // 15 minutes
+    windowMs: options.windowMs || 15 * 60 * 1000,
     max: options.max || 100,
     message: options.message || "Too many requests, please try again later.",
     standardHeaders: true,
@@ -16,13 +29,16 @@ const createRateLimiter = (options = {}) => {
   });
 };
 
-const strictLimiter = createRateLimiter({ max: 5, windowMs: 60 * 1000 });
-const standardLimiter = createRateLimiter({ max: 100 });
-const generousLimiter = createRateLimiter({ max: 1000 });
-
+// Export factory functions that create limiters on-demand
 module.exports = {
   createRateLimiter,
-  strictLimiter,
-  standardLimiter,
-  generousLimiter,
+  get strictLimiter() {
+    return createRateLimiter({ max: 5, windowMs: 60 * 1000 });
+  },
+  get standardLimiter() {
+    return createRateLimiter({ max: 100 });
+  },
+  get generousLimiter() {
+    return createRateLimiter({ max: 1000 });
+  },
 };

package/middleware/validation.js

@@ -40,6 +40,9 @@ const schemas = {
     stock: Joi.number().integer().min(0).required(),
     category: Joi.string().required(),
     sku: Joi.string().required(),
+    images: Joi.array().items(Joi.string().uri()).optional(),
+    isActive: Joi.boolean().optional(),
+    metadata: Joi.object().unknown(true).optional(),
   }),
 
   order: Joi.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prashant-neosoft-ecommerce/shared",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "added by prashant",
   "main": "index.js",
   "scripts": {

package/utils/redis.js

@@ -7,64 +7,92 @@ class RedisClient {
     this.isConnected = false;
   }
 
-  connect() {
-    if (this.client) return this.client;
-
-    this.client = new Redis({
-      host: process.env.REDIS_HOST || "redis-srv",
-      port: process.env.REDIS_PORT || 6379,
-      maxRetriesPerRequest: null,
-      enableReadyCheck: true,
-      retryStrategy(times) {
-        const delay = Math.min(times * 50, 2000);
-        return delay;
-      },
-    });
-
-    this.client.on("connect", () => {
-      this.isConnected = true;
-      logger.info("Redis connected");
-    });
-
-    this.client.on("error", (err) => {
-      logger.error("Redis error", err);
-    });
-
-    return this.client;
-  }
+  async connect() {
+    try {
+      this.client = new Redis({
+        host: process.env.REDIS_HOST || "localhost",
+        port: process.env.REDIS_PORT || 6379,
+        retryStrategy: (times) => {
+          const delay = Math.min(times * 50, 2000);
+          return delay;
+        },
+        lazyConnect: false, // Connect immediately
+      });
+
+      this.client.on("connect", () => {
+        this.isConnected = true;
+        logger.info("Redis connected successfully");
+      });
+
+      this.client.on("ready", () => {
+        this.isConnected = true;
+        logger.info("Redis ready to accept commands");
+      });
 
-  getClient() {
-    if (!this.client) {
-      this.connect();
+      this.client.on("error", (err) => {
+        this.isConnected = false;
+        logger.error("Redis error:", err);
+      });
+
+      this.client.on("close", () => {
+        this.isConnected = false;
+        logger.warn("Redis connection closed");
+      });
+
+      // Wait for connection to be ready
+      await this.client.ping();
+
+      return this.client;
+    } catch (error) {
+      this.isConnected = false;
+      logger.error("Redis connection failed:", error);
+      // Don't throw error, allow app to continue without Redis
+      return null;
     }
-    return this.client;
   }
 
   async get(key) {
+    if (!this.isConnected) return null;
+
     try {
-      return await this.getClient().get(key);
-    } catch (err) {
-      logger.error("Redis GET error", err);
+      return await this.client.get(key);
+    } catch (error) {
+      logger.error(`Redis GET error for key ${key}:`, error);
       return null;
     }
   }
 
-  async set(key, value, ttl = 300) {
+  async set(key, value, expireSeconds = 300) {
+    if (!this.isConnected) return;
+
     try {
       if (typeof value === "object") {
         value = JSON.stringify(value);
       }
-      await this.getClient().set(key, value, "EX", ttl);
-    } catch (err) {
-      logger.error("Redis SET error", err);
+      await this.client.set(key, value, "EX", expireSeconds);
+    } catch (error) {
+      logger.error(`Redis SET error for key ${key}:`, error);
     }
   }
 
   async del(key) {
+    if (!this.isConnected) return;
+
+    try {
+      await this.client.del(key);
+    } catch (error) {
+      logger.error(`Redis DEL error for key ${key}:`, error);
+    }
+  }
+
+  async exists(key) {
+    if (!this.isConnected) return false;
+
     try {
-      await this.getClient().del(key);
-    } catch (err) {
-      logger.error("Redis DEL error", err);
+      return await this.client.exists(key);
+    } catch (error) {
+      logger.error(`Redis EXISTS error for key ${key}:`, error);
+      return false;
     }
   }
 }