power-queues 2.0.22 → 2.1.1

package/dist/index.js

@@ -6,8 +6,8 @@ import {
   isArrFilled,
   isArr,
   isStrFilled,
+  isExists,
   isNumNZ,
-  jsonDecode,
   wait
 } from "full-utils";
 import { v4 as uuid } from "uuid";
@@ -252,315 +252,191 @@ var PowerQueues = class extends PowerRedis {
     super(...arguments);
     this.abort = new AbortController();
     this.scripts = {};
-    this.addingBatchTasksCount = 800;
-    this.addingBatchKeysLimit = 1e4;
-    this.workerExecuteLockTimeoutMs = 18e4;
-    this.workerCacheTaskTimeoutMs = 6e4;
-    this.approveBatchTasksCount = 2e3;
+    this.host = "host";
+    this.group = "gr1";
+    this.selectStuckCount = 200;
+    this.selectStuckTimeout = 6e4;
+    this.selectStuckMaxTimeout = 80;
+    this.selectCount = 200;
+    this.selectTimeout = 5e3;
+    this.buildBatchCount = 800;
+    this.buildBatchMaxCount = 1e4;
+    this.retryCount = 1;
+    this.executeSync = false;
+    this.idemLockTimeout = 18e4;
+    this.idemDoneTimeout = 6e4;
+    this.logStatus = false;
+    this.logStatusTimeout = 3e5;
+    this.approveCount = 2e3;
     this.removeOnExecuted = false;
-    this.executeBatchAtOnce = false;
-    this.executeJobStatus = false;
-    this.executeJobStatusTtlMs = 3e5;
-    this.consumerHost = "host";
-    this.stream = "stream";
-    this.group = "group";
-    this.workerBatchTasksCount = 200;
-    this.recoveryStuckTasksTimeoutMs = 6e4;
-    this.workerLoopIntervalMs = 5e3;
-    this.workerSelectionTimeoutMs = 80;
-    this.workerMaxRetries = 1;
-    this.workerClearAttemptsTimeoutMs = 864e5;
-  }
-  async onSelected(data) {
-    return data;
-  }
-  async onExecute(id, payload, createdAt, job, key, attempt) {
-  }
-  async onReady(data) {
-  }
-  async onSuccess(id, payload, createdAt, job, key) {
   }
