@slingr/slingr-services 0.0.5

package/services/dataStores/dataStores.js

@@ -0,0 +1,93 @@
+const definitions = require('../configuration/configuration').definitions;
+const httpModule = require('../httpModule/httpModule');
+
+const DATASTORES_API_PATH = '/services/dataStores/';
+
+const isEmpty = (obj) => {
+    return obj 
+        && Object.keys(obj).length === 0
+        && Object.getPrototypeOf(obj) === Object.prototype;
+}
+
+const dataStores = {
+    find: async (dataStoreName, filter) => {
+        if (isEmpty(filter)) filter = null;
+        const dataStoreResponse = await httpModule.get(DATASTORES_API_PATH+dataStoreName,{
+            params: {
+                ...filter
+            }
+        });
+        return dataStoreResponse.data;
+    },
+    findById: async (dataStoreName,documentId) => {
+        if (!documentId || documentId === '') throw new Error('The documentId can\'t be empty');
+        const dataStoreResponse = await httpModule.get(DATASTORES_API_PATH+dataStoreName+'/'+documentId);
+        return dataStoreResponse.data;
+    },
+    save: async (dataStoreName,document) => {
+        if (isEmpty(document)) throw new Error('The document to save can\'t be empty');
+        const dataStoreResponse = await httpModule.post(DATASTORES_API_PATH+dataStoreName,document);
+        return dataStoreResponse.data;
+    },
+    update: async (dataStoreName,documentId,newDocument) => {
+        if (!documentId) throw new Error('The documentId can\'t be empty');
+        if (isEmpty(newDocument)) throw new Error('The document to update can\'t be empty');
+        const dataStoreResponse = await httpModule.put(DATASTORES_API_PATH+dataStoreName+'/'+documentId,newDocument);
+        return dataStoreResponse.data;
+    },
+    remove: async (dataStoreName,filter) => {
+        if (isEmpty(filter)) filter = null;
+        const dataStoreResponse = await httpModule.delete(DATASTORES_API_PATH+dataStoreName,{
+            params: {
+                ...filter
+            }
+        });
+        return dataStoreResponse.data;
+    },
+    removeById: async (dataStoreName,documentId) => {
+        if (!documentId || documentId === '') throw new Error('The documentId can\'t be empty');
+        const dataStoreResponse = await httpModule.delete(DATASTORES_API_PATH+dataStoreName+'/'+documentId);
+        return dataStoreResponse.data;
+    },
+    count: async (dataStoreName, filter) => {
+        if (isEmpty(filter)) filter = null;
+        const dataStoreResponse = await httpModule.get(DATASTORES_API_PATH+dataStoreName+'/count',{
+            params: {
+                ...filter
+            }
+        });
+        return dataStoreResponse.data;
+    }
+};
+
+for (const dataStore of definitions.stores) {
+    const dataStoreName = dataStore.name;
+    dataStores[dataStoreName] = {
+        find: async (filter) => {
+            return await dataStores.find(dataStoreName,filter);
+        },
+        findOne: async (filter) => {
+            return (await dataStores.find(dataStoreName,filter)).items[0];
+        },
+        findById: async (documentId) => {
+            return await dataStores.findById(dataStoreName,documentId);
+        },
+        save: async (document) => {
+            return await dataStores.save(dataStoreName,document);
+        },
+        update: async (documentId,newDocument) => {
+            return await dataStores.update(dataStoreName,documentId,newDocument);
+        },
+        remove: async (filter) => {
+            return await dataStores.remove(filter);
+        },
+        removeById: async (documentId) => {
+            return await dataStores.removeById(dataStoreName,documentId);
+        },
+        count: async (filter) => {
+            return await dataStores.count(dataStoreName,filter);
+        }
+    }
+}
+
+module.exports = dataStores

package/services/events/events.js

