singulio-postgres 1.1.0

package/dist/pool.js

@@ -0,0 +1,216 @@
+/**
+ * @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 { sql } from 'bun';
+/**
+ * Connection pool manager for PostgreSQL
+ */
+export class PostgresPool {
+    config;
+    logger;
+    connections = new Map();
+    nextId = 0;
+    waitQueue = [];
+    closed = false;
+    idleCheckTimer;
+    constructor(config, logger) {
+        this.config = {
+            min: 2,
+            max: 20,
+            idleTimeout: 30000,
+            connectionTimeout: 10000,
+            maxLifetime: 3600000,
+            ...config,
+        };
+        this.logger = logger;
+        // Start idle connection checker
+        this.idleCheckTimer = setInterval(() => this.checkIdleConnections(), 10000);
+    }
+    /**
+     * Initialize the pool with minimum connections
+     */
+    async initialize() {
+        this.logger?.info('Initializing PostgreSQL pool', {
+            min: this.config.min,
+            max: this.config.max,
+        });
+        // Warm up minimum connections
+        for (let i = 0; i < this.config.min; i++) {
+            await this.createConnection();
+        }
+        this.logger?.info('PostgreSQL pool initialized', {
+            connections: this.connections.size,
+        });
+    }
+    async createConnection() {
+        const conn = {
+            id: this.nextId++,
+            createdAt: Date.now(),
+            lastUsedAt: Date.now(),
+            inUse: false,
+        };
+        this.connections.set(conn.id, conn);
+        return conn;
+    }
+    async acquireConnection() {
+        // Find an idle connection
+        for (const conn of this.connections.values()) {
+            if (!conn.inUse) {
+                // Check if connection is too old
+                if (Date.now() - conn.createdAt > this.config.maxLifetime) {
+                    await this.destroyConnection(conn);
+                    continue;
+                }
+                conn.inUse = true;
+                conn.lastUsedAt = Date.now();
+                return conn;
+            }
+        }
+        // Create new connection if under max
+        if (this.connections.size < this.config.max) {
+            const conn = await this.createConnection();
+            conn.inUse = true;
+            return conn;
+        }
+        // Wait for a connection
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const idx = this.waitQueue.findIndex(w => w.resolve === resolve);
+                if (idx >= 0)
+                    this.waitQueue.splice(idx, 1);
+                reject(new Error(`Connection timeout after ${this.config.connectionTimeout}ms`));
+            }, this.config.connectionTimeout);
+            this.waitQueue.push({ resolve, reject, timer });
+        });
+    }
+    releaseConnection(conn) {
+        conn.inUse = false;
+        conn.lastUsedAt = Date.now();
+        // Check waiting queue
+        if (this.waitQueue.length > 0) {
+            const waiter = this.waitQueue.shift();
+            clearTimeout(waiter.timer);
+            conn.inUse = true;
+            waiter.resolve(conn);
+        }
+    }
+    async destroyConnection(conn) {
+        this.connections.delete(conn.id);
+        this.logger?.debug('Connection destroyed', { id: conn.id });
+    }
+    async checkIdleConnections() {
+        if (this.closed)
+            return;
+        const now = Date.now();
+        for (const conn of this.connections.values()) {
+            // Don't close if we're at minimum
+            if (this.connections.size <= this.config.min)
+                break;
+            if (!conn.inUse && now - conn.lastUsedAt > this.config.idleTimeout) {
+                await this.destroyConnection(conn);
+            }
+        }
+    }
+    /**
+     * Execute a query using a pooled connection
+     */
+    async query(queryText, params) {
+        if (this.closed) {
+            throw new Error('Pool is closed');
+        }
+        const conn = await this.acquireConnection();
+        const start = performance.now();
+        try {
+            const result = await sql.unsafe(queryText, params ?? []);
+            const latency = performance.now() - start;
+            this.logger?.debug('Pool query executed', {
+                connId: conn.id,
+                query: queryText.substring(0, 100),
+                rows: result.length,
+                latencyMs: latency.toFixed(2),
+            });
+            return {
+                rows: result,
+                rowCount: result.length,
+            };
+        }
+        finally {
+            this.releaseConnection(conn);
+        }
+    }
+    /**
+     * Execute with exclusive connection for multi-statement operations
+     */
+    async withConnection(fn) {
+        if (this.closed) {
+            throw new Error('Pool is closed');
+        }
+        const conn = await this.acquireConnection();
+        try {
+            return await fn(async (queryText, params) => {
+                const result = await sql.unsafe(queryText, params ?? []);
+                return {
+                    rows: result,
+                    rowCount: result.length,
+                };
+            });
+        }
+        finally {
+            this.releaseConnection(conn);
+        }
+    }
+    /**
+     * Get current pool statistics
+     */
+    stats() {
+        let idle = 0;
+        let active = 0;
+        for (const conn of this.connections.values()) {
+            if (conn.inUse) {
+                active++;
+            }
+            else {
+                idle++;
+            }
+        }
+        return {
+            total: this.connections.size,
+            idle,
+            active,
+            pending: this.waitQueue.length,
+        };
+    }
+    /**
+     * Close the pool and all connections
+     */
+    async close() {
+        this.closed = true;
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+        }
+        // Reject all waiting
+        for (const waiter of this.waitQueue) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error('Pool is closing'));
+        }
+        this.waitQueue = [];
+        // Destroy all connections
+        for (const conn of this.connections.values()) {
+            await this.destroyConnection(conn);
+        }
+        this.logger?.info('PostgreSQL pool closed');
+    }
+}
+/**
+ * Create and initialize a connection pool
+ */
+export async function createPool(config, logger) {
+    const pool = new PostgresPool(config, logger);
+    await pool.initialize();
+    return pool;
+}

