qdone 2.0.9-alpha → 2.0.10-alpha

package/commonjs/src/scheduler/jobExecutor.js

@@ -0,0 +1,321 @@
+"use strict";
+/**
+ * Component to manage all the currently executing jobs, including extending
+ * their visibility timeouts and deleting them when they are successful.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobExecutor = void 0;
+var client_sqs_1 = require("@aws-sdk/client-sqs");
+var chalk_1 = __importDefault(require("chalk"));
+var debug_1 = __importDefault(require("debug"));
+var sqs_js_1 = require("../sqs.js");
+var debug = (0, debug_1.default)('qdone:jobExecutor');
+var maxJobSeconds = 12 * 60 * 60;
+var JobExecutor = /** @class */ (function () {
+    function JobExecutor(opt) {
+        this.opt = opt;
+        this.jobs = [];
+        this.stats = {
+            activeJobs: 0,
+            sqsCalls: 0,
+            timeoutsExtended: 0,
+            jobsSucceeded: 0,
+            jobsFailed: 0,
+            jobsDeleted: 0
+        };
+        this.maintainVisibility();
+        debug({ this: this });
+    }
+    JobExecutor.prototype.shutdown = function () {
+        this.shutdownRequested = true;
+        if (this.stats.activeJobs === 0 && this.jobs.length === 0) {
+            clearTimeout(this.maintainVisibilityTimeout);
+        }
+    };
+    JobExecutor.prototype.activeJobCount = function () {
+        return this.stats.activeJobs;
+    };
+    /**
+     * Changes message visibility on all running jobs using as few calls as possible.
+     */
+    JobExecutor.prototype.maintainVisibility = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, jobsToExtendByQrl, jobsToDeleteByQrl, jobsToCleanup, _i, _a, job, jobRunTime, jobsToDelete, jobsToExtend, doubled, secondsUntilMax, secondsUntilKill, _b, jobsToExtendByQrl_1, _c, qrl, jobsToExtend, entries, messageId, job, entry, input, result, _d, jobsToDeleteByQrl_1, _e, qrl, jobsToDelete, entries, messageId, job, entry, input, result;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        debug('maintainVisibility', this.jobs);
+                        now = new Date();
+                        jobsToExtendByQrl = new Map();
+                        jobsToDeleteByQrl = new Map();
+                        jobsToCleanup = new Set();
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('Stats: '), this.stats);
+                            console.error(chalk_1.default.blue('Running: '), this.jobs.map(function (_a) {
+                                var qname = _a.qname, message = _a.message;
+                                return ({ qname: qname, payload: message.Body });
+                            }));
+                        }
+                        // Build list of jobs we need to deal with
+                        for (_i = 0, _a = this.jobs; _i < _a.length; _i++) {
+                            job = _a[_i];
+                            jobRunTime = (now - job.start) / 1000;
+                            if (job.status === 'complete') {
+                                jobsToDelete = jobsToDeleteByQrl.get(job.qrl) || [];
+                                jobsToDelete.push(job);
+                                jobsToDeleteByQrl.set(job.qrl, jobsToDelete);
+                            }
+                            else if (job.status === 'failed') {
+                                jobsToCleanup.add(job);
+                            }
+                            else if (jobRunTime >= job.exendAtSecond) {
+                                jobsToExtend = jobsToExtendByQrl.get(job.qrl) || [];
+                                jobsToExtend.push(job);
+                                jobsToExtendByQrl.set(job.qrl, jobsToExtend);
+                                doubled = job.visibilityTimeout * 2;
+                                secondsUntilMax = maxJobSeconds - jobRunTime;
+                                secondsUntilKill = this.opt.killAfter - jobRunTime;
+                                job.visibilityTimeout = Math.min(double, secondsUntilMax, secondsUntilKill);
+                                job.extendAtSecond = jobRunTime + job.visibilityTimeout; // this is what we use next time
+                            }
+                        }
+                        debug('maintainVisibility', { jobsToDeleteByQrl: jobsToDeleteByQrl, jobsToExtendByQrl: jobsToExtendByQrl });
+                        _b = 0, jobsToExtendByQrl_1 = jobsToExtendByQrl;
+                        _f.label = 1;
+                    case 1:
+                        if (!(_b < jobsToExtendByQrl_1.length)) return [3 /*break*/, 6];
+                        _c = jobsToExtendByQrl_1[_b], qrl = _c[0], jobsToExtend = _c[1];
+                        _f.label = 2;
+                    case 2:
+                        if (!jobsToExtend.length) return [3 /*break*/, 4];
+                        entries = [];
+                        messageId = 0;
+                        while (messageId++ < 10 && jobsToExtend.length) {
+                            job = jobsToExtend.shift();
+                            entry = {
+                                Id: '' + messageId,
+                                ReceiptHandle: job.message.ReceiptHandle,
+                                VisibilityTimeout: job.visibilityTimeout
+                            };
+                            entries.push(entry);
+                        }
+                        input = { QueueUrl: qrl, Entries: entries };
+                        debug({ ChangeMessageVisibilityBatch: input });
+                        return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ChangeMessageVisibilityBatchCommand(input))];
+                    case 3:
+                        result = _f.sent();
+                        debug('ChangeMessageVisibilityBatch returned', result);
+                        this.stats.sqsCalls++;
+                        this.stats.timeoutsExtended += 10;
+                        return [3 /*break*/, 2];
+                    case 4:
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('Extended these jobs: '), jobsToExtend);
+                        }
+                        else if (!this.opt.disableLog) {
+                            console.log(JSON.stringify({
+                                event: 'EXTEND_VISIBILITY_TIMEOUTS',
+                                timestamp: now,
+                                messageIds: jobsToExtend.map(function (_a) {
+                                    var message = _a.message;
+                                    return message.MessageId;
+                                })
+                            }));
+                        }
+                        _f.label = 5;
+                    case 5:
+                        _b++;
+                        return [3 /*break*/, 1];
+                    case 6:
+                        _d = 0, jobsToDeleteByQrl_1 = jobsToDeleteByQrl;
+                        _f.label = 7;
+                    case 7:
+                        if (!(_d < jobsToDeleteByQrl_1.length)) return [3 /*break*/, 12];
+                        _e = jobsToDeleteByQrl_1[_d], qrl = _e[0], jobsToDelete = _e[1];
+                        _f.label = 8;
+                    case 8:
+                        if (!jobsToDelete.length) return [3 /*break*/, 10];
+                        entries = [];
+                        messageId = 0;
+                        while (messageId++ < 10 && jobsToDelete.length) {
+                            job = jobsToDelete.shift();
+                            entry = {
+                                Id: '' + messageId,
+                                ReceiptHandle: job.message.ReceiptHandle,
+                                VisibilityTimeout: job.visibilityTimeout
+                            };
+                            entries.push(entry);
+                        }
+                        input = { QueueUrl: qrl, Entries: entries };
+                        debug({ DeleteMessageBatch: input });
+                        return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.DeleteMessageBatchCommand(input))];
+                    case 9:
+                        result = _f.sent();
+                        this.stats.sqsCalls++;
+                        this.stats.jobsDeleted += 10;
+                        debug('DeleteMessageBatch returned', result);
+                        return [3 /*break*/, 8];
+                    case 10:
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('Deleted these finished jobs: '), jobsToDelete);
+                        }
+                        else if (!this.opt.disableLog) {
+                            console.log(JSON.stringify({
+                                event: 'DELETE_MESSAGES',
+                                timestamp: now,
+                                messageIds: jobsToDelete.map(function (_a) {
+                                    var message = _a.message;
+                                    return message.MessageId;
+                                })
+                            }));
+                        }
+                        _f.label = 11;
+                    case 11:
+                        _d++;
+                        return [3 /*break*/, 7];
+                    case 12:
+                        // Get rid of deleted and failed jobs
+                        this.jobs = this.jobs.filter(function (j) { return j.status === 'processing'; });
+                        // Check again later, unless we are shutting down and nothing's left
+                        if (this.shutdownRequested && this.stats.activeJobs === 0 && this.jobs.length === 0)
+                            return [2 /*return*/];
+                        this.maintainVisibilityTimeout = setTimeout(function () { return _this.maintainVisibility(); }, 10 * 1000);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    JobExecutor.prototype.executeJob = function (message, callback, qname, qrl) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, visibilityTimeout, job, queue, result, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        payload = this.opt.json ? JSON.parse(message.Body) : message.Body;
+                        visibilityTimeout = 30;
+                        job = {
+                            status: 'processing',
+                            start: new Date(),
+                            visibilityTimeout: 30,
+                            extendAtSecond: visibilityTimeout / 2,
+                            payload: this.opt.json ? JSON.parse(message.Body) : message.Body,
+                            message: message,
+                            callback: callback,
+                            qname: qname,
+                            qrl: qrl
+                        };
+                        debug('executeJob', job);
+                        this.jobs.push(job);
+                        this.stats.activeJobs++;
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('Executing:'), qname, chalk_1.default.blue('-->'), job.payload);
+                        }
+                        else if (!this.opt.disableLog) {
+                            console.log(JSON.stringify({
+                                event: 'MESSAGE_PROCESSING_START',
+                                timestamp: new Date(),
+                                qname: qname,
+                                messageId: message.MessageId,
+                                payload: job.payload
+                            }));
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        queue = qname.slice(this.opt.prefix.length);
+                        return [4 /*yield*/, callback(queue, payload)];
+                    case 2:
+                        result = _a.sent();
+                        debug('executeJob callback finished', { payload: payload, result: result });
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.green('SUCCESS'), message.Body);
+                        }
+                        job.status = 'complete';
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('  done'));
+                            console.error();
+                        }
+                        else if (!this.opt.disableLog) {
+                            console.log(JSON.stringify({
+                                event: 'MESSAGE_PROCESSING_COMPLETE',
+                                timestamp: new Date(),
+                                messageId: message.MessageId,
+                                payload: payload
+                            }));
+                        }
+                        this.stats.jobsSucceeded++;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        debug('exec.catch');
+                        // Fail path for job execution
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.red('FAILED'), message.Body);
+                            console.error(chalk_1.default.blue('  error : ') + err_1);
+                        }
+                        else if (!this.opt.disableLog) {
+                            // Production error logging
+                            console.log(JSON.stringify({
+                                event: 'MESSAGE_PROCESSING_FAILED',
+                                reason: 'exception thrown',
+                                qname: qname,
+                                timestamp: new Date(),
+                                messageId: message.MessageId,
+                                payload: payload,
+                                errorMessage: err_1.toString().split('\n').slice(1).join('\n').trim() || undefined,
+                                err: err_1
+                            }));
+                        }
+                        job.status = 'failed';
+                        this.stats.jobsFailed++;
+                        return [3 /*break*/, 4];
+                    case 4:
+                        this.stats.activeJobs--;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return JobExecutor;
+}());
+exports.JobExecutor = JobExecutor;