@@ -0,0 +1,69 @@
+const util = require('util');
+const httpModule = require('../httpModule/httpModule');
+const logger = require('../loggers/logs');
+
+const EVENTS_API_PATH = '/services/events';
+const EVENTS_SYNC_API_PATH = '/services/events/sync';
+
+
+let lastStatistic = null;
+
+const handleSendEvent = async (eventName, data, fromFunction, userId, userEmail, isSync) => {
+    if (!eventName) {
+        throw 'Event name is empty'
+    }
+    if (!data) {
+        data = {}
+    }
+    let eventBody = {
+        date: new Date().getTime(),
+        event: eventName,
+        data: data,
+        ...(fromFunction && { fromFunction: fromFunction }),
+        ...(userId && { userId: userId }),
+        ...(userEmail && { userEmail: userEmail }),
+    };
+
+    let response = null;
+
+    if (isSync) {
+        response = await httpModule.post(EVENTS_SYNC_API_PATH, eventBody);
+    } else {
+        httpModule.post(EVENTS_SYNC_API_PATH, eventBody);
+    }
+    if (!lastStatistic || (new Date() - 3600000) > lastStatistic) {
+        lastStatistic = new Date();
+        logger.info(">>> mem usage: " + util.inspect(process.memoryUsage(), { showHidden: true, depth: null }));
+    }
+    return response;
+
+}
+//handle sync responses from platform
+const send = (eventName, data, fromFunction, userId, userEmail) => {
+    handleSendEvent(eventName, data, fromFunction, userId, userEmail, false).then(
+        (data) => {
+            logger.debug('[EVENT][' + eventName + '] >> [SENT]')
+        }
+    ).catch(
+        (err) => {
+            logger.debug('[EVENT][' + eventName + '] >> [NO SENT]');
+            logger.info('Error when try to send event to ES [' + err + ']');
+        }
+    );
+};
+
+const sendSync = async (eventName, data, fromFunction, userId, userEmail) => {
+    try {
+        let response = await handleSendEvent(eventName, data, fromFunction, userId, userEmail, true);
+        logger.debug('[SYNC EVENT][' + eventName + '] >> [SENT]');
+        return response.data;
+    } catch (error) {
+        logger.debug('[SYNC EVENT][' + eventName + '] >> [NO SENT]');
+        logger.info('Error when try to send sync event to ES [' + error + ']');
+    }
+}
+
+module.exports = {
+    send,
+    sendSync
+}

package/services/files/files.js

