@tachybase/plugin-adapter-bullmq 0.23.8

package/dist/node_modules/bullmq/dist/cjs/commands/includes/cleanList.lua

@@ -0,0 +1,47 @@
+--[[
+  Function to clean job list.
+  Returns jobIds and deleted count number.
+]]
+
+-- Includes
+--- @include "getTimestamp"
+--- @include "removeJob"
+
+local function cleanList(listKey, jobKeyPrefix, rangeStart, rangeEnd,
+  timestamp, isWaiting)
+  local jobs = rcall("LRANGE", listKey, rangeStart, rangeEnd)
+  local deleted = {}
+  local deletedCount = 0
+  local jobTS
+  local deletionMarker = ''
+  local jobIdsLen = #jobs
+  for i, job in ipairs(jobs) do
+    if limit > 0 and deletedCount >= limit then
+      break
+    end
+  
+    local jobKey = jobKeyPrefix .. job
+    if (isWaiting or rcall("EXISTS", jobKey .. ":lock") == 0) then
+      -- Find the right timestamp of the job to compare to maxTimestamp:
+      -- * finishedOn says when the job was completed, but it isn't set unless the job has actually completed
+      -- * processedOn represents when the job was last attempted, but it doesn't get populated until
+      --   the job is first tried
+      -- * timestamp is the original job submission time
+      -- Fetch all three of these (in that order) and use the first one that is set so that we'll leave jobs
+      -- that have been active within the grace period:
+      jobTS = getTimestamp(jobKey, {"finishedOn", "processedOn", "timestamp"})
+      if (not jobTS or jobTS <= timestamp) then
+        -- replace the entry with a deletion marker; the actual deletion will
+        -- occur at the end of the script
+        rcall("LSET", listKey, rangeEnd - jobIdsLen + i, deletionMarker)
+        removeJob(job, true, jobKeyPrefix, true --[[remove debounce key]])
+        deletedCount = deletedCount + 1
+        table.insert(deleted, job)
+      end
+    end
+  end
+
+  rcall("LREM", listKey, 0, deletionMarker)
+
+  return {deleted, deletedCount}
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/cleanSet.lua

