@agentuity/postgres 0.1.41

package/dist/errors.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Base error for PostgreSQL-related errors.
+ */
+export declare const PostgresError: {
+    new (args?: ({
+        code?: string;
+        query?: string;
+    } & {
+        message?: string;
+        cause?: unknown;
+    }) | undefined): import("@agentuity/core").RichError & {
+        readonly _tag: "PostgresError";
+    } & Readonly<{
+        code?: string;
+        query?: string;
+    }>;
+    readonly defaultMessage?: string;
+};
+/**
+ * Error thrown when attempting to use a closed connection.
+ */
+export declare const ConnectionClosedError: {
+    new (args?: ({
+        wasReconnecting?: boolean;
+    } & {
+        message?: string;
+        cause?: unknown;
+    }) | undefined): import("@agentuity/core").RichError & {
+        readonly _tag: "ConnectionClosedError";
+    } & Readonly<{
+        wasReconnecting?: boolean;
+    }>;
+    readonly defaultMessage?: string;
+};
+/**
+ * Error thrown when reconnection fails after all attempts.
+ */
+export declare const ReconnectFailedError: {
+    new (args?: ({
+        attempts: number;
+        lastError?: Error;
+    } & {
+        cause?: unknown;
+    }) | undefined): import("@agentuity/core").RichError & {
+        readonly _tag: "ReconnectFailedError";
+    } & Readonly<{
+        attempts: number;
+        lastError?: Error;
+    }>;
+    readonly defaultMessage?: string;
+};
+/**
+ * Error thrown when a query times out.
+ */
+export declare const QueryTimeoutError: {
+    new (args?: ({
+        timeoutMs: number;
+        query?: string;
+    } & {
+        cause?: unknown;
+    }) | undefined): import("@agentuity/core").RichError & {
+        readonly _tag: "QueryTimeoutError";
+    } & Readonly<{
+        timeoutMs: number;
+        query?: string;
+    }>;
+    readonly defaultMessage?: string;
+};
+/**
+ * Error thrown when a transaction fails.
+ */
+export declare const TransactionError: {
+    new (args?: ({
+        phase?: "begin" | "commit" | "rollback" | "savepoint" | "query";
+    } & {
+        message?: string;
+        cause?: unknown;
+    }) | undefined): import("@agentuity/core").RichError & {
+        readonly _tag: "TransactionError";
+    } & Readonly<{
+        phase?: "begin" | "commit" | "rollback" | "savepoint" | "query";
+    }>;
+    readonly defaultMessage?: string;
+};
+/**
+ * Error thrown when an operation is not supported.
+ */
+export declare const UnsupportedOperationError: {
+    new (args?: ({
+        operation: string;
+        reason?: string;
+    } & {
+        cause?: unknown;
+    }) | undefined): import("@agentuity/core").RichError & {
+        readonly _tag: "UnsupportedOperationError";
+    } & Readonly<{
+        operation: string;
+        reason?: string;
+    }>;
+    readonly defaultMessage?: string;
+};
+/**
+ * Determines if an error is retryable (i.e., a reconnection should be attempted).
+ *
+ * @param error - The error to check
+ * @returns `true` if the error indicates a connection issue that may be resolved by reconnecting
+ */
+export declare function isRetryableError(error: unknown): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,aAAa;;eAClB,MAAM;gBACL,MAAM;;;;;;;eADP,MAAM;gBACL,MAAM;;;CACX,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,qBAAqB;;0BACf,OAAO;;;;;;;0BAAP,OAAO;;;CACtB,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,oBAAoB;;kBAItB,MAAM;oBACJ,KAAK;;;;;;kBADP,MAAM;oBACJ,KAAK;;;CACd,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,iBAAiB;;mBAClB,MAAM;gBACT,MAAM;;;;;;mBADH,MAAM;gBACT,MAAM;;;CACX,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,gBAAgB;;gBACpB,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO;;;;;;;gBAAvD,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO;;;CAC5D,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,yBAAyB;;mBAI1B,MAAM;iBACR,MAAM;;;;;;mBADJ,MAAM;iBACR,MAAM;;;CACZ,CAAC;AA2DL;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAoCxD"}

