Connection pooling for serverless in NextJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the database client for connection pooling.

NextJS

import { [1] } from '@vercel/postgres';

Drag options to blanks, or click blank then click option'

Apool

BcreateClient

Cconnect

DClient

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'createClient' instead of 'pool' causes no pooling.

Using 'connect' is incorrect as it's not exported here.

The 'pool' export from '@vercel/postgres' is used to manage connection pooling in serverless Next.js apps.

2fill in blank

medium

Complete the code to acquire a client connection from the pool.

NextJS

const client = await pool.[1]();

Drag options to blanks, or click blank then click option'

Aconnect

BgetClient

Cacquire

Dopen

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'getClient' or 'acquire' causes runtime errors as these methods don't exist.

The 'connect' method is used to get a client connection from the pool.

3fill in blank

hard

Fix the error in releasing the client connection back to the pool.

NextJS

await client.[1]();

Drag options to blanks, or click blank then click option'

Aclose

Brelease

Cend

Ddisconnect

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'close' or 'end' closes the connection permanently, breaking pooling.

The 'release' method returns the client to the pool for reuse.

4fill in blank

hard

Fill both blanks to create a query and release the client properly.

NextJS

const result = await client.[1]('SELECT NOW()');
await client.[2]();

Drag options to blanks, or click blank then click option'

Aquery

Brelease

Cexecute

Dclose

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'execute' instead of 'query' causes errors.

Using 'close' instead of 'release' breaks pooling.

Use 'query' to run SQL and 'release' to return the client to the pool.

5fill in blank

hard

Fill all three blanks to implement a safe query with try-finally for connection pooling.

NextJS

const client = await pool.[1]();
try {
  const result = await client.[2]('SELECT * FROM users');
  return result.rows;
} finally {
  await client.[3]();
}

Drag options to blanks, or click blank then click option'

Aconnect

Bquery

Crelease

Dclose

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to release client causes connection leaks.

Using 'close' instead of 'release' breaks pooling.

Acquire client with 'connect', run query with 'query', and release client with 'release' in finally block.

Practice

1. What is the main benefit of using connection pooling in a Next.js serverless app?

easy

A. It automatically scales the number of serverless functions.

B. It reuses database connections to improve speed and avoid connection limits.

C. It caches API responses for faster loading.

D. It encrypts database connections for security.

Solution

1. Step 1: Understand connection pooling purpose

   Connection pooling allows reusing existing database connections instead of opening new ones each time.

2. Step 2: Identify benefits in serverless context

   This reuse improves speed and prevents hitting database connection limits common in serverless environments.

3. Final Answer:

   It reuses database connections to improve speed and avoid connection limits. -> Option B

4. Quick Check:

   Connection pooling = reuse connections [OK]

Hint: Pooling means reusing connections to avoid limits [OK]

Common Mistakes:

• Confusing pooling with caching data
• Thinking pooling scales serverless functions
• Assuming pooling encrypts connections

2. Which code snippet correctly creates a MySQL connection pool using mysql2/promise in Next.js?

easy

A. const pool = mysql2.createPool({ host: 'localhost', user: 'root', database: 'test' }).promise();

B. const pool = mysql2.promise.createPool({ host: 'localhost', user: 'root', database: 'test' });

C. const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test' });

D. const pool = mysql2/promise.createPool({ host: 'localhost', user: 'root', database: 'test' });

Solution

1. Step 1: Recall mysql2/promise usage

   When importing mysql from 'mysql2/promise', mysql.createPool() directly creates a promise-based pool.

2. Step 2: Match correct syntax

   const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test' }); correctly uses the mysql2/promise import.

3. Final Answer:

   const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test' }); -> Option C

4. Quick Check:

   mysql2/promise + mysql.createPool() = correct syntax [OK]

Hint: mysql from 'mysql2/promise'; mysql.createPool() [OK]

Common Mistakes:

• Trying to call createPool directly on mysql2/promise import
• Missing .promise() for async support
• Using wrong import or syntax

3. Given this Next.js API handler using a PostgreSQL pool, what will be the output if the database connection fails?

import { Pool } from 'pg';
const pool = new Pool({ connectionString: process.env.DATABASE_URL });

export default async function handler(req, res) {
  try {
    const client = await pool.connect();
    const result = await client.query('SELECT NOW()');
    client.release();
    res.status(200).json({ time: result.rows[0].now });
  } catch (error) {
    res.status(500).json({ error: 'Database connection failed' });
  }
}

medium

A. Returns JSON with error message 'Database connection failed'.

B. Returns empty JSON object {}.

C. Throws an unhandled exception crashing the server.

D. Returns JSON with current time from database.

Solution

1. Step 1: Analyze try-catch behavior

   If pool.connect() fails, the code jumps to the catch block.

2. Step 2: Check catch block response

   The catch block sends a 500 status with JSON error message 'Database connection failed'.

3. Final Answer:

   Returns JSON with error message 'Database connection failed'. -> Option A

4. Quick Check:

   Error caught = JSON error response [OK]

Hint: Errors in try send JSON error response [OK]

Common Mistakes:

• Assuming unhandled exception crashes server
• Expecting successful time JSON on failure
• Thinking empty JSON is returned

4. Identify the bug in this Next.js serverless function using MySQL connection pooling:

import mysql from 'mysql2/promise';
const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test' });

export default async function handler(req, res) {
  const connection = await pool.getConnection();
  const [rows] = await connection.query('SELECT * FROM users');
  res.status(200).json(rows);
}

medium

A. Missing connection.release() after query.

B. Using getConnection() instead of connect().

C. Pool should be created inside the handler.

D. Query syntax is incorrect.

Solution

1. Step 1: Check connection usage

   The code gets a connection from the pool but never releases it back.

2. Step 2: Understand pooling best practice

   Connections must be released with connection.release() to avoid leaks and exhaustion.

3. Final Answer:

   Missing connection.release() after query. -> Option A

4. Quick Check:

   Always release pooled connections [OK]

Hint: Always release connections after use [OK]

Common Mistakes:

• Forgetting to release connections
• Thinking getConnection() is invalid
• Creating pool inside handler causing overhead

5. You want to optimize a Next.js serverless app connecting to PostgreSQL with connection pooling. Which approach best prevents exhausting database connections during high traffic?

hard

A. Close the pool after each query to free resources.

B. Create a new pool inside each API handler call.

C. Use a new client connection for every query without pooling.

D. Create a single global pool instance reused across requests.

Solution

1. Step 1: Understand serverless connection challenges

   Serverless functions can run many instances, so creating many pools wastes connections.

2. Step 2: Choose pooling strategy

   Creating a single global pool reused by all handlers limits total connections and improves reuse.

3. Final Answer:

   Create a single global pool instance reused across requests. -> Option D

4. Quick Check:

   Global pool reuse prevents connection exhaustion [OK]

Hint: Use one global pool, not new pools per request [OK]

Common Mistakes:

• Making new pool each request causing connection overload
• Not using pooling at all
• Closing pool too early causing errors