@@ -0,0 +1,114 @@
+const httpModule = require('../httpModule/httpModule');
+const logger = require('../loggers/logs');
+const appLogger = require('../loggers/appLogs');
+const fs = require('fs');
+const stream = require('node:stream');
+const pStream = stream.promises;
+const FormData = require('form-data');
+
+const FILES_API_PATH = '/svcss/files'
+const TMP_FILES_PATH = './tmp/'
+
+const clearTmpFile = async (filePath) => {
+    fs.unlink(filePath,(err) => {
+        if (err) throw err;
+        logger.debug(filePath + ' was deleted.');
+      });
+}
+
+const createTmpFile = async (fileName, fileContents) => {
+    const filePath = TMP_FILES_PATH + new Date().getTime() + '_' + (fileName ? fileName : 'file');
+    if (!fs.existsSync(TMP_FILES_PATH)) fs.mkdirSync(TMP_FILES_PATH);
+    
+    if (fileContents instanceof stream.Stream){
+        const writer = fs.createWriteStream(filePath);
+        fileContents.pipe(writer);
+        await pStream.finished(writer);
+    } else {
+        fs.writeFileSync(filePath, fileContents);
+    }
+    return filePath;
+}
+
+const download = async (fileId) => {
+    if (!fileId) {
+        throw new Error('The file ID cannot be empty when downloading files.');
+    }
+    
+    let downloadResponse;
+    try {
+        downloadResponse = await httpModule.get(FILES_API_PATH + '/' + fileId, {responseType: 'stream'});
+    } catch (error) {
+        logger.error('Error while downloading file from platform.',error);
+    }
+    const tmpFilePath = await createTmpFile(fileId, downloadResponse.data);
+    const downloadData = fs.readFileSync(tmpFilePath);
+    clearTmpFile(tmpFilePath);
+    return downloadData;
+};
+
+const upload = async (fileName, fileContents) => {
+    if (!fileName) {
+        logger.error('Cannot upload a file if fileName is empty.');
+        appLogger.error('Error while uploading a file because no fileName was provided.');
+        return;
+    }
+    if (!fileContents) {
+        logger.error('Cannot upload a file if fileContents is empty.');
+        appLogger.error('Error while uploading the file ['+fileName+'] because of empty content.');
+        return;
+    }
+
+    let tmpFilePath;
+    try {
+        tmpFilePath = await createTmpFile(fileName, fileContents);
+    } catch (err) {
+        logger.error('The temporal file for ['+fileName+']could not be created. The file wont be uploaded to the app.',err);
+        appLogger.error('Error while uploading the file ['+fileName+']. It wasn\'t uploaded to the app.');
+        return;
+    }
+
+    const formData = new FormData();
+    formData.append('file', fs.createReadStream(tmpFilePath));
+    let options = {
+        headers: {
+            ...formData.getHeaders()
+        }
+    };
+
+    let fileResponse;
+    try {
+        fileResponse = await httpModule.post(FILES_API_PATH, formData, options);
+        logger.debug('Uploaded file to application');
+    } catch (error) {
+        logger.info('Error while trying to upload a file to app [' + error + ']');
+        appLogger.error('Error while trying to upload a file from service to application');
+        return;
+    }
+    clearTmpFile(tmpFilePath);
+    return fileResponse.data;
+};
+
+const getFileMetadata = async (fileId) => {
+    if (!fileId) {
+        logger.error('The fileId cannot be empty when getting files metadata.')
+        appLogger.error('Error while getting app metadata because no fileId was provided.')
+        return;
+    }
+
+    let metadataResponse;
+    try {
+        metadataResponse = await httpModule.get(FILES_API_PATH+'/'+fileId+'/metadata');
+    } catch (error) {
+        logger.info('Error when try to fetch metadata from file [' + fileId + ']');
+        appLogger.error('Error when try to fetch metadata from file [' + fileId + ']',error);
+    }
+    logger.debug('File Metadata fetched.');
+    return metadataResponse.data;
+}
+
+module.exports = {
+    download,
+    upload,
+    getFileMetadata
+}

package/services/httpModule/httpModule.js

@@ -0,0 +1,31 @@
+const https = require('https');
+
+const {
+    applicationName,
+    environment,
+    token,
+    _extension_broker_api,
+} = require('../configuration/configuration').settings;
+const axiosInstance = require('axios').create(
+    {
+        baseURL: _extension_broker_api,
+        headers: {
+            app: applicationName,
+            env: environment,
+            token: token,
+            version: 'v1'
+        },
+        httpsAgent: new https.Agent({
+            rejectUnauthorized: false
+        }),
+    }
+);
+// require('axios-retry')(
+//     httpModule, {
+//         retries: 5,
+//         retryDelay: 5000,
+//         shouldResetTimeout: true 
+//     }
+// );
+
+module.exports = axiosInstance;

package/services/locks/locks.js

