idea-aws 3.6.2 → 3.7.2

package/dist/src/resourceController.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceController = void 0;
+/* eslint-disable no-invalid-this */
+const fs_1 = require("fs");
+const aws_sdk_1 = require("aws-sdk");
+const idea_toolbox_1 = require("idea-toolbox");
+const genericController_1 = require("./genericController");
+/**
+ * An abstract class to inherit to manage API requests (AWS API Gateway) in an AWS Lambda function.
+ */
+class ResourceController extends genericController_1.GenericController {
+    constructor(event, callback, options) {
+        super(event, callback, options);
+        this.templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
+        ///
+        /// REQUEST HANDLERS
+        ///
+        this.handleRequest = async () => {
+            try {
+                await this.checkAuthBeforeRequest();
+                try {
+                    let response;
+                    if (this.resourceId) {
+                        switch (this.httpMethod) {
+                            // resource/{resourceId}
+                            case 'GET':
+                                response = await this.getResource();
+                                break;
+                            case 'POST':
+                                response = await this.postResource();
+                                break;
+                            case 'PUT':
+                                response = await this.putResource();
+                                break;
+                            case 'DELETE':
+                                response = await this.deleteResource();
+                                break;
+                            case 'PATCH':
+                                response = await this.patchResource();
+                                break;
+                            case 'HEAD':
+                                response = await this.headResource();
+                                break;
+                            default:
+                                this.done(new Error('Unsupported method'));
+                        }
+                    }
+                    else {
+                        switch (this.httpMethod) {
+                            // resource
+                            case 'GET':
+                                response = await this.getResources();
+                                break;
+                            case 'POST':
+                                response = await this.postResources();
+                                break;
+                            case 'PUT':
+                                response = await this.putResources();
+                                break;
+                            case 'DELETE':
+                                response = await this.deleteResources();
+                                break;
+                            case 'PATCH':
+                                response = await this.patchResources();
+                                break;
+                            case 'HEAD':
+                                response = await this.headResources();
+                                break;
+                            default:
+                                this.done(new Error('Unsupported method'));
+                        }
+                    }
+                    this.done(null, response);
+                }
+                catch (err) {
+                    const errorMessage = err?.message || err?.errorMessage || 'Operation failed';
+                    this.done(new Error(errorMessage));
+                }
+            }
+            catch (err) {
+                const errorMessage = err?.message || err?.errorMessage || 'Forbidden';
+                this.done(new Error(errorMessage));
+            }
+        };
+        this.authorization = event.headers?.Authorization;
+        this.claims = event.requestContext?.authorizer?.claims;
+        this.principalId = this.claims?.sub;
+        this.user = this.principalId ? new idea_toolbox_1.CognitoUser(this.claims) : null;
+        this.stage = event.requestContext?.stage;
+        this.httpMethod = event.httpMethod;
+        this.resource = (event.resource || '').replace('+', ''); // {proxy+} -> {proxy}
+        this.path = event.path || '';
+        this.resourceId =
+            event.pathParameters && event.pathParameters[options.resourceId || 'proxy']
+                ? decodeURIComponent(event.pathParameters[options.resourceId || 'proxy'])
+                : '';
+        this.queryParams = event.queryStringParameters || {};
+        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+        this.logRequestsWithKey = options.logRequestsWithKey;
+        // acquire some info about the client, if available
+        let version = '?', platform = '?';
+        if (this.queryParams['_v']) {
+            version = this.queryParams['_v'];
+            delete this.queryParams['_v'];
+        }
+        if (this.queryParams['_p']) {
+            platform = this.queryParams['_p'];
+            delete this.queryParams['_p'];
+        }
+        // print the initial log
+        const info = { principalId: this.principalId, queryParams: this.queryParams, body: this.body, version, platform };
+        (0, idea_toolbox_1.logger)(`START: ${this.httpMethod} ${this.stage} ${this.path}`, null, info, true);
+    }
+    done(err, res, statusCode) {
+        (0, idea_toolbox_1.logger)(err ? 'DONE WITH ERRORS' : 'DONE', err, res, true);
+        // if configured, store the log of the request
+        if (this.logRequestsWithKey)
+            this.storeLog(!err);
+        this.callback(null, {
+            statusCode: statusCode ?? (err ? '400' : '200'),
+            body: err ? JSON.stringify({ message: err.message }) : JSON.stringify(res || {}),
+            headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }
+        });
+    }
+    /**
+     * To @override
+     */
+    async checkAuthBeforeRequest() {
+        return;
+    }
+    /**
+     * To @override
+     */
+    async getResource() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async postResource() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async putResource() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async deleteResource() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async headResource() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async getResources() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async postResources() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async putResources() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async patchResource() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async patchResources() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async deleteResources() {
+        throw new Error('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async headResources() {
+        throw new Error('Unsupported method');
+    }
+    ///
+    /// HELPERS
+    ///
+    /**
+     * Store the log associated to the request (no response/error handling).
+     */
+    storeLog(succeeded) {
+        const log = new idea_toolbox_1.APIRequestLog({
+            logId: this.logRequestsWithKey,
+            userId: this.principalId,
+            resource: this.resource,
+            path: this.path,
+            resourceId: this.resourceId,
+            method: this.httpMethod,
+            succeeded
+        });
+        // optionally add a track of the action
+        if (this.httpMethod === 'PATCH' && this.body && this.body.action)
+            log.action = this.body.action;
+        this.dynamoDB.put({ TableName: 'idea_logs', Item: log }).catch(() => {
+            /* ignore */
+        });
+    }
+    /**
+     * Check whether shared resource exists in the back-end (translation, template, etc.).
+     */
+    sharedResourceExists(path) {
+        return (0, fs_1.existsSync)(`assets/${path}`);
+    }
+    /**
+     * Load a shared resource in the back-end (translation, template, etc.).
+     */
+    loadSharedResource(path) {
+        return (0, fs_1.readFileSync)(`assets/${path}`, { encoding: 'utf-8' });
+    }
+    ///
+    /// MANAGE INTERNAL API REQUESTS (lambda invokes masked as API requests)
+    ///
+    /**
+     * Simulate an internal API request, invoking directly the lambda and therefore saving resources.
+     * @return the body of the response
+     * @deprecated don't run a Lambda from another Lambda (bad practice)
+     */
+    invokeInternalAPIRequest(params) {
+        return new Promise((resolve, reject) => {
+            // create a copy of the event
+            const event = JSON.parse(JSON.stringify(this.event));
+            // change only the event attributes we need; e.g. the authorization is unchanged
+            event.stage = params.stage || this.stage;
+            event.httpMethod = params.httpMethod;
+            event.resource = params.resource;
+            event.pathParameters = params.pathParams || {};
+            event.queryStringParameters = params.queryParams || {};
+            event.body = JSON.stringify(params.body || {});
+            // parse the path
+            event.path = event.resource;
+            for (const p in event.pathParameters)
+                if (event.pathParameters[p])
+                    event.resource = event.resource.replace(`{${p}}`, event.pathParameters[p]);
+            // set a flag to make the invoked to recognise that is an internal request
+            event.internalAPIRequest = true;
+            // invoke the lambda with the event prepaired, simulating an API request
+            new aws_sdk_1.Lambda().invoke({
+                FunctionName: params.lambda,
+                Qualifier: event.stage,
+                InvocationType: 'RequestResponse',
+                Payload: JSON.stringify(event)
+            }, (err, res) => {
+                // reject in case of internal error
+                if (err)
+                    reject(err);
+                else {
+                    // parse the payload and the body
+                    const payload = JSON.parse(res.Payload);
+                    const body = JSON.parse(payload.body);
+                    // if the response is successfull, return the body
+                    if (Number(payload.statusCode) === 200)
+                        resolve(body);
+                    // otherwise, reject the controlled error
+                    else
+                        reject(new Error(body.message));
+                }
+            });
+        });
+    }
+    /**
+     * Whether the current request comes from an internal API request, i.e. it was invoked by another controller.
+     * @deprecated don't run a Lambda from another Lambda (bad practice)
+     */
+    comesFromInternalRequest() {
+        return Boolean(this.event.internalAPIRequest);
+    }
+    //
+    // TRANSLATIONS
+    //
+    /**
+     * Load the translations from the shared resources and set them with a fallback language.
+     */
+    loadTranslations(lang, defLang) {
+        // check for the existance of the mandatory source file
+        if (!this.sharedResourceExists(`i18n/${lang}.json`))
+            return;
+        // set the languages
+        this.currentLang = lang;
+        this.defaultLang = defLang || lang;
+        this.translations = {};
+        // load the translations in the chosen language
+        this.translations[this.currentLang] = JSON.parse(this.loadSharedResource(`i18n/${this.currentLang}.json`).toString());
+        // load the translations in the default language, if set and differ from the current
+        if (this.defaultLang !== this.currentLang && this.sharedResourceExists(`i18n/${this.defaultLang}.json`))
+            this.translations[this.defaultLang] = JSON.parse(this.loadSharedResource(`i18n/${this.defaultLang}.json`).toString());
+    }
+    /**
+     * Get a translated term by key, optionally interpolating variables (e.g. `{{user}}`).
+     * If the term doesn't exist in the current language, it is searched in the default language.
+     */
+    t(key, interpolateParams) {
+        if (!this.translations || !this.currentLang)
+            return;
+        if (!this.isDefined(key) || !key.length)
+            return;
+        let res = this.interpolate(this.getValue(this.translations[this.currentLang], key), interpolateParams);
+        if (res === undefined && this.defaultLang !== null && this.defaultLang !== this.currentLang)
+            res = this.interpolate(this.getValue(this.translations[this.defaultLang], key), interpolateParams);
+        return res;
+    }
+    /**
+     * Interpolates a string to replace parameters.
+     * "This is a {{ key }}" ==> "This is a value", with params = { key: "value" }
+     */
+    interpolate(expr, params) {
+        if (!params || !expr)
+            return expr;
+        return expr.replace(this.templateMatcher, (substring, b) => {
+            const r = this.getValue(params, b);
+            return this.isDefined(r) ? r : substring;
+        });
+    }
+    /**
+     * Gets a value from an object by composed key.
+     * getValue({ key1: { keyA: 'valueI' }}, 'key1.keyA') ==> 'valueI'
+     */
+    getValue(target, key) {
+        const keys = typeof key === 'string' ? key.split('.') : [key];
+        key = '';
+        do {
+            key += keys.shift();
+            if (this.isDefined(target) && this.isDefined(target[key]) && (typeof target[key] === 'object' || !keys.length)) {
+                target = target[key];
+                key = '';
+            }
+            else if (!keys.length)
+                target = undefined;
+            else
+                key += '.';
+        } while (keys.length);
+        return target;
+    }
+    /**
+     * Helper to quicly check if the value is defined.
+     */
+    isDefined(value) {
+        return value !== undefined && value !== null;
+    }
+}
+exports.ResourceController = ResourceController;

