@getstrata/core 2.2.13 → 2.2.15

package/dist/entries/queue/publicQueue.js

@@ -448,21 +448,6 @@ redis.call('XDEL', KEYS[1], ARGV[2])
 if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[3]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[3]) end
 return 1
 `;
-var PROMOTE_RETRIES = `
-local kinds = {'stream','zset'}
-for i=1,2 do
-  local kind = redis.call('TYPE', KEYS[i]).ok
-  if kind ~= 'none' and kind ~= kinds[i] then return redis.error_reply('Invalid stream retry promotion key type') end
-end
-local now = redis.call('TIME')
-local due = tonumber(now[1])*1000 + math.floor(tonumber(now[2])/1000)
-local entries = redis.call('ZRANGE', KEYS[2], '-inf', due, 'BYSCORE', 'LIMIT', 0, 100)
-for _, payload in ipairs(entries) do
-  redis.call('XADD', KEYS[1], '*', 'payload', payload)
-  redis.call('ZREM', KEYS[2], payload)
-end
-return #entries
-`;
 async function scheduleStreamRetry(client, key, reservation, envelope, delayMs) {
   if (!Number.isSafeInteger(delayMs) || delayMs < 0 || delayMs > Number.MAX_SAFE_INTEGER / 2)
     throw new Error("Invalid Streams retry delay");
@@ -484,8 +469,93 @@ async function scheduleStreamRetry(client, key, reservation, envelope, delayMs)
   if (Number(scheduled) !== 1)
     throw new Error("Queue lease lost while scheduling retry");
 }
-async function promoteStreamRetries(client, key) {
-  return Number(await client.send("EVAL", [PROMOTE_RETRIES, "2", streamQueueKey(key), streamRetryKey(key)]));
+var POLL_STREAM_PRIORITIES = `
+local group = ARGV[1]
+local owner = ARGV[2]
+local visibility = ARGV[3]
+local function payloadOf(fields)
+  for index = 1, #fields, 2 do
+    if fields[index] == 'payload' and type(fields[index + 1]) == 'string' then return fields[index + 1] end
+  end
+  return ''
+end
+local cursors = {}
+for i = 1, #KEYS / 2 do cursors[i] = ARGV[3 + i] end
+for i = 1, #KEYS / 2 do
+  local stream = KEYS[(i - 1) * 2 + 1]
+  local retries = KEYS[(i - 1) * 2 + 2]
+  local cursor = ARGV[3 + i]
+  local streamKind = redis.call('TYPE', stream).ok
+  local retryKind = redis.call('TYPE', retries).ok
+  if streamKind ~= 'none' and streamKind ~= 'stream' then return redis.error_reply('Invalid stream retry promotion key type') end
+  if retryKind ~= 'none' and retryKind ~= 'zset' then return redis.error_reply('Invalid stream retry promotion key type') end
+  if streamKind == 'stream' then
+    local now = redis.call('TIME')
+    local due = tonumber(now[1]) * 1000 + math.floor(tonumber(now[2]) / 1000)
+    local ready = redis.call('ZRANGE', retries, '-inf', due, 'BYSCORE', 'LIMIT', 0, 100)
+    for _, payload in ipairs(ready) do
+      redis.call('XADD', stream, '*', 'payload', payload)
+      redis.call('ZREM', retries, payload)
+    end
+    local window = redis.call('XPENDING', stream, group, cursor, '+', 10)
+    local claimed = redis.call('XAUTOCLAIM', stream, group, owner, visibility, cursor, 'COUNT', 1)
+    for _, entry in ipairs(window) do
+      if entry[2] ~= owner and #redis.call('XPENDING', stream, group, '-', '+', 1, entry[2]) == 0 then
+        redis.call('XGROUP', 'DELCONSUMER', stream, group, entry[2])
+      end
+    end
+    if #redis.call('XPENDING', stream, group, '-', '+', 1, owner) == 0 then
+      redis.call('XGROUP', 'DELCONSUMER', stream, group, owner)
+    end
+    cursors[i] = claimed[1]
+    if #claimed[2] > 0 then
+      return {'1', tostring(i), claimed[2][1][1], payloadOf(claimed[2][1][2]), unpack(cursors)}
+    end
+    local fresh = redis.call('XREADGROUP', 'GROUP', group, owner, 'COUNT', 1, 'STREAMS', stream, '>')
+    if not fresh and #redis.call('XPENDING', stream, group, '-', '+', 1, owner) == 0 then
+      redis.call('XGROUP', 'DELCONSUMER', stream, group, owner)
+    end
+    if fresh and #fresh > 0 and #fresh[1][2] > 0 then
+      return {'1', tostring(i), fresh[1][2][1][1], payloadOf(fresh[1][2][1][2]), unpack(cursors)}
+    end
+  end
+end
+return {'0', unpack(cursors)}
+`;
+async function pollStreamPriorities(client, queueKeys, owner, cursors) {
+  const keys = [];
+  for (const key of queueKeys)
+    keys.push(streamQueueKey(key), streamRetryKey(key));
+  const raw = await client.send("EVAL", [
+    POLL_STREAM_PRIORITIES,
+    String(keys.length),
+    ...keys,
+    STREAM_GROUP,
+    owner,
+    String(readQueueVisibilityMs()),
+    ...cursors
+  ]);
+  if (!Array.isArray(raw))
+    throw new Error("Invalid Redis stream poll response");
+  const flag = String(raw[0]);
+  const cursorCount = queueKeys.length;
+  if (flag === "0") {
+    if (raw.length !== cursorCount + 1)
+      throw new Error("Invalid Redis stream poll response");
+    return { cursors: raw.slice(1).map(String), hit: null };
+  }
+  if (flag !== "1" || raw.length !== cursorCount + 4)
+    throw new Error("Invalid Redis stream poll response");
+  const index = Number(raw[1]);
+  if (!Number.isInteger(index) || index < 1 || index > queueKeys.length)
+    throw new Error("Invalid Redis stream poll response");
+  return {
+    cursors: raw.slice(4).map(String),
+    hit: {
+      index: index - 1,
+      reservation: { id: String(raw[2]), owner, payload: String(raw[3]) }
+    }
+  };
 }
 async function readStreamQueueDepth(client, key) {
   return Number(await client.send("EVAL", [
@@ -534,20 +604,6 @@ end
 if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[3]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[3]) end
 return acknowledged
 `;
