async function getSpotOptions()

in api/v1/src/spots/validateManager.js [61:145]
69 lines of code
15 McCabe index (conditional complexity)

async function getSpotOptions(options, includeQuery) {
    let configBucketName = SPOT_SERVICE_CONFIG.bucketName;
    let configFileName = SPOT_SERVICE_CONFIG.fileName;

    var json;
    let file = await storageUtil.fetchFileContent(configBucketName, configFileName).catch(err =>  {
        console.warn(err.message);
        return { success: false, errors: [err.message]};
    });
    if (file.success === false) {
        return { success: false, errors: [`fileName: '${configFileName}' or bucketName: '${configBucketName}' does not exist`] }
    }
    json = JSON.parse(stripJsonComments(file));

    if (json.entities === undefined) {
        return { success: false, errors: ['File [' + configFileName + '] schema is not correct'] };
    }
    let requests = [];
    for (const e of json.entities) {
        // set bigqueryUtil based off projectId in entities for now
        bigqueryUtil = new BigQueryUtil(e.projectId);
        let fqTable = `${e.projectId}.${e.datasetId}.${e.tableId}`;
        for (const r of e.availableRequests) {
            let request = { name: r.name, dataId: r.dataId };
            let regex = /(\s@[^\s]+)/g;
            let queryString = r.query ? r.query : r.filter;
            let params = queryString.match(regex);
            // console.log(`Matches: ${params}`);

            if (includeQuery === true) {
                let query;
                if (r.query) {
                    query = r.query;
                }
                else if (r.filter) {
                    query = `select * from \`${fqTable}\` where ${r.filter}`;
                }
                query = performTextVariableReplacements(query, e.projectId, e.datasetId, e.tableId);
                // console.log(`Query is ${query}`);
                request.query = query;
            }

            request.params = [];
            // eslint-disable-next-line no-loop-func

            for (const p of underscore.uniq(params)) {
                /* eslint-disable no-loop-func */
                let foundParam = e.parameters.find((rp) => {
                    return p.trim().toLowerCase() === `@${rp.name.toLowerCase()}`;
                });

                let list;
                if (options.includeAvailableValues) {
                    let query;
                    let availableValues = [];

                    // Find the unique available values using the 'column' or 'custom' query attribute from foundParam
                    if (foundParam.column) {
                        query = `select distinct ${foundParam.column} as value from \`${fqTable}\``;
                    }
                    else if (foundParam.custom) {
                        query = performTextVariableReplacements(foundParam.custom, e.projectId, e.datasetId, e.tableId);
                    }
                    if (query) {
                        const queryOptions = {
                            query: query
                        };
                        // eslint-disable-next-line no-await-in-loop
                        availableValues = await bigqueryUtil.executeQuerySync(queryOptions);
                    }
                    // console.log(JSON.stringify(availableValues));
                    list = underscore.pluck(availableValues[0], 'value');
                }

                let _param = { name: foundParam.name, description: foundParam.description };
                if (list) {
                    _param.values = list;
                }
                request.params.push(_param);
            }
            requests.push(request);
        }
    }
    return { data: requests, success: true };
}