@boringnode/queue 0.5.2 → 0.6.0

package/build/chunk-S37X3CBO.js

@@ -0,0 +1,500 @@
+import {
+  REDIS_DEDUP_LUA,
+  REDIS_JOB_STORAGE_LUA
+} from "./chunk-6IO4P6RB.js";
+
+// src/drivers/redis_scripts.ts
+var PUSH_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local pending_key = KEYS[2]
+  local overlay_key = KEYS[3]
+  local job_id = ARGV[1]
+  local job_data = ARGV[2]
+  local score = tonumber(ARGV[3])
+
+${REDIS_JOB_STORAGE_LUA}
+
+  store_job_data(data_key, overlay_key, job_id, job_data)
+  redis.call('ZADD', pending_key, score, job_id)
+
+  return 1
+`;
+var PUSH_DEDUP_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local target_key = KEYS[2]
+  local dedup_key = KEYS[3]
+  local other_state_key = KEYS[4]
+  local overlay_key = KEYS[5]
+  local job_id = ARGV[1]
+  local job_data = ARGV[2]
+  local score = tonumber(ARGV[3])
+  local ttl = tonumber(ARGV[4])
+  local extend = tonumber(ARGV[5])
+  local replace = tonumber(ARGV[6])
+  local payload_data = ARGV[7]
+  local payload_is_undefined = tonumber(ARGV[8])
+
+${REDIS_JOB_STORAGE_LUA}
+${REDIS_DEDUP_LUA}
+
+  local existing_result = resolve_dedup_existing_job(
+    data_key,
+    target_key,
+    other_state_key,
+    overlay_key,
+    dedup_key,
+    extend,
+    replace,
+    payload_data,
+    payload_is_undefined
+  )
+  if existing_result then
+    return existing_result
+  end
+
+  store_job_data(data_key, overlay_key, job_id, job_data)
+  redis.call('ZADD', target_key, score, job_id)
+  redis.call('SET', dedup_key, job_id)
+  if ttl > 0 then
+    redis.call('PEXPIRE', dedup_key, ttl)
+  end
+  return {'added', job_id}
+`;
+var PUSH_DELAYED_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local delayed_key = KEYS[2]
+  local overlay_key = KEYS[3]
+  local job_id = ARGV[1]
+  local job_data = ARGV[2]
+  local execute_at = tonumber(ARGV[3])
+
+${REDIS_JOB_STORAGE_LUA}
+
+  store_job_data(data_key, overlay_key, job_id, job_data)
+  redis.call('ZADD', delayed_key, execute_at, job_id)
+
+  return 1
+`;
+var ACQUIRE_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local pending_key = KEYS[2]
+  local active_key = KEYS[3]
+  local delayed_key = KEYS[4]
+  local overlay_key = KEYS[5]
+  local worker_id = ARGV[1]
+  local now = tonumber(ARGV[2])
+
+${REDIS_JOB_STORAGE_LUA}
+
+  -- Process delayed jobs: move ready jobs to pending
+  local ready_job_ids = redis.call('ZRANGEBYSCORE', delayed_key, 0, now)
+  if #ready_job_ids > 0 then
+    for i = 1, #ready_job_ids do
+      local job_id = ready_job_ids[i]
+      local job_data = redis.call('HGET', data_key, job_id)
+      if job_data then
+        local job = cjson.decode(job_data)
+        local priority = job.priority or 5
+        local score = priority * 10000000000000 + now
+        redis.call('ZADD', pending_key, score, job_id)
+        redis.call('ZREM', delayed_key, job_id)
+      end
+    end
+  end
+
+  -- Pop highest priority job (lowest score)
+  local result = redis.call('ZPOPMIN', pending_key)
+  if not result or #result == 0 then
+    return nil
+  end
+
+  local job_id = result[1]
+  local job_data = redis.call('HGET', data_key, job_id)
+  if not job_data then
+    return nil
+  end
+
+  -- Store in active hash (without data, it's in data_key)
+  local active_data = cjson.encode({
+    workerId = worker_id,
+    acquiredAt = now
+  })
+  redis.call('HSET', active_key, job_id, active_data)
+
+  return encode_job_result(job_data, overlay_key, job_id, {
+    acquiredAt = now
+  })
+`;
+var REMOVE_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local active_key = KEYS[2]
+  local overlay_key = KEYS[3]
+  local job_id = ARGV[1]
+  local dedup_prefix = ARGV[2]
+
+${REDIS_JOB_STORAGE_LUA}
+
+  if redis.call('HEXISTS', active_key, job_id) == 0 then
+    return 0
+  end
+
+  -- Read job data to extract dedup.id before deleting
+  local job_data = redis.call('HGET', data_key, job_id)
+  if job_data then
+    local ok, job = pcall(cjson.decode, job_data)
+    if ok and job and job.dedup and job.dedup.id then
+      local dkey = dedup_prefix .. job.dedup.id
+      if redis.call('GET', dkey) == job_id then
+        redis.call('DEL', dkey)
+      end
+    end
+  end
+
+  redis.call('HDEL', active_key, job_id)
+  delete_job_data(data_key, overlay_key, job_id)
+
+  return 1
+`;
+var FINALIZE_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local active_key = KEYS[2]
+  local history_key = KEYS[3]
+  local index_key = KEYS[4]
+  local overlay_key = KEYS[5]
+  local job_id = ARGV[1]
+  local now = tonumber(ARGV[2])
+  local max_age = tonumber(ARGV[3])
+  local max_count = tonumber(ARGV[4])
+  local error_message = ARGV[5]
+  local dedup_prefix = ARGV[6]
+
+${REDIS_JOB_STORAGE_LUA}
+
+  -- Verify job is active
+  if redis.call('HEXISTS', active_key, job_id) == 0 then
+    return 0
+  end
+
+  -- Remove from active
+  redis.call('HDEL', active_key, job_id)
+
+  -- Store finalization info (data stays in data_key)
+  local record = {
+    finishedAt = now
+  }
+  if error_message and error_message ~= '' then
+    record.error = error_message
+  end
+  redis.call('HSET', history_key, job_id, cjson.encode(record))
+  redis.call('ZADD', index_key, now, job_id)
+
+  local function delete_dedup_for(ids)
+    for i = 1, #ids do
+      local id = ids[i]
+      local d = redis.call('HGET', data_key, id)
+      if d then
+        local ok, job = pcall(cjson.decode, d)
+        if ok and job and job.dedup and job.dedup.id then
+          local dkey = dedup_prefix .. job.dedup.id
+          if redis.call('GET', dkey) == id then
+            redis.call('DEL', dkey)
+          end
+        end
+      end
+    end
+  end
+
+  -- Prune by age
+  if max_age and max_age > 0 then
+    local cutoff = now - max_age
+    local expired = redis.call('ZRANGEBYSCORE', index_key, 0, cutoff)
+    if #expired > 0 then
+      delete_dedup_for(expired)
+      redis.call('ZREM', index_key, unpack(expired))
+      redis.call('HDEL', history_key, unpack(expired))
+      delete_jobs_data(data_key, overlay_key, expired)
+    end
+  end
+
+  -- Prune by count
+  if max_count and max_count > 0 then
+    local size = tonumber(redis.call('ZCARD', index_key))
+    if size > max_count then
+      local excess = size - max_count
+      local stale = redis.call('ZRANGE', index_key, 0, excess - 1)
+      if #stale > 0 then
+        delete_dedup_for(stale)
+        redis.call('ZREM', index_key, unpack(stale))
+        redis.call('HDEL', history_key, unpack(stale))
+        delete_jobs_data(data_key, overlay_key, stale)
+      end
+    end
+  end
+
+  return 1
+`;
+var RETRY_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local active_key = KEYS[2]
+  local pending_key = KEYS[3]
+  local delayed_key = KEYS[4]
+  local overlay_key = KEYS[5]
+  local job_id = ARGV[1]
+  local retry_at = tonumber(ARGV[2])
+  local now = tonumber(ARGV[3])
+
+${REDIS_JOB_STORAGE_LUA}
+
+  -- Verify job is active
+  if redis.call('HEXISTS', active_key, job_id) == 0 then
+    return 0
+  end
+
+  -- Get job data
+  local job_data = redis.call('HGET', data_key, job_id)
+  if not job_data then
+    return 0
+  end
+
+  -- Remove from active
+  redis.call('HDEL', active_key, job_id)
+
+  -- Increment attempts without rewriting opaque job JSON.
+  local job = cjson.decode(job_data)
+  local overlay = read_job_overlay(overlay_key, job_id)
+  overlay.attempts = (overlay.attempts or job.attempts or 0) + 1
+  write_job_overlay(overlay_key, job_id, overlay)
+
+  -- Add back to pending or delayed
+  if retry_at and retry_at > now then
+    redis.call('ZADD', delayed_key, retry_at, job_id)
+  else
+    -- Score = priority * 1e13 + timestamp
+    -- Lower score = higher priority, FIFO within same priority
+    local priority = job.priority or 5
+    local score = priority * 10000000000000 + now
+    redis.call('ZADD', pending_key, score, job_id)
+  end
+
+  return 1
+`;
+var RECOVER_STALLED_JOBS_SCRIPT = `
+  local data_key = KEYS[1]
+  local active_key = KEYS[2]
+  local pending_key = KEYS[3]
+  local overlay_key = KEYS[4]
+  local now = tonumber(ARGV[1])
+  local stalled_threshold = tonumber(ARGV[2])
+  local max_stalled_count = tonumber(ARGV[3])
+  local dedup_prefix = ARGV[4]
+
+${REDIS_JOB_STORAGE_LUA}
+
+  local recovered = 0
+  local stalled_cutoff = now - stalled_threshold
+
+  -- Get all active jobs
+  local active_jobs = redis.call('HGETALL', active_key)
+
+  -- HGETALL returns [field1, value1, field2, value2, ...]
+  for i = 1, #active_jobs, 2 do
+    local job_id = active_jobs[i]
+    local active_data = active_jobs[i + 1]
+    local active = cjson.decode(active_data)
+
+    -- Check if job is stalled
+    if active.acquiredAt < stalled_cutoff then
+      local job_data = redis.call('HGET', data_key, job_id)
+      if job_data then
+        local job = cjson.decode(job_data)
+        local overlay = read_job_overlay(overlay_key, job_id)
+        local current_stalled_count = overlay.stalledCount or job.stalledCount or 0
+
+        -- Remove from active hash
+        redis.call('HDEL', active_key, job_id)
+
+        -- Check if job has exceeded max stalled count
+        if current_stalled_count >= max_stalled_count then
+          -- Job failed permanently, remove data + dedup key (only if pointer still ours)
+          if job.dedup and job.dedup.id then
+            local dkey = dedup_prefix .. job.dedup.id
+            if redis.call('GET', dkey) == job_id then
+              redis.call('DEL', dkey)
+            end
+          end
+          delete_job_data(data_key, overlay_key, job_id)
+        else
+          -- Recover: increment stalledCount without rewriting opaque job JSON.
+          overlay.stalledCount = current_stalled_count + 1
+          write_job_overlay(overlay_key, job_id, overlay)
+          -- Score = priority * 1e13 + timestamp
+          local priority = job.priority or 5
+          local score = priority * 10000000000000 + now
+          redis.call('ZADD', pending_key, score, job_id)
+          recovered = recovered + 1
+        end
+      end
+    end
+  end
+
+  return recovered
+`;
+var RENEW_JOBS_SCRIPT = `
+  local active_key = KEYS[1]
+  local now = tonumber(ARGV[1])
+  local worker_id = ARGV[2]
+
+  local renewed = 0
+  for i = 3, #ARGV do
+    local job_id = ARGV[i]
+    local active_data = redis.call('HGET', active_key, job_id)
+    if active_data then
+      local active = cjson.decode(active_data)
+      -- Only the worker that currently owns the lease may renew it.
+      if active.workerId == worker_id then
+        active.acquiredAt = now
+        redis.call('HSET', active_key, job_id, cjson.encode(active))
+        renewed = renewed + 1
+      end
+    end
+  end
+
+  return renewed
+`;
+var GET_JOB_SCRIPT = `
+  local data_key = KEYS[1]
+  local pending_key = KEYS[2]
+  local delayed_key = KEYS[3]
+  local active_key = KEYS[4]
+  local completed_key = KEYS[5]
+  local failed_key = KEYS[6]
+  local overlay_key = KEYS[7]
+  local job_id = ARGV[1]
+
+${REDIS_JOB_STORAGE_LUA}
+
+  local job_data = redis.call('HGET', data_key, job_id)
+  if not job_data then
+    return nil
+  end
+
+  local status = nil
+  local finished_at = nil
+  local error_msg = nil
+
+  -- Check status in order
+  if redis.call('HEXISTS', active_key, job_id) == 1 then
+    status = 'active'
+  elseif redis.call('ZSCORE', pending_key, job_id) then
+    status = 'pending'
+  elseif redis.call('ZSCORE', delayed_key, job_id) then
+    status = 'delayed'
+  else
+    local completed_data = redis.call('HGET', completed_key, job_id)
+    if completed_data then
+      status = 'completed'
+      local record = cjson.decode(completed_data)
+      finished_at = record.finishedAt
+    else
+      local failed_data = redis.call('HGET', failed_key, job_id)
+      if failed_data then
+        status = 'failed'
+        local record = cjson.decode(failed_data)
+        finished_at = record.finishedAt
+        error_msg = record.error
+      end
+    end
+  end
+
+  if not status then
+    return nil
+  end
+
+  return encode_job_result(job_data, overlay_key, job_id, {
+    status = status,
+    finishedAt = finished_at,
+    error = error_msg
+  })
+`;
+var CLAIM_SCHEDULE_SCRIPT = `
+  local schedules_index_key = KEYS[1]
+  local schedule_key_prefix = KEYS[2]
+  local now = tonumber(ARGV[1])
+
+  local ids = redis.call('SMEMBERS', schedules_index_key)
+
+  for i = 1, #ids do
+    local schedule_key = schedule_key_prefix .. ids[i]
+
+    -- Get schedule data
+    local data = redis.call('HGETALL', schedule_key)
+    if #data > 0 then
+      -- Convert HGETALL result to table
+      local schedule = {}
+      for j = 1, #data, 2 do
+        schedule[data[j]] = data[j + 1]
+      end
+
+      -- Check if schedule is due
+      if schedule.status == 'active' then
+        local next_run_at = tonumber(schedule.next_run_at)
+
+        if next_run_at and next_run_at <= now then
+          local run_count = tonumber(schedule.run_count or '0')
+          local run_limit = schedule.run_limit and tonumber(schedule.run_limit) or nil
+          local to_date = schedule.to_date and tonumber(schedule.to_date) or nil
+
+          -- Check limits
+          if not (run_limit and run_count >= run_limit) and not (to_date and now > to_date) then
+            -- This schedule is claimable - atomically update it
+            local new_run_count = run_count + 1
+
+            -- Calculate new next_run_at (simple interval-based for now)
+            -- Complex cron calculation happens in the caller
+            local new_next_run_at = ''
+            local every_ms = schedule.every_ms and tonumber(schedule.every_ms) or nil
+            if every_ms then
+              new_next_run_at = tostring(now + every_ms)
+            end
+
+            -- Check if we've hit the limit after this run
+            if run_limit and new_run_count >= run_limit then
+              new_next_run_at = ''
+            end
+
+            -- Check if past end date
+            if to_date and new_next_run_at ~= '' and tonumber(new_next_run_at) > to_date then
+              new_next_run_at = ''
+            end
+
+            -- Update the schedule atomically
+            redis.call('HSET', schedule_key,
+              'next_run_at', new_next_run_at,
+              'last_run_at', tostring(now),
+              'run_count', tostring(new_run_count))
+
+            -- Return the schedule data (before update) as JSON
+            return cjson.encode(schedule)
+          end
+        end
+      end
+    end
+  end
+
+  return nil
+`;
+
+export {
+  PUSH_JOB_SCRIPT,
+  PUSH_DEDUP_JOB_SCRIPT,
+  PUSH_DELAYED_JOB_SCRIPT,
+  ACQUIRE_JOB_SCRIPT,
+  REMOVE_JOB_SCRIPT,
+  FINALIZE_JOB_SCRIPT,
+  RETRY_JOB_SCRIPT,
+  RECOVER_STALLED_JOBS_SCRIPT,
+  RENEW_JOBS_SCRIPT,
+  GET_JOB_SCRIPT,
+  CLAIM_SCHEDULE_SCRIPT
+};
+//# sourceMappingURL=chunk-S37X3CBO.js.map

package/build/chunk-S37X3CBO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/drivers/redis_scripts.ts"],"sourcesContent":["import { REDIS_DEDUP_LUA, REDIS_JOB_STORAGE_LUA } from './redis_job_storage.js'\n\n/**\n * Lua script for pushing a job to the queue.\n * Stores job data in the central hash and adds jobId to pending ZSET.\n */\nexport const PUSH_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local pending_key = KEYS[2]\n  local overlay_key = KEYS[3]\n  local job_id = ARGV[1]\n  local job_data = ARGV[2]\n  local score = tonumber(ARGV[3])\n\n${REDIS_JOB_STORAGE_LUA}\n\n  store_job_data(data_key, overlay_key, job_id, job_data)\n  redis.call('ZADD', pending_key, score, job_id)\n\n  return 1\n`\n\n/**\n * Lua script for pushing a dedup job.\n *\n * Behavior:\n * - If dedup key exists AND job still exists AND within TTL: apply replace/extend, skip insert.\n * - If dedup key exists but job data missing (orphan): proceed to insert new.\n * - If TTL expired or no prior entry: insert new job, record dedup key with TTL.\n *\n * Replace only applies to jobs in pending or delayed state. Active and\n * retained completed/failed jobs are left untouched (returns 'skipped').\n * Replace swaps the payload only — priority/queue/delay/groupId/dedup\n * options of the existing job are preserved.\n *\n * Extend uses the ORIGINAL ttl recorded on the existing job (stored in\n * its dedup field), not the ttl arg of the current dispatch. Matches\n * Knex/Fake behavior: extend resets the clock but never changes the\n * window length.\n *\n * Returns {outcome, job_id}: outcome ∈ 'added' | 'skipped' | 'replaced' | 'extended'.\n */\nexport const PUSH_DEDUP_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local target_key = KEYS[2]\n  local dedup_key = KEYS[3]\n  local other_state_key = KEYS[4]\n  local overlay_key = KEYS[5]\n  local job_id = ARGV[1]\n  local job_data = ARGV[2]\n  local score = tonumber(ARGV[3])\n  local ttl = tonumber(ARGV[4])\n  local extend = tonumber(ARGV[5])\n  local replace = tonumber(ARGV[6])\n  local payload_data = ARGV[7]\n  local payload_is_undefined = tonumber(ARGV[8])\n\n${REDIS_JOB_STORAGE_LUA}\n${REDIS_DEDUP_LUA}\n\n  local existing_result = resolve_dedup_existing_job(\n    data_key,\n    target_key,\n    other_state_key,\n    overlay_key,\n    dedup_key,\n    extend,\n    replace,\n    payload_data,\n    payload_is_undefined\n  )\n  if existing_result then\n    return existing_result\n  end\n\n  store_job_data(data_key, overlay_key, job_id, job_data)\n  redis.call('ZADD', target_key, score, job_id)\n  redis.call('SET', dedup_key, job_id)\n  if ttl > 0 then\n    redis.call('PEXPIRE', dedup_key, ttl)\n  end\n  return {'added', job_id}\n`\n\n/**\n * Lua script for pushing a delayed job.\n * Stores job data in the central hash and adds jobId to delayed ZSET.\n */\nexport const PUSH_DELAYED_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local delayed_key = KEYS[2]\n  local overlay_key = KEYS[3]\n  local job_id = ARGV[1]\n  local job_data = ARGV[2]\n  local execute_at = tonumber(ARGV[3])\n\n${REDIS_JOB_STORAGE_LUA}\n\n  store_job_data(data_key, overlay_key, job_id, job_data)\n  redis.call('ZADD', delayed_key, execute_at, job_id)\n\n  return 1\n`\n\n/**\n * Lua script for atomic job acquisition.\n * 1. Check and process delayed jobs\n * 2. Pop from pending queue\n * 3. Add to active hash with worker info\n * 4. Return job data\n */\nexport const ACQUIRE_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local pending_key = KEYS[2]\n  local active_key = KEYS[3]\n  local delayed_key = KEYS[4]\n  local overlay_key = KEYS[5]\n  local worker_id = ARGV[1]\n  local now = tonumber(ARGV[2])\n\n${REDIS_JOB_STORAGE_LUA}\n\n  -- Process delayed jobs: move ready jobs to pending\n  local ready_job_ids = redis.call('ZRANGEBYSCORE', delayed_key, 0, now)\n  if #ready_job_ids > 0 then\n    for i = 1, #ready_job_ids do\n      local job_id = ready_job_ids[i]\n      local job_data = redis.call('HGET', data_key, job_id)\n      if job_data then\n        local job = cjson.decode(job_data)\n        local priority = job.priority or 5\n        local score = priority * 10000000000000 + now\n        redis.call('ZADD', pending_key, score, job_id)\n        redis.call('ZREM', delayed_key, job_id)\n      end\n    end\n  end\n\n  -- Pop highest priority job (lowest score)\n  local result = redis.call('ZPOPMIN', pending_key)\n  if not result or #result == 0 then\n    return nil\n  end\n\n  local job_id = result[1]\n  local job_data = redis.call('HGET', data_key, job_id)\n  if not job_data then\n    return nil\n  end\n\n  -- Store in active hash (without data, it's in data_key)\n  local active_data = cjson.encode({\n    workerId = worker_id,\n    acquiredAt = now\n  })\n  redis.call('HSET', active_key, job_id, active_data)\n\n  return encode_job_result(job_data, overlay_key, job_id, {\n    acquiredAt = now\n  })\n`\n\n/**\n * Lua script for removing a job completely (no history).\n * Also cleans up the dedup key if the job had dedup metadata.\n */\nexport const REMOVE_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local active_key = KEYS[2]\n  local overlay_key = KEYS[3]\n  local job_id = ARGV[1]\n  local dedup_prefix = ARGV[2]\n\n${REDIS_JOB_STORAGE_LUA}\n\n  if redis.call('HEXISTS', active_key, job_id) == 0 then\n    return 0\n  end\n\n  -- Read job data to extract dedup.id before deleting\n  local job_data = redis.call('HGET', data_key, job_id)\n  if job_data then\n    local ok, job = pcall(cjson.decode, job_data)\n    if ok and job and job.dedup and job.dedup.id then\n      local dkey = dedup_prefix .. job.dedup.id\n      if redis.call('GET', dkey) == job_id then\n        redis.call('DEL', dkey)\n      end\n    end\n  end\n\n  redis.call('HDEL', active_key, job_id)\n  delete_job_data(data_key, overlay_key, job_id)\n\n  return 1\n`\n\n/**\n * Lua script for finalizing a job in history.\n * Removes from active, stores finalization info, and prunes old records.\n * When pruning removes job data, also deletes the associated dedup key.\n */\nexport const FINALIZE_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local active_key = KEYS[2]\n  local history_key = KEYS[3]\n  local index_key = KEYS[4]\n  local overlay_key = KEYS[5]\n  local job_id = ARGV[1]\n  local now = tonumber(ARGV[2])\n  local max_age = tonumber(ARGV[3])\n  local max_count = tonumber(ARGV[4])\n  local error_message = ARGV[5]\n  local dedup_prefix = ARGV[6]\n\n${REDIS_JOB_STORAGE_LUA}\n\n  -- Verify job is active\n  if redis.call('HEXISTS', active_key, job_id) == 0 then\n    return 0\n  end\n\n  -- Remove from active\n  redis.call('HDEL', active_key, job_id)\n\n  -- Store finalization info (data stays in data_key)\n  local record = {\n    finishedAt = now\n  }\n  if error_message and error_message ~= '' then\n    record.error = error_message\n  end\n  redis.call('HSET', history_key, job_id, cjson.encode(record))\n  redis.call('ZADD', index_key, now, job_id)\n\n  local function delete_dedup_for(ids)\n    for i = 1, #ids do\n      local id = ids[i]\n      local d = redis.call('HGET', data_key, id)\n      if d then\n        local ok, job = pcall(cjson.decode, d)\n        if ok and job and job.dedup and job.dedup.id then\n          local dkey = dedup_prefix .. job.dedup.id\n          if redis.call('GET', dkey) == id then\n            redis.call('DEL', dkey)\n          end\n        end\n      end\n    end\n  end\n\n  -- Prune by age\n  if max_age and max_age > 0 then\n    local cutoff = now - max_age\n    local expired = redis.call('ZRANGEBYSCORE', index_key, 0, cutoff)\n    if #expired > 0 then\n      delete_dedup_for(expired)\n      redis.call('ZREM', index_key, unpack(expired))\n      redis.call('HDEL', history_key, unpack(expired))\n      delete_jobs_data(data_key, overlay_key, expired)\n    end\n  end\n\n  -- Prune by count\n  if max_count and max_count > 0 then\n    local size = tonumber(redis.call('ZCARD', index_key))\n    if size > max_count then\n      local excess = size - max_count\n      local stale = redis.call('ZRANGE', index_key, 0, excess - 1)\n      if #stale > 0 then\n        delete_dedup_for(stale)\n        redis.call('ZREM', index_key, unpack(stale))\n        redis.call('HDEL', history_key, unpack(stale))\n        delete_jobs_data(data_key, overlay_key, stale)\n      end\n    end\n  end\n\n  return 1\n`\n\n/**\n * Lua script for retrying a job.\n * 1. Verify job is active\n * 2. Remove from active hash\n * 3. Increment attempts in data\n * 4. Add back to pending (or delayed if retryAt is set)\n */\nexport const RETRY_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local active_key = KEYS[2]\n  local pending_key = KEYS[3]\n  local delayed_key = KEYS[4]\n  local overlay_key = KEYS[5]\n  local job_id = ARGV[1]\n  local retry_at = tonumber(ARGV[2])\n  local now = tonumber(ARGV[3])\n\n${REDIS_JOB_STORAGE_LUA}\n\n  -- Verify job is active\n  if redis.call('HEXISTS', active_key, job_id) == 0 then\n    return 0\n  end\n\n  -- Get job data\n  local job_data = redis.call('HGET', data_key, job_id)\n  if not job_data then\n    return 0\n  end\n\n  -- Remove from active\n  redis.call('HDEL', active_key, job_id)\n\n  -- Increment attempts without rewriting opaque job JSON.\n  local job = cjson.decode(job_data)\n  local overlay = read_job_overlay(overlay_key, job_id)\n  overlay.attempts = (overlay.attempts or job.attempts or 0) + 1\n  write_job_overlay(overlay_key, job_id, overlay)\n\n  -- Add back to pending or delayed\n  if retry_at and retry_at > now then\n    redis.call('ZADD', delayed_key, retry_at, job_id)\n  else\n    -- Score = priority * 1e13 + timestamp\n    -- Lower score = higher priority, FIFO within same priority\n    local priority = job.priority or 5\n    local score = priority * 10000000000000 + now\n    redis.call('ZADD', pending_key, score, job_id)\n  end\n\n  return 1\n`\n\n/**\n * Lua script for recovering stalled jobs.\n * Scans the active hash for jobs that have been active too long.\n * - Jobs within maxStalledCount: move back to pending with incremented stalledCount\n * - Jobs exceeding maxStalledCount: remove permanently (fail)\n * Returns the number of recovered jobs (not including failed ones).\n */\nexport const RECOVER_STALLED_JOBS_SCRIPT = `\n  local data_key = KEYS[1]\n  local active_key = KEYS[2]\n  local pending_key = KEYS[3]\n  local overlay_key = KEYS[4]\n  local now = tonumber(ARGV[1])\n  local stalled_threshold = tonumber(ARGV[2])\n  local max_stalled_count = tonumber(ARGV[3])\n  local dedup_prefix = ARGV[4]\n\n${REDIS_JOB_STORAGE_LUA}\n\n  local recovered = 0\n  local stalled_cutoff = now - stalled_threshold\n\n  -- Get all active jobs\n  local active_jobs = redis.call('HGETALL', active_key)\n\n  -- HGETALL returns [field1, value1, field2, value2, ...]\n  for i = 1, #active_jobs, 2 do\n    local job_id = active_jobs[i]\n    local active_data = active_jobs[i + 1]\n    local active = cjson.decode(active_data)\n\n    -- Check if job is stalled\n    if active.acquiredAt < stalled_cutoff then\n      local job_data = redis.call('HGET', data_key, job_id)\n      if job_data then\n        local job = cjson.decode(job_data)\n        local overlay = read_job_overlay(overlay_key, job_id)\n        local current_stalled_count = overlay.stalledCount or job.stalledCount or 0\n\n        -- Remove from active hash\n        redis.call('HDEL', active_key, job_id)\n\n        -- Check if job has exceeded max stalled count\n        if current_stalled_count >= max_stalled_count then\n          -- Job failed permanently, remove data + dedup key (only if pointer still ours)\n          if job.dedup and job.dedup.id then\n            local dkey = dedup_prefix .. job.dedup.id\n            if redis.call('GET', dkey) == job_id then\n              redis.call('DEL', dkey)\n            end\n          end\n          delete_job_data(data_key, overlay_key, job_id)\n        else\n          -- Recover: increment stalledCount without rewriting opaque job JSON.\n          overlay.stalledCount = current_stalled_count + 1\n          write_job_overlay(overlay_key, job_id, overlay)\n          -- Score = priority * 1e13 + timestamp\n          local priority = job.priority or 5\n          local score = priority * 10000000000000 + now\n          redis.call('ZADD', pending_key, score, job_id)\n          recovered = recovered + 1\n        end\n      end\n    end\n  end\n\n  return recovered\n`\n\n/**\n * Lua script for renewing the acquired timestamp of in-flight jobs (heartbeat).\n * Only entries still present in the active hash AND still owned by the calling\n * worker are renewed, so a job that was already recovered, finalized, or\n * re-acquired by another worker is never resurrected by a late heartbeat.\n * Preserves the existing worker info, updating only acquiredAt.\n * Returns the number of jobs renewed.\n */\nexport const RENEW_JOBS_SCRIPT = `\n  local active_key = KEYS[1]\n  local now = tonumber(ARGV[1])\n  local worker_id = ARGV[2]\n\n  local renewed = 0\n  for i = 3, #ARGV do\n    local job_id = ARGV[i]\n    local active_data = redis.call('HGET', active_key, job_id)\n    if active_data then\n      local active = cjson.decode(active_data)\n      -- Only the worker that currently owns the lease may renew it.\n      if active.workerId == worker_id then\n        active.acquiredAt = now\n        redis.call('HSET', active_key, job_id, cjson.encode(active))\n        renewed = renewed + 1\n      end\n    end\n  end\n\n  return renewed\n`\n\n/**\n * Lua script for getting a job record with its status.\n */\nexport const GET_JOB_SCRIPT = `\n  local data_key = KEYS[1]\n  local pending_key = KEYS[2]\n  local delayed_key = KEYS[3]\n  local active_key = KEYS[4]\n  local completed_key = KEYS[5]\n  local failed_key = KEYS[6]\n  local overlay_key = KEYS[7]\n  local job_id = ARGV[1]\n\n${REDIS_JOB_STORAGE_LUA}\n\n  local job_data = redis.call('HGET', data_key, job_id)\n  if not job_data then\n    return nil\n  end\n\n  local status = nil\n  local finished_at = nil\n  local error_msg = nil\n\n  -- Check status in order\n  if redis.call('HEXISTS', active_key, job_id) == 1 then\n    status = 'active'\n  elseif redis.call('ZSCORE', pending_key, job_id) then\n    status = 'pending'\n  elseif redis.call('ZSCORE', delayed_key, job_id) then\n    status = 'delayed'\n  else\n    local completed_data = redis.call('HGET', completed_key, job_id)\n    if completed_data then\n      status = 'completed'\n      local record = cjson.decode(completed_data)\n      finished_at = record.finishedAt\n    else\n      local failed_data = redis.call('HGET', failed_key, job_id)\n      if failed_data then\n        status = 'failed'\n        local record = cjson.decode(failed_data)\n        finished_at = record.finishedAt\n        error_msg = record.error\n      end\n    end\n  end\n\n  if not status then\n    return nil\n  end\n\n  return encode_job_result(job_data, overlay_key, job_id, {\n    status = status,\n    finishedAt = finished_at,\n    error = error_msg\n  })\n`\n\n/**\n * Lua script for atomically claiming a due schedule.\n * Iterates the schedule index server-side and claims the first due schedule.\n * Returns the schedule data if claimed, nil otherwise.\n */\nexport const CLAIM_SCHEDULE_SCRIPT = `\n  local schedules_index_key = KEYS[1]\n  local schedule_key_prefix = KEYS[2]\n  local now = tonumber(ARGV[1])\n\n  local ids = redis.call('SMEMBERS', schedules_index_key)\n\n  for i = 1, #ids do\n    local schedule_key = schedule_key_prefix .. ids[i]\n\n    -- Get schedule data\n    local data = redis.call('HGETALL', schedule_key)\n    if #data > 0 then\n      -- Convert HGETALL result to table\n      local schedule = {}\n      for j = 1, #data, 2 do\n        schedule[data[j]] = data[j + 1]\n      end\n\n      -- Check if schedule is due\n      if schedule.status == 'active' then\n        local next_run_at = tonumber(schedule.next_run_at)\n\n        if next_run_at and next_run_at <= now then\n          local run_count = tonumber(schedule.run_count or '0')\n          local run_limit = schedule.run_limit and tonumber(schedule.run_limit) or nil\n          local to_date = schedule.to_date and tonumber(schedule.to_date) or nil\n\n          -- Check limits\n          if not (run_limit and run_count >= run_limit) and not (to_date and now > to_date) then\n            -- This schedule is claimable - atomically update it\n            local new_run_count = run_count + 1\n\n            -- Calculate new next_run_at (simple interval-based for now)\n            -- Complex cron calculation happens in the caller\n            local new_next_run_at = ''\n            local every_ms = schedule.every_ms and tonumber(schedule.every_ms) or nil\n            if every_ms then\n              new_next_run_at = tostring(now + every_ms)\n            end\n\n            -- Check if we've hit the limit after this run\n            if run_limit and new_run_count >= run_limit then\n              new_next_run_at = ''\n            end\n\n            -- Check if past end date\n            if to_date and new_next_run_at ~= '' and tonumber(new_next_run_at) > to_date then\n              new_next_run_at = ''\n            end\n\n            -- Update the schedule atomically\n            redis.call('HSET', schedule_key,\n              'next_run_at', new_next_run_at,\n              'last_run_at', tostring(now),\n              'run_count', tostring(new_run_count))\n\n            -- Return the schedule data (before update) as JSON\n            return cjson.encode(schedule)\n          end\n        end\n      end\n    end\n  end\n\n  return nil\n`\n"],"mappings":"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","names":[]}

