gbox-apis/Api.js

An Gbox API's npm Package for Node.js and Sails.js

let dbConfig = {};
const mysql = require('mysql2/promise');
const Helper = require('./Helper');

const path = require('path');
let packageJson = null
if(typeof sails == "object" ) {
    packageJson = require(path.join(process.cwd(), 'package.json'));
} else {
    let Helpers = use('Helpers')
    packageJson =require(`${Helpers.appRoot()}/package.json`);
}




/**
 * Execute DB query
 *
 * @return rows
 */
function executeQuery(query) {
    return new Promise(async (resolve, reject) => {

        let connection;

        // establish DB connections
        try {
            connection = await mysql.createConnection(dbConfig);
        } catch (e) {
            reject('*****  Error: Unable to establish connection to DB. Contact System Administrator.  *****');
        }

        connection.query(query, (err, results, fields) => {
            connection.end();
            if (err) reject(err);

            resolve(results);
        });
    });
}


/**
 * Insert GaussBox API data in database
 *
 * @returns {number}  API id
 */
async function saveApi() {

    let query = ` 
            INSERT INTO apis
              (createdAt, updatedAt, deleteFlag, apiName, slug, version, description, url, port)
            VALUES
              (UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), 0, '${packageJson.descriptiveName || packageJson.name}', 
              '${packageJson.name}', '${packageJson.version}', '${packageJson.description || ''}', 
              '${process.env.homepage || `127.0.0.1:${process.env.PORT}`}', '${process.env.PORT}')`;

    // execute query
    let res;
    try {
        res = await executeQuery(query);
    } catch (e) {
        console.log('\x1b[31m', `[GB ERROR] Unable to save Api data: ${query}`, e, '\x1b[0m');     // log error
        throw new Error(e);
    }


    // return data id
    return res.insertId;
}


/**
 * Update GaussBox API data
 *
 * @returns {array}
 */
async function updateApi(oldApi) {
    // PREPARE DATA
    let query = ` 
        UPDATE apis
        SET
          apiName = '${packageJson.descriptiveName || ''}',
          url = '${process.env.homepage || `127.0.0.1:${process.env.PORT}`}',
          version = '${packageJson.version || ''}',
          description = '${packageJson.description || ''}',
          port = '${process.env.PORT || ''}'
        WHERE id = ${oldApi.id}`;

    // execute query
    try {
        await executeQuery(query);
    } catch (e) {
        console.log('\x1b[31m', `[GB ERROR] Unable to update Api data: ${query}`, e, '\x1b[0m');     // log error
        throw new Error(e);
    }

    return 'API model updated';
}


/**
 * Get GaussBox API's existing data
 *
 * @returns {array}
 */
async function getApi(apiName = null) {
    // prepare query for getting api data
    let query = ` 
        SELECT
          a.id AS apiId, a.apiName, a.slug, a.version, a.description, a.url, a.port, 
          am.id AS apiModuleId, am.moduleName,
          ac.id AS apiModuleActionId, ac.action, ac.actionName, ac.type, ac.routeVersion, ac.method, ac.route, ac.visibility, 
          ac.level, ac.controllerActions

        FROM apis a
        LEFT JOIN apiModuleActions ac ON ac.api = a.id
        LEFT JOIN apiModules am ON ac.apiModule = am.id

        WHERE a.deleteFlag = 0 `;
    if (apiName) query += ` AND a.slug = '${apiName}' `;

    // execute query
    let res;
    try {
        let data = await executeQuery(query);

        res = Helper.filterApiData(data);
    } catch (e) {
        console.log('\x1b[31m', `[GB ERROR] Unable to retrieve Api data: ${query}`, e, '\x1b[0m');     // log error
        throw new Error(e);
    }


    return res;
}


/**
 * Insert GaussBox API module data in database
 *
 * @returns {number}  API Module id
 */