-  async onBatchError(err, tasks) {
+  signal() {
+    return this.abort.signal;
   }
-  async onError(err, id, payload, createdAt, job, key) {
+  consumer() {
+    return this.host + ":" + process.pid;
   }
-  async onRetry(err, id, payload, createdAt, job, key, attempts) {
+  async runQueue(queueName, from = "0-0") {
+    await this.createGroup(queueName, from);
+    await this.consumerLoop(queueName, from);
   }
-  async runQueue() {
-    await this.createGroup("0-0");
-    await this.consumerLoop();
+  async createGroup(queueName, from = "0-0") {
+    try {
+      await this.redis.xgroup("CREATE", queueName, this.group, from, "MKSTREAM");
+    } catch (err) {
+      const msg = String(err?.message || "");
+      if (!msg.includes("BUSYGROUP")) {
+        throw err;
+      }
+    }
   }
-  async consumerLoop() {
+  async consumerLoop(queueName, from = "0-0") {
     const signal = this.signal();
     while (!signal?.aborted) {
+      let tasks = [];
       try {
-        const tasks = await this.select();
-        if (!isArrFilled(tasks)) {
-          await wait(600);
-          continue;
-        }
-        const tasksP = await this.onSelected(tasks);
-        const ids = await this.execute(isArrFilled(tasksP) ? tasksP : tasks);
-        if (isArrFilled(ids)) {
-          await this.approve(ids);
-        }
+        tasks = await this.select(queueName, from);
       } catch (err) {
-        await this.batchError(err);
-        await wait(600);
+      }
+      if (!isArrFilled(tasks)) {
+        await wait(400);
+        continue;
+      }
+      try {
+        await this.approve(queueName, await this.execute(queueName, await this.beforeExecute(queueName, tasks)));
+      } catch (err) {
+        await this.batchError(err, queueName, tasks);
+        try {
+          await this.approve(queueName, tasks.map((task) => task[0]));
+        } catch {
+        }
+        await wait(400);
       }
     }
   }
-  async addTasks(queueName, data, opts = {}) {
-    if (!isArrFilled(data)) {
-      throw new Error("Tasks is not filled.");
-    }
-    if (!isStrFilled(queueName)) {
-      throw new Error("Queue name is required.");
-    }
-    const job = opts.id ?? 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];
+  async batchError(err, queueName, tasks) {
+    try {
+      const filtered = {};
+      tasks.forEach((task, index) => {
+        const key = String(task[5] + ":" + task[2] + ":" + task[3]);
+        if (!filtered[key]) {
+          filtered[key] = [];
         }
+        filtered[key].push(tasks[index]);
       });
-    }
-    const runners = Array.from({ length: promises.length }, async () => {
-      while (promises.length) {
-        const promise = promises.shift();
-        if (promise) {
-          await promise();
-        }
+      for (let key in filtered) {
+        const filteredTasks = filtered[key];
+        const keySplit = key.split(":");
+        const attempt = Number(keySplit[0]);
+        await this.addTasks(queueName + (attempt + 1 >= this.retryCount ? ":dlq" : ""), filteredTasks.map((task) => ({ ...task[1] })), {
+          createdAt: Number(keySplit[1]),
+          job: keySplit[2],
+          attempt: attempt + 1
+        });
       }
-    });
-    if (opts.status) {
-      await this.redis.set(`${queueName}:${job}:total`, data.length);
-      await this.redis.pexpire(`${queueName}:${job}:total`, opts.statusTimeoutMs || 3e5);
+    } catch (err2) {
+      throw new Error(`Batch error. ${err2.message}`);
     }
-    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));
+    try {
+      await this.onBatchError(err, queueName, tasks);
+    } catch (err2) {
+      throw new Error(`Batch error. ${err2.message}`);
     }
   }
-  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)));
-      }
+  async approve(queueName, ids) {
+    if (!isArrFilled(ids)) {
+      return 0;
     }
-    throw new Error("Load lua script failed.");
-  }
-  saveScript(name, codeBody) {
-    if (!isStrFilled(codeBody)) {
-      throw new Error("Script body is empty.");
+    const approveCount = Math.max(500, Math.min(4e3, this.approveCount));
+    let total = 0, i = 0;
+    while (i < ids.length) {
+      const room = Math.min(approveCount, ids.length - i);
+      const part = ids.slice(i, i + room);
+      const approved = await this.runScript("Approve", [queueName], [this.group, this.removeOnExecuted ? "1" : "0", ...part], Approve);
+      total += Number(approved || 0);
+      i += room;
     }
-    this.scripts[name] = { codeBody };
-    return codeBody;
+    return total;
   }
-  async runScript(name, keys, args, defaultCode) {
-    if (!this.scripts[name]) {
-      if (!isStrFilled(defaultCode)) {
-        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);
+  async select(queueName, from = "0-0") {
+    let selected = await this.selectS(queueName, from);
+    if (!isArrFilled(selected)) {
+      selected = await this.selectF(queueName, from);
     }
+    return this.selectP(selected);
+  }
+  async selectS(queueName, from = "0-0") {
     try {
-      return await this.redis.evalsha(this.scripts[name].codeReady, keys.length, ...keys, ...args);
+      const res = await this.runScript("SelectStuck", [queueName], [this.group, this.consumer(), String(this.selectStuckTimeout), String(this.selectStuckCount), String(this.selectStuckMaxTimeout)], SelectStuck);
+      return isArr(res) ? res : [];
     } 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);
+      if (String(err?.message || "").includes("NOGROUP")) {
+        await this.createGroup(queueName, from);
       }
-      throw err;
     }
+    return [];
   }
-  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 && isArrFilled(entry.flat)) {
-        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 && isObjFilled(entry.payload)) {
-        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 (isNumNZ(pairs)) {
-        throw new Error('Task "flat" must contain at least one field/value pair.');
+  async selectF(queueName, from = "0-0") {
+    let rows = [];
+    try {
+      const res = await this.redis.xreadgroup(
+        "GROUP",
+        this.group,
+        this.consumer(),
+        "BLOCK",
+        Math.max(2, this.selectTimeout | 0),
+        "COUNT",
+        this.selectCount,
+        "STREAMS",
+        queueName,
+        ">"
+      );
+      rows = res?.[0]?.[1] ?? [];
+      if (!isArrFilled(rows)) {
+        return [];
       }
-      argv.push(String(id));
-      argv.push(String(pairs));
-      for (const token of flat) {
-        argv.push(!token ? "" : isStrFilled(token) ? token : String(token));
+    } catch (err) {
+      if (String(err?.message || "").includes("NOGROUP")) {
+        await this.createGroup(queueName, from);
       }
     }
-    return argv;
+    return rows;
   }
-  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 (isObj(entry.payload)) {
-        entry = {
-          ...entry,
-          payload: {
-            payload: JSON.stringify(entry.payload),
-            createdAt,
-            job
-          }
-        };
-        if (idem) {
-          entry.payload["idemKey"] = entry?.idemKey || uuid();
-        }
-      } 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());
-        }
-      }
-      const reqKeysLength = this.keysLength(entry);
-      if (batch.length && (batch.length >= this.addingBatchTasksCount || realKeysLength + reqKeysLength > this.addingBatchKeysLimit)) {
-        batches.push(batch);
-        batch = [];
-        realKeysLength = 0;
-      }
-      batch.push(entry);
-      realKeysLength += reqKeysLength;
-    }
-    if (batch.length) {
-      batches.push(batch);
+  selectP(raw) {
+    if (!Array.isArray(raw)) {
+      return [];
     }
-    return batches;
+    return Array.from(raw || []).map((e) => {
+      const id = Buffer.isBuffer(e?.[0]) ? e[0].toString() : e?.[0];
+      const kvRaw = e?.[1] ?? [];
+      const kv = isArr(kvRaw) ? kvRaw.map((x) => Buffer.isBuffer(x) ? x.toString() : x) : [];
+      return [id, kv];
+    }).filter(([id, kv]) => isStrFilled(id) && isArr(kv) && (kv.length & 1) === 0).map(([id, kv]) => {
+      const { payload, createdAt, job, idemKey = "", attempt } = this.values(kv);
+      return [id, this.payload(payload), createdAt, job, idemKey, Number(attempt)];
+    });
   }
-  keysLength(task) {
-    if ("flat" in task && Array.isArray(task.flat) && task.flat.length) {
-      return 2 + task.flat.length;
-    }
-    if ("payload" in task && isObj(task.payload)) {
-      return 2 + Object.keys(task.payload).length * 2;
+  values(value) {
+    const result = {};
+    for (let i = 0; i < value.length; i += 2) {
+      result[value[i]] = value[i + 1];
     }
-    return 2 + 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}`;
+    return result;
   }
-  async incrAttempts(id) {
+  payload(data) {
     try {
-      const key = this.attemptsKey(id);
-      const attempts = await this.redis.incr(key);
-      await this.redis.pexpire(key, this.workerClearAttemptsTimeoutMs);
-      return attempts;
+      return JSON.parse(data);
     } 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) {
-      const prefix = `${this.stream}:${job}:`;
-      await this.incr(`${prefix}ok`, this.executeJobStatusTtlMs);
-      await this.incr(`${prefix}ready`, this.executeJobStatusTtlMs);
-    }
-    await this.onSuccess(id, payload, createdAt, job, key);
-  }
-  async batchError(err, tasks) {
-    await this.onBatchError(err, tasks);
-  }
-  async error(err, id, payload, createdAt, job, key, attempt) {
-    if (this.executeJobStatus && attempt >= this.workerMaxRetries) {
-      const prefix = `${this.stream}:${job}:`;
-      await this.incr(`${prefix}err`, this.executeJobStatusTtlMs);
-      await this.incr(`${prefix}ready`, this.executeJobStatusTtlMs);
-    }
-    await this.onError(err, id, payload, createdAt, job, key);
-  }
-  async attempt(err, id, payload, createdAt, job, key, attempt) {
-    await this.onRetry(err, id, payload, createdAt, job, key, attempt);
+    return data;
   }
-  async execute(tasks) {
+  async execute(queueName, tasks) {
     const result = [];
     let contended = 0, promises = [];
-    for (const [id, payload, createdAt, job, idemKey] of tasks) {
-      if (this.executeBatchAtOnce) {
+    for (const [id, payload, createdAt, job, idemKey, attempt] of tasks) {
+      if (!this.executeSync) {
         promises.push((async () => {
-          const r = await this.executeProcess(id, payload, createdAt, job, idemKey);
+          const r = await this.executeProcess(queueName, { id, payload, createdAt, job, idemKey, attempt });
           if (r.id) {
             result.push(id);
           } else if (r.contended) {
@@ -568,7 +444,7 @@ var PowerQueues = class extends PowerRedis {
           }
         })());
       } else {
-        const r = await this.executeProcess(id, payload, createdAt, job, idemKey);
+        const r = await this.executeProcess(queueName, { id, payload, createdAt, job, idemKey, attempt });
         if (r.id) {
           result.push(id);
         } else if (r.contended) {
@@ -576,69 +452,20 @@ var PowerQueues = class extends PowerRedis {
         }
       }
     }
-    try {
-      if (this.executeBatchAtOnce && promises.length > 0) {
-        await Promise.all(promises);
-      }
-      await this.onReady(tasks);
-      if (!isArrFilled(result) && 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) {
-      await this.batchError(err, tasks);
-    }
-    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.getAttempts(id));
-        await this.success(id, payload, createdAt, job, key);
-        return { id };
-      } catch (err) {
-        const attempt = await this.incrAttempts(id);
-        await this.attempt(err, id, payload, createdAt, job, key, attempt);
-        await this.error(err, id, payload, createdAt, job, key, attempt);
-        if (attempt >= this.workerMaxRetries) {
-          await this.addTasks(`${this.stream}:dlq`, [{
-            payload: {
-              ...payload,
-              error: String(err?.message || err),
-              createdAt,
-              job,
-              id,
-              attempt
-            }
-          }]);
-          await this.clearAttempts(id);
-          return { id };
-        }
-      }
-    }
-    return {};
-  }
-  async approve(ids) {
-    if (!Array.isArray(ids) || !(ids.length > 0)) {
-      return 0;
+    if (!this.executeSync && 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.onBatchSuccess(queueName, tasks);
+    if (!isArrFilled(result) && 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;
+    return result;
   }
-  async idempotency(id, payload, createdAt, job, key) {
-    const keys = this.idempotencyKeys(key);
+  async executeProcess(queueName, task) {
+    const keys = this.idempotencyKeys(queueName, String(task.idemKey));
     const allow = await this.idempotencyAllow(keys);
     if (allow === 1) {
-      return { id };
+      return { id: task.id };
     } else if (allow === 0) {
       let ttl = -2;
       try {
@@ -654,29 +481,17 @@ var PowerQueues = class extends PowerRedis {
     const heartbeat = this.heartbeat(keys) || (() => {
     });
     try {
-      await this.onExecute(id, payload, createdAt, job, key, await this.getAttempts(id));
+      await this.onExecute(queueName, task);
       await this.idempotencyDone(keys);
-      await this.success(id, payload, createdAt, job, key);
-      return { id };
+      await this.success(queueName, task);
+      return { id: task.id };
     } catch (err) {
-      const attempt = await this.incrAttempts(id);
       try {
-        await this.attempt(err, id, payload, createdAt, job, key, attempt);
-        await this.error(err, id, payload, createdAt, job, key, attempt);
-        if (attempt >= this.workerMaxRetries) {
-          await this.addTasks(`${this.stream}:dlq`, [{
-            payload: {
-              ...payload,
-              error: String(err?.message || err),
-              createdAt,
-              job,
-              id,
-              attempt: 0
-            }
-          }]);
-          await this.clearAttempts(id);
+        task.attempt = task.attempt + 1;
+        await this.error(err, queueName, task);
+        if (task.attempt >= this.retryCount) {
           await this.idempotencyFree(keys);
-          return { id };
+          return { id: task.id };
         }
         await this.idempotencyFree(keys);
       } catch (err2) {
@@ -685,8 +500,8 @@ var PowerQueues = class extends PowerRedis {
       heartbeat();
     }
   }
-  idempotencyKeys(key) {
-    const prefix = `q:${this.stream.replace(/[^\w:\-]/g, "_")}:`;
+  idempotencyKeys(queueName, key) {
+    const prefix = `q:${queueName.replace(/[^\w:\-]/g, "_")}:`;
     const keyP = key.replace(/[^\w:\-]/g, "_");
     const doneKey = `${prefix}done:${keyP}`;
     const lockKey = `${prefix}lock:${keyP}`;
@@ -701,72 +516,50 @@ var PowerQueues = class extends PowerRedis {
     };
   }
   async idempotencyAllow(keys) {
-    const res = await this.runScript("IdempotencyAllow", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.workerExecuteLockTimeoutMs), keys.token], IdempotencyAllow);
+    const res = await this.runScript("IdempotencyAllow", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.idemLockTimeout), 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);
+    const res = await this.runScript("IdempotencyStart", [keys.lockKey, keys.startKey], [keys.token, String(this.idemLockTimeout)], 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);
+    await this.runScript("IdempotencyDone", [keys.doneKey, keys.lockKey, keys.startKey], [String(this.idemDoneTimeout), 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;
-      }
-    }
-  }
-  async select() {
-    let entries = await this.selectStuck();
-    if (!isArrFilled(entries)) {
-      entries = await this.selectFresh();
-    }
-    return this.normalizeEntries(entries);
-  }
-  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 isArr(res) ? res : [];
-    } catch (err) {
-      if (String(err?.message || "").includes("NOGROUP")) {
-        await this.createGroup();
-      }
-    }
-    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,
-        ">"
-      );
-      entries = res?.[0]?.[1] ?? [];
-      if (!isArrFilled(entries)) {
-        return [];
-      }
-    } catch (err) {
-      if (String(err?.message || "").includes("NOGROUP")) {
-        await this.createGroup();
+  async success(queueName, task) {
+    if (this.logStatus) {
+      const statusKey = `${queueName}:${task.job}:`;
+      await this.incr(statusKey + "ok", this.logStatusTimeout);
+      await this.incr(statusKey + "ready", this.logStatusTimeout);
+    }
+    await this.onSuccess(queueName, task);
+  }
+  async error(err, queueName, task) {
+    const dlqKey = queueName + ":dlq";
+    const taskP = { ...task };
+    if (task.attempt >= this.retryCount) {
+      const statusKey = `${queueName}:${task.job}:`;
+      await this.addTasks(dlqKey, [{ ...taskP.payload }], {
+        createdAt: task.createdAt,
+        job: task.job,
+        attempt: task.attempt
+      });
+      if (this.logStatus) {
+        await this.incr(statusKey + "err", this.logStatusTimeout);
+        await this.incr(statusKey + "ready", this.logStatusTimeout);
       }
+    } else {
+      await this.onRetry(err, queueName, task);
+      await this.addTasks(queueName, [{ ...taskP.payload }], {
+        createdAt: task.createdAt,
+        job: task.job,
+        attempt: task.attempt
+      });
     }
-    return entries;
+    await this.onError(err, queueName, task);
   }
   async waitAbortable(ttl) {
     return new Promise((resolve) => {
@@ -798,8 +591,8 @@ var PowerQueues = class extends PowerRedis {
   }
   async sendHeartbeat(keys) {
     try {
-      const r1 = await this.redis.pexpire(keys.lockKey, this.workerExecuteLockTimeoutMs);
-      const r2 = await this.redis.pexpire(keys.startKey, this.workerExecuteLockTimeoutMs);
+      const r1 = await this.redis.pexpire(keys.lockKey, this.idemLockTimeout);
+      const r2 = await this.redis.pexpire(keys.startKey, this.idemLockTimeout);
       const ok1 = Number(r1 || 0) === 1;
       const ok2 = Number(r2 || 0) === 1;
       return ok1 || ok2;
@@ -808,10 +601,10 @@ var PowerQueues = class extends PowerRedis {
     }
   }
   heartbeat(keys) {
-    if (this.workerExecuteLockTimeoutMs <= 0) {
+    if (this.idemLockTimeout <= 0) {
       return;
     }
-    const workerHeartbeatTimeoutMs = Math.max(1e3, Math.floor(Math.max(5e3, this.workerExecuteLockTimeoutMs | 0) / 4));
+    const workerHeartbeatTimeoutMs = Math.max(1e3, Math.floor(Math.max(5e3, this.idemLockTimeout | 0) / 4));
     let timer;
     let alive = true;
     let hbFails = 0;
@@ -851,39 +644,191 @@ var PowerQueues = class extends PowerRedis {
       stop();
     };
   }
-  normalizeEntries(raw) {
-    if (!Array.isArray(raw)) {
-      return [];
+  async runScript(name, keys, args, defaultCode) {
+    if (!this.scripts[name]) {
+      if (!isStrFilled(defaultCode)) {
+        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);
+    }
+    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);
+      }
+      throw err;
     }
-    return Array.from(raw || []).map((e) => {
-      const id = Buffer.isBuffer(e?.[0]) ? e[0].toString() : e?.[0];
-      const kvRaw = e?.[1] ?? [];
-      const kv = isArr(kvRaw) ? kvRaw.map((x) => Buffer.isBuffer(x) ? x.toString() : x) : [];
-      return [id, kv];
-    }).filter(([id, kv]) => isStrFilled(id) && isArr(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];
+  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)));
+      }
+    }
+    throw new Error("Load lua script failed.");
+  }
+  saveScript(name, codeBody) {
+    if (!isStrFilled(codeBody)) {
+      throw new Error("Script body is empty.");
+    }
+    this.scripts[name] = { codeBody };
+    return codeBody;
+  }
+  async addTasks(queueName, data, opts = {}) {
+    if (!isArrFilled(data)) {
+      throw new Error("Tasks is not filled.");
+    }
+    if (!isStrFilled(queueName)) {
+      throw new Error("Queue name is required.");
+    }
+    opts.job = opts.job ?? uuid();
+    const batches = this.buildBatches(data, opts);
+    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 payload = this.payloadBatch(batch, opts);
+        const partIds = await this.runScript("XAddBulk", [queueName], payload, XAddBulk);
+        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();
+        }
+      }
+    });
+    if (opts.status) {
+      await this.redis.set(`${queueName}:${opts.job}:total`, data.length);
+      await this.redis.pexpire(`${queueName}:${opts.job}:total`, this.logStatusTimeout);
+    }
+    await Promise.all(runners);
     return result;
   }
-  payload(data) {
-    try {
-      return jsonDecode(data);
-    } catch (err) {
+  buildBatches(tasks, opts = {}) {
+    const batches = [];
+    let batch = [], realKeysLength = 0;
+    for (let task of tasks) {
+      const createdAt = opts?.createdAt || Date.now();
+      let entry = {};
+      if (isObj(entry)) {
+        entry = {
+          payload: JSON.stringify(task),
+          attempt: Number(opts.attempt || 0),
+          job: opts.job ?? uuid(),
+          idemKey: uuid(),
+          createdAt
+        };
+      }
+      const reqKeysLength = this.keysLength(entry);
+      if (batch.length && (batch.length >= this.buildBatchCount || realKeysLength + reqKeysLength > this.buildBatchMaxCount)) {
+        batches.push(batch);
+        batch = [];
+        realKeysLength = 0;
+      }
+      batch.push(entry);
+      realKeysLength += reqKeysLength;
     }
-    return data;
+    if (batch.length) {
+      batches.push(batch);
+    }
+    return batches;
   }
-  signal() {
-    return this.abort.signal;
+  keysLength(task) {
+    if ("payload" in task && isObj(task.payload)) {
+      return 2 + Object.keys(task.payload).length * 2;
+    }
+    return 2 + Object.keys(task).length * 2;
   }
-  consumer() {
-    return `${String(this.consumerHost || "host")}:${process.pid}`;
+  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 ("payload" in entry && isObjFilled(entry)) {
+        for (const [k, v] of Object.entries(entry)) {
+          flat.push(k, v);
+        }
+      } else {
+        throw new Error('Task must have "payload" or "flat".');
+      }
+      const pairs = flat.length / 2;
+      if (isNumNZ(pairs)) {
+        throw new Error('Task "flat" must contain at least one field/value pair.');
+      }
+      argv.push(String(id));
+      argv.push(String(pairs));
+      for (const token of flat) {
+        argv.push(!isExists(token) ? "" : isStrFilled(token) ? token : String(token));
+      }
+    }
+    return argv;
+  }
+  async beforeExecute(queueName, tasks) {
+    return tasks;
+  }
+  async onExecute(queueName, task) {
+  }
+  async onBatchSuccess(queueName, tasks) {
+  }
+  async onSuccess(queueName, task) {
+  }
+  async onError(err, queueName, task) {
+  }
+  async onBatchError(err, queueName, tasks) {
+  }
+  async onRetry(err, queueName, task) {
   }
 };
 export {