singulio-postgres 1.1.0

package/dist/client.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @singulio/postgres - PostgreSQL Client
+ * Thin wrapper around bun:postgres native client
+ */
+import type { PostgresConfig, QueryResult, QueryRow, Logger } from './types.js';
+/**
+ * PostgreSQL client wrapping Bun's native postgres driver
+ */
+export declare class PostgresClient {
+    private connectionString;
+    private logger?;
+    private connected;
+    constructor(config: PostgresConfig | string, logger?: Logger);
+    private buildConnectionString;
+    /**
+     * Execute a SQL query with parameters
+     */
+    query<T = QueryRow>(queryText: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Execute a query and return the first row or null
+     */
+    queryOne<T = QueryRow>(queryText: string, params?: unknown[]): Promise<T | null>;
+    /**
+     * Execute a query and return all rows
+     */
+    queryAll<T = QueryRow>(queryText: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Execute a command (INSERT/UPDATE/DELETE) and return affected row count
+     */
+    execute(queryText: string, params?: unknown[]): Promise<number>;
+    /**
+     * Check if connected and working
+     */
+    ping(): Promise<boolean>;
+    /**
+     * Get server version
+     */
+    version(): Promise<string>;
+    /**
+     * Close all connections (for bun:postgres this is mostly a no-op as it manages connections)
+     */
+    close(): Promise<void>;
+    /**
+     * Get connection string (for debugging, sensitive parts masked)
+     */
+    get maskedConnectionString(): string;
+}
+/**
+ * Create a new PostgresClient instance
+ */
+export declare function createClient(config: PostgresConfig | string, logger?: Logger): PostgresClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEhF;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,cAAc,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAM5D,OAAO,CAAC,qBAAqB;IAgC7B;;OAEG;IACG,KAAK,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IA8BzF;;OAEG;IACG,QAAQ,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAKtF;;OAEG;IACG,QAAQ,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAKjF;;OAEG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAKrE;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAS9B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAKhC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;OAEG;IACH,IAAI,sBAAsB,IAAI,MAAM,CAEnC;CACF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAE7F"}

package/dist/client.js

@@ -0,0 +1,127 @@
+/**
+ * @singulio/postgres - PostgreSQL Client
+ * Thin wrapper around bun:postgres native client
+ */
+import { sql } from 'bun';
+/**
+ * PostgreSQL client wrapping Bun's native postgres driver
+ */
+export class PostgresClient {
+    connectionString;
+    logger;
+    connected = false;
+    constructor(config, logger) {
+        this.connectionString =
+            typeof config === 'string' ? config : this.buildConnectionString(config);
+        this.logger = logger;
+    }
+    buildConnectionString(config) {
+        if (config.connectionString)
+            return config.connectionString;
+        const { host = 'localhost', port = 5432, database = 'postgres', user = 'postgres', password = '', ssl, applicationName, } = config;
+        let connStr = `postgres://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}:${port}/${database}`;
+        const params = [];
+        if (ssl === true || ssl === 'require') {
+            params.push('sslmode=require');
+        }
+        else if (ssl === 'prefer') {
+            params.push('sslmode=prefer');
+        }
+        if (applicationName) {
+            params.push(`application_name=${encodeURIComponent(applicationName)}`);
+        }
+        if (params.length > 0) {
+            connStr += '?' + params.join('&');
+        }
+        return connStr;
+    }
+    /**
+     * Execute a SQL query with parameters
+     */
+    async query(queryText, params) {
+        const start = performance.now();
+        try {
+            // Use Bun's sql tagged template for parameterized queries
+            const result = await sql.unsafe(queryText, params ?? []);
+            const latency = performance.now() - start;
+            this.logger?.debug('Query executed', {
+                query: queryText.substring(0, 100),
+                params: params?.length ?? 0,
+                rows: result.length,
+                latencyMs: latency.toFixed(2),
+            });
+            return {
+                rows: result,
+                rowCount: result.length,
+            };
+        }
+        catch (error) {
+            const latency = performance.now() - start;
+            this.logger?.error('Query failed', {
+                query: queryText.substring(0, 100),
+                error: error instanceof Error ? error.message : String(error),
+                latencyMs: latency.toFixed(2),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Execute a query and return the first row or null
+     */
+    async queryOne(queryText, params) {
+        const result = await this.query(queryText, params);
+        return result.rows[0] ?? null;
+    }
+    /**
+     * Execute a query and return all rows
+     */
+    async queryAll(queryText, params) {
+        const result = await this.query(queryText, params);
+        return result.rows;
+    }
+    /**
+     * Execute a command (INSERT/UPDATE/DELETE) and return affected row count
+     */
+    async execute(queryText, params) {
+        const result = await this.query(queryText, params);
+        return result.rowCount;
+    }
+    /**
+     * Check if connected and working
+     */
+    async ping() {
+        try {
+            const result = await sql `SELECT 1 as ok`;
+            return result.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get server version
+     */
+    async version() {
+        const result = await sql `SELECT version()`;
+        return result[0]?.version ?? 'unknown';
+    }
+    /**
+     * Close all connections (for bun:postgres this is mostly a no-op as it manages connections)
+     */
+    async close() {
+        this.connected = false;
+        this.logger?.info('PostgresClient closed');
+    }
+    /**
+     * Get connection string (for debugging, sensitive parts masked)
+     */
+    get maskedConnectionString() {
+        return this.connectionString.replace(/:([^@]+)@/, ':***@');
+    }
+}
+/**
+ * Create a new PostgresClient instance
+ */
+export function createClient(config, logger) {
+    return new PostgresClient(config, logger);
+}

package/dist/health.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @singulio/postgres - Health Check Utilities
+ * Kubernetes readiness/liveness probes for PostgreSQL
+ */
+import type { HealthCheckResult, Logger } from './types.js';
+import type { PostgresPool } from './pool.js';
+/**
+ * Simple health check - verifies database connectivity
+ */
+export declare function healthCheck(logger?: Logger): Promise<HealthCheckResult>;
+/**
+ * Extended health check with pool statistics
+ */
+export declare function healthCheckWithPool(pool: PostgresPool, logger?: Logger): Promise<HealthCheckResult>;
+/**
+ * Deep health check - verifies database is accepting writes
+ */
+export declare function deepHealthCheck(logger?: Logger): Promise<HealthCheckResult>;
+/**
+ * Check PostgreSQL version
+ */
+export declare function getVersion(): Promise<string>;
+/**
+ * Check if database is in recovery mode (replica)
+ */
+export declare function isInRecovery(): Promise<boolean>;
+/**
+ * Get database size
+ */
+export declare function getDatabaseSize(dbName?: string): Promise<string>;
+/**
+ * Get connection count
+ */
+export declare function getConnectionCount(): Promise<{
+    active: number;
+    idle: number;
+    total: number;
+    maxConnections: number;
+}>;
+/**
+ * Create an HTTP health check handler for Bun.serve
+ */
+export declare function createHealthHandler(pool?: PostgresPool): (req: Request) => Promise<Response>;
+//# sourceMappingURL=health.d.ts.map

package/dist/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;GAEG;AACH,wBAAsB,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA2B7E;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,YAAY,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAwC5B;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAkDjF;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAGlD;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAGrD;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMtE;AAED;;GAEG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC,CAiBD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE,YAAY,IACvC,KAAK,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC,CAuB/C"}

package/dist/health.js

@@ -0,0 +1,182 @@
+/**
+ * @singulio/postgres - Health Check Utilities
+ * Kubernetes readiness/liveness probes for PostgreSQL
+ */
+import { sql } from 'bun';
+/**
+ * Simple health check - verifies database connectivity
+ */
+export async function healthCheck(logger) {
+    const start = performance.now();
+    try {
+        const result = await sql `SELECT 1 as ok`;
+        const latencyMs = performance.now() - start;
+        const healthy = result.length > 0 && result[0].ok === 1;
+        logger?.debug('Health check completed', { healthy, latencyMs: latencyMs.toFixed(2) });
+        return {
+            healthy,
+            latencyMs,
+        };
+    }
+    catch (error) {
+        const latencyMs = performance.now() - start;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger?.error('Health check failed', { error: errorMessage, latencyMs: latencyMs.toFixed(2) });
+        return {
+            healthy: false,
+            latencyMs,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Extended health check with pool statistics
+ */
+export async function healthCheckWithPool(pool, logger) {
+    const start = performance.now();
+    try {
+        // Query through pool
+        const result = await pool.query('SELECT 1 as ok');
+        const latencyMs = performance.now() - start;
+        const healthy = result.rows.length > 0 && result.rows[0].ok === 1;
+        const poolStats = pool.stats();
+        logger?.debug('Pool health check completed', {
+            healthy,
+            latencyMs: latencyMs.toFixed(2),
+            ...poolStats,
+        });
+        return {
+            healthy,
+            latencyMs,
+            poolStats,
+        };
+    }
+    catch (error) {
+        const latencyMs = performance.now() - start;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const poolStats = pool.stats();
+        logger?.error('Pool health check failed', {
+            error: errorMessage,
+            latencyMs: latencyMs.toFixed(2),
+            ...poolStats,
+        });
+        return {
+            healthy: false,
+            latencyMs,
+            poolStats,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Deep health check - verifies database is accepting writes
+ */
+export async function deepHealthCheck(logger) {
+    const start = performance.now();
+    try {
+        // Check we can read and write
+        await sql `
+      CREATE TEMP TABLE IF NOT EXISTS _health_check (
+        id serial PRIMARY KEY,
+        ts timestamptz DEFAULT NOW()
+      )
+    `;
+        await sql `INSERT INTO _health_check DEFAULT VALUES`;
+        const result = await sql `SELECT COUNT(*) as count FROM _health_check`;
+        await sql `DROP TABLE IF EXISTS _health_check`;
+        const latencyMs = performance.now() - start;
+        const healthy = result.length > 0 && result[0].count > 0;
+        logger?.debug('Deep health check completed', {
+            healthy,
+            latencyMs: latencyMs.toFixed(2),
+        });
+        return {
+            healthy,
+            latencyMs,
+        };
+    }
+    catch (error) {
+        const latencyMs = performance.now() - start;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Cleanup on error
+        try {
+            await sql `DROP TABLE IF EXISTS _health_check`;
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        logger?.error('Deep health check failed', {
+            error: errorMessage,
+            latencyMs: latencyMs.toFixed(2),
+        });
+        return {
+            healthy: false,
+            latencyMs,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Check PostgreSQL version
+ */
+export async function getVersion() {
+    const result = await sql `SELECT version()`;
+    return result[0]?.version ?? 'unknown';
+}
+/**
+ * Check if database is in recovery mode (replica)
+ */
+export async function isInRecovery() {
+    const result = await sql `SELECT pg_is_in_recovery() as in_recovery`;
+    return result[0]?.in_recovery === true;
+}
+/**
+ * Get database size
+ */
+export async function getDatabaseSize(dbName) {
+    const result = await sql.unsafe(`SELECT pg_size_pretty(pg_database_size(${dbName ? '$1' : 'current_database()'}))::text as size`, dbName ? [dbName] : []);
+    return result[0]?.size ?? 'unknown';
+}
+/**
+ * Get connection count
+ */
+export async function getConnectionCount() {
+    const result = await sql `
+    SELECT
+      COUNT(*) FILTER (WHERE state = 'active') as active,
+      COUNT(*) FILTER (WHERE state = 'idle') as idle,
+      COUNT(*) as total,
+      (SELECT setting::int FROM pg_settings WHERE name = 'max_connections') as max_connections
+    FROM pg_stat_activity
+    WHERE datname = current_database()
+  `;
+    return {
+        active: Number(result[0]?.active) || 0,
+        idle: Number(result[0]?.idle) || 0,
+        total: Number(result[0]?.total) || 0,
+        maxConnections: Number(result[0]?.max_connections) || 100,
+    };
+}
+/**
+ * Create an HTTP health check handler for Bun.serve
+ */
+export function createHealthHandler(pool) {
+    return async (req) => {
+        const url = new URL(req.url);
+        if (url.pathname === '/health' || url.pathname === '/healthz') {
+            const result = pool ? await healthCheckWithPool(pool) : await healthCheck();
+            return new Response(JSON.stringify(result), {
+                status: result.healthy ? 200 : 503,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        if (url.pathname === '/ready' || url.pathname === '/readyz') {
+            const result = await deepHealthCheck();
+            return new Response(JSON.stringify(result), {
+                status: result.healthy ? 200 : 503,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        return new Response('Not Found', { status: 404 });
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @singulio/postgres
+ * PostgreSQL 18.x client for Bun with RLS, pooling, transactions, and pgvector support
+ *
+ * A thin wrapper around bun:postgres native client providing:
+ * - Connection pooling with configurable limits
+ * - Row-Level Security (RLS) helpers for multi-tenant isolation
+ * - Transaction support with auto-rollback
+ * - pgvector extension for AI/ML embeddings
+ * - Kubernetes health check utilities
+ *
+ * @example
+ * ```typescript
+ * import { createClient, createPool, withTenant, vectorSearch } from '@singulio/postgres';
+ *
+ * // Simple client
+ * const client = createClient(process.env.DATABASE_URL);
+ * const users = await client.queryAll('SELECT * FROM users');
+ *
+ * // With RLS tenant context
+ * const tenantData = await withTenant({ tenantId: 'tenant-123' }, async () => {
+ *   return client.queryAll('SELECT * FROM contacts'); // RLS filters by tenant
+ * });
+ *
+ * // Vector similarity search
+ * const similar = await vectorSearch('documents', 'embedding', queryVector, {
+ *   operator: '<=>',  // Cosine similarity
+ *   limit: 10,
+ * });
+ * ```
+ */
+export type { PostgresConfig, PoolConfig, RLSContext, QueryResult, QueryRow, FieldInfo, IsolationLevel, TransactionOptions, HealthCheckResult, PoolStats, VectorDistanceOperator, VectorIndexType, VectorSearchOptions, Logger, } from './types.js';
+export { PostgresClient, createClient } from './client.js';
+export { PostgresPool, createPool } from './pool.js';
+export { setRLSContext, clearRLSContext, getRLSContext, withTenant, queryWithTenant, RLSClient, createRLSClient, } from './rls.js';
+export { transaction, serializableTransaction, readOnlyTransaction, savepoint, rollbackToSavepoint, releaseSavepoint, type TransactionQuery, } from './transaction.js';
+export { formatVector, parseVector, vectorDimension, normalizeVector, getDistanceOperator, getDistanceOperatorName, ensureVectorExtension, createVectorColumn, createVectorIndex, vectorSearch, insertWithVector, updateVector, batchInsertWithVectors, type Vector, } from './vector.js';
+export { healthCheck, healthCheckWithPool, deepHealthCheck, getVersion, isInRecovery, getDatabaseSize, getConnectionCount, createHealthHandler, } from './health.js';
+export { sql } from 'bun';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,YAAY,EACV,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,SAAS,EACT,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,SAAS,EACT,sBAAsB,EACtB,eAAe,EACf,mBAAmB,EACnB,MAAM,GACP,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3D,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGrD,OAAO,EACL,aAAa,EACb,eAAe,EACf,aAAa,EACb,UAAU,EACV,eAAe,EACf,SAAS,EACT,eAAe,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACT,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,YAAY,EACZ,WAAW,EACX,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,sBAAsB,EACtB,KAAK,MAAM,GACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,eAAe,EACf,UAAU,EACV,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC"}

package/dist/index.js

@@ -0,0 +1,45 @@
+/**
+ * @singulio/postgres
+ * PostgreSQL 18.x client for Bun with RLS, pooling, transactions, and pgvector support
+ *
+ * A thin wrapper around bun:postgres native client providing:
+ * - Connection pooling with configurable limits
+ * - Row-Level Security (RLS) helpers for multi-tenant isolation
+ * - Transaction support with auto-rollback
+ * - pgvector extension for AI/ML embeddings
+ * - Kubernetes health check utilities
+ *
+ * @example
+ * ```typescript
+ * import { createClient, createPool, withTenant, vectorSearch } from '@singulio/postgres';
+ *
+ * // Simple client
+ * const client = createClient(process.env.DATABASE_URL);
+ * const users = await client.queryAll('SELECT * FROM users');
+ *
+ * // With RLS tenant context
+ * const tenantData = await withTenant({ tenantId: 'tenant-123' }, async () => {
+ *   return client.queryAll('SELECT * FROM contacts'); // RLS filters by tenant
+ * });
+ *
+ * // Vector similarity search
+ * const similar = await vectorSearch('documents', 'embedding', queryVector, {
+ *   operator: '<=>',  // Cosine similarity
+ *   limit: 10,
+ * });
+ * ```
+ */
+// Client
+export { PostgresClient, createClient } from './client.js';
+// Pool
+export { PostgresPool, createPool } from './pool.js';
+// RLS
+export { setRLSContext, clearRLSContext, getRLSContext, withTenant, queryWithTenant, RLSClient, createRLSClient, } from './rls.js';
+// Transactions
+export { transaction, serializableTransaction, readOnlyTransaction, savepoint, rollbackToSavepoint, releaseSavepoint, } from './transaction.js';
+// Vector (pgvector)
+export { formatVector, parseVector, vectorDimension, normalizeVector, getDistanceOperator, getDistanceOperatorName, ensureVectorExtension, createVectorColumn, createVectorIndex, vectorSearch, insertWithVector, updateVector, batchInsertWithVectors, } from './vector.js';
+// Health
+export { healthCheck, healthCheckWithPool, deepHealthCheck, getVersion, isInRecovery, getDatabaseSize, getConnectionCount, createHealthHandler, } from './health.js';
+// Re-export bun:postgres sql for direct usage
+export { sql } from 'bun';

package/dist/pool.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @singulio/postgres - Connection Pool Manager
+ * Manages PostgreSQL connections with configurable pooling
+ *
+ * Note: Bun's native sql driver handles connection pooling internally.
+ * This module provides a higher-level API with explicit pool management
+ * for scenarios requiring fine-grained control.
+ */
+import type { PoolConfig, PoolStats, QueryResult, QueryRow, Logger } from './types.js';
+/**
+ * Connection pool manager for PostgreSQL
+ */
+export declare class PostgresPool {
+    private config;
+    private logger?;
+    private connections;
+    private nextId;
+    private waitQueue;
+    private closed;
+    private idleCheckTimer?;
+    constructor(config: PoolConfig, logger?: Logger);
+    /**
+     * Initialize the pool with minimum connections
+     */
+    initialize(): Promise<void>;
+    private createConnection;
+    private acquireConnection;
+    private releaseConnection;
+    private destroyConnection;
+    private checkIdleConnections;
+    /**
+     * Execute a query using a pooled connection
+     */
+    query<T = QueryRow>(queryText: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Execute with exclusive connection for multi-statement operations
+     */
+    withConnection<T>(fn: (query: (sql: string, params?: unknown[]) => Promise<QueryResult>) => Promise<T>): Promise<T>;
+    /**
+     * Get current pool statistics
+     */
+    stats(): PoolStats;
+    /**
+     * Close the pool and all connections
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create and initialize a connection pool
+ */
+export declare function createPool(config: PoolConfig, logger?: Logger): Promise<PostgresPool>;
+//# sourceMappingURL=pool.d.ts.map

package/dist/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAkBvF;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,WAAW,CAA4C;IAC/D,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAIT;IACR,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAC,CAAQ;gBAEnB,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM;IAe/C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAgBnB,gBAAgB;YAWhB,iBAAiB;IAkC/B,OAAO,CAAC,iBAAiB;YAaX,iBAAiB;YAKjB,oBAAoB;IAclC;;OAEG;IACG,KAAK,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IA4BzF;;OAEG;IACG,cAAc,CAAC,CAAC,EACpB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACnF,OAAO,CAAC,CAAC,CAAC;IAoBb;;OAEG;IACH,KAAK,IAAI,SAAS;IAoBlB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqB7B;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAI3F"}