Why database connectivity matters in Node.js - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is database connectivity important in Node.js applications?

Choose the best reason why connecting to a database is crucial for most Node.js apps.

A It automatically fixes bugs in the app without developer input.

B It speeds up the app by running all code inside the database server.

C It allows the app to store and retrieve data dynamically, making it interactive and useful.

D It replaces the need for any server-side code in the app.

💡 Hint

Think about what apps do with user information or content they show.

Database connectivity lets apps save and get data like user info or posts. Without it, apps can't remember or change data.

❓ component_behavior

intermediate

What happens if a Node.js app fails to connect to its database?

Consider a Node.js app that tries to fetch user data but the database connection fails. What will likely happen?

A The app will crash or show an error because it can't get the needed data.

B The app will continue normally and show cached data automatically.

C The app will switch to a backup database without any code changes.

D The app will run faster because it skips database calls.

💡 Hint

Think about what happens when the app asks for data but none arrives.

If the app can't connect to the database, it can't get data and usually throws an error or stops working properly.

📝 Syntax

advanced

Identify the correct way to connect to a MongoDB database using Node.js and the official driver.

Which code snippet correctly connects to a MongoDB database using the mongodb package?

Node.js

const { MongoClient } = require('mongodb');
const uri = 'mongodb://localhost:27017';

async function connect() {
  // connection code here
}

A

const client = MongoClient(uri);
client.connect();
console.log('Connected');

B

const client = new MongoClient(uri);
await client.connect();
console.log('Connected');

C

const client = new MongoClient();
await client.connect(uri);
console.log('Connected');

D

const client = new MongoClient(uri);
client.connect(() => console.log('Connected'));

💡 Hint

Remember to create a new MongoClient with the URI and use await to connect.

Option B correctly creates a new MongoClient with the URI and uses await client.connect() to establish the connection.

❓ state_output

advanced

What will be logged after this Node.js database connection code runs?

Consider this code snippet using pg package for PostgreSQL:

const { Client } = require('pg');
const client = new Client({ connectionString: 'postgresql://user:pass@localhost/db' });

async function run() {
  await client.connect();
  const res = await client.query('SELECT 1 AS number');
  console.log(res.rows[0].number);
  await client.end();
}

run();

What will be printed to the console?

A null

B undefined

C Error: connection refused

D 1

💡 Hint

The query selects a constant number 1 as 'number'.

The query returns one row with a column 'number' equal to 1, so res.rows[0].number is 1.

🔧 Debug

expert

Why does this Node.js code throw a 'TypeError: client.query is not a function'?

Examine the code below:

const { Client } = require('pg');
const client = Client({ connectionString: 'postgresql://user:pass@localhost/db' });

async function run() {
  await client.connect();
  const res = await client.query('SELECT NOW()');
  console.log(res.rows[0]);
  await client.end();
}

run();

Why does it throw the error?

A Because <code>Client</code> was called without <code>new</code>, so <code>client</code> is undefined and has no <code>query</code> method.

B Because the connection string is invalid and causes <code>query</code> to fail.

C Because <code>await</code> cannot be used outside an async function.

D Because <code>client.end()</code> is missing a callback function.

💡 Hint

Check how the Client object is created.

The Client constructor must be called with new. Without it, client is not an instance and lacks query.

Practice

1. Why is database connectivity important in a Node.js application?

easy

A. It makes the app run faster without any data storage.

B. It allows the app to save and retrieve data persistently.

C. It helps the app display colors on the screen.

D. It automatically fixes bugs in the code.

Solution

1. Step 1: Understand the role of database connectivity

   Database connectivity lets the app communicate with a database to save or get data.

2. Step 2: Identify the importance for data persistence

   Without database connectivity, the app cannot remember or update information after it stops running.

3. Final Answer:

   It allows the app to save and retrieve data persistently. -> Option B

4. Quick Check:

   Database connectivity = save and retrieve data [OK]

Hint: Database connectivity means saving and getting data [OK]

Common Mistakes:

