qdone 1.7.0 → 2.0.0-alpha

package/commonjs/src/consumer.js

@@ -0,0 +1,483 @@
+"use strict";
+/**
+ * Consumer implementation.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.processMessages = exports.resolveQueues = exports.pollSingleQueue = exports.processMessage = exports.requestShutdown = exports.DoNotProcess = void 0;
+var client_sqs_1 = require("@aws-sdk/client-sqs");
+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 defaults_js_1 = require("./defaults.js");
+var sqs_js_1 = require("./sqs.js");
+//
+// Throwing an instance of this Error allows the processMessages callback to
+// refuse a message which then gets immediately returned to the queue.
+//
+// This has the side effect of throtting the queue since it stops polling on
+// the queue until the next queue resolution in processMessages.
+//
+// This is useful for implementing schedulers on top of qdone, for example, to
+// look at the queue name and decide whether to take on a new message.
+//
+var DoNotProcess = /** @class */ (function (_super) {
+    __extends(DoNotProcess, _super);
+    function DoNotProcess() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return DoNotProcess;
+}(Error));
+exports.DoNotProcess = DoNotProcess;
+var debug = (0, debug_1.default)('qdone:worker');
+// Global flag for shutdown request
+var shutdownRequested = false;
+var shutdownCallbacks = [];
+function requestShutdown() {
+    shutdownRequested = true;
+    for (var _i = 0, shutdownCallbacks_1 = shutdownCallbacks; _i < shutdownCallbacks_1.length; _i++) {
+        var callback = shutdownCallbacks_1[_i];
+        try {
+            callback();
+        }
+        catch (e) { }
+    }
+}
+exports.requestShutdown = requestShutdown;
+function processMessage(message, callback, qname, qrl, opt) {
+    return __awaiter(this, void 0, void 0, function () {
+        function extendTimeout() {
+            return __awaiter(this, void 0, void 0, function () {
+                var maxJobRun, jobRunTime, result, err_2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            debug('extendTimeout');
+                            maxJobRun = 12 * 60 * 60;
+                            jobRunTime = ((new Date()) - jobStart) / 1000;
+                            // Double every time, up to max
+                            visibilityTimeout = Math.min(visibilityTimeout * 2, maxJobRun - jobRunTime, opt.killAfter - jobRunTime);
+                            if (opt.verbose) {
+                                console.error(chalk_1.default.blue('  Ran for ') + jobRunTime +
+                                    chalk_1.default.blue(' seconds, requesting another ') + visibilityTimeout +
+                                    chalk_1.default.blue(' seconds'));
+                            }
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ChangeMessageVisibilityCommand({
+                                    QueueUrl: qrl,
+                                    ReceiptHandle: message.ReceiptHandle,
+                                    VisibilityTimeout: visibilityTimeout
+                                }))];
+                        case 2:
+                            result = _a.sent();
+                            debug('ChangeMessageVisibility returned', result);
+                            if (jobRunTime + visibilityTimeout >= maxJobRun ||
+                                jobRunTime + visibilityTimeout >= opt.killAfter) {
+                                if (opt.verbose)
+                                    console.error(chalk_1.default.yellow('  warning: this is our last time extension'));
+                            }
+                            else {
+                                // Extend when we get 50% of the way to timeout
+                                timeoutExtender = setTimeout(extendTimeout, visibilityTimeout * 1000 * 0.5);
+                            }
+                            return [3 /*break*/, 4];
+                        case 3:
+                            err_2 = _a.sent();
+                            debug('ChangeMessageVisibility threw', err_2);
+                            // Rejection means we're ouuta time, whatever, let the job die
+                            if (opt.verbose) {
+                                console.error(chalk_1.default.red('  failed to extend job: ') + err_2);
+                            }
+                            else if (!opt.disableLog) {
+                                // Production error logging
+                                console.log(JSON.stringify({
+                                    event: 'MESSAGE_PROCESSING_FAILED',
+                                    reason: 'ran longer than --kill-after',
+                                    timestamp: new Date(),
+                                    messageId: message.MessageId,
+                                    payload: payload,
+                                    errorMessage: err_2.toString().split('\n').slice(1).join('\n').trim() || undefined,
+                                    err: err_2
+                                }));
+                            }
+                            return [3 /*break*/, 4];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        var payload, jobStart, visibilityTimeout, timeoutExtender, queue, result, err_1, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    debug('processMessage', message, qname, qrl);
+                    payload = JSON.parse(message.Body);
+                    if (opt.verbose) {
+                        console.error(chalk_1.default.blue('  Processing payload:'), payload);
+                    }
+                    else if (!opt.disableLog) {
+                        console.log(JSON.stringify({
+                            event: 'MESSAGE_PROCESSING_START',
+                            timestamp: new Date(),
+                            messageId: message.MessageId,
+                            payload: payload
+                        }));
+                    }
+                    jobStart = new Date();
+                    visibilityTimeout = 30 // this should be the queue timeout
+                    ;
+                    // Extend when we get 50% of the way to timeout
+                    timeoutExtender = setTimeout(extendTimeout, visibilityTimeout * 1000 * 0.5);
+                    debug('timeout', visibilityTimeout * 1000 * 0.5);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 7]);
+                    queue = qname.slice(opt.prefix.length);
+                    return [4 /*yield*/, callback(queue, payload)];
+                case 2:
+                    result = _a.sent();
+                    debug('processMessage callback finished', { payload: payload, result: result });
+                    clearTimeout(timeoutExtender);
+                    if (opt.verbose) {
+                        console.error(chalk_1.default.green('  SUCCESS'));
+                        console.error(chalk_1.default.blue('  cleaning up (removing message) ...'));
+                    }
+                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.DeleteMessageCommand({
+                            QueueUrl: qrl,
+                            ReceiptHandle: message.ReceiptHandle
+                        }))];
+                case 3:
+                    _a.sent();
+                    if (opt.verbose) {
+                        console.error(chalk_1.default.blue('  done'));
+                        console.error();
+                    }
+                    else if (!opt.disableLog) {
+                        console.log(JSON.stringify({
+                            event: 'MESSAGE_PROCESSING_COMPLETE',
+                            timestamp: new Date(),
+                            messageId: message.MessageId,
+                            payload: payload
+                        }));
+                    }
+                    return [2 /*return*/, { noJobs: 0, jobsSucceeded: 1, jobsFailed: 0 }];
+                case 4:
+                    err_1 = _a.sent();
+                    debug('exec.catch');
+                    clearTimeout(timeoutExtender);
+                    if (!(err_1 instanceof DoNotProcess)) return [3 /*break*/, 6];
+                    if (opt.verbose) {
+                        console.error(chalk_1.default.blue('  callback ') + chalk_1.default.yellow('REFUSED'));
+                        console.error(chalk_1.default.blue('  cleaning up (removing message) ...'));
+                    }
+                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ChangeMessageVisibilityCommand({
+                            QueueUrl: qrl,
+                            ReceiptHandle: message.ReceiptHandle,
+                            VisibilityTimeout: 0
+                        }))];
+                case 5:
+                    result = _a.sent();
+                    debug('ChangeMessageVisibility returned', result);
+                    return [2 /*return*/, { noJobs: 1, jobsSucceeded: 0, jobsFailed: 0 }];
+                case 6:
+                    // Fail path for job execution
+                    if (opt.verbose) {
+                        console.error(chalk_1.default.red('  FAILED'));
+                        console.error(chalk_1.default.blue('  error : ') + err_1);
+                    }
+                    else if (!opt.disableLog) {
+                        // Production error logging
+                        console.log(JSON.stringify({
+                            event: 'MESSAGE_PROCESSING_FAILED',
+                            reason: 'exception thrown',
+                            timestamp: new Date(),
+                            messageId: message.MessageId,
+                            payload: payload,
+                            errorMessage: err_1.toString().split('\n').slice(1).join('\n').trim() || undefined,
+                            err: err_1
+                        }));
+                    }
+                    return [2 /*return*/, { noJobs: 0, jobsSucceeded: 0, jobsFailed: 1 }];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.processMessage = processMessage;
+//
+// Pull work off of a single queue
+//
+function pollSingleQueue(qname, qrl, callback, opt) {
+    return __awaiter(this, void 0, void 0, function () {
+        var params, response, message;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    debug('pollSingleQueue', { qname: qname, qrl: qrl, callback: callback, opt: opt });
+                    params = {
+                        AttributeNames: ['All'],
+                        MaxNumberOfMessages: 1,
+                        MessageAttributeNames: ['All'],
+                        QueueUrl: qrl,
+                        VisibilityTimeout: 30,
+                        WaitTimeSeconds: opt.waitTime
+                    };
+                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ReceiveMessageCommand(params))];
+                case 1:
+                    response = _a.sent();
+                    debug('ReceiveMessage response', response);
+                    if (shutdownRequested)
+                        return [2 /*return*/, { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 }];
+                    if (response.Messages) {
+                        message = response.Messages[0];
+                        if (opt.verbose)
+                            console.error(chalk_1.default.blue('  Found message ' + message.MessageId));
+                        return [2 /*return*/, processMessage(message, callback, qname, qrl, opt)];
+                    }
+                    else {
+                        return [2 /*return*/, { noJobs: 1, jobsSucceeded: 0, jobsFailed: 0 }];
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.pollSingleQueue = pollSingleQueue;
+//
+// Resolve a set of queues
+//
+function resolveQueues(queues, opt) {
+    return __awaiter(this, void 0, void 0, function () {
+        var qnames, pairs, activePairs, selectedPairs;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // Start processing
+                    if (opt.verbose)
+                        console.error(chalk_1.default.blue('Resolving queues: ') + queues.join(' '));
+                    qnames = queues.map(function (queue) { return (0, qrlCache_js_1.normalizeQueueName)(queue, opt); });
+                    return [4 /*yield*/, (0, qrlCache_js_1.getQnameUrlPairs)(qnames, opt)
+                        // Figure out which pairs are active
+                    ];
+                case 1:
+                    pairs = _a.sent();
+                    activePairs = [];
+                    if (!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, opt)];
+                                    case 1:
+                                        idle = (_a.sent()).idle;
+                                        if (!idle)
+                                            activePairs.push(pair);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    // Finished resolving
+                    debug('getQnameUrlPairs.then');
+                    if (opt.verbose) {
+                        console.error(chalk_1.default.blue('  done'));
+                        console.error();
+                    }
+                    selectedPairs = (opt.activeOnly ? activePairs : pairs)
+                        .filter(function (_a) {
+                        var qname = _a.qname;
+                        var suf = opt.failSuffix + (opt.fifo ? '.fifo' : '');
+                        var isFailQueue = qname.slice(-suf.length) === suf;
+                        var shouldInclude = opt.includeFailed ? true : !isFailQueue;
+                        return shouldInclude;
+                    });
+                    return [2 /*return*/, selectedPairs];
+            }
+        });
+    });
+}
+exports.resolveQueues = resolveQueues;
+//
+// Consumer
+//
+function processMessages(queues, callback, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        // Callback to help facilitate better UX at shutdown
+        function shutdownCallback() {
+            if (opt.verbose) {
+                debug({ activeLoops: activeLoops });
+                var activeQueues = Object.keys(activeLoops).filter(function (q) { return activeLoops[q]; }).map(function (q) { return q.slice(opt.prefix.length); });
+                if (activeQueues.length) {
+                    console.error(chalk_1.default.blue('Waiting for work to finish on the following queues: ') + activeQueues.join(chalk_1.default.blue(', ')));
+                }
+                clearTimeout(delayTimeout);
+            }
+        }
+        // Listen to a queue until it is out of messages
+        function listenLoop(qname, qrl) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, noJobs, jobsSucceeded, jobsFailed, err_3;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 2, 3, 4]);
+                            if (shutdownRequested)
+                                return [2 /*return*/];
+                            if (opt.verbose) {
+                                console.error(chalk_1.default.blue('Looking for work on ') +
+                                    qname.slice(opt.prefix.length) +
+                                    chalk_1.default.blue(' (' + qrl + ')'));
+                            }
+                            return [4 /*yield*/, pollSingleQueue(qname, qrl, callback, opt)];
+                        case 1:
+                            _a = _b.sent(), noJobs = _a.noJobs, jobsSucceeded = _a.jobsSucceeded, jobsFailed = _a.jobsFailed;
+                            stats.noJobs += noJobs;
+                            stats.jobsFailed += jobsFailed;
+                            stats.jobsSucceeded += jobsSucceeded;
+                            // No work? return to outer loop
+                            if (noJobs)
+                                return [2 /*return*/];
+                            // Otherwise keep going
+                            return [2 /*return*/, listenLoop(qname, qrl)];
+                        case 2:
+                            err_3 = _b.sent();
+                            // TODO: Sentry
+                            console.error(chalk_1.default.red('  ERROR in listenLoop'));
+                            console.error(chalk_1.default.blue('  error : ') + err_3);
+                            return [3 /*break*/, 4];
+                        case 3:
+                            delete activeLoops[qname];
+                            return [7 /*endfinally*/];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        var opt, stats, activeLoops, delayTimeout, delay, start, selectedPairs, _i, selectedPairs_1, _a, qname, qrl, msSoFar, msUntilNextResolve;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    opt = (0, defaults_js_1.getOptionsWithDefaults)(options);
+                    debug('processMessages', { queues: queues, callback: callback, options: options, opt: opt });
+                    stats = { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 };
+                    activeLoops = {};
+                    delay = function (ms) { return new Promise(function (resolve) {
+                        delayTimeout = setTimeout(resolve, ms);
+                    }); };
+                    shutdownCallbacks.push(shutdownCallback);
+                    _b.label = 1;
+                case 1:
+                    if (!!shutdownRequested) return [3 /*break*/, 5];
+                    start = new Date();
+                    return [4 /*yield*/, resolveQueues(queues, opt)];
+                case 2:
+                    selectedPairs = _b.sent();
+                    if (shutdownRequested)
+                        return [3 /*break*/, 5];
+                    // But only if we have queues to listen on
+                    if (selectedPairs.length) {
+                        // Randomize order
+                        selectedPairs.sort(function () { return 0.5 - Math.random(); });
+                        if (opt.verbose) {
+                            console.error(chalk_1.default.blue('Listening to queues (in this order):'));
+                            console.error(selectedPairs.map(function (_a) {
+                                var qname = _a.qname, qrl = _a.qrl;
+                                return '  ' + qname.slice(opt.prefix.length) + chalk_1.default.blue(' - ' + qrl);
+                            }).join('\n'));
+                            console.error();
+                        }
+                        // Launch listen loop for each queue
+                        for (_i = 0, selectedPairs_1 = selectedPairs; _i < selectedPairs_1.length; _i++) {
+                            _a = selectedPairs_1[_i], qname = _a.qname, qrl = _a.qrl;
+                            if (!activeLoops[qname])
+                                activeLoops[qname] = listenLoop(qname, qrl);
+                        }
+                    }
+                    if (!!shutdownRequested) return [3 /*break*/, 4];
+                    msSoFar = Math.max(0, new Date() - start);
+                    msUntilNextResolve = Math.max(0, opt.waitTime * 1000 - msSoFar);
+                    debug({ msSoFar: msSoFar, msUntilNextResolve: msUntilNextResolve });
+                    if (!msUntilNextResolve) return [3 /*break*/, 4];
+                    if (opt.verbose)
+                        console.error(chalk_1.default.blue('Will resolve queues again in ' + Math.round(msUntilNextResolve / 1000) + ' seconds'));
+                    return [4 /*yield*/, delay(msUntilNextResolve)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4: return [3 /*break*/, 1];
+                case 5: 
+                // Wait on all work to finish
+                // shutdownCallback()
+                return [4 /*yield*/, Promise.all(Object.values(activeLoops))];
+                case 6:
+                    // Wait on all work to finish
+                    // shutdownCallback()
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.processMessages = processMessages;
+debug('loaded');

package/commonjs/src/defaults.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupVerbose = exports.setupAWS = exports.getOptionsWithDefaults = exports.defaults = void 0;
+/**
+ * Default options for qdone. Accepts a command line options object and
+ * returns nicely-named options.
+ */
+var uuid_1 = require("uuid");
+exports.defaults = Object.freeze({
+    // Shared
+    prefix: 'qdone_',
+    failSuffix: '_failed',
+    region: 'us-east-1',
+    quiet: false,
+    verbose: false,
+    cache: false,
+    cacheUri: undefined,
+    cachePrefix: 'qdone:',
+    cacheTtlSeconds: 10,
+    fifo: false,
+    disableLog: false,
+    includeFailed: false,
+    // Enqueue
+    groupId: (0, uuid_1.v1)(),
+    groupIdPerMessage: false,
+    deduplicationId: (0, uuid_1.v1)(),
+    messageRetentionPeriod: 1209600,
+    delay: 0,
+    dlq: false,
+    dlqSuffix: '_dead',
+    dlqAfter: 3,
+    // Worker
+    waitTime: 20,
+    killAfter: 30,
+    archive: false,
+    activeOnly: false,
+    // Idle Queues
+    idleFor: 60,
+    delete: false,
+    unpair: false
+});
+/**
+ * This function should be called by each exposed API entry point on the
+ * options passed in from the caller. It supports options named in camelCase
+ * and also in command-line-style returned by our parsers.
+ *
+ * By convention, we name the variable "options" if it comes from the user
+ * and "opt" if it has already passed through this function.
+ */
+function getOptionsWithDefaults(options) {
+    // For API invocations don't force caller to supply default options
+    if (!options)
+        options = {};
+    // Activate DLQ if any option is set
+    var dlq = options.dlq || !!(options['dlq-suffix'] || options['dlq-after'] || options['dlq-name']);
+    var opt = {
+        // Shared
+        prefix: options.prefix === '' ? options.prefix : (options.prefix || exports.defaults.prefix),
+        failSuffix: options.failSuffix || options['fail-suffix'] || exports.defaults.failSuffix,
+        region: options.region || process.env.AWS_REGION || exports.defaults.region,
+        quiet: options.quiet || exports.defaults.quiet,
+        verbose: options.verbose || exports.defaults.verbose,
+        fifo: options.fifo || exports.defaults.fifo,
+        sentryDsn: options.sentryDsn || options['sentry-dsn'],
+        disableLog: options.disableLog || options['disable-log'] || exports.defaults.disableLog,
+        // Cache
+        cacheUri: options.cacheUri || options['cache-uri'] || exports.defaults.cacheUri,
+        cachePrefix: options.cachePrefix || options['cache-prefix'] || exports.defaults.cachePrefix,
+        cacheTtlSeconds: options.cacheTtlSeconds || options['cache-ttl-seconds'] || exports.defaults.cacheTtlSeconds,
+        // Enqueue
+        groupId: options.groupId || options['group-id'] || exports.defaults.groupId,
+        groupIdPerMessage: false,
+        deduplicationId: options.deduplicationId || options['deduplication-id'] || exports.defaults.deduplicationId,
+        messageRetentionPeriod: options.messageRetentionPeriod || options['message-retention-period'] || exports.defaults.messageRetentionPeriod,
+        delay: options.delay || exports.defaults.delay,
+        dlq: dlq || exports.defaults.dlq,
+        dlqSuffix: options.dlqSuffix || options['dlq-suffix'] || exports.defaults.dlqSuffix,
+        dlqAfter: options.dlqAfter || options['dlq-after'] || exports.defaults.dlqAfter,
+        tags: options.tags || undefined,
+        // Worker
+        waitTime: options.waitTime || options['wait-time'] || exports.defaults.waitTime,
+        killAfter: options.killAfter || options['kill-after'] || exports.defaults.killAfter,
+        archive: options.archive || exports.defaults.archive,
+        activeOnly: options.activeOnly || options['active-only'] || exports.defaults.activeOnly,
+        includeFailed: options.includeFailed || options['include-failed'] || exports.defaults.includeFailed,
+        // Idle Queues
+        idleFor: options.idleFor || options['idle-for'] || exports.defaults.idleFor,
+        delete: options.delete || exports.defaults.delete,
+        unpair: options.delete || exports.defaults.unpair
+    };
+    process.env.AWS_REGION = opt.region;
+    // TODO: validate options
+    return opt;
+}
+exports.getOptionsWithDefaults = getOptionsWithDefaults;
+function setupAWS(options) {
+    var opt = getOptionsWithDefaults(options);
+    process.env.AWS_REGION = opt.region;
+}
+exports.setupAWS = setupAWS;
+function setupVerbose(options) {
+    var verbose = options.verbose || (process.stderr.isTTY && !options.quiet);
+    var quiet = options.quiet || (!process.stderr.isTTY && !options.verbose);
+    options.verbose = verbose;
+    options.quiet = quiet;
+}
+exports.setupVerbose = setupVerbose;