@@ -0,0 +1,37 @@
+const logger = require('../loggers/logs');
+const httpModule = require('../httpModule/httpModule');
+
+const LOCKS_API_PATH = '/locks/';
+
+const acquireLock = async (key) => {
+    if(!key) {
+        throw new Error('Key can\'t be empty to aquire a lock.');
+    }
+    let lock;
+    try {
+        lock = await httpModule.post(LOCKS_API_PATH+key);
+    } catch (error) {
+        logger.error('Error while triying to get lock for key ['+key+'].')
+        throw new Error('Error while triying to get lock for key ['+key+'].')
+    }
+    return lock;
+}
+
+const releaseLock = async (key) => {
+    if(!key) {
+        throw new Error('Key can\'t be empty to release a lock.');
+    }
+    let unlock;
+    try {
+        unlock = await httpModule.delete(LOCKS_API_PATH+key);
+    } catch (error) {
+        logger.error('Error while triying to release lock for key ['+key+'].')
+        throw new Error('Error while triying to release lock for key ['+key+'].')
+    }
+    return unlock;
+}
+
+module.exports = {
+    acquireLock,
+    releaseLock
+}

package/services/loggers/appLogs.js

@@ -0,0 +1,42 @@
+const 
+    logger = require('./logs'),
+    {
+        applicationName,
+        svcName,
+        environment
+    } = require('../configuration/configuration').settings,
+    httpModule = require('../httpModule/httpModule');
+
+ // app log (POST /api/services/logs)
+const sendAppLog = (level, message, additionalInfo) => {
+    if (!additionalInfo) {
+        additionalInfo = {}
+    }
+    additionalInfo.app = applicationName;
+    additionalInfo.svc = svcName;
+    additionalInfo.env = environment;
+
+    let appLog = {
+        date: +new Date(),
+        level: level,
+        message: message,
+        additionalInfo: additionalInfo
+    };
+    httpModule.post('/services/logs', appLog)
+        .then(body => logger.debug('[APP LOG][' + level + '] ' + appLog.message))
+        .catch(error => {
+            logger.debug('[APP LOG][' + level + '] ' + appLog.message + ' >> [NO SENT]');
+            logger.error('Error when try to send app log to ES [' + error + ']')
+        })
+};
+const appLogDebug = (message, additionalInfo) => sendAppLog('DEBUG', message, additionalInfo);
+const appLogInfo = (message, additionalInfo) => sendAppLog('INFO', message, additionalInfo);
+const appLogWarn = (message, additionalInfo) => sendAppLog('WARN', message, additionalInfo);
+const appLogError = (message, additionalInfo) => sendAppLog('ERROR', message, additionalInfo);
+
+module.exports = {
+    debug: appLogDebug,
+    info: appLogInfo,
+    warn: appLogWarn,
+    error: appLogError
+}

package/services/loggers/logs.js

@@ -0,0 +1,68 @@
+const {
+        podId,
+        applicationName,
+        svcName,
+        environment,
+        debug
+    } = require('../configuration/configuration').settings;
+const dayjs = require('dayjs');
+
+const formatLog = (level, message) => {
+    return dayjs().format('YYYY-MM-DD HH:mm:ss.SSS ZZ') + ' ' +
+    'comp=svc ' +
+    'level=' + level + ' ' +
+    'podId=' + podId + ' ' +
+    'app=' + applicationName + ' ' +
+    'svc=' + svcName + ' ' +
+    'env=' + environment + ' ' +
+    message;
+}
+
+const logDebug = (message, obj) => {
+    if (message && debug) {
+        if (obj) {
+            console.log(formatLog('DEBUG', message),obj);
+        } else {
+            console.log(formatLog('DEBUG', message));
+        }
+    }
+};
+
+const logInfo = (message, obj) => {
+    if (message) {
+        if (obj) {
+            console.info(formatLog('INFO', message),obj);
+        } else {
+            console.info(formatLog('INFO', message));
+        }
+    }
+};
+
+const logWarn = (message, obj) => {
+    if (message) {
+        if (obj) {
+            console.warn(formatLog('WARN', message),obj);
+        } else {
+            console.warn(formatLog('WARN', message));
+        }
+    }
+};
+
+const logError = (message, obj) => {
+    if (message) {
+        if (message) {
+            if (obj) {
+                console.error(formatLog('ERROR', message),obj);
+            } else {
+                console.error(formatLog('ERROR', message));
+            }
+        }
+    }
+};
+
+module.exports = {
+    debug: logDebug,
+    info: logInfo,
+    warn: logWarn,
+    error: logError
+}

