power-queues 1.0.8 → 2.0.1

package/dist/index.js

@@ -1,10 +1,765 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.QueueProcessor = exports.Processor = void 0;
-const Processor_1 = require("./src/Processor");
-Object.defineProperty(exports, "Processor", { enumerable: true, get: function () { return Processor_1.Processor; } });
-const QueueProcessor_1 = require("./src/QueueProcessor");
-Object.defineProperty(exports, "QueueProcessor", { enumerable: true, get: function () { return QueueProcessor_1.QueueProcessor; } });
-const Queue_1 = require("./src/Queue");
-Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return Queue_1.Queue; } });
-//# sourceMappingURL=index.js.map
+// src/PowerQueue.ts
+import { v4 as uuid } from "uuid";
+import {
+  isStrFilled,
+  isStr,
+  isArrFilled,
+  isArr,
+  isObjFilled,
+  isNumPZ,
+  isNumP,
+  isFunc,
+  wait
+} from "full-utils";
+import { PowerRedis } from "power-redis";
+var PowerQueue = class extends PowerRedis {
+  constructor() {
+    super(...arguments);
+    this.iterationTimeout = 1e3;
+    this.portionLength = 1e3;
+    this.expireStatusSec = 300;
+    this.maxAttempts = 1;
+    this.concurrency = 32;
+    this.visibilityTimeoutSec = 60;
+    this.retryBaseSec = 1;
+    this.retryMaxSec = 3600;
+    this.runners = /* @__PURE__ */ new Map();
+    this.processingRaw = /* @__PURE__ */ new Map();
+    this.heartbeatTimers = /* @__PURE__ */ new Map();
+  }
+  nowSec() {
+    return Math.floor(Date.now() / 1e3);
+  }
+  readyKey(queueName) {
+    return this.toKeyString(queueName);
+  }
+  processingKey(queueName) {
+    return this.toKeyString(queueName, "processing");
+  }
+  processingVtKey(queueName) {
+    return this.toKeyString(queueName, "processing", "vt");
+  }
+  delayedKey(queueName) {
+    return this.toKeyString(queueName, "delayed");
+  }
+  toKeyString(...parts) {
+    return super.toKeyString("queue", ...parts);
+  }
+  getReserveScriptLMOVE() {
+    return `
+			local source = KEYS[1]
+			local processing = KEYS[2]
+			local vtkey = KEYS[3]
+			local limit = tonumber(ARGV[1])
+			local deadline = tonumber(ARGV[2])
+			local moved = {}
+			for i = 1, limit do
+				local v = redis.call('LMOVE', source, processing, 'LEFT', 'RIGHT')
+				if not v then break end
+				table.insert(moved, v)
+			end
+			if #moved > 0 then
+				for i = 1, #moved do
+					redis.call('ZADD', vtkey, deadline, moved[i])
+				end
+			end
+			return moved
+		`;
+  }
+  getReserveScriptRPOPLPUSH() {
+    return `
+			local source = KEYS[1]
+			local processing = KEYS[2]
+			local vtkey = KEYS[3]
+			local limit = tonumber(ARGV[1])
+			local deadline = tonumber(ARGV[2])
+			local moved = {}
+			for i = 1, limit do
+				local v = redis.call('RPOPLPUSH', source, processing)
+				if not v then break end
+				table.insert(moved, v)
+			end
+			if #moved > 0 then
+				for i = 1, #moved do
+					redis.call('ZADD', vtkey, deadline, moved[i])
+				end
+			end
+			return moved
+		`;
+  }
+  getRequeueScript() {
+    return `
+			-- KEYS: 1=processing, 2=processingVt, 3=ready
+			-- ARGV: 1=now, 2=limit
+			local processing = KEYS[1]
+			local vt = KEYS[2]
+			local ready = KEYS[3]
+			local now = tonumber(ARGV[1])
+			local limit = tonumber(ARGV[2])
+
+			local members = redis.call('ZRANGEBYSCORE', vt, 0, now, 'LIMIT', 0, limit)
+			for i=1,#members do
+				local m = members[i]
+				redis.call('ZREM', vt, m)
+				redis.call('LREM', processing, 1, m)
+				redis.call('RPUSH', ready, m)
+			end
+			return #members
+		`;
+  }
+  getPromoteScript() {
+    return `
+			-- KEYS: 1=delayed, 2=ready
+			-- ARGV: 1=now, 2=limit
+			local delayed = KEYS[1]
+			local ready = KEYS[2]
+			local now = tonumber(ARGV[1])
+			local limit = tonumber(ARGV[2])
+
+			local due = redis.call('ZRANGEBYSCORE', delayed, 0, now, 'LIMIT', 0, limit)
+			for i=1,#due do
+				local m = due[i]
+				redis.call('ZREM', delayed, m)
+				redis.call('RPUSH', ready, m)
+			end
+			return #due
+		`;
+  }
+  async ensureReserveScript(force = false) {
+    if (!force && (this.reserveSha || this.reserveShaRpoplpush || !isFunc(this.redis?.script))) {
+      return;
+    }
+    this.reserveSha = void 0;
+    this.reserveShaRpoplpush = void 0;
+    try {
+      this.reserveSha = await this.redis?.script("LOAD", this.getReserveScriptLMOVE());
+    } catch {
+      this.reserveShaRpoplpush = await this.redis?.script("LOAD", this.getReserveScriptRPOPLPUSH());
+    }
+  }
+  async ensureRequeueScript(force = false) {
+    if (!force && this.requeueSha) {
+      return;
+    }
+    const scriptFn = this.redis?.script;
+    if (!scriptFn) {
+      return;
+    }
+    this.requeueSha = await scriptFn("LOAD", this.getRequeueScript());
+  }
+  async ensurePromoteScript(force = false) {
+    if (!force && this.promoteSha) {
+      return;
+    }
+    const scriptFn = this.redis?.script;
+    if (!scriptFn) {
+      return;
+    }
+    this.promoteSha = await scriptFn("LOAD", this.getPromoteScript());
+  }
+  async moveOneToProcessing(source, processing) {
+    const cli = this.redis;
+    try {
+      if (isFunc(cli.lmove)) {
+        const v = await cli.lmove(source, processing, "LEFT", "RIGHT");
+        return isStr(v) ? v : null;
+      }
+    } catch {
+    }
+    try {
+      if (isFunc(cli.rpoplpush)) {
+        const v = await cli.rpoplpush(source, processing);
+        return isStr(v) ? v : null;
+      }
+    } catch {
+    }
+    return null;
+  }
+  async evalshaWithReload(shaGetter, ensure, numKeys, keysAndArgs) {
+    await ensure(false);
+    const sha = shaGetter();
+    const evalshaFn = this.redis?.evalsha;
+    if (!sha || !evalshaFn) {
+      throw new Error("EVALSHA not available or SHA missing");
+    }
+    try {
+      return await evalshaFn(sha, numKeys, ...keysAndArgs.map(String));
+    } catch (err) {
+      const msg = err?.message;
+      if (typeof msg === "string" && msg.includes("NOSCRIPT")) {
+        await ensure(true);
+        const sha2 = shaGetter();
+        if (!sha2) {
+          throw new Error("EVALSHA NOSCRIPT and reload failed (no SHA)");
+        }
+        return await evalshaFn(sha2, numKeys, ...keysAndArgs.map(String));
+      }
+      throw err;
+    }
+  }
+  async zaddCompatXXCH(key, score, member) {
+    const zadd = this.redis?.zadd;
+    try {
+      if (zadd) {
+        await zadd.call(this.redis, key, "XX", "CH", score, member);
+        return;
+      }
+    } catch {
+    }
+    try {
+      if (zadd) {
+        await zadd.call(this.redis, key, "CH", "XX", score, member);
+        return;
+      }
+    } catch {
+    }
+    try {
+      await this.redis.zadd(key, score, member);
+    } catch {
+    }
+  }
+  startHeartbeat(task) {
+    const raw = this.processingRaw.get(task.id);
+    if (!raw) {
+      return;
+    }
+    const vtKey = this.processingVtKey(task.queueName);
+    const periodMs = Math.max(1e3, Math.floor(this.visibilityTimeoutSec * 1e3 * 0.4));
+    const t = setInterval(() => {
+      this.extendVisibility(vtKey, raw, this.visibilityTimeoutSec).catch(() => {
+      });
+    }, periodMs);
+    t.unref?.();
+    this.heartbeatTimers.set(task.id, t);
+  }
+  stopHeartbeat(task) {
+    const t = this.heartbeatTimers.get(task.id);
+    if (t) {
+      clearInterval(t);
+    }
+    this.heartbeatTimers.delete(task.id);
+  }
+  async reserveMany(source, processing, processingVt, limit = 100, visibilitySec = 60) {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    if (!isStrFilled(source) || !isStrFilled(processing) || !isStrFilled(processingVt)) {
+      throw new Error("Key format error.");
+    }
+    if (!isNumP(limit) || !isNumP(visibilitySec)) {
+      throw new Error("Limit/visibility format error.");
+    }
+    await this.ensureReserveScript();
+    const deadline = this.nowSec() + visibilitySec;
+    const tryEval = async () => {
+      if (isFunc(this.redis?.evalsha)) {
+        if (this.reserveSha) {
+          return await this.redis?.evalsha(this.reserveSha, 3, source, processing, processingVt, String(limit), String(deadline));
+        }
+        if (this.reserveShaRpoplpush) {
+          return await this.redis?.evalsha(this.reserveShaRpoplpush, 3, source, processing, processingVt, String(limit), String(deadline));
+        }
+      }
+      return null;
+    };
+    try {
+      const res = await tryEval();
+      if (isArr(res)) {
+        return Array.from(res).map(String);
+      }
+    } catch (err) {
+      if (isStr(err?.message) && String(err?.message ?? "").includes("NOSCRIPT")) {
+        await this.ensureReserveScript(true);
+        try {
+          const res2 = await tryEval();
+          if (isArr(res2)) {
+            return Array.from(res2).map(String);
+          }
+        } catch {
+        }
+      }
+    }
+    const moved = [];
+    for (let i = 0; i < limit; i++) {
+      const v = await this.moveOneToProcessing(source, processing);
+      if (!v) {
+        break;
+      }
+      moved.push(v);
+    }
+    if (moved.length) {
+      const tx = this.redis?.multi();
+      for (const v of moved) {
+        tx.zadd(processingVt, deadline, v);
+      }
+      await tx.exec();
+    }
+    return moved;
+  }
+  async ackProcessing(processing, processingVt, raw) {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    const tx = this.redis?.multi();
+    tx.lrem(processing, 1, raw);
+    tx.zrem(processingVt, raw);
+    await tx.exec();
+    return;
+  }
+  async requeueExpired(processing, processingVt, ready, nowTs, chunk = 1e3) {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    const now = isNumP(nowTs) ? nowTs : this.nowSec();
+    try {
+      const moved = await this.evalshaWithReload(
+        () => this.requeueSha,
+        (force) => this.ensureRequeueScript(!!force),
+        3,
+        [processing, processingVt, ready, String(now), String(chunk)]
+      );
+      return isNumP(moved) ? moved : 0;
+    } catch {
+      const expired = await this.redis?.zrangebyscore(processingVt, 0, now, "LIMIT", 0, chunk);
+      if (!isArrFilled(expired)) {
+        return 0;
+      }
+      const tx = this.redis?.multi();
+      for (const raw of expired) {
+        tx.lrem(processing, 1, raw);
+        tx.zrem(processingVt, raw);
+        tx.rpush(ready, raw);
+      }
+      await tx.exec();
+      return expired.length;
+    }
+  }
+  async promoteDelayed(delayed, ready, nowTs, chunk = 1e3) {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    const now = isNumP(nowTs) ? nowTs : this.nowSec();
+    try {
+      const promoted = await this.evalshaWithReload(
+        () => this.promoteSha,
+        (force) => this.ensurePromoteScript(!!force),
+        2,
+        [delayed, ready, String(now), String(chunk)]
+      );
+      return isNumP(promoted) ? promoted : 0;
+    } catch {
+      const due = await this.redis?.zrangebyscore(delayed, 0, now, "LIMIT", 0, chunk);
+      if (!isArrFilled(due)) {
+        return 0;
+      }
+      const tx = this.redis?.multi();
+      for (const raw of due) {
+        tx.zrem(delayed, raw);
+        tx.rpush(ready, raw);
+      }
+      await tx.exec();
+      return due.length;
+    }
+  }
+  async enqueue(ready, delayed, payload, delaySec) {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    const raw = this.toPayload(payload);
+    if (isNumP(delaySec) && delaySec > 0) {
+      const score = this.nowSec() + delaySec;
+      return await this.redis?.zadd(delayed, score, raw);
+    }
+    return await this.redis?.rpush(ready, raw);
+  }
+  async extendVisibility(processingVt, raw, visibilitySec) {
+    const deadline = this.nowSec() + Math.max(1, visibilitySec);
+    await this.zaddCompatXXCH(processingVt, deadline, raw);
+  }
+  run(queueName) {
+    if (!isStrFilled(queueName)) {
+      throw new Error("Queue name is not valid.");
+    }
+    const r = this.runners.get(queueName) ?? { running: false };
+    if (r.running) {
+      throw new Error(`Queue "${queueName}" already started.`);
+    }
+    r.running = true;
+    this.runners.set(queueName, r);
+    this.loop(queueName, r).catch(() => {
+      r.running = false;
+    });
+  }
+  stop(queueName) {
+    const r = this.runners.get(queueName);
+    if (r) {
+      r.running = false;
+      this.runners.delete(queueName);
+    }
+  }
+  buildTask(data) {
+    if (!isObjFilled(data)) {
+      throw new Error("Data property is not valid.");
+    }
+    if (!isStrFilled(data.queueName)) {
+      throw new Error("Queue name is not valid.");
+    }
+    return {
+      queueName: data.queueName,
+      iterationId: isStrFilled(data.iterationId) ? data.iterationId : uuid(),
+      iterationLength: Number(data.iterationLength || 0),
+      id: isStrFilled(data.id) ? data.id : uuid(),
+      maxAttempts: isNumPZ(data.maxAttempts) ? data.maxAttempts : this.maxAttempts,
+      currentAttempt: isNumPZ(data.currentAttempt) ? data.currentAttempt : 0,
+      chain: isObjFilled(data.chain) && isArrFilled(data.chain.queues) && isNumPZ(data.chain.index) ? data.chain : {
+        queues: [],
+        index: 0
+      },
+      payload: isObjFilled(data.payload) ? data.payload : {},
+      progress: {
+        createdAt: Date.now(),
+        successAt: 0,
+        errorAt: 0,
+        failAt: 0,
+        fatalAt: 0,
+        retries: [],
+        chain: [],
+        ...isObjFilled(data.progress) ? data.progress : {}
+      },
+      result: isObjFilled(data.result) ? data.result : {}
+    };
+  }
+  async addTask(data, delaySec) {
+    const ready = this.readyKey(String(data.queueName));
+    const delayed = this.delayedKey(String(data.queueName));
+    return await this.enqueue(ready, delayed, this.buildTask(data), isNumP(delaySec) ? delaySec : 0);
+  }
+  async addTasks(data) {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    if (!isObjFilled(data) || !isStrFilled(data.queueName)) {
+      throw new Error("Queue name is not valid.");
+    }
+    if (!isArrFilled(data.payloads)) {
+      return 0;
+    }
+    const queueName = String(data.queueName);
+    const ready = this.readyKey(queueName);
+    const delayed = this.delayedKey(queueName);
+    const now = this.nowSec();
+    const uniformDelay = isNumP(data.delaySec) ? Math.max(0, Number(data.delaySec)) : void 0;
+    const perItemDelays = isArr(data.delaySec) ? data.delaySec.map((v) => Math.max(0, Number(v || 0))) : void 0;
+    const batchSize = Math.max(1, Math.min(this.portionLength, 1e3));
+    let idx = 0, total = 0;
+    while (idx < data.payloads.length) {
+      const end = Math.min(idx + batchSize, data.payloads.length);
+      const tx = this.redis?.multi();
+      for (let i = idx; i < end; i++) {
+        const item = data.payloads[i];
+        let partial;
+        if (isObjFilled(item) && Object.prototype.hasOwnProperty.call(item, "payload")) {
+          partial = { ...item, queueName };
+        } else {
+          partial = { queueName, payload: item };
+        }
+        const task = this.buildTask(partial);
+        const raw = this.toPayload(task);
+        let d = 0;
+        if (isNumP(uniformDelay)) {
+          d = uniformDelay;
+        } else if (isArr(perItemDelays)) {
+          d = Number(perItemDelays[i] || 0);
+        }
+        if (d > 0) {
+          tx.zadd(delayed, now + d, raw);
+        } else {
+          tx.rpush(ready, raw);
+        }
+        total++;
+      }
+      await tx.exec();
+      idx = end;
+    }
+    return total;
+  }
+  async iteration(tasks) {
+    const tasksProcessed = await this.beforeIterationExecution(tasks);
+    const limit = Math.max(1, Number(this.concurrency) || 1);
+    let i = 0;
+    while (i < tasksProcessed.length) {
+      const slice = tasksProcessed.slice(i, i + limit);
+      await Promise.all(slice.map((task) => this.logic(task)));
+      i += limit;
+    }
+    await this.afterIterationExecution(tasksProcessed, tasksProcessed.map((t) => t.result ?? {}));
+  }
+  async beforeIterationExecution(data) {
+    return data;
+  }
+  async afterIterationExecution(data, results) {
+  }
+  async beforeExecution(task) {
+    return task;
+  }
+  async afterExecution(task, result) {
+    return result;
+  }
+  async execute(task) {
+    return {};
+  }
+  async onRetry(task) {
+  }
+  async onError(err, task) {
+  }
+  async onFail(err, task) {
+  }
+  async onFatal(err, task) {
+  }
+  async onSuccess(task, result) {
+  }
+  async onChainSuccess(task, result) {
+  }
+  async onIterationError(err, queueName) {
+  }
+  async logic(task) {
+    let data = task;
+    try {
+      data = await this.beforeExecution(task);
+      const before = data?.result ?? {};
+      const after = await this.execute(data);
+      data.result = {
+        ...isObjFilled(before) ? before : {},
+        ...isObjFilled(after) ? after : {}
+      };
+      await this.success(data, data.result);
+      return await this.afterExecution(data, data.result);
+    } catch (err) {
+      try {
+        await this.retry(data);
+      } catch (err2) {
+        await this.error(err2, data);
+      }
+    } finally {
+      try {
+        this.stopHeartbeat(data);
+        await this.ack(data).catch(() => {
+        });
+      } catch {
+      }
+    }
+    return {};
+  }
+  jitteredBackoffSec(attempt) {
+    const base = Math.max(1, Number(this.retryBaseSec) || 1);
+    const maxD = Math.max(base, Number(this.retryMaxSec) || 3600);
+    const pow = Math.min(maxD, base * Math.pow(2, Math.max(0, attempt - 1)));
+    const jitter = Math.floor(Math.random() * base);
+    return Math.min(maxD, pow + jitter);
+  }
+  async retry(task) {
+    if (!isObjFilled(task) || !isStrFilled(task.iterationId) || !isStrFilled(task.id) || !isStrFilled(task.queueName) || !isNumPZ(task.currentAttempt) || !isNumPZ(task.maxAttempts)) {
+      await this.error(new Error("Task format error."), task);
+      return;
+    }
+    const maxAttempts = task.maxAttempts ?? this.maxAttempts;
+    try {
+      if (task.currentAttempt < maxAttempts - 1) {
+        const taskProcessed = { ...task, currentAttempt: task.currentAttempt + 1 };
+        const delaySec = this.jitteredBackoffSec(taskProcessed.currentAttempt);
+        await this.addTask(taskProcessed, delaySec);
+        await this.onRetry(taskProcessed);
+        return;
+      }
+    } catch (err) {
+      await this.fail(err, task);
+      return;
+    }
+    await this.fail(new Error("The attempt limit has been reached."), task);
+  }
+  async iterationError(err, queueName, data) {
+    try {
+      await this.onIterationError(err, queueName);
+    } catch (err2) {
+    }
+    for (const t of data || []) {
+      if (isStrFilled(t.id)) {
+        this.processingRaw.delete(t.id);
+      }
+    }
+  }
+  async error(err, task) {
+    try {
+      await this.addTask({
+        ...task,
+        queueName: [task.queueName, task.iterationId, "error", "list"].join(":"),
+        currentAttempt: 0,
+        payload: {
+          ...task.payload,
+          errorMessage: String(err?.message ?? "")
+        }
+      });
+      await this.onError(err, task);
+    } catch (err2) {
+      try {
+        await this.onFatal(err2, task);
+      } catch {
+      }
+    }
+    try {
+      await this.status(task, "error");
+    } catch {
+    }
+  }
+  async fail(err, task) {
+    try {
+      await this.addTask({
+        ...task,
+        queueName: [task.queueName, task.iterationId, "fail", "list"].join(":"),
+        currentAttempt: 0,
+        payload: {
+          ...task.payload,
+          errorMessage: String(err?.message ?? "")
+        }
+      });
+      await this.onFail(err, task);
+    } catch (err2) {
+      try {
+        await this.onFatal(err2, task);
+      } catch {
+      }
+    }
+    try {
+      await this.status(task, "fail");
+    } catch {
+    }
+  }
+  async success(task, result) {
+    const taskProcessed = {
+      ...task,
+      progress: {
+        ...task.progress,
+        successAt: Date.now()
+      }
+    };
+    try {
+      if (isObjFilled(taskProcessed.chain) && isArrFilled(taskProcessed.chain.queues) && isNumPZ(taskProcessed.chain.index)) {
+        const currentIndex = taskProcessed.chain.index;
+        const newIndex = currentIndex + 1;
+        taskProcessed.progress.chain.push(Date.now());
+        if (currentIndex === taskProcessed.chain.queues.length - 1) {
+          await this.status(taskProcessed, "success");
+          await this.onChainSuccess(taskProcessed, result);
+        } else if (newIndex <= taskProcessed.chain.queues.length - 1) {
+          const newQueueName = taskProcessed.chain.queues[newIndex];
+          if (isStrFilled(newQueueName)) {
+            await this.addTask({
+              ...taskProcessed,
+              queueName: newQueueName,
+              currentAttempt: 0,
+              chain: {
+                ...taskProcessed.chain,
+                index: newIndex
+              },
+              result
+            });
+          } else {
+            await this.fail(new Error("Next queue format error."), taskProcessed);
+          }
+        }
+      } else {
+        await this.status(taskProcessed, "success");
+      }
+      await this.onSuccess(taskProcessed, result);
+    } catch (err) {
+      try {
+        await this.status(taskProcessed, "fatal");
+      } catch {
+      }
+      try {
+        await this.onFatal(err, taskProcessed);
+      } catch {
+      }
+    }
+  }
+  async status(task, category = "success") {
+    if (!this.checkConnection()) {
+      throw new Error("Redis connection error.");
+    }
+    const processedKey = this.toKeyString(task.queueName, task.iterationId, "processed");
+    const categoryKey = this.toKeyString(task.queueName, task.iterationId, category);
+    await this.redis?.incr(processedKey);
+    await this.redis?.incr(categoryKey);
+    await this.redis?.expire(processedKey, this.expireStatusSec);
+    await this.redis?.expire(categoryKey, this.expireStatusSec);
+  }
+  async loop(queueName, runner) {
+    if (!isStrFilled(queueName)) {
+      throw new Error(`Queue name is not valid: "${queueName}"; Type: "${typeof queueName}".`);
+    }
+    const ready = this.readyKey(queueName);
+    const processing = this.processingKey(queueName);
+    const processingVt = this.processingVtKey(queueName);
+    const delayed = this.delayedKey(queueName);
+    while (runner.running) {
+      if (!this.checkConnection()) {
+        await wait(this.iterationTimeout);
+        continue;
+      }
+      try {
+        await this.promoteDelayed(delayed, ready);
+      } catch {
+      }
+      try {
+        await this.requeueExpired(processing, processingVt, ready);
+      } catch {
+      }
+      let data = [];
+      try {
+        data = await this.data(queueName);
+        if (!isArrFilled(data)) {
+          await wait(this.iterationTimeout);
+          continue;
+        }
+        await this.iteration(data);
+      } catch (err) {
+        await this.iterationError(err, queueName, data);
+        await wait(this.iterationTimeout);
+      }
+    }
+  }
+  async data(queueName) {
+    const ready = this.readyKey(queueName);
+    const processing = this.processingKey(queueName);
+    const processingVt = this.processingVtKey(queueName);
+    const raws = await this.reserveMany(ready, processing, processingVt, this.portionLength, this.visibilityTimeoutSec);
+    if (!isArrFilled(raws)) {
+      return [];
+    }
+    const tasks = [];
+    for (const raw of raws) {
+      const obj = this.fromPayload(raw);
+      if (isObjFilled(obj) && isStrFilled(obj.iterationId) && isStrFilled(obj.id) && isStrFilled(obj.queueName) && isNumPZ(obj.maxAttempts) && isNumPZ(obj.currentAttempt)) {
+        const t = obj;
+        this.processingRaw.set(t.id, raw);
+        this.startHeartbeat(t);
+        tasks.push(t);
+      }
+    }
+    return tasks;
+  }
+  async ack(task) {
+    try {
+      const raw = this.processingRaw.get(task.id);
+      if (!isStrFilled(raw)) {
+        return;
+      }
+      this.processingRaw.delete(task.id);
+      await this.ackProcessing(this.processingKey(task.queueName), this.processingVtKey(task.queueName), raw);
+    } catch {
+    }
+  }
+};
+export {
+  PowerQueue
+};