zet-lib 6.0.2 → 6.1.1

package/lib/connection.js

@@ -2,613 +2,680 @@ const { Pool } = require('./Pool')
 const config = require('dotenv').config()
 const Util = require('./Util')
 
-const configPG = {
+const pool = new Pool({
   user: process.env.PGUSER,
   host: process.env.PGHOST,
   database: process.env.PGDATABASE,
   password: process.env.PGPASSWORD,
   port: process.env.PGPORT,
-  max: 20, // set pool max size to 20
-  idleTimeoutMillis: 1000, // close idle clients after 1 second
-  connectionTimeoutMillis: 10000, // return an error after 10 second if connection could not be established
-  maxUses: 7500, // close (and replace) a connection after it has been used 7500 times (see below for discussion)
-  poolSize: 50, // Default is 10 connections
-}
-
-const pool = new Pool(configPG)
+  max: 20,
+  idleTimeoutMillis: 1000,
+  connectionTimeoutMillis: 10000,
+  maxUses: 7500,
+  poolSize: 50,
+})
 
 pool.on('error', (err) => {
   console.error('Unexpected error on idle client', err)
 })
 
-// Validasi identifier (nama tabel) untuk mencegah SQL injection
+const SAFE_IDENTIFIER_PART = /^[a-zA-Z_][a-zA-Z0-9_]*$/
 const SAFE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)?$/
-const sanitizeTableName = (table) => {
-  if (typeof table !== 'string' || !table.trim()) return ''
-  const t = table.trim()
-  if (!SAFE_IDENTIFIER.test(t)) {
-    throw new Error(`Invalid table name: ${t}`)
+const SAFE_CAST = /^[a-z][a-z0-9_]*(\(\d+\))?$/
+const SAFE_RETURNING = /^RETURNING \*$/i
+const SAFE_RETURNING_COLS = /^RETURNING ([a-zA-Z_][a-zA-Z0-9_]*)(,\s*[a-zA-Z_][a-zA-Z0-9_]*)*$/i
+const META_WHERE_KEYS = new Set(['type', 'cast'])
+const JOIN_TYPES = new Set(['LEFT', 'RIGHT', 'INNER', 'FULL', 'LEFT OUTER', 'RIGHT OUTER', 'FULL OUTER', 'CROSS'])
+const 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|@>)'
+const STRING_OPERATOR_RE = new RegExp(`^${OPERATOR_RE}\\s+([\\s\\S]+)$`, 'i')
+const KEY_OPERATOR_RE = new RegExp(`^(.+?)\\s+${OPERATOR_RE}$`, 'i')
+
+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 hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)
+const asArray = (val) => (Array.isArray(val) ? val : [])
+const isPlainObject = (val) => !!val && typeof val === 'object' && !Array.isArray(val)
+const rowsOf = (result) => (result && Array.isArray(result.rows) ? result.rows : [])
+
+const logQueryError = (sql, params, err) => {
+  console.error(sql)
+  if (params !== undefined) console.error(params)
+  console.error(err && err.toString ? err.toString() : err)
+}
+
+const runQuery = async (sql, params) => {
+  const values = Array.isArray(params) && params.length ? params : undefined
+  try {
+    return await pool.query(sql, values)
+  } catch (err) {
+    logQueryError(sql, params, err)
+    throw err
   }
-  return t
 }
 
-// Validasi limit/offset sebagai integer non-negatif
 const toSafeNonNegativeInt = (val, fallback) => {
-  if (val === undefined || val === null) return fallback
+  if (val === undefined || val === null || val === '') return fallback
   const n = parseInt(val, 10)
-  if (!Number.isInteger(n) || n < 0) return fallback
-  return n
+  return Number.isInteger(n) && n >= 0 ? n : fallback
 }
 
