@idiamantino/livepro-utils/aws/sqs.js

Stuff for LP

const AWS = require('aws-sdk');

const Utils = require("../library/utils");
let LpUtils = new Utils();

class Sqs {
    
	constructor(region, apiVersion = '2012-11-05', debug = false) {
        this.setDebug(debug);
        this.region = region;
        LpUtils.printDebug("SQS constructor region:", region);
        
        AWS.config.update({region:this.region});
        this.sqs = new AWS.SQS({apiVersion: apiVersion});
    }
    
    setDebug(debug = false) {
        this.debug = debug;
        LpUtils.setDebug(debug);
    }
    
    async test(params){
         LpUtils.printDebug("SQS function accessible:", params);
         LpUtils.printDebug("Region:", this.region);
         return (true);
    }
    
    // Function to add one individual process to the sqs
    async addToSQS(queueURL, region, processEndpoint, clientName, subdomain, clientDomain, clientSecret, processUrl, processName, processStatus, checkResponse, processId, processType, extraParameters = "") {
         var params = {
              DelaySeconds: 0,
              MessageAttributes: {
                "client_name": {
                  DataType: "String",
                  StringValue: clientName,
                },
                "subdomain": {
                  DataType: "String",
                  StringValue: subdomain
                },
                "domain": {
                  DataType: "String",
                  StringValue: clientDomain
                },
                "secret": {
                  DataType: "String",
                  StringValue: clientSecret
                },
                "process_name": {
                  DataType: "String",
                  StringValue: processName
                },
                "process_type": {
                  DataType: "String",
                  StringValue: processType
                },
                "check_response": {
                  DataType: "String",
                  StringValue: checkResponse
                },
                "process_id": {
                  DataType: "String",
                  StringValue: processId
                }
              },
              MessageBody: "Client added to the SQS queue via Lambda: " + clientName + processName,
              MessageDeduplicationId: processId,  // Required for FIFO queues
              MessageGroupId:  processName,  // Required for FIFO queues
              QueueUrl: queueURL
            };
            
            if(typeof processUrl !== "undefined" && processUrl !== "") params.MessageAttributes.process_url = {DataType: "String",StringValue: processUrl};
            if(typeof extraParameters !== "undefined" && extraParameters !== "") params.MessageAttributes.extra_parameters = {DataType: "String",StringValue: extraParameters};
            try {
                LpUtils.printDebug("SQS Parameters: ");
                let sqsdata = await this.sqs.sendMessage(params).promise();
                LpUtils.printDebug("Added to SQS without error", clientName);
                return(true);
            } catch (err) {
                console.log(err);
                return(false);
            }   
    }
    
    // If there are messages on the queue, enable process that will run the processes via cloudwatch
    async getSQSMessage(queueURL) {
        LpUtils.printDebug("Check SQS Process Started ");
        let data = await this.getSQSMessages(queueURL,1,1,0)
        return(data);
    }
    
    async getSQSMessages(queueURL, numberOfMessages, visibilityTimeout = 30, waitTimeSeconds = 0) {
        LpUtils.printDebug("Check SQS Process Started ");
        var params = {
         MaxNumberOfMessages: numberOfMessages,
         MessageAttributeNames: [
            "All"
         ],
         QueueUrl: queueURL,
         VisibilityTimeout: visibilityTimeout,
         WaitTimeSeconds: waitTimeSeconds
        };
        LpUtils.printDebug("Trying to receive: ", numberOfMessages);
        let data = await this.sqs.receiveMessage(params).promise();
        return data;
    }
    
    async deleteSqsMessage(queueURL, receiptHandle) {
        var deleteParams = {
            QueueUrl: queueURL,
            ReceiptHandle: receiptHandle
        };
        let deleted = await this.sqs.deleteMessage(deleteParams).promise();
        return deleted;
    }
    
    async getQueueUrl(queueName) {
        var params = {
          QueueName: queueName
        };
        const sqsreturn = new Promise((res, rej) => {
            this.sqs.getQueueUrl(params, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(data);
              }
            }); 
        });
        const queueUrl = await sqsreturn;
        return(queueUrl.QueueUrl);
    }
}

module.exports = Sqs;