@bitblit/ratchet-aws 4.0.80-alpha

package/dist/cjs/ses/mailer.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mailer = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const client_ses_1 = require("@aws-sdk/client-ses");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const luxon_1 = require("luxon");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+const ratchet_common_5 = require("@bitblit/ratchet-common");
+class Mailer {
+    constructor(ses, config = {}) {
+        this.ses = ses;
+        this.config = config;
+        ratchet_common_5.RequireRatchet.notNullOrUndefined(this.ses);
+        if (!!config.archive && !config.archive.getDefaultBucket()) {
+            throw new Error('If archive specified, must set a default bucket');
+        }
+    }
+    async fillEmailBody(rts, context, htmlTemplateName, txtTemplateName = null, layoutName = null, partialNames = null) {
+        ratchet_common_5.RequireRatchet.notNullOrUndefined(htmlTemplateName);
+        if (!this.config.templateRenderer) {
+            ratchet_common_3.ErrorRatchet.throwFormattedErr('Cannot use fill body if template renderer not set');
+        }
+        rts.htmlMessage = await this.config.templateRenderer.renderTemplate(htmlTemplateName, context, layoutName, partialNames);
+        rts.txtMessage = !!txtTemplateName ? await this.config.templateRenderer.renderTemplate(txtTemplateName, context) : null;
+        return rts;
+    }
+    async fillEmailBodyAndSend(rts, context, htmlTemplateName, txtTemplateName = null, layoutName = null, partialNames = null) {
+        const newVal = await this.fillEmailBody(rts, context, htmlTemplateName, txtTemplateName, layoutName, partialNames);
+        const rval = await this.sendEmail(newVal);
+        return rval;
+    }
+    filterEmailsToValid(emails) {
+        const rval = (emails || []).filter((e) => {
+            if (!this.config.allowedDestinationEmails || this.config.allowedDestinationEmails.length == 0) {
+                return true;
+            }
+            else {
+                const match = this.config.allowedDestinationEmails.find((s) => s.test(e));
+                return !!match;
+            }
+        });
+        return rval;
+    }
+    async archiveEmailIfConfigured(rts) {
+        let rval = false;
+        if (!!rts && !!this.config.archive && !rts.doNotArchive) {
+            ratchet_common_1.Logger.debug('Archiving outbound email to : %j', rts.destinationAddresses);
+            let targetPath = ratchet_common_2.StringRatchet.trimToEmpty(this.config.archivePrefix);
+            if (!targetPath.endsWith('/')) {
+                targetPath += '/';
+            }
+            const now = luxon_1.DateTime.utc();
+            targetPath +=
+                'year=' +
+                    now.toFormat('yyyy') +
+                    '/month=' +
+                    now.toFormat('MM') +
+                    '/day=' +
+                    now.toFormat('dd') +
+                    '/hour=' +
+                    now.toFormat('HH') +
+                    '/' +
+                    now.toFormat('mm_ss__SSS');
+            targetPath += '.json';
+            try {
+                await this.config.archive.writeObjectToCacheFile(targetPath, rts);
+                rval = true;
+            }
+            catch (err) {
+                ratchet_common_1.Logger.warn('Failed to archive email %s %j : %s', targetPath, rts, err);
+            }
+        }
+        return rval;
+    }
+    applyLimitsToBodySizesIfAnyInPlace(rts) {
+        if (this.config.maxMessageBodySizeInBytes) {
+            const txtSize = ratchet_common_2.StringRatchet.trimToEmpty(rts.txtMessage).length;
+            const htmlSize = ratchet_common_2.StringRatchet.trimToEmpty(rts.htmlMessage).length;
+            const totalSize = txtSize + htmlSize;
+            if (totalSize > this.config.maxMessageBodySizeInBytes) {
+                ratchet_common_1.Logger.warn('Max message size is %d but size is %d - converting', this.config.maxMessageBodySizeInBytes, totalSize);
+                rts.attachments = rts.attachments || [];
+                if (ratchet_common_2.StringRatchet.trimToNull(rts.txtMessage)) {
+                    const txtAttach = {
+                        filename: 'original-txt-body.txt',
+                        contentType: 'text/plain',
+                        base64Data: ratchet_common_4.Base64Ratchet.generateBase64VersionOfString(rts.txtMessage),
+                    };
+                    rts.attachments.push(txtAttach);
+                }
+                if (ratchet_common_2.StringRatchet.trimToNull(rts.htmlMessage)) {
+                    const htmlAttach = {
+                        filename: 'original-html-body.html',
+                        contentType: 'text/html',
+                        base64Data: ratchet_common_4.Base64Ratchet.generateBase64VersionOfString(rts.htmlMessage),
+                    };
+                    rts.attachments.push(htmlAttach);
+                }
+                rts.htmlMessage = null;
+                rts.txtMessage = 'The message was too large and was converted to attachment(s).  Please see attached files for content';
+            }
+        }
+    }
+    applyLimitsToAttachmentSizesIfAnyInPlace(rts) {
+        if (this.config.maxAttachmentSizeInBase64Bytes) {
+            const filtered = [];
+            if (rts.attachments) {
+                rts.attachments.forEach((a) => {
+                    if (a.base64Data && a.base64Data.length < this.config.maxAttachmentSizeInBase64Bytes) {
+                        filtered.push(a);
+                    }
+                    else {
+                        ratchet_common_1.Logger.warn('Removing too-large attachment : %s : %s : %d', a.filename, a.contentType, a.base64Data.length);
+                        filtered.push({
+                            filename: 'attachment-removed-notice-' + ratchet_common_2.StringRatchet.createRandomHexString(4) + '.txt',
+                            contentType: 'text/plain',
+                            base64Data: ratchet_common_4.Base64Ratchet.generateBase64VersionOfString('Attachment ' +
+                                a.filename +
+                                ' of type ' +
+                                a.contentType +
+                                ' was removed since it was ' +
+                                a.base64Data.length +
+                                ' bytes but max allowed is ' +
+                                this.config.maxAttachmentSizeInBase64Bytes),
+                        });
+                    }
+                });
+            }
+            rts.attachments = filtered;
+        }
+    }
+    async sendEmail(inRts) {
+        ratchet_common_5.RequireRatchet.notNullOrUndefined(inRts, 'RTS must be defined');
+        ratchet_common_5.RequireRatchet.notNullOrUndefined(inRts.destinationAddresses, 'Destination addresses must be defined');
+        let rval = null;
+        let toAddresses = this.filterEmailsToValid(inRts.destinationAddresses);
+        const autoBcc = inRts.doNotAutoBcc ? [] : this.config.autoBccAddresses || [];
+        const bccAddresses = (inRts.bccAddresses || []).concat(autoBcc);
+        if (toAddresses.length === 0 && bccAddresses.length > 0) {
+            ratchet_common_1.Logger.debug('Destination emails filtered to none but BCC defined, copying BCC');
+            toAddresses = bccAddresses;
+        }
+        const rts = Object.assign({}, inRts);
+        rts.srcDestinationAddresses = inRts.destinationAddresses;
+        rts.srcBccAddresses = inRts.bccAddresses;
+        rts.destinationAddresses = toAddresses;
+        rts.bccAddresses = bccAddresses;
+        this.applyLimitsToBodySizesIfAnyInPlace(rts);
+        this.applyLimitsToAttachmentSizesIfAnyInPlace(rts);
+        await this.archiveEmailIfConfigured(rts);
+        if (rts.destinationAddresses.length === 0) {
+            ratchet_common_1.Logger.info('After cleaning email lists, no destination addresses left - not sending email');
+        }
+        else {
+            const toLine = 'To: ' + rts.destinationAddresses.join(', ') + '\n';
+            const bccLine = !!rts.bccAddresses && rts.bccAddresses.length > 0 ? 'Bcc: ' + rts.bccAddresses.join(', ') + '\n' : '';
+            try {
+                const from = rts.fromAddress || this.config.defaultSendingAddress;
+                const boundary = 'NextPart';
+                const altBoundary = 'AltPart';
+                let rawMail = 'From: ' + from + '\n';
+                rawMail += toLine;
+                rawMail += bccLine;
+                rawMail += 'Subject: ' + rts.subject + '\n';
+                rawMail += 'MIME-Version: 1.0\n';
+                rawMail += 'Content-Type: multipart/mixed; boundary="' + boundary + '"\n';
+                rawMail += '\n\n--' + boundary + '\n';
+                rawMail += 'Content-Type: multipart/alternative; boundary="' + altBoundary + '"\n';
+                if (!!ratchet_common_2.StringRatchet.trimToNull(rts.htmlMessage)) {
+                    rawMail += '\n\n--' + altBoundary + '\n';
+                    rawMail += 'Content-Type: text/html; charset="UTF-8"\n\n';
+                    rawMail += rts.htmlMessage;
+                }
+                if (!!ratchet_common_2.StringRatchet.trimToNull(rts.txtMessage)) {
+                    rawMail += '\n\n--' + altBoundary + '\n';
+                    rawMail += 'Content-Type: text/plain\n\n';
+                    rawMail += rts.txtMessage;
+                }
+                rawMail += '\n\n--' + altBoundary + '--\n';
+                if (rts.attachments) {
+                    rts.attachments.forEach((a) => {
+                        rawMail += '\n\n--' + boundary + '\n';
+                        rawMail += 'Content-Type: ' + a.contentType + '; name="' + a.filename + '"\n';
+                        rawMail += 'Content-Transfer-Encoding: base64\n';
+                        rawMail += 'Content-Disposition: attachment\n\n';
+                        rawMail += a.base64Data.replace(/([^\0]{76})/g, '$1\n') + '\n\n';
+                    });
+                }
+                rawMail += '\n\n--' + boundary + '--\n';
+                const params = {
+                    RawMessage: { Data: new TextEncoder().encode(rawMail) },
+                };
+                rval = await this.ses.send(new client_ses_1.SendRawEmailCommand(params));
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Error while processing email: %s', err, err);
+            }
+        }
+        return rval;
+    }
+    static validEmail(email) {
+        return email !== null && Mailer.EMAIL.test(email);
+    }
+}
+exports.Mailer = Mailer;
+Mailer.EMAIL = new RegExp('.+@.+\\.[a-z]+');

