@mixd-id/web-scaffold 0.2.240705 → 0.2.250801009

package/src/utils/preset-selector.cjs

@@ -0,0 +1,1455 @@
+const dayjs = require("dayjs");
+const {Op, literal, fn, DataTypes} = module.parent.require("sequelize");
+const {ftWildcard, groupBy} = require("./helpers");
+
+const getValue = (filter, opt) => {
+
+  const { columns, withoutKey = false } = opt
+  const { key, operator } = filter
+  const keyColumns = groupBy(columns, 'key')
+  const type = ((keyColumns[key] ?? [])[0] ?? {}).type
+
+  let whereObj = {}
+
+  switch(type){
+
+    case 'boolean':
+      withoutKey ? whereObj = { [Op.eq]:filter.value } : whereObj[key] = filter.value
+      break
+
+    case 'number':
+      switch(operator) {
+        case '=':
+          withoutKey ? whereObj = { [Op.eq]:filter.value } : whereObj[key] = filter.value
+          break
+
+        case '>':
+        case '>=':
+        case '<':
+        case '<=':
+          withoutKey ?
+            whereObj = { [Op[operator]]:filter.value } :
+            whereObj[key] = {
+              [Op[operator]]: filter.value
+            }
+          break
+
+        case 'in':
+          withoutKey ?
+            whereObj = { [Op.in]: (Array.isArray(filter.value) ? filter.value : filter.value.split(','))
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_)) } :
+            whereObj[key] = {
+              [Op.in]: filter.value.split(',')
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_))
+            }
+          break
+
+        case 'notIn':
+          withoutKey ?
+            whereObj = { [Op.notIn]: filter.value.split(',')
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_)) } :
+            whereObj[key] = {
+              [Op.notIn]: filter.value.split(',')
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_))
+            }
+          break
+      }
+      break
+
+    case 'date':
+      switch(operator) {
+
+        case 'thisWeek':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs().startOf('week').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('week').format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs().startOf('week').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('week').format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case 'thisMonth':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs().startOf('month').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('month').format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs().startOf('month').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('month').format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case 'thisYear':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs().startOf('year').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('year').format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs().startOf('year').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('year').format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case 'null':
+          withoutKey ?
+            whereObj = {
+              [Op.eq]: null
+            } :
+            whereObj[key] = {
+              [Op.eq]: null
+            }
+          break
+
+        case 'between':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                dayjs(filter.value2).format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                dayjs(filter.value2).format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case 'yesterday':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs().subtract(1, 'day').startOf('day').format('YYYY-MM-DD 00:00:00'),
+                dayjs().subtract(1, 'day').endOf('day').format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs().subtract(1, 'day').startOf('day').format('YYYY-MM-DD 00:00:00'),
+                dayjs().subtract(1, 'day').endOf('day').format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case 'today':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs().startOf('day').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('day').format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs().startOf('day').format('YYYY-MM-DD 00:00:00'),
+                dayjs().endOf('day').format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case '<':
+          withoutKey ?
+            whereObj = {
+              [Op.lt]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.lt]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+              ]
+            }
+          break
+
+        case '<=':
+          withoutKey ?
+            whereObj = {
+              [Op.lte]: [
+                dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.lte]: [
+                dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case '=':
+          withoutKey ?
+            whereObj = {
+              [Op.between]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.between]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case '>':
+          withoutKey ?
+            whereObj = {
+              [Op.gt]: [
+                dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.gt]: [
+                dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+              ]
+            }
+          break
+
+        case '>=':
+          withoutKey ?
+            whereObj = {
+              [Op.gte]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+              ]
+            } :
+            whereObj[key] = {
+              [Op.gte]: [
+                dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+              ]
+            }
+          break
+
+      }
+      break
+
+    default:
+      switch(operator) {
+        case '=':
+          withoutKey ?
+            whereObj = {
+              [Op.eq]: filter.value
+            } :
+            whereObj[key] = {
+              [Op.eq]: filter.value
+            }
+          break
+
+        case 'eq':
+        case 'not':
+          withoutKey ?
+            whereObj = {
+              [Op[operator]]: filter.value
+            } :
+            whereObj[key] = {
+              [Op[operator]]: filter.value
+            }
+          break
+
+        case 'startsWith':
+          withoutKey ?
+            whereObj = {
+              [Op.like]: `${filter.value}%`
+            } :
+            whereObj[key] = {
+              [Op.like]: `${filter.value}%`
+            }
+          break
+
+        case 'endsWith':
+          withoutKey ?
+            whereObj = {
+              [Op.like]: `%${filter.value}`
+            } :
+            whereObj[key] = {
+              [Op.like]: `%${filter.value}`
+            }
+          break
+
+        case 'contains':
+          withoutKey ?
+            whereObj = {
+              [Op.like]: `%${filter.value}%`
+            } :
+            whereObj[key] = {
+              [Op.like]: `%${filter.value}%`
+            }
+          break
+
+        case 'notContains':
+          withoutKey ?
+            whereObj = {
+              [Op.notLike]: `%${filter.value}%`
+            } :
+            whereObj[key] = {
+              [Op.notLike]: `%${filter.value}%`
+            }
+          break
+
+        case 'notEmpty':
+          whereObj = {
+            [key]:{
+              [Op.or]: [
+                { [Op.ne]: null },
+                { [Op.ne]: '' }
+              ]
+            }
+          }
+          break
+
+        case 'in':
+          withoutKey ?
+            whereObj = {
+              [Op.in]: (!Array.isArray(filter.value) ? filter.value.split(',') : filter.value)
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_))
+            } :
+            whereObj[key] = {
+              [Op.in]: (!Array.isArray(filter.value) ? filter.value.split(',') : filter.value)
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_))
+            }
+          break
+
+        case 'notIn':
+          withoutKey ?
+            whereObj = {
+              [Op.notIn]: filter.value.split(',')
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_))
+            } :
+            whereObj[key] = {
+              [Op.notIn]: filter.value.split(',')
+                .map(_ => parseInt(_))
+                .filter(_ => !isNaN(_))
+            }
+          break
+
+        case 'regex':
+          withoutKey ?
+            whereObj = {
+              [Op.regexp]: filter.value
+            } :
+            whereObj[key] = {
+              [Op.regexp]: filter.value
+            }
+          break
+      }
+      break
+  }
+
+  return whereObj
+}
+
+const filtersToSequelizeWhere = async(filters, opt) => {
+  if(!Array.isArray(filters) || filters.length < 1){
+    return {
+      where: {},
+      replacements: []
+    }
+  }
+
+  let whereArr = []
+  let replacements = []
+
+  const getValue = (filter, opt) => {
+
+    const { columns } = opt.config
+    let { key, operator, value, fn:filterFn } = filter
+    const keyColumns = groupBy(columns, 'key')
+    const type = ((keyColumns[key] ?? [])[0] ?? {}).type
+
+    let whereObj = {}
+    let Model, field
+    if(opt.model){
+      const modelAttributes = opt.model.getAttributes()
+      if(modelAttributes[key]){
+        Model = opt.model
+        field = modelAttributes[key].field
+      }
+    }
+
+    switch(type){
+
+      case 'boolean':
+        value = !!value
+        whereObj = { [key]: value }
+        break
+
+      case 'number':
+      case 'currency':
+        value = parseFloat(value)
+
+        switch(operator) {
+          case '=':
+            whereObj = { [key]:value }
+            break
+
+          case '>':
+            whereObj = { [key]:{ [Op.gt]:value } }
+            break
+
+          case '>=':
+            whereObj = { [key]:{ [Op.gte]:value } }
+            break
+
+          case '<':
+            whereObj = { [key]:{ [Op.lt]:value } }
+            break
+
+          case '<=':
+            whereObj = { [key]:{ [Op.lte]:value } }
+            break
+
+          case 'in':
+            whereObj = {
+              [key]:{
+                [Op.in]: (!Array.isArray(filter.value) ? filter.value.split(',') : filter.value)
+                  .map(_ => parseInt(_))
+                  .filter(_ => !isNaN(_))
+              }
+            }
+            break
+
+          case 'notIn':
+            whereObj = {
+              [key]:{
+                [Op.notIn]: (!Array.isArray(filter.value) ? filter.value.split(',') : filter.value)
+                  .map(_ => parseInt(_))
+                  .filter(_ => !isNaN(_))
+              }
+            }
+            break
+        }
+        break
+
+      case 'date':
+        switch(operator) {
+
+          case 'thisWeek':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs().startOf('week').format('YYYY-MM-DD 00:00:00'),
+                  dayjs().endOf('week').format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case 'thisMonth':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs().startOf('month').format('YYYY-MM-DD 00:00:00'),
+                  dayjs().endOf('month').format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case 'lastMonth':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs().subtract(1, 'month').startOf('month').format('YYYY-MM-DD 00:00:00'),
+                  dayjs().subtract(1, 'month').endOf('month').format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case 'thisYear':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs().startOf('year').format('YYYY-MM-DD 00:00:00'),
+                  dayjs().endOf('year').format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case 'null':
+            whereObj = {
+              [key]: null
+            }
+            break
+
+          case 'between':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                  dayjs(filter.value2).format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case 'yesterday':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs().subtract(1, 'day').startOf('day').format('YYYY-MM-DD 00:00:00'),
+                  dayjs().subtract(1, 'day').endOf('day').format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case 'today':
+            whereObj = {
+              [key]:{
+                [Op.between]: [
+                  dayjs().startOf('day').format('YYYY-MM-DD 00:00:00'),
+                  dayjs().endOf('day').format('YYYY-MM-DD 23:59:59'),
+                ]
+              }
+            }
+            break
+
+          case '<':
+            switch(filterFn) {
+
+              case 'format_hour':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%H") < "${filter.value}"`)
+                break
+
+              default:
+                whereObj = {
+                  [key]: {
+                    [Op.lt]: [
+                      dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                    ]
+                  }
+                }
+            }
+            break
+
+          case '<=':
+            switch(filterFn) {
+
+              case 'format_hour':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%H") <= "${filter.value}"`)
+                break
+
+              default:
+                whereObj = {
+                  [key]: {
+                    [Op.lte]: [
+                      dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+                    ]
+                  }
+                }
+            }
+            break
+
+          case '=':
+            switch(filterFn) {
+
+              case 'format_date':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%Y-%m-%d") = "${filter.value}"`)
+                break
+
+              case 'format_hour':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%H") = "${filter.value}"`)
+                break
+
+              case 'format_month':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%m") = "${filter.value.split('-')[1]}"`)
+                break
+
+              case 'format_year':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%Y") = "${filter.value}"`)
+                break
+
+              default:
+                whereObj = {
+                  [key]: {
+                    [Op.between]: [
+                      dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                      dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+                    ]
+                  }
+                }
+            }
+            break
+
+          case '>':
+            switch(filterFn) {
+
+              case 'format_hour':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%H") > "${filter.value}"`)
+                break
+
+              default:
+                whereObj = {
+                  [key]: {
+                    [Op.gt]: [
+                      dayjs(filter.value).format('YYYY-MM-DD 23:59:59'),
+                    ]
+                  }
+                }
+            }
+            break
+
+          case '>=':
+            switch(filterFn) {
+
+              case 'format_hour':
+                whereObj = literal(`DATE_FORMAT(${Model.name}.${field}, "%H") >= "${filter.value}"`)
+                break
+
+              default:
+                whereObj = {
+                  [key]: {
+                    [Op.gte]: [
+                      dayjs(filter.value).format('YYYY-MM-DD 00:00:00'),
+                    ]
+                  }
+                }
+            }
+            break
+
+        }
+        break
+
+      default:
+        switch(operator) {
+          case '=':
+            whereObj = {
+              [key]:{
+                [Op.eq]: filter.value
+              }
+            }
+            break
+
+          case 'eq':
+          case 'not':
+            whereObj = {
+              [key]:{
+                [Op[operator]]: filter.value
+              }
+            }
+            break
+
+          case 'startsWith':
+            whereObj = {
+              [key]:{
+                [Op.like]: `${filter.value}%`
+              }
+            }
+            break
+
+          case 'endsWith':
+            whereObj = {
+              [key]:{
+                [Op.like]: `%${filter.value}`
+              }
+            }
+            break
+
+          case 'contains':
+            whereObj = {
+              [key]:{
+                [Op.like]: `%${filter.value}%`
+              }
+            }
+            break
+
+          case 'notContains':
+            whereObj = {
+              [key]:{
+                [Op.notLike]: `%${filter.value}%`
+              }
+            }
+            break
+
+          case 'notEmpty':
+            whereObj = {
+              [key]:{
+                [Op.or]: [
+                  { [Op.ne]: null },
+                  { [Op.ne]: '' }
+                ]
+              }
+            }
+            break
+
+          case 'in':
+            whereObj = {
+              [key]:{
+                [Op.in]: (!Array.isArray(filter.value) ? filter.value.split(',') : filter.value)
+                  .filter(_ => _)
+              }
+            }
+            break
+
+          case 'notIn':
+            whereObj = {
+              [key]:{
+                [Op.notIn]: filter.value.split(',')
+                  .map(_ => parseInt(_))
+                  .filter(_ => !isNaN(_))
+              }
+            }
+            break
+
+          case 'regex':
+            whereObj = {
+              [key]:{
+                [Op.regexp]: filter.value
+              }
+            }
+            break
+        }
+        break
+    }
+
+    return whereObj
+  }
+
+  //console.log(util.inspect(filters, false, null, true))
+
+  for(let filter of filters) {
+    if (filter.enabled === false) continue
+
+    const { key, value, modifier = 'and' } = filter
+
+    if(key.indexOf('.') >= 0) continue
+
+    if(Array.isArray(value)){
+
+      const modifierValue = []
+
+      for(let _value of value){
+        modifierValue.push(getValue({
+          ..._value,
+          key
+        }, opt))
+      }
+
+      switch(modifier){
+        case 'or':
+          whereArr.push({
+            [Op.or]: modifierValue
+          })
+          break
+
+        default:
+          whereArr.push({
+            [Op.and]: modifierValue
+          })
+          break
+      }
+    }
+    else{
+      whereArr.push(getValue(filter, opt))
+    }
+  }
+
+  //console.log(util.inspect(whereArr, false, null, true))
+
+  return {
+    where: {
+      [Op.and]: whereArr
+    },
+    replacements
+  }
+}
+
+const afterItemToSequelizeWhere = async (order, afterItem) => {
+  if(!afterItem){
+    return { where:{}, replacements:[] }
+  }
+
+  if(order.filter((_) => _[0] === 'id').length <= 0){
+    order.push([ 'id', 'desc' ])
+  }
+
+  const opOr = []
+  for(let i = 0 ; i < order.length ; i++){
+
+    const obj = order[i]
+
+    if(obj.length !== 2) continue
+
+    const exp = {}
+    for(let j = 0 ; j < i ; j++){
+      exp[order[j][0]] = afterItem[order[j][0]]
+    }
+    exp[obj[0]] = obj[1] === 'desc' ? { [Op.lt]:afterItem[obj[0]] } : { [Op.gt]:afterItem[obj[0]] }
+
+    if(Object.keys(exp).length === 1){
+      opOr.push(exp)
+    }
+    else{
+      opOr.push({
+        [Op.and]: exp
+      })
+    }
+  }
+
+  let where = {}
+  const replacements = []
+  if(opOr.length > 0){
+    where = {
+      [Op.or]: opOr
+    }
+  }
+
+  return {
+    where,
+    replacements
+  }
+}
+
+const searchToSequelizeWhere = async (search, params) => {
+  if(!search && (!Array.isArray(params) || params.length < 1)){
+    return {
+      where: {},
+      replacements: []
+    }
+  }
+
+  const { match } = params
+
+  let where = {}
+  let replacements = []
+
+  if(match){
+
+    if(Array.isArray(match) && match.length > 0){
+      where = literal(`MATCH(${match.join(',')}) AGAINST (? IN BOOLEAN MODE)`)
+      replacements.push(ftWildcard(search))
+    }
+
+  }
+
+  return {
+    where,
+    replacements
+  }
+}
+
+const chartToSequelizeWhere = async (chart, opt) => {
+
+  const { model, where, replacements } = opt
+  const { type } = chart
+  const { xAxis, yAxis } = chart[type] ?? {}
+
+  //console.log(util.inspect(chart, false, null, true ))
+
+  let attributes = []
+  let group = []
+  let include = []
+  let order
+
+  switch(type){
+
+    case 'doughnut':
+    case 'pie':
+      if(yAxis.length > 0){
+        const field = model.rawAttributes[yAxis[0].key].field
+
+        for(let xAxe of xAxis){
+          if(!xAxe.key) continue
+
+          const field = model.rawAttributes[xAxe.key].field
+
+          switch(xAxe.aggregrate){
+
+            case 'date':
+              attributes.push([literal(`DATE_FORMAT(${field}, "%Y-%m-%d")`), xAxis[0].key])
+              group.push(literal(`DATE_FORMAT(${field}, "%Y-%m-%d")`))
+              order = literal(`DATE_FORMAT(${field}, \"%Y-%m-%d\")`)
+              break
+
+            default:
+              attributes.push([literal(`${field}`), xAxe.key])
+              group.push(literal(`${field}`))
+              order = literal(`${field}`)
+              break
+          }
+        }
+
+        if(yAxis.length > 0){
+          for(let yAxe of yAxis){
+            if(!yAxe.key) continue
+
+            const groups = await model.findAll({
+              attributes: [ yAxe.key ],
+              where: {
+                [Op.and]: [
+                  where
+                ]
+              },
+              group: [ yAxe.key ],
+              replacements
+            })
+
+            if(groups.length > 50){
+              throw new Error('Chart value is too large, max 50 items allowed.')
+            }
+
+            groups.forEach(group => {
+              if(group[yAxis[0].key] === null){
+                attributes.push([literal(`SUM(CASE WHEN ${field} is null THEN 1 ELSE 0 END)`), `${yAxe.key}:NULL`])
+              }
+              else if(group[yAxis[0].key] === ''){
+                attributes.push([literal(`SUM(CASE WHEN ${field} = '' THEN 1 ELSE 0 END)`), `${yAxe.key}:EMPTY`])
+              }
+              else{
+                attributes.push([literal(`SUM(CASE WHEN ${field} = '${group[yAxe.key]}' THEN 1 ELSE 0 END)`), `${yAxe.key}:${group[yAxe.key]}` ])
+              }
+            })
+          }
+        }
+        else{
+          attributes.push([literal(`COUNT(*)`), 'count'])
+        }
+
+      }
+      break
+
+    case 'bar':
+    case 'line':
+      for(let xAxe of xAxis){
+        if(!xAxe.key) continue
+
+        const field = model.rawAttributes[xAxe.key].field
+
+        switch(xAxe.aggregrate){
+
+          case 'date':
+            attributes.push([literal(`DATE_FORMAT(${model.name}.${field}, "%Y-%m-%d")`), xAxis[0].key])
+            group.push(literal(`DATE_FORMAT(${model.name}.${field}, "%Y-%m-%d")`))
+            order = literal(`DATE_FORMAT(${model.name}.${field}, \"%Y-%m-%d\")`)
+            break
+
+          case 'hour':
+            attributes.push([literal(`DATE_FORMAT(${model.name}.${field}, "%H")`), xAxis[0].key])
+            group.push(literal(`DATE_FORMAT(${model.name}.${field}, "%H")`))
+            order = literal(`DATE_FORMAT(${model.name}.${field}, \"%H\")`)
+            break
+
+          default:
+            attributes.push([literal(`${model.name}.${field}`), xAxe.key])
+            group.push(literal(`${model.name}.${field}`))
+            order = literal(`${model.name}.${field}`)
+            break
+        }
+      }
+
+      if(yAxis.length < 1){
+        attributes.push([literal(`COUNT(*)`), 'count'])
+      }
+      else{
+        for(let yAxe of yAxis){
+          switch(yAxe.aggregrate){
+
+            case 'count':
+              attributes.push([literal(`COUNT(*)`), `${yAxe.key}:count`])
+              break
+
+            default:
+              const field = model.rawAttributes[yAxe.key].field
+
+              const groups = await model.findAll({
+                attributes: [ yAxe.key ],
+                where: {
+                  [Op.and]: [
+                    where
+                  ]
+                },
+                group: [ yAxe.key ],
+                replacements
+              })
+
+              if(groups.length > 50){
+                throw new Error('Chart value is too large, max 50 items allowed.')
+              }
+
+              groups.forEach(group => {
+                if(group[yAxe.key] === null){
+                  attributes.push([literal(`SUM(CASE WHEN ${model.name}.${field} is null THEN 1 ELSE 0 END)`), `${yAxe.key}:NULL`])
+                }
+                else if(group[yAxe.key] === ''){
+                  attributes.push([literal(`SUM(CASE WHEN ${model.name}.${field} = '' THEN 1 ELSE 0 END)`), `${yAxe.key}:EMPTY`])
+                }
+                else{
+                  attributes.push([literal(`SUM(CASE WHEN ${model.name}.${field} = '${group[yAxe.key]}' THEN 1 ELSE 0 END)`), `${yAxe.key}:${group[yAxe.key]}` ])
+                }
+              })
+
+              break
+          }
+        }
+      }
+
+      break
+  }
+
+  /*console.log(
+    util.inspect({
+      attributes,
+      group,
+      order,
+      include
+    }, false, null, true)
+  )*/
+
+  return {
+    attributes,
+    group,
+    order,
+    include
+  }
+}
+
+const pivotToSequelizeWhere = async (pivot, opt) => {
+  const { model, sorts = [] } = opt
+
+  const attributes = []
+  const group = []
+  const order = []
+  const sortExists = sorts.length > 0
+
+  if(Array.isArray(pivot.rows)){
+    const groupedSorts = groupBy(sorts, 'key')
+
+    for(let row of pivot.rows){
+      const field = model.rawAttributes[row.key].field
+
+      switch(row.aggregrate){
+
+        case 'date':
+          attributes.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y-%m-%d'), row.key ])
+          group.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y-%m-%d'), row.key ])
+          if(!sortExists) order.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y-%m-%d'), 'asc' ])
+          break
+
+        case 'month':
+          attributes.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y-%m'), row.key ])
+          group.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y-%m'), row.key ])
+          if(!sortExists) order.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y-%m'), 'asc' ])
+          break
+
+        case 'year':
+          attributes.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y'), row.key ])
+          group.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y'), row.key ])
+          if(!sortExists) order.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%Y'), 'asc' ])
+          break
+
+        case 'hour':
+          attributes.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%H:00-%H:59'), row.key ])
+          group.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%H:00-%H:59'), row.key ])
+          if(!sortExists) order.push([ fn('DATE_FORMAT', literal(`${model.name}.${field}`), '%H:00-%H:59'), 'asc' ])
+          break
+
+        default:
+          attributes.push([ literal(`${model.name}.${field}`), row.key ])
+          group.push(`${model.name}.${field}`)
+          if(!sortExists) order.push([ row.key, groupedSorts[row.key] ? groupedSorts[row.key][0].type : 'asc' ])
+          break
+      }
+    }
+  }
+
+  const sortKeyToOrders = {} // Helper to determine group ordering
+  if(Array.isArray(pivot.values)){
+    for(let value of pivot.values){
+      const valueKey = model.rawAttributes[value.key].field
+
+      switch(value.aggregrate){
+
+        case 'sum':
+          attributes.push([ fn('SUM', literal(`${model.name}.${valueKey}`)), `_${value.key}-${value.aggregrate}` ])
+          break
+
+        case 'avg':
+          attributes.push([ fn('AVG', literal(`${model.name}.${valueKey}`)), `_${value.key}-${value.aggregrate}` ])
+          break
+
+        case 'min':
+          attributes.push([ fn('MIN', literal(`${model.name}.${valueKey}`)), `_${value.key}-${value.aggregrate}` ])
+          break
+
+        case 'max':
+          attributes.push([ fn('MAX', literal(`${model.name}.${valueKey}`)), `_${value.key}-${value.aggregrate}` ])
+          break
+
+        case 'countDistinct':
+          attributes.push([ literal(`COUNT(DISTINCT ${model.name}.${valueKey})`), `_${value.key}-${value.aggregrate}` ])
+          sortKeyToOrders[`_${value.key}-${value.aggregrate}`] = literal(`COUNT(DISTINCT ${model.name}.${valueKey})`)
+          break
+
+        case 'first':
+          attributes.push([ literal(`(SELECT ${valueKey} FROM ${model.tableName} WHERE id = MIN(${model.name}.id))`), `_${value.key}-${value.aggregrate}` ])
+          break
+
+        case 'last':
+          attributes.push([ literal(`(SELECT ${valueKey} FROM ${model.tableName} WHERE id = MAX(${model.name}.id))`), `_${value.key}-${value.aggregrate}` ])
+          break
+
+        case 'count':
+          attributes.push([ fn('COUNT', literal(`${model.name}.${valueKey}`)), `_${value.key}-${value.aggregrate}` ])
+          sortKeyToOrders[`_${value.key}-${value.aggregrate}`] = fn('COUNT', literal(`${model.name}.${valueKey}`))
+          break
+
+        default:
+          const { where, replacements } = opt
+          const groups = await model.findAll({
+            attributes: [ value.key ],
+            where: {
+              [Op.and]: [
+                where
+              ]
+            },
+            group: [ value.key ],
+            replacements
+          })
+
+          if(groups.length > 50){
+            throw new Error('Pivot value group is too large, max 50 items allowed.')
+          }
+
+          const field = model.rawAttributes[value.key].field
+
+
+          groups.forEach(group => {
+
+            let groupValue
+            if(group[value.key] === null){
+              attributes.push([ literal(`SUM(CASE WHEN ${model.name}.${field} is null THEN 1 ELSE 0 END)`), `_${value.key}-(null)` ])
+            }
+            else if(group[value.key] === ''){
+              attributes.push([ literal(`SUM(CASE WHEN ${model.name}.${field} = '' THEN 1 ELSE 0 END)`), `_${value.key}-(empty)` ])
+            }
+            else{
+              if(model.rawAttributes[value.key].type instanceof DataTypes.BOOLEAN){
+                groupValue = group[value.key]
+                attributes.push([ literal(`SUM(CASE WHEN ${model.name}.${field} = ${groupValue === true ? 1 : 0} THEN 1 ELSE 0 END)`), `_${value.key}-${groupValue}` ])
+              }
+              else{
+                groupValue = (group[value.key] ?? '').toString().replace(/\s/g, '_')
+                attributes.push([ literal(`SUM(CASE WHEN ${model.name}.${field} = '${group[value.key]}' THEN 1 ELSE 0 END)`), `_${value.key}-${groupValue}` ])
+              }
+            }
+          })
+
+          break
+      }
+    }
+  }
+
+  if(sortExists){
+    for(let sort of sorts){
+      if(sortKeyToOrders[sort.key]){
+        order.push([ sortKeyToOrders[sort.key], sort.type ?? 'asc' ])
+      }
+      else{
+        order.push([ sort.key, sort.type ?? 'asc' ])
+      }
+    }
+  }
+
+  attributes.push([ literal(`1`), 'isPivot' ])
+
+  return {
+    attributes,
+    group,
+    order
+  }
+}
+
+const sortsToSequelizeWhere = async (sorts, opt) => {
+
+  let { order, model } = opt ?? {}
+
+  if(Array.isArray(sorts) && sorts.length > 0){
+
+    if(sorts.filter(_ => !_.key).length > 0){
+      throw new Error('Sorts must have a key')
+    }
+
+    order = []
+    for(let sort of sorts){
+      order.push([ sort.key, sort.type ?? 'asc' ])
+    }
+  }
+
+  // Make sure the last sort is always by id
+  if(order.length > 0 && order[order.length - 1][0] !== 'id' &&
+    model && model.rawAttributes && model.rawAttributes.id && model.rawAttributes.id.field){
+    order.push([ 'id', (order[0] ?? [])[1] ?? 'desc' ])
+  }
+
+  //console.log(util.inspect(sorts, false, null, true /* enable colors */))
+
+  return {
+    order
+  }
+}
+
+const filtersToSequelizeInclude = async(filters, opt, includes) => {
+  if(!Array.isArray(filters) || filters.length < 1){
+    return includes
+  }
+
+  // TODO: Test on 2 level or more level includes
+
+  // Generate where object
+  let whereObj = {}
+  for(let filter of filters) {
+    if (filter.enabled === false) continue
+
+    const {key, value, operator} = filter
+
+    if(key.indexOf('.') < 0) continue
+
+    if(Array.isArray(value) && !operator){
+      const { modifier = 'and' } = filter
+
+      if(![ 'and', 'or' ].includes(modifier)) continue
+
+      const opModifierValue = []
+      for(let v of value){
+        opModifierValue.push(getValue({ ...v, key }, {
+          ...opt,
+          withoutKey: true
+        }))
+      }
+
+      whereObj = {
+        ...whereObj,
+        [key]: {
+          [Op[modifier]]: opModifierValue
+        }
+      }
+    }
+    else{
+      whereObj = {
+        ...whereObj,
+        ...getValue(filter, opt)
+      }
+    }
+  }
+  //console.log('whereObj', util.inspect(whereObj, false, null, true /* enable colors */))
+
+  // Apply where to includes
+  for(let key in whereObj){
+
+    const keyParts = key.split('.')
+    if(keyParts.length < 2) continue
+
+    // Walk through the includes to find the correct include
+    let include
+    for(let i = 0 ; i < keyParts.length - 1 ; i++){
+      const as = keyParts[i]
+      include = !include ? includes.find(_ => _.as === as) : include.includes ?? []
+    }
+
+    // If include is not found, skip
+    if(!include){
+      continue
+    }
+
+    // Generate where object for the correct include
+    const currentKey = keyParts[keyParts.length - 1]
+    if(!include.where){
+      include.where = { [Op.and]: [] }
+    }
+    include.where[Op.and].push({ [currentKey]: whereObj[key] })
+
+    include.required = true
+  }
+
+  //console.log('includes', util.inspect(includes, false, null, true /* enable colors */))
+
+  return includes
+}
+
+const syntaxSearchToSequelizeOpt = async(search, opt) => {
+
+  let where = {}
+  let replacements = []
+
+  const { config } = opt
+
+  let syntaxKey = search[1]
+  let syntaxVal = search[2].trim()
+
+  return {
+    where,
+    replacements
+  }
+}
+
+const presetToSequelizeList = async(preset, {
+  conn,
+  model,
+  config,
+  where:initialWhere,
+  replacements: initialReplacements,
+  include,
+  order:initialOrder
+}) => {
+  if(!model) return {}
+
+  const updatedAtField = model.rawAttributes['updatedAt'] ?? model.rawAttributes['updated_at']
+
+  if(!initialOrder){
+    initialOrder = [
+      ...(updatedAtField ? [[ updatedAtField.fieldName, 'desc' ]] : []),
+      [ 'id', 'desc' ],
+    ]
+  }
+
+  const { itemsPerPage = 20, filters = [], sorts, pivot, afterItem, search, id, uid } = preset;
+
+  let where = {}
+  const replacements = []
+  const { order } = await sortsToSequelizeWhere(sorts, {
+    order: initialOrder
+  })
+
+  if(Array.isArray(id)){
+    where = {
+      ...where,
+      id: {
+        [Op.in]: id
+      }
+    }
+  }
+
+  if(Array.isArray(uid)){
+    where = {
+      ...where,
+      uid: {
+        [Op.in]: uid
+      }
+    }
+  }
+
+  const { where:filterWhere, replacements:filterReplacements } = await filtersToSequelizeWhere(filters, {
+    config,
+    model
+  })
+
+  let searchWhere = {}, searchReplacements = []
+  if(search){
+    const syntaxSearch = (search ?? '').match(/^(\w+)\:(.*)/)
+    if(syntaxSearch !== null){
+      const syntaxSearchOpt = syntaxSearchToSequelizeOpt(syntaxSearch, { config })
+      searchWhere = syntaxSearchOpt.where
+      searchReplacements = syntaxSearchOpt.replacements
+    }
+    else{
+      const match = (config.columns ?? [])
+        .filter(_ => (_.search && _.key))
+        .map(_ => typeof _.search === 'string' ? _.search : _.key)
+
+      if(match !== null){
+        const searchOpt = await searchToSequelizeWhere(search, {
+          match
+        })
+        searchWhere = searchOpt.where
+        searchReplacements = searchOpt.replacements
+      }
+      else{
+        console.warn('### Preset search does not have any searchable columns defined, search will not work.')
+      }
+    }
+  }
+
+  if(include){
+    include = await filtersToSequelizeInclude(filters, config, include)
+  }
+
+  if(pivot && pivot.enabled){
+    const { attributes, group, order } = await pivotToSequelizeWhere(pivot, {
+      model,
+      conn
+    })
+
+    return {
+      attributes,
+      where: {
+        [Op.and]: [
+          initialWhere ?? {},
+          where,
+          filterWhere,
+          searchWhere
+        ]
+      },
+      replacements: [
+        ...(initialReplacements ?? []),
+        ...filterReplacements,
+        ...searchReplacements
+      ],
+      group,
+      order
+    }
+  }
+  else{
+    const { where:afterItemWhere } = await afterItemToSequelizeWhere(order, afterItem)
+
+    return {
+      where: {
+        [Op.and]: [
+          initialWhere ?? {},
+          where,
+          afterItemWhere,
+          filterWhere,
+          searchWhere,
+        ]
+      },
+      limit: itemsPerPage + 1,
+      order,
+      include,
+      replacements: [
+        ...(initialReplacements ?? []),
+        ...replacements,
+        ...filterReplacements,
+        ...searchReplacements
+      ],
+      itemsPerPage
+    }
+  }
+}
+
+
+module.exports = {
+  filtersToSequelizeWhere,
+  afterItemToSequelizeWhere,
+  searchToSequelizeWhere,
+  chartToSequelizeWhere,
+  pivotToSequelizeWhere,
+  sortsToSequelizeWhere,
+  filtersToSequelizeInclude,
+
+  presetToSequelizeList
+}