package/services/settings/settings.js

@@ -0,0 +1,26 @@
+const httpModule = require('../httpModule/httpModule');
+const {setPropertyOnSettings} = require('../configuration/configuration');
+
+
+const checkProxyStatus = async () => {
+    try {
+        let res = await httpModule.get('/services/configuration');
+        let data = res.data;
+        return data.proxy
+    } catch (err) {
+        console.log("err is:",err);
+    }
+}
+
+const refreshCache = async () => {
+        try {
+            await httpModule.put('/services/management/clearCache');
+        } catch (err) {
+            console.log("err is:",err);
+        }
+}
+
+module.exports = {
+    checkProxyStatus,
+    refreshCache 
+}

package/services/users/users.js

@@ -0,0 +1,112 @@
+const dataStores = require('../dataStores/dataStores');
+const events = require('../events/events');
+
+const USER_DATASTORE_NAME = '__svc_users__';
+const USER_CONNECTED_EVENT = 'userConnected';
+const USER_DISCONNECTED_EVENT = 'userDisconnected';
+
+const findById = async (userId) => {
+    if (!userId) {
+        throw new Error('User id cannot be empty.')
+    }
+    try {
+        const user = await dataStores.findById(USER_DATASTORE_NAME, userId);
+    } catch (error) {
+
+    }
+    return user;
+};
+
+const save = async (userId, userInfo) => {
+    if (!userId) {
+        throw new Error('User id cannot be empty.')
+    }
+    try {
+        const user = await dataStores.findById(USER_DATASTORE_NAME, userId);
+    } catch (error) {
+
+    }
+    try {
+        const savedUser = await dataStores.save(USER_DATASTORE_NAME, user, userInfo);
+    } catch (error) {
+
+    }
+    return savedUser;
+};
+
+const removeById = async (userId) => {
+    if (!userId) {
+        throw new Error('User id cannot be empty.')
+    }
+    try {
+        const user = await dataStores.removeById(USER_DATASTORE_NAME, userId);
+    } catch (error) {
+
+    }
+};
+
+//Kind of a check and update
+const checkUserConnection = async (userId, newInfo) => {
+    if (!userId) {
+        throw new Error('User id cannot be empty.')
+    }
+    try {
+        const user = await dataStores.findById(USER_DATASTORE_NAME, userId);
+    } catch (error) {
+
+    }
+    if (!user) {
+        throw new Error('User with id [' + userId + '] is not connected.');
+    }
+    user = {
+        ...user,
+        ...newInfo
+    };
+    return user;
+}
+
+const connect = async (userId, userInfo, functionId) => {
+    if (!userId) {
+        throw new Error('User id cannot be empty.')
+    }
+    let user;
+    try {
+        user = await save(userId, userInfo);
+    } catch (error) {
+
+    }
+    sendUserConnectedEvent(userId, userInfo, functionId);
+    return user;
+}
+
+const disconnect = async (userId, functionId) => {
+    if (!userId) {
+        throw new Error('User id cannot be empty.')
+    }
+    let user;
+    try {
+        await removeById(userId);
+    } catch (error) {
+
+    }
+    sendUserDisconnectedEvent(userId, null, functionId);
+    return user;
+}
+
+const sendUserConnectedEvent = (userId, userInfo, functionId) => {
+    events.send(USER_CONNECTED_EVENT, userInfo, functionId, userId);
+}
+
+const sendUserDisconnectedEvent = (userId, functionId) => {
+    events.send(USER_DISCONNECTED_EVENT, null, functionId, userId);
+}
+
+module.exports = {
+    findById,
+    save,
+    removeById,
+    connect,
+    disconnect,
+    sendUserConnectedEvent,
+    sendUserDisconnectedEvent
+}