/**
 * Execute a function within an isolated database transaction
 * Automatically rolls back after execution to prevent data leakage between tests
 *
 * @param pool - PostgreSQL connection pool
 * @param fn - Async function to execute within transaction
 * @returns Promise resolving to function result
 *
 * @example
 * ```typescript
 * it('should create entity', () =>
 *   withTestTransaction(pool, async (client) => {
 *     const result = await ensureFinancialEntity(client, {...});
 *     expect(result.id).toBeDefined();
 *   })
 * );
 * ```
 */
export async function withTestTransaction(pool, fn) {
    const client = await pool.connect();
    try {
        await client.query('BEGIN');
        const result = await fn(client);
        await client.query('ROLLBACK');
        return result;
    }
    catch (error) {
        // Ensure rollback on error
        try {
            await client.query('ROLLBACK');
        }
        catch (rollbackError) {
            // Log rollback failure but throw original error
            console.error('Failed to rollback transaction:', rollbackError);
        }
        throw error;
    }
    finally {
        client.release();
    }
}
/**
 * Execute multiple test functions in parallel, each in its own isolated transaction
 * Useful for testing concurrent access patterns
 *
 * @param pool - PostgreSQL connection pool
 * @param fns - Array of async functions to execute concurrently
 * @returns Promise resolving to array of results
 *
 * @example
 * ```typescript
 * const [result1, result2] = await withConcurrentTransactions(pool, [
 *   async (client) => ensureFinancialEntity(client, params),
 *   async (client) => ensureFinancialEntity(client, params),
 * ]);
 * ```
 */
export async function withConcurrentTransactions(pool, fns) {
    return Promise.all(fns.map(fn => withTestTransaction(pool, fn)));
}
//# sourceMappingURL=test-transaction.js.map