queen-mq 0.1.1 → 0.1.2

package/src/managers/systemEventManager.js

@@ -1,4 +1,5 @@
 import { generateUUID } from '../utils/uuid.js';
+import config from '../config.js';
 
 export const SYSTEM_QUEUE = '__system_events__';
 
@@ -24,6 +25,7 @@ export class SystemEventManager {
     this.handlers = new Map();
     this.eventQueue = [];
     this.batchTimer = null;
+    this.enabled = config.SYSTEM_EVENTS.ENABLED;
   }
   
   // Register event handlers
@@ -48,9 +50,12 @@ export class SystemEventManager {
     // Handle locally first (immediate consistency for originating server)
     await this.handleEventLocally(event);
     
-    // Queue for batch publishing
-    this.eventQueue.push(event);
-    this.scheduleBatch();
+    // Only publish to system queue if system events are enabled
+    if (this.enabled) {
+      // Queue for batch publishing
+      this.eventQueue.push(event);
+      this.scheduleBatch();
+    }
   }
   
   // Process incoming event from system queue

package/src/routes/messages.js

@@ -12,23 +12,31 @@ export const createMessagesRoutes = (pool, queueManager) => {
         m.id,
         m.transaction_id,
         m.payload,
-        m.status,
-        m.worker_id,
         m.created_at,
-        m.locked_at,
-        m.completed_at,
-        m.failed_at,
-        m.error_message,
-        m.retry_count,
-        m.lease_expires_at,
+        m.trace_id,
         q.name || '/' || p.name as queue_path,
         q.name as queue_name,
         p.name as partition_name,
         q.namespace,
-        q.task
+        q.task,
+        q.priority as queue_priority,
+        pc.lease_expires_at,
+        pc.last_consumed_created_at,
+        pc.last_consumed_id,
+        CASE
+          WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
+          WHEN pc.last_consumed_created_at IS NOT NULL AND (
+            m.created_at < pc.last_consumed_created_at OR 
+            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+          ) THEN 'completed'
+          ELSE 'pending'
+        END as message_status
       FROM queen.messages m
       JOIN queen.partitions p ON p.id = m.partition_id
       JOIN queen.queues q ON q.id = p.queue_id
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
+      LEFT JOIN queen.dead_letter_queue dlq ON dlq.message_id = m.id
       WHERE 1=1
     `;
     
@@ -52,11 +60,20 @@ export const createMessagesRoutes = (pool, queueManager) => {
       query += ` AND q.task = $${++paramCount}`;
     }
     if (status) {
+      // Filter by computed status
       params.push(status);
-      query += ` AND m.status = $${++paramCount}`;
+      query += ` AND CASE
+          WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
+          WHEN pc.last_consumed_created_at IS NOT NULL AND (
+            m.created_at < pc.last_consumed_created_at OR 
+            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+          ) THEN 'completed'
+          ELSE 'pending'
+        END = $${++paramCount}`;
     }
     
-    query += ` ORDER BY m.created_at DESC`;
+    query += ` ORDER BY m.created_at DESC, m.id DESC`;
     
     params.push(limit);
     query += ` LIMIT $${++paramCount}`;
@@ -75,14 +92,10 @@ export const createMessagesRoutes = (pool, queueManager) => {
       namespace: row.namespace,
       task: row.task,
       payload: row.payload,
-      status: row.status,
-      workerId: row.worker_id,
+      status: row.message_status,
+      traceId: row.trace_id,
+      queuePriority: row.queue_priority,
       createdAt: row.created_at,
-      lockedAt: row.locked_at,
-      completedAt: row.completed_at,
-      failedAt: row.failed_at,
-      errorMessage: row.error_message,
-      retryCount: row.retry_count,
       leaseExpiresAt: row.lease_expires_at
     }));
   };
@@ -91,7 +104,12 @@ export const createMessagesRoutes = (pool, queueManager) => {
   const getMessage = async (transactionId) => {
     const result = await pool.query(`
       SELECT 
-        m.*,
+        m.id,
+        m.transaction_id,
+        m.partition_id,
+        m.payload,
+        m.created_at,
+        m.trace_id,
         q.name || '/' || p.name as queue_path,
         q.name as queue_name,
         p.name as partition_name,
@@ -101,10 +119,26 @@ export const createMessagesRoutes = (pool, queueManager) => {
         q.retry_limit,
         q.retry_delay,
         q.ttl,
-        q.priority
+        q.priority as queue_priority,
+        pc.lease_expires_at,
+        pc.last_consumed_created_at,
+        pc.last_consumed_id,
+        dlq.error_message,
+        dlq.retry_count,
+        CASE
+          WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
+          WHEN pc.last_consumed_created_at IS NOT NULL AND (
+            m.created_at < pc.last_consumed_created_at OR 
+            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+          ) THEN 'completed'
+          ELSE 'pending'
+        END as message_status
       FROM queen.messages m
       JOIN queen.partitions p ON p.id = m.partition_id
       JOIN queen.queues q ON q.id = p.queue_id
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
+      LEFT JOIN queen.dead_letter_queue dlq ON dlq.message_id = m.id
       WHERE m.transaction_id = $1
     `, [transactionId]);
     
@@ -122,12 +156,9 @@ export const createMessagesRoutes = (pool, queueManager) => {
       namespace: row.namespace,
       task: row.task,
       payload: row.payload,
-      status: row.status,
-      workerId: row.worker_id,
+      status: row.message_status,
+      traceId: row.trace_id,
       createdAt: row.created_at,
-      lockedAt: row.locked_at,
-      completedAt: row.completed_at,
-      failedAt: row.failed_at,
       errorMessage: row.error_message,
       retryCount: row.retry_count,
       leaseExpiresAt: row.lease_expires_at,
@@ -136,7 +167,7 @@ export const createMessagesRoutes = (pool, queueManager) => {
         retryLimit: row.retry_limit,
         retryDelay: row.retry_delay,
         ttl: row.ttl,
-        priority: row.priority
+        priority: row.queue_priority
       }
     };
   };
@@ -157,48 +188,74 @@ export const createMessagesRoutes = (pool, queueManager) => {
     return { deleted: true, transactionId };
   };
   
-  // Retry message
+  // Retry message (remove from DLQ - cursor will process it if not consumed yet)
   const retryMessage = async (transactionId) => {
-    const result = await pool.query(`
-      UPDATE queen.messages 
-      SET 
-        status = 'pending',
-        worker_id = NULL,
-        locked_at = NULL,
-        lease_expires_at = NULL,
-        retry_count = retry_count + 1,
-        error_message = NULL
-      WHERE transaction_id = $1 
-        AND status IN ('failed', 'dead_letter')
-      RETURNING id, retry_count
+    // Find the message
+    const msgCheck = await pool.query(`
+      SELECT m.id, m.partition_id, m.created_at,
+             dlq.consumer_group, dlq.retry_count
+      FROM queen.messages m
+      LEFT JOIN queen.dead_letter_queue dlq ON dlq.message_id = m.id
+      WHERE m.transaction_id = $1
     `, [transactionId]);
     
-    if (result.rows.length === 0) {
-      throw new Error('Message not found or not in failed state');
+    if (msgCheck.rows.length === 0) {
+      throw new Error('Message not found');
+    }
+    
+    const msg = msgCheck.rows[0];
+    
+    if (!msg.consumer_group) {
+      throw new Error('Message is not in DLQ, cannot retry');
     }
     
-    log(`${LogTypes.RETRY} | TransactionId: ${transactionId} | NewRetryCount: ${result.rows[0].retry_count}`);
-    return { retried: true, transactionId };
+    const consumerGroup = msg.consumer_group;
+    const newRetryCount = (msg.retry_count || 0) + 1;
+    
+    // Remove from DLQ - message will be available for consumption if before cursor
+    const deleteResult = await pool.query(`
+      DELETE FROM queen.dead_letter_queue
+      WHERE message_id = $1 AND consumer_group = $2
+      RETURNING message_id
+    `, [msg.id, consumerGroup]);
+    
+    if (deleteResult.rows.length === 0) {
+      throw new Error('Message not found in DLQ');
+    }
+    
+    log(`${LogTypes.RETRY} | TransactionId: ${transactionId} | ConsumerGroup: ${consumerGroup}`);
+    return { retried: true, transactionId, consumerGroup };
   };
   
   // Move message to DLQ
-  const moveToDLQ = async (transactionId) => {
+  const moveToDLQ = async (transactionId, consumerGroup = '__QUEUE_MODE__', errorMessage = 'Manually moved to DLQ') => {
+    // Find the message
+    const msgCheck = await pool.query(`
+      SELECT m.id, m.partition_id, m.created_at
+      FROM queen.messages m
+      WHERE m.transaction_id = $1
+    `, [transactionId]);
+    
+    if (msgCheck.rows.length === 0) {
+      throw new Error('Message not found');
+    }
+    
+    const msg = msgCheck.rows[0];
+    
+    // Insert into dead_letter_queue
     const result = await pool.query(`
-      UPDATE queen.messages 
-      SET 
-        status = 'dead_letter',
-        failed_at = NOW()
-      WHERE transaction_id = $1 
-        AND status = 'failed'
+      INSERT INTO queen.dead_letter_queue (message_id, partition_id, consumer_group, error_message, retry_count, original_created_at)
+      VALUES ($1, $2, $3, $4, 0, $5)
+      ON CONFLICT DO NOTHING
       RETURNING id
-    `, [transactionId]);
+    `, [msg.id, msg.partition_id, consumerGroup, errorMessage, msg.created_at]);
     
     if (result.rows.length === 0) {
-      throw new Error('Message not found or not in failed state');
+      throw new Error('Message already in DLQ for this consumer group');
     }
     
-    log(`${LogTypes.MANUAL_DLQ} | TransactionId: ${transactionId} | MessageId: ${result.rows[0].id}`);
-    return { movedToDLQ: true, transactionId };
+    log(`${LogTypes.MANUAL_DLQ} | TransactionId: ${transactionId} | MessageId: ${msg.id} | ConsumerGroup: ${consumerGroup}`);
+    return { movedToDLQ: true, transactionId, messageId: msg.id };
   };
   
   // Get related messages (same partition, near in time)
@@ -220,10 +277,23 @@ export const createMessagesRoutes = (pool, queueManager) => {
     const result = await pool.query(`
       SELECT 
         m.transaction_id,
-        m.status,
         m.created_at,
-        m.payload
+        m.payload,
+        pc.lease_expires_at,
+        pc.last_consumed_created_at,
+        pc.last_consumed_id,
+        CASE
+          WHEN dlq.message_id IS NOT NULL THEN 'dead_letter'
+          WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 'processing'
+          WHEN pc.last_consumed_created_at IS NOT NULL AND (
+            m.created_at < pc.last_consumed_created_at OR 
+            (m.created_at = pc.last_consumed_created_at AND m.id <= pc.last_consumed_id)
+          ) THEN 'completed'
+          ELSE 'pending'
+        END as message_status
       FROM queen.messages m
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = m.partition_id AND pc.consumer_group = '__QUEUE_MODE__'
+      LEFT JOIN queen.dead_letter_queue dlq ON dlq.message_id = m.id
       WHERE m.partition_id = $1
         AND m.transaction_id != $2
         AND m.created_at BETWEEN $3::timestamp - INTERVAL '1 hour' 
@@ -234,7 +304,7 @@ export const createMessagesRoutes = (pool, queueManager) => {
     
     return result.rows.map(row => ({
       transactionId: row.transaction_id,
-      status: row.status,
+      status: row.message_status,
       createdAt: row.created_at,
       payload: row.payload
     }));

package/src/routes/pop.js

@@ -13,70 +13,54 @@ export const createPopRoute = (queueManager, eventManager) => {
     const maxTimeout = config.QUEUE.MAX_TIMEOUT;
     const effectiveTimeout = Math.min(timeout, maxTimeout);
     
-    // Handle different pop scenarios
-    if (scope.namespace || scope.task) {
-      // Pop with filters (namespace or task)
-      let result = await queueManager.popMessagesWithFilters(scope, { batch, wait: false, timeout: effectiveTimeout });
-      
-      if (result.messages.length > 0 || !wait) {
-        return result;
-      }
-      
-      // Simple polling for filtered pops (no specific queue path to wait on)
-      const startTime = Date.now();
-      const pollInterval = Math.min(config.QUEUE.POLL_INTERVAL_FILTERED, effectiveTimeout / 10);
-      
-      while (Date.now() - startTime < effectiveTimeout) {
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
-        result = await queueManager.popMessagesWithFilters(scope, { batch, wait: false });
-        if (result.messages.length > 0) {
-          return result;
-        }
-      }
-      
-      return { messages: [] };
-    }
-    
-    // Regular queue/partition pop (now with consumer group support)
-    const popScope = {
-      ...scope,
-      consumerGroup: consumerGroup || scope.consumerGroup
-    };
-    
-    const popOptions = {
+    // ALWAYS USE UNIFIED POP - handles all 3 modes (direct, queue-level, filtered)
+    let result = await queueManager.uniquePop(scope, { 
       batch, 
       wait: false, 
-      timeout: effectiveTimeout,
-      subscriptionMode,
-      subscriptionFrom
-    };
-    
-    let result = await queueManager.popMessages(popScope, popOptions);
+      timeout: effectiveTimeout, 
+      subscriptionMode, 
+      subscriptionFrom 
+    });
     
     if (result.messages.length > 0 || !wait) {
       return result;
     }
     
-    // Long polling with event-driven optimization
+    // Long polling with event-driven optimization and exponential backoff
     const queuePath = scope.partition 
       ? `${scope.queue}/${scope.partition}`
       : scope.queue;
     
     const startTime = Date.now();
-    const pollInterval = Math.min(config.QUEUE.POLL_INTERVAL, effectiveTimeout / 10);
+    const initialPollInterval = Math.min(config.QUEUE.POLL_INTERVAL, effectiveTimeout / 10);
+    const maxPollInterval = config.QUEUE.MAX_POLL_INTERVAL || 2000; // Default 2 seconds
+    const backoffThreshold = config.QUEUE.BACKOFF_THRESHOLD || 5; // Retries before backoff
+    const backoffMultiplier = config.QUEUE.BACKOFF_MULTIPLIER || 2;
+    
+    let currentPollInterval = initialPollInterval;
+    let consecutiveEmptyPolls = 0;
     
     while (Date.now() - startTime < effectiveTimeout) {
-      // Wait for message notification or short timeout
+      // Wait for message notification or current poll interval
       const notification = await Promise.race([
-        eventManager.waitForMessage(queuePath, pollInterval),
-        new Promise(resolve => setTimeout(() => resolve(null), pollInterval))
+        eventManager.waitForMessage(queuePath, currentPollInterval),
+        new Promise(resolve => setTimeout(() => resolve(null), currentPollInterval))
       ]);
       
       // Try to get messages whether notified or not
-      result = await queueManager.popMessages(popScope, popOptions);
+      result = await queueManager.uniquePop(scope, { batch, wait: false, subscriptionMode, subscriptionFrom });
       if (result.messages.length > 0) {
         return result;
       }
+      
+      // Implement exponential backoff after threshold
+      consecutiveEmptyPolls++;
+      if (consecutiveEmptyPolls >= backoffThreshold) {
+        currentPollInterval = Math.min(
+          currentPollInterval * backoffMultiplier,
+          maxPollInterval
+        );
+      }
     }
     
     // Timeout reached, no messages

package/src/routes/resources.js

@@ -1,4 +1,6 @@
-export const createResourcesRoutes = (pool) => {
+import { EventTypes } from '../managers/systemEventManager.js';
+
+export const createResourcesRoutes = (pool, systemEventManager) => {
   
   // Get all queues with their partitions
   const getQueues = async (filters = {}) => {
@@ -13,12 +15,12 @@ export const createResourcesRoutes = (pool) => {
         q.created_at as queue_created_at,
         COUNT(DISTINCT p.id) as partition_count,
         COUNT(DISTINCT m.id) as message_count,
-        COUNT(DISTINCT CASE WHEN ms.status = 'pending' THEN m.id END) as pending_count,
-        COUNT(DISTINCT CASE WHEN ms.status = 'processing' THEN m.id END) as processing_count
+        COALESCE(SUM(DISTINCT pc.pending_estimate), 0) as pending_count,
+        COUNT(DISTINCT CASE WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN p.id END) as processing_count
       FROM queen.queues q
       LEFT JOIN queen.partitions p ON p.queue_id = q.id
       LEFT JOIN queen.messages m ON m.partition_id = p.id
-      LEFT JOIN queen.messages_status ms ON ms.message_id = m.id AND ms.consumer_group IS NULL
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
       WHERE 1=1
     `;
     
@@ -72,25 +74,27 @@ export const createResourcesRoutes = (pool) => {
     
     const queue = queueResult.rows[0];
     
-    // Get partitions with stats (partitions no longer have options or priority)
+    // Get partitions with stats using partition_consumers
     const partitionsResult = await pool.query(`
       SELECT 
         p.id,
         p.name,
         p.created_at,
         COUNT(DISTINCT m.id) as message_count,
-        COUNT(DISTINCT CASE WHEN ms.status = 'pending' THEN m.id END) as pending,
-        COUNT(DISTINCT CASE WHEN ms.status = 'processing' THEN m.id END) as processing,
-        COUNT(DISTINCT CASE WHEN ms.status = 'completed' THEN m.id END) as completed,
-        COUNT(DISTINCT CASE WHEN ms.status = 'failed' THEN m.id END) as failed,
-        COUNT(DISTINCT CASE WHEN ms.status = 'dead_letter' THEN m.id END) as dead_letter,
+        COALESCE(pc.pending_estimate, 0) as pending,
+        CASE WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 1 ELSE 0 END as processing,
+        COALESCE(pc.total_messages_consumed, 0) as completed,
+        0 as failed,
+        (SELECT COUNT(*) FROM queen.dead_letter_queue dlq 
+         WHERE dlq.partition_id = p.id 
+         AND (dlq.consumer_group IS NULL OR dlq.consumer_group = '__QUEUE_MODE__')) as dead_letter,
         MIN(m.created_at) as oldest_message,
         MAX(m.created_at) as newest_message
       FROM queen.partitions p
       LEFT JOIN queen.messages m ON m.partition_id = p.id
-      LEFT JOIN queen.messages_status ms ON ms.message_id = m.id AND ms.consumer_group IS NULL
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
       WHERE p.queue_id = $1
-      GROUP BY p.id, p.name, p.created_at
+      GROUP BY p.id, p.name, p.created_at, pc.pending_estimate, pc.lease_expires_at, pc.total_messages_consumed
       ORDER BY p.name
     `, [queue.id]);
     
@@ -151,13 +155,13 @@ export const createResourcesRoutes = (pool) => {
         q.namespace,
         q.task,
         q.priority,
-        COUNT(DISTINCT CASE WHEN ms.status = 'pending' THEN m.id END) as pending,
-        COUNT(DISTINCT CASE WHEN ms.status = 'processing' THEN m.id END) as processing,
+        COALESCE(pc.pending_estimate, 0) as pending,
+        CASE WHEN pc.lease_expires_at IS NOT NULL AND pc.lease_expires_at > NOW() THEN 1 ELSE 0 END as processing,
         COUNT(DISTINCT m.id) as total
       FROM queen.partitions p
       JOIN queen.queues q ON q.id = p.queue_id
       LEFT JOIN queen.messages m ON m.partition_id = p.id
-      LEFT JOIN queen.messages_status ms ON ms.message_id = m.id AND ms.consumer_group IS NULL
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
       WHERE 1=1
     `;
     
@@ -168,11 +172,11 @@ export const createResourcesRoutes = (pool) => {
     }
     
     query += ` GROUP BY p.id, p.name, p.created_at, 
-                        q.name, q.namespace, q.task, q.priority`;
+                        q.name, q.namespace, q.task, q.priority, pc.pending_estimate, pc.lease_expires_at`;
     
     if (minDepth) {
       params.push(minDepth);
-      query += ` HAVING COUNT(DISTINCT CASE WHEN ms.status = 'pending' THEN m.id END) >= $${params.length}`;
+      query += ` HAVING COALESCE(pc.pending_estimate, 0) >= $${params.length}`;
     }
     
     query += ` ORDER BY q.name, q.priority DESC, p.name`;
@@ -201,11 +205,11 @@ export const createResourcesRoutes = (pool) => {
         COUNT(DISTINCT q.id) as queue_count,
         COUNT(DISTINCT p.id) as partition_count,
         COUNT(DISTINCT m.id) as message_count,
-        COUNT(DISTINCT CASE WHEN ms.status = 'pending' THEN m.id END) as pending_count
+        COALESCE(SUM(pc.pending_estimate), 0) as pending_count
       FROM queen.queues q
       LEFT JOIN queen.partitions p ON p.queue_id = q.id
       LEFT JOIN queen.messages m ON m.partition_id = p.id
-      LEFT JOIN queen.messages_status ms ON ms.message_id = m.id AND ms.consumer_group IS NULL
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
       WHERE q.namespace IS NOT NULL
       GROUP BY q.namespace
       ORDER BY q.namespace
@@ -229,11 +233,11 @@ export const createResourcesRoutes = (pool) => {
         COUNT(DISTINCT q.id) as queue_count,
         COUNT(DISTINCT p.id) as partition_count,
         COUNT(DISTINCT m.id) as message_count,
-        COUNT(DISTINCT CASE WHEN ms.status = 'pending' THEN m.id END) as pending_count
+        COALESCE(SUM(pc.pending_estimate), 0) as pending_count
       FROM queen.queues q
       LEFT JOIN queen.partitions p ON p.queue_id = q.id
       LEFT JOIN queen.messages m ON m.partition_id = p.id
-      LEFT JOIN queen.messages_status ms ON ms.message_id = m.id AND ms.consumer_group IS NULL
+      LEFT JOIN queen.partition_consumers pc ON pc.partition_id = p.id AND pc.consumer_group = '__QUEUE_MODE__'
       WHERE q.task IS NOT NULL
       GROUP BY q.task
       ORDER BY q.task
@@ -257,11 +261,16 @@ export const createResourcesRoutes = (pool) => {
         (SELECT COUNT(*) FROM queen.queues) as total_queues,
         (SELECT COUNT(*) FROM queen.partitions) as total_partitions,
         (SELECT COUNT(*) FROM queen.messages) as total_messages,
-        (SELECT COUNT(*) FROM queen.messages_status WHERE status = 'pending' AND consumer_group IS NULL) as pending_messages,
-        (SELECT COUNT(*) FROM queen.messages_status WHERE status = 'processing' AND consumer_group IS NULL) as processing_messages,
-        (SELECT COUNT(*) FROM queen.messages_status WHERE status = 'completed' AND consumer_group IS NULL) as completed_messages,
-        (SELECT COUNT(*) FROM queen.messages_status WHERE status = 'failed' AND consumer_group IS NULL) as failed_messages,
-        (SELECT COUNT(*) FROM queen.messages_status WHERE status = 'dead_letter' AND consumer_group IS NULL) as dead_letter_messages,
+        (SELECT COALESCE(SUM(pending_estimate), 0)::integer FROM queen.partition_consumers 
+         WHERE consumer_group = '__QUEUE_MODE__') as pending_messages,
+        (SELECT COUNT(*) FROM queen.partition_consumers 
+         WHERE consumer_group = '__QUEUE_MODE__' 
+         AND lease_expires_at IS NOT NULL 
+         AND lease_expires_at > NOW()) as processing_messages,
+        (SELECT COALESCE(SUM(total_messages_consumed), 0)::integer FROM queen.partition_consumers 
+         WHERE consumer_group = '__QUEUE_MODE__') as completed_messages,
+        0 as failed_messages,
+        (SELECT COUNT(*) FROM queen.dead_letter_queue WHERE consumer_group IS NULL OR consumer_group = '__QUEUE_MODE__') as dead_letter_messages,
         (SELECT COUNT(DISTINCT namespace) FROM queen.queues WHERE namespace IS NOT NULL) as namespaces,
         (SELECT COUNT(DISTINCT task) FROM queen.queues WHERE task IS NOT NULL) as tasks
     `);
@@ -285,12 +294,37 @@ export const createResourcesRoutes = (pool) => {
     };
   };
   
+  // Delete a queue (cascades to partitions, messages, etc.)
+  // Idempotent: returns success even if queue doesn't exist
+  const deleteQueue = async (queueName) => {
+    const result = await pool.query(
+      `DELETE FROM queen.queues WHERE name = $1 RETURNING id, name`,
+      [queueName]
+    );
+    
+    // Emit system event for cache invalidation across nodes
+    if (result.rows.length > 0 && systemEventManager) {
+      await systemEventManager.emit(EventTypes.QUEUE_DELETED, {
+        entityId: queueName,
+        queueId: result.rows[0].id
+      });
+    }
+    
+    return {
+      deleted: true,
+      queue: queueName,
+      existed: result.rows.length > 0,
+      id: result.rows.length > 0 ? result.rows[0].id : null
+    };
+  };
+  
   return {
     getQueues,
     getQueue,
     getPartitions,
     getNamespaces,
     getTasks,
-    getSystemOverview
+    getSystemOverview,
+    deleteQueue
   };
 };