package/dist/cjs/ses/ratchet-template-renderer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ses/ready-to-send-email.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ses/remote-handlebars-template-renderer.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteHandlebarsTemplateRenderer = void 0;
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const handlebars_layouts_1 = tslib_1.__importDefault(require("handlebars-layouts"));
+class RemoteHandlebarsTemplateRenderer {
+    constructor(prefix = '', suffix = '', maxCacheTemplates = 10) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.maxCacheTemplates = maxCacheTemplates;
+        if (this.maxCacheTemplates > 0) {
+            this.cache = new Map();
+        }
+    }
+    async renderTemplate(templateName, context, layoutName = null) {
+        return this.renderRemoteTemplate(templateName, context, layoutName);
+    }
+    async renderRemoteTemplate(templateName, inContext, layoutName = null) {
+        const template = await this.fetchTemplate(templateName);
+        const layoutText = !!layoutName ? await this.fetchTemplateText(layoutName) : null;
+        if (!!layoutText) {
+            await handlebars_layouts_1.default.register(handlebars_1.default);
+            handlebars_1.default.registerPartial(layoutName, layoutText);
+        }
+        const context = inContext || {};
+        const result = !!template ? template(context) : null;
+        return result;
+    }
+    async renderTemplateDirect(templateText, context, layoutName = null) {
+        const template = handlebars_1.default.compile(templateText);
+        const result = template(context);
+        return result;
+    }
+    async fetchTemplate(templateName) {
+        let rval = null;
+        try {
+            if (!!this.cache && this.cache.has(templateName)) {
+                ratchet_common_2.Logger.silly('Cache hit for template : %s', templateName);
+                rval = this.cache.get(templateName);
+            }
+            else {
+                ratchet_common_2.Logger.debug('Cache miss for template : %s', templateName);
+                const templateText = await this.fetchTemplateText(templateName);
+                if (!!templateText) {
+                    rval = handlebars_1.default.compile(templateText);
+                    if (!!this.cache && !!rval) {
+                        this.cache.set(templateName, rval);
+                        if (this.cache.size > this.maxCacheTemplates) {
+                            this.cache.delete(Array.from(this.cache.keys())[0]);
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            ratchet_common_2.Logger.warn('Could not fetch and compile template : %s : %s', templateName, err, err);
+            rval = null;
+        }
+        return rval;
+    }
+    async fetchTemplateText(templateName) {
+        let rval = null;
+        const url = ratchet_common_1.StringRatchet.trimToEmpty(this.prefix) + templateName + ratchet_common_1.StringRatchet.trimToEmpty(this.suffix);
+        try {
+            const resp = await (0, cross_fetch_1.default)(url);
+            rval = await resp.text();
+        }
+        catch (err) {
+            ratchet_common_2.Logger.warn('Could not fetch url : %s : %s', url, err, err);
+            rval = null;
+        }
+        return rval;
+    }
+}
+exports.RemoteHandlebarsTemplateRenderer = RemoteHandlebarsTemplateRenderer;

package/dist/cjs/ses/resolved-ready-to-send-email.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/sns/sns-ratchet.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnsRatchet = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const client_sns_1 = require("@aws-sdk/client-sns");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class SnsRatchet {
+    constructor(sns = new client_sns_1.SNSClient({ region: 'us-east-1' }), topicArn) {
+        this.sns = sns;
+        this.topicArn = topicArn;
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(this.sns, 'sns');
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(this.topicArn, 'topicArn');
+    }
+    async sendMessage(inMsg, suppressErrors = false) {
+        let result = null;
+        try {
+            const safeInMsg = inMsg ? inMsg : 'NO-MESSAGE-PROVIDED';
+            const msg = typeof safeInMsg === 'string' ? safeInMsg : JSON.stringify(safeInMsg);
+            const params = {
+                TopicArn: this.topicArn,
+                Message: msg,
+            };
+            ratchet_common_1.Logger.debug('Sending via SNS : %j', params);
+            result = await this.sns.send(new client_sns_1.PublishCommand(params));
+        }
+        catch (err) {
+            if (suppressErrors) {
+                ratchet_common_1.Logger.error('Failed to fire SNS notification : %j : %s', inMsg, err);
+            }
+            else {
+                throw err;
+            }
+        }
+        return result;
+    }
+    async conditionallySendMessage(inMsg, condition, suppressErrors = false) {
+        let rval = null;
+        if (condition) {
+            rval = await this.sendMessage(inMsg, suppressErrors);
+        }
+        else {
+            ratchet_common_1.Logger.info('Not sending message, condition was false : %j', inMsg);
+        }
+        return rval;
+    }
+}
+exports.SnsRatchet = SnsRatchet;

package/dist/cjs/sync-lock/dynamo-db-sync-lock.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDbSyncLock = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+class DynamoDbSyncLock {
+    constructor(ratchet, tableName) {
+        this.ratchet = ratchet;
+        this.tableName = tableName;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet, 'ratchet');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(this.tableName), 'tableName');
+    }
+    async acquireLock(lockKey, expirationSeconds = 30) {
+        let rval = false;
+        if (!!lockKey && !!expirationSeconds) {
+            const nowSeconds = Math.floor(new Date().getTime() / 1000);
+            const row = {
+                lockingKey: lockKey,
+                timestamp: nowSeconds,
+                expires: nowSeconds + expirationSeconds,
+            };
+            const params = {
+                Item: row,
+                ReturnConsumedCapacity: 'TOTAL',
+                TableName: this.tableName,
+                ConditionExpression: 'attribute_not_exists(lockingKey)',
+            };
+            try {
+                const pio = await this.ratchet.getDDB().send(new client_dynamodb_1.PutItemCommand(params));
+                rval = true;
+            }
+            catch (err) {
+                if (String(err).indexOf('ConditionalCheckFailedException') > -1) {
+                    ratchet_common_1.Logger.silly('Unable to acquire lock on %s', lockKey);
+                }
+            }
+        }
+        return rval;
+    }
+    async releaseLock(lockKey) {
+        if (ratchet_common_1.StringRatchet.trimToNull(lockKey)) {
+            try {
+                const dio = await this.ratchet.simpleDelete(this.tableName, { lockingKey: lockKey });
+                ratchet_common_1.Logger.silly('Released lock %s : %s', lockKey, dio);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.warn('Failed to release lock key : %s : %s', lockKey, err, err);
+            }
+        }
+    }
+    async clearExpiredSyncLocks() {
+        const nowSeconds = Math.floor(new Date().getTime() / 1000);
+        const scan = {
+            TableName: this.tableName,
+            FilterExpression: 'expires < :now',
+            ExpressionAttributeValues: {
+                ':now': nowSeconds,
+            },
+        };
+        const vals = await this.ratchet.fullyExecuteScan(scan);
+        const keysOnly = vals.map((v) => {
+            const next = { lockingKey: v['lockingKey'] };
+            return next;
+        });
+        const removed = await this.ratchet.deleteAllInBatches(this.tableName, keysOnly, 25);
+        return removed;
+    }
+}
+exports.DynamoDbSyncLock = DynamoDbSyncLock;

package/dist/cjs/sync-lock/memory-sync-lock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySyncLock = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class MemorySyncLock {
+    constructor() {
+        this._locks = new Map();
+    }
+    async acquireLock(lockKey, expirationSeconds = 30) {
+        let rval = false;
+        if (ratchet_common_1.StringRatchet.trimToNull(lockKey)) {
+            const now = Date.now();
+            const val = this._locks.get(lockKey);
+            if (!val || val < now) {
+                this._locks.set(lockKey, now + expirationSeconds * 1000);
+                rval = true;
+            }
+        }
+        return rval;
+    }
+    async releaseLock(lockKey) {
+        if (ratchet_common_1.StringRatchet.trimToNull(lockKey)) {
+            this._locks.delete(lockKey);
+        }
+    }
+    async clearExpiredSyncLocks() {
+        const toRemove = [];
+        const now = Date.now();
+        this._locks.forEach((v, k) => {
+            if (v < now) {
+                toRemove.push(k);
+            }
+        });
+        toRemove.forEach((k) => {
+            this._locks.delete(k);
+        });
+        return toRemove.length;
+    }
+}
+exports.MemorySyncLock = MemorySyncLock;

package/dist/cjs/sync-lock/sync-lock-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es/batch/aws-batch-background-processor.js

@@ -0,0 +1,40 @@
+import { DateTime } from 'luxon';
+import { ErrorRatchet, Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+export class AwsBatchBackgroundProcessor {
+    constructor(batchRatchet, validTaskNames) {
+        this.batchRatchet = batchRatchet;
+        this.validTaskNames = validTaskNames;
+        RequireRatchet.notNullOrUndefined(this.batchRatchet, 'batchRatchet');
+        RequireRatchet.notNullOrUndefined(this.batchRatchet.batchClient, 'batchRatchet.batchClient');
+        RequireRatchet.notNullOrUndefined(this.batchRatchet.defaultJobDefinition, 'batchRatchet.defaultJobDefinition');
+        RequireRatchet.notNullOrUndefined(this.batchRatchet.defaultQueueName, 'batchRatchet.defaultQueueName');
+    }
+    async scheduleBackgroundTask(taskName, data = {}, meta = {}) {
+        if (this.validTaskNames &&
+            this.validTaskNames.length &&
+            (!StringRatchet.trimToNull(taskName) || !this.validTaskNames.includes(taskName))) {
+            ErrorRatchet.throwFormattedErr('Cannot start task %s - not found in valid task list', taskName);
+        }
+        Logger.info('Submitting background task to AWS batch: %s %j %s', taskName, data, this.batchRatchet.defaultQueueName);
+        let rval = null;
+        const jobName = `${this.batchRatchet.defaultJobDefinition}-${taskName}_${DateTime.utc().toFormat('yyyy-MM-dd-HH-mm')}`;
+        const options = {
+            jobName: jobName,
+            jobDefinition: this.batchRatchet.defaultJobDefinition,
+            jobQueue: this.batchRatchet.defaultQueueName,
+            parameters: {
+                taskName,
+                taskData: JSON.stringify(data),
+                taskMetadata: JSON.stringify(meta),
+            },
+        };
+        try {
+            rval = await this.batchRatchet.scheduleJob(options);
+            Logger.info('Job %s(%s) submitted', rval.jobName, rval.jobId);
+        }
+        catch (err) {
+            Logger.error('Cannot submit batch job taskName: %s jobDef: %s queue: %s jobName: %s data: %j', taskName, this.batchRatchet.defaultJobDefinition, this.batchRatchet.defaultQueueName, jobName, data, err);
+        }
+        return rval;
+    }
+}

package/dist/es/batch/aws-batch-ratchet.js

@@ -0,0 +1,51 @@
+import { ListJobsCommand, SubmitJobCommand, } from '@aws-sdk/client-batch';
+import { Logger, RequireRatchet } from '@bitblit/ratchet-common';
+export class AwsBatchRatchet {
+    constructor(_batchClient, _defaultQueueName, _defaultJobDefinition) {
+        this._batchClient = _batchClient;
+        this._defaultQueueName = _defaultQueueName;
+        this._defaultJobDefinition = _defaultJobDefinition;
+    }
+    get batchClient() {
+        return this._batchClient;
+    }
+    get defaultQueueName() {
+        return this._defaultQueueName;
+    }
+    get defaultJobDefinition() {
+        return this._defaultJobDefinition;
+    }
+    async scheduleJob(options) {
+        Logger.info('Submitting batch job %s', options.jobName);
+        try {
+            const rval = await this._batchClient.send(new SubmitJobCommand(options));
+            Logger.info('Job %s(%s) submitted', rval.jobName, rval.jobId);
+            return rval;
+        }
+        catch (err) {
+            Logger.error('Cannot submit batch job %s: %s', options.jobName, err);
+        }
+        return null;
+    }
+    async jobCountInState(jobStatus, queueName = this.defaultQueueName) {
+        const all = await this.listJobs(queueName, jobStatus);
+        return all.length;
+    }
+    async listJobs(queueName = this.defaultQueueName, jobStatus = null) {
+        RequireRatchet.notNullOrUndefined(queueName, 'queueName');
+        let rval = [];
+        const request = {
+            jobQueue: queueName,
+            jobStatus: jobStatus,
+            nextToken: null,
+        };
+        Logger.info('Fetching %j', request);
+        do {
+            Logger.info('Pulling page...');
+            const tmp = await this._batchClient.send(new ListJobsCommand(request));
+            rval = rval.concat(tmp.jobSummaryList);
+            request.nextToken = tmp.nextToken;
+        } while (request.nextToken);
+        return rval;
+    }
+}

package/dist/es/build/ratchet-aws-info.js

@@ -0,0 +1,14 @@
+export class RatchetAwsInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}