@bitblit/ratchet-aws 4.0.80-alpha

package/dist/es/ses/mailer.js

@@ -0,0 +1,204 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { SendRawEmailCommand } from '@aws-sdk/client-ses';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { DateTime } from 'luxon';
+import { Base64Ratchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+export class Mailer {
+    constructor(ses, config = {}) {
+        this.ses = ses;
+        this.config = config;
+        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) {
+        RequireRatchet.notNullOrUndefined(htmlTemplateName);
+        if (!this.config.templateRenderer) {
+            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) {
+            Logger.debug('Archiving outbound email to : %j', rts.destinationAddresses);
+            let targetPath = StringRatchet.trimToEmpty(this.config.archivePrefix);
+            if (!targetPath.endsWith('/')) {
+                targetPath += '/';
+            }
+            const now = 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) {
+                Logger.warn('Failed to archive email %s %j : %s', targetPath, rts, err);
+            }
+        }
+        return rval;
+    }
+    applyLimitsToBodySizesIfAnyInPlace(rts) {
+        if (this.config.maxMessageBodySizeInBytes) {
+            const txtSize = StringRatchet.trimToEmpty(rts.txtMessage).length;
+            const htmlSize = StringRatchet.trimToEmpty(rts.htmlMessage).length;
+            const totalSize = txtSize + htmlSize;
+            if (totalSize > this.config.maxMessageBodySizeInBytes) {
+                Logger.warn('Max message size is %d but size is %d - converting', this.config.maxMessageBodySizeInBytes, totalSize);
+                rts.attachments = rts.attachments || [];
+                if (StringRatchet.trimToNull(rts.txtMessage)) {
+                    const txtAttach = {
+                        filename: 'original-txt-body.txt',
+                        contentType: 'text/plain',
+                        base64Data: Base64Ratchet.generateBase64VersionOfString(rts.txtMessage),
+                    };
+                    rts.attachments.push(txtAttach);
+                }
+                if (StringRatchet.trimToNull(rts.htmlMessage)) {
+                    const htmlAttach = {
+                        filename: 'original-html-body.html',
+                        contentType: 'text/html',
+                        base64Data: 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 {
+                        Logger.warn('Removing too-large attachment : %s : %s : %d', a.filename, a.contentType, a.base64Data.length);
+                        filtered.push({
+                            filename: 'attachment-removed-notice-' + StringRatchet.createRandomHexString(4) + '.txt',
+                            contentType: 'text/plain',
+                            base64Data: 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) {
+        RequireRatchet.notNullOrUndefined(inRts, 'RTS must be defined');
+        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) {
+            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) {
+            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 (!!StringRatchet.trimToNull(rts.htmlMessage)) {
+                    rawMail += '\n\n--' + altBoundary + '\n';
+                    rawMail += 'Content-Type: text/html; charset="UTF-8"\n\n';
+                    rawMail += rts.htmlMessage;
+                }
+                if (!!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 SendRawEmailCommand(params));
+            }
+            catch (err) {
+                Logger.error('Error while processing email: %s', err, err);
+            }
+        }
+        return rval;
+    }
+    static validEmail(email) {
+        return email !== null && Mailer.EMAIL.test(email);
+    }
+}
+Mailer.EMAIL = new RegExp('.+@.+\\.[a-z]+');

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,74 @@
+import handlebars from 'handlebars';
+import fetch from 'cross-fetch';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common';
+import layouts from 'handlebars-layouts';
+export 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 layouts.register(handlebars);
+            handlebars.registerPartial(layoutName, layoutText);
+        }
+        const context = inContext || {};
+        const result = !!template ? template(context) : null;
+        return result;
+    }
+    async renderTemplateDirect(templateText, context, layoutName = null) {
+        const template = handlebars.compile(templateText);
+        const result = template(context);
+        return result;
+    }
+    async fetchTemplate(templateName) {
+        let rval = null;
+        try {
+            if (!!this.cache && this.cache.has(templateName)) {
+                Logger.silly('Cache hit for template : %s', templateName);
+                rval = this.cache.get(templateName);
+            }
+            else {
+                Logger.debug('Cache miss for template : %s', templateName);
+                const templateText = await this.fetchTemplateText(templateName);
+                if (!!templateText) {
+                    rval = handlebars.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) {
+            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 = StringRatchet.trimToEmpty(this.prefix) + templateName + StringRatchet.trimToEmpty(this.suffix);
+        try {
+            const resp = await fetch(url);
+            rval = await resp.text();
+        }
+        catch (err) {
+            Logger.warn('Could not fetch url : %s : %s', url, err, err);
+            rval = null;
+        }
+        return rval;
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,43 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { PublishCommand, SNSClient } from '@aws-sdk/client-sns';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+export class SnsRatchet {
+    constructor(sns = new SNSClient({ region: 'us-east-1' }), topicArn) {
+        this.sns = sns;
+        this.topicArn = topicArn;
+        RequireRatchet.notNullOrUndefined(this.sns, 'sns');
+        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,
+            };
+            Logger.debug('Sending via SNS : %j', params);
+            result = await this.sns.send(new PublishCommand(params));
+        }
+        catch (err) {
+            if (suppressErrors) {
+                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 {
+            Logger.info('Not sending message, condition was false : %j', inMsg);
+        }
+        return rval;
+    }
+}

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

@@ -0,0 +1,65 @@
+import { Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { PutItemCommand } from '@aws-sdk/client-dynamodb';
+export class DynamoDbSyncLock {
+    constructor(ratchet, tableName) {
+        this.ratchet = ratchet;
+        this.tableName = tableName;
+        RequireRatchet.notNullOrUndefined(ratchet, 'ratchet');
+        RequireRatchet.notNullOrUndefined(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 PutItemCommand(params));
+                rval = true;
+            }
+            catch (err) {
+                if (String(err).indexOf('ConditionalCheckFailedException') > -1) {
+                    Logger.silly('Unable to acquire lock on %s', lockKey);
+                }
+            }
+        }
+        return rval;
+    }
+    async releaseLock(lockKey) {
+        if (StringRatchet.trimToNull(lockKey)) {
+            try {
+                const dio = await this.ratchet.simpleDelete(this.tableName, { lockingKey: lockKey });
+                Logger.silly('Released lock %s : %s', lockKey, dio);
+            }
+            catch (err) {
+                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;
+    }
+}

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

@@ -0,0 +1,36 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class MemorySyncLock {
+    constructor() {
+        this._locks = new Map();
+    }
+    async acquireLock(lockKey, expirationSeconds = 30) {
+        let rval = false;
+        if (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 (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;
+    }
+}

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

@@ -0,0 +1 @@
+export {};