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

package/src/db/__tests__/mysqlClient.test.ts

@@ -1,262 +0,0 @@
-import { createMysqlClient } from '../mysqlClient'
-import { createPool, Pool } from 'mysql2/promise'
-
-// Mock mysql2 module
-jest.mock('mysql2/promise', () => ({
-  createPool: jest.fn(),
-}))
-
-// Mock monitor
-jest.mock('../../monitor/monitor', () => ({
-  monitor: {
-    emit: jest.fn(),
-  },
-  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',
-  },
-}))
-
-describe('MySqlClient', () => {
-  let mockPool: jest.Mocked<Pool>
-
-  beforeEach(() => {
-    mockPool = {
-      query: jest.fn(),
-      connect: jest.fn(),
-      end: jest.fn(),
-      execute: jest.fn(),
-      getConnection: jest.fn(),
-      config: {},
-    } as any
-    ;(createPool as jest.MockedFunction<typeof createPool>).mockReturnValue(
-      mockPool
-    )
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('createMysqlClient', () => {
-    it('should return client with correct clientType', () => {
-      const client = createMysqlClient(mockPool)
-
-      expect(client.clientType).toBe('mysql')
-    })
-
-    it('should execute query and return rows', async () => {
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      mockPool.execute.mockResolvedValue([mockRows, []] as any)
-
-      const client = createMysqlClient(mockPool)
-      const result = await client.query('SELECT * FROM users WHERE id = ?', [1])
-
-      expect(mockPool.execute).toHaveBeenCalledWith(
-        'SELECT * FROM users WHERE id = ?',
-        [1]
-      )
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should handle query without parameters', async () => {
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      mockPool.execute.mockResolvedValue([mockRows, []] as any)
-
-      const client = createMysqlClient(mockPool)
-      const result = await client.query('SELECT * FROM users')
-
-      expect(mockPool.execute).toHaveBeenCalledWith(
-        'SELECT * FROM users',
-        undefined
-      )
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should handle empty result set', async () => {
-      mockPool.execute.mockResolvedValue([[], []] as any)
-
-      const client = createMysqlClient(mockPool)
-      const result = await client.query('SELECT * FROM users WHERE id = ?', [
-        999,
-      ])
-
-      expect(result).toEqual([])
-    })
-
-    it('should handle query errors', async () => {
-      const error = new Error('Database connection failed')
-      mockPool.execute.mockRejectedValue(error)
-
-      const client = createMysqlClient(mockPool)
-
-      await expect(client.query('SELECT * FROM users')).rejects.toThrow(
-        'Database connection failed'
-      )
-    })
-
-    it('should handle retry options', async () => {
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      mockPool.execute.mockResolvedValue([mockRows, []] as any)
-
-      const retryOptions = {
-        retries: 3,
-        factor: 2,
-        minTimeout: 1000,
-        maxTimeout: 5000,
-      }
-
-      const client = createMysqlClient(mockPool, retryOptions)
-      const result = await client.query('SELECT * FROM users')
-
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should handle transient errors with retry', async () => {
-      const transientError = new Error('Connection lost')
-      ;(transientError as any).code = 'ECONNRESET'
-
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-
-      // First call fails with transient error, second succeeds
-      mockPool.execute
-        .mockRejectedValueOnce(transientError)
-        .mockResolvedValueOnce([mockRows, []] as any)
-
-      const retryOptions = {
-        retries: 3,
-        factor: 2,
-        minTimeout: 100,
-        maxTimeout: 500,
-      }
-
-      const client = createMysqlClient(mockPool, retryOptions)
-      const result = await client.query('SELECT * FROM users')
-
-      expect(mockPool.execute).toHaveBeenCalledTimes(2)
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should throw non-transient errors immediately', async () => {
-      const permanentError = new Error('Table does not exist')
-      ;(permanentError as any).code = 'ER_NO_SUCH_TABLE'
-
-      mockPool.execute.mockRejectedValue(permanentError)
-
-      const retryOptions = {
-        retries: 3,
-        factor: 2,
-        minTimeout: 100,
-        maxTimeout: 500,
-      }
-
-      const client = createMysqlClient(mockPool, retryOptions)
-
-      await expect(
-        client.query('SELECT * FROM nonexistent_table')
-      ).rejects.toThrow('Table does not exist')
-      expect(mockPool.execute).toHaveBeenCalledTimes(1)
-    })
-
-    describe('beginTransaction', () => {
-      let mockConnection: any
-
-      beforeEach(() => {
-        mockConnection = {
-          execute: jest.fn(),
-          beginTransaction: jest.fn(),
-          commit: jest.fn(),
-          rollback: jest.fn(),
-          release: jest.fn(),
-        }
-        mockPool.getConnection.mockResolvedValue(mockConnection)
-      })
-
-      it('should create a transaction client', async () => {
-        const client = createMysqlClient(mockPool)
-        const transaction = await client.beginTransaction()
-
-        expect(mockPool.getConnection).toHaveBeenCalled()
-        expect(mockConnection.beginTransaction).toHaveBeenCalled()
-        expect(transaction).toHaveProperty('query')
-        expect(transaction).toHaveProperty('commit')
-        expect(transaction).toHaveProperty('rollback')
-      })
-
-      it('should execute queries within transaction', async () => {
-        const mockRows = [{ id: 1, name: 'John Doe' }]
-        mockConnection.execute.mockResolvedValue([mockRows, []])
-
-        const client = createMysqlClient(mockPool)
-        const transaction = await client.beginTransaction()
-        const result = await transaction.query(
-          'SELECT * FROM users WHERE id = ?',
-          [1]
-        )
-
-        expect(mockConnection.execute).toHaveBeenCalledWith(
-          'SELECT * FROM users WHERE id = ?',
-          [1]
-        )
-        expect(result).toEqual(mockRows)
-      })
-
-      it('should commit transaction successfully', async () => {
-        const client = createMysqlClient(mockPool)
-        const transaction = await client.beginTransaction()
-        await transaction.commit()
-
-        expect(mockConnection.commit).toHaveBeenCalled()
-        expect(mockConnection.release).toHaveBeenCalled()
-      })
-
-      it('should rollback transaction on error', async () => {
-        const client = createMysqlClient(mockPool)
-        const transaction = await client.beginTransaction()
-        await transaction.rollback()
-
-        expect(mockConnection.rollback).toHaveBeenCalled()
-        expect(mockConnection.release).toHaveBeenCalled()
-      })
-
-      it('should release connection even if commit fails', async () => {
-        const commitError = new Error('Commit failed')
-        mockConnection.commit.mockRejectedValue(commitError)
-
-        const client = createMysqlClient(mockPool)
-        const transaction = await client.beginTransaction()
-
-        await expect(transaction.commit()).rejects.toThrow('Commit failed')
-        expect(mockConnection.release).toHaveBeenCalled()
-      })
-
-      it('should release connection even if rollback fails', async () => {
-        const rollbackError = new Error('Rollback failed')
-        mockConnection.rollback.mockRejectedValue(rollbackError)
-
-        const client = createMysqlClient(mockPool)
-        const transaction = await client.beginTransaction()
-
-        await expect(transaction.rollback()).rejects.toThrow('Rollback failed')
-        expect(mockConnection.release).toHaveBeenCalled()
-      })
-
-      it('should release connection if beginTransaction fails', async () => {
-        const beginError = new Error('Begin transaction failed')
-        mockConnection.beginTransaction.mockRejectedValue(beginError)
-
-        const client = createMysqlClient(mockPool)
-
-        await expect(client.beginTransaction()).rejects.toThrow(
-          'Begin transaction failed'
-        )
-        expect(mockConnection.release).toHaveBeenCalled()
-      })
-    })
-  })
-})

package/src/db/__tests__/pgClient.test.ts

@@ -1,260 +0,0 @@
-import { createPgClient } from '../pgClient'
-import { Pool } from 'pg'
-
-// Mock pg module
-jest.mock('pg', () => ({
-  Pool: jest.fn(),
-}))
-
-// Mock monitor
-jest.mock('../../monitor/monitor', () => ({
-  monitor: {
-    emit: jest.fn(),
-  },
-  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',
-  },
-}))
-
-describe('PgClient', () => {
-  let mockPool: jest.Mocked<Pool>
-
-  beforeEach(() => {
-    mockPool = {
-      query: jest.fn(),
-      connect: jest.fn(),
-      end: jest.fn(),
-    } as any
-    ;(Pool as jest.MockedClass<typeof Pool>).mockImplementation(() => mockPool)
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('createPgClient', () => {
-    it('should return client with correct clientType', async () => {
-      const client = await createPgClient(mockPool)
-      expect(client.clientType).toBe('pg')
-    })
-
-    it('should execute query and return rows', async () => {
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      mockPool.query.mockResolvedValue({ rows: mockRows, rowCount: 1 } as any)
-      const client = await createPgClient(mockPool)
-      const result = await client.query('SELECT * FROM users WHERE id = $1', [
-        1,
-      ])
-      expect(mockPool.query).toHaveBeenCalledWith(
-        'SELECT * FROM users WHERE id = $1',
-        [1]
-      )
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should handle query without parameters', async () => {
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      mockPool.query.mockResolvedValue({ rows: mockRows, rowCount: 1 } as any)
-      const client = await createPgClient(mockPool)
-      const result = await client.query('SELECT * FROM users')
-      expect(mockPool.query).toHaveBeenCalledWith(
-        'SELECT * FROM users',
-        undefined
-      )
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should handle empty result set', async () => {
-      mockPool.query.mockResolvedValue({ rows: [], rowCount: 0 } as any)
-      const client = await createPgClient(mockPool)
-      const result = await client.query('SELECT * FROM users WHERE id = $1', [
-        999,
-      ])
-      expect(result).toEqual([])
-    })
-
-    it('should handle query errors', async () => {
-      const error = new Error('Database connection failed')
-      mockPool.query.mockRejectedValue(error)
-      const client = await createPgClient(mockPool)
-      await expect(client.query('SELECT * FROM users')).rejects.toThrow(
-        'Database connection failed'
-      )
-    })
-
-    it('should handle retry options', async () => {
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      mockPool.query.mockResolvedValue({ rows: mockRows, rowCount: 1 } as any)
-      const retryOptions = {
-        retries: 3,
-        factor: 2,
-        minTimeout: 1000,
-        maxTimeout: 5000,
-      }
-      const client = await createPgClient(mockPool, retryOptions)
-      const result = await client.query('SELECT * FROM users')
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should handle transient errors with retry', async () => {
-      const transientError = new Error('Connection lost')
-      ;(transientError as any).code = 'ECONNRESET'
-      const mockRows = [{ id: 1, name: 'John Doe' }]
-      // First call fails with transient error, second succeeds
-      mockPool.query
-        .mockRejectedValueOnce(transientError)
-        .mockResolvedValueOnce({ rows: mockRows, rowCount: 1 } as any)
-      const retryOptions = {
-        retries: 3,
-        factor: 2,
-        minTimeout: 100,
-        maxTimeout: 500,
-      }
-      const client = await createPgClient(mockPool, retryOptions)
-      const result = await client.query('SELECT * FROM users')
-      expect(mockPool.query).toHaveBeenCalledTimes(2)
-      expect(result).toEqual(mockRows)
-    })
-
-    it('should throw non-transient errors immediately', async () => {
-      const permanentError = new Error('Table does not exist')
-      ;(permanentError as any).code = 'ER_NO_SUCH_TABLE'
-      mockPool.query.mockRejectedValue(permanentError)
-      const retryOptions = {
-        retries: 3,
-        factor: 2,
-        minTimeout: 100,
-        maxTimeout: 500,
-      }
-      const client = await createPgClient(mockPool, retryOptions)
-      await expect(
-        client.query('SELECT * FROM nonexistent_table')
-      ).rejects.toThrow('Table does not exist')
-      expect(mockPool.query).toHaveBeenCalledTimes(1)
-    })
-
-    it('should install unaccent extension when requested', async () => {
-      mockPool.query
-        .mockResolvedValueOnce({ rows: [], rowCount: 0 } as any) // Extension not found
-        .mockResolvedValueOnce({ rows: [], rowCount: 0 } as any) // Extension created
-        .mockResolvedValueOnce({ rows: [{ id: 1 }], rowCount: 1 } as any) // Query result
-      const client = await createPgClient(mockPool, undefined, undefined, true)
-      await client.query('SELECT * FROM users')
-      expect(mockPool.query).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "SELECT 1 FROM pg_extension WHERE extname = 'unaccent'"
-        )
-      )
-      expect(mockPool.query).toHaveBeenCalledWith(
-        expect.stringContaining('CREATE EXTENSION IF NOT EXISTS unaccent')
-      )
-    })
-
-    describe('beginTransaction', () => {
-      let mockClient: any
-
-      beforeEach(() => {
-        mockClient = {
-          query: jest.fn(),
-          release: jest.fn(),
-        }
-        mockPool.connect.mockResolvedValue(mockClient)
-      })
-
-      it('should create a transaction client', async () => {
-        const client = await createPgClient(mockPool)
-        const transaction = await client.beginTransaction()
-
-        expect(mockPool.connect).toHaveBeenCalled()
-        expect(mockClient.query).toHaveBeenCalledWith('BEGIN')
-        expect(transaction).toHaveProperty('query')
-        expect(transaction).toHaveProperty('commit')
-        expect(transaction).toHaveProperty('rollback')
-      })
-
-      it('should execute queries within transaction', async () => {
-        const mockRows = [{ id: 1, name: 'John Doe' }]
-        mockClient.query.mockResolvedValue({ rows: mockRows, rowCount: 1 })
-
-        const client = await createPgClient(mockPool)
-        const transaction = await client.beginTransaction()
-        const result = await transaction.query(
-          'SELECT * FROM users WHERE id = $1',
-          [1]
-        )
-
-        expect(mockClient.query).toHaveBeenCalledWith(
-          'SELECT * FROM users WHERE id = $1',
-          [1]
-        )
-        expect(result).toEqual(mockRows)
-      })
-
-      it('should commit transaction successfully', async () => {
-        const client = await createPgClient(mockPool)
-        const transaction = await client.beginTransaction()
-        await transaction.commit()
-
-        expect(mockClient.query).toHaveBeenCalledWith('COMMIT')
-        expect(mockClient.release).toHaveBeenCalled()
-      })
-
-      it('should rollback transaction on error', async () => {
-        const client = await createPgClient(mockPool)
-        const transaction = await client.beginTransaction()
-        await transaction.rollback()
-
-        expect(mockClient.query).toHaveBeenCalledWith('ROLLBACK')
-        expect(mockClient.release).toHaveBeenCalled()
-      })
-
-      it('should release connection even if commit fails', async () => {
-        const commitError = new Error('Commit failed')
-
-        // Mock the sequence: BEGIN succeeds, COMMIT fails
-        mockClient.query
-          .mockResolvedValueOnce({ rows: [], rowCount: 0 }) // BEGIN
-          .mockRejectedValueOnce(commitError) // COMMIT
-
-        const client = await createPgClient(mockPool)
-        const transaction = await client.beginTransaction()
-
-        await expect(transaction.commit()).rejects.toThrow('Commit failed')
-        expect(mockClient.release).toHaveBeenCalled()
-      })
-
-      it('should release connection even if rollback fails', async () => {
-        const rollbackError = new Error('Rollback failed')
-
-        // Mock the sequence: BEGIN succeeds, ROLLBACK fails
-        mockClient.query
-          .mockResolvedValueOnce({ rows: [], rowCount: 0 }) // BEGIN
-          .mockRejectedValueOnce(rollbackError) // ROLLBACK
-
-        const client = await createPgClient(mockPool)
-        const transaction = await client.beginTransaction()
-
-        await expect(transaction.rollback()).rejects.toThrow('Rollback failed')
-        expect(mockClient.release).toHaveBeenCalled()
-      })
-
-      it('should release connection if BEGIN fails', async () => {
-        const beginError = new Error('Begin transaction failed')
-        mockClient.query.mockRejectedValue(beginError)
-
-        const client = await createPgClient(mockPool)
-
-        await expect(client.beginTransaction()).rejects.toThrow(
-          'Begin transaction failed'
-        )
-        expect(mockClient.release).toHaveBeenCalled()
-      })
-    })
-  })
-})

package/src/db/initDb.ts

@@ -1,181 +0,0 @@
-import { Pool, PoolConfig } from 'pg'
-import { createPool as createMySqlPool } from 'mysql2/promise'
-import { createPgClient } from './pgClient'
-import { createMysqlClient } from './mysqlClient'
-import { IDatabaseClient } from './IDatabaseClient'
-import { DBClients, RetryOptions } from '../core/types'
-
-const dbClients: Record<string, IDatabaseClient> = {}
-const defaultName = 'default'
-
-/**
- * Initialize a database client with the specified configuration
- *
- * @template T - The type of connection options (PoolConfig for PostgreSQL or PoolOptions for MySQL)
- * @param config - Configuration object for database initialization
- * @param config.name - Optional name for the database client (defaults to 'default')
- * @param config.type - Database type ('pg' for PostgreSQL or 'mysql' for MySQL)
- * @param config.options - Connection options specific to the database type
- * @param config.retryOptions - Optional retry configuration for failed queries
- * @param config.installUnaccentExtension - Optional flag to install unaccent extension (PostgreSQL only)
- * @returns Promise<void> - Resolves when the database client is successfully initialized
- *
- * @throws {Error} When type is not provided or is invalid
- * @throws {Error} When connection options are not provided
- * @throws {Error} When an unsupported database type is specified
- *
- * @example
- * // Initialize PostgreSQL client
- * await initDb({
- *   name: 'myPostgresDb',
- *   type: 'pg',
- *   options: {
- *     host: 'localhost',
- *     port: 5432,
- *     database: 'mydb',
- *     user: 'user',
- *     password: 'password'
- *   },
- *   retryOptions: { maxRetries: 3, delay: 1000 },
- *   installUnaccentExtension: true
- * });
- *
- * @example
- * // Initialize MySQL client
- * await initDb({
- *   name: 'myMysqlDb',
- *   type: 'mysql',
- *   options: {
- *     host: 'localhost',
- *     port: 3306,
- *     database: 'mydb',
- *     user: 'user',
- *     password: 'password'
- *   },
- *   retryOptions: { maxRetries: 3, delay: 1000 }
- * });
- */
-export const initDb = async <T>(config: {
-  name?: string
-  type: DBClients
-  options: T
-  retryOptions?: RetryOptions
-  installUnaccentExtension?: boolean
-}): Promise<void> => {
-  if (!config.type)
-    throw new Error('Type is required. Accept values: pg | mysql')
-
-  if (!config.options) throw new Error('Connection options is required')
-
-  if (config.type === 'pg') {
-    const poolConfig = config.options as unknown as PoolConfig
-    const pool = new Pool(config.options)
-    dbClients[config.name || defaultName] = await createPgClient(
-      pool,
-      config.retryOptions,
-      poolConfig,
-      config.installUnaccentExtension
-    )
-
-    console.log(
-      `@starbemtech/star-db-query-builder: Postgres db client "${config.name}" created successfully`
-    )
-  } else if (config.type === 'mysql') {
-    const pool = createMySqlPool(config.options)
-    dbClients[config.name || defaultName] = createMysqlClient(
-      pool,
-      config.retryOptions
-    )
-
-    console.info(
-      `@starbemtech/star-db-query-builder: Postgres db client "${config.name}" created successfully`
-    )
-  } else {
-    throw new Error('Unsupported database type')
-  }
-}
-
-/**
- * Initialize a database client with the specified configuration
- *
- * @template T - The type of connection options (PoolConfig for PostgreSQL or PoolOptions for MySQL)
- * @param config - Configuration object for database initialization
- * @param config.name - Optional name for the database client (defaults to 'default')
- * @param config.type - Database type ('pg' for PostgreSQL or 'mysql' for MySQL)
- * @param config.options - Connection options specific to the database type
- * @param config.retryOptions - Optional retry configuration for failed queries
- * @param config.installUnaccentExtension - Optional flag to install unaccent extension (PostgreSQL only)
- * @returns Promise<void> - Resolves when the database client is successfully initialized
- *
- * @throws {Error} When database type is not provided or is invalid
- * @throws {Error} When connection options are not provided
- * @throws {Error} When an unsupported database type is specified
- *
- * @example
- * // Initialize PostgreSQL client
- * await initDb({
- *   name: 'myPostgresDb',
- *   type: 'pg',
- *   options: {
- *     host: 'localhost',
- *     port: 5432,
- *     database: 'mydb',
- *     user: 'user',
- *     password: 'password'
- *   },
- *   retryOptions: { maxRetries: 3, delay: 1000 },
- *   installUnaccentExtension: true
- * });
- *
- * @example
- * // Initialize MySQL client
- * await initDb({
- *   name: 'myMysqlDb',
- *   type: 'mysql',
- *   options: {
- *     host: 'localhost',
- *     port: 3306,
- *     database: 'mydb',
- *     user: 'user',
- *     password: 'password'
- *   },
- *   retryOptions: { maxRetries: 3, delay: 1000 }
- * });
- */
-export const getDbClient = (name?: string): IDatabaseClient => {
-  const client = dbClients[name || defaultName]
-  if (!client) {
-    throw new Error(`Database client "${name}" is not initialized`)
-  }
-
-  return client
-}
-
-/**
- * Retrieves a specific database client by name
- *
- * @param name - Optional name of the database client to retrieve. If not provided, returns the default client
- * @returns IDatabaseClient - The requested database client instance
- *
- * @throws {Error} When the specified database client name is not found or not initialized
- *
- * @example
- * // Get default database client
- * const defaultClient = getDbClient();
- *
- * @example
- * // Get specific database client by name
- * const postgresClient = getDbClient('myPostgresDb');
- * const mysqlClient = getDbClient('myMysqlDb');
- *
- * @example
- * // Handle error when client is not found
- * try {
- *   const client = getDbClient('nonExistentDb');
- * } catch (error) {
- *   console.error('Database client not found:', error.message);
- * }
- */
-export const getAllDbClients = (): Record<string, IDatabaseClient> => {
-  return dbClients
-}