@starbemtech/star-db-query-builder 1.0.0 → 1.0.2

package/src/default/genericRepository.ts

@@ -1,143 +0,0 @@
-import { QueryParams } from './types'
-import {
-  createGroupByClause,
-  createLimitClause,
-  createOrderByClause,
-  generatePlaceholders,
-  createSelectFields,
-  createWhereClause,
-  generateSetClause,
-} from './utils'
-
-export const findFirst = async <T>({
-  tableName,
-  dbClient,
-  select,
-  where,
-  groupBy,
-  orderBy,
-}: QueryParams): Promise<T> => {
-  if (!tableName) throw new Error('Table name is required')
-  if (!dbClient) throw new Error('DB client is required')
-
-  const fields = createSelectFields(select)
-  const [whereClause, params] = createWhereClause(where)
-  const orderByClause = createOrderByClause(orderBy)
-  const groupByClause = createGroupByClause(groupBy)
-
-  const rows = await dbClient.query<T>(
-    `SELECT ${fields} FROM ${tableName}
-      ${whereClause.length > 7 ? whereClause : ''}
-      ${groupByClause}
-      ${orderByClause}
-    `,
-    [params]
-  )
-
-  return rows[0] || null
-}
-
-export const findMany = async <T>({
-  tableName,
-  dbClient,
-  select,
-  where,
-  groupBy,
-  orderBy,
-  limit,
-}: QueryParams): Promise<T[]> => {
-  if (!tableName) throw new Error('Table name is required')
-  if (!dbClient) throw new Error('DB client is required')
-
-  const fields = createSelectFields(select)
-  const [whereClause, params] = createWhereClause(where)
-  const orderByClause = createOrderByClause(orderBy)
-  const groupByClause = createGroupByClause(groupBy)
-  const limitClause = createLimitClause(limit)
-
-  const rows = await dbClient.query<T[]>(
-    `SELECT ${fields} FROM ${tableName}
-      ${whereClause.length > 7 ? whereClause : ''}
-      ${groupByClause}
-      ${orderByClause}
-      ${limitClause}
-    `,
-    [params]
-  )
-
-  return rows || []
-}
-
-export const insert = async <T>({
-  tableName,
-  dbClient,
-  data,
-  returning,
-}: QueryParams & { data: T; returning?: string[] }): Promise<T | void> => {
-  if (!tableName) throw new Error('Table name is required')
-  if (!dbClient) throw new Error('DB client is required')
-  if (!data) throw new Error('Data object is required')
-
-  const keys = Object.keys(data)
-  const values = Object.values(data)
-
-  const placeholders = generatePlaceholders(keys, dbClient.clientType)
-  let query = `INSERT INTO ${tableName} (${keys.join(', ')}) VALUES (${placeholders})`
-
-  if (dbClient.clientType === 'pg') {
-    if (returning && returning.length > 0) {
-      query += ` RETURNING ${createSelectFields(returning)}`
-    }
-  }
-
-  const inserted = await dbClient.query<T[]>(query, values)
-
-  if (dbClient.clientType === 'pg') return inserted[0]
-}
-
-export const update = async <T>({
-  tableName,
-  dbClient,
-  id,
-  data,
-  returning,
-}: QueryParams & { data: T; returning?: string[] }): Promise<T | void> => {
-  if (!tableName) throw new Error('Table name is required')
-  if (!dbClient) throw new Error('DB client is required')
-  if (!id) throw new Error('ID is required')
-  if (!data) throw new Error('Data object is required')
-
-  const keys = Object.keys(data)
-  const values: any[] = Object.values(data)
-
-  const setClause = generateSetClause(keys, dbClient.clientType)
-  let query = `UPDATE ${tableName} SET ${setClause} WHERE ${id}`
-
-  if (dbClient.clientType === 'pg') {
-    if (returning && returning.length > 0) {
-      query += ` RETURNIN ${createSelectFields(returning)}`
-    }
-  }
-
-  const updated = await dbClient.query<T[]>(query, values)
-
-  if (dbClient.clientType === 'pg') return updated[0]
-}
-
-export const deleteOne = async ({
-  tableName,
-  dbClient,
-  id,
-  permanently = false,
-}: QueryParams & { permanently?: boolean }): Promise<void> => {
-  if (!tableName) throw new Error('Table name is required')
-  if (!dbClient) throw new Error('DB client is required')
-  if (!id) throw new Error('ID is required')
-
-  await dbClient.query(
-    permanently
-      ? `DELETE FROM ${tableName} WHERE id = ${dbClient.clientType === 'pg' ? '$1' : '?'}`
-      : `UPDATE ${tableName} SET status = 'deleted' WHERE id = ${dbClient.clientType === 'pg' ? '$1' : '?'}`,
-    [id]
-  )
-}

package/src/default/types.ts

