vtlab-generic-functions 1.0.4

package/rds/utils/queryBuilder.js

@@ -0,0 +1,164 @@
+let GLOBAL_MYSQL_LIMIT = 10;
+let GLOBAL_MYSQL_OFFSET = 0;
+
+/**
+ * To build LIMIT query, 10 is the default limit
+ * @param limit
+ * @returns {string}
+ */
+const buildLimitQuery = (limit) => {
+  let limitQuery = '';
+  if (limit.length > 0) {
+    limitQuery += ` LIMIT ${limit}`;
+  } else {
+    limitQuery += ` LIMIT ${GLOBAL_MYSQL_LIMIT}`;
+  }
+  return limitQuery;
+};
+
+/**
+ * To build WHERE query
+ * @param where
+ * @returns {string}
+ */
+const buildWhereQuery = (where) => {
+  let whereQuery = '';
+  if (where.length > 0) {
+    where.forEach((item, index) => {
+      if (index === 0) {
+        whereQuery += ` WHERE ${item.column} ${item.operator} ${item.value}`;
+      } else {
+        whereQuery += ` AND ${item.column} ${item.operator} ${item.value}`;
+      }
+    });
+  }
+  return whereQuery;
+};
+
+/**
+ * To build OFFSET query
+ * @param offset
+ * @returns {string}
+ */
+const buildOffsetQuery = (offset) => {
+  let offsetQuery = '';
+  if (offset.length > 0) {
+    offsetQuery += ` OFFSET ${offset}`;
+  } else {
+    offsetQuery += ` OFFSET ${GLOBAL_MYSQL_OFFSET}`;
+  }
+  return offsetQuery;
+};
+
+/**
+ * To build ORDER BY query
+ * @param orderBy
+ * @returns {string}
+ */
+const buildOrderByQuery = (orderBy) => {
+  let orderByQuery = '';
+  if (orderBy.length > 0) {
+    orderBy.forEach((item, index) => {
+      if (index === 0) {
+        orderByQuery += ` ORDER BY ${item.key} ${item.order}`;
+      } else {
+        orderByQuery += `, ${item.key} ${item.order}`;
+      }
+    });
+  }
+  return orderByQuery;
+};
+
+/**
+ * To build INSERT query
+ * @param tableName
+ * @param data
+ * @returns {string}
+ */
+const buildInsertQuery = (tableName, data) => {
+  let insertQuery = `INSERT INTO \`${tableName}\``;
+  let keys = Object.keys(data);
+  let values = keys.map(key => data[key]);
+  insertQuery += `(${keys.join(', ')}) VALUES (${values.join(', ')})`;
+  return insertQuery;
+};
+
+/**
+ * To build UPDATE Query
+ * @param tableName
+ * @param data
+ * @param where
+ * @returns {string}
+ */
+const buildUpdateQuery = (tableName, data, where) => {
+
+  let updateQuery = `UPDATE \`${tableName}\` SET`;
+  let keys = Object.keys(data);
+  let values = keys.map(key => data[key]);
+  keys.forEach((key, index) => {
+    if (index === 0) {
+      updateQuery += ` ${key} = ${values[index]}`;
+    } else {
+      updateQuery += `, ${key} = ${values[index]}`;
+    }
+  });
+  updateQuery += buildWhereQuery(where);
+  return updateQuery;
+};
+
+/**
+ * to build DELETE query
+ * @param tableName
+ * @param where
+ * @returns {string}
+ */
+const buildDeleteQuery = (tableName, where) => {
+  let deleteQuery = `DELETE FROM \`${tableName}\``;
+  deleteQuery += buildWhereQuery(where);
+  return deleteQuery;
+};
+
+/**
+ * to build SELECT query
+ * @param tableName
+ * @param where
+ * @param orderBy
+ * @param limit
+ * @param offset
+ * @returns {string}
+ */
+const buildSelectQuery = (tableName = '', where = [], orderBy = [], limit = GLOBAL_MYSQL_LIMIT, offset = GLOBAL_MYSQL_OFFSET) => {
+  let selectQuery = `SELECT * FROM \`${tableName}\``;
+  selectQuery += buildWhereQuery(where);
+  selectQuery += buildOrderByQuery(orderBy);
+  selectQuery += buildLimitQuery(limit);
+  selectQuery += buildOffsetQuery(offset);
+  return selectQuery;
+};
+
+/**
+ * to build create table query
+ * @param tableName
+ * @param columns
+ * @returns {string}
+ */
+const buildCreateTableQuery = (tableName, columns) => {
+  let createTableQuery = `CREATE TABLE \`${tableName}\` (`;
+  let keys = Object.keys(columns);
+  let values = keys.map(key => columns[key]);
+  createTableQuery += `${keys.join(', ')}`;
+  createTableQuery += `) ENGINE=InnoDB DEFAULT CHARSET=utf8;`;
+  return createTableQuery;
+};
+
+
+module.exports = {
+  buildLimitQuery,
+  buildWhereQuery,
+  buildOffsetQuery,
+  buildOrderByQuery,
+  buildInsertQuery,
+  buildUpdateQuery,
+  buildDeleteQuery,
+  buildSelectQuery
+};

