zet-lib 6.1.0 → 6.1.1

package/lib/connection.js

@@ -2,127 +2,116 @@ 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 : ''
+}
 
-// 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 *'
+const quoteTableName = (table) => {
+  const t = sanitizeTableName(table)
+  return t ? t.split('.').map((part) => `"${part}"`).join('.') : ''
 }
 
-// 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 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
 }
 
-// Whitelist operator perbandingan untuk WHERE
-const SAFE_WHERE_OPERATORS = new Set([
-  '=', '!=', '<>', '<', '>', '<=', '>=',
-  'LIKE', 'ILIKE', 'NOT LIKE', 'NOT ILIKE',
-  'IS NOT', 'IS', 'IN', 'NOT IN',
-  'BETWEEN', 'NOT BETWEEN', '@>',
-])
+const sanitizeColumnName = (key) => {
+  const col = String(key == null ? '' : key).trim()
+  return SAFE_IDENTIFIER_PART.test(col) ? col : null
+}
 
-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 sanitizeReturning = (clause) => {
+  if (typeof clause !== 'string' || !clause.trim()) return 'RETURNING *'
+  const s = clause.trim()
+  return (SAFE_RETURNING.test(s) || SAFE_RETURNING_COLS.test(s)) ? s : 'RETURNING *'
 }
 
 const normalizeOperator = (op) => {
@@ -131,79 +120,79 @@ const normalizeOperator = (op) => {
   return OPERATOR_NAME_MAP[key] || ''
 }
 
-const sanitizeWhereOption = (option) => {
-  if (option == null || typeof option !== 'string') return ''
-  const s = String(option).trim().toUpperCase().replace(/\s+/g, ' ')
-  return SAFE_WHERE_OPERATORS.has(s) ? s : (normalizeOperator(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 quoteIdent = (name) => sanitizeWhereField(name)
+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
+}
 
-const quoteTableName = (table) => {
-  const t = sanitizeTableName(table || '')
+const escapeLiteral = (value) => String(value == null ? '' : value).replace(/'/g, "''")
+
+const schemaSql = (table) => {
+  const t = sanitizeTableName(table)
   if (!t) return ''
-  return t.split('.').map((p) => `"${p}"`).join('.')
+  const name = t.includes('.') ? t.split('.').pop() : t
+  return `'${escapeLiteral(name)}'`
 }
 
-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 safeJson = (value) => {
+  if (typeof value === 'string') return value
+  try {
+    return JSON.stringify(value)
+  } catch (err) {
+    throw new Error('Invalid JSON value for query parameter')
+  }
+}
+
+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((v) => {
-    const t = v.trim().replace(/^['"]|['"]$/g, '')
+  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
+  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 [
-      byAnd[0].trim().replace(/^['"]|['"]$/g, ''),
-      byAnd.slice(1).join(' AND ').trim().replace(/^['"]|['"]$/g, ''),
-    ]
-  }
+  if (byAnd.length >= 2) return [stripQuotes(byAnd[0]), stripQuotes(byAnd.slice(1).join(' AND '))]
   const byComma = s.split(',')
-  if (byComma.length >= 2) {
-    return [
-      byComma[0].trim().replace(/^['"]|['"]$/g, ''),
-      byComma.slice(1).join(',').trim().replace(/^['"]|['"]$/g, ''),
-    ]
-  }
-  return [s, s]
+  if (byComma.length >= 2) return [stripQuotes(byComma[0]), stripQuotes(byComma.slice(1).join(','))]
+  return []
 }
 
 const isOperatorMap = (value) => {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
-  if (value instanceof Date) return false
-  if (value._isAMomentObject) return false
+  if (!isPlainObject(value) || value instanceof Date || 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()))
+  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()
-  if (!/^[a-z][a-z0-9_]*(\(\d+\))?$/.test(c)) return fieldSql
-  return `${fieldSql}::${c}`
+  return SAFE_CAST.test(c) ? `${fieldSql}::${c}` : fieldSql
 }
 
 const pushWhereCondition = (parts, params, increment, fieldSql, operator, value) => {
   const op = normalizeOperator(operator)
-  if (!fieldSql || !op) return increment
+  if (!fieldSql || !op || !Number.isInteger(increment) || increment < 1) return increment
 
   if (op === 'IS NULL' || op === 'IS NOT NULL') {
     parts.push(`${fieldSql} ${op}`)
@@ -211,7 +200,7 @@ const pushWhereCondition = (parts, params, increment, fieldSql, operator, value)
   }
 
   if (op === 'IS' || op === 'IS NOT') {
-    if (value === null || value === undefined || /^null$/i.test(String(value))) {
+    if (value == null || /^null$/i.test(String(value))) {
       parts.push(`${fieldSql} ${op} NULL`)
       return increment
     }
@@ -226,15 +215,14 @@ const pushWhereCondition = (parts, params, increment, fieldSql, operator, value)
       parts.push(op === 'IN' ? 'FALSE' : 'TRUE')
       return increment
     }
-    const placeholders = list.map((_, i) => `$${increment + i}`).join(', ')
-    parts.push(`${fieldSql} ${op} (${placeholders})`)
+    parts.push(`${fieldSql} ${op} (${list.map((_, i) => `$${increment + i}`).join(', ')})`)
     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
+    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
@@ -242,7 +230,7 @@ const pushWhereCondition = (parts, params, increment, fieldSql, operator, value)
 
   if (op === '@>') {
     parts.push(`${fieldSql}::jsonb @> $${increment}::jsonb`)
-    params.push(typeof value === 'string' ? value : JSON.stringify(value))
+    params.push(safeJson(value))
     return increment + 1
   }
 
@@ -254,7 +242,7 @@ const pushWhereCondition = (parts, params, increment, fieldSql, operator, value)
 const appendWhereEntry = (parts, params, increment, key, value) => {
   let fieldName = key
   let keyOp = ''
-  const keyMatch = KEY_OPERATOR_RE.exec(String(key).trim())
+  const keyMatch = typeof key === 'string' ? KEY_OPERATOR_RE.exec(key.trim()) : null
   if (keyMatch) {
     fieldName = keyMatch[1]
     keyOp = normalizeOperator(keyMatch[2])
@@ -262,11 +250,7 @@ const appendWhereEntry = (parts, params, increment, key, value) => {
 
   const fieldSql = quoteIdent(fieldName)
   if (!fieldSql) return increment
-
-  if (keyOp) {
-    return pushWhereCondition(parts, params, increment, fieldSql, keyOp, value)
-  }
-
+  if (keyOp) return pushWhereCondition(parts, params, increment, fieldSql, keyOp, value)
   if (value === null || value === undefined) {
     parts.push(`${fieldSql} IS NULL`)
     return increment
@@ -276,13 +260,9 @@ const appendWhereEntry = (parts, params, increment, key, 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)
+      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])
     }
@@ -291,8 +271,7 @@ const appendWhereEntry = (parts, params, increment, key, value) => {
 
   if (isOperatorMap(value)) {
     const castRaw = value.cast || value.type
-    const cast = String(castRaw || '').toLowerCase() === 'date' ? 'date' : castRaw
-    const sqlField = fieldSqlWithCast(fieldSql, cast)
+    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)
@@ -315,379 +294,276 @@ const appendWhereEntry = (parts, params, increment, key, value) => {
   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(', ') : '*'
+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])
   }
-  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(' ')
+  return increment
 }
 
-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 normalizeWhereArrayItem = (raw) => {
+  if (Array.isArray(raw)) {
+    return { field: raw[0], option: raw[1], value: raw[2], operator: raw[3] || 'AND', type: raw[4] }
   }
-  const parts = []
-  for (const key in having) {
-    increment = appendWhereEntry(parts, arr, increment, key, having[key])
-  }
-  return { sql: parts.length ? ` HAVING ${parts.join(' AND ')} ` : '', increment }
+  return isPlainObject(raw) ? raw : null
 }
 
-const connection = {}
+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
 
-connection.query = async (string, arr) => {
-  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)
+  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 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 += `, `
-        }
-      }
-    }
+  if (type === 'inline') {
+    if (item.value == null) return increment
+    parts.push(field ? `${field} ${item.value}` : String(item.value))
+    return increment
   }
-  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(', ')} `
-    }
+
+  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
   }
 
-  return orderBy
+  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)
 }
 
 const whereFn = (obj, startIncrement = 1) => {
-  const where = obj.where || {}
-  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 = startIncrement
-  const arr = []
+  const incrementStart = Number.isInteger(startIncrement) && startIncrement > 0 ? startIncrement : 1
+  const params = []
   const parts = []
+  let increment = incrementStart
 
-  if (where && typeof where === 'object' && !Array.isArray(where)) {
-    for (const key in where) {
-      increment = appendWhereEntry(parts, arr, increment, key, where[key])
-    }
-  }
+  increment = appendWhereObject(parts, params, increment, obj && obj.where)
 
   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 ')})`)
+  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
   }
 
-  let wherequery = parts.join(' AND ')
-  let hasWhere = parts.length > 0
-
-  if (whereArray.length) {
-    let andOr = wherequery ? ' AND ' : ''
-    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
+  return {
+    where: sql ? `WHERE ${sql}` : '',
+    arr: params,
+    increment,
+  }
+}
 
-      const type = !item.type ? 'text' : item.type
-      if (index > 0) {
-        andOr = ''
-      }
-      let operator = !item.operator ? ' AND ' : item.operator
-      if (index == whereArray.length - 1) {
-        operator = ''
-      }
+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(', ') : '*'
+  }
+  return typeof select === 'string' && select.trim() ? select : '*'
+}
 
-      const quotedField = item.field ? quoteIdent(item.field) : ''
-      let field = ''
-      if (type == 'date') {
-        field = quotedField ? `${quotedField}::text ` : ''
-      } else {
-        field = quotedField || ''
-      }
+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(' ')
 
-      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 {
-        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 (rawOption.includes('$')) {
-          wherequery += `${andOr} ${field} ${rawOption} ${operator}`
-          increment++
-          arr.push(item.value)
-          hasWhere = true
-        } else {
-          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} ${option} $${increment} ${operator}`
-            increment++
-            let itemValue = item.value
-            if (option === '=') {
-              itemValue = Util.replaceAll(itemValue + '', '%', '')
-            }
-            arr.push(itemValue)
-            hasWhere = true
-          }
-        }
-      }
+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)
     })
-  }
+    .filter(Boolean)
+  return cols.length ? ` GROUP BY ${cols.join(', ')}` : ''
+}
 
-  if (arr.length > 0) {
-    hasWhere = true
+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 }
+}
+
+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(', ')}` : ''
   }
 
-  return {
-    where: hasWhere && wherequery ? `WHERE ${wherequery}` : '',
-    arr,
-    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)
   }
+  return segments.length ? ` ORDER BY ${segments.join(', ')}` : ''
 }
 
 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)
-  const limit = limitVal !== null ? ` LIMIT ${limitVal} ` : ''
-  const offset = offsetVal !== null ? ` OFFSET ${offsetVal} ` : ''
-  const orderBy = orderByFn(obj)
-  const values = obj.values || []
-  const join = formatJoins(obj.joins || obj.join || [])
-  const groupBy = groupByFn(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 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 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.results = async (obj) => {
-  const { sql, arr, values } = buildSelectQuery(obj)
+const requireDataObject = (data, action) => {
+  if (!isPlainObject(data)) throw new Error(`Data object is required for ${action}`)
+  return { ...data }
+}
+
+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 = {}
+
+connection.query = async (string, arr) => {
   try {
-    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
+    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.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) => {
-  const { sql, arr } = buildSelectQuery(obj)
-  return { sql, arr }
+  try {
+    const built = buildSelectQuery(obj)
+    return { sql: built.sql, arr: built.arr }
+  } catch (err) {
+    return { sql: '', arr: [], error: err.message }
+  }
 }
 
 connection.result = async (obj) => {
   const results = await connection.results(obj)
-  if (results.length) {
-    return results[0]
-  } else {
-    return []
-  }
+  return Array.isArray(results) && results.length ? results[0] : []
 }
 
 connection.insert = async (obj) => {
-  const tableSql = quoteTableName(obj.table || '')
-  if (!tableSql) throw new Error('Table name is required for insert')
-  const data = { ...obj.data }
+  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
-  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++
-    }
-  }
-  if (datas.length === 0) throw new Error('At least one valid column is required for insert')
-  const sql = `INSERT INTO ${tableSql} ("${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 { 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.update = async (obj) => {
-  const tableSql = quoteTableName(obj.table || '')
-  if (!tableSql) throw new Error('Table name is required for update')
-  const data = { ...obj.data }
+  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 arr = []
-  const dataArr = []
-  let increment = 1
-
-  for (const key in data) {
-    const col = sanitizeColumnName(key)
-    if (col) {
-      dataArr.push(`"${col}" = $${increment}`)
-      arr.push(data[key])
-      increment++
-    }
-  }
-  if (dataArr.length === 0) throw new Error('At least one valid column is required for update')
-
-  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)
-    return result.rows[0]
-  } catch (e) {
-    console.log(sql)
-    console.log(arr)
-    console.log(e.toString())
-    throw e
-  }
+  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]
 }
 
 connection.delete = async (obj) => {
-  const tableSql = quoteTableName(obj.table || '')
-  if (!tableSql) throw new Error('Table name is required for delete')
+  if (!isPlainObject(obj)) throw new Error('Delete options must be an object')
+  const tableSql = requireTableName(obj.table, '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, whereObj.arr)
-  } catch (e) {
-    console.log(sql)
-    console.log(whereObj.arr)
-    console.log(e.toString())
-    throw e
-  }
+  const sql = `DELETE FROM ${tableSql}${whereObj.where ? ` ${whereObj.where}` : ''} RETURNING *`
+  return runQuery(sql, whereObj.arr)
 }
 
 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`
@@ -701,205 +577,105 @@ connection.count = async (obj) => {
     distinct: undefined,
   })
   if (!row || Array.isArray(row)) return 0
-  return Number(row.count || 0)
+  const n = Number(row.count)
+  return Number.isFinite(n) ? n : 0
 }
 
-connection.insertData = async(tableName, data) => {
-  try {
-    // Validasi input
-    if (!data || typeof data !== 'object') {
-      throw new Error('Invalid data provided for insert');
-    }
+connection.insertData = async (tableName, data) => connection.insert({ table: tableName, data })
 
-    const columns = Object.keys(data);
-    if (columns.length === 0) {
-      throw new Error('No columns found in the data object');
-    }
-
-    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.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.deleteData = async(tableName, where) => {
-  try {
-    // Validasi input
-    if (!where || typeof where !== 'object') {
-      throw new Error('Invalid where clause provided for delete');
-    }
-
-    const whereColumns = Object.keys(where);
-    if (whereColumns.length === 0) {
-      throw new Error('No where conditions provided for delete');
-    }
-
-    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.insertMultipleRecords = async(tableName,records) => {
-  try {
-    // Validasi input
-    if (!records || !Array.isArray(records) || records.length === 0) {
-      console.warn(`No records to insert into ${tableName}`);
-      return [];
-    }
-
-    // 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.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 columns = Object.keys(firstRecord);
-    if (columns.length === 0) {
-      throw new Error('No columns found in the first record');
-    }
+  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')
 
-    // 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`);
-      }
+  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 = 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 {
-  }
+  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.driver = config.driver
+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 = (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.describeTable = (table) => {
-  return connection.showFullFields(table)
+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