vtlab-generic-functions 1.0.4

package/mysql/README.md

@@ -0,0 +1,29 @@
+#### models
+each file represents the table name in the mysql database.
+
+#### utils/querybuilder
+To build the query, mostly imported in the models
+
+#### index.js
+extend the export by including the models/{table}
+
+### Example usage from Lambda JS:
+```
+const pelMysql = require('/opt/mysql');
+
+const db = pelMysql.connectToDatabase({
+    host: 'localhost',
+    user: 'root',
+    password: 'example',
+    database: 'pel',
+    port: 3306
+});
+
+let users = pelMysql.get_all_users(db, function (err, data) {
+    if (err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
+```

package/mysql/connect-to-mysqldb.js

@@ -0,0 +1,26 @@
+const mysql = require('mysql');
+
+const connectToDatabase = function (params) {
+  if (!params.host || !params.port || !params.user || !params.password || !params.database) {
+    throw new Error('Missing required parameters');
+  }
+
+  let connection = mysql.createConnection({
+    host: params.host,
+    user: params.user,
+    password: params.password,
+    database: params.database,
+    port: params.port,
+    charset: 'utf8'
+  });
+
+  connection.connect(function (err) {
+    if (err) throw (err);
+  });
+
+  return connection;
+};
+
+module.exports = {
+  connectToDatabase,
+};

package/mysql/index.js

@@ -0,0 +1,8 @@
+const MYSQLClient = require('./connect-to-mysqldb');
+const users = require('./models/users');
+
+module.exports = {
+    ...MYSQLClient,
+    ...users,
+    // ...other_table
+};

package/mysql/models/users.js

@@ -0,0 +1,47 @@
+/**
+ * This is just a sample/test template for you to copy for the actual table in the DB.
+ */
+
+const queryBuilder = require('../utils/queryBuilder');
+
+/**
+ * to get uses by ID
+ * @param id String
+ * @param callback onSuccess(error, result)
+ */
+const get_user_by_id = function (db_connection, id, callback) {
+
+  let where = [{
+    key: 'id',
+    value: id,
+  }];
+
+  db_connection.query(queryBuilder.buildSelectQuery('users', where), function (err, result) {
+    if (err) {
+      callback(err, null);
+    } else {
+      callback(null, result);
+    }
+  });
+
+}
+
+/**
+ * to get all the users in the table
+ * @param callback onSuccess(error, result)
+ */
+const get_all_users = function (db_connection, callback) {
+  db_connection.query(queryBuilder.buildSelectQuery('users'), function (err, result) {
+    if (err) {
+      callback(err, null)
+    } else {
+      callback(null, result)
+    }
+  });
+}
+
+
+module.exports = {
+  get_user_by_id,
+  get_all_users
+}

package/mysql/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.key} = ${item.value}`;
+      } else {
+        whereQuery += ` AND ${item.key} = ${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/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "vtlab-generic-functions",
+  "version": "1.0.4",
+  "scripts": {
+    "test": "jest"
+  },
+  "dependencies": {
+    "@aws-sdk/client-lambda": "^3.478.0",
+    "@aws-sdk/client-s3": "^3.478.0",
+    "@aws-sdk/client-ses": "^3.478.0",
+    "@aws-sdk/client-sqs": "^3.478.0",
+    "axios": "^1.6.2",
+    "countries-code": "^1.1.0",
+    "country-data": "0.0.31",
+    "csv-parse": "^4.16.0",
+    "dot-object": "^2.1.4",
+    "easy-soap-request": "^4.8.0",
+    "flatted": "^3.2.2",
+    "html-pdf": "^3.0.1",
+    "joi": "^17.4.1",
+    "jsftp": "^2.1.3",
+    "mongodb": "^4.0.1",
+    "multer": "^1.4.4",
+    "multer-s3": "^2.9.0",
+    "mysql": "^2.18.1",
+    "node-xlsx": "^0.17.2",
+    "node-zip": "^1.1.1",
+    "nodemailer": "^6.6.3",
+    "phantomjs-prebuilt": "^2.1.16",
+    "postal-codes-js": "^2.5.2",
+    "promise-ftp": "^1.3.5",
+    "save": "^2.4.0",
+    "ssh2-sftp-client": "^7.0.0",
+    "vtlab-timezone-utils": "^1.0.15",
+    "xlsx": "^0.18.5",
+    "xml2js": "^0.6.2"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "nodemailer-mock": "^2.0.3",
+    "sinon": "^17.0.1"
+  }
+}