• Thinking it speeds up the app without data storage
• Confusing database connectivity with UI features
• Assuming it fixes code bugs automatically

2. Which of the following is the correct way to start a database connection in Node.js using a common library?

easy

A. const db = require('mysql').createConnection(config);

B. const db = connect('database');

C. const db = require('db').connect();

D. connect.db('mysql', config);

Solution

1. Step 1: Recognize common Node.js database connection syntax

   Popular libraries like mysql use require('mysql').createConnection(config) to connect.

2. Step 2: Check each option for correct syntax

   const db = require('mysql').createConnection(config); matches the correct pattern; others have wrong method calls or missing parts.

3. Final Answer:

   const db = require('mysql').createConnection(config); -> Option A

4. Quick Check:

   Correct connection syntax = const db = require('mysql').createConnection(config); [OK]

Hint: Look for require + createConnection pattern [OK]

Common Mistakes:

• Using connect() directly without require
• Wrong method names like connect.db
• Missing configuration object

3. What will the following Node.js code output if the database connection fails?

const mysql = require('mysql');
const connection = mysql.createConnection({host: 'localhost', user: 'root', password: 'wrong'});
connection.connect(err => {
  if (err) {
    console.log('Connection error');
  } else {
    console.log('Connected');
  }
});

medium

A. Connected

B. SyntaxError

C. Connection error

D. No output

Solution

1. Step 1: Understand the connection callback behavior

   The connect method calls the callback with an error if connection fails.

2. Step 2: Analyze the error handling in the callback

   If err exists, it logs 'Connection error'; otherwise, 'Connected'. Wrong password causes err.

3. Final Answer:

   Connection error -> Option C

4. Quick Check:

   Error in connect logs 'Connection error' [OK]

Hint: Error in connect callback logs 'Connection error' [OK]

Common Mistakes:

• Assuming it logs 'Connected' even on failure
• Expecting a syntax error from wrong password
• Thinking no output occurs on failure

4. Identify the error in this Node.js database connection code:

const mysql = require('mysql');
const connection = mysql.createConnection({host: 'localhost', user: 'root', password: 'pass'});
connection.connect();
connection.query('SELECT * FROM users', (err, results) => {
  if (err) throw err;
  console.log(results);
});
connection.end();

medium

A. createConnection() requires a callback function.

B. query() method is used incorrectly with wrong parameters.

C. end() should be called before query() to close connection early.

D. Missing callback in connect() causes query to run before connection is ready.

Solution

1. Step 1: Check connection timing

   connect() is asynchronous; without a callback, query may run before connection is ready.

2. Step 2: Identify the impact on query execution

   Running query before connection is established can cause errors or unexpected behavior.

3. Final Answer:

   Missing callback in connect() causes query to run before connection is ready. -> Option D

4. Quick Check:

   connect() async needs callback before query [OK]

Hint: Always use callback or await after connect() before queries [OK]

Common Mistakes:

• Calling end() too early before queries finish
• Thinking createConnection needs a callback
• Misusing query() parameters

5. You want to build a Node.js app that stores user preferences and updates them often. Which approach best ensures data is saved and updated correctly?

hard

A. Connect to the database once at app start, reuse connection for all queries, and close on app exit.

B. Open a new database connection for every query and close it immediately after.

C. Store preferences only in memory variables without database connection.

D. Use database connection only for reading data, not for saving updates.

Solution

1. Step 1: Consider connection efficiency and data consistency

   Reusing one connection reduces overhead and keeps queries consistent.

2. Step 2: Evaluate options for frequent updates

   Opening and closing connections for each query wastes resources; in-memory storage loses data on restart.

3. Final Answer:

   Connect to the database once at app start, reuse connection for all queries, and close on app exit. -> Option A

4. Quick Check:

   Reuse connection for frequent updates [OK]

Hint: Reuse one connection for many queries, close at app end [OK]

Common Mistakes:

• Opening/closing connection for every query wastes resources
• Not using database loses persistent data
• Using DB only for reads misses updates