vtlab-generic-functions 1.0.4

package/axios/README.md

@@ -0,0 +1,30 @@
+### Example usage from Lambda JS:
+
+```javascript
+    let result = await pelRequest.get('https://api.sampleapis.com/coffee/hot', {
+      "auth": {
+        "test": "test"
+      },
+      "logId": "apiGateway/microservices",
+      "payload": []
+    });
+
+    console.log(result.data);
+
+```
+
+#### Example SOAP usage from Lambda JS:
+```javascript
+let result = await pelRequest.sendSoapRequest('http://www.gcomputer.net//webservices/dilbert.asmx', {
+    "auth": {
+        "test": "test"
+    },
+    "logId": "apiGateway/microservices",
+    "payload": xml,
+    "headers": {
+        "SOAPAction": "http://gcomputer.net/webservices/DailyDilbert"
+    }
+});
+
+console.log(result);
+```

package/axios/index.js

@@ -0,0 +1,287 @@
+const axios = require('axios');
+const Joi = require('joi');
+const axiosLogs = require('./logs');
+
+// set axios defaults
+axios.defaults.timeout = 120000;
+axios.defaults.headers.post['Content-Type'] = 'application/json';
+axios.defaults.headers.get['Content-Type'] = 'application/json';
+axios.defaults.headers.put['Content-Type'] = 'application/json';
+axios.defaults.headers.patch['Content-Type'] = 'application/json';
+axios.defaults.headers.post['Accept'] = 'application/json';
+axios.defaults.headers.get['Accept'] = 'application/json';
+axios.defaults.headers.put['Accept'] = 'application/json';
+axios.defaults.headers.patch['Accept'] = 'application/json';
+
+/**
+ * Joi schema validation for request param
+ * @type {Joi.ObjectSchema<any>}
+ */
+const paramSchema = Joi.object({
+    'logId': Joi.string().max(200).required().trim(), //this for us to store the request in the cloduwatch
+    'payload': Joi.alternatives().try(Joi.array(), Joi.object(), Joi.string()).optional(), // this for the marketplace or 3rd party
+    'config': Joi.object().optional(), // this to config the axios
+    'headers': Joi.object().optional() // this to set/configure the headers like auth or anything
+});
+
+/**
+ * validate params against paramSchema
+ * @param params Object request param
+ * @returns {any} Object of valid param or Joi's error validation message
+ */
+const validateParams = (params) => {
+    let result = paramSchema.validate(params, { abortEarly: false, stripUnknown: true });
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.value;
+};
+
+/**
+ * list of things before makes axios request
+ * @param url
+ * @param params
+ * @returns {Promise<void>}
+ * @private
+ */
+const _beforeRequestHook = async (url, params) => {
+    await axiosLogs.processLogAndUploadToCW(params, params.logId)
+};
+
+/**
+ * list of this after axios SUCCESS response
+ * @param url
+ * @param params
+ * @param response
+ * @returns {Promise<void>}
+ * @private
+ */
+const _afterRequestSuccessHook = async (url, params, response) => {
+    // Do something after request is sent
+    let logValue = JSON.stringify({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        config: response.config,
+        data: response.data
+    });
+
+    await axiosLogs.processLogAndUploadToCW(logValue, params.logId);
+};
+
+/**
+ * list of this after axios ERROR response
+ * @param url
+ * @param params
+ * @param response
+ * @returns {Promise<void>}
+ * @private
+ */
+const _afterRequestErrorHook = async (url, params, response) => {
+    // Do something after request is sent
+    let logValue = JSON.stringify({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        config: response.config,
+        data: response.data,
+        isAxiosError: response.isAxiosError,
+        message: response.message,
+        stack: response.stack
+    });
+
+    await axiosLogs.processLogAndUploadToCW(logValue, params.logId);
+};
+
+/**
+ * filter payload from params
+ * @param params
+ * @returns {*[]}
+ * @private
+ */
+const _preparePayload = (params) => {
+    return params.payload || '';
+};
+
+/**
+ * Make axios request
+ * @param url
+ * @param params
+ * @param method
+ * @returns {Promise<unknown>}
+ */
+const request = (url, params, method) => {
+    return new Promise(async (resolve, reject) => {
+        //validate
+        let validParam = validateParams(params);
+
+        let configurationParams = {};
+
+        //steps before making request
+        await _beforeRequestHook(url, validParam);
+
+        //prepare payload
+        let payload = _preparePayload(validParam);
+        // console.log(`${method} ${url}`, payload);
+
+        // if any custom headers are required, add them to the request
+        if (validParam.headers) {
+            configurationParams['headers'] = validParam.headers;
+        }
+
+        // add config params
+        if (validParam.config) {
+            configurationParams = {
+                ...configurationParams,
+                ...validParam.config
+            }
+        }
+
+        //lets make axios request
+        axios[method](url, payload, configurationParams).then(async function (response) {
+
+            //success request
+            await _afterRequestSuccessHook(url, validParam, response);
+            resolve(response);
+        })
+            .catch(async function (error) {
+
+                //error response
+                await _afterRequestErrorHook(url, validParam, error);
+                reject(error);
+            });
+    });
+};
+
+/**
+ * Make axios request
+ * @param url
+ * @param params
+ * @param method
+ * @returns {Promise<unknown>}
+ */
+const getRequest = (url, params, method) => {
+    return new Promise(async (resolve, reject) => {
+        //validate
+        let validParam = validateParams(params);
+
+        let configurationParams = {};
+
+        //steps before making request
+        await _beforeRequestHook(url, validParam);
+
+        //prepare payload
+        let payload = _preparePayload(validParam);
+        // console.log(`${method} ${url}`, payload);
+
+        // if any custom headers are required, add them to the request
+        if (validParam.headers) {
+            configurationParams['headers'] = validParam.headers;
+        }
+
+        // add config params
+        if (validParam.config) {
+            configurationParams = {
+                ...configurationParams,
+                ...validParam.config
+            }
+        }
+
+        //lets make axios request
+        axios[method](url, configurationParams).then(async function (response) {
+
+            //success request
+            await _afterRequestSuccessHook(url, validParam, response);
+            resolve(response);
+        })
+          .catch(async function (error) {
+
+              //error response
+              await _afterRequestErrorHook(url, validParam, error);
+              reject(error);
+          });
+    });
+};
+
+/**
+ * GET request handler
+ * @param url
+ * @param params
+ * @returns {Promise<*>}
+ */
+const get = async (url, params) => {
+    return await getRequest(url, params, 'get');
+};
+
+/**
+ * POST method handler
+ * @param url
+ * @param params
+ * @returns {Promise<*>}
+ */
+const post = async (url, params) => {
+    return await request(url, params, 'post');
+};
+
+/**
+ * PUT request handler
+ * @param url
+ * @param params
+ * @returns {Promise<*>}
+ */
+const put = async (url, params) => {
+    return await request(url, params, 'put');
+};
+
+/**
+ * PATCH request handler
+ * @param url
+ * @param params
+ * @returns {Promise<*>}
+ */
+const patch = async (url, params) => {
+    return await request(url, params, 'patch');
+};
+
+
+/**
+ * DELETE request handler
+ * @param url
+ * @param params
+ * @returns {Promise<*>}
+ */
+const deletion = async (url, params) => {
+    return await getRequest(url, params, 'delete');
+};
+
+const sendSoapRequest = async (url, params) => {
+    //default headers
+    const headers = {
+        'Content-Type': 'text/xml; charset=utf-8',
+    };
+    params.headers = Object.assign(params.headers, headers);
+    /*If you need to add aditional header. Add it in the params
+    eg header params
+    {
+        "auth": {
+            ...
+        },
+        "logId": "...",
+        "payload": xml,
+        "headers": {
+            "SOAPAction": "http://gcomputer.net/webservices/DailyDilbert"
+        }
+    }*/
+
+    return await post(url, params);
+}
+
+// export the request handler
+module.exports = {
+    get,
+    post,
+    put,
+    patch,
+    deletion,
+    sendSoapRequest
+};

