Why database connectivity matters in Node.js

Introduction

Database connectivity lets your Node.js app talk to a database to save and get data. Without it, your app can't remember or use information.

When you want to save user sign-up details like names and emails.

When you need to show a list of products stored in a database.

When your app must update information, like changing a password.

When you want to keep track of user actions or logs.

When you need to fetch data quickly for reports or dashboards.

Syntax

Node.js

const { Client } = require('pg');

async function main() {
  const client = new Client({
    user: 'user',
    host: 'localhost',
    database: 'mydb',
    password: 'password',
    port: 5432
  });

  await client.connect();

  // Use client to query the database

  await client.end();
}

main().catch(console.error);

This example uses the 'pg' library to connect to a PostgreSQL database.

You create a client with connection details, connect, run queries, then close the connection.

Examples

Example connecting to a MySQL database using the mysql2/promise library.

Node.js

const mysql = require('mysql2/promise');

async function main() {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    database: 'testdb',
    password: 'password'
  });

  // Run queries here

  await connection.end();
}

main().catch(console.error);

Example connecting to a MongoDB database using the official MongoDB driver with async/await.

Node.js

import { MongoClient } from 'mongodb';

const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);

async function run() {
  await client.connect();
  const database = client.db('mydb');
  const collection = database.collection('users');

  // Use collection to find or insert documents

  await client.close();
}

run();

Sample Program

This Node.js program connects to a PostgreSQL database, asks for the current time, prints it, then closes the connection.

Node.js

import { Client } from 'pg';

async function main() {
  const client = new Client({
    user: 'user',
    host: 'localhost',
    database: 'mydb',
    password: 'password',
    port: 5432
  });

  await client.connect();

  const res = await client.query('SELECT NOW()');
  console.log('Current time from database:', res.rows[0].now);

  await client.end();
}

main().catch(console.error);

Important Notes

Always close your database connection to avoid resource leaks.

Use async/await to handle database calls cleanly and avoid callback hell.

Keep your database credentials safe and do not hardcode them in real apps.

Summary

Database connectivity lets your app save and get data.

You connect, run queries, then close the connection.

It is important for apps that need to remember or update information.

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