@starbemtech/star-db-query-builder 1.3.1 → 1.4.0

package/src/core/types.ts

@@ -1,97 +0,0 @@
-import { IDatabaseClient } from '../db/IDatabaseClient'
-
-export interface RetryOptions {
-  retries?: number
-  factor?: number
-  minTimeout?: number
-  maxTimeout?: number
-  randomize?: boolean
-}
-
-export interface QueryExec {
-  text: string
-  values?: any[]
-}
-
-type SimpleValue = string | number | boolean | Date | null
-
-export interface OperatorCondition {
-  operator:
-    | 'ILIKE'
-    | 'LIKE'
-    | '='
-    | '>'
-    | '<'
-    | 'IN'
-    | 'BETWEEN'
-    | '!='
-    | '<='
-    | '>='
-    | 'NOT IN'
-    | 'LIKE'
-    | 'NOT LIKE'
-    | 'IS NULL'
-    | 'IS NOT NULL'
-    | 'NOT EXISTS'
-  value: SimpleValue | SimpleValue[]
-}
-
-export type LogicalOperator = 'OR' | 'AND'
-
-export type Condition<T> = OperatorCondition | LogicalCondition<T>
-
-interface LogicalCondition<T> {
-  OR?: Conditions<T>[]
-  AND?: Conditions<T>[]
-  JOINS?: Conditions<object>
-  notExists?: OperatorCondition
-}
-
-export type Conditions<T> = {
-  [P in keyof T]?: Condition<T[P]>
-} & LogicalCondition<T>
-
-export type DBClients = 'pg' | 'mysql'
-
-export type OrderBy = { field: string; direction: 'ASC' | 'DESC' }[]
-
-export interface QueryParams<T> {
-  tableName: string
-  dbClient: IDatabaseClient
-  id?: string
-  select?: string[]
-  where?: Conditions<T>
-  orderBy?: OrderBy
-  groupBy?: string[]
-  limit?: number
-  offset?: number
-  joins?: JoinClause[]
-  unaccent?: boolean
-}
-
-interface JoinClause {
-  type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL'
-  table: string
-  on: string
-}
-
-export interface QueryBuilder {
-  select: string[]
-  from?: string
-  joins?: JoinClause[]
-  where?: string
-  groupBy?: string[]
-  orderBy?: string
-  limit?: string
-  offset?: string
-}
-
-export interface RawQueryParams {
-  dbClient: IDatabaseClient
-  sql: string
-  params?: any[]
-}
-
-export interface TransactionParams {
-  dbClient: IDatabaseClient
-}

package/src/core/utils.ts