package/axios/logs.js

@@ -0,0 +1,110 @@
+const cloudwatch = require('../cloudwatch');
+const s3bucket = require('../s3bucket');
+const secretsManager = require('../config');
+
+/**
+ * Processes a payload, checks its size, and if it's larger than the max size, uploads it to an S3 bucket.
+ *
+ * @async
+ * @param {string | Buffer | object} payload - The payload to process. Can be a string, a Buffer, or an object.
+ * @returns {Promise<string>} If the payload is larger than the max size, returns a presigned URL to the payload in the S3 bucket. Otherwise, returns the original payload.
+ * @throws {Error} If the payload is an unsupported data type.
+ */
+const processPayload = async (payload) => {
+  // Maximum payload size in kilobytes
+  const maxPayloadSize = 15;
+
+  // Initialize dataSize with a default value
+  let dataSize = 0;
+
+  if (payload) {
+    // If the payload is a string, calculate the byte length of the string
+    if (typeof payload === 'string') {
+      dataSize = Buffer.byteLength(payload);
+    }
+    // If the payload is an object, stringify it and then calculate the byte length of the string
+    else if (typeof payload === 'object') {
+      dataSize = Buffer.byteLength(JSON.stringify(payload));
+    }
+    // If the payload is a Buffer, use its length property
+    else if (Buffer.isBuffer(payload)) {
+      dataSize = payload.length;
+    }
+    // If the payload is of another type, try to convert it to a string and then calculate the byte length
+    else {
+      try {
+        let dataToString = String(payload);
+        dataSize = Buffer.byteLength(dataToString);
+      } catch (e) {
+        throw new Error('Unsupported data type');
+      }
+    }
+  }
+
+  // Calculate the size of the data in kilobytes
+  const dataSizeKB = dataSize / 1024;
+
+  // Determine the environment
+  const environment = process.env.NODE_ENV === "production" ? "production" : "develop";
+
+  // Initialize response with the original payload
+  let response = payload;
+
+  // Create the path for the S3 bucket
+  const path = `${environment}/axios/${Date.now()}.txt`;
+
+  // If the payload size is larger than the maximum size, upload it to the S3 bucket and generate a presigned URL
+  if(dataSizeKB > maxPayloadSize) {
+    let bucketOptions = {
+      ACL: "private",
+      ContentType: 'text/plain'
+    }
+    let bucketConfirmedPath =  await s3bucket.uploadToS3(path, payload, bucketOptions, "s3LogsBucket");
+    console.log("bucketConfirmedPath", bucketConfirmedPath);
+    // get bucket name from secrets manager
+    let bucket = await secretsManager.get('s3LogsBucket');
+    console.log("bucket", bucket);
+    let signedURL = s3bucket.generatePresignedUrl(bucket, path);
+    console.log("signedURL", signedURL)
+
+    // Update the response to be the presigned URL
+    response = `Payload size too big. Read the full log here: ${signedURL}`;
+  }
+
+  // Return the response
+  return response;
+}
+
+
+
+/**
+ * Processes a log and uploads it to CloudWatch.
+ *
+ * @async
+ * @param {string | Buffer | object} log - The log to process and upload.
+ * @param {string} logId - The ID of the log.
+ */
+const processLogAndUploadToCW = async (log, logId) => {
+  try {
+    // If the global variable SKIPAXIOSLOGS is set to true, don't process or upload the log
+    if (global.SKIPAXIOSLOGS) {
+      return;
+    }
+
+    // Process the log payload
+    let logValue = await processPayload(log);
+
+    // Upload the processed log to CloudWatch
+    await cloudwatch.putLogEvents(logValue, logId);
+
+  } catch (e) {
+    // If an error occurs, log it
+    console.log("Layer error processLogAndUploadToCW: ", e);
+  }
+}
+
+
+
+module.exports = {
+  processLogAndUploadToCW
+};

