redis-smq 8.3.0 → 8.3.1

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.3.1](https://github.com/weyoss/redis-smq/compare/v8.3.0...v8.3.1) (2025-05-06)
+
+### ⚡ Performance Improvements
+
+- **redis-smq:** optimize and clean up LUA scripts for better Redis performance ([1f8b128](https://github.com/weyoss/redis-smq/commit/1f8b128716e2686bd7d145efaef9b0c9a28daa65))
+
 ## [8.3.0](https://github.com/weyoss/redis-smq/compare/v8.2.1...v8.3.0) (2025-05-04)
 
 ### 🐛 Bug Fixes

package/dist/cjs/src/common/redis-client/scripts/lua/acknowledge-message.lua

@@ -2,27 +2,38 @@ local keyQueueProcessing = KEYS[1]
 local keyQueueAcknowledged = KEYS[2]
 local keyMessage = KEYS[3]
 
----
-
 local EMessagePropertyStatus = ARGV[1]
 local EMessagePropertyStatusAcknowledged = ARGV[2]
 local storeMessages = ARGV[3]
 local expireStoredMessages = ARGV[4]
 local storedMessagesSize = ARGV[5]
 
-local function updateMessageStatus()
-    redis.call("HMSET", keyMessage, EMessagePropertyStatus, EMessagePropertyStatusAcknowledged)
+-- Get the message ID from the processing queue
+local messageId = redis.call("LPOP", keyQueueProcessing)
+
+-- If no message was found, return early
+if messageId == false then
+    return nil
 end
 
-local messageId = redis.call("LPOP", keyQueueProcessing)
+-- Update message status immediately
+redis.call("HSET", keyMessage, EMessagePropertyStatus, EMessagePropertyStatusAcknowledged)
+
+-- Only perform storage operations if needed
 if storeMessages == '1' then
+    -- Add to acknowledged queue
     redis.call("RPUSH", keyQueueAcknowledged, messageId)
+
+    -- Apply expiration if configured
     if expireStoredMessages ~= '0' then
         redis.call("PEXPIRE", keyQueueAcknowledged, expireStoredMessages)
     end
+
+    -- Trim the queue if size limit is set
     if storedMessagesSize ~= '0' then
-        local result = redis.call("LTRIM", keyQueueAcknowledged, storedMessagesSize, -1)
-        return result
+        -- storedMessagesSize should be negative for proper trimming (to keep newest messages)
+        redis.call("LTRIM", keyQueueAcknowledged, storedMessagesSize, -1)
     end
 end
-updateMessageStatus()
+
+return messageId

package/dist/cjs/src/common/redis-client/scripts/lua/create-queue.lua

@@ -3,8 +3,6 @@ local keyNsQueues = KEYS[2]
 local keyQueues = KEYS[3]
 local keyQueueProperties = KEYS[4]
 
----
-
 local namespace = ARGV[1]
 local queue = ARGV[2]
 local queuePropertiesQueueType = ARGV[3]
@@ -12,12 +10,19 @@ local queueType = ARGV[4]
 local queuePropertiesQueueDeliveryModel = ARGV[5]
 local deliveryModel = ARGV[6]
 
-if redis.call("SISMEMBER", keyQueues, queue) == 0 then
-    redis.call("SADD", keyQueues, queue)
-    redis.call("SADD", keyNsQueues, queue)
-    redis.call("SADD", keyNamespaces, namespace)
-    redis.call("HSET", keyQueueProperties, queuePropertiesQueueType, queueType)
-    redis.call("HSET", keyQueueProperties, queuePropertiesQueueDeliveryModel, deliveryModel)
-    return 'OK'
+-- Check if queue already exists
+if redis.call("SISMEMBER", keyQueues, queue) == 1 then
+    return 'QUEUE_EXISTS'
 end
-return 'QUEUE_EXISTS'
+
+--
+redis.call("SADD", keyQueues, queue)
+redis.call("SADD", keyNsQueues, queue)
+redis.call("SADD", keyNamespaces, namespace)
+
+--
+redis.call("HSET", keyQueueProperties,
+           queuePropertiesQueueType, queueType,
+           queuePropertiesQueueDeliveryModel, deliveryModel)
+
+return 'OK'

package/dist/cjs/src/common/redis-client/scripts/lua/delete-consumer-group.lua

@@ -9,26 +9,37 @@ local typeLIFOQueue = ARGV[3]
 local typeFIFOQueue = ARGV[4]
 local groupId = ARGV[5]
 
+-- Get queue type once and validate it exists
 local queueType = redis.call("HGET", keyQueueProperties, queuePropertiesQueueType)
 if queueType == false then
     return 'QUEUE_NOT_FOUND'
 end
 
-local count = 0;
+-- Determine which key to check based on queue type (only once)
+local pendingKey
 if queueType == typePriorityQueue then
-    count = redis.call("ZCARD", keyQueuePendingPriority)
-elseif queueType == typeLIFOQueue or queueType == typeFIFOQueue then
-    count = redis.call("LLEN", keyQueuePending)
+    pendingKey = keyQueuePendingPriority
+else
+    pendingKey = keyQueuePending
 end
+
+-- Check if the queue is empty using the appropriate command
+local count = 0
+if queueType == typePriorityQueue then
+    count = redis.call("ZCARD", pendingKey)
+else
+    count = redis.call("LLEN", pendingKey)
+end
+
+-- Return early if the queue is not empty
 if count > 0 then
     return 'CONSUMER_GROUP_NOT_EMPTY'
 end
 
+-- Remove the consumer group
 redis.call("SREM", keyQueueConsumerGroups, groupId)
-if queueType == typePriorityQueue then
-    redis.call("DEL", keyQueuePendingPriority)
-elseif queueType == typeLIFOQueue or queueType == typeFIFOQueue then
-    redis.call("DEL", keyQueuePending)
-end
+
+-- Delete the pending queue
+redis.call("DEL", pendingKey)
 
 return 'OK'

package/dist/cjs/src/common/redis-client/scripts/lua/delete-message.lua

@@ -1,161 +1,104 @@
--- Constants for queue properties and message statuses
-local EQueuePropertyQueueType = ARGV[1]
-local EQueuePropertyMessagesCount = ARGV[2]
-local EQueuePropertyQueueTypePriorityQueue = ARGV[3]
-local EQueuePropertyQueueTypeLIFOQueue = ARGV[4]
-local EQueuePropertyQueueTypeFIFOQueue = ARGV[5]
-local EMessagePropertyStatus = ARGV[6]
-local EMessagePropertyStatusProcessing = ARGV[7]
-local EMessagePropertyStatusAcknowledged = ARGV[8]
-local EMessagePropertyStatusPending = ARGV[9]
-local EMessagePropertyStatusScheduled = ARGV[10]
-local EMessagePropertyStatusDeadLettered = ARGV[11]
-local EMessagePropertyStatusUnackDelaying = ARGV[12]
-local EMessagePropertyStatusUnackRequeuing = ARGV[13]
-
--- Response status constants
-local STATUS = {
-    OK = 'OK',
-    MESSAGE_NOT_FOUND = 'MESSAGE_NOT_FOUND',
-    MESSAGE_IN_PROCESS = 'MESSAGE_IN_PROCESS',
-    INVALID_PARAMETERS = 'INVALID_PARAMETERS',
-    PARTIAL_SUCCESS = 'PARTIAL_SUCCESS'
-}
-
--- Key placeholders
-local keys = {
-    queueScheduled = '',
-    queueDelayed = '',
-    queueRequeued = '',
-    message = '',
-    queueProperties = '',
-    queuePending = '',
-    queueDL = '',
-    queueAcknowledged = '',
-    queuePriorityPending = '',
-    queueMessages = '',
-}
-
--- Offset trackers
-local keyIndexOffset = 0
-local argvIndexOffset = 13
-
--- Removes a message from the corresponding queue (scheduled, acknowledged, delayed, requeue, pending) based on status
-local function removeFromStatusQueue(messageId, messageStatus)
-    local deleted = 0
-
-    if messageStatus == EMessagePropertyStatusAcknowledged then
-        deleted = redis.call("LREM", keys.queueAcknowledged, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusDeadLettered then
-        deleted = redis.call("LREM", keys.queueDL, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusScheduled then
-        deleted = redis.call("ZREM", keys.queueScheduled, messageId)
-    elseif messageStatus == EMessagePropertyStatusUnackDelaying then
-        deleted = redis.call("LREM", keys.queueDelayed, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusUnackRequeuing then
-        deleted = redis.call("LREM", keys.queueRequeued, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusPending then
-        local queueType = redis.call("HGET", keys.queueProperties, EQueuePropertyQueueType)
-        if queueType then
-            if queueType == EQueuePropertyQueueTypePriorityQueue then
-                deleted = redis.call("ZREM", keys.queuePriorityPending, messageId)
-            elseif queueType == EQueuePropertyQueueTypeFIFOQueue or queueType == EQueuePropertyQueueTypeLIFOQueue then
-                deleted = redis.call("LREM", keys.queuePending, 1, messageId)
-            end
-        end
-    end
-
-    return deleted
+local QUEUE_TYPE = ARGV[1]
+local MSG_COUNT = ARGV[2]
+local QUEUE_TYPE_PRIORITY = ARGV[3]
+local QUEUE_TYPE_LIFO = ARGV[4]
+local QUEUE_TYPE_FIFO = ARGV[5]
+local MSG_STATUS = ARGV[6]
+local MSG_STATUS_PROCESSING = ARGV[7]
+local MSG_STATUS_ACKNOWLEDGED = ARGV[8]
+local MSG_STATUS_PENDING = ARGV[9]
+local MSG_STATUS_SCHEDULED = ARGV[10]
+local MSG_STATUS_DEADLETTERED = ARGV[11]
+local MSG_STATUS_UNACK_DELAYING = ARGV[12]
+local MSG_STATUS_UNACK_REQUEUING = ARGV[13]
+
+local STATUS_OK = 'OK'
+local STATUS_MESSAGE_NOT_FOUND = 'MESSAGE_NOT_FOUND'
+local STATUS_MESSAGE_IN_PROCESS = 'MESSAGE_IN_PROCESS'
+local STATUS_INVALID_PARAMETERS = 'INVALID_PARAMETERS'
+
+-- Counters for tracking results
+local processedCount = 0
+local successCount = 0
+local notFoundCount = 0
+local inProcessCount = 0
+
+-- Constants for parameter counts
+local INITIAL_KEY_OFFSET = 0
+local INITIAL_ARGV_OFFSET = 13
+local PARAMS_PER_MESSAGE = 1
+local KEYS_PER_MESSAGE = 10
+
+-- Validate parameters
+if #ARGV <= INITIAL_ARGV_OFFSET then
+    return 'INVALID_PARAMETERS'
 end
 
--- Deletes a message and returns the status
-local function deleteMessage(messageId)
-    -- Check if message exists and get its status
-    local messageStatus = redis.call("HGET", keys.message, EMessagePropertyStatus)
-    if not messageStatus then
-        return STATUS.MESSAGE_NOT_FOUND
-    end
-
-    -- For messages in process, we'll just report the status but not attempt deletion
-    if messageStatus == EMessagePropertyStatusProcessing then
-        return STATUS.MESSAGE_IN_PROCESS
-    end
+--
+local keyIndex = INITIAL_KEY_OFFSET + 1
 
-    -- Try to remove the message from acknowledged, dl, scheduled, etc. based on message status
-    removeFromStatusQueue(messageId, messageStatus)
+for argvIndex = INITIAL_ARGV_OFFSET + 1, #ARGV, PARAMS_PER_MESSAGE do
+    local messageId = ARGV[argvIndex]
 
-    -- Delete the message
-    redis.call("DEL", keys.message)
+    -- Setup direct key references for this message
+    local queueScheduled = KEYS[keyIndex]
+    local queueDelayed = KEYS[keyIndex + 1]
+    local queueRequeued = KEYS[keyIndex + 2]
+    local messageKey = KEYS[keyIndex + 3]
+    local queueProperties = KEYS[keyIndex + 4]
+    local queuePending = KEYS[keyIndex + 5]
+    local queueDL = KEYS[keyIndex + 6]
+    local queueAcknowledged = KEYS[keyIndex + 7]
+    local queuePriorityPending = KEYS[keyIndex + 8]
+    local queueMessages = KEYS[keyIndex + 9]
 
-    -- Remove the message ID from queue messages
-    redis.call("SREM", keys.queueMessages, messageId)
+    -- Update keyIndex for next iteration
+    keyIndex = keyIndex + KEYS_PER_MESSAGE
 
-    -- Decrements the message count in queue properties
-    redis.call("HINCRBY", keys.queueProperties, EQueuePropertyMessagesCount, -1)
+    --
+    processedCount = processedCount + 1
 
-    return STATUS.OK
-end
-
--- Setup keys for a message
-local function setupKeysForMessage(baseOffset)
-    keys.queueScheduled = KEYS[baseOffset + 1]
-    keys.queueDelayed = KEYS[baseOffset + 2]
-    keys.queueRequeued = KEYS[baseOffset + 3]
-    keys.message = KEYS[baseOffset + 4]
-    keys.queueProperties = KEYS[baseOffset + 5]
-    keys.queuePending = KEYS[baseOffset + 6]
-    keys.queueDL = KEYS[baseOffset + 7]
-    keys.queueAcknowledged = KEYS[baseOffset + 8]
-    keys.queuePriorityPending = KEYS[baseOffset + 9]
-    keys.queueMessages = KEYS[baseOffset + 10]
-end
-
--- Main execution logic
-local function main()
-    -- Counters for tracking results
-    local processedCount = 0
-    local successCount = 0
-    local notFoundCount = 0
-    local inProcessCount = 0
-
-    -- Check if we have enough arguments
-    if #ARGV <= argvIndexOffset then
-        return STATUS.INVALID_PARAMETERS
-    end
-
-    -- Process each message ID
-    for i = argvIndexOffset + 1, #ARGV do
-        local messageId = ARGV[i]
-        processedCount = processedCount + 1
+    -- Check if message exists and get its status
+    local messageStatus = redis.call("HGET", messageKey, MSG_STATUS)
+    if messageStatus == false then
+        notFoundCount = notFoundCount + 1
+    elseif messageStatus == MSG_STATUS_PROCESSING then
+        inProcessCount = inProcessCount + 1
+    else
+        -- Remove from appropriate queue based on status
+        if messageStatus == MSG_STATUS_ACKNOWLEDGED then
+            redis.call("LREM", queueAcknowledged, 1, messageId)
+        elseif messageStatus == MSG_STATUS_DEADLETTERED then
+            redis.call("LREM", queueDL, 1, messageId)
+        elseif messageStatus == MSG_STATUS_SCHEDULED then
+            redis.call("ZREM", queueScheduled, messageId)
+        elseif messageStatus == MSG_STATUS_UNACK_DELAYING then
+            redis.call("LREM", queueDelayed, 1, messageId)
+        elseif messageStatus == MSG_STATUS_UNACK_REQUEUING then
+            redis.call("LREM", queueRequeued, 1, messageId)
+        elseif messageStatus == MSG_STATUS_PENDING then
+            local queueType = redis.call("HGET", queueProperties, QUEUE_TYPE)
+            if queueType then
+                if queueType == QUEUE_TYPE_PRIORITY then
+                    redis.call("ZREM", queuePriorityPending, messageId)
+                elseif queueType == QUEUE_TYPE_FIFO or queueType == QUEUE_TYPE_LIFO then
+                    redis.call("LREM", queuePending, 1, messageId)
+                end
+            end
+        end
 
-        -- Setup keys for this message
-        setupKeysForMessage(keyIndexOffset)
-        keyIndexOffset = keyIndexOffset + 10
+        -- Delete the message
+        redis.call("DEL", messageKey)
 
-        -- Try to delete the message
-        local messageStatus = deleteMessage(messageId)
+        -- Remove the message ID from queue messages
+        redis.call("SREM", queueMessages, messageId)
 
-        -- Track results but continue processing regardless of status
-        if messageStatus == STATUS.OK then
-            successCount = successCount + 1
-        elseif messageStatus == STATUS.MESSAGE_NOT_FOUND then
-            notFoundCount = notFoundCount + 1
-        elseif messageStatus == STATUS.MESSAGE_IN_PROCESS then
-            inProcessCount = inProcessCount + 1
-        end
+        -- Decrements the message count in queue properties
+        redis.call("HINCRBY", queueProperties, MSG_COUNT, -1)
 
-        -- Always continue to the next message
+        successCount = successCount + 1
     end
-
-    -- Return an array instead of a table for compatibility with Redis
-    -- Format: [processed, success, notFound, inProcess]
-    return {
-        processedCount,
-        successCount,
-        notFoundCount,
-        inProcessCount
-    }
 end
 
--- Execute the main function and return the result
-return main()
+-- Return an array with the results
+return {processedCount, successCount, notFoundCount, inProcessCount}

package/dist/cjs/src/common/redis-client/scripts/lua/fetch-message-for-processing.lua

@@ -5,8 +5,16 @@ local EMessagePropertyState = ARGV[2]
 local EMessagePropertyMessage = ARGV[3]
 local EMessagePropertyStatusProcessing = ARGV[4]
 
+-- Fetch only the required fields in a single operation
 local result = redis.call("HMGET", keyMessage, EMessagePropertyState, EMessagePropertyMessage)
-if result[1] ~= false and result[2] ~= false then
-    redis.call("HSET", keyMessage, EMessagePropertyStatus, EMessagePropertyStatusProcessing)
-    return result
+
+-- Early return if either field is missing
+if result[1] == false or result[2] == false then
+    return false
 end
+
+-- Update the message status to processing
+redis.call("HSET", keyMessage, EMessagePropertyStatus, EMessagePropertyStatusProcessing)
+
+-- Return the message data
+return result

package/dist/cjs/src/common/redis-client/scripts/lua/handle-processing-queue.lua

@@ -8,49 +8,46 @@ local EMessagePropertyStatus = ARGV[7]
 local EMessageUnacknowledgedCauseOfflineConsumer = ARGV[8]
 local EMessageUnacknowledgedCauseOfflineHandler = ARGV[9]
 
----
+--
+local INITIAL_KEY_OFFSET = 0
+local INITIAL_ARGV_OFFSET = 9
+local PARAMS_PER_MESSAGE = 7
+local KEYS_PER_MESSAGE = 9
 
-local keyIndexOffset = 0
-local argvIndexOffset = 9
-
----
-
-local keyQueueProcessing = ''
-local keyQueueDelayed = ''
-local keyQueueRequeued = ''
-local keyQueueDL = ''
-local keyQueueProcessingQueues = ''
-local keyQueueConsumers = ''
-local keyConsumerQueues = ''
-local keyQueueProperties = ''
-local keyMessage = ''
+--
+if (#ARGV <= INITIAL_ARGV_OFFSET) then
+    return 'INVALID_PARAMETERS'
+end
 
-local queue = ''
-local consumerId = ''
-local messageId = ''
-local retryAction = ''
-local messageDeadLetteredCause = ''
-local messageUnacknowledgedCause = ''
-local messageStatus = ''
+--
+local keyIndex = INITIAL_KEY_OFFSET + 1
 
----
+--
+for argvIndex = INITIAL_ARGV_OFFSET + 1, #ARGV, PARAMS_PER_MESSAGE do
+    -- Read all values for this group directly
+    local queue = ARGV[argvIndex]
+    local consumerId = ARGV[argvIndex + 1]
+    local messageId = ARGV[argvIndex + 2]
+    local retryAction = ARGV[argvIndex + 3]
+    local messageDeadLetteredCause = ARGV[argvIndex + 4]
+    local messageUnacknowledgedCause = ARGV[argvIndex + 5]
+    local messageStatus = ARGV[argvIndex + 6]
 
-local function updateMessageStatus()
-    redis.call("HMSET", keyMessage, EMessagePropertyStatus, messageStatus)
-end
+    -- Get keys for this group directly
+    local keyQueueProcessing = KEYS[keyIndex]
+    local keyQueueDelayed = KEYS[keyIndex + 1]
+    local keyQueueRequeued = KEYS[keyIndex + 2]
+    local keyQueueDL = KEYS[keyIndex + 3]
+    local keyQueueProcessingQueues = KEYS[keyIndex + 4]
+    local keyQueueConsumers = KEYS[keyIndex + 5]
+    local keyConsumerQueues = KEYS[keyIndex + 6]
+    local keyQueueProperties = KEYS[keyIndex + 7]
+    local keyMessage = KEYS[keyIndex + 8]
 
-local function removeQueueConsumer()
-    if queue ~= '' then
-        redis.call("HDEL", keyQueueConsumers, consumerId)
-        redis.call("SREM", keyConsumerQueues, queue)
-        local size = redis.call("SCARD", keyConsumerQueues)
-        if size == 0 then
-            redis.call("DEL", keyConsumerQueues)
-        end
-    end
-end
+    -- Update keyIndex for next iteration
+    keyIndex = keyIndex + KEYS_PER_MESSAGE
 
-local function retryMessage()
+    -- Process message
     if messageId ~= '' then
         if retryAction == ERetryActionRequeue then
             redis.call("RPOPLPUSH", keyQueueProcessing, keyQueueRequeued)
@@ -64,63 +61,37 @@ local function retryMessage()
                     redis.call("PEXPIRE", keyQueueDL, expireStoredMessages)
                 end
                 if storedMessagesSize ~= '0' then
+                    -- storedMessagesSize should be negative for proper trimming (to keep newest messages)
                     redis.call("LTRIM", keyQueueDL, storedMessagesSize, -1)
                 end
             else
                 redis.call("RPOP", keyQueueProcessing)
             end
         end
-        updateMessageStatus();
-    end
-end
 
-local function deleteProcessingQueue()
-    if keyQueueProcessing ~= '' then
-        redis.call("HDEL", keyQueueProcessingQueues, keyQueueProcessing)
-        redis.call("DEL", keyQueueProcessing)
+        -- Update message status
+        redis.call("HSET", keyMessage, EMessagePropertyStatus, messageStatus)
     end
-end
 
----
+    -- Handle offline consumer/handler
+    if messageUnacknowledgedCause == EMessageUnacknowledgedCauseOfflineConsumer or
+       messageUnacknowledgedCause == EMessageUnacknowledgedCauseOfflineHandler then
+        -- Delete processing queue
+        if keyQueueProcessing ~= '' then
+            redis.call("HDEL", keyQueueProcessingQueues, keyQueueProcessing)
+            redis.call("DEL", keyQueueProcessing)
+        end
 
-if #ARGV > argvIndexOffset then
-    for index in pairs(ARGV) do
-        if (index > argvIndexOffset) then
-            local relativeIndex = index % 7
-            if relativeIndex == 3 then
-                queue = ARGV[index]
-                keyQueueProcessing = KEYS[keyIndexOffset + 1]
-                keyQueueDelayed = KEYS[keyIndexOffset + 2];
-                keyQueueRequeued = KEYS[keyIndexOffset + 3];
-                keyQueueDL = KEYS[keyIndexOffset + 4]
-                keyQueueProcessingQueues = KEYS[keyIndexOffset + 5]
-                keyQueueConsumers = KEYS[keyIndexOffset + 6]
-                keyConsumerQueues = KEYS[keyIndexOffset + 7]
-                keyQueueProperties = KEYS[keyIndexOffset + 8]
-                keyMessage = KEYS[keyIndexOffset + 9]
-                keyIndexOffset = keyIndexOffset + 9
-            elseif relativeIndex == 4 then
-                consumerId = ARGV[index]
-            elseif relativeIndex == 5 then
-                messageId = ARGV[index]
-            elseif relativeIndex == 6 then
-                retryAction = ARGV[index]
-            elseif relativeIndex == 0 then
-                messageDeadLetteredCause = ARGV[index]
-            elseif relativeIndex == 1 then
-                messageUnacknowledgedCause = ARGV[index]
-            elseif relativeIndex == 2 then
-                messageStatus = ARGV[index]
-                retryMessage()
-                if messageUnacknowledgedCause == EMessageUnacknowledgedCauseOfflineConsumer or messageUnacknowledgedCause == EMessageUnacknowledgedCauseOfflineHandler then
-                    deleteProcessingQueue()
-                    removeQueueConsumer()
-                end
+        -- Remove queue consumer
+        if queue ~= '' then
+            redis.call("HDEL", keyQueueConsumers, consumerId)
+            redis.call("SREM", keyConsumerQueues, queue)
+            local size = redis.call("SCARD", keyConsumerQueues)
+            if size == 0 then
+                redis.call("DEL", keyConsumerQueues)
             end
         end
     end
-    return 'OK'
 end
 
-return 'INVALID_PARAMETERS'
-
+return 'OK'

package/dist/cjs/src/common/redis-client/scripts/lua/has-queue-rate-exceeded.lua

@@ -1,19 +1,26 @@
 local keyQueueRateLimitCounter = KEYS[1]
 
----
+local rateLimitLimit = tonumber(ARGV[1])
+local rateLimitExpire = tonumber(ARGV[2])
 
-local rateLimitLimit = ARGV[1]
-local rateLimitExpire = ARGV[2]
+-- Get the current counter value
+local count = redis.call("GET", keyQueueRateLimitCounter)
 
-local result = redis.call("GET", keyQueueRateLimitCounter)
-if result == false then
-    redis.call("SET", keyQueueRateLimitCounter, rateLimitLimit)
-    redis.call("PEXPIRE", keyQueueRateLimitCounter, rateLimitExpire);
+-- If counter doesn't exist, initialize it
+if count == false then
+    -- Use SET with EX option to combine SET and EXPIRE into one command
+    redis.call("SET", keyQueueRateLimitCounter, rateLimitLimit, "PX", rateLimitExpire)
     return 0
 end
-local count = tonumber(result)
+
+-- Convert to number
+count = tonumber(count)
+
+-- Check if rate limit is exceeded
 if count <= 1 then
     return 1
 end
+
+-- Decrement the counter
 redis.call("DECR", keyQueueRateLimitCounter)
 return 0

package/dist/cjs/src/common/redis-client/scripts/lua/init-consumer-queue.lua

@@ -3,17 +3,21 @@ local keyQueueConsumers = KEYS[2]
 local keyConsumerQueues = KEYS[3]
 local keyQueueProcessingQueues = KEYS[4]
 
----
-
 local consumerId = ARGV[1]
 local consumerInfo = ARGV[2]
 local queue = ARGV[3]
 local consumerProcessingQueue = ARGV[4]
 
-if redis.call("SISMEMBER", keyQueues, queue) == 1 then
-    redis.call("SADD", keyConsumerQueues, queue)
-    redis.call("HSET", keyQueueConsumers, consumerId, consumerInfo)
-    redis.call("HSET", keyQueueProcessingQueues, consumerProcessingQueue, consumerId)
-    return 1
+-- Early return if queue doesn't exist
+if redis.call("SISMEMBER", keyQueues, queue) == 0 then
+    return 0
 end
-return 0
+
+-- Execute all operations in sequence without conditional branching
+redis.call("SADD", keyConsumerQueues, queue)
+
+--
+redis.call("HSET", keyQueueConsumers, consumerId, consumerInfo)
+redis.call("HSET", keyQueueProcessingQueues, consumerProcessingQueue, consumerId)
+
+return 1