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

package/src/db/mysqlClient.ts

@@ -1,200 +0,0 @@
-import { Pool, PoolConnection } from 'mysql2/promise'
-import promiseRetry from 'promise-retry'
-import { IDatabaseClient, ITransactionClient } from './IDatabaseClient'
-import { RetryOptions } from '../core/types'
-import { monitor, MonitorEvents } from '../monitor/monitor'
-
-const transientErrorCodes = new Set([
-  'ECONNRESET',
-  'ETIMEDOUT',
-  'PROTOCOL_CONNECTION_LOST',
-  'ECONNREFUSED',
-])
-
-/**
- * Checks if the given error is a transient error that can be retried
- *
- * Transient errors are temporary network or connection issues that typically
- * resolve themselves and can be safely retried. This function checks if the
- * error code matches known transient error patterns for MySQL connections.
- *
- * @param error - The error object to check
- * @returns boolean - True if the error is transient and can be retried, false otherwise
- *
- * @example
- * try {
- *   const result = await pool.execute(sql, params);
- * } catch (error) {
- *   if (isTransientError(error)) {
- *     // Retry the operation
- *     console.log('Transient error detected, retrying...');
- *   } else {
- *     // Handle permanent error
- *     throw error;
- *   }
- * }
- */
-function isTransientError(error: any): boolean {
-  return error && error.code && transientErrorCodes.has(error.code)
-}
-
-/**
- * Creates a MySQL database client
- *
- * This function initializes a MySQL database client with the provided pool configuration
- * and optional retry options. It sets up monitoring for connection events and query operations.
- *
- * @param pool - The MySQL pool instance
- * @param retryOptions - Optional retry options for failed queries
- * @returns IDatabaseClient - The MySQL database client instance
- *
- * @example
- * const mysqlClient = createMysqlClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- *
- * @example
- * const mysqlClient = createMysqlClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- *
- * @example
- * const mysqlClient = createMysqlClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- *
- * @example
- * const mysqlClient = createMysqlClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- */
-export const createMysqlClient = (
-  pool: Pool,
-  retryOptions?: RetryOptions
-): IDatabaseClient => {
-  monitor.emit(MonitorEvents.CONNECTION_CREATED, {
-    clientType: 'mysql',
-    poolOptions: pool.config,
-  })
-
-  return {
-    clientType: 'mysql',
-    query: async <T>(sql: string, params?: any[]): Promise<T> => {
-      return promiseRetry(async (retry, attempt) => {
-        const startTime = Date.now()
-        try {
-          monitor.emit(MonitorEvents.QUERY_START, {
-            clientType: 'mysql',
-            sql,
-            params,
-            attempt,
-          })
-
-          const [rows] = await pool.execute(sql, params)
-
-          const elapsedTime = Date.now() - startTime
-          monitor.emit(MonitorEvents.QUERY_END, {
-            clientType: 'mysql',
-            sql,
-            params,
-            attempt,
-            elapsedTime,
-          })
-
-          return rows as unknown as T
-        } catch (error: any) {
-          const elapsedTime = Date.now() - startTime
-          monitor.emit(MonitorEvents.QUERY_ERROR, {
-            clientType: 'mysql',
-            sql,
-            params,
-            attempt,
-            elapsedTime,
-            error,
-          })
-
-          if (isTransientError(error)) {
-            console.warn(
-              `MySQL query attempt ${attempt} failed, retrying...`,
-              error
-            )
-            monitor.emit(MonitorEvents.RETRY_ATTEMPT, {
-              clientType: 'mysql',
-              sql,
-              params,
-              attempt,
-              error,
-            })
-
-            return retry(error)
-          }
-
-          throw error
-        }
-      }, retryOptions)
-    },
-    beginTransaction: async (): Promise<ITransactionClient> => {
-      const connection: PoolConnection = await pool.getConnection()
-
-      try {
-        await connection.beginTransaction()
-
-        return {
-          query: async <T>(sql: string, params?: any[]): Promise<T> => {
-            const startTime = Date.now()
-            try {
-              monitor.emit(MonitorEvents.QUERY_START, {
-                clientType: 'mysql',
-                sql,
-                params,
-                attempt: 1,
-                inTransaction: true,
-              })
-
-              const [rows] = await connection.execute(sql, params)
-
-              const elapsedTime = Date.now() - startTime
-              monitor.emit(MonitorEvents.QUERY_END, {
-                clientType: 'mysql',
-                sql,
-                params,
-                attempt: 1,
-                elapsedTime,
-                inTransaction: true,
-              })
-
-              return rows as unknown as T
-            } catch (error) {
-              const elapsedTime = Date.now() - startTime
-              monitor.emit(MonitorEvents.QUERY_ERROR, {
-                clientType: 'mysql',
-                sql,
-                params,
-                attempt: 1,
-                elapsedTime,
-                error,
-                inTransaction: true,
-              })
-              throw error
-            }
-          },
-          commit: async (): Promise<void> => {
-            try {
-              await connection.commit()
-              monitor.emit(MonitorEvents.TRANSACTION_COMMIT, {
-                clientType: 'mysql',
-              })
-            } finally {
-              connection.release()
-            }
-          },
-          rollback: async (): Promise<void> => {
-            try {
-              await connection.rollback()
-              monitor.emit(MonitorEvents.TRANSACTION_ROLLBACK, {
-                clientType: 'mysql',
-              })
-            } finally {
-              connection.release()
-            }
-          },
-        }
-      } catch (error) {
-        connection.release()
-        throw error
-      }
-    },
-  }
-}

