src/cli/cms/data/sql.js - Code Metrics - Inspection of "split sql and sort (+ UT for sort)" - AdFabConnect/abejs - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bdfcbe...91ed9c )

unknown

created 2016-10-04 13:04 UTC

src/cli/cms/data/sql.js F

↳ Parent: Project

Complexity

Total Complexity	122
Complexity/F	4.88

Size

Lines of Code	449
Function Count	25

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	0
wmc	122
c	1
b	0
f	0
nc	1
mnd	6
bc	88
fnc	25
dl	0
loc	449
rs	3.12
bpm	3.52
cpm	4.88
noi	33

14 Functions

Rating	Name	Size	Complexity
C	sql.js ➔ recurseWhere	70	17
A	sql.js ➔ sanitizeFromStatement	11	3
B	sql.js ➔ getFromDirectory	18	10
A	sql.js ➔ executeQuerySync	3	1
C	sql.js ➔ executeWhereClause	35	11
C	sql.js ➔ getWhereValuesToCompare	55	13
C	sql.js ➔ cleanRequest	46	12
B	sql.js ➔ getSourceType	22	5
B	sql.js ➔ executeOrderByClause	15	7
C	sql.js ➔ handleSqlRequest	71	15
A	sql.js ➔ execQuery	11	1
A	sql.js ➔ executeQuery	10	1
A	sql.js ➔ getDataSource	15	3
A	sql.js ➔ executeFromClause	21	2

How to fix Complexity

import {parse} from 'node-sqlparser'
import {Promise} from 'es6-promise'
import path from 'path'
import {
  coreUtils,
  config,
  Manager,
  FileParser,

  getAttr
} from '../../'