package/s3bucket/index.js

@@ -0,0 +1,175 @@
+const { S3Client, PutObjectCommand, GetObjectCommand, getSignedUrl } = require("@aws-sdk/client-s3");
+const config = require('../config');
+const multer = require('multer');
+const multerS3 = require('multer-s3');
+const { promisesCollector } = require('../utils');
+
+/**
+ * Uploads a file to an S3 bucket.
+ *
+ * @param {string} path - The path (including the file name) where the file will be stored in the bucket.
+ * @param {Buffer|string} file - The file data to upload. Can be a Buffer or a string.
+ * @param {Object} options - Additional options for the S3 upload (e.g., ACL, ContentType).
+ * @param {string} [bucketName="s3bucket"] - The name of the S3 bucket on the config. Defaults to 's3bucket'.
+ * @returns {Promise<string>} - A promise that resolves to the path of the uploaded file.
+ * @throws {Error} - Throws an error if the upload fails.
+ */
+const uploadToS3 = async (path, file, options, bucketName = "s3bucket") => {
+  try {
+    const allConfig = await config.get();
+    const bucket = allConfig[bucketName];
+    if (!bucket) {
+      throw new Error(`Bucket ${bucketName} not found in config`);
+    }
+
+    const s3Client = new S3Client({
+      credentials: {
+        accessKeyId: allConfig.awsCredentials.accessKeyId,
+        secretAccessKey: allConfig.awsCredentials.secretAccessKey,
+      },
+      region: allConfig.awsCredentials.region,
+    });
+
+    const command = new PutObjectCommand({
+      Bucket: bucket,
+      Key: path,
+      Body: file,
+      ACL: 'public-read',
+      ...options
+    });
+
+    await s3Client.send(command);
+    return path;
+  } catch (error) {
+    throw error;
+  }
+};
+
+/**
+ * Creates a multer instance configured to upload files to an S3 bucket.
+ *
+ * @returns {Promise<Multer>} - A promise that resolves to a Multer instance.
+ * @throws {Error} - Throws an error if the configuration fails.
+ */
+const uploadMultiForm = async () => {
+  const allConfig = await config.get();
+  const s3Client = new S3Client({
+    credentials: {
+      accessKeyId: allConfig.awsCredentials.accessKeyId,
+      secretAccessKey: allConfig.awsCredentials.secretAccessKey,
+    },
+    region: allConfig.awsCredentials.region
+  });
+
+  return multer({
+    storage: multerS3({
+      s3: s3Client,
+      bucket: allConfig.s3bucket,
+      acl: 'private',
+      metadata: (req, file, cb) => {
+        cb(null, { fieldName: file.fieldname });
+      },
+      key: (req, file, cb) => {
+        const url = `${req.internalParams.filesUrl}/${file.originalname}`;
+        cb(null, url);
+      }
+    }),
+    limits: {
+      fileSize: 50 * 1024 * 1024, // 50 MB
+      fields: 20,
+      parts: 100,
+    },
+  });
+};
+
+/**
+ * Downloads a file from an S3 bucket.
+ *
+ * @param {string} path - The path (including the file name) of the file in the S3 bucket.
+ * @returns {Promise<Object>} - A promise that resolves to the downloaded file data.
+ * @throws {Error} - Throws an error if the download fails.
+ */
+const downloadFileFromS3 = async (path) => {
+  try {
+    const allConfig = await config.get();
+    const s3Client = new S3Client({
+      credentials: {
+        accessKeyId: allConfig.awsCredentials.accessKeyId,
+        secretAccessKey: allConfig.awsCredentials.secretAccessKey,
+      },
+      region: allConfig.awsCredentials.region
+    });
+
+    const command = new GetObjectCommand({
+      Bucket: allConfig.s3bucket,
+      Key: path
+    });
+
+    const data = await s3Client.send(command);
+    return data;
+  } catch (error) {
+    throw error;
+  }
+};
+
+/**
+ * Uploads multiple files to an S3 bucket.
+ *
+ * @param {string} path - The base path where the files will be stored in the bucket.
+ * @param {Array<Object>} files - An array of file objects to upload.
+ * @param {string} [extension='pdf'] - The extension to append to each file.
+ * @param {Object} [options={}] - Default options for each file upload.
+ * @returns {Promise<Array<string>>} - A promise that resolves to an array of paths of the uploaded files.
+ * @throws {Error} - Throws an error if the upload fails.
+ */
+const uploadFilesToS3 = async (path, files, extension = 'pdf', options = {
+  ACL: "private",
+  ContentEncoding: "base64",
+  ContentType: "application/pdf",
+}) => {
+  if (files.length === 0 || !path) {
+    return "";
+  }
+
+  return promisesCollector(files, async (_file) => {
+    let _path = `${path}${new Date().getTime()}.${extension}`;
+    try {
+      let file = Buffer.from(_file.content, "base64");
+      return uploadToS3(_path, file, options);
+    } catch (error) {
+      throw new Error("Error creating file in AWS");
+    }
+  });
+};
+
+/**
+ * Generates a presigned URL for a file stored in an S3 bucket.
+ *
+ * @param {string} bucket - The name of the S3 bucket.
+ * @param {string} key - The key of the file in the S3 bucket.
+ * @param {number} [expirationInSeconds=2592000] - The expiration time of the URL in seconds. Defaults to 30 days.
+ * @returns {Promise<string>} - A promise that resolves to the presigned URL.
+ * @throws {Error} - Throws an error if the URL generation fails.
+ */
+const generatePresignedUrl = async (bucket, key, expirationInSeconds = 86400 * 30) => {
+  try {
+    const s3Client = new S3Client();
+
+    const command = new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    });
+
+    return await getSignedUrl(s3Client, command, { expiresIn: expirationInSeconds });
+  } catch (error) {
+    throw error;
+  }
+};
+
+module.exports = {
+  uploadToS3,
+  downloadFileFromS3,
+  uploadMultiForm,
+  uploadFilesToS3,
+  generatePresignedUrl
+};