async function saveApiModule(apiId) {

    let moduleName = packageJson.name.split('-');
    let query = ` 
            INSERT INTO apiModules
              (createdAt, updatedAt, deleteFlag, moduleName, api)
            VALUES
              (UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), 0, '${moduleName[0]}', ${apiId})`;

    // execute query
    let res;
    try {
        res = await executeQuery(query);
    } catch (e) {
        console.log('\x1b[31m', `[GB ERROR] Unable to save Api modules: ${query}`, e, '\x1b[0m');     // log error
        throw new Error(e);
    }


    // return data id
    return res.insertId;
}


/**
 * Insert GaussBox API module actions data in database
 *
 * @returns {array}
 */
async function saveApiActions(apiActions, apiId, apiModuleId) {

    let res;
    let query = '';
    try {
        // prepare query
        query = `
          INSERT INTO apiModuleActions
            (createdAt, updatedAt, actionName, action, type, routeVersion, method, route, 
            visibility, level, controllerActions, api, apiModule)
          VALUES `;
        let firstCheck = true;

        for (let action of apiActions) {
            if (!firstCheck) query += ', ';

            query += `(UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), '${action.actionName}',  '${action.action}', '${action.type}', 
                  '${action.routeVersion}', '${action.routeMethod}', '${action.route}', 
                  '${ (action.visibility && action.visibility !== '') ? JSON.stringify(action.visibility) : ''}', 
                  '${ (action.level && action.level !== '') ? JSON.stringify(action.level) : ''}', 
                  '${ (action.controllerActions) ? JSON.stringify(action.controllerActions) : '[]'}', 
                  ${apiId}, ${apiModuleId})`;
            firstCheck = false;
        }

        res = await executeQuery(query);
    } catch (e) {
        console.log('\x1b[31m', `[GB ERROR] Unable to save Api actions: ${query}`, e, '\x1b[0m');     // log error
        throw new Error(e);
    }

    // return data id
    return res;
}


/**
 * Update GaussBox API actions data from database
 *
 * @returns {array}
 */
async function updateApiActions(apiActions) {

    for (let action of apiActions) {

        let query = `   UPDATE apiModuleActions
                        SET updatedAt = UNIX_TIMESTAMP(),
                            actionName = '${action.actionName}',
                            action = '${action.action}',
                            type = '${action.type}',
                            routeVersion = '${action.routeVersion}',
                            visibility = '${action.visibility ? JSON.stringify(action.visibility) : ""}',
                            level = '${action.level ? JSON.stringify(action.level) : ""}',
                            controllerActions = '${action.controllerActions ? JSON.stringify(action.controllerActions) : "[]"}'
                        WHERE route = '${action.route}' AND method = '${action.routeMethod}'`;

        // execute query
        try {
            await executeQuery(query);
        } catch (e) {
            console.log('\x1b[31m', `[GB ERROR] Unable to update Api actions: ${query}`, e, '\x1b[0m');     // log error
            throw new Error(e);
        }
    }

    return 'API actions updated.';
}


/**
 * Remove GaussBox API actions data from database
 *
 * @returns {array}
 */
async function removeApiActions(apiActions) {
    // prepare query
    let query = `
          DELETE FROM apiModuleActions
          WHERE id IN (`;
    let firstCheck = true;

    for (let action of apiActions) {
        if (!firstCheck) query += ', ';
        query += action.id;
        firstCheck = false;
    }
    query += `)`;


    // execute query
    let res;
    try {
        res = await executeQuery(query);
    } catch (e) {
        console.log('\x1b[31m', `[GB ERROR] Unable to remove Api actions: ${query}`, e, '\x1b[0m');     // log error
        throw new Error(e);
    }

    return res;
}




// managing Gauss Box API'S
module.exports = (config) => {
    dbConfig = config;

    return {
        saveApi: saveApi,
        updateApi: updateApi,
        getApi: getApi,
        saveApiModule: saveApiModule,
        saveApiActions: saveApiActions,
        updateApiActions: updateApiActions,
        removeApiActions: removeApiActions,
    }
};