queen-mq 0.1.2 → 0.1.3

package/src/services/startupSync.js

@@ -22,7 +22,7 @@ export async function syncSystemEvents(client, eventManager, consumerGroup) {
     }
     
     for (const message of result.messages) {
-      await eventManager.processSystemEvent(message.payload);
+      await eventManager.processSystemEvent(message.data);
       await client.ack(message.transactionId, 'completed', null, consumerGroup);
       processed++;
     }

package/src/test/advanced-pattern-tests.js

@@ -1000,7 +1000,7 @@ export async function testMultipleConsumersSinglePartitionOrdering(client) {
               limit: batchSize, 
               batch: batchSize 
             })) {
-              const sequenceNumber = msg.payload.sequenceNumber;
+              const sequenceNumber = msg.data.sequenceNumber;
               consumerMessages.push({
                 consumerId,
                 sequenceNumber,

package/src/test/core-tests.js

@@ -340,3 +340,113 @@ export async function testPartitionFIFOOrdering(client) {
   }
 }
 
+/**
+ * Test 8: Window Buffer
+ * Verifies that windowBuffer delays message consumption across all access modes
+ */
+export async function testWindowBuffer(client) {
+  startTest('Window Buffer');
+  
+  try {
+    const timestamp = Date.now();
+    const queueName = 'test-window-buffer-' + timestamp;
+    const partition = 'test-partition';
+    
+    // Test CASE 1: Direct partition access
+    await client.queue(queueName, { windowBuffer: 5 });
+    
+    // Push a message
+    await client.push(`${queueName}/${partition}`, { test: 'case1' });
+    
+    // Try to take immediately - should get nothing
+    let gotImmediate = false;
+    for await (const msg of client.take(`${queueName}/${partition}`, { limit: 1 })) {
+      gotImmediate = true;
+      await client.ack(msg);
+    }
+    
+    if (gotImmediate) {
+      throw new Error('Got message immediately in direct access - windowBuffer not working');
+    }
+    log('Direct partition access: windowBuffer correctly delayed message');
+    
+    // Wait for window to pass
+    await sleep(6000);
+    
+    // Now should get the message
+    let gotDelayed = false;
+    for await (const msg of client.take(`${queueName}/${partition}`, { limit: 1 })) {
+      gotDelayed = true;
+      await client.ack(msg);
+    }
+    
+    if (!gotDelayed) {
+      throw new Error('Did not get message after window expired');
+    }
+    log('Message available after window buffer expired');
+    
+    // Test CASE 2: Queue-level access
+    const queue2 = 'test-window-buffer-q2-' + timestamp;
+    await client.queue(queue2, { windowBuffer: 5 });
+    await client.push(`${queue2}/p1`, { test: 'case2' });
+    
+    let gotCase2Immediate = false;
+    for await (const msg of client.take(queue2, { limit: 1 })) {
+      gotCase2Immediate = true;
+      await client.ack(msg);
+    }
+    
+    if (gotCase2Immediate) {
+      throw new Error('Got message immediately in queue access - windowBuffer not working');
+    }
+    log('Queue-level access: windowBuffer correctly delayed message');
+    
+    await sleep(6000);
+    
+    let gotCase2Delayed = false;
+    for await (const msg of client.take(queue2, { limit: 1 })) {
+      gotCase2Delayed = true;
+      await client.ack(msg);
+    }
+    
+    if (!gotCase2Delayed) {
+      throw new Error('Did not get message after window expired (queue access)');
+    }
+    
+    // Test CASE 3: Namespace/task filtered access
+    const ns = `test-ns-${timestamp}`;
+    const task = `test-task-${timestamp}`;
+    const queue3 = 'test-window-buffer-filtered-' + timestamp;
+    
+    await client.queue(queue3, { windowBuffer: 5 }, ns, task);
+    await client.push(`${queue3}/p1`, { test: 'case3' });
+    
+    let gotCase3Immediate = false;
+    for await (const msg of client.take(`namespace:${ns}/task:${task}`, { limit: 1 })) {
+      gotCase3Immediate = true;
+      await client.ack(msg);
+    }
+    
+    if (gotCase3Immediate) {
+      throw new Error('Got message immediately in filtered access - windowBuffer not working');
+    }
+    log('Namespace/task filtered access: windowBuffer correctly delayed message');
+    
+    await sleep(6000);
+    
+    let gotCase3Delayed = false;
+    for await (const msg of client.take(`namespace:${ns}/task:${task}`, { limit: 1 })) {
+      gotCase3Delayed = true;
+      await client.ack(msg);
+    }
+    
+    if (!gotCase3Delayed) {
+      throw new Error('Did not get message after window expired (filtered access)');
+    }
+    
+    passTest('Window buffer works correctly across all access modes');
+  } catch (error) {
+    failTest(error);
+  }
+}
+

package/src/test/test-new.js

@@ -32,7 +32,8 @@ import {
   testQueueConfiguration,
   testTakeAndAcknowledgment,
   testDelayedProcessing,
-  testPartitionFIFOOrdering
+  testPartitionFIFOOrdering,
+  testWindowBuffer
 } from './core-tests.js';
 
 import {
@@ -168,6 +169,7 @@ async function runTests() {
       await runTest(() => testTakeAndAcknowledgment(client));
       await runTest(() => testDelayedProcessing(client));
       await runTest(() => testPartitionFIFOOrdering(client));
+      await runTest(() => testWindowBuffer(client));
     }
     
     // ============================================

package/src/test/test.js

@@ -4147,7 +4147,7 @@ async function testMultipleConsumersSinglePartitionOrdering() {
             
             // Process messages and track their sequence numbers
             for (const msg of result.messages) {
-              const sequenceNumber = msg.payload.sequenceNumber;
+              const sequenceNumber = msg.data.sequenceNumber;
               consumerMessages.push({
                 consumerId,
                 sequenceNumber,

package/src/test/window-buffer-test.js

@@ -0,0 +1,114 @@
+/**
+ * Test to validate windowBuffer functionality
+ * Ensures windowBuffer works correctly for all access modes:
+ * - Direct partition access
+ * - Queue-level access  
+ * - Namespace/task filtered access
+ */
+
+import { Queen } from '../client/index.js';
+import { sleep } from './utils.js';
+
+const client = new Queen({
+  baseUrl: 'http://localhost:6632'
+});
+
+async function testWindowBuffer() {
+  console.log('\n🧪 Testing windowBuffer functionality...\n');
+  
+  const timestamp = Date.now();
+  const queueName = 'test-window-buffer-' + timestamp;
+  const partition = 'test-partition';
+  
+  // Delete queue if it exists (cleanup from previous runs)
+  try {
+    await client.queueDelete(queueName);
+    console.log(`0. Deleted existing queue "${queueName}" (cleanup)`);
+  } catch (err) {
+    // Queue doesn't exist, that's fine
+  }
+  
+  // Configure queue with 10 second window buffer
+  console.log(`1. Creating queue "${queueName}" with windowBuffer: 10 seconds`);
+  await client.queue(queueName, {
+    windowBuffer: 10
+  });
+  
+  // Push first message
+  console.log('2. Pushing first message at', new Date().toISOString());
+  await client.push(`${queueName}/${partition}`, { message: 'Message 1' });
+  
+  // Wait 2 seconds and push second message
+  await sleep(2000);
+  console.log('3. Pushing second message at', new Date().toISOString());
+  await client.push(`${queueName}/${partition}`, { message: 'Message 2' });
+  
+  // Try to pop immediately (should get NOTHING due to windowBuffer)
+  console.log('\n4. Trying to pop immediately (should get NOTHING due to 10s windowBuffer)...');
+  
+  // Test CASE 1: Direct partition access
+  console.log('\n   TEST CASE 1: Direct partition access');
+  let case1Result = 0;
+  for await (const msg of client.take(`${queueName}/${partition}`, { limit: 10, batch: 10 })) {
+    case1Result++;
+    await client.ack(msg, true);
+  }
+  const case1Status = case1Result === 0 ? '✅' : '❌';
+  console.log(`   ${case1Status} DIRECT ACCESS: Got ${case1Result} messages (expected 0)`);
+  
+  // Test CASE 2: Queue-level access
+  console.log('\n   TEST CASE 2: Queue-level access');
+  let case2Result = 0;
+  for await (const msg of client.take(queueName, { limit: 10, batch: 10 })) {
+    case2Result++;
+    await client.ack(msg, true);
+  }
+  const case2Status = case2Result === 0 ? '✅' : '❌';
+  console.log(`   ${case2Status} QUEUE ACCESS: Got ${case2Result} messages (expected 0)`);
+  
+  // Test CASE 3: Namespace/task filtered access (should work correctly)
+  console.log('\n   TEST CASE 3: Namespace/task filtered access');
+  
+  // Use unique namespace/task per test run to avoid collisions
+  const testNamespace = `test-ns-${timestamp}`;
+  const testTask = `test-task-${timestamp}`;
+  const filteredQueue = `${queueName}-filtered`;
+  
+  // Delete queue if it exists
+  try {
+    await client.queueDelete(filteredQueue);
+  } catch (err) {
+    // Queue doesn't exist, that's fine
+  }
+  
+  await client.queue(filteredQueue, {
+    windowBuffer: 10
+  }, testNamespace, testTask);
+  
+  await client.push(`${filteredQueue}/${partition}`, { message: 'Filtered message' });
+  
+  let case3Result = 0;
+  for await (const msg of client.take(`namespace:${testNamespace}/task:${testTask}`, { limit: 10, batch: 10 })) {
+    case3Result++;
+    await client.ack(msg, true);
+  }
+  const case3Status = case3Result === 0 ? '✅' : '❌';
+  console.log(`   ${case3Status} FILTERED ACCESS: Got ${case3Result} messages (expected 0)`);
+  
+  console.log('\n📊 SUMMARY:');
+  const allPassed = case1Result === 0 && case2Result === 0 && case3Result === 0;
+  
+  if (allPassed) {
+    console.log('   ✅ All tests PASSED! windowBuffer is working correctly in all access modes.');
+  } else {
+    console.log('   Issues found:');
+    if (case1Result !== 0) console.log('   ❌ Direct partition access: windowBuffer NOT enforced');
+    if (case2Result !== 0) console.log('   ❌ Queue-level access: windowBuffer NOT enforced');
+    if (case3Result !== 0) console.log('   ❌ Namespace/task filtered access: windowBuffer NOT enforced');
+  }
+  
+  console.log('\n' + (allPassed ? '✅ Test complete. All fixed!' : '❌ Test complete. Issues remain.') + '\n');
+}
+
+testWindowBuffer().catch(console.error);
+

package/webapp/src/components/messages/MessageFilters.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="filter-container">
+  <div>
     <div class="flex flex-col sm:flex-row gap-3">
       <!-- Search by Transaction ID -->
       <div class="flex-1">
@@ -49,19 +49,6 @@
   </div>
 </template>
 
-<style scoped>
-.filter-container {
-  background: #ffffff;
-  border: none;
-  box-shadow: none;
-  border-radius: 0.75rem;
-  padding: 1rem;
-}
-
-.dark .filter-container {
-  background: #0a0d14;
-}
-</style>
 
 <script setup>
 import { ref, watch } from 'vue';

package/webapp/src/views/Analytics.vue

@@ -317,27 +317,27 @@ onUnmounted(() => {
 }
 
 
-:deep(.filter-container .input) {
+.filter-flat :deep(.input) {
   background: transparent;
   border: 1px solid rgba(156, 163, 175, 0.15);
   transition: all 0.2s ease;
 }
 
-:deep(.filter-container .input:hover) {
+.filter-flat :deep(.input:hover) {
   border-color: rgba(156, 163, 175, 0.25);
 }
 
-:deep(.filter-container .input:focus) {
+.filter-flat :deep(.input:focus) {
   background: rgba(244, 63, 94, 0.02);
   border-color: rgba(244, 63, 94, 0.4);
   box-shadow: 0 0 0 3px rgba(244, 63, 94, 0.05);
 }
 
-.dark :deep(.filter-container .input) {
+.dark .filter-flat :deep(.input) {
   border-color: rgba(156, 163, 175, 0.1);
 }
 
-.dark :deep(.filter-container .input:focus) {
+.dark .filter-flat :deep(.input:focus) {
   background: rgba(244, 63, 94, 0.03);
   border-color: rgba(244, 63, 94, 0.5);
   box-shadow: 0 0 0 3px rgba(244, 63, 94, 0.08);

package/webapp/src/views/Messages.vue

@@ -18,12 +18,14 @@
         </div>
 
         <!-- Filters -->
-        <MessageFilters
+        <div class="filter-flat">
+          <MessageFilters
           v-model:search="searchQuery"
           v-model:queue="queueFilter"
           v-model:status="statusFilter"
           :queues="queues"
-        />
+          />
+        </div>
 
         <LoadingSpinner v-if="loading && !messages.length" />