@@ -1,53 +0,0 @@
-import { IDatabaseClient } from '../db/IDatabaseClient'
-
-export interface QueryExec {
-  text: string
-  values?: any[]
-}
-
-type SimpleValue = string | number | boolean | Date
-
-type ConditionOperator = 'AND' | 'OR'
-
-interface OperatorCondition {
-  operator:
-    | 'LIKE'
-    | '='
-    | '>'
-    | '<'
-    | 'IN'
-    | 'BETWEEN'
-    | '!='
-    | '<='
-    | '>='
-    | 'NOT IN'
-    | 'LIKE'
-    | 'NOT LIKE'
-  value: SimpleValue | SimpleValue[]
-}
-
-export type DBClients = 'pg' | 'mysql'
-
-export interface CompositeCondition {
-  type: ConditionOperator
-  conditions: Condition[]
-}
-
-export type Condition = SimpleValue | OperatorCondition | CompositeCondition
-
-export interface Conditions {
-  [key: string]: Condition
-}
-
-export type OrderBy = { field: string; direction: 'ASC' | 'DESC' }[]
-
-export interface QueryParams {
-  tableName: string
-  dbClient: IDatabaseClient
-  id?: string
-  select?: string[]
-  where?: Conditions
-  orderBy?: OrderBy
-  groupBy?: string[]
-  limit?: number
-}

package/src/default/utils.ts

@@ -1,107 +0,0 @@
-import {
-  Conditions,
-  Condition,
-  CompositeCondition,
-  OrderBy,
-  DBClients,
-} from './types'
-
-const arrayToStringWithQuotes = (items: string[]): string => {
-  const itemsWithQuotes = items.map((item) => `"${item}"`)
-  return itemsWithQuotes.join(', ')
-}
-
-export const createSelectFields = (fields?: string[]): string => {
-  return fields && fields.length > 0 ? arrayToStringWithQuotes(fields) : '*'
-}
-
-export const generatePlaceholders = (
-  keys: any[],
-  clientType: DBClients
-): string => {
-  return keys
-    .map((_, index) => (clientType === 'pg' ? `$${index + 1}` : '?'))
-    .join(', ')
-}
-
-export const generateSetClause = (
-  keys: any[],
-  clientType: DBClients
-): string => {
-  return keys
-    .map((key, index) =>
-      clientType === 'pg' ? `${key} = $${index + 1}` : `${key} = ?`
-    )
-    .join(', ')
-}
-
-export const createWhereClause = (
-  conditions: Conditions = {},
-  startIndex: number = 1
-): [string, any[], number] => {
-  let index = startIndex
-  const whereParts: string[] = []
-  const values: any[] = []
-
-  const processCondition = (key: string, condition: Condition): number => {
-    if (typeof condition === 'object' && condition !== null) {
-      if ('operator' in condition && 'value' in condition) {
-        const { operator, value } = condition
-        if (Array.isArray(value)) {
-          const placeholders = value.map(() => `$${index++}`).join(', ')
-          if (operator === 'BETWEEN') {
-            whereParts.push(
-              `"${key}" ${operator} ${placeholders.replace(', ', ' AND ')}`
-            )
-          } else {
-            whereParts.push(`"${key}" ${operator} (${placeholders})`)
-          }
-          values.push(...value)
-        } else {
-          whereParts.push(`"${key}" ${operator} $${index++}`)
-          values.push(value)
-        }
-      } else if ('type' in condition && 'conditions' in condition) {
-        const compositeCondition: CompositeCondition = condition
-        const subWhereParts: string[] = []
-        compositeCondition.conditions.forEach((subCondition) => {
-          // Recurso: criar uma chave fictícia, pois as condições compostas não necessitam de chave
-          index = processCondition('', subCondition)
-        })
-        whereParts.push(
-          `(${subWhereParts.join(` ${compositeCondition.type} `)})`
-        )
-      }
-    } else if (key) {
-      // Condição simples
-      whereParts.push(`"${key}" = $${index}`)
-      values.push(condition)
-      index++
-    }
-    return index
-  }
-
-  Object.entries(conditions).forEach(([key, value]) => {
-    index = processCondition(key, value)
-  })
-
-  const whereClause =
-    whereParts.length > 0 ? ` WHERE ${whereParts.join(' AND ')}` : ''
-  return [whereClause, values, index]
-}
-
-export const createOrderByClause = (orderBy?: OrderBy) => {
-  if (!orderBy || orderBy.length === 0) return ''
-  const clause = orderBy.map((o) => `${o.field} ${o.direction}`).join(', ')
-  return ` ORDER BY ${clause}`
-}
-
-export const createGroupByClause = (groupBy?: string[]) => {
-  if (!groupBy || groupBy.length === 0) return ''
-  return ` GROUP BY ${groupBy.join(', ')}`
-}
-
-export const createLimitClause = (limit?: number) => {
-  if (!limit) return ''
-  return ` LIMIT ${limit}`
-}