package/axios/utils.js

@@ -0,0 +1,37 @@
+const xml2js = require('xml2js');
+
+/**
+ * convert xml to JSON
+ * @param dataXml
+ * @param options
+ * @returns {Promise<*>}
+ */
+
+ const XMLToJSON = async (dataXml, options) =>{
+    try{
+        return xml2js.parseStringPromise(dataXml,options);
+    }catch(err){
+        throw err;
+    }
+}
+
+/**
+ * convert JSON to XML
+ * @param dataJson
+ * @param options
+ * @returns {Promise<*>}
+ */
+ const JSONToXML = async (dataJson, options) =>{
+    try{
+        let builder = new xml2js.Builder(); 
+        return builder.buildObject(dataJson);
+    }catch(err){
+        throw err
+    }
+}
+
+
+module.exports = {
+    XMLToJSON,
+    JSONToXML
+}

package/cloudwatch/index.js

@@ -0,0 +1,109 @@
+const { SQSClient, SendMessageCommand } = require('@aws-sdk/client-sqs');
+const { randomUUID } = require('crypto');
+const config = require('../config');
+
+if (!global.LOG_STREAM_NAME) {
+    global.LOG_STREAM_NAME = `${process.env.AWS_LAMBDA_FUNCTION_NAME}-${process.env.AWS_LAMBDA_LOG_STREAM_NAME}-${randomUUID()}`;
+}
+
+const putLogEvents = async (logEvents = [], logGroupName, logLevel = 2, logStreamName = null) => {
+    if (logLevel === 0) {
+        return;
+    }
+
+    if (!logGroupName) {
+        throw new Error('logEvents and logGroupName are required');
+    }
+
+    let awsCredentials = await config.get('awsCredentials');
+    const sqsClient = new SQSClient({
+        region: awsCredentials.region,
+        credentials: {
+            accessKeyId: awsCredentials.accessKeyId,
+            secretAccessKey: awsCredentials.secretAccessKey
+        }
+    });
+
+    Array.isArray(logEvents) || (logEvents = [String(logEvents)]);
+
+    if (logEvents.length === 0) {
+        throw new Error('Empty log event');
+    }
+
+    switch (logLevel) {
+        case 1:
+            logLevel = 'DEBUG';
+            break;
+        case 2:
+            logLevel = 'INFO';
+            break;
+        case 3:
+            logLevel = 'WARN';
+            break;
+        case 4:
+            logLevel = 'ERROR';
+            break;
+        case 5:
+            logLevel = 'CRITICAL';
+            break;
+        default:
+            logLevel = 'INFO';
+    }
+
+    let cloudWatchLogEvents = [];
+    let maxBytes = 200000;
+    for (let logEvent of logEvents) {
+        if (logEvent.length > maxBytes) {
+            for (let j = 0; j < logEvent.length; j += maxBytes) {
+                let logEventChunk = logEvent.substring(j, j + maxBytes);
+                cloudWatchLogEvents.push({
+                    message: `${logLevel} ${logEventChunk}`,
+                    timestamp: new Date().getTime()
+                });
+            }
+        } else {
+            cloudWatchLogEvents.push({
+                message: `${logLevel} ${logEvent}`,
+                timestamp: new Date().getTime()
+            });
+        }
+    }
+
+    let QueueUrl = 'https://sqs.eu-west-1.amazonaws.com/826419745875/tookane_SQS_save_log_on_cloudwatch_DEVELOP';
+    if (process.env.NODE_ENV === 'production') {
+        QueueUrl = 'https://sqs.eu-west-1.amazonaws.com/826419745875/tookane_SQS_save_log_on_cloudwatch';
+    }
+
+    let errors = [];
+    let sqsMessage = [];
+
+    for (const event of cloudWatchLogEvents) {
+        const sqsParams = {
+            MessageBody: JSON.stringify({
+                logEvents: [event],
+                logGroupName: logGroupName,
+                logStreamName: logStreamName || global.LOG_STREAM_NAME,
+                logLevel: logLevel
+            }),
+            QueueUrl
+        };
+
+        try {
+            const command = new SendMessageCommand(sqsParams);
+            const response = await sqsClient.send(command);
+            sqsMessage.push(response);
+        } catch (error) {
+            errors.push(error);
+        }
+    }
+
+    if (errors.length > 0) {
+        throw errors;
+    }
+
+    return sqsMessage;
+};
+
+module.exports = {
+    putLogEvents
+};