package/dist/rls.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @singulio/postgres - Row-Level Security Helpers
+ * Multi-tenant isolation via PostgreSQL session GUCs
+ */
+import type { RLSContext, QueryResult, QueryRow, Logger } from './types.js';
+/**
+ * Set RLS context variables for the current session
+ */
+export declare function setRLSContext(context: RLSContext): Promise<void>;
+/**
+ * Clear RLS context variables
+ */
+export declare function clearRLSContext(): Promise<void>;
+/**
+ * Get current RLS context
+ */
+export declare function getRLSContext(): Promise<RLSContext | null>;
+/**
+ * Execute a function with RLS context, automatically cleaning up afterward
+ */
+export declare function withTenant<T>(context: RLSContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Execute a query with RLS context
+ */
+export declare function queryWithTenant<T = QueryRow>(context: RLSContext, queryText: string, params?: unknown[]): Promise<QueryResult<T>>;
+/**
+ * RLS-aware client wrapper
+ */
+export declare class RLSClient {
+    private logger?;
+    constructor(logger?: Logger);
+    /**
+     * Execute query with tenant context
+     */
+    query<T = QueryRow>(context: RLSContext, queryText: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Execute with tenant context, return first row
+     */
+    queryOne<T = QueryRow>(context: RLSContext, queryText: string, params?: unknown[]): Promise<T | null>;
+    /**
+     * Execute with tenant context, return all rows
+     */
+    queryAll<T = QueryRow>(context: RLSContext, queryText: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Wrap a function with RLS context
+     */
+    withTenant<T>(context: RLSContext, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Create an RLS-aware client
+ */
+export declare function createRLSClient(logger?: Logger): RLSClient;
+//# sourceMappingURL=rls.d.ts.map

package/dist/rls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rls.d.ts","sourceRoot":"","sources":["../src/rls.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAE5E;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBtE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAIrD;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAgBhE;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAOzF;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,GAAG,QAAQ,EAChD,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAQzB;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,MAAM,CAAC,EAAE,MAAM;IAI3B;;OAEG;IACG,KAAK,CAAC,CAAC,GAAG,QAAQ,EACtB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAwB1B;;OAEG;IACG,QAAQ,CAAC,CAAC,GAAG,QAAQ,EACzB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAKpB;;OAEG;IACG,QAAQ,CAAC,CAAC,GAAG,QAAQ,EACzB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,OAAO,CAAC,CAAC,EAAE,CAAC;IAKf;;OAEG;IACH,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAGrE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAE1D"}

package/dist/rls.js

@@ -0,0 +1,134 @@
+/**
+ * @singulio/postgres - Row-Level Security Helpers
+ * Multi-tenant isolation via PostgreSQL session GUCs
+ */
+import { sql } from 'bun';
+/**
+ * Set RLS context variables for the current session
+ */
+export async function setRLSContext(context) {
+    // Set tenant reference (required for RLS policies)
+    await sql `SELECT set_config('app.tenant_ref', ${context.tenantId}, TRUE)`;
+    // Set admin flag (bypasses some policies)
+    await sql `SELECT set_config('app.is_admin', ${context.isAdmin ? 't' : 'f'}, TRUE)`;
+    // Set user ID if provided
+    if (context.userId) {
+        await sql `SELECT set_config('app.user_id', ${context.userId}, TRUE)`;
+    }
+    // Set any extra GUCs
+    if (context.extraGUCs) {
+        for (const [key, value] of Object.entries(context.extraGUCs)) {
+            await sql.unsafe(`SELECT set_config($1, $2, TRUE)`, [key, value]);
+        }
+    }
+}
+/**
+ * Clear RLS context variables
+ */
+export async function clearRLSContext() {
+    await sql `SELECT set_config('app.tenant_ref', '', TRUE)`;
+    await sql `SELECT set_config('app.is_admin', 'f', TRUE)`;
+    await sql `SELECT set_config('app.user_id', '', TRUE)`;
+}
+/**
+ * Get current RLS context
+ */
+export async function getRLSContext() {
+    const result = await sql `
+    SELECT
+      current_setting('app.tenant_ref', TRUE) as tenant_id,
+      current_setting('app.user_id', TRUE) as user_id,
+      current_setting('app.is_admin', TRUE) as is_admin
+  `;
+    const row = result[0];
+    if (!row || !row.tenant_id)
+        return null;
+    return {
+        tenantId: row.tenant_id,
+        userId: row.user_id || undefined,
+        isAdmin: row.is_admin === 't',
+    };
+}
+/**
+ * Execute a function with RLS context, automatically cleaning up afterward
+ */
+export async function withTenant(context, fn) {
+    await setRLSContext(context);
+    try {
+        return await fn();
+    }
+    finally {
+        await clearRLSContext();
+    }
+}
+/**
+ * Execute a query with RLS context
+ */
+export async function queryWithTenant(context, queryText, params) {
+    return withTenant(context, async () => {
+        const result = await sql.unsafe(queryText, params ?? []);
+        return {
+            rows: result,
+            rowCount: result.length,
+        };
+    });
+}
+/**
+ * RLS-aware client wrapper
+ */
+export class RLSClient {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Execute query with tenant context
+     */
+    async query(context, queryText, params) {
+        const start = performance.now();
+        try {
+            const result = await queryWithTenant(context, queryText, params);
+            this.logger?.debug('RLS query executed', {
+                tenant: context.tenantId,
+                query: queryText.substring(0, 100),
+                rows: result.rowCount,
+                latencyMs: (performance.now() - start).toFixed(2),
+            });
+            return result;
+        }
+        catch (error) {
+            this.logger?.error('RLS query failed', {
+                tenant: context.tenantId,
+                query: queryText.substring(0, 100),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Execute with tenant context, return first row
+     */
+    async queryOne(context, queryText, params) {
+        const result = await this.query(context, queryText, params);
+        return result.rows[0] ?? null;
+    }
+    /**
+     * Execute with tenant context, return all rows
+     */
+    async queryAll(context, queryText, params) {
+        const result = await this.query(context, queryText, params);
+        return result.rows;
+    }
+    /**
+     * Wrap a function with RLS context
+     */
+    withTenant(context, fn) {
+        return withTenant(context, fn);
+    }
+}
+/**
+ * Create an RLS-aware client
+ */
+export function createRLSClient(logger) {
+    return new RLSClient(logger);
+}

package/dist/transaction.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @singulio/postgres - Transaction Helpers
+ * ACID transaction support with auto-rollback
+ */
+import type { TransactionOptions, RLSContext, QueryResult, QueryRow, Logger } from './types.js';
+/**
+ * Transaction query interface
+ */
+export interface TransactionQuery {
+    /**
+     * Execute a query within the transaction
+     */
+    query<T = QueryRow>(queryText: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Execute and return first row
+     */
+    queryOne<T = QueryRow>(queryText: string, params?: unknown[]): Promise<T | null>;
+    /**
+     * Execute and return all rows
+     */
+    queryAll<T = QueryRow>(queryText: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Execute a command (INSERT/UPDATE/DELETE)
+     */
+    execute(queryText: string, params?: unknown[]): Promise<number>;
+}
+/**
+ * Execute a function within a transaction
+ * Auto-commits on success, auto-rollbacks on error
+ */
+export declare function transaction<T>(fn: (tx: TransactionQuery) => Promise<T>, options?: TransactionOptions, logger?: Logger): Promise<T>;
+/**
+ * Execute a function within a serializable transaction
+ * Best for operations requiring strong consistency
+ */
+export declare function serializableTransaction<T>(fn: (tx: TransactionQuery) => Promise<T>, rlsContext?: RLSContext, logger?: Logger): Promise<T>;
+/**
+ * Execute a function within a read-only transaction
+ * Best for reporting/analytics queries
+ */
+export declare function readOnlyTransaction<T>(fn: (tx: TransactionQuery) => Promise<T>, rlsContext?: RLSContext, logger?: Logger): Promise<T>;
+/**
+ * Create a savepoint within a transaction
+ */
+export declare function savepoint(name: string): Promise<void>;
+/**
+ * Rollback to a savepoint
+ */
+export declare function rollbackToSavepoint(name: string): Promise<void>;
+/**
+ * Release a savepoint
+ */
+export declare function releaseSavepoint(name: string): Promise<void>;
+//# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAwBhG;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpF;;OAEG;IACH,QAAQ,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAEjF;;OAEG;IACH,QAAQ,CAAC,CAAC,GAAG,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAE5E;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACjE;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,EAAE,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,EACxC,OAAO,GAAE,kBAAuB,EAChC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,CAAC,CAoFZ;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,CAAC,EAC7C,EAAE,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,EACxC,UAAU,CAAC,EAAE,UAAU,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,CAAC,CASZ;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,EAAE,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,EACxC,UAAU,CAAC,EAAE,UAAU,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,CAAC,CASZ;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAErE;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElE"}

package/dist/transaction.js

@@ -0,0 +1,138 @@
+/**
+ * @singulio/postgres - Transaction Helpers
+ * ACID transaction support with auto-rollback
+ */
+import { sql } from 'bun';
+import { setRLSContext, clearRLSContext } from './rls.js';
+/**
+ * Build BEGIN statement with options
+ */
+function buildBeginStatement(options) {
+    const parts = ['BEGIN'];
+    if (options.isolationLevel) {
+        parts.push(`ISOLATION LEVEL ${options.isolationLevel}`);
+    }
+    if (options.readOnly) {
+        parts.push('READ ONLY');
+    }
+    if (options.deferrable && options.readOnly && options.isolationLevel === 'SERIALIZABLE') {
+        parts.push('DEFERRABLE');
+    }
+    return parts.join(' ');
+}
+/**
+ * Execute a function within a transaction
+ * Auto-commits on success, auto-rollbacks on error
+ */
+export async function transaction(fn, options = {}, logger) {
+    const start = performance.now();
+    // Begin transaction
+    const beginStmt = buildBeginStatement(options);
+    await sql.unsafe(beginStmt);
+    // Set RLS context if provided
+    if (options.rlsContext) {
+        await setRLSContext(options.rlsContext);
+    }
+    // Create query interface
+    const tx = {
+        async query(queryText, params) {
+            const result = await sql.unsafe(queryText, params ?? []);
+            return {
+                rows: result,
+                rowCount: result.length,
+            };
+        },
+        async queryOne(queryText, params) {
+            const result = await tx.query(queryText, params);
+            return result.rows[0] ?? null;
+        },
+        async queryAll(queryText, params) {
+            const result = await tx.query(queryText, params);
+            return result.rows;
+        },
+        async execute(queryText, params) {
+            const result = await tx.query(queryText, params);
+            return result.rowCount;
+        },
+    };
+    try {
+        const result = await fn(tx);
+        // Clear RLS context before commit
+        if (options.rlsContext) {
+            await clearRLSContext();
+        }
+        // Commit
+        await sql `COMMIT`;
+        const latency = performance.now() - start;
+        logger?.debug('Transaction committed', {
+            isolationLevel: options.isolationLevel ?? 'READ COMMITTED',
+            tenant: options.rlsContext?.tenantId,
+            latencyMs: latency.toFixed(2),
+        });
+        return result;
+    }
+    catch (error) {
+        // Clear RLS context before rollback
+        if (options.rlsContext) {
+            try {
+                await clearRLSContext();
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
+        }
+        // Rollback
+        try {
+            await sql `ROLLBACK`;
+        }
+        catch {
+            // Connection might be broken
+        }
+        const latency = performance.now() - start;
+        logger?.error('Transaction rolled back', {
+            isolationLevel: options.isolationLevel ?? 'READ COMMITTED',
+            tenant: options.rlsContext?.tenantId,
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs: latency.toFixed(2),
+        });
+        throw error;
+    }
+}
+/**
+ * Execute a function within a serializable transaction
+ * Best for operations requiring strong consistency
+ */
+export async function serializableTransaction(fn, rlsContext, logger) {
+    return transaction(fn, {
+        isolationLevel: 'SERIALIZABLE',
+        rlsContext,
+    }, logger);
+}
+/**
+ * Execute a function within a read-only transaction
+ * Best for reporting/analytics queries
+ */
+export async function readOnlyTransaction(fn, rlsContext, logger) {
+    return transaction(fn, {
+        readOnly: true,
+        rlsContext,
+    }, logger);
+}
+/**
+ * Create a savepoint within a transaction
+ */
+export async function savepoint(name) {
+    await sql.unsafe(`SAVEPOINT ${name}`);
+}
+/**
+ * Rollback to a savepoint
+ */
+export async function rollbackToSavepoint(name) {
+    await sql.unsafe(`ROLLBACK TO SAVEPOINT ${name}`);
+}
+/**
+ * Release a savepoint
+ */
+export async function releaseSavepoint(name) {
+    await sql.unsafe(`RELEASE SAVEPOINT ${name}`);
+}