export function cleanRequest(str, jsonPage) {

  var matchFrom = /from .(.*?) /
  var matchVariable = /{{([a-zA-Z]*)}}/

  var matchFromExec = matchFrom.exec(str)
  if(typeof matchFromExec !== 'undefined' && matchFromExec !== null
    && typeof matchFromExec[1] !== 'undefined' && matchFromExec[1] !== null) {

    var fromMatch
    var toReplace = matchFromExec[1]
    while (fromMatch = matchVariable.exec(toReplace)) {
      try {
        var value = eval('jsonPage.' + fromMatch[1])

        if(typeof value !== 'undefined' && value !== null) {
          toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', value)
        }else {
          toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', '')
        }
      }catch(e) {

      }
    }

    str = str.replace(matchFromExec[1], toReplace)
  }

  var from = /from ([\S\s]+)/.exec(str)

  var matches = from
  if(matches[1]) {
    var res = matches[1]
    var splitAttr = [' where ', ' order by ', ' limit ', ' WHERE ', ' ORDER BY ', ' LIMIT ']
    for(var i = 0; i < splitAttr.length; i++) {
      if(res.indexOf(splitAttr[i]) > -1) {
        res = res.substring(0, res.indexOf(splitAttr[i]))
      }
    }
    var escapedFrom = res.replace(/\//g, '___abe___')
    escapedFrom = escapedFrom.replace(/\./g, '___abe_dot___')
    escapedFrom = escapedFrom.replace(/-/g, '___abe_dash___')
    str = str.replace(res, escapedFrom)
  }

  str = str.replace(/``/g, '\'\'')

  return str
}

export function handleSqlRequest(str, jsonPage) {
  var req = cleanRequest(str, jsonPage)
  var request = parse(req)
  var reconstructSql = ''

  // SQL TYPE
  var type = ''
  if(typeof request.type !== 'undefined' && request.type !== null) {
    type = request.type
  }
  reconstructSql += `${type} `

  // SQL COLUMNS
  var columns = []
  if(typeof request.columns !== 'undefined' && request.columns !== null) {
    if(request.columns === '*') {
      columns.push('*')
    }else {
      Array.prototype.forEach.call(request.columns, (item) => {
        columns.push(item.expr.column)
      })
    }
  }
  reconstructSql += `${JSON.stringify(columns)} `

  // SQL FROM
  var from = []
  if(typeof request.from !== 'undefined' && request.from !== null) {

    Array.prototype.forEach.call(request.from, (item) => {
      from.push(item.table)
    })
  }else {
    from.push('*')
  }
  reconstructSql += `from ${JSON.stringify(from)} `

  var where
  if(typeof request.where !== 'undefined' && request.where !== null) {
    where = request.where
    // where = recurseWhere(request.where)
    // reconstructSql += 'where '
    // Array.prototype.forEach.call(where, (w) => {
    //   reconstructSql += `${w.operator} ${w.left} ${w.compare} ${w.right} `
    // })
  }

  var limit = -1
  if(typeof request.limit !== 'undefined' && request.limit !== null) {
    limit = request.limit[request.limit.length - 1].value
  }

  var orderby
  if(typeof request.orderby !== 'undefined' && request.orderby !== null && request.orderby.length > 0) {
    orderby = {
      column: request.orderby[0].expr.column,
      type: request.orderby[0].type
    }
    reconstructSql += `ORDER BY ${orderby.column} ${orderby.type} `
  }

  return {
    type: type,
    columns: columns,
    from: from,
    where: where,

    string: reconstructSql,
    limit: limit,
    orderby: orderby

  }
}

export function getDataSource(str) {
  var res = str.substring(str.indexOf('source=') + 8, str.length)

  var reg = /([^'"]*=[\s\S]*?}})/g
  var matches = res.match(reg)
  if(typeof matches !== 'undefined' && matches !== null) {
    Array.prototype.forEach.call(matches, (match) => {
      res = res.replace(match, '')
    })
  }else {
    res = res.replace('}}', '')
  }

  return res.substring(0, res.length-1)
}

/**
 * replaces escaped characters with the right ones
 * @param  {String} statement the from clause
 * @return {String}           the from sanitized
 */
export function sanitizeFromStatement(statement){
  var from = ''

  if(typeof statement !== 'undefined' && statement !== null) {
    from = statement[0].replace(/___abe_dot___/g, '.')
    from = from.replace(/___abe___/g, '/')
    from = from.replace(/___abe_dash___/g, '-')
  }

  return from
}

/**
 * calculate the directory to analyze from the from clause
 * @param  {String} statement the from clause
 * @param  {String} tplPath   the path from the template originator
 * @return {string}           the directory to analyze
 */
export function getFromDirectory(statement, tplPath){
  var pathFromDir = ''
  if(typeof tplPath === 'undefined' || tplPath === null || tplPath === ''){
    tplPath = '/'
  }

  if(statement === '' || statement === '*' || statement === '/') {
    pathFromDir = path.join(config.root, config.data.url)
  }else if(statement === './') {
    pathFromDir = path.join(config.root, config.data.url, tplPath)
  }else if(statement.indexOf('/') === 0) {
    pathFromDir = path.join(config.root, config.data.url, statement)
  }else if(statement.indexOf('/') !== 0) {
    pathFromDir = path.join(config.root, config.data.url, tplPath, statement)
  }

  return pathFromDir
}

export function executeOrderByClause(files, orderby){
  if(typeof orderby !== 'undefined' && orderby !== null) {
    if(orderby.column.toLowerCase() === 'random') {
      files = coreUtils.sort.shuffle(files)
    }else if(orderby.column.toLowerCase() === 'date') {
      if(orderby.type === 'ASC') {
        files.sort(coreUtils.sort.byDateAsc)
      }else if(orderby.type === 'DESC') {
        files.sort(coreUtils.sort.byDateDesc)
      }
    }
  }

  return files
}

export function executeFromClause(statement, pathFromClause){
  var from = sanitizeFromStatement(statement)

  // if the from clause ends with a dot, we won't recurse the directory analyze
  if(from.slice(-1) === '.'){
    from = from.slice(0, -1)
  }
  
  var fromDirectory = getFromDirectory(from, pathFromClause)

  var list = Manager.instance.getList()
  var files_array = list.filter((element, index) => {

    if(element.publish) {
      if (element.path.indexOf(fromDirectory) > -1) {
        return true
      }
    }
    return false
  })
  return files_array
}

export function execQuery(pathQuery, match, jsonPage) {
  var res
  var files
  var request = handleSqlRequest(getAttr(match, 'source'), jsonPage)

  files = executeFromClause(request.from, pathQuery)
  files = executeOrderByClause(files, request.orderby)
  res = executeWhereClause(files, request.where, request.limit, request.columns, jsonPage)

  return res
}

export function executeQuerySync(pathQuerySync, match, jsonPage) {
  return execQuery(pathQuerySync, match, jsonPage)
}

export function executeQuery(pathexecuteQuery, match, jsonPage) {
  var p = new Promise((resolve) => {
    var res = execQuery(pathexecuteQuery, match, jsonPage)
    resolve(res)
  }).catch(function(e) {
    console.error(e)
  })

  return p
}

/**
 * check if a given string an url, string json, file url, abe sql request
 * 
 * get('http://google.com')
 * get('{"test":"test"}')
 * get('select * from ../')
 * get('test')
 * 
 * @param  {String} str 
 * @return {String} url | request | value | file | other
 */
export function getSourceType(str) {
  if(/http:\/\/|https:\/\//.test(str)) {
    return 'url'
  }

  if(/select[\S\s]*?from/.test(str)) {
    return 'request'
  }

  try {
    JSON.parse(str)
    return 'value'
  }catch(e) {


  }

  if(/\.json/.test(str)) {
    return 'file'
  }

  return 'other'
}

export function executeWhereClause(files, wheres, maxLimit, columns, jsonPage){
  var res = []
  var limit = 0

  for(let file of files) {
    if(limit < maxLimit || maxLimit === -1) {
      if(typeof wheres !== 'undefined' && wheres !== null) {

        if(!recurseWhere(wheres, file.publish, jsonPage)) {
          var json = JSON.parse(JSON.stringify(file.publish))
          var jsonValues = {}

          if(typeof columns !== 'undefined' && columns !== null && columns.length > 0 && columns[0] !== '*') {
            
            Array.prototype.forEach.call(columns, (column) => {
              if(typeof json[column] !== 'undefined' && json[column] !== null) {

                jsonValues[column] = json[column]

              }
            })
            jsonValues['abe_meta'] = json['abe_meta']
          }else {
            jsonValues = json
          }

          res.push(jsonValues)
          limit++
        }
      }
    } else {
      break
    }
  }

  return res
}

export function getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc) {

  var regexIsVariable = /^{{(.*)}}$/
  var value
  var compare

  try {
    var variableLeft = where.left.column
    var checkIfLeftIsAVariable = regexIsVariable.exec(variableLeft)
    if(typeof checkIfLeftIsAVariable !== 'undefined' && checkIfLeftIsAVariable !== null && checkIfLeftIsAVariable.length > 0) {
      variableLeft = checkIfLeftIsAVariable[1]
    }
    value = eval('jsonDoc.' + variableLeft)

  }catch(e) {
    // console.log('e', e)
  }
  
  if(where.operator === 'IN' || where.operator === 'NOT IN') {
    compare = []
    Array.prototype.forEach.call(where.right.value, (right) => {
      var matchRightVariable = regexIsVariable.exec(right.column)
      if(typeof matchRightVariable !== 'undefined' && matchRightVariable !== null && matchRightVariable.length > 0) {
        try {
          var jsonOriginalValues = eval('jsonOriginalDoc.' + matchRightVariable[1])

          Array.prototype.forEach.call(jsonOriginalValues, (jsonOriginalValue) => {

            compare.push(eval('jsonOriginalValue.' + where.left.column))

          })
        }catch(e) {}

      }
      else{
        compare.push(right.column)
      }
    })
  }else {
    compare = where.right.column
    var matchRightVariable = regexIsVariable.exec(compare)

    if(typeof matchRightVariable !== 'undefined' && matchRightVariable !== null && matchRightVariable.length > 0) {
      try {
        var shouldCompare = eval('jsonOriginalDoc.' + matchRightVariable[1])

        if(typeof shouldCompare !== 'undefined' && shouldCompare !== null) {
          compare = shouldCompare
        }else {
          compare = null
        }
      }catch(e) {
        compare = null
      }
    }
  }

  return {
    left: value,

    right: compare
  }
}

export function recurseWhere(where, jsonDoc, jsonOriginalDoc) {
  var shouldAdd = true

  var isNotLeftCorrect = false

  var isNotRightCorrect = false

  var isNotCorrect = false


  switch(where.operator) {

  case '=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)
    isNotCorrect = !(values.left === values.right)
    break
  case '!=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left !== values.right)
    break
  case '>':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left > values.right)
    break
  case '>=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left >= values.right)
    break
  case '<':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left < values.right)
    break
  case '<=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left <= values.right)
    break
  case 'LIKE':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left && values.left.indexOf(values.right) > -1)
    break
  case 'NOT LIKE':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left && values.left.indexOf(values.right) === -1)
    break
  case 'AND':
    isNotLeftCorrect = recurseWhere(where.left, jsonDoc, jsonOriginalDoc)
    isNotRightCorrect = recurseWhere(where.right, jsonDoc, jsonOriginalDoc)
    isNotCorrect = (isNotLeftCorrect || isNotRightCorrect) ? true : false
    break
  case 'OR':
    isNotLeftCorrect = recurseWhere(where.left, jsonDoc, jsonOriginalDoc)
    isNotRightCorrect = recurseWhere(where.right, jsonDoc, jsonOriginalDoc)
    isNotCorrect = (isNotLeftCorrect && isNotRightCorrect) ? true : false
    break
  case 'IN':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = true
    Array.prototype.forEach.call(values.right, (right) => {
      if(values.left === right) {
        isNotCorrect = false
      }
    })
    break
  case 'NOT IN':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = false
    Array.prototype.forEach.call(values.right, (right) => {
      if(values.left === right) {
        isNotCorrect = true
      }
    })
    break
  }
  return isNotCorrect
}