package/dist/{s3.d.ts → src/s3.d.ts}

@@ -16,7 +16,7 @@ export declare class S3 {
     constructor();
     /**
      * Create a download link of a piece of data (through S3).
-     * *Pratically*, it uploads the file on an S3 bucket, generating and returning a url to it.
+     * *Practically*, it uploads the file on an S3 bucket, generating and returning a url to it.
      */
     createDownloadURLFromData(data: Buffer | any, options?: CreateDownloadURLFromDataOptions): Promise<SignedURL>;
     /**

package/dist/src/s3.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetObjectTypes = exports.S3 = void 0;
+const aws_sdk_1 = require("aws-sdk");
+const idea_toolbox_1 = require("idea-toolbox");
+// declare libs as global vars to be reused in warm starts by the Lambda function
+let ideaWarmStart_s3 = null;
+/**
+ * A wrapper for AWS Simple Storage Service.
+ */
+class S3 {
+    /**
+     * Initialize a new S3 helper object.
+     */
+    constructor() {
+        this.DEFAULT_DOWNLOAD_BUCKET_PREFIX = 'common';
+        this.DEFAULT_DOWNLOAD_BUCKET = 'idea-downloads';
+        this.DEFAULT_DOWNLOAD_BUCKET_SEC_TO_EXP = 180;
+        this.DEFAULT_UPLOAD_BUCKET_SEC_TO_EXP = 300;
+        if (!ideaWarmStart_s3)
+            ideaWarmStart_s3 = new aws_sdk_1.S3({ apiVersion: '2006-03-01', signatureVersion: 'v4' });
+        this.s3 = ideaWarmStart_s3;
+    }
+    /**
+     * Create a download link of a piece of data (through S3).
+     * *Practically*, it uploads the file on an S3 bucket, generating and returning a url to it.
+     */
+    async createDownloadURLFromData(data, options) {
+        // if needed, randomly generates the key
+        if (!options.key)
+            options.key = new Date().getTime().toString().concat(Math.random().toString(36).slice(2));
+        options.key = `${options.prefix || this.DEFAULT_DOWNLOAD_BUCKET_PREFIX}/${options.key}`;
+        options.bucket = options.bucket || this.DEFAULT_DOWNLOAD_BUCKET;
+        options.secToExp = options.secToExp || this.DEFAULT_DOWNLOAD_BUCKET_SEC_TO_EXP;
+        await this.s3
+            .upload({ Bucket: options.bucket, Key: options.key, Body: data, ContentType: options.contentType })
+            .promise();
+        return this.signedURLGet(options.bucket, options.key, options.secToExp);
+    }
+    /**
+     * Get a signed URL to put a file on a S3 bucket.
+     * @param expires seconds after which the signed URL expires
+     */
+    signedURLPut(bucket, key, expires) {
+        return new idea_toolbox_1.SignedURL({
+            url: this.s3.getSignedUrl('putObject', {
+                Bucket: bucket,
+                Key: key,
+                Expires: expires || this.DEFAULT_UPLOAD_BUCKET_SEC_TO_EXP
+            })
+        });
+    }
+    /**
+     * Get a signed URL to get a file on a S3 bucket.
+     * @param expires seconds after which the signed URL expires
+     */
+    signedURLGet(bucket, key, expires) {
+        return new idea_toolbox_1.SignedURL({
+            url: this.s3.getSignedUrl('getObject', {
+                Bucket: bucket,
+                Key: key,
+                Expires: expires || this.DEFAULT_DOWNLOAD_BUCKET_SEC_TO_EXP
+            })
+        });
+    }
+    /**
+     * Make a copy of an object of the bucket.
+     */
+    async copyObject(options) {
+        (0, idea_toolbox_1.logger)('S3 COPY OBJECT', null, options.key);
+        await this.s3.copyObject({ CopySource: options.copySource, Bucket: options.bucket, Key: options.key }).promise();
+    }
+    /**
+     * Get an object from a S3 bucket.
+     */
+    async getObject(options) {
+        (0, idea_toolbox_1.logger)('S3 GET OBJECT', null, options.type);
+        const result = await this.s3.getObject({ Bucket: options.bucket, Key: options.key }).promise();
+        switch (options.type) {
+            case GetObjectTypes.JSON:
+                return JSON.parse(result.Body.toString('utf-8'));
+            case GetObjectTypes.TEXT:
+                return result.Body.toString('utf-8');
+            default:
+                return result;
+        }
+    }
+    /**
+     * Put an object in a S3 bucket.
+     */
+    async putObject(options) {
+        const params = { Bucket: options.bucket, Key: options.key, Body: options.body };
+        if (options.contentType)
+            params.ContentType = options.contentType;
+        if (options.acl)
+            params.ACL = options.acl;
+        if (options.metadata)
+            params.Metadata = options.metadata;
+        (0, idea_toolbox_1.logger)('S3 PUT OBJECT', null, options.key);
+        return await this.s3.putObject(params).promise();
+    }
+    /**
+     * Delete an object from an S3 bucket.
+     */
+    async deleteObject(options) {
+        (0, idea_toolbox_1.logger)('S3 DELETE OBJECT', null, options.key);
+        return await this.s3.deleteObject({ Bucket: options.bucket, Key: options.key }).promise();
+    }
+    /**
+     * List the objects of an S3 bucket.
+     */
+    async listObjects(options) {
+        (0, idea_toolbox_1.logger)('S3 LIST OBJECTS', null, options.prefix);
+        return await this.s3.listObjects({ Bucket: options.bucket, Prefix: options.prefix }).promise();
+    }
+    /**
+     * List the objects keys of an S3 bucket.
+     */
+    async listObjectsKeys(options) {
+        const result = await this.listObjects(options);
+        return result.Contents.map(obj => obj.Key);
+    }
+    /**
+     * Check whether an object on an S3 bucket exists.
+     */
+    async doesObjectExist(options) {
+        try {
+            await this.s3.headObject({ Bucket: options.bucket, Key: options.key }).promise();
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+}
+exports.S3 = S3;
+/**
+ * The managed types to convert objects coming from an S3 bucket.
+ */
+var GetObjectTypes;
+(function (GetObjectTypes) {
+    GetObjectTypes["JSON"] = "JSON";
+    GetObjectTypes["TEXT"] = "TEXT";
+})(GetObjectTypes = exports.GetObjectTypes || (exports.GetObjectTypes = {}));

package/dist/{ses.d.ts → src/ses.d.ts}

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { Headers } from 'nodemailer/lib/mailer';
 /**
  * A wrapper for AWS Simple Email Service.
  */
@@ -6,7 +7,7 @@ export declare class SES {
     /**
      * Send an email through AWS Simple Email Service.
      */
-    sendEmail(emailData: EmailData, sesParams: SESParams): Promise<void>;
+    sendEmail(emailData: EmailData, sesParams: SESParams): Promise<any>;
     private searchForCustomSESConfigByTeamId;
     private sendEmailWithSES;
     private sendEmailWithNodemailer;

package/dist/src/ses.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SES = void 0;
+const aws_sdk_1 = require("aws-sdk");
+const nodemailer_1 = require("nodemailer");
+const idea_toolbox_1 = require("idea-toolbox");
+const dynamoDB_1 = require("./dynamoDB");
+// declare libs as global vars to be reused in warm starts by the Lambda function
+let ideaWarmStart_ses = null;
+/**
+ * A wrapper for AWS Simple Email Service.
+ */
+class SES {
+    /**
+     * Send an email through AWS Simple Email Service.
+     */
+    async sendEmail(emailData, sesParams) {
+        // if requested, check whether there is a custom SES configuration to apply for the team
+        const customSESConfig = await this.searchForCustomSESConfigByTeamId(sesParams.teamId);
+        let result;
+        // if the email includes attachments, send with Nodemailer (to avoid size limitations)
+        if (emailData.attachments?.length)
+            result = await this.sendEmailWithNodemailer(emailData, customSESConfig || sesParams);
+        // otherwise, send with SES (more secure)
+        else
+            result = await this.sendEmailWithSES(emailData, customSESConfig || sesParams);
+        return result;
+    }
+    async searchForCustomSESConfigByTeamId(teamId) {
+        if (!teamId)
+            return null;
+        try {
+            return await new dynamoDB_1.DynamoDB().get({ TableName: 'idea_teamsSES', Key: { teamId } });
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async sendEmailWithSES(emailData, sesParams) {
+        const sesData = {};
+        sesData.Destination = {};
+        if (emailData.toAddresses)
+            sesData.Destination.ToAddresses = emailData.toAddresses;
+        if (emailData.ccAddresses)
+            sesData.Destination.CcAddresses = emailData.ccAddresses;
+        if (emailData.bccAddresses)
+            sesData.Destination.BccAddresses = emailData.bccAddresses;
+        if (emailData.replyToAddresses)
+            sesData.ReplyToAddresses = emailData.replyToAddresses;
+        sesData.Message = {};
+        if (emailData.subject)
+            sesData.Message.Subject = { Charset: 'UTF-8', Data: emailData.subject };
+        sesData.Message.Body = {};
+        if (emailData.html)
+            sesData.Message.Body.Html = { Charset: 'UTF-8', Data: emailData.html };
+        if (emailData.text)
+            sesData.Message.Body.Text = { Charset: 'UTF-8', Data: emailData.text };
+        if (!emailData.html && !emailData.text)
+            sesData.Message.Body.Text = { Charset: 'UTF-8', Data: '' };
+        sesData.Source = `${sesParams.sourceName} <${sesParams.source}>`;
+        sesData.SourceArn = sesParams.sourceArn;
+        (0, idea_toolbox_1.logger)('SES SEND EMAIL');
+        if (!ideaWarmStart_ses)
+            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
+        await ideaWarmStart_ses.sendEmail(sesData).promise();
+    }
+    async sendEmailWithNodemailer(emailData, sesParams) {
+        const mailOptions = {};
+        mailOptions.from = `${sesParams.sourceName} <${sesParams.source}>`;
+        mailOptions.to = emailData.toAddresses.join(',');
+        if (emailData.ccAddresses)
+            mailOptions.cc = emailData.ccAddresses.join(',');
+        if (emailData.bccAddresses)
+            mailOptions.bcc = emailData.bccAddresses.join(',');
+        if (emailData.replyToAddresses)
+            mailOptions.replyTo = emailData.replyToAddresses.join(',');
+        mailOptions.subject = emailData.subject;
+        if (emailData.html)
+            mailOptions.html = emailData.html;
+        if (emailData.text)
+            mailOptions.text = emailData.text;
+        mailOptions.attachments = emailData.attachments;
+        (0, idea_toolbox_1.logger)('SES SEND EMAIL (NODEMAILER)');
+        if (!ideaWarmStart_ses)
+            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
+        await (0, nodemailer_1.createTransport)({ SES: ideaWarmStart_ses }).sendMail(mailOptions);
+    }
+}
+exports.SES = SES;

package/dist/{sns.d.ts → src/sns.d.ts}

@@ -11,7 +11,7 @@ export declare class SNS {
     /**
      * Publish a message to a SNS endpoint.
      */
-    publish(params: SNSPublishParams): Promise<AWS.SNS.PublishResponse>;
+    publish(snsParams: SNSPublishParams): Promise<AWS.SNS.PublishResponse>;
 }
 /**
  * SNS configuration.