package/build/index.d.ts

@@ -1,5 +1,5 @@
-import { Q as QueueManagerConfig, W as WorkerCycle, R as RetryConfig, g as JobOptions, h as QueueConfig, D as Duration, A as Adapter, i as JobFactory, L as Logger, b as AcquiredJob, j as Job, a as JobClass, e as ScheduleData, k as ScheduleStatus, f as ScheduleListOptions } from './job-Z5fBSzRX.js';
-export { m as JobBatchDispatcher, l as ScheduleBuilder, n as customBackoff, p as exponentialBackoff, q as fixedBackoff, o as linearBackoff } from './job-Z5fBSzRX.js';
+import { Q as QueueManagerConfig, W as WorkerCycle, R as RetryConfig, g as JobOptions, h as QueueConfig, i as Duration, A as Adapter, j as JobFactory, L as Logger, b as AcquiredJob, k as Job, a as JobClass, e as ScheduleData, l as ScheduleStatus, f as ScheduleListOptions } from './job-C4oyCVxR.js';
+export { m as JobBatchDispatcher, n as ScheduleBuilder, o as customBackoff, p as exponentialBackoff, q as fixedBackoff, r as linearBackoff } from './job-C4oyCVxR.js';
 import { FakeAdapter } from './src/drivers/fake_adapter.js';
 import { Knex } from 'knex';
 import * as _poppinss_utils_exception from '@poppinss/utils/exception';
@@ -513,6 +513,14 @@ declare class QueueSchemaService {
      * The optional callback allows adding custom columns.
      */
     createJobsTable(tableName?: string, extend?: (table: Knex.CreateTableBuilder) => void): Promise<void>;
+    /**
+     * Idempotent migration: adds dedup columns (dedup_id, dedup_at, dedup_ttl)
+     * and a (queue, dedup_id) index to an existing jobs table.
+     *
+     * Safe to run multiple times. Uses hasColumn checks so it won't fail on re-runs.
+     * For large Postgres tables, consider pausing workers during the run.
+     */
+    addDedupColumns(tableName?: string): Promise<void>;
     /**
      * Creates the schedules table with the default schema.
      * The optional callback allows adding custom columns.