package/config/index.js

@@ -0,0 +1,74 @@
+// Importamos solo el cliente S3 y las operaciones necesarias
+const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
+
+// Creamos una instancia del cliente S3
+const s3 = new S3Client({});
+
+const getObjectByString = (obj, key) => {
+    const keys = key.split('.');
+    let temp = obj;
+    for (let key of keys) {
+        temp = temp[key];
+    }
+    return temp;
+};
+
+// Cache object
+let cache = {};
+
+const getConfigValuesFromS3Bucket = async (configKey = null, ifValuesFromRoot = null) => {
+    const { NODE_ENV, TOOK_SECRETS_BUCKET, TOOK_SECRETS_DEVELOP, TOOK_SECRETS_PRODUCTION } = process.env;
+    let defaultEnvironment = NODE_ENV;
+    const availableEnvironments = ['production', 'develop', 'staging', 'uat', 'demo', 'test', 'testing'];
+    if (!defaultEnvironment || !availableEnvironments.includes(defaultEnvironment)) {
+        defaultEnvironment = 'develop';
+    }
+    const effectiveEnvironment = ifValuesFromRoot || defaultEnvironment;
+    let secretName = TOOK_SECRETS_DEVELOP;
+    if (effectiveEnvironment === 'production') {
+        secretName = TOOK_SECRETS_PRODUCTION;
+    }
+    const secretsBucketName = TOOK_SECRETS_BUCKET;
+
+    // Check cache first
+    if (cache[effectiveEnvironment] && (!configKey || cache[effectiveEnvironment][configKey])) {
+        return cache[effectiveEnvironment][configKey] ? cache[effectiveEnvironment][configKey] : cache[effectiveEnvironment];
+    }
+
+    try {
+        // If not in cache, then get from S3
+        const data = await s3.send(new GetObjectCommand({
+            Bucket: secretsBucketName,
+            Key: `${secretName}/index.json`,
+        }));
+
+        let config = JSON.parse(await streamToString(data.Body));
+
+        config = config[effectiveEnvironment];
+
+        // Cache the config
+        cache[effectiveEnvironment] = config;
+
+        if (configKey) {
+            return getObjectByString(config, configKey);
+        } else {
+            return config;
+        }
+    } catch (err) {
+        throw err;
+    }
+};
+
+// Helper function to convert stream to string
+const streamToString = (stream) => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', (chunk) => chunks.push(chunk));
+        stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        stream.on('error', reject);
+    });
+};
+
+module.exports = {
+    get: getConfigValuesFromS3Bucket
+};

