@take-out/postgres 0.0.28

package/src/migrate.ts

@@ -0,0 +1,192 @@
+/**
+ * Custom migration script - why?
+ * Well migration scripts aren't so complex, and we haven't found a simple enough library
+ * to deserve a new dependency. We like this setup because we can customize it easily
+ * and it's pretty easy to understand.
+ *
+ * This migration system handles both custom TypeScript migrations and
+ * SQL migrations generated by Drizzle.
+ */
+
+import { basename } from 'node:path'
+import type { PoolClient } from 'pg'
+import { getDBClient } from './helpers/getDBClient'
+
+export type Migration = {
+  name: string
+  up?: (client: PoolClient) => Promise<void>
+}
+
+export type MigrateOptions = {
+  connectionString: string
+  migrationsGlob: Record<string, () => Promise<unknown>>
+  createDatabases?: string[]
+  onMigrationComplete?: () => Promise<void>
+  gitSha?: string
+  cvrDb?: string
+  changeDb?: string
+}
+
+// check if we're running in AWS Lambda or other serverless environment
+const isServerless = !!(
+  process.env.AWS_LAMBDA_FUNCTION_NAME ||
+  process.env.AWS_LAMBDA_RUNTIME_API ||
+  process.env.LAMBDA_RUNTIME_DIR ||
+  process.env.IS_SERVERLESS
+)
+
+export async function migrate(options: MigrateOptions) {
+  const {
+    connectionString,
+    migrationsGlob,
+    createDatabases = [],
+    onMigrationComplete,
+    gitSha,
+    cvrDb,
+    changeDb,
+  } = options
+
+  console.info(`Running migrations${gitSha ? ` for git version: ${gitSha}` : ''}`)
+
+  const client = await getDBClient({ connectionString })
+
+  const hasDB = async (name: string) => {
+    const result = !!(
+      await client.query(`
+        SELECT 1 FROM pg_database WHERE datname = '${name}'
+      `)
+    ).rows.length
+
+    console.info(result ? `${name} db exists` : `creating ${name} db`)
+
+    return result
+  }
+
+  // create zero databases if specified
+  if (cvrDb || changeDb) {
+    if (!cvrDb) {
+      throw new Error(`Missing cvrDb`)
+    }
+
+    const zeroDBNames = [basename(cvrDb || ''), basename(changeDb || '')].filter(Boolean)
+
+    for (const name of zeroDBNames) {
+      if (!(await hasDB(name))) {
+        await client.query(`CREATE DATABASE ${name};`)
+      }
+    }
+  }
+
+  // create additional databases if specified
+  for (const dbUrl of createDatabases) {
+    const name = basename(dbUrl)
+    if (!(await hasDB(name))) {
+      await client.query(`CREATE DATABASE ${name};`)
+    }
+  }
+
+  try {
+    await client.query('BEGIN')
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS migrations (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        run_on TIMESTAMP NOT NULL DEFAULT NOW()
+      )
+    `)
+
+    const appliedMigrations = await client.query('SELECT name FROM migrations')
+    const appliedMigrationNames = new Set(appliedMigrations.rows.map((row) => row.name))
+
+    // get TypeScript migrations
+    const tsMigrationsSorted = Object.entries(migrationsGlob)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([file, run]) => ({
+        name: basename(file).replace('.ts', ''),
+        run,
+      }))
+      .filter(({ name }) => /^[\d]+/.test(name))
+
+    console.info(`Found ${tsMigrationsSorted.length} TypeScript migrations`)
+
+    // process TypeScript migrations
+    const tsMigrations: Migration[] = await Promise.all(
+      tsMigrationsSorted.map(async ({ name, run }) => {
+        if (appliedMigrationNames.has(name)) {
+          console.info(`TypeScript migration applied already: ${name}`)
+          return null
+        }
+        try {
+          const migration = (await run()) as object
+          return { ...migration, name }
+        } catch (error) {
+          console.error(`Failed to load TypeScript migration ${name}:`, error)
+          throw error
+        }
+      })
+    ).then((migrations) => migrations.filter(Boolean) as Migration[])
+
+    // combine TypeScript and SQL migrations, sorted by name to ensure correct order
+    const migrations = [...tsMigrations].sort((a, b) => a.name.localeCompare(b.name))
+
+    if (!migrations.length) {
+      console.info(`No migrations to apply!`)
+      await client.query('COMMIT')
+    } else {
+      for (const migration of migrations) {
+        // don't try catch here, we want to exit and rollback all migrations if one fails
+        console.info(`Migrating: ${migration.name}`)
+
+        if (migration.up) {
+          // TypeScript migration
+          console.info(`Applying migration: ${migration.name}`)
+          await migration.up(client)
+        }
+
+        await client.query('INSERT INTO migrations (name) VALUES ($1)', [migration.name])
+        console.info(`Successfully applied migration: ${migration.name}`)
+      }
+
+      await client.query('COMMIT')
+      console.info(`Successfully committed all migrations`)
+    }
+  } catch (e) {
+    console.error(`Migration failed, rolling back:`, e)
+    await client.query('ROLLBACK')
+    console.info(`Releasing client connection...`)
+    try {
+      client.release(false)
+    } catch (releaseErr) {
+      console.error(`Error releasing connection after rollback:`, releaseErr)
+    }
+    throw e
+  }
+
+  if (onMigrationComplete) {
+    await onMigrationComplete()
+  }
+
+  console.info(`Releasing client connection...`)
+  try {
+    // don't destroy the connection forcefully - let it return to pool gracefully
+    client.release(false)
+  } catch (err) {
+    console.error(`Error releasing connection gracefully, trying to destroy:`, err)
+    try {
+      client.release(true)
+    } catch (destroyErr) {
+      console.error(`Error destroying connection:`, destroyErr)
+    }
+  }
+
+  console.info(`🙌 Done migrating`)
+
+  exitProcess()
+}
+
+function exitProcess() {
+  if (typeof process === 'undefined') return
+  // lambda was complaining about process.exit
+  if (isServerless) return
+  process.exit(0)
+}

package/src/scripts/build-migrations.ts

@@ -0,0 +1,66 @@
+import { execSync } from 'node:child_process'
+import path from 'node:path'
+
+export type BuildMigrationsOptions = {
+  migrationsDir: string
+  outFile?: string
+  target?: string
+  aliases?: Record<string, string>
+}
+
+export async function buildMigrations(options: BuildMigrationsOptions) {
+  const {
+    migrationsDir,
+    outFile = 'migrate-dist.js',
+    target = 'node22',
+    aliases = {},
+  } = options
+
+  const { build } = await import('vite')
+
+  const migrateFile = path.join(migrationsDir, '..', 'migrate.ts')
+
+  const result = await build({
+    configFile: false,
+    resolve: {
+      alias: aliases,
+    },
+    define: {
+      'process.env.GIT_SHA': JSON.stringify(
+        execSync('git rev-parse HEAD').toString().trim()
+      ),
+    },
+    build: {
+      outDir: path.dirname(migrateFile),
+      target,
+      minify: false,
+      emptyOutDir: false,
+      copyPublicDir: false,
+      lib: {
+        name: 'migrate',
+        formats: ['es'],
+        entry: migrateFile,
+      },
+      rollupOptions: {
+        external: (id) => {
+          // externalize all node modules and node: imports
+          if (id.startsWith('node:') || id === 'pg') return true
+          // externalize all absolute paths (like aliases)
+          if (id.startsWith('/')) return false
+          // externalize node_modules
+          if (!id.startsWith('.') && !id.startsWith('/')) return true
+          return false
+        },
+        output: {
+          format: 'es',
+          inlineDynamicImports: true,
+          exports: 'named',
+          entryFileNames: outFile,
+        },
+      },
+    },
+  })
+
+  console.info(`✓ Built migration bundle: ${outFile}`)
+  return result
+}

package/src/scripts/drizzle-migrations-sync.ts

@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+
+/**
+ * This script scans for SQL files in migrations directory,
+ * creates corresponding TypeScript migration files,
+ * and imports the SQL with ?raw
+ */
+
+import { readdir, writeFile, stat, rename } from 'node:fs/promises'
+import { join, basename, extname } from 'node:path'
+import { existsSync } from 'node:fs'
+
+export type DrizzleSyncOptions = {
+  migrationsDir: string
+}
+
+/**
+ * Extracts the numeric prefix from a migration filename
+ */
+function getMigrationNumber(filename: string): number | null {
+  const match = filename.match(/^(\d+)/)
+  return match && match[1] ? Number.parseInt(match[1], 10) : null
+}
+
+/**
+ * Finds the highest migration number in the directory
+ */
+async function getHighestMigrationNumber(dir: string): Promise<number> {
+  const files = await readdir(dir)
+  let highest = -1
+
+  for (const file of files) {
+    const num = getMigrationNumber(file)
+    if (num !== null && num > highest) {
+      highest = num
+    }
+  }
+
+  return highest
+}
+
+/**
+ * Renames newly generated drizzle migrations to use correct sequential numbering
+ */
+async function renameNewDrizzleMigrations(
+  migrationsPath: string,
+  sqlFiles: string[]
+): Promise<string[]> {
+  const drizzlePattern = /^(\d{4})_[a-z]+_[a-z_]+\.sql$/
+  const files = await readdir(migrationsPath)
+
+  // get the highest existing migration number
+  const highestNumber = await getHighestMigrationNumber(migrationsPath)
+
+  // find new drizzle SQL files (without corresponding .ts files yet)
+  const newDrizzleSqlFiles = sqlFiles.filter((file) => {
+    if (!drizzlePattern.test(file)) return false
+    const tsFile = file.replace('.sql', '.ts')
+    return !files.includes(tsFile)
+  })
+
+  if (newDrizzleSqlFiles.length === 0) return sqlFiles
+
+  // group by migration number
+  const migrationGroups = new Map<string, string[]>()
+  for (const file of newDrizzleSqlFiles) {
+    const num = file.substring(0, 4)
+    if (!migrationGroups.has(num)) {
+      migrationGroups.set(num, [])
+    }
+    migrationGroups.get(num)!.push(file)
+  }
+
+  let nextNumber = highestNumber + 1
+  const renamedFiles: string[] = []
+
+  // process each group of new migrations
+  for (const [originalNum, groupFiles] of migrationGroups) {
+    const drizzleNum = Number.parseInt(originalNum, 10)
+
+    // if drizzle's number is less than or equal to our highest, we need to renumber
+    if (drizzleNum <= highestNumber) {
+      const newNumStr = nextNumber.toString().padStart(4, '0')
+
+      console.info(`Renumbering new drizzle migration ${originalNum} to ${newNumStr}`)
+
+      for (const file of groupFiles) {
+        const newName = file.replace(/^\d{4}/, newNumStr)
+        const oldPath = join(migrationsPath, file)
+        const newPath = join(migrationsPath, newName)
+
+        await rename(oldPath, newPath)
+        console.info(`  Renamed ${file} -> ${newName}`)
+        renamedFiles.push(newName)
+      }
+
+      // also rename the meta snapshot if it exists
+      const metaDir = join(migrationsPath, 'meta')
+      if (existsSync(metaDir)) {
+        const metaFiles = await readdir(metaDir)
+        const snapshotFile = `${originalNum}_snapshot.json`
+        if (metaFiles.includes(snapshotFile)) {
+          const newSnapshotName = `${newNumStr}_snapshot.json`
+          await rename(join(metaDir, snapshotFile), join(metaDir, newSnapshotName))
+          console.info(`  Renamed meta/${snapshotFile} -> meta/${newSnapshotName}`)
+        }
+      }
+
+      nextNumber++
+    } else {
+      // keep files that don't need renaming
+      renamedFiles.push(...groupFiles)
+    }
+  }
+
+  // return updated list of SQL files (with renamed files + unchanged files)
+  return sqlFiles.map((file) => {
+    const idx = newDrizzleSqlFiles.indexOf(file)
+    if (idx !== -1) {
+      // find what this file was renamed to
+      for (const renamed of renamedFiles) {
+        if (renamed.includes(file.substring(5))) {
+          // match by the descriptive part after the number
+          return renamed
+        }
+      }
+    }
+    return file
+  })
+}
+
+export async function syncDrizzleMigrations(options: DrizzleSyncOptions) {
+  const { migrationsDir } = options
+
+  // get all sql files in the migrations directory
+  const files = await readdir(migrationsDir)
+  let sqlFiles = files.filter((file) => extname(file) === '.sql')
+
+  console.info(`Found ${sqlFiles.length} SQL files to convert to migrations.`)
+
+  // rename any new drizzle migrations to continue from the highest number
+  sqlFiles = await renameNewDrizzleMigrations(migrationsDir, sqlFiles)
+
+  // for each sql file, create a typescript migration
+  for (const sqlFile of sqlFiles) {
+    const baseName = basename(sqlFile, '.sql')
+    const tsFileName = `${baseName}.ts`
+    const tsFilePath = join(migrationsDir, tsFileName)
+
+    // skip if typescript file already exists
+    if (existsSync(tsFilePath)) {
+      const sqlStat = await stat(join(migrationsDir, sqlFile))
+      const tsStat = await stat(tsFilePath)
+
+      if (tsStat.mtimeMs > sqlStat.mtimeMs) {
+        continue
+      }
+
+      console.info(`Updating ${tsFileName} as SQL file has been modified.`)
+    } else {
+      console.info(`Creating ${tsFileName}`)
+    }
+
+    // generate the migration content
+    const migrationContent = `import type { PoolClient } from 'pg'
+import sql from './${sqlFile}?raw'
+
+export async function up(client: PoolClient) {
+  await client.query(sql)
+}
+`
+
+    // write the typescript file
+    await writeFile(tsFilePath, migrationContent)
+    console.info(`Successfully created ${tsFileName}`)
+  }
+
+  console.info('Migration sync completed.')
+}

package/src/scripts/migration-add.ts

@@ -0,0 +1,54 @@
+import { join } from 'node:path'
+import { readdirSync, writeFileSync } from 'node:fs'
+
+export type MigrationAddOptions = {
+  migrationsDir: string
+  name?: string
+}
+
+const commonWords = ['sapphire', 'emerald', 'ruby', 'amber', 'topaz', 'onyx', 'pearl']
+
+export function addMigration(options: MigrationAddOptions): string {
+  const { migrationsDir, name } = options
+
+  // if no name is provided, pick a random one from common words
+  const migrationName =
+    name || commonWords[Math.floor(Math.random() * commonWords.length)]!
+
+  // read all files in the migrations directory
+  const files = readdirSync(migrationsDir)
+
+  // find the highest migration number from both .ts and .sql files
+  const migrationRegex = /^(\d+)[-_].*\.(ts|sql)$/
+  let maxNumber = 0
+  for (const file of files) {
+    const match = file.match(migrationRegex)
+    if (match?.[1]) {
+      const num = Number.parseInt(match[1], 10)
+      if (!Number.isNaN(num) && num > maxNumber) {
+        maxNumber = num
+      }
+    }
+  }
+
+  // calculate the next migration number and pad to 4 digits
+  const nextNumber = (maxNumber + 1).toString().padStart(4, '0')
+  const newFilename = `${nextNumber}-${migrationName}.ts`
+  const newFilePath = join(migrationsDir, newFilename)
+
+  // create a template for custom TypeScript migrations
+  const templateContent = `import type { PoolClient } from 'pg'
+
+export async function up(client: PoolClient) {
+  // implementation for applying this migration
+}
+`
+
+  // write the template to the new file
+  writeFileSync(newFilePath, templateContent)
+
+  console.info(`Created custom migration: ${newFilePath}`)
+  console.info(`For Drizzle schema migrations, run 'drizzle-kit generate' instead`)
+
+  return newFilePath
+}

package/src/scripts/pg_dump.ts

@@ -0,0 +1,46 @@
+export type PgDumpOptions = {
+  connectionString?: string
+  host?: string
+  port?: number
+  database?: string
+  user?: string
+  password?: string
+  args?: string[]
+}
+
+export function runPgDump(options: PgDumpOptions = {}) {
+  const { connectionString, host, port, database, user, password, args = [] } = options
+
+  const env: Record<string, string> = {
+    ...process.env,
+  } as any
+
+  if (connectionString) {
+    // parse connection string and set individual env vars
+    const url = new URL(connectionString)
+    env.PGHOST = url.hostname
+    env.PGPORT = url.port || '5432'
+    env.PGDATABASE = url.pathname.slice(1)
+    env.PGUSER = url.username
+    if (url.password) {
+      env.PGPASSWORD = url.password
+    }
+  } else {
+    if (host) env.PGHOST = host
+    if (port) env.PGPORT = port.toString()
+    if (database) env.PGDATABASE = database
+    if (user) env.PGUSER = user
+    if (password) env.PGPASSWORD = password
+  }
+
+  console.info(`Running pg_dump on postgres ${env.PGHOST}/${env.PGDATABASE}`)
+
+  const result = Bun.spawnSync(['pg_dump', ...args], {
+    stdin: 'ignore',
+    stdout: 'inherit',
+    stderr: 'inherit',
+    env,
+  })
+
+  return result.exitCode
+}

package/src/scripts/psql.ts

@@ -0,0 +1,51 @@
+export type PsqlOptions = {
+  connectionString?: string
+  host?: string
+  port?: number
+  database?: string
+  user?: string
+  password?: string
+  query?: string
+}
+
+export function runPsql(options: PsqlOptions = {}) {
+  const { connectionString, host, port, database, user, password, query } = options
+
+  const env: Record<string, string> = {
+    ...process.env,
+  } as any
+
+  if (connectionString) {
+    // parse connection string and set individual env vars
+    const url = new URL(connectionString)
+    env.PGHOST = url.hostname
+    env.PGPORT = url.port || '5432'
+    env.PGDATABASE = url.pathname.slice(1)
+    env.PGUSER = url.username
+    if (url.password) {
+      env.PGPASSWORD = url.password
+    }
+  } else {
+    if (host) env.PGHOST = host
+    if (port) env.PGPORT = port.toString()
+    if (database) env.PGDATABASE = database
+    if (user) env.PGUSER = user
+    if (password) env.PGPASSWORD = password
+  }
+
+  const args: string[] = []
+  if (query) {
+    args.push('-c', query)
+  }
+
+  console.info(`Connecting to postgres ${env.PGHOST}/${env.PGDATABASE}`)
+
+  const result = Bun.spawnSync(['psql', ...args], {
+    stdin: 'ignore',
+    stdout: 'inherit',
+    stderr: 'inherit',
+    env,
+  })
+
+  return result.exitCode
+}

package/src/sql.ts

@@ -0,0 +1,36 @@
+import type { Pool, QueryResult } from 'pg'
+import { ellipsis } from '@take-out/helpers'
+
+export type SqlQuery = {
+  text: string
+  values: any[]
+}
+
+export const createSql = (pool: Pool) => {
+  return (strings: TemplateStringsArray, ...values: any[]): Promise<QueryResult<any>> => {
+    const text = strings.reduce((result, str, i) => {
+      return result + str + (i < values.length ? `$${i + 1}` : '')
+    }, '')
+
+    console.info(`sql: ${ellipsis(text, 80)}`)
+
+    return pool.query(text.trim(), values)
+  }
+}
+
+// default export for backward compatibility
+let defaultPool: Pool | null = null
+
+export const setDefaultPool = (pool: Pool) => {
+  defaultPool = pool
+}
+
+export const sql = (
+  strings: TemplateStringsArray,
+  ...values: any[]
+): Promise<QueryResult<any>> => {
+  if (!defaultPool) {
+    throw new Error('No default pool set. Call setDefaultPool() first or use createSql()')
+  }
+  return createSql(defaultPool)(strings, ...values)
+}

package/types/build.d.ts

@@ -0,0 +1,2 @@
+export { buildMigrations } from './scripts/build-migrations';
+//# sourceMappingURL=build.d.ts.map

package/types/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA"}

package/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/types/createServerHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { Pool } from 'pg';
+import { createSql } from './sql';
+import { getDBClient, type GetDBClientOptions } from './helpers/getDBClient';
+export type ServerHelpers = {
+    sql: ReturnType<typeof createSql>;
+    getDBClient: (options?: Omit<GetDBClientOptions, 'pool' | 'connectionString'>) => ReturnType<typeof getDBClient>;
+};
+export declare function createServerHelpers(pool: Pool): ServerHelpers;
+//# sourceMappingURL=createServerHelpers.d.ts.map

package/types/createServerHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServerHelpers.d.ts","sourceRoot":"","sources":["../src/createServerHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAA;AAC9B,OAAO,EAAE,SAAS,EAAkB,MAAM,OAAO,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAE5E,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,CAAA;IACjC,WAAW,EAAE,CACX,OAAO,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,kBAAkB,CAAC,KAC5D,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA;CACpC,CAAA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,CAQ7D"}

package/types/helpers/chunkedQuery.d.ts

@@ -0,0 +1,17 @@
+import type { PoolClient, QueryResultRow } from 'pg';
+interface ChunkedQueryOptions {
+    chunkSize?: number;
+    onProgress?: (processed: number, total: number) => void;
+}
+/**
+ * Process database records in chunks to avoid memory issues with large datasets
+ */
+export declare function processInChunks<T extends QueryResultRow = QueryResultRow>(client: PoolClient, query: string, processor: (rows: T[]) => Promise<void>, options?: ChunkedQueryOptions): Promise<void>;
+/**
+ * Update records in chunks with a transformer function
+ */
+export declare function updateInChunks<T extends QueryResultRow & {
+    id: string;
+}>(client: PoolClient, tableName: string, selectQuery: string, transformer: (row: T) => Promise<Partial<T> | null>, options?: ChunkedQueryOptions): Promise<number>;
+export {};
+//# sourceMappingURL=chunkedQuery.d.ts.map

package/types/helpers/chunkedQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkedQuery.d.ts","sourceRoot":"","sources":["../../src/helpers/chunkedQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,IAAI,CAAA;AAEpD,UAAU,mBAAmB;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACxD;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EAC7E,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,EACvC,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC,CAoCf;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC5E,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EACnD,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,MAAM,CAAC,CA4BjB"}

package/types/helpers/getDBClient.d.ts

@@ -0,0 +1,11 @@
+import pg, { type Pool, type PoolClient } from 'pg';
+export type GetDBClientOptions = {
+    pool?: Pool;
+    connectionString?: string;
+    retries?: number;
+    onRetry?: (error: Error, attempt: number) => void;
+};
+export declare function getDBClient(options?: GetDBClientOptions): Promise<PoolClient>;
+export declare function queryDb(queryText: string, params?: any[], options?: GetDBClientOptions): Promise<pg.QueryResult<any>>;
+export declare function getNewClient(options?: GetDBClientOptions): Promise<pg.Client>;
+//# sourceMappingURL=getDBClient.d.ts.map