-var CLAIM_STREAM = `
-local window = redis.call('XPENDING', KEYS[1], ARGV[1], ARGV[4], '+', 10)
-local claimed = redis.call('XAUTOCLAIM', KEYS[1], ARGV[1], ARGV[2], ARGV[3], ARGV[4], 'COUNT', 1)
-for _, entry in ipairs(window) do
-  if entry[2] ~= ARGV[2] and #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, entry[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], entry[2]) end
-end
-if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[2]) end
-return claimed
-`;
-var READ_STREAM = `
-local entries = redis.call('XREADGROUP', 'GROUP', ARGV[1], ARGV[2], 'COUNT', 1, 'STREAMS', KEYS[1], '>')
-if not entries and #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[2]) end
-return entries
-`;
 async function ensureStreamGroup(client, key) {
   await assertLegacyDrained(client, key);
   try {
@@ -557,17 +613,6 @@ async function ensureStreamGroup(client, key) {
       throw error;
   }
 }
-function readStreamEntry(value, owner) {
-  if (!Array.isArray(value) || typeof value[0] !== "string" || !Array.isArray(value[1]))
-    throw new Error("Invalid Redis stream entry response");
-  const fields = value[1];
-  let payload;
-  for (let index = 0;index < fields.length; index += 2) {
-    if (fields[index] === "payload" && typeof fields[index + 1] === "string")
-      payload = fields[index + 1];
-  }
-  return { id: value[0], owner, payload: payload ?? "" };
-}
 async function updateStreamReservation(client, key, reservation, action, controlKey) {
   return Number(await client.send("EVAL", [
     UPDATE_STREAM,
@@ -584,35 +629,6 @@ async function updateStreamReservation(client, key, reservation, action, control
     controlKey ? "1" : "0"
   ])) === 1;
 }
-async function reserveStreamJob(client, key, owner, cursor = "0-0") {
-  const claimed = await client.send("EVAL", [
-    CLAIM_STREAM,
-    "1",
-    streamQueueKey(key),
-    STREAM_GROUP,
-    owner,
-    String(readQueueVisibilityMs()),
-    cursor
-  ]);
-  if (!Array.isArray(claimed) || typeof claimed[0] !== "string" || !Array.isArray(claimed[1]))
-    throw new Error("Invalid Redis XAUTOCLAIM response");
-  const nextCursor = claimed[0];
-  if (claimed[1].length > 0)
-    return { reservation: readStreamEntry(claimed[1][0], owner), cursor: nextCursor };
-  const fresh = await client.send("EVAL", [
-    READ_STREAM,
-    "1",
-    streamQueueKey(key),
-    STREAM_GROUP,
-    owner
-  ]);
-  if (fresh === null)
-    return { reservation: null, cursor: nextCursor };
-  if (!Array.isArray(fresh) || !Array.isArray(fresh[0]) || !Array.isArray(fresh[0][1]))
-    throw new Error("Invalid Redis XREADGROUP response");
-  return { reservation: readStreamEntry(fresh[0][1][0], owner), cursor: nextCursor };
-}
-
 class RedisStreamsQueue {
   client;
   constructor(redisUrl) {
@@ -710,12 +726,6 @@ class RedisStreamsWorker {
       await ensureStreamGroup(this.client, key);
     this.initialized = true;
   }
-  async reserve(key) {
-    await promoteStreamRetries(this.client, key);
-    const result = await reserveStreamJob(this.client, key, this.owner, this.cursors.get(key));
-    this.cursors.set(key, result.cursor);
-    return result.reservation;
-  }
   async processNext() {
     if (this.processing)
       throw new Error("Queue worker already processing a job.");
@@ -732,13 +742,19 @@ class RedisStreamsWorker {
     await this.initialize();
     const deadline = performance.now() + this.timeoutSeconds * 1000;
     do {
-      for (const key of this.queueKeys) {
-        if (this.stopping)
-          return false;
-        const reservation = await this.reserve(key);
-        if (!reservation)
-          continue;
-        await this.handle(key, reservation);
+      if (this.stopping)
+        return false;
+      const polled = await pollStreamPriorities(this.client, this.queueKeys, this.owner, this.queueKeys.map((key) => this.cursors.get(key) ?? "0-0"));
+      this.queueKeys.forEach((key, index) => {
+        const cursor = polled.cursors[index];
+        if (cursor)
+          this.cursors.set(key, cursor);
+      });
+      if (polled.hit) {
+        const key = this.queueKeys[polled.hit.index];
+        if (!key)
+          throw new Error("Invalid Redis stream poll response");
+        await this.handle(key, polled.hit.reservation);
         return true;
       }
       if (performance.now() >= deadline || this.stopping)
@@ -1011,6 +1027,66 @@ for _, record in ipairs(redis.call('LRANGE', KEYS[2], 0, -1)) do
 end
 return reclaimed
 `;
+var POLL_LIST_PRIORITIES = `${SCRIPT_HEADER}
+local owner = ARGV[1]
+local visibility = ARGV[2]
+local reservationId = ARGV[3]
+local reclaim = ARGV[4] == '1'
+local function reclaimQueue(listKey, processingKey, leaseKey)
+  local err = checkType(listKey, 'list') or checkType(processingKey, 'list') or checkType(leaseKey, 'hash')
+  if err then return err end
+  local now = nowMs()
+  for _, record in ipairs(redis.call('LRANGE', processingKey, 0, -1)) do
+    local payload, field = record, record
+    local modern = false
+    local ok, reservation = pcall(cjson.decode, record)
+    if ok and type(reservation) == 'table' and reservation.strataReservation == 1 then
+      payload, field, modern = reservation.payload, reservation.id, true
+    end
+    local raw = redis.call('HGET', leaseKey, field)
+    local expired = true
+    if raw then
+      if modern then
+        local leaseOk, lease = pcall(cjson.decode, raw)
+        expired = not leaseOk or type(lease) ~= 'table' or not tonumber(lease.expiresAt) or tonumber(lease.expiresAt) <= now
+      else
+        local reservedAt = tonumber(raw)
+        expired = not reservedAt or now - reservedAt >= tonumber(visibility)
+      end
+    end
+    if expired then
+      redis.call('LPUSH', listKey, payload)
+      redis.call('LREM', processingKey, 1, record)
+      redis.call('HDEL', leaseKey, field)
+    end
+  end
+end
+local function reserveQueue(listKey, processingKey, leaseKey)
+  local err = checkType(listKey, 'list') or checkType(processingKey, 'list') or checkType(leaseKey, 'hash')
+  if err then return err end
+  local payload = redis.call('LINDEX', listKey, -1)
+  if not payload then return nil end
+  local record = cjson.encode({strataReservation=1, id=reservationId, owner=owner, payload=payload})
+  local lease = cjson.encode({owner=owner, expiresAt=nowMs()+tonumber(visibility)})
+  redis.call('LPUSH', processingKey, record)
+  redis.call('HSET', leaseKey, reservationId, lease)
+  redis.call('RPOP', listKey)
+  return record
+end
+local count = #KEYS / 3
+if reclaim then
+  for i = 1, count do
+    local err = reclaimQueue(KEYS[(i - 1) * 3 + 1], KEYS[(i - 1) * 3 + 2], KEYS[(i - 1) * 3 + 3])
+    if err then return err end
+  end
+end
+for i = 1, count do
+  local record = reserveQueue(KEYS[(i - 1) * 3 + 1], KEYS[(i - 1) * 3 + 2], KEYS[(i - 1) * 3 + 3])
+  if type(record) == 'string' then return {'1', tostring(i), record} end
+  if record then return record end
+end
+return {'0'}
+`;
 function queueInvalidKey(queueKey) {
   return `${queueKey}:invalid`;
 }
@@ -1045,6 +1121,41 @@ async function updateQueueReservation(client, queueKey, reservation, action) {
     reservation.payload
   ])) === 1;
 }
+async function pollListPriorities(client, queueKeys, owner, reservationId, reclaim) {
+  const keys = [];
+  for (const key of queueKeys) {
+    keys.push(key, queueProcessingKey(key), queueProcessingLeaseKey(key));
+  }
+  const raw = await client.send("EVAL", [
+    POLL_LIST_PRIORITIES,
+    String(keys.length),
+    ...keys,
+    owner,
+    String(readQueueVisibilityMs()),
+    reservationId,
+    reclaim ? "1" : "0"
+  ]);
+  if (!Array.isArray(raw))
+    throw new Error("Invalid Redis list poll response");
+  const flag = String(raw[0]);
+  if (flag === "0") {
+    if (raw.length !== 1)
+      throw new Error("Invalid Redis list poll response");
+    return null;
+  }
+  if (flag !== "1" || raw.length !== 3)
+    throw new Error("Invalid Redis list poll response");
+  const index = Number(raw[1]);
+  const record = raw[2];
+  if (!Number.isInteger(index) || index < 1 || index > queueKeys.length || typeof record !== "string") {
+    throw new Error("Invalid Redis list poll response");
+  }
+  const queueKey = queueKeys[index - 1];
+  if (!queueKey)
+    throw new Error("Invalid Redis list poll response");
+  const reservation = JSON.parse(record);
+  return { queueKey, reservation: { ...reservation, record } };
+}
 async function reclaimExpiredQueueReservations(client, queueKeys = QUEUE_KEYS) {
   let reclaimed = 0;
   for (const key of queueKeys) {
@@ -1105,14 +1216,14 @@ class QueueWorker {
   }
   async reserve() {
     const deadline = performance.now() + this.timeoutSeconds * 1000;
+    let reclaim = true;
     do {
-      for (const key of this.queueKeys) {
-        if (this.stopping)
-          return null;
-        const reservation = await reserveQueueJob(this.client, key, this.owner);
-        if (reservation)
-          return { queueKey: key, reservation };
-      }
+      if (this.stopping)
+        return null;
+      const reserved = await pollListPriorities(this.client, this.queueKeys, this.owner, crypto.randomUUID(), reclaim);
+      reclaim = false;
+      if (reserved)
+        return reserved;
       if (this.stopping || performance.now() >= deadline)
         return null;
       await Bun.sleep(Math.min(100, Math.max(1, deadline - performance.now())));
@@ -1122,7 +1233,6 @@ class QueueWorker {
   async processNext() {
     if (this.stopping)
       return false;
-    await reclaimExpiredQueueReservations(this.client, this.queueKeys);
     const reserved = await this.reserve();
     if (!reserved)
       return false;