@@ -1,357 +0,0 @@
-import { Conditions, Condition, OrderBy, DBClients } from './types'
-
-/**
- * Converts an array of strings to a comma-separated string with quotes
- *
- * This function takes an array of strings and converts it to a comma-separated string
- * with quotes. It handles the differences between PostgreSQL and MySQL syntax for
- * string arrays.
- *
- * @param items - The array of strings to convert
- * @param clientType - The type of database client
- * @returns A comma-separated string with quotes
- *
- * @example
- * const items = ['item1', 'item2', 'item3']
- * const clientType = 'pg'
- * const result = arrayToStringWithQuotes(items, clientType)
- * // result will be: 'item1', 'item2', 'item3'
- */
-const arrayToStringWithQuotes = (
-  items: string[],
-  clientType: DBClients
-): string => {
-  const itemsWithQuotes = items.map((item) =>
-    clientType === 'pg' ? `${item}` : `${item}`
-  )
-  return itemsWithQuotes.join(', ')
-}
-
-/**
- * Generates a PostgreSQL placeholder for a parameter
- *
- * This function generates a PostgreSQL placeholder for a parameter. It returns
- * a string with a dollar sign and the index of the parameter.
- *
- * @param index - The index of the parameter
- * @returns A PostgreSQL placeholder
- *
- * @example
- * const index = 1
- * const placeholder = pgPlaceholderGenerator(index)
- * // placeholder will be: $1
- */
-const pgPlaceholderGenerator = (index: number) => `$${index}`
-
-/**
- * Generates a MySQL placeholder for a parameter
- *
- * This function generates a MySQL placeholder for a parameter. It returns
- * a string with a question mark.
- *
- * @returns A MySQL placeholder
- *
- * @example
- * const placeholder = mysqlPlaceholderGenerator()
- * // placeholder will be: ?
- */
-const mysqlPlaceholderGenerator = () => `?`
-
-/**
- * Creates a SELECT clause for a query
- *
- * This function creates a SELECT clause for a query. It takes an array of fields
- * and a database client type and returns a string with the fields separated by commas.
- *
- * @param fields - The array of fields to select
- * @param clientType - The type of database client
- * @returns A string with the fields separated by commas
- *
- * @example
- * const fields = ['id', 'name', 'email']
- * const clientType = 'pg'
- * const result = createSelectFields(fields, clientType)
- * // result will be: "id, name, email"
- */
-export const createSelectFields = (
-  fields: string[] = [],
-  clientType: DBClients
-): string => {
-  return fields && fields.length > 0
-    ? arrayToStringWithQuotes(fields, clientType)
-    : '*'
-}
-
-/**
- * Generates placeholders for a query
- *
- * This function generates placeholders for a query. It takes an array of keys
- * and a database client type and returns a string with the placeholders separated by commas.
- *
- * @param keys - The array of keys to generate placeholders for
- * @param clientType - The type of database client
- * @returns A string with the placeholders separated by commas
- *
- * @example
- * const keys = ['id', 'name', 'email']
- * const clientType = 'pg'
- * const result = generatePlaceholders(keys, clientType)
- * // result will be: $1, $2, $3
- */
-export const generatePlaceholders = (
-  keys: any[],
-  clientType: DBClients
-): string => {
-  return keys
-    .map((_, index) => (clientType === 'pg' ? `$${index + 1}` : '?'))
-    .join(', ')
-}
-
-/**
- * Generates a SET clause for a query
- *
- * This function generates a SET clause for a query. It takes an array of keys
- * and a database client type and returns a string with the keys and placeholders separated by commas.
- *
- * @param keys - The array of keys to generate SET clause for
- * @param clientType - The type of database client
- * @returns A string with the keys and placeholders separated by commas
- *
- * @example
- * const keys = ['id', 'name', 'email']
- * const clientType = 'pg'
- * const result = generateSetClause(keys, clientType)
- * // result will be: "id = $1, name = $2, email = $3"
- */
-export const generateSetClause = (
-  keys: any[],
-  clientType: DBClients
-): string => {
-  return keys
-    .map((key, index) =>
-      clientType === 'pg' ? `${key} = $${index + 1}` : `${key} = ?`
-    )
-    .join(', ')
-}
-
-/**
- * Creates a WHERE clause for a query
- *
- * This function creates a WHERE clause for a query. It takes an array of conditions
- * and a database client type and returns a string with the conditions separated by AND.
- *
- * @param conditions - The array of conditions to create WHERE clause for
- * @param startIndex - The index of the first parameter
- * @param clientType - The type of database client
- * @param unaccent - Whether to use unaccent function
- * @returns A string with the conditions separated by AND
- *
- * @example
- * const conditions = [{ field: 'name', operator: '=', value: 'John Doe' }]
- * const startIndex = 1
- * const clientType = 'pg'
- * const unaccent = true
- * const result = createWhereClause(conditions, startIndex, clientType, unaccent)
- * // result will be: "name = $1"
- */
-export const createWhereClause = <T>(
-  conditions: Conditions<T> = {},
-  startIndex = 1,
-  clientType: DBClients,
-  unaccent?: boolean
-): [string, any[], number] => {
-  let index = startIndex
-  const whereParts: string[] = []
-  const values: any[] = []
-
-  const processCondition = (key: string, condition: Condition<T>) => {
-    if (typeof condition === 'object' && condition !== null) {
-      if ('operator' in condition && 'value' in condition) {
-        const { operator, value } = condition
-
-        if (operator === 'NOT EXISTS' && typeof value === 'string') {
-          whereParts.push(`NOT EXISTS (${value})`)
-        } else if (operator.includes('NULL')) {
-          whereParts.push(`${key} ${operator}`)
-        } else if (Array.isArray(value)) {
-          const placeholders = value
-            .map(() =>
-              clientType === 'pg'
-                ? pgPlaceholderGenerator(index++)
-                : mysqlPlaceholderGenerator()
-            )
-            .join(', ')
-
-          if (operator === 'BETWEEN') {
-            whereParts.push(
-              `${key} ${operator} ${placeholders.replace(', ', ' AND ')}`
-            )
-          } else if (operator === 'IN') {
-            whereParts.push(`${key} ${operator} (${placeholders})`)
-          } else {
-            whereParts.push(`${key} ${operator} (${placeholders})`)
-          }
-          values.push(...value)
-        } else {
-          if (unaccent && clientType === 'pg') {
-            if (operator.toUpperCase() === 'ILIKE') {
-              whereParts.push(
-                `unaccent(${key}::text) ILIKE unaccent(${pgPlaceholderGenerator(index)})`
-              )
-            } else {
-              whereParts.push(
-                `unaccent(${key}::text) ${operator} unaccent(${pgPlaceholderGenerator(index)})`
-              )
-            }
-          } else {
-            whereParts.push(
-              clientType === 'pg'
-                ? `${key} ${operator} ${pgPlaceholderGenerator(index)}`
-                : `${key} ${operator} ${mysqlPlaceholderGenerator()}`
-            )
-          }
-          index++
-          values.push(value)
-        }
-      }
-    }
-  }
-
-  if ('JOINS' in conditions) {
-    const logicalOperator = conditions.JOINS ? 'AND' : 'OR'
-    const compositeConditions = conditions.JOINS
-
-    if (Array.isArray(compositeConditions)) {
-      const subWhereParts = compositeConditions
-        .map((subCondition: any) => {
-          if (
-            typeof subCondition === 'object' &&
-            !Array.isArray(subCondition) &&
-            subCondition !== null
-          ) {
-            const key = Object.keys(subCondition)[0]
-            const condition = subCondition[key]
-
-            // Adiciona o tratamento de unaccent nas condições de JOINS
-            processCondition(key, condition)
-            return whereParts.pop()
-          }
-          return ''
-        })
-        .filter((part) => part)
-
-      whereParts.push(`(${subWhereParts.join(` ${logicalOperator} `)})`)
-    }
-  } else {
-    Object.entries(conditions).forEach(([key, value]) =>
-      processCondition(key, value as Condition<T>)
-    )
-  }
-
-  if ('OR' in conditions || 'AND' in conditions) {
-    const logicalOperator = conditions.OR ? 'OR' : 'AND'
-    const compositeConditions = conditions.OR || conditions.AND
-
-    if (Array.isArray(compositeConditions)) {
-      const subWhereParts = compositeConditions
-        .map((subCondition: any) => {
-          if (
-            typeof subCondition === 'object' &&
-            !Array.isArray(subCondition) &&
-            subCondition !== null
-          ) {
-            const key = Object.keys(subCondition)[0]
-            const condition = subCondition[key]
-            processCondition(key, condition) // Certifica que o unaccent é processado aqui também
-            return whereParts.pop()
-          }
-
-          return ''
-        })
-        .filter((part) => part)
-
-      whereParts.push(`(${subWhereParts.join(` ${logicalOperator} `)})`)
-    }
-  }
-
-  const whereClause =
-    whereParts.length > 0 ? ` WHERE ${whereParts.join(' AND ')}` : ''
-  return [whereClause, values, index]
-}
-
-/**
- * Creates an ORDER BY clause for a query
- *
- * This function creates an ORDER BY clause for a query. It takes an array of
- * order by fields and returns a string with the fields separated by commas.
- *
- * @param orderBy - The array of order by fields
- * @returns A string with the fields separated by commas
- *
- * @example
- * const orderBy = [{ field: 'created_at', direction: 'DESC' }]
- * const result = createOrderByClause(orderBy)
- * // result will be: "ORDER BY created_at DESC"
- */
-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}`
-}
-
-/**
- * Creates a GROUP BY clause for a query
- *
- * This function creates a GROUP BY clause for a query. It takes an array of
- * group by fields and returns a string with the fields separated by commas.
- *
- * @param groupBy - The array of group by fields
- * @returns A string with the fields separated by commas
- *
- * @example
- * const groupBy = ['status']
- * const result = createGroupByClause(groupBy)
- * // result will be: "GROUP BY status"
- */
-export const createGroupByClause = (groupBy?: string[]) => {
-  if (!groupBy || groupBy.length === 0) return ''
-  return ` GROUP BY ${groupBy.join(', ')}`
-}
-
-/**
- * Creates a LIMIT clause for a query
- *
- * This function creates a LIMIT clause for a query. It takes a limit number
- * and returns a string with the limit.
- *
- * @param limit - The limit number
- * @returns A string with the limit
- *
- * @example
- * const limit = 10
- * const result = createLimitClause(limit)
- * // result will be: "LIMIT 10"
- */
-export const createLimitClause = (limit?: number) => {
-  if (!limit) return ''
-  return ` LIMIT ${limit}`
-}
-
-/**
- * Creates an OFFSET clause for a query
- *
- * This function creates an OFFSET clause for a query. It takes an offset number
- * and returns a string with the offset.
- *
- * @param offset - The offset number
- * @returns A string with the offset
- *
- * @example
- * const offset = 10
- * const result = createOffsetClause(offset)
- * // result will be: "OFFSET 10"
- */
-export const createOffsetClause = (offset?: number) => {
-  if (!offset) return ''
-  return ` OFFSET ${offset}`
-}

package/src/db/IDatabaseClient.ts

@@ -1,16 +0,0 @@
-import { DBClients } from '../core/types'
-
-export interface ITransactionClient {
-  query: <T>(sql: string, params?: any[]) => Promise<T>
-  commit: () => Promise<void>
-  rollback: () => Promise<void>
-}
-
-/**
- * Database client interface
- */
-export type IDatabaseClient = {
-  clientType: DBClients
-  query: <T>(sql: string, params?: any[]) => Promise<T>
-  beginTransaction: () => Promise<ITransactionClient>
-}