package/src/db/pgClient.ts

@@ -1,246 +0,0 @@
-import { Pool, PoolConfig, PoolClient } from 'pg'
-import promiseRetry from 'promise-retry'
-import { IDatabaseClient, ITransactionClient } from './IDatabaseClient'
-import { RetryOptions } from '../core/types'
-import { monitor, MonitorEvents } from '../monitor/monitor'
-
-const transientErrorCodes = new Set(['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED'])
-
-/**
- * Checks if the given error is a transient error that can be retried
- *
- * Transient errors are temporary network or connection issues that typically
- * resolve themselves and can be safely retried. This function checks if the
- * error code matches known transient error patterns for PostgreSQL connections.
- *
- * @param error - The error object to check
- * @returns boolean - True if the error is transient and can be retried, false otherwise
- *
- * @example
- * try {
- *   const result = await pool.query(sql, params);
- * } catch (error) {
- *   if (isTransientError(error)) {
- *     // Retry the operation
- *     console.log('Transient error detected, retrying...');
- *   } else {
- *     // Handle permanent error
- *     throw error;
- *   }
- * }
- */
-function isTransientError(error: any): boolean {
-  return error && error.code && transientErrorCodes.has(error.code)
-}
-
-/**
- * Ensures that the unaccent extension is installed in the PostgreSQL database
- *
- * This function checks if the unaccent extension is installed in the database
- * and installs it if it is not. It also emits a connection created event to
- * the monitor.
- *
- * @param pool - The PostgreSQL pool instance
- * @returns Promise<void> - Resolves when the unaccent extension is installed or already exists
- *
- * @example
- * await ensureUnaccentExtension(pool);
- */
-async function ensureUnaccentExtension(pool: Pool): Promise<void> {
-  try {
-    const checkResult = await pool.query(`
-      SELECT 1 FROM pg_extension WHERE extname = 'unaccent'
-    `)
-
-    if (checkResult.rows.length === 0) {
-      await pool.query('CREATE EXTENSION IF NOT EXISTS unaccent')
-
-      monitor.emit(MonitorEvents.CONNECTION_CREATED, {
-        clientType: 'pg',
-        extension: 'unaccent',
-        status: 'installed',
-      })
-
-      console.info(
-        '@starbemtech/star-db-query-builder: Extensão unaccent instalada com sucesso.'
-      )
-    }
-  } catch (error) {
-    monitor.emit(MonitorEvents.QUERY_ERROR, {
-      clientType: 'pg',
-      action: 'install_unaccent',
-      error,
-    })
-    throw new Error(
-      `@starbemtech/star-db-query-builder: Não foi possível instalar a extensão unaccent:
-      ${error}`
-    )
-  }
-}
-
-/**
- * Creates a PostgreSQL database client
- *
- * This function initializes a PostgreSQL database client with the provided pool configuration
- * and optional retry options. It sets up monitoring for connection events and query operations.
- *
- * @param pool - The PostgreSQL pool instance
- * @param retryOptions - Optional retry options for failed queries
- * @param poolConfig - Optional pool configuration
- * @param installUnaccentExtension - Optional flag to install unaccent extension
- * @returns IDatabaseClient - The PostgreSQL database client instance
- *
- * @example
- * const pgClient = await createPgClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- *
- * @example
- * const pgClient = await createPgClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- *
- * @example
- * const pgClient = await createPgClient(pool, { retries: 3, factor: 2, minTimeout: 1000 });
- */
-export const createPgClient = async (
-  pool: Pool,
-  retryOptions?: RetryOptions,
-  poolConfig?: PoolConfig,
-  installUnaccentExtension?: boolean
-): Promise<IDatabaseClient> => {
-  if (installUnaccentExtension) {
-    await ensureUnaccentExtension(pool)
-  }
-
-  monitor.emit(MonitorEvents.CONNECTION_CREATED, {
-    clientType: 'pg',
-    poolOptions: poolConfig,
-  })
-
-  return {
-    clientType: 'pg',
-    query: async <T>(sql: string, params?: any[]): Promise<T> => {
-      return promiseRetry(async (retry, attempt) => {
-        const startTime = Date.now()
-        try {
-          monitor.emit(MonitorEvents.QUERY_START, {
-            clientType: 'pg',
-            sql,
-            params,
-            attempt,
-          })
-
-          const { rows } = await pool.query(sql, params)
-
-          const elapsedTime = Date.now() - startTime
-          monitor.emit(MonitorEvents.QUERY_END, {
-            clientType: 'pg',
-            sql,
-            params,
-            attempt,
-            elapsedTime,
-          })
-
-          return rows as unknown as T
-        } catch (error) {
-          const elapsedTime = Date.now() - startTime
-          monitor.emit(MonitorEvents.QUERY_ERROR, {
-            clientType: 'pg',
-            sql,
-            params,
-            attempt,
-            elapsedTime,
-            error,
-          })
-
-          if (isTransientError(error)) {
-            console.warn(
-              `Postgres query attempt ${attempt} failed, retrying...`,
-              error
-            )
-
-            monitor.emit(MonitorEvents.RETRY_ATTEMPT, {
-              clientType: 'pg',
-              sql,
-              params,
-              attempt,
-              error,
-            })
-
-            return retry(error)
-          }
-
-          throw error
-        }
-      }, retryOptions)
-    },
-    beginTransaction: async (): Promise<ITransactionClient> => {
-      const client: PoolClient = await pool.connect()
-
-      try {
-        await client.query('BEGIN')
-
-        return {
-          query: async <T>(sql: string, params?: any[]): Promise<T> => {
-            const startTime = Date.now()
-            try {
-              monitor.emit(MonitorEvents.QUERY_START, {
-                clientType: 'pg',
-                sql,
-                params,
-                attempt: 1,
-                inTransaction: true,
-              })
-
-              const { rows } = await client.query(sql, params)
-
-              const elapsedTime = Date.now() - startTime
-              monitor.emit(MonitorEvents.QUERY_END, {
-                clientType: 'pg',
-                sql,
-                params,
-                attempt: 1,
-                elapsedTime,
-                inTransaction: true,
-              })
-
-              return rows as unknown as T
-            } catch (error) {
-              const elapsedTime = Date.now() - startTime
-              monitor.emit(MonitorEvents.QUERY_ERROR, {
-                clientType: 'pg',
-                sql,
-                params,
-                attempt: 1,
-                elapsedTime,
-                error,
-                inTransaction: true,
-              })
-              throw error
-            }
-          },
-          commit: async (): Promise<void> => {
-            try {
-              await client.query('COMMIT')
-              monitor.emit(MonitorEvents.TRANSACTION_COMMIT, {
-                clientType: 'pg',
-              })
-            } finally {
-              client.release()
-            }
-          },
-          rollback: async (): Promise<void> => {
-            try {
-              await client.query('ROLLBACK')
-              monitor.emit(MonitorEvents.TRANSACTION_ROLLBACK, {
-                clientType: 'pg',
-              })
-            } finally {
-              client.release()
-            }
-          },
-        }
-      } catch (error) {
-        client.release()
-        throw error
-      }
-    },
-  }
-}

