power-queues 2.0.4 → 2.0.6

package/dist/index.js

@@ -1,7 +1,6 @@
 // src/PowerQueues.ts
+import { PowerRedis } from "power-redis";
 import { wait } from "full-utils";
-
-// src/AddTasks.ts
 import { v4 as uuid } from "uuid";
 
 // src/scripts.ts
@@ -230,593 +229,620 @@ var SelectStuck = `
 	return results
 `;
 
-// src/mix.ts
-function mix(Base2, ...mixins) {
-  return mixins.reduce((acc, mixin) => mixin(acc), Base2);
-}
-
-// src/Script.ts
-function Script(Base2) {
-  return class extends Base2 {
-    constructor() {
-      super(...arguments);
-      this.strictCheckingConnection = ["true", "on", "yes", "y", "1"].includes(String(process.env.REDIS_STRICT_CHECK_CONNECTION ?? "").trim().toLowerCase());
-      this.scripts = {};
-    }
-    async runScript(name, keys, args, defaultCode) {
-      if (!this.scripts[name]) {
-        if (typeof defaultCode !== "string" || !(defaultCode.length > 0)) {
-          throw new Error(`Undefined script "${name}". Save it before executing.`);
-        }
-        this.saveScript(name, defaultCode);
-      }
-      if (!this.scripts[name].codeReady) {
-        this.scripts[name].codeReady = await this.loadScript(this.scripts[name].codeBody);
-      }
+// src/PowerQueues.ts
+var PowerQueues = class extends PowerRedis {
+  constructor() {
+    super(...arguments);
+    this.abort = new AbortController();
+    this.strictCheckingConnection = ["true", "on", "yes", "y", "1"].includes(String(process.env.REDIS_STRICT_CHECK_CONNECTION ?? "").trim().toLowerCase());
+    this.scripts = {};
+    this.addingBatchTasksCount = 800;
+    this.addingBatchKeysLimit = 1e4;
+    this.workerExecuteLockTimeoutMs = 18e4;
+    this.workerCacheTaskTimeoutMs = 60;
+    this.approveBatchTasksCount = 2e3;
+    this.removeOnExecuted = false;
+    this.executeBatchAtOnce = false;
+    this.executeJobStatus = false;
+    this.executeJobStatusTtlSec = 300;
+    this.consumerHost = "host";
+    this.stream = "stream";
+    this.group = "group";
+    this.workerBatchTasksCount = 200;
+    this.recoveryStuckTasksTimeoutMs = 6e4;
+    this.workerLoopIntervalMs = 5e3;
+    this.workerSelectionTimeoutMs = 80;
+    this.workerMaxRetries = 5;
+    this.workerClearAttemptsTimeoutMs = 864e5;
+    this.workerStatusTimeoutMs = 864e5;
+  }
+  async onSelected(data) {
+    return data;
+  }
+  async onExecute(id, payload, createdAt, job, key, attempt) {
+  }
+  async onExecuted(data) {
+  }
+  async onSuccess(id, payload, createdAt, job, key) {
+  }
+  async runQueue() {
+    await this.createGroup("0-0");
+    await this.consumerLoop();
+  }
+  async consumerLoop() {
+    const signal = this.signal();
+    while (!signal?.aborted) {
       try {
-        return await this.redis.evalsha(this.scripts[name].codeReady, keys.length, ...keys, ...args);
-      } catch (err) {
-        if (String(err?.message || "").includes("NOSCRIPT")) {
-          this.scripts[name].codeReady = await this.loadScript(this.scripts[name].codeBody);
-          return await this.redis.evalsha(this.scripts[name].codeReady, keys.length, ...keys, ...args);
+        const tasks = await this.select();
+        if (!Array.isArray(tasks) || !(tasks.length > 0)) {
+          await wait(600);
+          continue;
         }
-        throw err;
-      }
-    }
-    async loadScripts(full = false) {
-      const scripts = full ? [
-        ["XAddBulk", XAddBulk],
-        ["Approve", Approve],
-        ["IdempotencyAllow", IdempotencyAllow],
-        ["IdempotencyStart", IdempotencyStart],
-        ["IdempotencyDone", IdempotencyDone],
-        ["IdempotencyFree", IdempotencyFree],
-        ["SelectStuck", SelectStuck]
-      ] : [
-        ["XAddBulk", XAddBulk]
-      ];
-      for (const [name, code] of scripts) {
-        await this.loadScript(this.saveScript(name, code));
-      }
-    }
-    async loadScript(code) {
-      for (let i = 0; i < 3; i++) {
-        try {
-          return await this.redis.script("LOAD", code);
-        } catch (e) {
-          if (i === 2) {
-            throw e;
-          }
-          await new Promise((r) => setTimeout(r, 10 + Math.floor(Math.random() * 40)));
+        const tasksP = await this.onSelected(tasks);
+        const ids = await this.execute(Array.isArray(tasksP) && tasksP.length > 0 ? tasksP : tasks);
+        if (Array.isArray(ids) && ids.length > 0) {
+          await this.approve(ids);
         }
+      } catch (err) {
+        await this.batchError(err);
+        await wait(600);
       }
-      throw new Error("Load lua script failed.");
-    }
-    saveScript(name, codeBody) {
-      if (typeof codeBody !== "string" || !(codeBody.length > 0)) {
-        throw new Error("Script body is empty.");
-      }
-      this.scripts[name] = { codeBody };
-      return codeBody;
     }
-  };
-}
-
-// src/AddTasks.ts
-function AddTasks(Base2) {
-  return class extends mix(Base2, Script) {
-    constructor() {
-      super(...arguments);
-      this.addingBatchTasksCount = 800;
-      this.addingBatchKeysLimit = 1e4;
-      this.idemOn = true;
-      this.idemKey = "";
-    }
-    async addTasks(queueName, data, opts) {
-      if (!Array.isArray(data) || !(data.length > 0)) {
-        throw new Error("Tasks is not filled.");
-      }
-      if (typeof queueName !== "string" || !(queueName.length > 0)) {
-        throw new Error("Queue name is required.");
-      }
-      const batches = this.buildBatches(data);
-      const result = new Array(data.length);
-      const promises = [];
-      let cursor = 0;
-      for (const batch of batches) {
-        const start = cursor;
-        const end = start + batch.length;
-        cursor = end;
-        promises.push(async () => {
-          const partIds = await this.xaddBatch(queueName, ...this.payloadBatch(batch, opts));
-          for (let k = 0; k < partIds.length; k++) {
-            result[start + k] = partIds[k];
-          }
-        });
-      }
-      const runners = Array.from({ length: promises.length }, async () => {
-        while (promises.length) {
-          const promise = promises.shift();
-          if (promise) {
-            await promise();
-          }
+  }
+  async addTasks(queueName, data, opts = {}) {
+    if (!Array.isArray(data) || !(data.length > 0)) {
+      throw new Error("Tasks is not filled.");
+    }
+    if (typeof queueName !== "string" || !(queueName.length > 0)) {
+      throw new Error("Queue name is required.");
+    }
+    const job = uuid();
+    const batches = this.buildBatches(data, job, opts.idem);
+    const result = new Array(data.length);
+    const promises = [];
+    let cursor = 0;
+    for (const batch of batches) {
+      const start = cursor;
+      const end = start + batch.length;
+      cursor = end;
+      promises.push(async () => {
+        const partIds = await this.xaddBatch(queueName, ...this.payloadBatch(batch, opts));
+        for (let k = 0; k < partIds.length; k++) {
+          result[start + k] = partIds[k];
         }
       });
-      await Promise.all(runners);
-      return result;
-    }
-    async xaddBatch(queueName, ...batches) {
-      return await this.runScript("XAddBulk", [queueName], batches, XAddBulk);
-    }
-    payloadBatch(data, opts) {
-      const maxlen = Math.max(0, Math.floor(opts?.maxlen ?? 0));
-      const approx = opts?.exact ? 0 : opts?.approx !== false ? 1 : 0;
-      const exact = opts?.exact ? 1 : 0;
-      const nomkstream = opts?.nomkstream ? 1 : 0;
-      const trimLimit = Math.max(0, Math.floor(opts?.trimLimit ?? 0));
-      const minidWindowMs = Math.max(0, Math.floor(opts?.minidWindowMs ?? 0));
-      const minidExact = opts?.minidExact ? 1 : 0;
-      const argv = [
-        String(maxlen),
-        String(approx),
-        String(data.length),
-        String(exact),
-        String(nomkstream),
-        String(trimLimit),
-        String(minidWindowMs),
-        String(minidExact)
-      ];
-      for (const item of data) {
-        const entry = item;
-        const id = entry.id ?? "*";
-        let flat;
-        if ("flat" in entry && Array.isArray(entry.flat) && entry.flat.length > 0) {
-          flat = entry.flat;
-          if (flat.length % 2 !== 0) {
-            throw new Error('Property "flat" must contain an even number of realKeysLength (field/value pairs).');
-          }
-        } else if ("payload" in entry && typeof entry.payload === "object" && Object.keys(entry.payload || {}).length > 0) {
-          flat = [];
-          for (const [k, v] of Object.entries(entry.payload)) {
-            flat.push(k, v);
-          }
-        } else {
-          throw new Error('Task must have "payload" or "flat".');
-        }
-        const pairs = flat.length / 2;
-        if (pairs <= 0) {
-          throw new Error('Task must have "payload" or "flat".');
-        }
-        argv.push(String(id));
-        argv.push(String(pairs));
-        for (const token of flat) {
-          argv.push(!token ? "" : typeof token === "string" && token.length > 0 ? token : String(token));
+    }
+    const runners = Array.from({ length: promises.length }, async () => {
+      while (promises.length) {
+        const promise = promises.shift();
+        if (promise) {
+          await promise();
         }
       }
-      return argv;
-    }
-    buildBatches(tasks) {
-      const job = uuid();
-      const batches = [];
-      let batch = [], realKeysLength = 0;
-      for (let task of tasks) {
-        let entry = task;
-        if (this.idemOn) {
-          const createdAt = entry?.createdAt || Date.now();
-          let idemKey = entry?.idemKey || uuid();
-          if (typeof entry.payload === "object") {
-            if (this.idemKey && typeof entry.payload[this.idemKey] === "string" && entry.payload[this.idemKey].length > 0) {
-              idemKey = entry.payload[this.idemKey];
-            }
-            entry = {
-              ...entry,
-              payload: {
-                payload: JSON.stringify(entry.payload),
-                createdAt,
-                job,
-                idemKey
-              }
-            };
-          } else if (Array.isArray(entry.flat)) {
-            entry.flat.push("createdAt");
-            entry.flat.push(String(createdAt));
-            entry.flat.push("job");
-            entry.flat.push(job);
-            entry.flat.push("idemKey");
-            entry.flat.push(idemKey);
-          }
-        }
-        const reqKeysLength = this.keysLength(entry);
-        if (batch.length && (batch.length >= this.addingBatchTasksCount || realKeysLength + reqKeysLength > this.addingBatchKeysLimit)) {
-          batches.push(batch);
-          batch = [];
-          realKeysLength = 0;
+    });
+    if (opts.status) {
+      await this.redis.set(`${queueName}:${job}:total`, data.length);
+      await this.redis.set(`${queueName}:${job}:ready`, 0);
+      await this.redis.set(`${queueName}:${job}:err`, 0);
+      await this.redis.set(`${queueName}:${job}:ok`, 0);
+      await this.redis.pexpire(`${queueName}:${job}:total`, this.workerStatusTimeoutMs);
+      await this.redis.pexpire(`${queueName}:${job}:ready`, this.workerStatusTimeoutMs);
+      await this.redis.pexpire(`${queueName}:${job}:err`, this.workerStatusTimeoutMs);
+      await this.redis.pexpire(`${queueName}:${job}:ok`, this.workerStatusTimeoutMs);
+    }
+    await Promise.all(runners);
+    return result;
+  }
+  async loadScripts(full = false) {
+    const scripts = full ? [
+      ["XAddBulk", XAddBulk],
+      ["Approve", Approve],
+      ["IdempotencyAllow", IdempotencyAllow],
+      ["IdempotencyStart", IdempotencyStart],
+      ["IdempotencyDone", IdempotencyDone],
+      ["IdempotencyFree", IdempotencyFree],
+      ["SelectStuck", SelectStuck]
+    ] : [
+      ["XAddBulk", XAddBulk]
+    ];
+    for (const [name, code] of scripts) {
+      await this.loadScript(this.saveScript(name, code));
+    }
+  }
+  async loadScript(code) {
+    for (let i = 0; i < 3; i++) {
+      try {
+        return await this.redis.script("LOAD", code);
+      } catch (e) {
+        if (i === 2) {
+          throw e;
         }
-        batch.push(entry);
-        realKeysLength += reqKeysLength;
+        await new Promise((r) => setTimeout(r, 10 + Math.floor(Math.random() * 40)));
       }
-      if (batch.length) {
-        batches.push(batch);
-      }
-      return batches;
     }
-    keysLength(task) {
-      return 2 + ("flat" in task && Array.isArray(task.flat) && task.flat.length ? task.flat.length : Object.keys(task).length * 2);
+    throw new Error("Load lua script failed.");
+  }
+  saveScript(name, codeBody) {
+    if (typeof codeBody !== "string" || !(codeBody.length > 0)) {
+      throw new Error("Script body is empty.");
     }
-  };
-}
-
-// src/SelectTasks.ts
-function SelectTasks(Base2) {
-  return class extends mix(Base2, Script) {
-    constructor() {
-      super(...arguments);
-      this.consumerHost = "host";
-      this.stream = "stream";
-      this.group = "group";
-      this.workerBatchTasksCount = 200;
-      this.recoveryStuckTasksTimeoutMs = 6e4;
-      this.workerLoopIntervalMs = 5e3;
-      this.workerSelectionTimeoutMs = 80;
-    }
-    async createGroup(from = "$") {
-      try {
-        await this.redis.xgroup("CREATE", this.stream, this.group, from, "MKSTREAM");
-      } catch (err) {
-        const msg = String(err?.message || "");
-        if (!msg.includes("BUSYGROUP")) {
-          throw err;
-        }
+    this.scripts[name] = { codeBody };
+    return codeBody;
+  }
+  async runScript(name, keys, args, defaultCode) {
+    if (!this.scripts[name]) {
+      if (typeof defaultCode !== "string" || !(defaultCode.length > 0)) {
+        throw new Error(`Undefined script "${name}". Save it before executing.`);
       }
+      this.saveScript(name, defaultCode);
     }
-    async select() {
-      let entries = await this.selectStuck();
-      if (!entries?.length) {
-        entries = await this.selectFresh();
+    if (!this.scripts[name].codeReady) {
+      this.scripts[name].codeReady = await this.loadScript(this.scripts[name].codeBody);
+    }
+    try {
+      return await this.redis.evalsha(this.scripts[name].codeReady, keys.length, ...keys, ...args);
+    } catch (err) {
+      if (String(err?.message || "").includes("NOSCRIPT")) {
+        this.scripts[name].codeReady = await this.loadScript(this.scripts[name].codeBody);
+        return await this.redis.evalsha(this.scripts[name].codeReady, keys.length, ...keys, ...args);
       }
-      return this.normalizeEntries(entries);
+      throw err;
     }
-    async selectStuck() {
-      try {
-        const res = await this.runScript("SelectStuck", [this.stream], [this.group, this.consumer(), String(this.recoveryStuckTasksTimeoutMs), String(this.workerBatchTasksCount), String(this.workerSelectionTimeoutMs)], SelectStuck);
-        return Array.isArray(res) ? res : [];
-      } catch (err) {
-        if (String(err?.message || "").includes("NOGROUP")) {
-          await this.createGroup();
+  }
+  async xaddBatch(queueName, ...batches) {
+    return await this.runScript("XAddBulk", [queueName], batches, XAddBulk);
+  }
+  payloadBatch(data, opts) {
+    const maxlen = Math.max(0, Math.floor(opts?.maxlen ?? 0));
+    const approx = opts?.exact ? 0 : opts?.approx !== false ? 1 : 0;
+    const exact = opts?.exact ? 1 : 0;
+    const nomkstream = opts?.nomkstream ? 1 : 0;
+    const trimLimit = Math.max(0, Math.floor(opts?.trimLimit ?? 0));
+    const minidWindowMs = Math.max(0, Math.floor(opts?.minidWindowMs ?? 0));
+    const minidExact = opts?.minidExact ? 1 : 0;
+    const argv = [
+      String(maxlen),
+      String(approx),
+      String(data.length),
+      String(exact),
+      String(nomkstream),
+      String(trimLimit),
+      String(minidWindowMs),
+      String(minidExact)
+    ];
+    for (const item of data) {
+      const entry = item;
+      const id = entry.id ?? "*";
+      let flat;
+      if ("flat" in entry && Array.isArray(entry.flat) && entry.flat.length > 0) {
+        flat = entry.flat;
+        if (flat.length % 2 !== 0) {
+          throw new Error('Property "flat" must contain an even number of realKeysLength (field/value pairs).');
+        }
+      } else if ("payload" in entry && typeof entry.payload === "object" && Object.keys(entry.payload || {}).length > 0) {
+        flat = [];
+        for (const [k, v] of Object.entries(entry.payload)) {
+          flat.push(k, v);
         }
+      } else {
+        throw new Error('Task must have "payload" or "flat".');
+      }
+      const pairs = flat.length / 2;
+      if (pairs <= 0) {
+        throw new Error('Task must have "payload" or "flat".');
+      }
+      argv.push(String(id));
+      argv.push(String(pairs));
+      for (const token of flat) {
+        argv.push(!token ? "" : typeof token === "string" && token.length > 0 ? token : String(token));
       }
-      return [];
     }
-    async selectFresh() {
-      let entries = [];
-      try {
-        const res = await this.redis.xreadgroup(
-          "GROUP",
-          this.group,
-          this.consumer(),
-          "BLOCK",
-          Math.max(2, this.workerLoopIntervalMs | 0),
-          "COUNT",
-          this.workerBatchTasksCount,
-          "STREAMS",
-          this.stream,
-          ">"
-        );
-        if (!res?.[0]?.[1]?.length) {
-          return [];
-        }
-        entries = res?.[0]?.[1] ?? [];
-        if (!entries?.length) {
-          return [];
+    return argv;
+  }
+  buildBatches(tasks, job, idem) {
+    const batches = [];
+    let batch = [], realKeysLength = 0;
+    for (let task of tasks) {
+      const createdAt = task?.createdAt || Date.now();
+      let entry = task;
+      if (typeof entry.payload === "object") {
+        entry = {
+          ...entry,
+          payload: {
+            payload: JSON.stringify(entry.payload),
+            createdAt,
+            job
+          }
+        };
+        if (idem) {
+          entry.payload["idemKey"] = entry?.idemKey || uuid();
         }
-      } catch (err) {
-        if (String(err?.message || "").includes("NOGROUP")) {
-          await this.createGroup();
+      } else if (Array.isArray(entry.flat)) {
+        entry.flat.push("createdAt");
+        entry.flat.push(String(createdAt));
+        entry.flat.push("job");
+        entry.flat.push(job);
+        if (idem) {
+          entry.flat.push("idemKey");
+          entry.flat.push(entry?.idemKey || uuid());
         }
       }
-      return entries;
-    }
-    normalizeEntries(raw) {
-      if (!Array.isArray(raw)) {
-        return [];
+      const reqKeysLength = this.keysLength(entry);
+      if (batch.length && (batch.length >= this.addingBatchTasksCount || realKeysLength + reqKeysLength > this.addingBatchKeysLimit)) {
+        batches.push(batch);
+        batch = [];
+        realKeysLength = 0;
       }
-      return Array.from(raw || []).map((e) => {
-        const id = Buffer.isBuffer(e?.[0]) ? e[0].toString() : e?.[0];
-        const kvRaw = e?.[1] ?? [];
-        const kv = Array.isArray(kvRaw) ? kvRaw.map((x) => Buffer.isBuffer(x) ? x.toString() : x) : [];
-        return [id, kv, 0, "", ""];
-      }).filter(([id, kv]) => typeof id === "string" && id.length > 0 && Array.isArray(kv) && (kv.length & 1) === 0).map(([id, kv]) => {
-        const values = this.values(kv);
-        const { idemKey = "", createdAt, job, ...data } = this.payload(values);
-        return [id, data, createdAt, job, idemKey];
-      });
+      batch.push(entry);
+      realKeysLength += reqKeysLength;
     }
-    consumer() {
-      return `${String(this.consumerHost || "host")}:${process.pid}`;
+    if (batch.length) {
+      batches.push(batch);
     }
-  };
-}
-
-// src/ExecuteTasks.ts
-function ExecuteTasks(Base2) {
-  return class extends mix(Base2, Script) {
-    constructor() {
-      super(...arguments);
-      this.abort = new AbortController();
-      this.workerExecuteLockTimeoutMs = 18e4;
-      this.workerCacheTaskTimeoutMs = 60;
-      this.approveBatchTasksCount = 2e3;
-      this.removeOnExecuted = false;
-      this.executeBatchAtOnce = false;
-      this.executeJobStatus = false;
-      this.executeJobStatusTtlSec = 300;
-      this.consumerHost = "host";
-      this.stream = "stream";
-      this.group = "group";
-    }
-    async onExecute(id, payload, createdAt, job, key) {
-    }
-    async onExecuted(data) {
-    }
-    async onSuccess(id, payload, createdAt, job, key) {
-    }
-    async success(id, payload, createdAt, job, key) {
-      if (this.executeJobStatus) {
-        await this.status(id, payload, createdAt, job, key);
-      }
-      await this.onSuccess(id, payload, createdAt, job, key);
-    }
-    async status(id, payload, createdAt, job, key) {
-      const prefix = `s:${this.stream}:`;
-      const { ready = 0, ok = 0 } = await this.getMany(prefix);
-      await this.redis.setMany([{ key: `${prefix}ready`, value: ready + 1 }, { key: `${prefix}ok`, value: ok + 1 }], this.executeJobStatusTtlSec);
-    }
-    async execute(tasks) {
-      const result = [];
-      let contended = 0, promises = [];
-      for (const [id, payload, createdAt, job, idemKey] of tasks) {
-        if (this.executeBatchAtOnce) {
-          promises.push((async () => {
-            const r = await this.executeProcess(id, payload, createdAt, job, idemKey);
-            if (r.id) {
-              result.push(id);
-            } else if (r.contended) {
-              contended++;
-            }
-          })());
-        } else {
+    return batches;
+  }
+  keysLength(task) {
+    return 2 + ("flat" in task && Array.isArray(task.flat) && task.flat.length ? task.flat.length : Object.keys(task).length * 2);
+  }
+  attemptsKey(id) {
+    const safeStream = this.stream.replace(/[^\w:\-]/g, "_");
+    const safeId = id.replace(/[^\w:\-]/g, "_");
+    return `q:${safeStream}:attempts:${safeId}`;
+  }
+  async incrAttempts(id) {
+    try {
+      const key = this.attemptsKey(id);
+      const attempts = await this.redis.incr(key);
+      await this.redis.pexpire(key, this.workerClearAttemptsTimeoutMs);
+      return attempts;
+    } catch (err) {
+    }
+    return 0;
+  }
+  async getAttempts(id) {
+    const key = this.attemptsKey(id);
+    const v = await this.redis.get(key);
+    return Number(v || 0);
+  }
+  async clearAttempts(id) {
+    const key = this.attemptsKey(id);
+    try {
+      await this.redis.del(key);
+    } catch (e) {
+    }
+  }
+  async success(id, payload, createdAt, job, key) {
+    if (this.executeJobStatus) {
+      await this.status(id, payload, createdAt, job, key);
+    }
+    await this.onSuccess(id, payload, createdAt, job, key);
+  }
+  async status(id, payload, createdAt, job, key) {
+    const prefix = `s:${this.stream}:`;
+    const { ready = 0, ok = 0 } = await this.getMany(prefix);
+    await this.setMany([{ key: `${prefix}ready`, value: ready + 1 }, { key: `${prefix}ok`, value: ok + 1 }], this.executeJobStatusTtlSec);
+  }
+  async batchError(err, tasks) {
+  }
+  async error(err, id, payload, createdAt, job, key) {
+    await this.onError(err, id, payload, createdAt, job, key);
+  }
+  async onError(err, id, payload, createdAt, job, key) {
+  }
+  async attempt(err, id, payload, createdAt, job, key, attempts) {
+    await this.onRetry(err, id, payload, createdAt, job, key, attempts);
+  }
+  async onRetry(err, id, payload, createdAt, job, key, attempts) {
+  }
+  async execute(tasks) {
+    const result = [];
+    let contended = 0, promises = [];
+    for (const [id, payload, createdAt, job, idemKey] of tasks) {
+      if (this.executeBatchAtOnce) {
+        promises.push((async () => {
           const r = await this.executeProcess(id, payload, createdAt, job, idemKey);
           if (r.id) {
             result.push(id);
           } else if (r.contended) {
             contended++;
           }
-        }
-      }
-      try {
-        if (this.executeBatchAtOnce && promises.length > 0) {
-          await Promise.all(promises);
-        }
-        await this.onExecuted(tasks);
-        if ((!Array.isArray(result) || !(result.length > 0)) && contended > tasks.length >> 1) {
-          await this.waitAbortable(15 + Math.floor(Math.random() * 35) + Math.min(250, 15 * contended + Math.floor(Math.random() * 40)));
-        }
-      } catch (err) {
-      }
-      return result;
-    }
-    async executeProcess(id, payload, createdAt, job, key) {
-      if (key) {
-        return await this.idempotency(id, payload, createdAt, job, key);
+        })());
       } else {
-        try {
-          await this.onExecute(id, payload, createdAt, job, key);
-          await this.success(id, payload, createdAt, job, key);
-          return { id };
-        } catch (err) {
+        const r = await this.executeProcess(id, payload, createdAt, job, idemKey);
+        if (r.id) {
+          result.push(id);
+        } else if (r.contended) {
+          contended++;
         }
       }
-      return {};
     }
-    async approve(ids) {
-      if (!Array.isArray(ids) || !(ids.length > 0)) {
-        return 0;
+    try {
+      if (this.executeBatchAtOnce && promises.length > 0) {
+        await Promise.all(promises);
       }
-      const approveBatchTasksCount = Math.max(500, Math.min(4e3, this.approveBatchTasksCount));
-      let total = 0, i = 0;
-      while (i < ids.length) {
-        const room = Math.min(approveBatchTasksCount, ids.length - i);
-        const part = ids.slice(i, i + room);
-        const approved = await this.runScript("Approve", [this.stream], [this.group, this.removeOnExecuted ? "1" : "0", ...part], Approve);
-        total += Number(approved || 0);
-        i += room;
+      await this.onExecuted(tasks);
+      if ((!Array.isArray(result) || !(result.length > 0)) && contended > tasks.length >> 1) {
+        await this.waitAbortable(15 + Math.floor(Math.random() * 35) + Math.min(250, 15 * contended + Math.floor(Math.random() * 40)));
       }
-      return total;
+    } catch (err) {
+      await this.batchError(err, tasks);
     }
-    async idempotency(id, payload, createdAt, job, key) {
-      const keys = this.idempotencyKeys(key);
-      const allow = await this.idempotencyAllow(keys);
-      if (allow === 1) {
-        return { id };
-      } else if (allow === 0) {
-        let ttl = -2;
-        try {
-          ttl = await this.redis.pttl(keys.startKey);
-        } catch (err) {
-        }
-        await this.waitAbortable(ttl);
-        return { contended: true };
-      }
-      if (!await this.idempotencyStart(keys)) {
-        return { contended: true };
-      }
-      const heartbeat = this.heartbeat(keys) || (() => {
-      });
+    return result;
+  }
+  async executeProcess(id, payload, createdAt, job, key) {
+    if (key) {
+      return await this.idempotency(id, payload, createdAt, job, key);
+    } else {
       try {
-        await this.onExecute(id, payload, createdAt, job, key);
-        await this.idempotencyDone(keys);
+        await this.onExecute(id, payload, createdAt, job, key, await this.getAttempts(id));
         await this.success(id, payload, createdAt, job, key);
         return { id };
       } catch (err) {
-        try {
-          await this.idempotencyFree(keys);
-        } catch (err2) {
+        const attempts = await this.incrAttempts(id);
+        await this.attempt(err, id, payload, createdAt, job, key, attempts);
+        await this.error(err, id, payload, createdAt, job, key);
+        if (attempts >= this.workerMaxRetries) {
+          await this.addTasks(`${this.stream}:dlq`, [{
+            payload: {
+              ...payload,
+              error: String(err?.message || err),
+              createdAt,
+              job,
+              id,
+              attempts
+            }
+          }]);
+          await this.clearAttempts(id);
+          return { id };
         }
-      } finally {
-        heartbeat();
       }
     }
-    idempotencyKeys(key) {
-      const prefix = `q:${this.stream.replace(/[^\w:\-]/g, "_")}:`;
-      const keyP = key.replace(/[^\w:\-]/g, "_");
-      const doneKey = `${prefix}done:${keyP}`;
-      const lockKey = `${prefix}lock:${keyP}`;
-      const startKey = `${prefix}start:${keyP}`;
-      const token = `${this.consumer()}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-      return {
-        prefix,
-        doneKey,
-        lockKey,
-        startKey,
-        token
-      };
-    }
-    async idempotencyAllow(keys) {
-      const res = await this.runScript("IdempotencyAllow", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.workerExecuteLockTimeoutMs), keys.token], IdempotencyAllow);
-      return Number(res || 0);
-    }
-    async idempotencyStart(keys) {
-      const res = await this.runScript("IdempotencyStart", [keys.lockKey, keys.startKey], [keys.token, String(this.workerExecuteLockTimeoutMs)], IdempotencyStart);
-      return Number(res || 0) === 1;
-    }
-    async idempotencyDone(keys) {
-      await this.runScript("IdempotencyDone", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.workerCacheTaskTimeoutMs), keys.token], IdempotencyDone);
-    }
-    async idempotencyFree(keys) {
-      await this.runScript("IdempotencyFree", [keys.lockKey, keys.startKey], [keys.token], IdempotencyFree);
-    }
-    async waitAbortable(ttl) {
-      return new Promise((resolve) => {
-        const signal = this.signal();
-        if (signal?.aborted) {
-          return resolve();
-        }
-        const t = setTimeout(() => {
-          if (signal) {
-            signal.removeEventListener("abort", onAbort);
-          }
-          resolve();
-        }, ttl > 0 ? 25 + Math.floor(Math.random() * 50) : 5 + Math.floor(Math.random() * 15));
-        t.unref?.();
-        function onAbort() {
-          clearTimeout(t);
-          resolve();
-        }
-        signal?.addEventListener("abort", onAbort, { once: true });
-      });
-    }
-    heartbeat(keys) {
-      if (this.workerExecuteLockTimeoutMs <= 0) {
-        return;
+    return {};
+  }
+  async approve(ids) {
+    if (!Array.isArray(ids) || !(ids.length > 0)) {
+      return 0;
+    }
+    const approveBatchTasksCount = Math.max(500, Math.min(4e3, this.approveBatchTasksCount));
+    let total = 0, i = 0;
+    while (i < ids.length) {
+      const room = Math.min(approveBatchTasksCount, ids.length - i);
+      const part = ids.slice(i, i + room);
+      const approved = await this.runScript("Approve", [this.stream], [this.group, this.removeOnExecuted ? "1" : "0", ...part], Approve);
+      total += Number(approved || 0);
+      i += room;
+    }
+    return total;
+  }
+  async idempotency(id, payload, createdAt, job, key) {
+    const keys = this.idempotencyKeys(key);
+    const allow = await this.idempotencyAllow(keys);
+    if (allow === 1) {
+      return { id };
+    } else if (allow === 0) {
+      let ttl = -2;
+      try {
+        ttl = await this.redis.pttl(keys.startKey);
+      } catch (err) {
       }
-      let timer, alive = true, hbFails = 0;
-      const workerHeartbeatTimeoutMs = Math.max(1e3, Math.floor(Math.max(5e3, this.workerExecuteLockTimeoutMs | 0) / 4));
-      const stop = () => {
-        alive = false;
-        if (timer) {
-          clearTimeout(timer);
-        }
-      };
-      const onAbort = () => stop();
-      const signal = this.signal();
-      signal?.addEventListener?.("abort", onAbort, { once: true });
-      const tick = async () => {
-        if (!alive) {
-          return;
-        }
-        try {
-          const r = await this.heartbeat(keys);
-          hbFails = r ? 0 : hbFails + 1;
-          if (hbFails >= 3) {
-            throw new Error("Heartbeat lost.");
-          }
-        } catch {
-          hbFails++;
-          if (hbFails >= 6) {
-            stop();
-            return;
-          }
+      await this.waitAbortable(ttl);
+      return { contended: true };
+    }
+    if (!await this.idempotencyStart(keys)) {
+      return { contended: true };
+    }
+    const heartbeat = this.heartbeat(keys) || (() => {
+    });
+    try {
+      await this.onExecute(id, payload, createdAt, job, key, await this.getAttempts(id));
+      await this.idempotencyDone(keys);
+      await this.success(id, payload, createdAt, job, key);
+      return { id };
+    } catch (err) {
+      const attempts = await this.incrAttempts(id);
+      try {
+        await this.attempt(err, id, payload, createdAt, job, key, attempts);
+        await this.error(err, id, payload, createdAt, job, key);
+        if (attempts >= this.workerMaxRetries) {
+          await this.addTasks(`${this.stream}:dlq`, [{
+            payload: {
+              ...payload,
+              error: String(err?.message || err),
+              createdAt,
+              job,
+              id
+            }
+          }]);
+          await this.clearAttempts(id);
+          await this.idempotencyFree(keys);
+          return { id };
         }
-        timer = setTimeout(tick, workerHeartbeatTimeoutMs).unref?.();
-      };
-      timer = setTimeout(tick, workerHeartbeatTimeoutMs).unref?.();
-      return () => {
-        signal?.removeEventListener?.("abort", onAbort);
-        stop();
-      };
-    }
-    values(value) {
-      const result = {};
-      for (let i = 0; i < value.length; i += 2) {
-        result[value[i]] = value[i + 1];
+        await this.idempotencyFree(keys);
+      } catch (err2) {
       }
-      return result;
+    } finally {
+      heartbeat();
     }
-    payload(data) {
-      try {
-        return JSON.parse(data.payload);
-      } catch (err) {
+  }
+  idempotencyKeys(key) {
+    const prefix = `q:${this.stream.replace(/[^\w:\-]/g, "_")}:`;
+    const keyP = key.replace(/[^\w:\-]/g, "_");
+    const doneKey = `${prefix}done:${keyP}`;
+    const lockKey = `${prefix}lock:${keyP}`;
+    const startKey = `${prefix}start:${keyP}`;
+    const token = `${this.consumer()}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+    return {
+      prefix,
+      doneKey,
+      lockKey,
+      startKey,
+      token
+    };
+  }
+  async idempotencyAllow(keys) {
+    const res = await this.runScript("IdempotencyAllow", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.workerExecuteLockTimeoutMs), keys.token], IdempotencyAllow);
+    return Number(res || 0);
+  }
+  async idempotencyStart(keys) {
+    const res = await this.runScript("IdempotencyStart", [keys.lockKey, keys.startKey], [keys.token, String(this.workerExecuteLockTimeoutMs)], IdempotencyStart);
+    return Number(res || 0) === 1;
+  }
+  async idempotencyDone(keys) {
+    await this.runScript("IdempotencyDone", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.workerCacheTaskTimeoutMs), keys.token], IdempotencyDone);
+  }
+  async idempotencyFree(keys) {
+    await this.runScript("IdempotencyFree", [keys.lockKey, keys.startKey], [keys.token], IdempotencyFree);
+  }
+  async createGroup(from = "$") {
+    try {
+      await this.redis.xgroup("CREATE", this.stream, this.group, from, "MKSTREAM");
+    } catch (err) {
+      const msg = String(err?.message || "");
+      if (!msg.includes("BUSYGROUP")) {
+        throw err;
       }
-      return data;
-    }
-    consumer() {
-      return `${String(this.consumerHost || "host")}:${process.pid}`;
-    }
-    signal() {
-      return this.abort.signal;
     }
-  };
-}
-
-// src/PowerQueues.ts
-var Base = class {
-};
-var PowerQueues = class extends mix(Base, AddTasks, SelectTasks, ExecuteTasks) {
-  constructor() {
-    super(...arguments);
-    this.abort = new AbortController();
-  }
-  async onSelected(data) {
-    return data;
   }
-  async onExecute(id, payload, createdAt, job, key) {
+  async select() {
+    let entries = await this.selectStuck();
+    if (!entries?.length) {
+      entries = await this.selectFresh();
+    }
+    return this.normalizeEntries(entries);
   }
-  async onExecuted(data) {
+  async selectStuck() {
+    try {
+      const res = await this.runScript("SelectStuck", [this.stream], [this.group, this.consumer(), String(this.recoveryStuckTasksTimeoutMs), String(this.workerBatchTasksCount), String(this.workerSelectionTimeoutMs)], SelectStuck);
+      return Array.isArray(res) ? res : [];
+    } catch (err) {
+      if (String(err?.message || "").includes("NOGROUP")) {
+        await this.createGroup();
+      }
+    }
+    return [];
   }
-  async onSuccess(id, payload, createdAt, job, key) {
+  async selectFresh() {
+    let entries = [];
+    try {
+      const res = await this.redis.xreadgroup(
+        "GROUP",
+        this.group,
+        this.consumer(),
+        "BLOCK",
+        Math.max(2, this.workerLoopIntervalMs | 0),
+        "COUNT",
+        this.workerBatchTasksCount,
+        "STREAMS",
+        this.stream,
+        ">"
+      );
+      if (!res?.[0]?.[1]?.length) {
+        return [];
+      }
+      entries = res?.[0]?.[1] ?? [];
+      if (!entries?.length) {
+        return [];
+      }
+    } catch (err) {
+      if (String(err?.message || "").includes("NOGROUP")) {
+        await this.createGroup();
+      }
+    }
+    return entries;
   }
-  async runQueue() {
-    await this.createGroup("0-0");
-    await this.consumerLoop();
+  async waitAbortable(ttl) {
+    return new Promise((resolve) => {
+      const signal = this.signal();
+      if (signal?.aborted) {
+        return resolve();
+      }
+      const t = setTimeout(() => {
+        if (signal) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ttl > 0 ? 25 + Math.floor(Math.random() * 50) : 5 + Math.floor(Math.random() * 15));
+      t.unref?.();
+      function onAbort() {
+        clearTimeout(t);
+        resolve();
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
   }
-  async consumerLoop() {
+  heartbeat(keys) {
+    if (this.workerExecuteLockTimeoutMs <= 0) {
+      return;
+    }
+    let timer, alive = true, hbFails = 0;
+    const workerHeartbeatTimeoutMs = Math.max(1e3, Math.floor(Math.max(5e3, this.workerExecuteLockTimeoutMs | 0) / 4));
+    const stop = () => {
+      alive = false;
+      if (timer) {
+        clearTimeout(timer);
+      }
+    };
+    const onAbort = () => stop();
     const signal = this.signal();
-    while (!signal?.aborted) {
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+    const tick = async () => {
+      if (!alive) {
+        return;
+      }
       try {
-        const tasks = await this.select();
-        if (!Array.isArray(tasks) || !(tasks.length > 0)) {
-          await wait(600);
-          continue;
+        const r = await this.heartbeat(keys);
+        hbFails = r ? 0 : hbFails + 1;
+        if (hbFails >= 3) {
+          throw new Error("Heartbeat lost.");
         }
-        const tasksP = await this.onSelected(tasks);
-        const ids = await this.execute(Array.isArray(tasksP) && tasksP.length > 0 ? tasksP : tasks);
-        if (Array.isArray(ids) && ids.length > 0) {
-          await this.approve(ids);
+      } catch {
+        hbFails++;
+        if (hbFails >= 6) {
+          stop();
+          return;
         }
-      } catch (err) {
-        await wait(600);
       }
+      timer = setTimeout(tick, workerHeartbeatTimeoutMs).unref?.();
+    };
+    timer = setTimeout(tick, workerHeartbeatTimeoutMs).unref?.();
+    return () => {
+      signal?.removeEventListener?.("abort", onAbort);
+      stop();
+    };
+  }
+  normalizeEntries(raw) {
+    if (!Array.isArray(raw)) {
+      return [];
     }
+    return Array.from(raw || []).map((e) => {
+      const id = Buffer.isBuffer(e?.[0]) ? e[0].toString() : e?.[0];
+      const kvRaw = e?.[1] ?? [];
+      const kv = Array.isArray(kvRaw) ? kvRaw.map((x) => Buffer.isBuffer(x) ? x.toString() : x) : [];
+      return [id, kv];
+    }).filter(([id, kv]) => typeof id === "string" && id.length > 0 && Array.isArray(kv) && (kv.length & 1) === 0).map(([id, kv]) => {
+      const { idemKey = "", job, createdAt, payload } = this.values(kv);
+      return [id, this.payload(payload), createdAt, job, idemKey];
+    });
+  }
+  values(value) {
+    const result = {};
+    for (let i = 0; i < value.length; i += 2) {
+      result[value[i]] = value[i + 1];
+    }
+    return result;
+  }
+  payload(data) {
+    try {
+      return JSON.parse(data?.payload);
+    } catch (err) {
+    }
+    return data;
+  }
+  signal() {
+    return this.abort.signal;
+  }
+  consumer() {
+    return `${String(this.consumerHost || "host")}:${process.pid}`;
   }
 };
 export {