package/soap/index.js

@@ -0,0 +1,71 @@
+const soapRequest = require('easy-soap-request');
+var xml2js = require('xml2js');
+
+
+/**
+ * Private fucntions
+ */
+
+
+
+
+/**
+ * API functions
+ */
+
+/**
+ * This function will send a SOAP Request
+ * @param {string} url
+ * @param {string} headers {'user-agent': '' , 'Content-type': '', 'soapAction': ''}
+ * @param {string} xml 
+ * @param {int} timeout 
+ * @returns {Promise} {           
+ *                      headers,
+ *                      body,
+ *                      statusCode
+ *                    }
+ * @throw error: If validate method fails.
+ */
+const sendSoapRequest = async ({url, headers, xml, timeout=3000 }) => {
+    try{
+        let {response} = await soapRequest({ url: url, headers: headers, xml: xml, timeout});
+        return  response; //{ headers, body, statusCode }
+    }catch(err){
+        throw err;
+    }
+}
+
+const getSoapHeaders = ({contentType='text/xml;charset=UTF-8', soapAction, userAgent}) =>{
+   let headers= {}
+   headers['Content-type'] = contentType;
+   if(soapAction) headers['SOAPAction'] = soapAction;
+   if (userAgent) headers['user-agent'] = userAgent;
+   return headers;
+}
+
+const xmlToJson = async (dataXml, options) =>{
+    try{
+        let jsonRes = xml2js.parseStringPromise(dataXml,options);
+        return jsonRes;
+    }catch(err){
+        throw err;
+    }
+}
+
+const jsonToXml = async (dataJson,options) =>{
+    try{
+        let builder = new xml2js.Builder(); 
+        let xmlRes = builder.buildObject(dataJson);
+        return xmlRes;
+    }catch(err){
+        throw err
+    }
+}
+
+
+module.exports = {
+    sendSoapRequest,
+    getSoapHeaders,
+    xmlToJson,
+    jsonToXml
+}