package/customers/marketplace/bringg/auth.js

@@ -0,0 +1,59 @@
+const axiosRequest = require("../../../axios");
+const cloudwatch = require("../../../cloudwatch");
+const utils = require("../../../utils");
+
+const getAuthToken = async ({
+                                client_id = "",
+                                client_secret = "",
+                                baseUrl = "",
+                                logId = "",
+                                logGroupName = "",
+                            }) => {
+    const payload = {
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: "client_credentials",
+    };
+
+    const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+    };
+
+    let paramsRequest = {
+        logId: logId,
+        headers: headers,
+        payload: payload,
+    };
+
+    baseUrl = baseUrl + "/oauth/token";
+    let response = null;
+    try {
+        await cloudwatch.putLogEvents(
+            logId +
+            "Data to be sent to BRINGG for login >>>>>>> : " +
+            utils.dataToString(paramsRequest, "data").res,
+            logGroupName
+        );
+
+        response = await axiosRequest.post(baseUrl, paramsRequest);
+        await cloudwatch.putLogEvents(
+            logId +
+            "Response fomr BRINGG login >>>>>>> : " +
+            utils.dataToString(response, "data").res,
+            logGroupName
+        );
+        return response && response.data ? response.data.access_token : "";
+    } catch (err) {
+        let {res} = utils.dataToString(err);
+        await cloudwatch.putLogEvents(
+            logId + "Finsish BRINGG LOGIN Process with errors: " + res,
+            logGroupName
+        );
+        throw err;
+    }
+};
+
+module.exports = {
+    getAuthToken,
+};