package/parsingFiles/index.js

@@ -0,0 +1,114 @@
+var fs = require('fs'); 
+var parse = require('csv-parse');
+var XLSX = require('xlsx');
+
+
+const CODES_TYPE = {
+   EXTENSION_NOT_FOUND: 'extension_not_found',
+   GENERIC_ERROR: 'generic_error',
+   SUCCESSFULL_OP: 'succesfull_op'
+
+}
+
+/**
+ * Private functions
+ */
+/*Transform headers is need. For example: delete blanks...etc.
+const processHeadersFromFile = ({typeOp='',headers=[]}) =>{
+    return headers;
+}
+
+const fromArrayToObjectArray = ({headers, data}) =>{
+    let objArrayResult = [];
+    headers = processHeadersFromFile({typeOp:'',headers})
+    objArrayResult = data.map(dataItem => {
+        let objResult = {}
+        headers.forEach((headersItem, index) => {
+            objResult[headersItem] = dataItem[index] ? dataItem[index] : '';
+        });
+        return objResult;
+    })
+
+    return objArrayResult;
+}*/
+
+/**
+ * Public functions
+ */
+
+
+const fileToJson =  ({filePathWithName,delimiter=',',columns=true,params}) =>{
+    return new Promise ((resolve, reject)=> {
+        let result = null;
+
+        try{
+            let extension = filePathWithName.split('.')[filePathWithName.split('.').length - 1];
+
+            switch (extension.toLowerCase()) {
+                case 'xlsx':
+                    var workbook = XLSX.readFile(filePathWithName);
+                    var sheet_name_list = workbook.SheetNames;
+                    result = XLSX.utils.sheet_to_json(workbook.Sheets[sheet_name_list[0]],{defval: ""})
+                    return resolve({
+                        code: CODES_TYPE.SUCCESSFULL_OP,
+                        message: 'Operación realizada correctamente',
+                        data :result
+                    });
+                break;
+                case 'txt':
+                case 'csv':
+                    result = [];
+                    
+                    fs.createReadStream(filePathWithName)
+                        .pipe(
+                            parse({
+                                ...params,
+                                columns: columns,
+                                delimiter: delimiter
+                            }))
+                        .on('data', function(csvrow) {
+                            result.push(csvrow);        
+                        })
+                        .on('error',function(err) {
+                            return reject( {code: CODES_TYPE.GENERIC_ERROR,
+                                message: 'Error durante el procesado del fichero',
+                                alternative: 'Revisar el error retornado',
+                                dataError: err
+                            })
+                        })
+                        .on('end',function() {
+                            return resolve({
+                                code: CODES_TYPE.SUCCESSFULL_OP,
+                                message: 'Operación realizada correctamente',
+                                data :result
+                            })
+                        });
+                              
+                    break;
+
+                default:
+                    return reject({
+                        code : EXTENSION_NOT_FOUND,
+                        message : `La extensión ${extension} no está prevista`,
+                        alternative: 'Por favor, pruebe con una de las extensiones previstas',
+                        dataError:{}
+                    });
+            }
+        }catch(err){
+           
+            return reject({
+                code : CODES_TYPE.GENERIC_ERROR,
+                message : 'Error procesando el fichero',
+                alternative: 'Revise la información de error',
+                dataError: err
+            })
+        }
+    })
+
+   
+}
+
+
+module.exports = {
+    fileToJson
+}

package/pdf/index.js