package/sqs/index.js

@@ -0,0 +1,85 @@
+const { SQSClient, SendMessageCommand } = require("@aws-sdk/client-sqs");
+const config = require('../config');
+const validator = require('../validator');
+
+/**
+ * Sends a message to an SQS queue.
+ *
+ * @param {Object} message - The message to be sent to the queue.
+ * @param {string} queueUrl - The URL of the SQS queue.
+ * @param {boolean} [isFIFOQueue=true] - Specifies if the queue is a FIFO queue.
+ * @returns {Promise<Object>} - A promise that resolves to the response from SQS.
+ * @throws {Error} - Throws an error if sending the message fails.
+ */
+const sendSQSMessage = async (message, queueUrl, isFIFOQueue = true) => {
+    try {
+        const awsCredentials = await config.get('awsCredentials');
+        const environment = process.env.NODE_ENV || 'develop';
+
+        const sqsClient = new SQSClient({
+            region: awsCredentials.region,
+            credentials: {
+                accessKeyId: awsCredentials.accessKeyId,
+                secretAccessKey: awsCredentials.secretAccessKey
+            }
+        });
+
+        const params = {
+            MessageBody: JSON.stringify(message),
+            QueueUrl: queueUrl,
+        };
+
+        if (isFIFOQueue) {
+            params.MessageGroupId = environment;
+        }
+
+        const command = new SendMessageCommand(params);
+        const data = await sqsClient.send(command);
+        return data;
+    } catch (error) {
+        throw error;
+    }
+};
+
+/**
+ * Saves a job event to an SQS queue.
+ *
+ * @param {Object} [document={}] - The job event document to be saved.
+ * @returns {Promise<Object>} - A promise that resolves to the response from SQS.
+ * @throws {Error} - Throws an error if saving the job event fails.
+ */
+const saveJobEvent = async (document = {}) => {
+    try {
+        const jobEvent = validator.validate(document, 'jobEvent');
+        const queue = await config.get('microservices.sqs.jobEvent');
+        const environment = process.env.NODE_ENV || 'develop';
+
+        return sendSQSMessage({ document: jobEvent, environment }, queue);
+    } catch (error) {
+        throw error;
+    }
+};
+
+/**
+ * Saves an integration message to an SQS queue.
+ *
+ * @param {Object} [document={}] - The integration message document to be saved.
+ * @returns {Promise<Object>} - A promise that resolves to the response from SQS.
+ * @throws {Error} - Throws an error if saving the integration message fails.
+ */
+const saveIntegrationMessages = async (document = {}) => {
+    try {
+        const integrationMessages = validator.validate(document, 'integrationMessages');
+        const queue = await config.get('microservices.sqs.integrationMessage');
+        const environment = process.env.NODE_ENV || 'develop';
+
+        return sendSQSMessage(integrationMessages, queue, false);
+    } catch (error) {
+        throw error;
+    }
+};
+
+module.exports = {
+    saveJobEvent,
+    saveIntegrationMessages
+};