redis-smq 8.2.1 → 8.3.1

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

@@ -1,104 +1,104 @@
-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]
+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'
 
-local keyQueueScheduled = ''
-local keyQueueDelayed = ''
-local keyQueueRequeued = ''
-local keyMessage = ''
-local keyQueueProperties = ''
-local keyQueuePending = ''
-local keyQueueDL = ''
-local keyQueueAcknowledged = ''
-local keyQueuePriorityPending = ''
+-- 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
 
-local messageId = ''
+-- Validate parameters
+if #ARGV <= INITIAL_ARGV_OFFSET then
+    return 'INVALID_PARAMETERS'
+end
 
----
+--
+local keyIndex = INITIAL_KEY_OFFSET + 1
 
-local keyIndexOffset = 0
-local argvIndexOffset = 13
+for argvIndex = INITIAL_ARGV_OFFSET + 1, #ARGV, PARAMS_PER_MESSAGE do
+    local messageId = ARGV[argvIndex]
 
----
+    -- 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]
 
-local function updateQueue()
-    redis.call("HINCRBY", keyQueueProperties, EQueuePropertyMessagesCount, -1)
-end
+    -- Update keyIndex for next iteration
+    keyIndex = keyIndex + KEYS_PER_MESSAGE
 
-local function deleteMessage()
-    local messageStatus = redis.call("HGET", keyMessage, EMessagePropertyStatus)
+    --
+    processedCount = processedCount + 1
+
+    -- Check if message exists and get its status
+    local messageStatus = redis.call("HGET", messageKey, MSG_STATUS)
     if messageStatus == false then
-        return 'MESSAGE_NOT_FOUND'
-    end
-    if messageStatus == EMessagePropertyStatusProcessing then
-        return 'MESSAGE_IN_PROCESS'
-    end
-    local deleted = 0;
-    if messageStatus == EMessagePropertyStatusAcknowledged then
-        deleted = redis.call("LREM", keyQueueAcknowledged, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusDeadLettered then
-        deleted = redis.call("LREM", keyQueueDL, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusScheduled then
-        deleted = redis.call("ZREM", keyQueueScheduled, messageId)
-    elseif messageStatus == EMessagePropertyStatusUnackDelaying then
-        deleted = redis.call("LREM", keyQueueDelayed, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusUnackRequeuing then
-        deleted = redis.call("LREM", keyQueueRequeued, 1, messageId)
-    elseif messageStatus == EMessagePropertyStatusPending then
-        local queueType = redis.call("HGET", keyQueueProperties, EQueuePropertyQueueType)
-        if queueType ~= false then
-            if queueType == EQueuePropertyQueueTypePriorityQueue then
-                deleted = redis.call("ZREM", keyQueuePriorityPending, messageId)
-            end
-            if queueType == EQueuePropertyQueueTypeFIFOQueue or queueType == EQueuePropertyQueueTypeLIFOQueue then
-                deleted = redis.call("LREM", keyQueuePending, 1, messageId)
+        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
-    end
-    if deleted == 1 then
-        redis.call("DEL", keyMessage)
-        return 'OK'
-    end
-    return 'MESSAGE_NOT_DELETED'
-end
 
-local deleteMessageStatus = 'INVALID_PARAMETERS'
+        -- Delete the message
+        redis.call("DEL", messageKey)
 
-if #ARGV > argvIndexOffset then
-    for index in pairs(ARGV) do
-        if (index > argvIndexOffset) then
-            messageId = ARGV[index]
-            keyQueueScheduled = KEYS[keyIndexOffset + 1]
-            keyQueueDelayed = KEYS[keyIndexOffset + 2]
-            keyQueueRequeued = KEYS[keyIndexOffset + 3]
-            keyMessage = KEYS[keyIndexOffset + 4]
-            keyQueueProperties = KEYS[keyIndexOffset + 5]
-            keyQueuePending = KEYS[keyIndexOffset + 6]
-            keyQueueDL = KEYS[keyIndexOffset + 7]
-            keyQueueAcknowledged = KEYS[keyIndexOffset + 8]
-            keyQueuePriorityPending = KEYS[keyIndexOffset + 9]
-            keyIndexOffset = keyIndexOffset + 9
-            deleteMessageStatus = deleteMessage()
-            if deleteMessageStatus ~= 'OK' then
-                break
-            end
-            updateQueue()
-        end
+        -- Remove the message ID from queue messages
+        redis.call("SREM", queueMessages, messageId)
+
+        -- Decrements the message count in queue properties
+        redis.call("HINCRBY", queueProperties, MSG_COUNT, -1)
+
+        successCount = successCount + 1
     end
 end
 
-return deleteMessageStatus
+-- Return an array with the results
+return {processedCount, successCount, notFoundCount, inProcessCount}

package/dist/esm/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/esm/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/esm/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/esm/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

package/dist/esm/src/common/redis-client/scripts/lua/publish-message.lua

@@ -4,8 +4,6 @@ local keyQueuePending = KEYS[3]
 local keyQueueMessages = KEYS[4]
 local keyMessage = KEYS[5]
 
----
-
 local EQueuePropertyQueueType = ARGV[1]
 local EQueuePropertyMessagesCount = ARGV[2]
 local EQueuePropertyQueueTypePriorityQueue = ARGV[3]
@@ -20,33 +18,28 @@ local messageState = ARGV[11]
 local EMessagePropertyMessage = ARGV[12]
 local message = ARGV[13]
 
-local queueProperties = redis.call("HMGET", keyQueueProperties, EQueuePropertyQueueType)
-
-local function saveMessage()
-    redis.call("SADD", keyQueueMessages, messageId)
-    redis.call(
-            "HMSET", keyMessage,
-            EMessagePropertyStatus, messageStatus,
-            EMessagePropertyState, messageState,
-            EMessagePropertyMessage, message
-    )
-    redis.call("HINCRBY", keyQueueProperties, EQueuePropertyMessagesCount, 1)
-end
+-- Get queue type with a single field fetch
+local queueType = redis.call("HGET", keyQueueProperties, EQueuePropertyQueueType)
 
-local queueType = queueProperties[1]
+-- Early return if queue doesn't exist
 if queueType == false then
     return 'QUEUE_NOT_FOUND'
 end
 
+-- Handle different queue types
 if queueType == EQueuePropertyQueueTypePriorityQueue then
+    -- Check if priority is provided for priority queue
     if messagePriority == nil or messagePriority == '' then
         return 'MESSAGE_PRIORITY_REQUIRED'
     end
     redis.call("ZADD", keyPriorityQueue, messagePriority, messageId)
 else
+    -- Check if priority is incorrectly provided for non-priority queue
     if not (messagePriority == nil or messagePriority == '') then
         return 'PRIORITY_QUEUING_NOT_ENABLED'
     end
+
+    -- Handle LIFO and FIFO queues
     if queueType == EQueuePropertyQueueTypeLIFOQueue then
         redis.call("RPUSH", keyQueuePending, messageId)
     elseif queueType == EQueuePropertyQueueTypeFIFOQueue then
@@ -56,6 +49,14 @@ else
     end
 end
 
-saveMessage()
-return 'OK'
-
+-- Add message to queue and set its properties
+redis.call("SADD", keyQueueMessages, messageId)
+redis.call(
+    "HSET", keyMessage,
+    EMessagePropertyStatus, messageStatus,
+    EMessagePropertyState, messageState,
+    EMessagePropertyMessage, message
+)
+redis.call("HINCRBY", keyQueueProperties, EQueuePropertyMessagesCount, 1)
+
+return 'OK'