@@ -0,0 +1,34 @@
+const htmlToPdf = require('html-pdf');
+
+/**
+ * Convierte el contenido de un archivo en formato string a un archivo PDF.
+ * @param {string} content - El contenido del archivo en formato string.
+ * @param {Object} [options] - Opciones para personalizar la configuración de html-pdf.
+ * @param {string} [options.format='Letter'] - El formato de papel del PDF.
+ * @param {string} [options.orientation='portrait'] - La orientación de la página.
+ * @param {number} [options.border='10mm'] - El ancho del borde de la página.
+ * @param {string} [options.header] - Una cadena que especifica el encabezado de la página.
+ * @param {string} [options.footer] - Una cadena que especifica el pie de página de la página.
+ * @returns {Promise<Buffer>} - Un Buffer del archivo PDF generado.
+ */
+const  convertToPdf = (content, options = {}) =>  {
+  const {
+    format = 'Letter',
+    orientation = 'portrait',
+    border = '10mm',
+    header = '',
+    footer = ''
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    htmlToPdf.create(content, { format, orientation, border, header, footer }).toBuffer((err, buffer) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(buffer);
+      }
+    });
+  });
+}
+
+module.exports = convertToPdf;

package/postalCode/index.js

@@ -0,0 +1,38 @@
+const postalCodes = require('postal-codes-js');
+
+/**
+ * This function will transform the incoming values received on data onto the outgoing mapped values, returning a JSON object.
+ * @param {string} countryCode ISO 3166-1 alpha-2 or alpha-3 country code as string.
+ * @param {string} postalCode Postal code as string or number.
+ * @returns {Promise} {           
+ *                      isValid: true | false
+ *                      message: Indicates why it is no valid (isValid: false) or it operations was ok.
+ *                    }
+ * @throw error: If validate method fails.
+ */
+ const isValidPostalCode = async ({countryCode , postalCode }) => {
+
+    try{
+        let isValid = postalCodes.validate(countryCode, postalCode);
+
+        if(isValid === true){
+            return {
+                isValid: true,
+                message:'Postal code exists for the input country'
+            }
+        }else{
+            return {
+                isValid: false,
+                message: isValid
+            }
+        }
+    }catch(err){
+        throw err;
+    }
+
+ }
+
+
+ module.exports = {
+    isValidPostalCode
+ }

package/rds/connect-to-rdsdb.js

@@ -0,0 +1,33 @@
+const mysql = require('mysql');
+
+const connectToDatabase = function (params) {
+    return new Promise((resolve, reject) => {
+
+        if (!params.host || !params.port || !params.user || !params.password || !params.database) {
+            reject(new Error('Missing required parameters'));
+        }
+
+        let connection = mysql.createConnection({
+            host: params.host,
+            user: params.user,
+            password: params.password,
+            database: params.database,
+            port: params.port,
+            charset: 'utf8'
+        });
+
+        connection.connect(function (err) {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(connection);
+            }
+        });
+
+    });
+
+};
+
+module.exports = {
+    connectToDatabase
+};

package/rds/index.js

@@ -0,0 +1,33 @@
+const config = require('../config');
+const RDSConnection = require('./connect-to-rdsdb');
+const queryBuilder = require('./utils/queryBuilder');
+const {getValueOrNull} = require('../utils/index');
+/**
+ * To connect RDS Database. It's always mysql present in out AWS
+ * @param path
+ * @returns db connection
+ */
+const connectMyRDS = async (databaseName) => {
+    try {
+        const dbParams = await config.get(databaseName, 'rds');
+
+        if (!dbParams) {
+            throw new Error('Database name is not valid in the Secret Manager');
+        }
+
+        dbParams.database = databaseName;
+        dbParams.port = dbParams.port || 3306;
+
+        const connection = await RDSConnection.connectToDatabase(dbParams);
+        return connection;
+    } catch (error) {
+        throw error;
+    }
+
+};
+
+//export
+module.exports = {
+    connectMyRDS,
+    ...queryBuilder
+}