@@ -0,0 +1,66 @@
+--[[
+  Function to clean job set.
+  Returns jobIds and deleted count number.
+]] 
+
+-- Includes
+--- @include "batches"
+--- @include "getJobsInZset"
+--- @include "getTimestamp"
+--- @include "removeJob"
+local function isJobSchedulerJob(jobId, jobSchedulersKey)
+    if jobSchedulersKey then
+        local jobSchedulerId = jobId:match("repeat:(.*):%d+")
+        if jobSchedulerId then
+            return rcall("ZSCORE", jobSchedulersKey, jobSchedulerId)
+        end
+    end
+    return false
+end
+
+local function cleanSet(
+    setKey,
+    jobKeyPrefix,
+    rangeEnd,
+    timestamp,
+    limit,
+    attributes,
+    isFinished,
+    jobSchedulersKey)
+    local jobs = getJobsInZset(setKey, rangeEnd, limit)
+    local deleted = {}
+    local deletedCount = 0
+    local jobTS
+    for i, job in ipairs(jobs) do
+        if limit > 0 and deletedCount >= limit then
+            break
+        end
+
+        -- Extract a Job Scheduler Id from jobId ("repeat:job-scheduler-id:millis") 
+        -- and check if it is in the scheduled jobs
+        if not isJobSchedulerJob(job, jobSchedulersKey) then
+            local jobKey = jobKeyPrefix .. job
+            if isFinished then
+                removeJob(job, true, jobKeyPrefix, true --[[remove debounce key]] )
+                deletedCount = deletedCount + 1
+                table.insert(deleted, job)
+            else
+                -- * finishedOn says when the job was completed, but it isn't set unless the job has actually completed
+                jobTS = getTimestamp(jobKey, attributes)
+                if (not jobTS or jobTS <= timestamp) then
+                    removeJob(job, true, jobKeyPrefix, true --[[remove debounce key]] )
+                    deletedCount = deletedCount + 1
+                    table.insert(deleted, job)
+                end
+            end
+        end
+    end
+
+    if (#deleted > 0) then
+        for from, to in batches(#deleted, 7000) do
+            rcall("ZREM", setKey, unpack(deleted, from, to))
+        end
+    end
+
+    return {deleted, deletedCount}
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/collectMetrics.lua

@@ -0,0 +1,46 @@
+--[[
+  Functions to collect metrics based on a current and previous count of jobs.
+  Granualarity is fixed at 1 minute.
+]] 
+--- @include "batches"
+local function collectMetrics(metaKey, dataPointsList, maxDataPoints,
+                                 timestamp)
+    -- Increment current count
+    local count = rcall("HINCRBY", metaKey, "count", 1) - 1
+
+    -- Compute how many data points we need to add to the list, N.
+    local prevTS = rcall("HGET", metaKey, "prevTS")
+
+    if not prevTS then
+        -- If prevTS is nil, set it to the current timestamp
+        rcall("HSET", metaKey, "prevTS", timestamp, "prevCount", 0)
+        return
+    end
+
+    local N = math.min(math.floor(timestamp / 60000) - math.floor(prevTS / 60000), tonumber(maxDataPoints))
+
+    if N > 0 then
+        local delta = count - rcall("HGET", metaKey, "prevCount")
+        -- If N > 1, add N-1 zeros to the list
+        if N > 1 then
+            local points = {}
+            points[1] = delta
+            for i = 2, N do
+                points[i] = 0
+            end
+
+            for from, to in batches(#points, 7000) do
+                rcall("LPUSH", dataPointsList, unpack(points, from, to))
+            end
+        else
+            -- LPUSH delta to the list
+            rcall("LPUSH", dataPointsList, delta)
+        end
+
+        -- LTRIM to keep list to its max size
+        rcall("LTRIM", dataPointsList, 0, maxDataPoints - 1)
+
+        -- update prev count with current count
+        rcall("HSET", metaKey, "prevCount", count, "prevTS", timestamp)
+    end
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/deduplicateJob.lua

@@ -0,0 +1,24 @@
+--[[
+  Function to debounce a job.
+]]
+
+local function deduplicateJob(prefixKey, deduplicationOpts, jobId, deduplicationKey, eventsKey, maxEvents)
+  local deduplicationId = deduplicationOpts and deduplicationOpts['id']
+  if deduplicationId then
+    local ttl = deduplicationOpts['ttl']
+    local deduplicationKeyExists
+    if ttl then
+      deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'PX', ttl, 'NX')
+    else
+      deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'NX')
+    end
+    if deduplicationKeyExists then
+      local currentDebounceJobId = rcall('GET', deduplicationKey)
+      rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+        "debounced", "jobId", currentDebounceJobId, "debounceId", deduplicationId)
+      rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+        "deduplicated", "jobId", currentDebounceJobId, "deduplicationId", deduplicationId)
+      return currentDebounceJobId
+    end
+  end
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/destructureJobKey.lua