package/dist/errors.js

@@ -0,0 +1,115 @@
+import { StructuredError } from '@agentuity/core';
+/**
+ * Base error for PostgreSQL-related errors.
+ */
+export const PostgresError = StructuredError('PostgresError')();
+/**
+ * Error thrown when attempting to use a closed connection.
+ */
+export const ConnectionClosedError = StructuredError('ConnectionClosedError')();
+/**
+ * Error thrown when reconnection fails after all attempts.
+ */
+export const ReconnectFailedError = StructuredError('ReconnectFailedError', 'Failed to reconnect after maximum attempts')();
+/**
+ * Error thrown when a query times out.
+ */
+export const QueryTimeoutError = StructuredError('QueryTimeoutError', 'Query timed out')();
+/**
+ * Error thrown when a transaction fails.
+ */
+export const TransactionError = StructuredError('TransactionError')();
+/**
+ * Error thrown when an operation is not supported.
+ */
+export const UnsupportedOperationError = StructuredError('UnsupportedOperationError', 'This operation is not supported')();
+/**
+ * Error codes that indicate a retryable connection error.
+ */
+const RETRYABLE_ERROR_CODES = new Set([
+    // Bun SQL specific
+    'ERR_POSTGRES_CONNECTION_CLOSED',
+    'ERR_POSTGRES_CONNECTION_TIMEOUT',
+    // Node.js / system errors
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'EPIPE',
+    'ENOTFOUND',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'EAI_AGAIN',
+    // PostgreSQL error codes
+    '57P01', // admin_shutdown
+    '57P02', // crash_shutdown
+    '57P03', // cannot_connect_now
+    '08000', // connection_exception
+    '08003', // connection_does_not_exist
+    '08006', // connection_failure
+    '08001', // sqlclient_unable_to_establish_sqlconnection
+    '08004', // sqlserver_rejected_establishment_of_sqlconnection
+]);
+/**
+ * Error messages that indicate a retryable connection error.
+ */
+const RETRYABLE_ERROR_MESSAGES = [
+    'connection closed',
+    'connection terminated',
+    'connection reset',
+    'connection refused',
+    'connection timed out',
+    'socket hang up',
+    'read ECONNRESET',
+    'write EPIPE',
+    'getaddrinfo',
+    'ENOTFOUND',
+    'network is unreachable',
+    'no route to host',
+    'server closed the connection unexpectedly',
+    'terminating connection due to administrator command',
+    'the database system is shutting down',
+    'the database system is starting up',
+    'the database system is in recovery mode',
+    'failed to read',
+    'failed to write',
+    'broken pipe',
+    'end of file',
+    'eof',
+];
+/**
+ * Determines if an error is retryable (i.e., a reconnection should be attempted).
+ *
+ * @param error - The error to check
+ * @returns `true` if the error indicates a connection issue that may be resolved by reconnecting
+ */
+export function isRetryableError(error) {
+    if (!error) {
+        return false;
+    }
+    // Check error code
+    if (typeof error === 'object' && error !== null) {
+        const err = error;
+        // Check 'code' property
+        if (typeof err.code === 'string' && RETRYABLE_ERROR_CODES.has(err.code)) {
+            return true;
+        }
+        // Check 'errno' property (Node.js style)
+        if (typeof err.errno === 'string' && RETRYABLE_ERROR_CODES.has(err.errno)) {
+            return true;
+        }
+        // Check nested cause
+        if (err.cause && isRetryableError(err.cause)) {
+            return true;
+        }
+    }
+    // Check error message
+    const message = error instanceof Error ? error.message : String(error);
+    const lowerMessage = message.toLowerCase();
+    for (const pattern of RETRYABLE_ERROR_MESSAGES) {
+        if (lowerMessage.includes(pattern.toLowerCase())) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @agentuity/postgres - Resilient PostgreSQL client with automatic reconnection
+ *
+ * This package provides a PostgreSQL client that wraps Bun's native SQL driver
+ * and adds automatic reconnection with exponential backoff.
+ *
+ * @example
+ * ```typescript
+ * import { postgres } from '@agentuity/postgres';
+ *
+ * // Create a client (uses DATABASE_URL by default)
+ * const sql = postgres();
+ *
+ * // Execute queries using tagged template literals
+ * const users = await sql`SELECT * FROM users WHERE active = ${true}`;
+ *
+ * // Transactions
+ * const tx = await sql.begin();
+ * try {
+ *   await tx`INSERT INTO users (name) VALUES (${name})`;
+ *   await tx.commit();
+ * } catch (error) {
+ *   await tx.rollback();
+ *   throw error;
+ * }
+ *
+ * // Close when done
+ * await sql.close();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { postgres, default } from './postgres';
+export { PostgresClient, createCallableClient, type CallablePostgresClient } from './client';
+export { Transaction, Savepoint, ReservedConnection } from './transaction';
+export { patchBunSQL, isPatched, SQL } from './patch';
+export type { PostgresConfig, ReconnectConfig, ConnectionStats, TLSConfig, TransactionOptions, ReserveOptions, } from './types';
+export { PostgresError, ConnectionClosedError, ReconnectFailedError, QueryTimeoutError, TransactionError, UnsupportedOperationError, isRetryableError, } from './errors';
+export { computeBackoff, sleep, mergeReconnectConfig, DEFAULT_RECONNECT_CONFIG } from './reconnect';
+export { shutdownAll, getClientCount, getClients, hasActiveClients } from './registry';
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,KAAK,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAG7F,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAG3E,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAGtD,YAAY,EACX,cAAc,EACd,eAAe,EACf,eAAe,EACf,SAAS,EACT,kBAAkB,EAClB,cAAc,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EACN,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAGpG,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,47 @@
+/**
+ * @agentuity/postgres - Resilient PostgreSQL client with automatic reconnection
+ *
+ * This package provides a PostgreSQL client that wraps Bun's native SQL driver
+ * and adds automatic reconnection with exponential backoff.
+ *
+ * @example
+ * ```typescript
+ * import { postgres } from '@agentuity/postgres';
+ *
+ * // Create a client (uses DATABASE_URL by default)
+ * const sql = postgres();
+ *
+ * // Execute queries using tagged template literals
+ * const users = await sql`SELECT * FROM users WHERE active = ${true}`;
+ *
+ * // Transactions
+ * const tx = await sql.begin();
+ * try {
+ *   await tx`INSERT INTO users (name) VALUES (${name})`;
+ *   await tx.commit();
+ * } catch (error) {
+ *   await tx.rollback();
+ *   throw error;
+ * }
+ *
+ * // Close when done
+ * await sql.close();
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Main factory function
+export { postgres, default } from './postgres';
+// Client class for advanced usage
+export { PostgresClient, createCallableClient } from './client';
+// Transaction and reserved connection classes
+export { Transaction, Savepoint, ReservedConnection } from './transaction';
+// Patch function for modifying Bun.SQL globally
+export { patchBunSQL, isPatched, SQL } from './patch';
+// Errors
+export { PostgresError, ConnectionClosedError, ReconnectFailedError, QueryTimeoutError, TransactionError, UnsupportedOperationError, isRetryableError, } from './errors';
+// Reconnection utilities
+export { computeBackoff, sleep, mergeReconnectConfig, DEFAULT_RECONNECT_CONFIG } from './reconnect';
+// Global registry for coordinated shutdown
+export { shutdownAll, getClientCount, getClients, hasActiveClients } from './registry';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAwB;AACxB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE/C,kCAAkC;AAClC,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAA+B,MAAM,UAAU,CAAC;AAE7F,8CAA8C;AAC9C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAE3E,gDAAgD;AAChD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAYtD,SAAS;AACT,OAAO,EACN,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,GAChB,MAAM,UAAU,CAAC;AAElB,yBAAyB;AACzB,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEpG,2CAA2C;AAC3C,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/patch.d.ts

@@ -0,0 +1,65 @@
+import { SQL } from 'bun';
+import type { ReconnectConfig } from './types';
+/**
+ * Patches Bun's native SQL class to add automatic reconnection support.
+ *
+ * This modifies the global `Bun.SQL` prototype to intercept connection close
+ * events and automatically attempt reconnection with exponential backoff.
+ *
+ * **Note:** This is a global modification that affects all SQL instances created
+ * after calling this function. Use with caution in shared environments.
+ *
+ * @param config - Optional configuration for reconnection behavior
+ *
+ * @example
+ * ```typescript
+ * import { patchBunSQL, SQL } from '@agentuity/postgres';
+ *
+ * // Patch with default settings
+ * patchBunSQL();
+ *
+ * // Or with custom configuration
+ * patchBunSQL({
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 200,
+ *   },
+ *   onreconnect: (attempt) => console.log(`Reconnecting... attempt ${attempt}`),
+ *   onreconnected: () => console.log('Reconnected!'),
+ * });
+ *
+ * // Now use Bun.SQL normally - it will auto-reconnect
+ * const sql = new SQL({ url: process.env.DATABASE_URL });
+ * const users = await sql`SELECT * FROM users`;
+ * ```
+ */
+export declare function patchBunSQL(config?: {
+    reconnect?: ReconnectConfig;
+    onreconnect?: (attempt: number) => void;
+    onreconnected?: () => void;
+    onreconnectfailed?: (error: Error) => void;
+}): void;
+/**
+ * Returns whether Bun.SQL has been patched.
+ */
+export declare function isPatched(): boolean;
+/**
+ * Resets the patch state (mainly for testing).
+ * @internal
+ */
+export declare function _resetPatch(): void;
+/**
+ * Re-export of Bun's SQL class.
+ *
+ * When using the patched version, import SQL from this module instead of 'bun':
+ *
+ * @example
+ * ```typescript
+ * import { patchBunSQL, SQL } from '@agentuity/postgres';
+ *
+ * patchBunSQL();
+ * const sql = new SQL({ url: process.env.DATABASE_URL });
+ * ```
+ */
+export { SQL };
+//# sourceMappingURL=patch.d.ts.map

package/dist/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../src/patch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC1B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAoB/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE;IACpC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAC3C,GAAG,IAAI,CA6BP;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAMlC;AAED;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/dist/patch.js

@@ -0,0 +1,111 @@
+import { SQL } from 'bun';
+import { mergeReconnectConfig, DEFAULT_RECONNECT_CONFIG } from './reconnect';
+/**
+ * Whether Bun.SQL has already been patched.
+ */
+let _patched = false;
+/**
+ * Global reconnect configuration for patched Bun.SQL instances.
+ */
+let _globalReconnectConfig = { ...DEFAULT_RECONNECT_CONFIG };
+/**
+ * Callbacks for reconnection events.
+ */
+let _onReconnect;
+let _onReconnected;
+let _onReconnectFailed;
+/**
+ * Patches Bun's native SQL class to add automatic reconnection support.
+ *
+ * This modifies the global `Bun.SQL` prototype to intercept connection close
+ * events and automatically attempt reconnection with exponential backoff.
+ *
+ * **Note:** This is a global modification that affects all SQL instances created
+ * after calling this function. Use with caution in shared environments.
+ *
+ * @param config - Optional configuration for reconnection behavior
+ *
+ * @example
+ * ```typescript
+ * import { patchBunSQL, SQL } from '@agentuity/postgres';
+ *
+ * // Patch with default settings
+ * patchBunSQL();
+ *
+ * // Or with custom configuration
+ * patchBunSQL({
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 200,
+ *   },
+ *   onreconnect: (attempt) => console.log(`Reconnecting... attempt ${attempt}`),
+ *   onreconnected: () => console.log('Reconnected!'),
+ * });
+ *
+ * // Now use Bun.SQL normally - it will auto-reconnect
+ * const sql = new SQL({ url: process.env.DATABASE_URL });
+ * const users = await sql`SELECT * FROM users`;
+ * ```
+ */
+export function patchBunSQL(config) {
+    if (_patched) {
+        // Already patched, just update config if provided
+        if (config?.reconnect) {
+            _globalReconnectConfig = mergeReconnectConfig(config.reconnect);
+        }
+        if (config?.onreconnect)
+            _onReconnect = config.onreconnect;
+        if (config?.onreconnected)
+            _onReconnected = config.onreconnected;
+        if (config?.onreconnectfailed)
+            _onReconnectFailed = config.onreconnectfailed;
+        return;
+    }
+    // Store configuration
+    if (config?.reconnect) {
+        _globalReconnectConfig = mergeReconnectConfig(config.reconnect);
+    }
+    _onReconnect = config?.onreconnect;
+    _onReconnected = config?.onreconnected;
+    _onReconnectFailed = config?.onreconnectfailed;
+    // Note: True monkey-patching of Bun.SQL internals is not feasible
+    // because Bun.SQL is a native class. Instead, users should use
+    // PostgresClient from this package which provides the same API
+    // with automatic reconnection built in.
+    //
+    // This function exists to set global reconnection configuration
+    // that could be used by future implementations.
+    _patched = true;
+}
+/**
+ * Returns whether Bun.SQL has been patched.
+ */
+export function isPatched() {
+    return _patched;
+}
+/**
+ * Resets the patch state (mainly for testing).
+ * @internal
+ */
+export function _resetPatch() {
+    _patched = false;
+    _globalReconnectConfig = { ...DEFAULT_RECONNECT_CONFIG };
+    _onReconnect = undefined;
+    _onReconnected = undefined;
+    _onReconnectFailed = undefined;
+}
+/**
+ * Re-export of Bun's SQL class.
+ *
+ * When using the patched version, import SQL from this module instead of 'bun':
+ *
+ * @example
+ * ```typescript
+ * import { patchBunSQL, SQL } from '@agentuity/postgres';
+ *
+ * patchBunSQL();
+ * const sql = new SQL({ url: process.env.DATABASE_URL });
+ * ```
+ */
+export { SQL };
+//# sourceMappingURL=patch.js.map

package/dist/patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.js","sourceRoot":"","sources":["../src/patch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE7E;;GAEG;AACH,IAAI,QAAQ,GAAG,KAAK,CAAC;AAErB;;GAEG;AACH,IAAI,sBAAsB,GAA8B,EAAE,GAAG,wBAAwB,EAAE,CAAC;AAExF;;GAEG;AACH,IAAI,YAAqD,CAAC;AAC1D,IAAI,cAAwC,CAAC;AAC7C,IAAI,kBAAwD,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,WAAW,CAAC,MAK3B;IACA,IAAI,QAAQ,EAAE,CAAC;QACd,kDAAkD;QAClD,IAAI,MAAM,EAAE,SAAS,EAAE,CAAC;YACvB,sBAAsB,GAAG,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,MAAM,EAAE,WAAW;YAAE,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC;QAC3D,IAAI,MAAM,EAAE,aAAa;YAAE,cAAc,GAAG,MAAM,CAAC,aAAa,CAAC;QACjE,IAAI,MAAM,EAAE,iBAAiB;YAAE,kBAAkB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAC7E,OAAO;IACR,CAAC;IAED,sBAAsB;IACtB,IAAI,MAAM,EAAE,SAAS,EAAE,CAAC;QACvB,sBAAsB,GAAG,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACjE,CAAC;IACD,YAAY,GAAG,MAAM,EAAE,WAAW,CAAC;IACnC,cAAc,GAAG,MAAM,EAAE,aAAa,CAAC;IACvC,kBAAkB,GAAG,MAAM,EAAE,iBAAiB,CAAC;IAE/C,kEAAkE;IAClE,+DAA+D;IAC/D,+DAA+D;IAC/D,wCAAwC;IACxC,EAAE;IACF,gEAAgE;IAChE,gDAAgD;IAEhD,QAAQ,GAAG,IAAI,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS;IACxB,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW;IAC1B,QAAQ,GAAG,KAAK,CAAC;IACjB,sBAAsB,GAAG,EAAE,GAAG,wBAAwB,EAAE,CAAC;IACzD,YAAY,GAAG,SAAS,CAAC;IACzB,cAAc,GAAG,SAAS,CAAC;IAC3B,kBAAkB,GAAG,SAAS,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/dist/postgres.d.ts

@@ -0,0 +1,62 @@
+import type { PostgresConfig } from './types';
+import { type CallablePostgresClient } from './client';
+/**
+ * Creates a resilient PostgreSQL client with automatic reconnection.
+ *
+ * This is the main entry point for creating a PostgreSQL client. The returned
+ * client can be used as a tagged template literal for queries.
+ *
+ * @param config - Connection configuration. Can be:
+ *   - A connection URL string (e.g., `postgres://user:pass@host:5432/db`)
+ *   - A configuration object with connection options
+ *   - Omitted to use `process.env.DATABASE_URL`
+ *
+ * @returns A callable PostgresClient that supports tagged template literals
+ *
+ * @example
+ * ```typescript
+ * import { postgres } from '@agentuity/postgres';
+ *
+ * // Using environment variable (DATABASE_URL)
+ * const sql = postgres();
+ *
+ * // Using connection URL
+ * const sql = postgres('postgres://user:pass@localhost:5432/mydb');
+ *
+ * // Using configuration object
+ * const sql = postgres({
+ *   hostname: 'localhost',
+ *   port: 5432,
+ *   username: 'user',
+ *   password: 'pass',
+ *   database: 'mydb',
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 100,
+ *   },
+ * });
+ *
+ * // Execute queries using tagged template literals
+ * const users = await sql`SELECT * FROM users`;
+ * const user = await sql`SELECT * FROM users WHERE id = ${userId}`;
+ *
+ * // Transactions
+ * const tx = await sql.begin();
+ * try {
+ *   await tx`INSERT INTO users (name) VALUES (${name})`;
+ *   await tx.commit();
+ * } catch (error) {
+ *   await tx.rollback();
+ *   throw error;
+ * }
+ *
+ * // Close when done
+ * await sql.close();
+ * ```
+ */
+export declare function postgres(config?: string | PostgresConfig): CallablePostgresClient;
+/**
+ * Default export for convenience.
+ */
+export default postgres;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAwB,KAAK,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,sBAAsB,CAEjF;AAED;;GAEG;AACH,eAAe,QAAQ,CAAC"}

package/dist/postgres.js

@@ -0,0 +1,63 @@
+import { createCallableClient } from './client';
+/**
+ * Creates a resilient PostgreSQL client with automatic reconnection.
+ *
+ * This is the main entry point for creating a PostgreSQL client. The returned
+ * client can be used as a tagged template literal for queries.
+ *
+ * @param config - Connection configuration. Can be:
+ *   - A connection URL string (e.g., `postgres://user:pass@host:5432/db`)
+ *   - A configuration object with connection options
+ *   - Omitted to use `process.env.DATABASE_URL`
+ *
+ * @returns A callable PostgresClient that supports tagged template literals
+ *
+ * @example
+ * ```typescript
+ * import { postgres } from '@agentuity/postgres';
+ *
+ * // Using environment variable (DATABASE_URL)
+ * const sql = postgres();
+ *
+ * // Using connection URL
+ * const sql = postgres('postgres://user:pass@localhost:5432/mydb');
+ *
+ * // Using configuration object
+ * const sql = postgres({
+ *   hostname: 'localhost',
+ *   port: 5432,
+ *   username: 'user',
+ *   password: 'pass',
+ *   database: 'mydb',
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 100,
+ *   },
+ * });
+ *
+ * // Execute queries using tagged template literals
+ * const users = await sql`SELECT * FROM users`;
+ * const user = await sql`SELECT * FROM users WHERE id = ${userId}`;
+ *
+ * // Transactions
+ * const tx = await sql.begin();
+ * try {
+ *   await tx`INSERT INTO users (name) VALUES (${name})`;
+ *   await tx.commit();
+ * } catch (error) {
+ *   await tx.rollback();
+ *   throw error;
+ * }
+ *
+ * // Close when done
+ * await sql.close();
+ * ```
+ */
+export function postgres(config) {
+    return createCallableClient(config);
+}
+/**
+ * Default export for convenience.
+ */
+export default postgres;
+//# sourceMappingURL=postgres.js.map

package/dist/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAA+B,MAAM,UAAU,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAgC;IACxD,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC;AACrC,CAAC;AAED;;GAEG;AACH,eAAe,QAAQ,CAAC"}