@getvision/server 0.4.2-107ad21-develop → 0.4.3-d4c761e-develop

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @getvision/server
 
+## 0.4.2
+
+### Patch Changes
+
+- 3b8f782: Add configurable BullMQ options for queue, worker, and queue events
+- 107ad21: bump package versions in bun.lock
+
 ## 0.4.1
 
 ### Patch Changes

package/README.md

@@ -205,6 +205,17 @@ const app = new Vision({
   },
   pubsub: {
     devMode: true,     // In-memory BullMQ for local dev
+    redis: {
+      host: 'localhost',
+      port: 6379,
+      password: 'your-password',
+      // Connection settings to prevent timeouts
+      keepAlive: 30000,              // Keep connection alive (30s)
+      maxRetriesPerRequest: 20,      // Retry failed commands
+      enableReadyCheck: true,        // Check Redis is ready
+      connectTimeout: 10000,         // Connection timeout (10s)
+      enableOfflineQueue: true       // Queue commands when offline
+    },
     // BullMQ options
     queue: {
       defaultJobOptions: {
@@ -362,6 +373,75 @@ app.service('users')
   })
 ```
 
+## Redis Connection Configuration
+
+### Preventing Connection Drops
+
+Redis connections can close due to timeouts or network issues, causing workers to fail with "Connection is closed" errors. Vision Server includes sensible defaults to help prevent this:
+
+```typescript
+const app = new Vision({
+  service: { name: 'My API' },
+  pubsub: {
+    devMode: false,  // Use Redis in production
+    redis: {
+      host: process.env.REDIS_HOST,
+      port: parseInt(process.env.REDIS_PORT || '6379'),
+      password: process.env.REDIS_PASSWORD,
+      // Connection settings (these are the defaults)
+      keepAlive: 30000,              // Keep connection alive (30s)
+      maxRetriesPerRequest: 20,      // Retry failed commands
+      enableReadyCheck: true,        // Check Redis is ready before commands
+      connectTimeout: 10000,         // Connection timeout (10s)
+      enableOfflineQueue: true       // Queue commands when offline
+    }
+  }
+})
+```
+
+**What this helps with:**
+- ✅ **keepAlive (30s)**: Helps prevent idle connection timeouts
+- ✅ **Automatic reconnection**: Retries up to 10 times with exponential backoff
+- ✅ **Connection settings**: Each Queue/Worker/QueueEvents uses these connection settings
+- ✅ **Offline queue**: Commands are queued when Redis is temporarily unavailable
+
+### Environment Variables
+
+You can also configure Redis via environment variables:
+
+```bash
+# Option 1: Redis URL (recommended)
+REDIS_URL=redis://:password@hostname:6379
+
+# Option 2: Individual variables
+REDIS_HOST=hostname
+REDIS_PORT=6379
+REDIS_PASSWORD=password
+```
+
+### Troubleshooting
+
+**"Connection is closed" errors:**
+- Vision Server now includes automatic reconnection with exponential backoff
+- Check logs for `🔄 Redis reconnecting...` messages
+- If reconnection fails after 10 attempts, check your Redis server health
+
+**"Could not renew lock for job" errors:**
+- This happens when workers lose connection during job processing
+- The new keepAlive setting (30s) prevents this
+- Increase `keepAlive` if you have very long-running jobs
+
+**Custom retry strategy:**
+```typescript
+pubsub: {
+  redis: {
+    // ... other settings
+    keepAlive: 60000,  // 60s for long-running jobs
+    maxRetriesPerRequest: 30  // More retries for unstable networks
+  }
+}
+```
+
 ## Hono Compatibility
 
 Vision extends Hono, so all Hono features work:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getvision/server",
-  "version": "0.4.2-107ad21-develop",
+  "version": "0.4.3-d4c761e-develop",
   "type": "module",
   "description": "Vision Server - Meta-framework with built-in observability, pub/sub, and type-safe APIs",
   "exports": {

package/src/event-bus.ts

@@ -10,6 +10,26 @@ export interface EventBusConfig {
     host?: string
     port?: number
     password?: string
+    /**
+     * Enable keepalive to prevent connection timeouts (default: true in production)
+     */
+    keepAlive?: number
+    /**
+     * Max retry attempts for failed commands (default: 20)
+     */
+    maxRetriesPerRequest?: number
+    /**
+     * Enable ready check before executing commands (default: true)
+     */
+    enableReadyCheck?: boolean
+    /**
+     * Connection timeout in ms (default: 10000)
+     */
+    connectTimeout?: number
+    /**
+     * Enable offline queue (default: true)
+     */
+    enableOfflineQueue?: boolean
   }
   queue?: Omit<QueueOptions, 'connection'>
   worker?: Omit<WorkerOptions, 'connection'>
@@ -86,6 +106,38 @@ export class EventBus {
     }
   }
 
+  /**
+   * Get Redis connection configuration
+   * Includes keepalive, retry strategy, and connection pooling
+   */
+  private getRedisConnection() {
+    const baseConfig = this.config.redis || {
+      host: 'localhost',
+      port: 6379,
+    }
+
+    return {
+      host: baseConfig.host,
+      port: baseConfig.port,
+      password: baseConfig.password,
+      keepAlive: baseConfig.keepAlive ?? 30000, // 30 seconds keepalive
+      maxRetriesPerRequest: baseConfig.maxRetriesPerRequest ?? 20,
+      enableReadyCheck: baseConfig.enableReadyCheck ?? true,
+      connectTimeout: baseConfig.connectTimeout ?? 10000,
+      enableOfflineQueue: baseConfig.enableOfflineQueue ?? true,
+      // Retry strategy for automatic reconnection
+      retryStrategy: (times: number) => {
+        if (times > 10) {
+          console.error('❌ Redis connection failed after 10 retries')
+          return null // Stop retrying
+        }
+        const delay = Math.min(times * 200, 3000)
+        console.log(`🔄 Redis reconnecting... attempt ${times}, delay ${delay}ms`)
+        return delay
+      },
+    }
+  }
+
   /**
    * Get or create a queue for an event
    */
@@ -97,13 +149,9 @@ export class EventBus {
 
     let queue = this.queues.get(eventName)
     if (!queue) {
-      const connection = this.config.redis || {
-        host: 'localhost',
-        port: 6379,
-      }
       queue = new Queue(eventName, {
         ...(this.config.queue || {}),
-        connection,
+        connection: this.getRedisConnection(),
       })
       this.queues.set(eventName, queue)
     }
@@ -206,10 +254,6 @@ export class EventBus {
       this.devModeHandlers.set(eventName, handlers)
     } else {
       // Production mode - create BullMQ worker
-      const connection = this.config.redis || {
-        host: 'localhost',
-        port: 6379,
-      }
       const workerKey = `${eventName}-handler`
       
       // Close existing worker if it exists
@@ -231,7 +275,7 @@ export class EventBus {
         },
         {
           ...(this.config.worker || {}),
-          connection,
+          connection: this.getRedisConnection(),
           concurrency:
             options?.concurrency ??
             this.config.workerConcurrency ??
@@ -244,13 +288,9 @@ export class EventBus {
 
       // Listen to queue events
       if (!this.queueEvents.has(eventName)) {
-        const connection = this.config.redis || {
-          host: 'localhost',
-          port: 6379,
-        }
         const queueEvents = new QueueEvents(eventName, {
           ...(this.config.queueEvents || {}),
-          connection,
+          connection: this.getRedisConnection(),
         })
 
         queueEvents.on('completed', ({ jobId }) => {
@@ -284,10 +324,6 @@ export class EventBus {
       this.devModeHandlers.set(cronName, handlers)
     } else {
       // Production mode - create BullMQ worker for cron jobs
-      const connection = this.config.redis || {
-        host: 'localhost',
-        port: 6379,
-      }
       const cronWorkerKey = `${cronName}-handler`
       
       // Close existing cron worker if it exists
@@ -315,7 +351,7 @@ export class EventBus {
         },
         {
           ...(this.config.worker || {}),
-          connection,
+          connection: this.getRedisConnection(),
           concurrency: this.config.worker?.concurrency ?? 1,
         }
       )
@@ -326,7 +362,7 @@ export class EventBus {
       if (!this.queueEvents.has(cronName)) {
         const queueEvents = new QueueEvents(cronName, {
           ...(this.config.queueEvents || {}),
-          connection,
+          connection: this.getRedisConnection(),
         })
 
         queueEvents.on('completed', ({ jobId }) => {

package/src/vision-app.ts

@@ -124,6 +124,26 @@ export interface VisionConfig {
       host?: string
       port?: number
       password?: string
+      /**
+       * Enable keepalive to prevent connection timeouts (default: 30000ms)
+       */
+      keepAlive?: number
+      /**
+       * Max retry attempts for failed commands (default: 20)
+       */
+      maxRetriesPerRequest?: number
+      /**
+       * Enable ready check before executing commands (default: true)
+       */
+      enableReadyCheck?: boolean
+      /**
+       * Connection timeout in ms (default: 10000)
+       */
+      connectTimeout?: number
+      /**
+       * Enable offline queue (default: true)
+       */
+      enableOfflineQueue?: boolean
     }
     devMode?: boolean  // Use in-memory event bus (no Redis required)
     eventBus?: EventBus  // Share EventBus instance across apps (for sub-apps)