@@ -0,0 +1,12 @@
+--[[
+  Functions to destructure job key.
+  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
+]]
+
+local getJobIdFromKey = function (jobKey)
+  return string.match(jobKey, ".*:(.*)")
+end
+
+local getJobKeyPrefix = function (jobKey, jobId)
+  return string.sub(jobKey, 0, #jobKey - #jobId)
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/findPage.lua

@@ -0,0 +1,70 @@
+--[[
+  Function to achieve pagination for a set or hash.
+  This function simulates pagination in the most efficient way possible
+  for a set using sscan or hscan.
+
+  The main limitation is that sets are not order preserving, so the
+  pagination is not stable. This means that if the set is modified
+  between pages, the same element may appear in different pages.
+]] -- Maximum number of elements to be returned by sscan per iteration.
+local maxCount = 100
+
+-- Finds the cursor, and returns the first elements available for the requested page.
+local function findPage(key, command, pageStart, pageSize, cursor, offset,
+                        maxIterations, fetchJobs)
+    local items = {}
+    local jobs = {}
+    local iterations = 0
+
+    repeat
+        -- Iterate over the set using sscan/hscan.
+        local result = rcall(command, key, cursor, "COUNT", maxCount)
+
+        cursor = result[1]
+        local members = result[2]
+        local step = 1
+        if command == "HSCAN" then
+            step = 2
+        end
+        
+        if #members == 0 then
+            -- If the result is empty, we can return the result.
+            return cursor, offset, items, jobs
+        end
+
+        local chunkStart = offset
+        local chunkEnd = offset + #members / step
+
+        local pageEnd = pageStart + pageSize
+
+        if chunkEnd < pageStart then
+            -- If the chunk is before the page, we can skip it.
+            offset = chunkEnd
+        elseif chunkStart > pageEnd then
+            -- If the chunk is after the page, we can return the result.
+            return cursor, offset, items, jobs
+        else
+            -- If the chunk is overlapping the page, we need to add the elements to the result.
+            for i = 1, #members, step do
+                if offset >= pageEnd then
+                    return cursor, offset, items, jobs
+                end
+                if offset >= pageStart then
+                    local index = #items + 1
+                    if fetchJobs ~= nil then
+                        jobs[#jobs+1] = rcall("HGETALL", members[i])
+                    end
+                    if step == 2 then
+                        items[index] = {members[i], members[i + 1]}
+                    else
+                        items[index] = members[i]
+                    end
+                end
+                offset = offset + 1
+            end
+        end
+        iterations = iterations + 1
+    until cursor == "0" or iterations >= maxIterations
+
+    return cursor, offset, items, jobs
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getDelayedScore.lua

@@ -0,0 +1,25 @@
+--[[
+  Bake in the job id first 12 bits into the timestamp
+  to guarantee correct execution order of delayed jobs
+  (up to 4096 jobs per given timestamp or 4096 jobs apart per timestamp)
+  WARNING: Jobs that are so far apart that they wrap around will cause FIFO to fail
+]]
+local function getDelayedScore(delayedKey, timestamp, delay)
+  local delayedTimestamp = (delay > 0 and (tonumber(timestamp) + delay)) or tonumber(timestamp)
+  local minScore = delayedTimestamp * 0x1000
+  local maxScore = (delayedTimestamp + 1 ) * 0x1000 - 1
+
+  local result = rcall("ZREVRANGEBYSCORE", delayedKey, maxScore,
+    minScore, "WITHSCORES","LIMIT", 0, 1)
+  if #result then
+    local currentMaxScore = tonumber(result[2])
+    if currentMaxScore ~= nil then
+      if currentMaxScore >= maxScore then
+        return maxScore, delayedTimestamp
+      else
+        return currentMaxScore + 1, delayedTimestamp
+      end
+    end
+  end
+  return minScore, delayedTimestamp
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getJobsInZset.lua

@@ -0,0 +1,13 @@
+--[[
+  We use ZRANGEBYSCORE to make the case where we're deleting a limited number
+  of items in a sorted set only run a single iteration. If we simply used
+  ZRANGE, we may take a long time traversing through jobs that are within the
+  grace period.
+]]
+local function getJobsInZset(zsetKey, rangeEnd, limit)
+  if limit > 0 then
+    return rcall("ZRANGEBYSCORE", zsetKey, 0, rangeEnd, "LIMIT", 0, limit)
+  else
+    return rcall("ZRANGEBYSCORE", zsetKey, 0, rangeEnd)
+  end
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getNextDelayedTimestamp.lua

@@ -0,0 +1,12 @@
+--[[
+  Function to return the next delayed job timestamp.
+]]
+local function getNextDelayedTimestamp(delayedKey)
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if nextTimestamp ~= nil then 
+      return nextTimestamp / 0x1000
+    end
+  end
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getOrSetMaxEvents.lua

@@ -0,0 +1,11 @@
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getRateLimitTTL.lua

@@ -0,0 +1,17 @@
+--[[
+  Function to get current rate limit ttl.
+]]
+local function getRateLimitTTL(maxJobs, rateLimiterKey)
+  if maxJobs and maxJobs <= tonumber(rcall("GET", rateLimiterKey) or 0) then
+    local pttl = rcall("PTTL", rateLimiterKey)
+
+    if pttl == 0 then
+      rcall("DEL", rateLimiterKey)
+    end
+
+    if pttl > 0 then
+      return pttl
+    end
+  end
+  return 0
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getTargetQueueList.lua

@@ -0,0 +1,22 @@
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+
+  if queueAttributes[1] then
+    return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
+  end
+  return waitKey, false
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getTimestamp.lua

@@ -0,0 +1,19 @@
+--[[
+  Function to get the latest saved timestamp.
+]]
+
+local function getTimestamp(jobKey, attributes)
+  if #attributes == 1 then
+    return rcall("HGET", jobKey, attributes[1])
+  end
+
+  local jobTs
+  for _, ts in ipairs(rcall("HMGET", jobKey, unpack(attributes))) do
+    if (ts) then
+      jobTs = ts
+      break
+    end
+  end
+
+  return jobTs
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/getZSetItems.lua

@@ -0,0 +1,7 @@
+--[[
+  Function to get ZSet items.
+]]
+
+local function getZSetItems(keyName, max)
+  return rcall('ZRANGE', keyName, 0, max - 1)
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/handleDuplicatedJob.lua

@@ -0,0 +1,26 @@
+--[[
+  Function to handle the case when job is duplicated.
+]]
+
+-- Includes
+--- @include "updateExistingJobsParent"
+
+local function handleDuplicatedJob(jobKey, jobId, currentParentKey, currentParent,
+  parentData, parentDependenciesKey, completedKey, eventsKey, maxEvents, timestamp)
+  local existedParentKey = rcall("HGET", jobKey, "parentKey")
+
+  if not existedParentKey or existedParentKey == currentParentKey then
+    updateExistingJobsParent(currentParentKey, currentParent, parentData,
+      parentDependenciesKey, completedKey, jobKey,
+      jobId, timestamp)
+  else
+    if currentParentKey ~= nil and currentParentKey ~= existedParentKey
+      and (rcall("EXISTS", existedParentKey) == 1) then
+      return -7
+    end
+  end
+  rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+    "duplicated", "jobId", jobId)
+
+  return jobId .. "" -- convert to string
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/isLocked.lua

@@ -0,0 +1,33 @@
+--[[
+  Function to recursively check if there are no locks
+  on the jobs to be removed.
+
+  returns:
+    boolean
+]]
+
+local function isLocked( prefix, jobId, removeChildren)
+  local jobKey = prefix .. jobId;
+
+  -- Check if this job is locked
+  local lockKey = jobKey .. ':lock'
+  local lock = rcall("GET", lockKey)
+  if not lock then
+    if removeChildren == "1" then
+      local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
+      if (#dependencies > 0) then
+        for i, childJobKey in ipairs(dependencies) do
+          -- We need to get the jobId for this job.
+          local childJobId = getJobIdFromKey(childJobKey)
+          local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
+          local result = isLocked( childJobPrefix, childJobId, removeChildren )
+          if result then
+            return true
+          end
+        end
+      end
+    end
+    return false
+  end
+  return true
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/isQueueMaxed.lua

@@ -0,0 +1,15 @@
+--[[
+  Function to check if queue is maxed or not.
+]]
+local function isQueueMaxed(queueMetaKey, activeKey)
+  local maxConcurrency = rcall("HGET", queueMetaKey, "concurrency")
+
+  if maxConcurrency then
+    local activeCount = rcall("LLEN", activeKey)
+    if activeCount >= tonumber(maxConcurrency) then
+      return true
+    end
+  end
+
+  return false
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/isQueuePaused.lua

@@ -0,0 +1,7 @@
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function isQueuePaused(queueMetaKey)
+  return rcall("HEXISTS", queueMetaKey, "paused") == 1
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/isQueuePausedOrMaxed.lua

@@ -0,0 +1,18 @@
+--[[
+  Function to check if queue is paused or maxed
+  (since an empty list and !EXISTS are not really the same).
+]]
+
+local function isQueuePausedOrMaxed(queueMetaKey, activeKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+
+  if queueAttributes[1] then
+    return true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      return activeCount >= tonumber(queueAttributes[2])
+    end
+  end
+  return false
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/moveJobFromPriorityToActive.lua

@@ -0,0 +1,13 @@
+--[[
+  Function to move job from prioritized state to active.
+]]
+
+local function moveJobFromPriorityToActive(priorityKey, activeKey, priorityCounterKey)
+  local prioritizedJob = rcall("ZPOPMIN", priorityKey)
+  if #prioritizedJob > 0 then
+    rcall("LPUSH", activeKey, prioritizedJob[1])
+    return prioritizedJob[1]
+  else
+    rcall("DEL", priorityCounterKey)
+  end
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/moveParentFromWaitingChildrenToFailed.lua

@@ -0,0 +1,53 @@
+--[[
+  Function to recursively move from waitingChildren to failed.
+]]
+
+-- Includes
+--- @include "moveParentToWaitIfNeeded"
+--- @include "removeDeduplicationKeyIfNeeded"
+--- @include "removeJobsOnFail"
+
+local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
+  if rcall("ZREM", parentQueueKey .. ":waiting-children", parentId) == 1 then
+    local parentQueuePrefix = parentQueueKey .. ":"
+    local parentFailedKey = parentQueueKey .. ":failed"
+    rcall("ZADD", parentFailedKey, timestamp, parentId)
+    local failedReason = "child " .. jobIdKey .. " failed"
+    rcall("HMSET", parentKey, "failedReason", failedReason, "finishedOn", timestamp)
+    rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
+      failedReason, "prev", "waiting-children")
+
+    local jobAttributes = rcall("HMGET", parentKey, "parent", "deid", "opts")
+
+    removeDeduplicationKeyIfNeeded(parentQueueKey .. ":", jobAttributes[2])
+
+    if jobAttributes[1] then
+      local parentData = cjson.decode(jobAttributes[1])
+      if parentData['fpof'] then
+        moveParentFromWaitingChildrenToFailed(
+          parentData['queueKey'],
+          parentData['queueKey'] .. ':' .. parentData['id'],
+          parentData['id'],
+          parentKey,
+          timestamp
+        )
+      elseif parentData['idof'] or parentData['rdof'] then
+        local grandParentKey = parentData['queueKey'] .. ':' .. parentData['id']
+        local grandParentDependenciesSet = grandParentKey .. ":dependencies"
+        if rcall("SREM", grandParentDependenciesSet, parentKey) == 1 then
+          moveParentToWaitIfNeeded(parentData['queueKey'], grandParentDependenciesSet,
+            grandParentKey, parentData['id'], timestamp)
+          if parentData['idof'] then
+            local grandParentFailedSet = grandParentKey .. ":failed"
+            rcall("HSET", grandParentFailedSet, parentKey, failedReason)
+          end
+        end
+      end
+    end
+
+    local parentRawOpts = jobAttributes[3]
+    local parentOpts = cjson.decode(parentRawOpts)
+    
+    removeJobsOnFail(parentQueuePrefix, parentFailedKey, parentId, parentOpts, timestamp)
+  end
+end

package/dist/node_modules/bullmq/dist/cjs/commands/includes/moveParentToWaitIfNeeded.lua

@@ -0,0 +1,55 @@
+--[[
+  Validate and move parent to active if needed.
+]]
+
+-- Includes
+--- @include "addDelayMarkerIfNeeded"
+--- @include "addJobInTargetList"
+--- @include "addJobWithPriority"
+--- @include "isQueuePausedOrMaxed"
+--- @include "getTargetQueueList"
+
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
+                                        parentKey, parentId, timestamp)
+    local isParentActive = rcall("ZSCORE",
+                                 parentQueueKey .. ":waiting-children", parentId)
+    if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then
+        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+        local parentWaitKey = parentQueueKey .. ":wait"
+        local parentPausedKey = parentQueueKey .. ":paused"
+        local parentActiveKey = parentQueueKey .. ":active"
+        local parentMetaKey = parentQueueKey .. ":meta"
+
+        local parentMarkerKey = parentQueueKey .. ":marker"
+        local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
+        local priority = tonumber(jobAttributes[1]) or 0
+        local delay = tonumber(jobAttributes[2]) or 0
+
+        if delay > 0 then
+            local delayedTimestamp = tonumber(timestamp) + delay
+            local score = delayedTimestamp * 0x1000
+            local parentDelayedKey = parentQueueKey .. ":delayed"
+            rcall("ZADD", parentDelayedKey, score, parentId)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed",
+                  "jobId", parentId, "delay", delayedTimestamp)
+
+            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+        else
+            if priority == 0 then
+                local parentTarget, isParentPausedOrMaxed =
+                    getTargetQueueList(parentMetaKey, parentActiveKey, parentWaitKey,
+                                       parentPausedKey)
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed,
+                    parentId)
+            else
+                local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
+                addJobWithPriority(parentMarkerKey,
+                                   parentQueueKey .. ":prioritized", priority,
+                                   parentId, parentQueueKey .. ":pc", isPausedOrMaxed)
+            end
+
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
+                  "jobId", parentId, "prev", "waiting-children")
+        end
+    end
+end