package/src/monitor/monitor.ts

@@ -1,16 +0,0 @@
-import { EventEmitter } from 'stream'
-
-/**
- * Monitor events
- */
-export enum MonitorEvents {
-  CONNECTION_CREATED = 'connection_created',
-  QUERY_START = 'query_start',
-  QUERY_END = 'query_end',
-  QUERY_ERROR = 'query_error',
-  RETRY_ATTEMPT = 'retry_attempt',
-  TRANSACTION_COMMIT = 'transaction_commit',
-  TRANSACTION_ROLLBACK = 'transaction_rollback',
-}
-
-export const monitor = new EventEmitter()

package/src/setupTests.ts

@@ -1,45 +0,0 @@
-// Jest setup file for star-db-query-builder tests
-
-// Mock console methods to reduce noise in tests
-const originalConsole = { ...console }
-
-beforeAll(() => {
-  // Suppress console.log, console.warn, and console.error during tests
-  jest.spyOn(console, 'log').mockImplementation(() => {})
-  jest.spyOn(console, 'warn').mockImplementation(() => {})
-  jest.spyOn(console, 'error').mockImplementation(() => {})
-})
-
-afterAll(() => {
-  // Restore original console methods
-  console.log = originalConsole.log
-  console.warn = originalConsole.warn
-  console.error = originalConsole.error
-})
-
-// Export test utilities for use in test files
-export const testUtils = {
-  // Helper to create mock database client
-  createMockDbClient: (clientType: 'pg' | 'mysql' = 'pg') => ({
-    clientType,
-    query: jest.fn(),
-    connect: jest.fn(),
-    end: jest.fn(),
-  }),
-
-  // Helper to create sample data
-  createSampleUser: () => ({
-    id: '123e4567-e89b-12d3-a456-426614174000',
-    name: 'John Doe',
-    email: 'john.doe@example.com',
-    status: 'active',
-    created_at: new Date('2023-01-01'),
-    updated_at: new Date('2023-01-01'),
-  }),
-
-  // Helper to create sample conditions
-  createSampleConditions: () => ({
-    status: { operator: '=', value: 'active' },
-    email: { operator: 'ILIKE', value: '%example.com' },
-  }),
-}

package/tsconfig.test.json

@@ -1,21 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "types": [
-      "jest",
-      "node"
-    ],
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": [
-    "src/**/*",
-    "**/*.test.ts",
-    "**/*.spec.ts",
-    "jest.config.ts"
-  ],
-  "exclude": [
-    "dist",
-    "node_modules"
-  ]
-}