-// Validasi satu segmen ORDER BY (identifier + optional ASC/DESC) untuk mencegah SQL injection
-const SAFE_IDENTIFIER_PART = /^[a-zA-Z_][a-zA-Z0-9_]*$/
-const sanitizeOrderBySegment = (segment) => {
-  if (typeof segment !== 'string' || !segment.trim()) return ''
-  const parts = segment.trim().split(/\s+/)
-  const ident = parts[0]
-  const dir = parts[1] ? parts[1].toUpperCase() : ''
-  if (dir && dir !== 'ASC' && dir !== 'DESC') return ''
-  const identParts = ident.split('.')
-  const valid = identParts.length > 0 && identParts.every(p => SAFE_IDENTIFIER_PART.test(p))
-  if (!valid) return ''
-  const quotedIdent = identParts.map(p => `"${p}"`).join('.')
-  return dir ? `${quotedIdent} ${dir}` : quotedIdent
+const quoteIdent = (name) => {
+  if (name == null || typeof name !== 'string' || !name.trim()) return ''
+  const parts = name.trim().split('.')
+  if (!parts.length || !parts.every((part) => SAFE_IDENTIFIER_PART.test(part))) return ''
+  return parts.map((part) => `"${part}"`).join('.')
 }
 
-// Validasi nama kolom (identifier tunggal) untuk INSERT/UPDATE
-const sanitizeColumnName = (key) => SAFE_IDENTIFIER_PART.test(String(key).trim()) ? String(key).trim() : null
+const sanitizeTableName = (table) => {
+  if (typeof table !== 'string' || !table.trim()) return ''
+  const t = table.trim()
+  return SAFE_IDENTIFIER.test(t) ? t : ''
+}
+
+const quoteTableName = (table) => {
+  const t = sanitizeTableName(table)
+  return t ? t.split('.').map((part) => `"${part}"`).join('.') : ''
+}
+
+const requireTableName = (table, action) => {
+  if (typeof table === 'string' && table.trim() && !SAFE_IDENTIFIER.test(table.trim())) {
+    throw new Error(`Invalid table name: ${table.trim()}`)
+  }
+  const quoted = quoteTableName(table)
+  if (!quoted) throw new Error(`Table name is required${action ? ` for ${action}` : ''}`)
+  return quoted
+}
+
+const sanitizeColumnName = (key) => {
+  const col = String(key == null ? '' : key).trim()
+  return SAFE_IDENTIFIER_PART.test(col) ? col : null
+}
 
-// Validasi klausa RETURNING: hanya RETURNING * atau RETURNING col1, col2, ...
-const SAFE_RETURNING = /^RETURNING \*$/i
-const SAFE_RETURNING_COLS = /^RETURNING ([a-zA-Z_][a-zA-Z0-9_]*)(,\s*[a-zA-Z_][a-zA-Z0-9_]*)*$/i
 const sanitizeReturning = (clause) => {
   if (typeof clause !== 'string' || !clause.trim()) return 'RETURNING *'
   const s = clause.trim()
-  if (SAFE_RETURNING.test(s)) return s
-  if (SAFE_RETURNING_COLS.test(s)) return s
-  return 'RETURNING *'
+  return (SAFE_RETURNING.test(s) || SAFE_RETURNING_COLS.test(s)) ? s : 'RETURNING *'
 }
 
-// Validasi field di WHERE (identifier atau schema.table)
-const sanitizeWhereField = (field) => {
-  if (field == null || typeof field !== 'string' || !field.trim()) return ''
-  const identParts = String(field).trim().split('.')
-  const valid = identParts.length > 0 && identParts.every(p => SAFE_IDENTIFIER_PART.test(p))
-  if (!valid) return ''
-  return identParts.map(p => `"${p}"`).join('.')
+const normalizeOperator = (op) => {
+  if (op == null) return ''
+  const key = String(op).trim().replace(/_/g, ' ').replace(/\s+/g, ' ').toUpperCase()
+  return OPERATOR_NAME_MAP[key] || ''
 }
 
-// Whitelist operator perbandingan untuk WHERE
-const SAFE_WHERE_OPERATORS = new Set(['=', '!=', '<>', '<', '>', '<=', '>=', 'LIKE', 'ILIKE', 'IS NOT', 'IS'])
-const sanitizeWhereOption = (option) => {
-  if (option == null || typeof option !== 'string') return ''
-  const s = String(option).trim().toUpperCase()
-  return SAFE_WHERE_OPERATORS.has(s) ? s : ''
-}
+const sanitizeWhereOption = (option) => (typeof option === 'string' ? normalizeOperator(option) : '')
 
 const sanitizeWhereConnector = (op) => {
   if (op == null || typeof op !== 'string') return ' AND '
-  const s = String(op).trim().toUpperCase()
-  return (s === 'OR' ? ' OR ' : ' AND ')
+  return String(op).trim().toUpperCase() === 'OR' ? ' OR ' : ' AND '
 }
 
-const connection = {}
+const sanitizeOrderBySegment = (segment) => {
+  if (typeof segment !== 'string' || !segment.trim()) return ''
+  const parts = segment.trim().split(/\s+/)
+  const ident = quoteIdent(parts[0])
+  if (!ident) return ''
+  const dir = parts[1] ? parts[1].toUpperCase() : ''
+  if (dir && dir !== 'ASC' && dir !== 'DESC') return ''
+  return dir ? `${ident} ${dir}` : ident
+}
 
-connection.query = async (string, arr) => {
+const escapeLiteral = (value) => String(value == null ? '' : value).replace(/'/g, "''")
+
+const schemaSql = (table) => {
+  const t = sanitizeTableName(table)
+  if (!t) return ''
+  const name = t.includes('.') ? t.split('.').pop() : t
+  return `'${escapeLiteral(name)}'`
+}
+
+const safeJson = (value) => {
+  if (typeof value === 'string') return value
   try {
-    /*console.log(string);
-        console.log(JSON.stringify(arr))*/
-    const result = await pool.query(string, arr)
-    return result.rows
-  } catch (e) {
-    console.log(string)
-    console.log(e)
+    return JSON.stringify(value)
+  } catch (err) {
+    throw new Error('Invalid JSON value for query parameter')
   }
 }
 
-const orderByFn = (obj) => {
-  const objOrderby = !obj.orderBy ? [] : obj.orderBy
-  let orderBy = ''
-  if (objOrderby.length) {
-    orderBy = ` ORDER BY  `
-    for (var i = 0; i < objOrderby.length; i++) {
-      if (i % 2 == 0) {
-        orderBy += ` "${obj.orderBy[i]}" `
-      } else {
-        orderBy += ` ${obj.orderBy[i]} `
-        if (i == objOrderby.length - 1) {
-          orderBy += ` `
-        } else {
-          orderBy += `, `
-        }
-      }
+const stripQuotes = (value) => String(value == null ? '' : value).trim().replace(/^['"]|['"]$/g, '')
+
+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((item) => {
+    const t = stripQuotes(item)
+    return /^-?\d+(\.\d+)?$/.test(t) ? Number(t) : t
+  })
+}
+
+const parseRangeLiteral = (raw) => {
+  if (Array.isArray(raw)) return raw.slice(0, 2)
+  const s = String(raw == null ? '' : raw).trim()
+  if (!s) return []
+  const byAnd = s.split(/\s+AND\s+/i)
+  if (byAnd.length >= 2) return [stripQuotes(byAnd[0]), stripQuotes(byAnd.slice(1).join(' AND '))]
+  const byComma = s.split(',')
+  if (byComma.length >= 2) return [stripQuotes(byComma[0]), stripQuotes(byComma.slice(1).join(','))]
+  return []
+}
+
+const isOperatorMap = (value) => {
+  if (!isPlainObject(value) || value instanceof Date || value._isAMomentObject) return false
+  const keys = Object.keys(value)
+  return keys.length > 0 && keys.every((key) => !!normalizeOperator(key) || META_WHERE_KEYS.has(String(key).toLowerCase()))
+}
+
+const fieldSqlWithCast = (fieldSql, cast) => {
+  if (!cast) return fieldSql
+  const c = String(cast).trim().toLowerCase()
+  return SAFE_CAST.test(c) ? `${fieldSql}::${c}` : fieldSql
+}
+
+const pushWhereCondition = (parts, params, increment, fieldSql, operator, value) => {
+  const op = normalizeOperator(operator)
+  if (!fieldSql || !op || !Number.isInteger(increment) || increment < 1) 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 || /^null$/i.test(String(value))) {
+      parts.push(`${fieldSql} ${op} NULL`)
+      return increment
     }
+    parts.push(`${fieldSql} ${op} $${increment}`)
+    params.push(value)
+    return increment + 1
   }
-  if (obj.hasOwnProperty('order_by') && Array.isArray(obj.order_by) && obj.order_by.length) {
-    const segments = obj.order_by.map(sanitizeOrderBySegment).filter(Boolean)
-    if (segments.length) {
-      orderBy = ` ORDER BY ${segments.join(', ')} `
+
+  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
     }
+    parts.push(`${fieldSql} ${op} (${list.map((_, i) => `$${increment + i}`).join(', ')})`)
+    params.push(...list)
+    return increment + list.length
   }
 
-  return orderBy
+  if (op === 'BETWEEN' || op === 'NOT BETWEEN') {
+    const range = parseRangeLiteral(value)
+    if (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(safeJson(value))
+    return increment + 1
+  }
+
+  parts.push(`${fieldSql} ${op} $${increment}`)
+  params.push(value)
+  return increment + 1
 }
 
-const whereFn = (obj) => {
-  const where = obj.where || {}
-  //[{field:"your_field",option:"=>",value:"12",operator:"AND",type:"text,json,date, inline"}]
-  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++
+const appendWhereEntry = (parts, params, increment, key, value) => {
+  let fieldName = key
+  let keyOp = ''
+  const keyMatch = typeof key === 'string' ? KEY_OPERATOR_RE.exec(key.trim()) : null
+  if (keyMatch) {
+    fieldName = keyMatch[1]
+    keyOp = normalizeOperator(keyMatch[2])
   }
-  //console.log(whereArray);
-  let hasWhere = false
-  wherequery = arr.length ? wherequery.join(' AND ') : ''
-  if (whereArray.length) {
-    let andOr = wherequery ? ' AND ' : ''
-    whereArray.map((item, index) => {
-      let type = !item.type ? 'text' : item.type
-      if (index > 0) {
-        andOr = ''
-      }
-      let operator = !item.operator ? ' AND ' : item.operator
-      if (index == whereArray.length - 1) {
-        operator = ''
-      }
-      let fields = ''
-      if (type == 'date') {
-        field = item.field.indexOf('.') > -1 ? item.field + '::text ' : ` ${item.field}::text `
-      } else {
-        field = item.field.indexOf('.') > -1 ? item.field : item.field ? ` "${item.field}" ` : ''
-      }
-      // 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++
-        hasWhere = true
-      } else {
-        if (type == 'json') {
-          wherequery += andOr + ` (${String(field).trim()})::jsonb @> $${increment}::jsonb ${operator}`
-          arr.push(JSON.stringify(item.value))
-          increment++
-          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}`
-          }
-          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++
-          } else {
-            wherequery += `${andOr} ${field} ${item.option} $${increment} ${operator}`
-            increment++
-          }
-          let itemValue = item.value
-          if (item.option == '=') {
-            itemValue = Util.replaceAll(itemValue + '', '%', '')
-          }
-          arr.push(itemValue)
-        }
-      }
-    })
-    //console.log(arr)
+
+  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 (arr.length > 0) {
-    hasWhere = true
+
+  if (Array.isArray(value)) {
+    if (value.length && typeof value[0] === 'string' && normalizeOperator(value[0])) {
+      const op = normalizeOperator(value[0])
+      const rest = value.slice(1)
+      const first = rest.length === 1 ? rest[0] : rest
+      if (op === 'IN' || op === 'NOT IN' || op === 'BETWEEN' || op === 'NOT BETWEEN') {
+        return pushWhereCondition(parts, params, increment, fieldSql, op, first)
+      }
+      return pushWhereCondition(parts, params, increment, fieldSql, op, rest[0])
+    }
+    return pushWhereCondition(parts, params, increment, fieldSql, 'IN', value)
   }
-  let wheres = ''
-  if (hasWhere) {
-    wheres = `WHERE ${wherequery}`
+
+  if (isOperatorMap(value)) {
+    const castRaw = value.cast || value.type
+    const sqlField = fieldSqlWithCast(fieldSql, String(castRaw || '').toLowerCase() === 'date' ? 'date' : castRaw)
+    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
   }
 
-  let objAll = {
-    where: wheres,
-    arr: arr,
-    increment: 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)
+    }
   }
-  //console.log(obj)
-  return objAll
+
+  return pushWhereCondition(parts, params, increment, fieldSql, '=', value)
 }
 
-connection.results = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  const select = obj.select || '*'
-  const statement = obj.statement || ''
-  const limitVal = toSafeNonNegativeInt(obj.limit, null)
-  const offsetVal = obj.hasOwnProperty('offset') ? toSafeNonNegativeInt(obj.offset, 0) : (obj.limit ? 0 : null)
-  const limit = limitVal !== null ? ` LIMIT ${limitVal} ` : ''
-  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 appendWhereObject = (target, params, increment, source) => {
+  if (!isPlainObject(source)) return increment
+  for (const key of Object.keys(source)) {
+    increment = appendWhereEntry(target, params, increment, key, source[key])
   }
-  const whereObj = whereFn(obj)
-  const wheres = whereObj.where
-  const arr = whereObj.arr
+  return increment
+}
 
-  const sql = `SELECT ${select} FROM "${table}" ${join} ${wheres} ${statement} ${orderBy} ${limit} ${offset}`.replace(/\s+/g, ' ').trim()
-  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) {
-    console.log(sql)
-    console.log(arr)
-    console.log(e.toString())
-    throw e
+const normalizeWhereArrayItem = (raw) => {
+  if (Array.isArray(raw)) {
+    return { field: raw[0], option: raw[1], value: raw[2], operator: raw[3] || 'AND', type: raw[4] }
   }
+  return isPlainObject(raw) ? raw : null
 }
 
-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 applyWhereArrayItem = (parts, params, increment, item) => {
+  const type = item.type || 'text'
+  const fieldSql = item.field ? quoteIdent(item.field) : ''
+  const field = type === 'date' && fieldSql ? `${fieldSql}::text` : fieldSql
+
+  if (item.isJSON || type === 'json' || type === 'jsonb') {
+    if (!fieldSql) return increment
+    parts.push(`${fieldSql}::jsonb @> $${increment}::jsonb`)
+    params.push(typeof item.value === 'string' ? item.value : safeJson(item.value))
+    return increment + 1
   }
-  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 }
-}
 
-connection.result = async (obj) => {
-  const results = await connection.results(obj)
-  if (results.length) {
-    return results[0]
-  } else {
-    return []
+  if (type === 'inline') {
+    if (item.value == null) return increment
+    parts.push(field ? `${field} ${item.value}` : String(item.value))
+    return increment
   }
-}
 
-connection.insert = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  if (!table) throw new Error('Table name is required for insert')
-  const data = { ...obj.data }
-  const returning = sanitizeReturning(data.returning || 'RETURNING *')
-  delete data.returning
-  let increment = 1
-  const datas = []
-  const values = []
-  const arr = []
-  for (const key in data) {
-    const col = sanitizeColumnName(key)
-    if (col) {
-      datas.push(col)
-      values.push(`$${increment}`)
-      arr.push(data[key])
-      increment++
-    }
+  const rawOption = item.option == null ? '=' : String(item.option)
+  if (rawOption.includes('{{value}}')) {
+    parts.push(`${field} ${rawOption.replace('{{value}}', `$${increment}`)}`.trim())
+    params.push(item.value)
+    return increment + 1
+  }
+  if (rawOption.includes('$')) {
+    parts.push(`${field} ${rawOption}`.trim())
+    params.push(item.value)
+    return increment + 1
   }
-  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}`
 
-  try {
-    const results = await pool.query(sql, arr)
-    return results.rows[0]
-  } catch (e) {
-    console.log(sql)
-    console.log(arr)
-    console.log(e.toString())
-    throw e
+  const option = sanitizeWhereOption(rawOption) || '='
+  if (Array.isArray(item.value) && (option === '=' || option === 'IN' || option === 'NOT IN')) {
+    return pushWhereCondition(parts, params, increment, field, option === 'NOT IN' ? 'NOT IN' : 'IN', item.value)
+  }
+  if (option === '=' && item.value != null && typeof item.value !== 'object') {
+    const cleaned = Util && typeof Util.replaceAll === 'function'
+      ? Util.replaceAll(String(item.value), '%', '')
+      : String(item.value).split('%').join('')
+    return pushWhereCondition(parts, params, increment, field, option, cleaned)
   }
+  return pushWhereCondition(parts, params, increment, field, option, item.value)
 }
 
-connection.update = async (obj) => {
-  const table = sanitizeTableName(obj.table || '')
-  if (!table) 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
+const whereFn = (obj, startIncrement = 1) => {
+  const incrementStart = Number.isInteger(startIncrement) && startIncrement > 0 ? startIncrement : 1
+  const params = []
+  const parts = []
+  let increment = incrementStart
+
+  increment = appendWhereObject(parts, params, increment, obj && obj.where)
+
+  const orParts = []
+  increment = appendWhereObject(orParts, params, increment, obj && (obj.orWhere || obj.or_where))
+  if (orParts.length) parts.push(`(${orParts.join(' OR ')})`)
+
+  const arrayParts = []
+  const connectors = []
+  asArray(obj && obj.whereArray).forEach((raw) => {
+    const item = normalizeWhereArrayItem(raw)
+    if (!item) return
+    const itemParts = []
+    increment = applyWhereArrayItem(itemParts, params, increment, item)
+    if (!itemParts.length) return
+    arrayParts.push(itemParts.join(' AND '))
+    connectors.push(sanitizeWhereConnector(item.operator))
+  })
+
+  let sql = parts.join(' AND ')
+  if (arrayParts.length) {
+    const arraySql = arrayParts.reduce((acc, part, index) => (
+      index === 0 ? part : `${acc}${connectors[index - 1]}${part}`
+    ), '')
+    sql = sql ? `${sql} AND ${arraySql}` : arraySql
+  }
 
-  for (const key in data) {
-    const col = sanitizeColumnName(key)
-    if (col) {
-      dataArr.push(`"${col}" = $${increment}`)
-      arr.push(data[key])
-      increment++
-    }
+  return {
+    where: sql ? `WHERE ${sql}` : '',
+    arr: params,
+    increment,
   }
-  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++
-    }
+const formatSelect = (select) => {
+  if (Array.isArray(select)) {
+    const cols = select
+      .filter((item) => typeof item === 'string' && item.trim())
+      .map((item) => quoteIdent(item.trim()) || item.trim())
+    return cols.length ? cols.join(', ') : '*'
   }
-  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++
-      }
+  return typeof select === 'string' && select.trim() ? select : '*'
+}
+
+const formatJoins = (joins) => asArray(joins).map((item) => {
+  if (typeof item === 'string') return item.trim()
+  if (!isPlainObject(item)) return ''
+  const type = String(item.type || 'LEFT').trim().toUpperCase()
+  if (!JOIN_TYPES.has(type)) return ''
+  const table = quoteTableName(item.table || '')
+  if (!table) return ''
+  const alias = item.as ? ` ${quoteIdent(item.as) || ''}`.trimEnd() : ''
+  if (type === 'CROSS') return `CROSS JOIN ${table}${alias}`
+  const on = String(item.on || '').trim()
+  return on ? `${type} JOIN ${table}${alias} ON ${on}` : ''
+}).filter(Boolean).join(' ')
+
+const groupByFn = (obj) => {
+  const value = obj && (obj.groupBy || obj.group_by)
+  if (!value) return ''
+  const cols = (Array.isArray(value) ? value : String(value).split(','))
+    .map((item) => {
+      const trimmed = String(item || '').trim()
+      return quoteIdent(trimmed) || sanitizeOrderBySegment(trimmed)
     })
-    if (wherequery.endsWith(' AND ')) wherequery = wherequery.slice(0, -5)
-    else if (wherequery.endsWith(' OR ')) wherequery = wherequery.slice(0, -4)
-  }
+    .filter(Boolean)
+  return cols.length ? ` GROUP BY ${cols.join(', ')}` : ''
+}
 
-  const wheres = wherequery ? ' WHERE ' + wherequery : ''
-  const sql = `UPDATE "${table}" SET ${dataArr.join(', ')}${wheres} ${returning}`
+const havingFn = (obj, increment, params) => {
+  const parts = []
+  const next = appendWhereObject(parts, params, increment, obj && obj.having)
+  return { sql: parts.length ? ` HAVING ${parts.join(' AND ')}` : '', increment: next }
+}
 
-  try {
-    const result = await pool.query(sql, arr)
-    return result.rows[0]
-  } catch (e) {
-    console.log(sql)
-    console.log(arr)
-    console.log(e.toString())
-    throw e
+const orderByFn = (obj) => {
+  if (!isPlainObject(obj)) return ''
+
+  if (hasOwn(obj, 'order_by') && Array.isArray(obj.order_by) && obj.order_by.length) {
+    const segments = obj.order_by.map(sanitizeOrderBySegment).filter(Boolean)
+    return segments.length ? ` ORDER BY ${segments.join(', ')}` : ''
   }
-}
 
-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 pairs = asArray(obj.orderBy)
+  const segments = []
+  for (let i = 0; i < pairs.length; i += 2) {
+    const col = sanitizeOrderBySegment(String(pairs[i] == null ? '' : pairs[i]))
+    if (!col) continue
+    const dir = pairs[i + 1] != null ? String(pairs[i + 1]).trim().toUpperCase() : ''
+    segments.push(dir === 'ASC' || dir === 'DESC' ? (col.includes(' ') ? col : `${col} ${dir}`) : col)
   }
-  const whereClause = wherequery.length ? wherequery.join(' AND ') : ''
-  const wheres = whereClause ? ' WHERE ' + whereClause : ''
-  const sql = `DELETE FROM "${table}"${wheres} RETURNING *`
-  try {
-    return await pool.query(sql, arr)
-  } catch (e) {
-    console.log(sql)
-    console.log(arr)
-    console.log(e.toString())
-    throw e
+  return segments.length ? ` ORDER BY ${segments.join(', ')}` : ''
+}
+
+const buildSelectQuery = (obj) => {
+  if (!isPlainObject(obj)) throw new Error('Query options must be an object')
+  const tableSql = requireTableName(obj.table, 'select')
+  const whereObj = whereFn(obj)
+  const havingObj = havingFn(obj, whereObj.increment, whereObj.arr)
+  const limitVal = toSafeNonNegativeInt(obj.limit, null)
+  const offsetVal = hasOwn(obj, 'offset') ? toSafeNonNegativeInt(obj.offset, 0) : (obj.limit ? 0 : null)
+  const sql = [
+    `SELECT ${obj.distinct ? 'DISTINCT ' : ''}${formatSelect(obj.select)}`,
+    `FROM ${tableSql}`,
+    formatJoins(obj.joins || obj.join),
+    whereObj.where,
+    groupByFn(obj),
+    havingObj.sql,
+    obj.statement || '',
+    orderByFn(obj),
+    limitVal !== null ? `LIMIT ${limitVal}` : '',
+    offsetVal !== null ? `OFFSET ${offsetVal}` : '',
+  ].filter(Boolean).join(' ').replace(/\s+/g, ' ').trim()
+
+  return {
+    sql,
+    arr: whereObj.arr,
+    values: asArray(obj.values),
   }
 }
 
-connection.insertData = async(tableName, data) => {
-  try {
-    // Validasi input
-    if (!data || typeof data !== 'object') {
-      throw new Error('Invalid data provided for insert');
-    }
+const requireDataObject = (data, action) => {
+  if (!isPlainObject(data)) throw new Error(`Data object is required for ${action}`)
+  return { ...data }
+}
 
-    const columns = Object.keys(data);
-    if (columns.length === 0) {
-      throw new Error('No columns found in the data object');
-    }
+const collectColumns = (data) => {
+  const cols = []
+  const values = []
+  Object.keys(data).forEach((key) => {
+    const col = sanitizeColumnName(key)
+    if (!col) return
+    cols.push(col)
+    values.push(data[key])
+  })
+  if (!cols.length) throw new Error('At least one valid column is required')
+  return { cols, values }
+}
+
+const connection = {}
 
-    const placeholders = columns.map((_, index) => `$${index + 1}`).join(',');
-    const insertQuery = `
-            INSERT INTO "${tableName}" (${columns.map(col => `"${col}"`).join(',')})
-            VALUES (${placeholders})
-            RETURNING *
-        `;
-    const values = columns.map(col => data[col]);
-    const result = await pool.query(insertQuery, values);
-    console.log(`Successfully inserted 1 record into ${tableName}`);
-    return result.rows[0];
-  } catch (error) {
-    console.error(`Error inserting record into ${tableName}:`, error);
-    throw error;
-  } finally {
+connection.query = async (string, arr) => {
+  try {
+    if (typeof string !== 'string' || !string.trim()) return []
+    const result = await pool.query(string, Array.isArray(arr) && arr.length ? arr : undefined)
+    return rowsOf(result)
+  } catch (err) {
+    logQueryError(string, arr, err)
+    return []
   }
 }
 
-connection.deleteData = async(tableName, where) => {
+connection.results = async (obj) => {
+  const { sql, arr, values } = buildSelectQuery(obj)
+  const result = await runQuery(sql, arr.length ? arr : values)
+  return rowsOf(result)
+}
+
+connection.sql = async (obj) => {
   try {
-    // Validasi input
-    if (!where || typeof where !== 'object') {
-      throw new Error('Invalid where clause provided for delete');
-    }
+    const built = buildSelectQuery(obj)
+    return { sql: built.sql, arr: built.arr }
+  } catch (err) {
+    return { sql: '', arr: [], error: err.message }
+  }
+}
 
-    const whereColumns = Object.keys(where);
-    if (whereColumns.length === 0) {
-      throw new Error('No where conditions provided for delete');
-    }
+connection.result = async (obj) => {
+  const results = await connection.results(obj)
+  return Array.isArray(results) && results.length ? results[0] : []
+}
 
-    const whereConditions = whereColumns.map((col, index) => `"${col}" = $${index + 1}`).join(' AND ');
-    const deleteQuery = `
-            DELETE FROM "${tableName}"
-            WHERE ${whereConditions}
-            RETURNING *
-        `;
-    const values = whereColumns.map(col => where[col]);
-    const result = await pool.query(deleteQuery, values);
-    console.log(`Successfully deleted ${result.rowCount} records from ${tableName}`);
-    return result.rowCount;
-  } catch (error) {
-    console.error(`Error deleting records from ${tableName}:`, error);
-    throw error;
-  } finally {
-  }
+connection.insert = async (obj) => {
+  if (!isPlainObject(obj)) throw new Error('Insert options must be an object')
+  const tableSql = requireTableName(obj.table, 'insert')
+  const data = requireDataObject(obj.data, 'insert')
+  const returning = sanitizeReturning(data.returning || 'RETURNING *')
+  delete data.returning
+  const { cols, values } = collectColumns(data)
+  const placeholders = cols.map((_, i) => `$${i + 1}`)
+  const sql = `INSERT INTO ${tableSql} ("${cols.join('","')}") VALUES (${placeholders.join(',')}) ${returning}`
+  return rowsOf(await runQuery(sql, values))[0]
 }
 
-connection.insertMultipleRecords = async(tableName,records) => {
-  try {
-    // Validasi input
-    if (!records || !Array.isArray(records) || records.length === 0) {
-      console.warn(`No records to insert into ${tableName}`);
-      return [];
-    }
+connection.update = async (obj) => {
+  if (!isPlainObject(obj)) throw new Error('Update options must be an object')
+  const tableSql = requireTableName(obj.table, 'update')
+  const data = requireDataObject(obj.data, 'update')
+  const returning = sanitizeReturning(data.returning || 'RETURNING *')
+  delete data.returning
+  const { cols, values } = collectColumns(data)
+  const setSql = cols.map((col, i) => `"${col}" = $${i + 1}`).join(', ')
+  const whereObj = whereFn(obj, cols.length + 1)
+  const sql = `UPDATE ${tableSql} SET ${setSql}${whereObj.where ? ` ${whereObj.where}` : ''} ${returning}`
+  return rowsOf(await runQuery(sql, values.concat(whereObj.arr)))[0]
+}
 
-    // Validasi bahwa semua records memiliki struktur yang sama
-    const firstRecord = records[0];
-    if (!firstRecord || typeof firstRecord !== 'object') {
-      throw new Error('First record is invalid or empty');
-    }
+connection.delete = async (obj) => {
+  if (!isPlainObject(obj)) throw new Error('Delete options must be an object')
+  const tableSql = requireTableName(obj.table, 'delete')
+  const whereObj = whereFn(obj, 1)
+  const sql = `DELETE FROM ${tableSql}${whereObj.where ? ` ${whereObj.where}` : ''} RETURNING *`
+  return runQuery(sql, whereObj.arr)
+}
 
-    const columns = Object.keys(firstRecord);
-    if (columns.length === 0) {
-      throw new Error('No columns found in the first record');
-    }
+connection.count = async (obj) => {
+  if (!isPlainObject(obj)) throw new Error('Count options must be an object')
+  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
+  const n = Number(row.count)
+  return Number.isFinite(n) ? n : 0
+}
 
-    // Validasi bahwa semua records memiliki kolom yang sama
-    for (let i = 1; i < records.length; i++) {
-      const record = records[i];
-      if (!record || typeof record !== 'object') {
-        throw new Error(`Record at index ${i} is invalid`);
-      }
-      const recordColumns = Object.keys(record);
-      if (recordColumns.length !== columns.length || !recordColumns.every(col => columns.includes(col))) {
-        throw new Error(`Record at index ${i} has different structure than the first record`);
-      }
-    }
+connection.insertData = async (tableName, data) => connection.insert({ table: tableName, data })
 
-    const placeholders = records.map((_, rowIndex) =>
-        `(${columns.map((_, colIndex) => `$${rowIndex * columns.length + colIndex + 1}`).join(',')})`
-    ).join(',');
-
-    // Create the INSERT query
-    const insertQuery = `
-            INSERT INTO "${tableName}" (${columns.map(col => `"${col}"`).join(',')})
-            VALUES ${placeholders}
-            RETURNING *
-        `;
-    const values = records.flatMap(record => columns.map(col => record[col]));
-    const result = await pool.query(insertQuery, values);
-    console.log(`Successfully inserted ${records.length} records into ${tableName}`);
-    return result.rows;
-  } catch (error) {
-    console.error(`Error inserting multiple records into ${tableName}:`, error);
-    throw error;
-  } finally {
+connection.deleteData = async (tableName, where) => {
+  if (!isPlainObject(where) || !Object.keys(where).length) {
+    throw new Error('Invalid where clause provided for delete')
   }
+  const result = await connection.delete({ table: tableName, where })
+  return result && Number.isInteger(result.rowCount) ? result.rowCount : 0
 }
 
-connection.driver = config.driver
-connection.showTables = "SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema'"
-connection.showFullFields = (tableRelations) => {
-  return `SELECT 
-                 column_name AS "Field",  concat(data_type,'(',character_maximum_length,')') AS "Type" , is_nullable AS "Null"
-                FROM
-                 information_schema.COLUMNS
-                WHERE
-                 TABLE_NAME = '${tableRelations}';`
+connection.insertMultipleRecords = async (tableName, records) => {
+  const tableSql = requireTableName(tableName, 'insert')
+  const rows = asArray(records)
+  if (!rows.length) return []
+  if (!isPlainObject(rows[0])) throw new Error('First record is invalid or empty')
+
+  const rawCols = Object.keys(rows[0])
+  const cols = rawCols.map(sanitizeColumnName)
+  if (!cols.length || cols.some((col) => !col)) throw new Error('No valid columns found in the first record')
+
+  rows.forEach((record, index) => {
+    if (!isPlainObject(record)) throw new Error(`Record at index ${index} is invalid`)
+    const recordCols = Object.keys(record)
+    if (recordCols.length !== rawCols.length || !recordCols.every((col) => rawCols.includes(col))) {
+      throw new Error(`Record at index ${index} has different structure than the first record`)
+    }
+  })
+
+  const placeholders = rows.map((_, rowIndex) =>
+    `(${cols.map((_, colIndex) => `$${rowIndex * cols.length + colIndex + 1}`).join(',')})`
+  ).join(',')
+  const values = rows.flatMap((record) => cols.map((col) => record[col]))
+  const sql = `INSERT INTO ${tableSql} ("${cols.join('","')}") VALUES ${placeholders} RETURNING *`
+  return rowsOf(await runQuery(sql, values))
 }
 
-connection.describeTable = (table) => {
-  return connection.showFullFields(table)
+connection.driver = (config && config.parsed && config.parsed.DRIVER) || 'pg'
+connection.showTables = "SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema'"
+
+connection.showFullFields = (table) => {
+  const name = schemaSql(table)
+  if (!name) return ''
+  return `SELECT column_name AS "Field", concat(data_type,'(',character_maximum_length,')') AS "Type", is_nullable AS "Null"
+                FROM information_schema.COLUMNS
+                WHERE TABLE_NAME = ${name};`
 }
 
+connection.describeTable = (table) => connection.showFullFields(table)
+
 connection.showComments = (table) => {
-  return ` SELECT c.table_schema,c.table_name,c.column_name as "COLUMN_NAME",pgd.description as "COLUMN_COMMENT"
+  const name = schemaSql(table)
+  if (!name) return ''
+  return `SELECT c.table_schema,c.table_name,c.column_name as "COLUMN_NAME",pgd.description as "COLUMN_COMMENT"
                 FROM pg_catalog.pg_statio_all_tables as st
                   inner join pg_catalog.pg_description pgd on (pgd.objoid=st.relid)
                   inner join information_schema.columns c on (pgd.objsubid=c.ordinal_position
                     and  c.table_schema=st.schemaname and c.table_name=st.relname)
-                WHERE c.table_name = '${table}' ORDER BY c.column_name`
+                WHERE c.table_name = ${name} ORDER BY c.column_name`
 }
 
 connection.showFields = (table) => {
-  return `
-        SELECT
-            tc.table_name AS "TABLE_NAME", 
-            kcu.column_name AS "COLUMN_NAME", 
-            tc.constraint_name AS "CONSTRAINT_NAME", 
-            ccu.table_name AS "REFERENCED_TABLE_NAME",
-            ccu.column_name AS "REFERENCED_COLUMN_NAME",
-            tc.table_schema
-        FROM 
-            information_schema.table_constraints AS tc 
+  const name = schemaSql(table)
+  if (!name) return ''
+  return `SELECT tc.table_name AS "TABLE_NAME", kcu.column_name AS "COLUMN_NAME", tc.constraint_name AS "CONSTRAINT_NAME",
+            ccu.table_name AS "REFERENCED_TABLE_NAME", ccu.column_name AS "REFERENCED_COLUMN_NAME", tc.table_schema
+        FROM information_schema.table_constraints AS tc
             JOIN information_schema.key_column_usage AS kcu
-              ON tc.constraint_name = kcu.constraint_name
-              AND tc.table_schema = kcu.table_schema
+              ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
             JOIN information_schema.constraint_column_usage AS ccu
-              ON ccu.constraint_name = tc.constraint_name
-              AND ccu.table_schema = tc.table_schema
-        WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${table}';`
+              ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name=${name};`
 }
 
-//list constraint list
 connection.constraintList = (table, schema = 'public') => {
-  return `
-	SELECT con.*
+  const name = schemaSql(table)
+  const schemaName = sanitizeTableName(schema)
+  if (!name || !schemaName) return ''
+  return `SELECT con.*
        FROM pg_catalog.pg_constraint con
-            INNER JOIN pg_catalog.pg_class rel
-                       ON rel.oid = con.conrelid
-            INNER JOIN pg_catalog.pg_namespace nsp
-                       ON nsp.oid = connamespace
-       WHERE nsp.nspname = '${schema}' AND rel.relname = '${table}'; `
+            INNER JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
+            INNER JOIN pg_catalog.pg_namespace nsp ON nsp.oid = connamespace
+       WHERE nsp.nspname = '${escapeLiteral(schemaName)}' AND rel.relname = ${name};`
 }
 
-//find foreign key
 connection.foreignKeyList = (table) => {
-  return `SELECT
-    tc.table_schema, 
-    tc.constraint_name, 
-    tc.table_name, 
-    kcu.column_name, 
-    ccu.table_schema AS foreign_table_schema,
-    ccu.table_name AS foreign_table_name,
-    ccu.column_name AS foreign_column_name 
-FROM information_schema.table_constraints AS tc 
+  const name = schemaSql(table)
+  if (!name) return ''
+  return `SELECT tc.table_schema, tc.constraint_name, tc.table_name, kcu.column_name,
+    ccu.table_schema AS foreign_table_schema, ccu.table_name AS foreign_table_name, ccu.column_name AS foreign_column_name
+FROM information_schema.table_constraints AS tc
 JOIN information_schema.key_column_usage AS kcu
-    ON tc.constraint_name = kcu.constraint_name
-    AND tc.table_schema = kcu.table_schema
+    ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
 JOIN information_schema.constraint_column_usage AS ccu
     ON ccu.constraint_name = tc.constraint_name
-WHERE tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_name='${table}';`
-}
-
-var toNumber = function (num) {
-  num = num + ''
-  var t = replaceAll(num, '.', '')
-  if (t) {
-    return parseFloat(t)
-  } else return 0
-}
-
-function replaceAll(str, find, replace) {
-  return str.replace(new RegExp(find, 'g'), replace)
+WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name=${name};`
 }
 
 module.exports = connection