eip-cloud-services 1.2.2 → 1.2.4

package/README.md

@@ -2,7 +2,7 @@
 
 ## Summary
 
-The EIP Cloud Services Module is a comprehensive Node.js package that provides seamless integration with various cloud services, including Redis, AWS S3, CDN, AWS Lambda, and MySQL. This module is designed to simplify the complexities of interacting with these cloud services, offering a range of functionalities from data caching and storage to content delivery and serverless computing.
+The EIP Cloud Services Module is a comprehensive Node.js package that provides seamless integration with various cloud services, including Redis, AWS S3, CDN, AWS Lambda, AWS SQS, and MySQL. This module is designed to simplify the complexities of interacting with these cloud services, offering a range of functionalities from data caching and storage to content delivery and serverless computing.
 
 ## Installation and Import
 
@@ -58,6 +58,10 @@ module.exports = {
         logs: "verbose", // "verbose" or "outputs", any other value will not log. verbose will log all activity. outputs will only log when there is a file updated.
         logsFunction: ( message ) => { ... } // Optional, if nothing is provided console.log will be used.
     },
+    sqs: {
+        region: 'eu-west-1',
+        endpoint: 'http://localhost:4566' // Optional (e.g. localstack)
+    },
     mysql: {
         connectionLimit: 10, // Max connections
         host: 'my-database.domain.com',
@@ -76,6 +80,7 @@ module.exports = {
 3. [CDN Module](#cdn-module)
 4. [MySQL Module](#mysql-module)
 5. [AWS Lambda Module](#aws-lambda-module)
+6. [AWS SQS Module](#aws-sqs-module)
 
 # AWS Lambda Module
 
@@ -131,6 +136,30 @@ The module includes error handling to manage issues related to Lambda invocation
 
 Logging is provided to track the start and completion of Lambda invocations, aiding in debugging and monitoring.
 
+# AWS SQS Module
+
+## Overview
+
+This module provides helpers for sending, receiving, and deleting messages in AWS SQS queues.
+
+## Usage
+
+```javascript
+const sqs = require('eip-cloud-services').sqs;
+
+const queueUrl = await sqs.getQueueUrl('my-queue');
+await sqs.sendMessage(queueUrl, { type: 'example', payload: 'hello' });
+
+const messages = await sqs.receiveMessages(queueUrl, { maxMessages: 5, waitTimeSeconds: 10 });
+if (messages.length > 0) {
+    await sqs.deleteMessages(queueUrl, messages);
+}
+```
+
+## Configuration
+
+Set `sqs.region` and optionally `sqs.endpoint` in your config. The module defaults to `eu-west-1` and uses the AWS SDK credential chain.
+
 # MySQL Module
 
 ## Overview

package/index.js

@@ -3,5 +3,6 @@ exports.redis = require ( './src/redis' );
 exports.s3 = require ( './src/s3' );
 exports.cdn = require ( './src/cdn' );
 exports.lambda = require ( './src/lambda' );
+exports.sqs = require ( './src/sqs' );
 exports.mysql = require ( './src/mysql' );
-exports.mysql8 = require ( './src/mysql8' );
+exports.mysql8 = require ( './src/mysql8' );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {
@@ -17,6 +17,7 @@
     "@aws-sdk/client-cloudfront": "^3.354.0",
     "@aws-sdk/client-lambda": "^3.356.0",
     "@aws-sdk/client-s3": "^3.354.0",
+    "@aws-sdk/client-sqs": "^3.356.0",
     "@aws-sdk/client-secrets-manager": "^3.354.0",
     "config": "^3.3.9",
     "google-auth-library": "^8.8.0",

package/src/redis.js

@@ -8,6 +8,11 @@ if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirector
 }
 
 const clients = {};
+const applyPrefix = (value) => {
+    const prefix = config?.redis?.prefix;
+    if (!prefix || typeof value !== 'string') return value;
+    return value.startsWith(prefix) ? value : `${prefix}${value}`;
+};
 
 /**
  * Creates or retrieves a Redis client instance based on a given client identifier.
@@ -725,9 +730,10 @@ exports.setExpiry = async ( key, seconds = 0 ) => {
 exports.publish = async ( channel, message ) => {
     try {
         if ( typeof channel === 'string' && typeof message === 'string' ) {
-            const client = await getClient ( `${channel}_pub` );
+            const fullChannel = applyPrefix ( channel );
+            const client = await getClient ( `${fullChannel}_pub` );
 
-            return client.publish ( channel, message );
+            return client.publish ( fullChannel, message );
         }
 
         throw new Error ( 'redis.publish expects string types for both channel and message' );
@@ -749,15 +755,16 @@ exports.publish = async ( channel, message ) => {
 exports.subscribe = async ( channel, messageHandler ) => {
     try {
         if ( typeof channel === 'string' && typeof messageHandler === 'function' ) {
-            const client = await getClient ( `${channel}_sub` );
+            const fullChannel = applyPrefix ( channel );
+            const client = await getClient ( `${fullChannel}_sub` );
 
             client.on ( 'message', ( receivedChannel, message ) => {
-                if ( receivedChannel === channel ) {
+                if ( receivedChannel === fullChannel ) {
                     messageHandler ( message );
                 }
             } );
 
-            await client.subscribe ( channel );
+            await client.subscribe ( fullChannel );
         
             return;
         }
@@ -781,12 +788,13 @@ exports.subscribe = async ( channel, messageHandler ) => {
 exports.unsubscribe = async ( channel ) => {
     try {
         if ( typeof channel === 'string' ) {
-            const client = await getClient ( `${channel}_sub` );
+            const fullChannel = applyPrefix ( channel );
+            const client = await getClient ( `${fullChannel}_sub` );
 
             client.removeAllListeners ( 'message' );
 
-            await client.unsubscribe ( channel );
-            await deleteClient ( `${channel}_sub` );
+            await client.unsubscribe ( fullChannel );
+            await deleteClient ( `${fullChannel}_sub` );
 
             return;
         }

package/src/s3.js

@@ -197,13 +197,14 @@ exports.get = async ( key, bucket = config?.s3?.Bucket, options = {} ) => {
  * @description Sets an object in S3 with the provided key, body, and optional parameters.
  */
 exports.set = async ( key, body, options = {} ) => {
-    const bucket = options.bucket || config?.s3?.Bucket;
-    const contentType = options.contentType || 'application/json';
-    const cacheControl = options.cacheControl || 'max-age=25,s-maxage=30,must-revalidate';
-    const encrypt = Boolean ( options.encrypt );
-    const metadata = options.metadata || {};
-    const hasAcl = Object.prototype.hasOwnProperty.call ( options, 'acl' );
-    const acl = hasAcl ? options.acl : 'public-read';
+    const {
+        bucket = config?.s3?.Bucket,
+        contentType = 'application/json',
+        acl = 'public-read',
+        cacheControl = 'max-age=25,s-maxage=30,must-revalidate',
+        encrypt = false,
+        metadata = {}
+    } = options;
     
     if ( encrypt && ( contentType === 'application/json' || contentType === 'text/plain' ) ) {
 
@@ -233,21 +234,16 @@ exports.set = async ( key, body, options = {} ) => {
     }
 
     try {
-        const params = {
+        const command = new PutObjectCommand ( {
             Bucket: bucket,
             Key: key,
             Body: body,
             ContentType: contentType,
+            ACL: acl,
             CacheControl: cacheControl,
             Metadata: metadata,
             ContentLength: Buffer.byteLength ( body )
-        };
-
-        if ( acl !== null && acl !== undefined && acl !== false ) {
-            params.ACL = acl;
-        }
-
-        const command = new PutObjectCommand ( params );
+        } );
   
         const data = await S3.send ( command );
 
@@ -412,4 +408,4 @@ const streamToBuffer = async ( stream ) => {
     await pipelineAsync ( stream, collectorStream );
     
     return Buffer.concat ( chunks );
-};
+};

package/src/sqs.js

@@ -0,0 +1,116 @@
+const { SQSClient, SendMessageCommand, ReceiveMessageCommand, DeleteMessageCommand, DeleteMessageBatchCommand, GetQueueUrlCommand, GetQueueAttributesCommand } = require ( '@aws-sdk/client-sqs' );
+const fs = require ( 'fs' );
+let config = {};
+const configDirPath = `${ process.cwd ()}/config`;
+if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirectory () ) {
+    config = require ( 'config' ); // require the config directory if it exists
+}
+
+const resolveClientConfig = () => {
+    const region = config?.sqs?.region || process.env.AWS_REGION || 'eu-west-1';
+    const endpoint = config?.sqs?.endpoint;
+    return endpoint ? { region, endpoint } : { region };
+};
+
+const client = new SQSClient ( resolveClientConfig () );
+
+/**
+ * Resolve a queue URL by name.
+ *
+ * @param {string} queueName - The name of the queue.
+ * @returns {Promise<string>} The queue URL.
+ */
+exports.getQueueUrl = async ( queueName ) => {
+    const command = new GetQueueUrlCommand ( { QueueName: queueName } );
+    const response = await client.send ( command );
+    return response.QueueUrl;
+};
+
+/**
+ * Fetch queue attributes.
+ *
+ * @param {string} queueUrl - The queue URL.
+ * @param {string[]} [attributeNames=['All']] - Attribute names to fetch.
+ * @returns {Promise<Record<string, string>>} Attributes map.
+ */
+exports.getQueueAttributes = async ( queueUrl, attributeNames = [ 'All' ] ) => {
+    const command = new GetQueueAttributesCommand ( {
+        QueueUrl: queueUrl,
+        AttributeNames: attributeNames
+    } );
+    const response = await client.send ( command );
+    return response.Attributes || {};
+};
+
+/**
+ * Send a message to an SQS queue.
+ *
+ * @param {string} queueUrl - The queue URL.
+ * @param {string|object} messageBody - The message payload.
+ * @param {object} [options={}] - Additional SQS message options.
+ * @returns {Promise<object>} Send response.
+ */
+exports.sendMessage = async ( queueUrl, messageBody, options = {} ) => {
+    const body = typeof messageBody === 'string' ? messageBody : JSON.stringify ( messageBody );
+    const command = new SendMessageCommand ( {
+        QueueUrl: queueUrl,
+        MessageBody: body,
+        ...options
+    } );
+    return client.send ( command );
+};
+
+/**
+ * Receive messages from an SQS queue.
+ *
+ * @param {string} queueUrl - The queue URL.
+ * @param {object} [options={}] - Receive options.
+ * @returns {Promise<object[]>} Array of messages.
+ */
+exports.receiveMessages = async ( queueUrl, options = {} ) => {
+    const command = new ReceiveMessageCommand ( {
+        QueueUrl: queueUrl,
+        MaxNumberOfMessages: options.maxMessages || options.MaxNumberOfMessages || 1,
+        WaitTimeSeconds: options.waitTimeSeconds || options.WaitTimeSeconds || 10,
+        VisibilityTimeout: options.visibilityTimeout || options.VisibilityTimeout,
+        MessageAttributeNames: options.MessageAttributeNames || [ 'All' ],
+        AttributeNames: options.AttributeNames || [ 'All' ]
+    } );
+    const response = await client.send ( command );
+    return response.Messages || [];
+};
+
+/**
+ * Delete a single message from an SQS queue.
+ *
+ * @param {string} queueUrl - The queue URL.
+ * @param {string} receiptHandle - The receipt handle of the message.
+ * @returns {Promise<object>} Delete response.
+ */
+exports.deleteMessage = async ( queueUrl, receiptHandle ) => {
+    const command = new DeleteMessageCommand ( {
+        QueueUrl: queueUrl,
+        ReceiptHandle: receiptHandle
+    } );
+    return client.send ( command );
+};
+
+/**
+ * Delete multiple messages from an SQS queue.
+ *
+ * @param {string} queueUrl - The queue URL.
+ * @param {Array<{receiptHandle?: string, ReceiptHandle?: string}>} messages - Messages or receipt handles.
+ * @returns {Promise<object>} Batch delete response.
+ */
+exports.deleteMessages = async ( queueUrl, messages ) => {
+    const entries = ( messages || [] ).map ( ( msg, index ) => ( {
+        Id: String ( index ),
+        ReceiptHandle: msg?.ReceiptHandle || msg?.receiptHandle || msg
+    } ) );
+    if ( entries.length === 0 ) return { Successful: [], Failed: [] };
+    const command = new DeleteMessageBatchCommand ( {
+        QueueUrl: queueUrl,
+        Entries: entries
+    } );
+    return client.send ( command );
+};