zet-lib 6.0.2 → 6.1.0

package/lib/connection.js

@@ -79,11 +79,62 @@ const sanitizeWhereField = (field) => {
 }
 
 // Whitelist operator perbandingan untuk WHERE
-const SAFE_WHERE_OPERATORS = new Set(['=', '!=', '<>', '<', '>', '<=', '>=', 'LIKE', 'ILIKE', 'IS NOT', 'IS'])
+const SAFE_WHERE_OPERATORS = new Set([
+  '=', '!=', '<>', '<', '>', '<=', '>=',
+  'LIKE', 'ILIKE', 'NOT LIKE', 'NOT ILIKE',
+  'IS NOT', 'IS', 'IN', 'NOT IN',
+  'BETWEEN', 'NOT BETWEEN', '@>',
+])
+
+const OPERATOR_NAME_MAP = {
+  '=': '=',
+  EQ: '=',
+  '!=': '<>',
+  '<>': '<>',
+  NE: '<>',
+  '<': '<',
+  LT: '<',
+  '>': '>',
+  GT: '>',
+  '<=': '<=',
+  LTE: '<=',
+  '>=': '>=',
+  GTE: '>=',
+  LIKE: 'LIKE',
+  ILIKE: 'ILIKE',
+  'NOT LIKE': 'NOT LIKE',
+  NOTLIKE: 'NOT LIKE',
+  'NOT ILIKE': 'NOT ILIKE',
+  NOTILIKE: 'NOT ILIKE',
+  IN: 'IN',
+  'NOT IN': 'NOT IN',
+  NOTIN: 'NOT IN',
+  BETWEEN: 'BETWEEN',
+  'NOT BETWEEN': 'NOT BETWEEN',
+  NOTBETWEEN: 'NOT BETWEEN',
+  IS: 'IS',
+  'IS NOT': 'IS NOT',
+  ISNOT: 'IS NOT',
+  'IS NULL': 'IS NULL',
+  ISNULL: 'IS NULL',
+  'IS NOT NULL': 'IS NOT NULL',
+  ISNOTNULL: 'IS NOT NULL',
+  'NOT NULL': 'IS NOT NULL',
+  NOTNULL: 'IS NOT NULL',
+  '@>': '@>',
+  CONTAINS: '@>',
+}
+
+const normalizeOperator = (op) => {
+  if (op == null) return ''
+  const key = String(op).trim().replace(/_/g, ' ').replace(/\s+/g, ' ').toUpperCase()
+  return OPERATOR_NAME_MAP[key] || ''
+}
+
 const sanitizeWhereOption = (option) => {
   if (option == null || typeof option !== 'string') return ''
-  const s = String(option).trim().toUpperCase()
-  return SAFE_WHERE_OPERATORS.has(s) ? s : ''
+  const s = String(option).trim().toUpperCase().replace(/\s+/g, ' ')
+  return SAFE_WHERE_OPERATORS.has(s) ? s : (normalizeOperator(s) || '')
 }
 
 const sanitizeWhereConnector = (op) => {
@@ -92,6 +143,233 @@ const sanitizeWhereConnector = (op) => {
   return (s === 'OR' ? ' OR ' : ' AND ')
 }
 
+const quoteIdent = (name) => sanitizeWhereField(name)
+
+const quoteTableName = (table) => {
+  const t = sanitizeTableName(table || '')
+  if (!t) return ''
+  return t.split('.').map((p) => `"${p}"`).join('.')
+}
+
+const META_WHERE_KEYS = new Set(['type', 'cast'])
+const STRING_OPERATOR_RE = /^(>=|<=|<>|!=|=|>|<|NOT\s+ILIKE|NOT\s+LIKE|ILIKE|LIKE|NOT\s+IN|IN|NOT\s+BETWEEN|BETWEEN|IS\s+NOT\s+NULL|IS\s+NULL|IS\s+NOT|IS|@>)\s+([\s\S]+)$/i
+const KEY_OPERATOR_RE = /^(.+?)\s+(>=|<=|<>|!=|=|>|<|NOT\s+ILIKE|NOT\s+LIKE|ILIKE|LIKE|NOT\s+IN|IN|NOT\s+BETWEEN|BETWEEN|IS\s+NOT\s+NULL|IS\s+NULL|IS\s+NOT|IS|@>)$/i
+
+const parseListLiteral = (raw) => {
+  if (Array.isArray(raw)) return raw
+  const s = String(raw == null ? '' : raw).trim().replace(/^\(|\)$/g, '')
+  if (!s) return []
+  return s.split(',').map((v) => {
+    const t = v.trim().replace(/^['"]|['"]$/g, '')
+    return /^-?\d+(\.\d+)?$/.test(t) ? Number(t) : t
+  })
+}
+
+const parseRangeLiteral = (raw) => {
+  if (Array.isArray(raw)) return raw
+  const s = String(raw == null ? '' : raw).trim()
+  const byAnd = s.split(/\s+AND\s+/i)
+  if (byAnd.length >= 2) {
+    return [
+      byAnd[0].trim().replace(/^['"]|['"]$/g, ''),
+      byAnd.slice(1).join(' AND ').trim().replace(/^['"]|['"]$/g, ''),
+    ]
+  }
+  const byComma = s.split(',')
+  if (byComma.length >= 2) {
+    return [
+      byComma[0].trim().replace(/^['"]|['"]$/g, ''),
+      byComma.slice(1).join(',').trim().replace(/^['"]|['"]$/g, ''),
+    ]
+  }
+  return [s, s]
+}
+
+const isOperatorMap = (value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  if (value instanceof Date) return false
+  if (value._isAMomentObject) return false
+  const keys = Object.keys(value)
+  if (!keys.length) return false
+  return keys.every((k) => !!normalizeOperator(k) || META_WHERE_KEYS.has(String(k).toLowerCase()))
+}
+
+const fieldSqlWithCast = (fieldSql, cast) => {
+  if (!cast) return fieldSql
+  const c = String(cast).trim().toLowerCase()
+  if (!/^[a-z][a-z0-9_]*(\(\d+\))?$/.test(c)) return fieldSql
+  return `${fieldSql}::${c}`
+}
+
+const pushWhereCondition = (parts, params, increment, fieldSql, operator, value) => {
+  const op = normalizeOperator(operator)
+  if (!fieldSql || !op) return increment
+
+  if (op === 'IS NULL' || op === 'IS NOT NULL') {
+    parts.push(`${fieldSql} ${op}`)
+    return increment
+  }
+
+  if (op === 'IS' || op === 'IS NOT') {
+    if (value === null || value === undefined || /^null$/i.test(String(value))) {
+      parts.push(`${fieldSql} ${op} NULL`)
+      return increment
+    }
+    parts.push(`${fieldSql} ${op} $${increment}`)
+    params.push(value)
+    return increment + 1
+  }
+
+  if (op === 'IN' || op === 'NOT IN') {
+    const list = Array.isArray(value) ? value : parseListLiteral(value)
+    if (!list.length) {
+      parts.push(op === 'IN' ? 'FALSE' : 'TRUE')
+      return increment
+    }
+    const placeholders = list.map((_, i) => `$${increment + i}`).join(', ')
+    parts.push(`${fieldSql} ${op} (${placeholders})`)
+    params.push(...list)
+    return increment + list.length
+  }
+
+  if (op === 'BETWEEN' || op === 'NOT BETWEEN') {
+    const range = Array.isArray(value) ? value : parseRangeLiteral(value)
+    if (!range || range.length < 2) return increment
+    parts.push(`${fieldSql} ${op} $${increment} AND $${increment + 1}`)
+    params.push(range[0], range[1])
+    return increment + 2
+  }
+
+  if (op === '@>') {
+    parts.push(`${fieldSql}::jsonb @> $${increment}::jsonb`)
+    params.push(typeof value === 'string' ? value : JSON.stringify(value))
+    return increment + 1
+  }
+
+  parts.push(`${fieldSql} ${op} $${increment}`)
+  params.push(value)
+  return increment + 1
+}
+
+const appendWhereEntry = (parts, params, increment, key, value) => {
+  let fieldName = key
+  let keyOp = ''
+  const keyMatch = KEY_OPERATOR_RE.exec(String(key).trim())
+  if (keyMatch) {
+    fieldName = keyMatch[1]
+    keyOp = normalizeOperator(keyMatch[2])
+  }
+
+  const fieldSql = quoteIdent(fieldName)
+  if (!fieldSql) return increment
+
+  if (keyOp) {
+    return pushWhereCondition(parts, params, increment, fieldSql, keyOp, value)
+  }
+
+  if (value === null || value === undefined) {
+    parts.push(`${fieldSql} IS NULL`)
+    return increment
+  }
+
+  if (Array.isArray(value)) {
+    if (value.length && typeof value[0] === 'string' && normalizeOperator(value[0])) {
+      const op = normalizeOperator(value[0])
+      const rest = value.slice(1)
+      if (op === 'IN' || op === 'NOT IN') {
+        const list = rest.length === 1 && Array.isArray(rest[0]) ? rest[0] : rest
+        return pushWhereCondition(parts, params, increment, fieldSql, op, list)
+      }
+      if (op === 'BETWEEN' || op === 'NOT BETWEEN') {
+        const range = rest.length === 1 && Array.isArray(rest[0]) ? rest[0] : rest
+        return pushWhereCondition(parts, params, increment, fieldSql, op, range)
+      }
+      return pushWhereCondition(parts, params, increment, fieldSql, op, rest[0])
+    }
+    return pushWhereCondition(parts, params, increment, fieldSql, 'IN', value)
+  }
+
+  if (isOperatorMap(value)) {
+    const castRaw = value.cast || value.type
+    const cast = String(castRaw || '').toLowerCase() === 'date' ? 'date' : castRaw
+    const sqlField = fieldSqlWithCast(fieldSql, cast)
+    for (const [opKey, opVal] of Object.entries(value)) {
+      if (META_WHERE_KEYS.has(String(opKey).toLowerCase())) continue
+      increment = pushWhereCondition(parts, params, increment, sqlField, opKey, opVal)
+    }
+    return increment
+  }
+
+  if (typeof value === 'string') {
+    const matched = STRING_OPERATOR_RE.exec(value.trim())
+    if (matched) {
+      const op = normalizeOperator(matched[1])
+      let raw = matched[2]
+      if (op === 'IN' || op === 'NOT IN') raw = parseListLiteral(raw)
+      else if (op === 'BETWEEN' || op === 'NOT BETWEEN') raw = parseRangeLiteral(raw)
+      else if ((op === 'IS' || op === 'IS NOT') && /^null$/i.test(String(raw))) raw = null
+      return pushWhereCondition(parts, params, increment, fieldSql, op, raw)
+    }
+  }
+
+  return pushWhereCondition(parts, params, increment, fieldSql, '=', value)
+}
+
+const formatSelect = (select) => {
+  if (Array.isArray(select)) {
+    const cols = select.map((item) => {
+      if (typeof item !== 'string') return ''
+      const trimmed = item.trim()
+      if (!trimmed) return ''
+      return quoteIdent(trimmed) || trimmed
+    }).filter(Boolean)
+    return cols.length ? cols.join(', ') : '*'
+  }
+  if (typeof select === 'string' && select.trim()) return select
+  return '*'
+}
+
+const formatJoins = (joins) => {
+  if (!Array.isArray(joins) || !joins.length) return ''
+  return joins.map((item) => {
+    if (typeof item === 'string') return item
+    if (!item || typeof item !== 'object') return ''
+    const type = String(item.type || 'LEFT').trim().toUpperCase()
+    const allowed = new Set(['LEFT', 'RIGHT', 'INNER', 'FULL', 'LEFT OUTER', 'RIGHT OUTER', 'FULL OUTER', 'CROSS'])
+    if (!allowed.has(type)) return ''
+    const table = quoteTableName(item.table || '')
+    if (!table) return ''
+    const alias = item.as ? ` ${quoteIdent(item.as) || String(item.as).trim()}` : ''
+    if (type === 'CROSS') return `CROSS JOIN ${table}${alias}`
+    const on = String(item.on || '').trim()
+    if (!on) return ''
+    return `${type} JOIN ${table}${alias} ON ${on}`
+  }).filter(Boolean).join(' ')
+}
+
+const groupByFn = (obj) => {
+  const g = obj.groupBy || obj.group_by
+  if (!g) return ''
+  const list = Array.isArray(g) ? g : String(g).split(',')
+  const cols = list.map((item) => {
+    const trimmed = String(item || '').trim()
+    return quoteIdent(trimmed) || sanitizeOrderBySegment(trimmed)
+  }).filter(Boolean)
+  return cols.length ? ` GROUP BY ${cols.join(', ')} ` : ''
+}
+
+const havingFn = (obj, increment, arr) => {
+  const having = obj.having || {}
+  if (!having || typeof having !== 'object' || Array.isArray(having)) {
+    return { sql: '', increment }
+  }
+  const parts = []
+  for (const key in having) {
+    increment = appendWhereEntry(parts, arr, increment, key, having[key])
+  }
+  return { sql: parts.length ? ` HAVING ${parts.join(' AND ')} ` : '', increment }
+}
+
 const connection = {}
 
 connection.query = async (string, arr) => {
@@ -134,25 +412,51 @@ const orderByFn = (obj) => {
   return orderBy
 }
 
-const whereFn = (obj) => {
+const whereFn = (obj, startIncrement = 1) => {
   const where = obj.where || {}
-  //[{field:"your_field",option:"=>",value:"12",operator:"AND",type:"text,json,date, inline"}]
+  const orWhere = obj.orWhere || obj.or_where || {}
+  // [{field:"join_date",option:">=",value:"2025-02-12",operator:"AND",type:"text,json,date,inline"}]
+  // atau bentuk singkat: ["join_date", ">=", "2025-02-12"]
   const whereArray = obj.whereArray || []
-  let increment = 1
-  let arr = [],
-      wherequery = []
-  for (const key in where) {
-    wherequery.push(key.indexOf('.') > -1 ? ` ${key} = $${increment} ` : ` "${key}" = $${increment}`)
-    arr.push(where[key])
-    increment++
-  }
-  //console.log(whereArray);
-  let hasWhere = false
-  wherequery = arr.length ? wherequery.join(' AND ') : ''
+  let increment = startIncrement
+  const arr = []
+  const parts = []
+
+  if (where && typeof where === 'object' && !Array.isArray(where)) {
+    for (const key in where) {
+      increment = appendWhereEntry(parts, arr, increment, key, where[key])
+    }
+  }
+
+  const orParts = []
+  if (orWhere && typeof orWhere === 'object' && !Array.isArray(orWhere)) {
+    for (const key in orWhere) {
+      increment = appendWhereEntry(orParts, arr, increment, key, orWhere[key])
+    }
+  }
+  if (orParts.length) {
+    parts.push(`(${orParts.join(' OR ')})`)
+  }
+
+  let wherequery = parts.join(' AND ')
+  let hasWhere = parts.length > 0
+
   if (whereArray.length) {
     let andOr = wherequery ? ' AND ' : ''
-    whereArray.map((item, index) => {
-      let type = !item.type ? 'text' : item.type
+    whereArray.forEach((rawItem, index) => {
+      let item = rawItem
+      if (Array.isArray(item)) {
+        item = {
+          field: item[0],
+          option: item[1],
+          value: item[2],
+          operator: item[3] || 'AND',
+          type: item[4],
+        }
+      }
+      if (!item || typeof item !== 'object') return
+
+      const type = !item.type ? 'text' : item.type
       if (index > 0) {
         andOr = ''
       }
@@ -160,74 +464,100 @@ const whereFn = (obj) => {
       if (index == whereArray.length - 1) {
         operator = ''
       }
-      let fields = ''
+
+      const quotedField = item.field ? quoteIdent(item.field) : ''
+      let field = ''
       if (type == 'date') {
-        field = item.field.indexOf('.') > -1 ? item.field + '::text ' : ` ${item.field}::text `
+        field = quotedField ? `${quotedField}::text ` : ''
       } else {
-        field = item.field.indexOf('.') > -1 ? item.field : item.field ? ` "${item.field}" ` : ''
+        field = quotedField || ''
       }
-      // PostgreSQL: jsonb containment (@>) dengan parameter untuk keamanan
-      if (item.isJSON) {
-        wherequery += andOr + ` (${String(field).trim()})::jsonb @> $${increment}::jsonb ${operator}`
-        arr.push(JSON.stringify(item.value))
-        increment++
+
+      if (item.isJSON || type == 'json' || type == 'jsonb') {
+        if (quotedField) {
+          wherequery += andOr + ` (${quotedField})::jsonb @> $${increment}::jsonb ${operator}`
+          arr.push(typeof item.value === 'string' ? item.value : JSON.stringify(item.value))
+          increment++
+          hasWhere = true
+        }
+      } else if (type == 'inline') {
+        if (field) {
+          wherequery += andOr + ` ${field}  ${item.value} ${operator}`
+        } else {
+          wherequery += andOr + ` ${item.value} ${operator}`
+        }
         hasWhere = true
       } else {
-        if (type == 'json') {
-          wherequery += andOr + ` (${String(field).trim()})::jsonb @> $${increment}::jsonb ${operator}`
-          arr.push(JSON.stringify(item.value))
+        const rawOption = item.option == null ? '=' : String(item.option)
+        if (rawOption.includes('{{value}}')) {
+          const option = rawOption.replace('{{value}}', `$${increment}`)
+          wherequery += `${andOr} ${field} ${option} ${operator}`
           increment++
+          arr.push(item.value)
           hasWhere = true
-        } else if (type == 'inline') {
-          //select * from attendance where employee_id = 4803 and date IN ('2023-12-21','2023-12-22')
-          if (field) {
-            wherequery += andOr + ` ${field}  ${item.value} ${operator}`
-          } else {
-            wherequery += andOr + ` ${item.value} ${operator}`
-          }
+        } else if (rawOption.includes('$')) {
+          wherequery += `${andOr} ${field} ${rawOption} ${operator}`
+          increment++
+          arr.push(item.value)
           hasWhere = true
         } else {
-          if (item.option.includes('{{value}}')) {
-            item.option = item.option.replace('{{value}}', `$${increment}`)
-            wherequery += `${andOr} ${field} ${item.option} ${operator}`
-            increment++
-          } else if (item.option.includes('$')) {
-            wherequery += `${andOr} ${field} ${item.option} ${operator}`
-            increment++
+          const option = sanitizeWhereOption(rawOption) || '='
+          if (Array.isArray(item.value) && (option === '=' || option === 'IN' || option === 'NOT IN')) {
+            const listOp = option === 'NOT IN' ? 'NOT IN' : 'IN'
+            const list = item.value
+            if (!list.length) {
+              wherequery += `${andOr} ${listOp === 'NOT IN' ? 'TRUE' : 'FALSE'} ${operator}`
+            } else {
+              const placeholders = list.map((_, i) => `$${increment + i}`).join(', ')
+              wherequery += `${andOr} ${field} ${listOp} (${placeholders}) ${operator}`
+              arr.push(...list)
+              increment += list.length
+            }
+            hasWhere = true
+          } else if (option === 'BETWEEN' || option === 'NOT BETWEEN') {
+            const range = Array.isArray(item.value) ? item.value : parseRangeLiteral(item.value)
+            if (range && range.length >= 2) {
+              wherequery += `${andOr} ${field} ${option} $${increment} AND $${increment + 1} ${operator}`
+              arr.push(range[0], range[1])
+              increment += 2
+              hasWhere = true
+            }
+          } else if ((option === 'IS' || option === 'IS NOT') && (item.value == null || /^null$/i.test(String(item.value)))) {
+            wherequery += `${andOr} ${field} ${option} NULL ${operator}`
+            hasWhere = true
+          } else if (option === 'IS NULL' || option === 'IS NOT NULL') {
+            wherequery += `${andOr} ${field} ${option} ${operator}`
+            hasWhere = true
           } else {
-            wherequery += `${andOr} ${field} ${item.option} $${increment} ${operator}`
+            wherequery += `${andOr} ${field} ${option} $${increment} ${operator}`
             increment++
+            let itemValue = item.value
+            if (option === '=') {
+              itemValue = Util.replaceAll(itemValue + '', '%', '')
+            }
+            arr.push(itemValue)
+            hasWhere = true
           }
-          let itemValue = item.value
-          if (item.option == '=') {
-            itemValue = Util.replaceAll(itemValue + '', '%', '')
-          }
-          arr.push(itemValue)
         }
       }
     })
-    //console.log(arr)
   }
+
   if (arr.length > 0) {
     hasWhere = true
   }
-  let wheres = ''
-  if (hasWhere) {
-    wheres = `WHERE ${wherequery}`
-  }
 
-  let objAll = {
-    where: wheres,
-    arr: arr,
-    increment: increment,
+  return {
+    where: hasWhere && wherequery ? `WHERE ${wherequery}` : '',
+    arr,
+    increment,
   }
-  //console.log(obj)
-  return objAll
 }
 
-connection.results = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  const select = obj.select || '*'
+const buildSelectQuery = (obj) => {
+  const tableSql = obj.table ? quoteTableName(obj.table) : '""'
+  const select = formatSelect(obj.select)
+  const distinct = obj.distinct ? 'DISTINCT ' : ''
   const statement = obj.statement || ''
   const limitVal = toSafeNonNegativeInt(obj.limit, null)
   const offsetVal = obj.hasOwnProperty('offset') ? toSafeNonNegativeInt(obj.offset, 0) : (obj.limit ? 0 : null)
@@ -235,18 +565,18 @@ connection.results = async (obj) => {
   const offset = offsetVal !== null ? ` OFFSET ${offsetVal} ` : ''
   const orderBy = orderByFn(obj)
   const values = obj.values || []
-  const objJoin = obj.joins || []
-  let join = ''
-  if (objJoin.length) {
-    join = objJoin.join(' ')
-  }
+  const join = formatJoins(obj.joins || obj.join || [])
+  const groupBy = groupByFn(obj)
   const whereObj = whereFn(obj)
-  const wheres = whereObj.where
+  const havingObj = havingFn(obj, whereObj.increment, whereObj.arr)
   const arr = whereObj.arr
+  const sql = `SELECT ${distinct}${select} FROM ${tableSql} ${join} ${whereObj.where} ${groupBy} ${havingObj.sql} ${statement} ${orderBy} ${limit} ${offset}`.replace(/\s+/g, ' ').trim()
+  return { sql, arr, values }
+}
 
-  const sql = `SELECT ${select} FROM "${table}" ${join} ${wheres} ${statement} ${orderBy} ${limit} ${offset}`.replace(/\s+/g, ' ').trim()
+connection.results = async (obj) => {
+  const { sql, arr, values } = buildSelectQuery(obj)
   try {
-    const start = Date.now()
     const result = await pool.query(sql, arr.length ? arr : values.length ? values : null)
     return !result.rows ? [] : result.rows
   } catch (e) {
@@ -258,24 +588,8 @@ connection.results = async (obj) => {
 }
 
 connection.sql = async (obj) => {
-  const select = obj.select || '*'
-  const table = obj.table || ''
-  //[{field:"your_field",option:"=>",value:"12",operator:"AND",type:"text,json,date"}]
-  const statement = obj.statement || ''
-  const limit = obj.limit ? ` LIMIT ${obj.limit} ` : ''
-  const offset = obj.hasOwnProperty('offset') ? ` OFFSET ${obj.offset} ` : obj.limit ? 'OFFSET 0' : ''
-  const orderBy = orderByFn(obj)
-  const values = obj.values || []
-  const objJoin = obj.joins || []
-  let join = ''
-  if (objJoin.length) {
-    join = objJoin.join(' ')
-  }
-  const whereObj = whereFn(obj)
-  const wheres = whereObj.where
-  const arr = whereObj.arr
-  const sql = `SELECT ${select} FROM  "${table}" ${join} ${wheres} ${statement} ${orderBy} ${limit}  ${offset}`
-  return { sql: sql, arr: arr }
+  const { sql, arr } = buildSelectQuery(obj)
+  return { sql, arr }
 }
 
 connection.result = async (obj) => {
@@ -288,8 +602,8 @@ connection.result = async (obj) => {
 }
 
 connection.insert = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  if (!table) throw new Error('Table name is required for insert')
+  const tableSql = quoteTableName(obj.table || '')
+  if (!tableSql) throw new Error('Table name is required for insert')
   const data = { ...obj.data }
   const returning = sanitizeReturning(data.returning || 'RETURNING *')
   delete data.returning
@@ -307,7 +621,7 @@ connection.insert = async (obj) => {
     }
   }
   if (datas.length === 0) throw new Error('At least one valid column is required for insert')
-  const sql = `INSERT INTO "${table}" ("${datas.join('","')}") VALUES (${values.join(',')}) ${returning}`
+  const sql = `INSERT INTO ${tableSql} ("${datas.join('","')}") VALUES (${values.join(',')}) ${returning}`
 
   try {
     const results = await pool.query(sql, arr)
@@ -321,17 +635,14 @@ connection.insert = async (obj) => {
 }
 
 connection.update = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  if (!table) throw new Error('Table name is required for update')
+  const tableSql = quoteTableName(obj.table || '')
+  if (!tableSql) throw new Error('Table name is required for update')
   const data = { ...obj.data }
   const returning = sanitizeReturning(data.returning || 'RETURNING *')
   delete data.returning
 
-  const where = obj.where || {}
-  const whereArray = obj.whereArray || []
   const arr = []
   const dataArr = []
-  let wherequery = []
   let increment = 1
 
   for (const key in data) {
@@ -344,35 +655,10 @@ connection.update = async (obj) => {
   }
   if (dataArr.length === 0) throw new Error('At least one valid column is required for update')
 
-  for (const key in where) {
-    const col = sanitizeColumnName(key)
-    if (col) {
-      wherequery.push(`"${col}" = $${increment}`)
-      arr.push(where[key])
-      increment++
-    }
-  }
-  wherequery = wherequery.length ? wherequery.join(' AND ') : ''
-
-  if (whereArray.length) {
-    let andOr = wherequery ? ' AND ' : ''
-    whereArray.forEach((item, index) => {
-      if (index > 0) andOr = ''
-      const field = sanitizeWhereField(item.field)
-      const option = sanitizeWhereOption(item.option)
-      const connector = sanitizeWhereConnector(item.operator)
-      if (field && option) {
-        wherequery += `${andOr} ${field} ${option} $${increment} ${connector}`
-        arr.push(item.value)
-        increment++
-      }
-    })
-    if (wherequery.endsWith(' AND ')) wherequery = wherequery.slice(0, -5)
-    else if (wherequery.endsWith(' OR ')) wherequery = wherequery.slice(0, -4)
-  }
-
-  const wheres = wherequery ? ' WHERE ' + wherequery : ''
-  const sql = `UPDATE "${table}" SET ${dataArr.join(', ')}${wheres} ${returning}`
+  const whereObj = whereFn(obj, increment)
+  arr.push(...whereObj.arr)
+  const wheres = whereObj.where ? ` ${whereObj.where}` : ''
+  const sql = `UPDATE ${tableSql} SET ${dataArr.join(', ')}${wheres} ${returning}`
 
   try {
     const result = await pool.query(sql, arr)
@@ -386,33 +672,38 @@ connection.update = async (obj) => {
 }
 
 connection.delete = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  if (!table) throw new Error('Table name is required for delete')
-  const where = obj.where || {}
-  const arr = []
-  const wherequery = []
-  let increment = 1
-  for (const key in where) {
-    const col = sanitizeColumnName(key)
-    if (col) {
-      wherequery.push(`"${col}" = $${increment}`)
-      arr.push(where[key])
-      increment++
-    }
-  }
-  const whereClause = wherequery.length ? wherequery.join(' AND ') : ''
-  const wheres = whereClause ? ' WHERE ' + whereClause : ''
-  const sql = `DELETE FROM "${table}"${wheres} RETURNING *`
+  const tableSql = quoteTableName(obj.table || '')
+  if (!tableSql) throw new Error('Table name is required for delete')
+  const whereObj = whereFn(obj, 1)
+  const wheres = whereObj.where ? ` ${whereObj.where}` : ''
+  const sql = `DELETE FROM ${tableSql}${wheres} RETURNING *`
   try {
-    return await pool.query(sql, arr)
+    return await pool.query(sql, whereObj.arr)
   } catch (e) {
     console.log(sql)
-    console.log(arr)
+    console.log(whereObj.arr)
     console.log(e.toString())
     throw e
   }
 }
 
+connection.count = async (obj) => {
+  const countSelect = obj.select && /count\s*\(/i.test(String(obj.select))
+    ? obj.select
+    : `COUNT(${obj.countField ? (quoteIdent(obj.countField) || '*') : '*'}) AS count`
+  const row = await connection.result({
+    ...obj,
+    select: countSelect,
+    limit: undefined,
+    offset: undefined,
+    orderBy: undefined,
+    order_by: undefined,
+    distinct: undefined,
+  })
+  if (!row || Array.isArray(row)) return 0
+  return Number(row.count || 0)
+}
+
 connection.insertData = async(tableName, data) => {
   try {
     // Validasi input

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zet-lib",
-  "version": "6.0.2",
+  "version": "6.1.0",
   "description": "zet is a library that part of zet generator.",
   "engines": {
     "node": ">=18"