1			import {parse} from 'node-sqlparser'
2			import {Promise} from 'es6-promise'
3			import path from 'path'
4			import {
5			coreUtils,
6			config,
7			Manager,
8			FileParser,
			0 ignored issues – show Unused Code introduced 2016-10-03 09:32 UTC by Report Bug Copy Issue Report The variable `FileParser` seems to be never used. Consider removing it. Loading history...
9			getAttr
10			} from '../../'
11
12			export function cleanRequest(str, jsonPage) {
			0 ignored issues – show Unused Code introduced 2016-10-04 12:44 UTC by Report Bug Copy Issue Report The parameter `jsonPage` is not used and could be removed. This check looks for parameters in functions that are not used in the function body and are not followed by other parameters which are used inside the function. Loading history...
13			var matchFrom = /from .(.*?) /
14			var matchVariable = /{{([a-zA-Z]*)}}/
15
16			var matchFromExec = matchFrom.exec(str)
17			if(typeof matchFromExec !== 'undefined' && matchFromExec !== null
18			&& typeof matchFromExec[1] !== 'undefined' && matchFromExec[1] !== null) {
19
20			var fromMatch
21			var toReplace = matchFromExec[1]
22			while (fromMatch = matchVariable.exec(toReplace)) {
23			try {
24			var value = eval('jsonPage.' + fromMatch[1])
			0 ignored issues – show Security Performance introduced 2016-09-27 10:32 UTC by Report Bug Copy Issue Report Calls to `eval` are slow and potentially dangerous, especially on untrusted code. Please consider whether there is another way to achieve your goal. Loading history...
25			if(typeof value !== 'undefined' && value !== null) {
26			toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', value)
27			}else {
28			toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', '')
29			}
30			}catch(e) {
			0 ignored issues – show Coding Style Comprehensibility Best Practice introduced 2016-09-30 14:19 UTC by Report Bug Copy Issue Report Empty catch clauses should be used with caution; consider adding a comment why this is needed. Loading history...
31			}
32			}
33
34			str = str.replace(matchFromExec[1], toReplace)
35			}
36

AdFabConnect / abejs

Push — master ( bdfcbe...91ed9c )

src/cli/cms/data/sql.js F

Complexity

Size

Duplication

Importance

14 Functions

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like