@mixd-id/web-scaffold 0.2.240706 → 0.2.250801010

package/src/utils/preset-selector.js

@@ -1,8 +1,366 @@
-const groupBy = require("lodash/groupBy");
 const dayjs = require("dayjs");
-const {Op, literal, fn, col, where, DataTypes} = require("sequelize");
-const {ftWildcard} = require("./helpers");
-const util = require("util");
+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 'eq':
+        case '=':
+          withoutKey ?
+            whereObj = {
+              [Op.eq]: filter.value
+            } :
+            whereObj[key] = {
+              [Op.eq]: filter.value
+            }
+          break
+
+        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){
@@ -23,8 +381,14 @@ const filtersToSequelizeWhere = async(filters, opt) => {
     const type = ((keyColumns[key] ?? [])[0] ?? {}).type
 
     let whereObj = {}
-    const modelAttributes = opt.model.getAttributes()
-    const {Model, field} = modelAttributes[key]
+    let Model, field
+    if(opt.model){
+      const modelAttributes = opt.model.getAttributes()
+      if(modelAttributes[key]){
+        Model = opt.model
+        field = modelAttributes[key].field
+      }
+    }
 
     switch(type){
 
@@ -127,6 +491,12 @@ const filtersToSequelizeWhere = async(filters, opt) => {
             }
             break
 
+          case 'null':
+            whereObj = {
+              [key]: null
+            }
+            break
+
           case 'between':
             whereObj = {
               [key]:{
@@ -268,6 +638,7 @@ const filtersToSequelizeWhere = async(filters, opt) => {
 
       default:
         switch(operator) {
+          case 'eq':
           case '=':
             whereObj = {
               [key]:{
@@ -276,7 +647,6 @@ const filtersToSequelizeWhere = async(filters, opt) => {
             }
             break
 
-          case 'eq':
           case 'not':
             whereObj = {
               [key]:{
@@ -317,6 +687,17 @@ const filtersToSequelizeWhere = async(filters, opt) => {
             }
             break
 
+          case 'notEmpty':
+            whereObj = {
+              [key]:{
+                [Op.or]: [
+                  { [Op.ne]: null },
+                  { [Op.ne]: '' }
+                ]
+              }
+            }
+            break
+
           case 'in':
             whereObj = {
               [key]:{
@@ -649,7 +1030,6 @@ const chartToSequelizeWhere = async (chart, opt) => {
 }
 
 const pivotToSequelizeWhere = async (pivot, opt) => {
-
   const { model, sorts = [] } = opt
 
   const attributes = []
@@ -657,120 +1037,131 @@ const pivotToSequelizeWhere = async (pivot, opt) => {
   const order = []
   const sortExists = sorts.length > 0
 
-  const groupedSorts = groupBy(sorts, 'key')
-
-  for(let row of pivot.rows){
+  if(Array.isArray(pivot.rows)){
+    const groupedSorts = groupBy(sorts, 'key')
 
-    const field = model.rawAttributes[row.key].field
+    for(let row of pivot.rows){
+      const field = model.rawAttributes[row.key].field
 
-    switch(row.aggregrate){
+      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 '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 '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 '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
+        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
+        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
-  for(let value of pivot.values){
-    const valueKey = model.rawAttributes[value.key].field
+  if(Array.isArray(pivot.values)){
+    for(let value of pivot.values){
+      const valueKey = model.rawAttributes[value.key].field
 
-    switch(value.aggregrate){
+      switch(value.aggregrate){
 
-      case 'sum':
-        attributes.push([ fn('SUM', literal(`${model.name}.${valueKey}`)), `_${value.key}-${value.aggregrate}` ])
-        break
+        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 '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 '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 '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 '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 '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
+        case 'first':
+          attributes.push([ literal(`(SELECT ${valueKey} FROM ${model.tableName} WHERE id = MIN(${model.name}.id))`), `_${value.key}-${value.aggregrate}` ])
+          break
 
-      default:
-        const { where, replacements } = opt
-        const groups = await model.findAll({
-          attributes: [ value.key ],
-          where: {
-            [Op.and]: [
-              where
-            ]
-          },
-          group: [ value.key ],
-          replacements
-        })
+        case 'last':
+          attributes.push([ literal(`(SELECT ${valueKey} FROM ${model.tableName} WHERE id = MAX(${model.name}.id))`), `_${value.key}-${value.aggregrate}` ])
+          break
 
-        if(groups.length > 50){
-          throw new Error('Pivot value group is too large, max 50 items allowed.')
-        }
+        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
+          const field = model.rawAttributes[value.key].field
 
 
-        groups.forEach(group => {
+          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}` ])
+            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{
-              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}` ])
+              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
+          break
+      }
     }
   }
 
@@ -892,6 +1283,8 @@ const filtersToSequelizeInclude = async(filters, opt, includes) => {
       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 */))
@@ -915,7 +1308,7 @@ const syntaxSearchToSequelizeOpt = async(search, opt) => {
   }
 }
 
-const presetToSequelizeList = async(preset = {}, {
+const presetToSequelizeList = async(preset, {
   conn,
   model,
   config,
@@ -924,6 +1317,7 @@ const presetToSequelizeList = async(preset = {}, {
   include,
   order:initialOrder
 }) => {
+  if(!model) return {}
 
   const updatedAtField = model.rawAttributes['updatedAt'] ?? model.rawAttributes['updated_at']