package/commonjs/src/scheduler/queueManager.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Component to manange what queues are being listened to and in what order.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueManager = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+var debug_1 = __importDefault(require("debug"));
+var qrlCache_js_1 = require("../qrlCache.js");
+var idleQueues_js_1 = require("../idleQueues.js");
+var sqs_js_1 = require("../sqs.js");
+var debug = (0, debug_1.default)('qdone:queueManager');
+var QueueManager = /** @class */ (function () {
+    function QueueManager(opt, queues, resolveSeconds) {
+        if (resolveSeconds === void 0) { resolveSeconds = 10; }
+        this.opt = opt;
+        this.queues = queues;
+        this.resolveSeconds = resolveSeconds;
+        this.selectedPairs = [];
+        this.resolveTimeout = undefined;
+        this.shutdownRequested = false;
+        this.resolveQueues();
+    }
+    QueueManager.prototype.resolveQueues = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var qnames, pairs, activePairs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.shutdownRequested)
+                            return [2 /*return*/];
+                        // Start processing
+                        if (this.opt.verbose)
+                            console.error(chalk_1.default.blue('Resolving queues: ') + this.queues.join(' '));
+                        qnames = this.queues.map(function (queue) { return (0, qrlCache_js_1.normalizeQueueName)(queue, _this.opt); });
+                        return [4 /*yield*/, (0, qrlCache_js_1.getQnameUrlPairs)(qnames, this.opt)];
+                    case 1:
+                        pairs = _a.sent();
+                        if (this.shutdownRequested)
+                            return [2 /*return*/];
+                        activePairs = [];
+                        if (!this.opt.activeOnly) return [3 /*break*/, 3];
+                        debug({ pairsBeforeCheck: pairs });
+                        return [4 /*yield*/, Promise.all(pairs.map(function (pair) { return __awaiter(_this, void 0, void 0, function () {
+                                var idle;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, (0, idleQueues_js_1.cheapIdleCheck)(pair.qname, pair.qrl, this.opt)];
+                                        case 1:
+                                            idle = (_a.sent()).idle;
+                                            if (!idle)
+                                                activePairs.push(pair);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (this.shutdownRequested)
+                            return [2 /*return*/];
+                        // Finished resolving
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('  done'));
+                            console.error();
+                        }
+                        // Figure out which queues we want to listen on, choosing between active and
+                        // all, filtering out failed queues if the user wants that
+                        this.selectedPairs = (this.opt.activeOnly ? activePairs : pairs)
+                            .filter(function (_a) {
+                            var qname = _a.qname;
+                            var suf = _this.opt.failSuffix + (_this.opt.fifo ? '.fifo' : '');
+                            var isFailQueue = qname.slice(-suf.length) === suf;
+                            var shouldInclude = _this.opt.includeFailed ? true : !isFailQueue;
+                            return shouldInclude;
+                        });
+                        // Randomize order
+                        this.selectedPairs.sort(function () { return 0.5 - Math.random(); });
+                        debug('selectedPairs', this.selectedPairs);
+                        if (this.opt.verbose) {
+                            console.error(chalk_1.default.blue('Will resolve queues again in ' + this.resolveSeconds + ' seconds'));
+                        }
+                        this.resolveTimeout = setTimeout(function () { return _this.resolveQueues(); }, this.resolveSeconds * 1000);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Return the next queue in the lineup
+    QueueManager.prototype.nextPair = function () {
+        var pair = this.selectedPairs.shift();
+        this.selectedPairs.push(pair);
+        return pair;
+    };
+    QueueManager.prototype.getPairs = function () {
+        return this.selectedPairs;
+    };
+    QueueManager.prototype.shutdown = function () {
+        clearTimeout(this.resolveTimeout);
+        this.shutdownRequested = true;
+    };
+    return QueueManager;
+}());
+exports.QueueManager = QueueManager;

package/commonjs/src/scheduler/systemMonitor.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Component to track event loop latency, which can be used as a metric for
+ * backpressure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemMonitor = void 0;
+var SystemMonitor = /** @class */ (function () {
+    function SystemMonitor(opt, smoothingFactor, reportSeconds) {
+        if (smoothingFactor === void 0) { smoothingFactor = 0.5; }
+        if (reportSeconds === void 0) { reportSeconds = 5; }
+        this.opt = opt;
+        this.smoothingFactor = smoothingFactor;
+        this.reportSeconds = reportSeconds;
+        this.measurements = {
+            setTimeout: [],
+            setImmediate: []
+        };
+        this.timeouts = {
+            setTimeout: undefined,
+            setImmediate: undefined,
+            reportLatency: undefined
+        };
+        this.measureLatencySetTimeout();
+        this.reportLatency();
+    }
+    SystemMonitor.prototype.measureLatencySetTimeout = function () {
+        var _this = this;
+        var start = new Date();
+        this.timeouts.setTimeout = setTimeout(function () {
+            var latency = new Date() - start;
+            _this.measurements.setTimeout.push(latency);
+            if (_this.measurements.setTimeout.length > 1000)
+                _this.measurements.setTimeout.shift();
+            _this.measureLatencySetTimeout();
+        });
+    };
+    SystemMonitor.prototype.getLatency = function () {
+        var results = {};
+        for (var k in this.measurements) {
+            var values = this.measurements[k];
+            results[k] = values.length ? values.reduce(function (a, b) { return a + b; }, 0) / values.length : 0;
+        }
+        return results;
+    };
+    SystemMonitor.prototype.reportLatency = function () {
+        var _this = this;
+        this.timeouts.reportLatency = setTimeout(function () {
+            var _a;
+            for (var k in _this.measurements) {
+                var values = _this.measurements[k];
+                var mean = values.length ? values.reduce(function (a, b) { return a + b; }, 0) / values.length : 0;
+                console.log((_a = {}, _a[k] = mean, _a));
+            }
+            _this.reportLatency();
+        }, this.reportSeconds * 1000);
+    };
+    SystemMonitor.prototype.shutdown = function () {
+        console.log(this.measurements);
+        for (var k in this.timeouts)
+            clearTimeout(this.timeouts[k]);
+    };
+    return SystemMonitor;
+}());
+exports.SystemMonitor = SystemMonitor;

package/index.js

@@ -1,2 +1,2 @@
 export { enqueue, enqueueBatch } from './src/enqueue.js'
-export { processMessages, requestShutdown, DoNotProcess } from './src/consumer.js'
+export { processMessages, requestShutdown } from './src/consumer.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qdone",
-  "version": "2.0.9-alpha",
+  "version": "2.0.10-alpha",
   "description": "Language agnostic job queue for SQS",
   "type": "module",
   "main": "./index.js",