DEV Community: Zechariah Hounwanou

Streamlining Your Contribution: How to Get Your TMDB API Key for LDBflix Contribution

Zechariah Hounwanou — Sun, 12 May 2024 14:13:23 +0000

Developers wishing to contribute to the LBDflix open-source project might not be able to do so without explicit instructions about how to obtain the API key from The Movie Database (TMDB).

In this article, we will guide developers through the process of obtaining their own TMDB API Key and securely storing it in their project development environment so that they can access and contribute to the data easily.

What is LDBflix

LDBflix is a dynamic movie web application that provides information and trailers for a wide range of movies and television shows. It is a comprehensive movie collection for any movie fan, and it also suggests movies and TV episodes to viewers. It is an open-source project that welcomes developers, designers, writers, and movie enthusiasts to cooperate and learn.

This open-source project provides a user-friendly interface for browsing and discovering a large collection of movies and TV episodes. A third-party API is used to obtain data, ensuring up-to-date information.

The platform is created using NextJS and CSS for styling. Here's the GitHub repository.

What is TMDB

TMDB is a community-built Movie and TV Show database that offers a fantastic Application Programming Interface (API) for accessing available movies and television shows. It also provides details about movies and TV shows, such as titles, synopses, release dates, cast lists, and genres.

Once your API key has been generated, you will be able to interact with the TMDB API and retrieve data.

How to Obtain a TMDB API Key

Step 1: Open your browser and enter the phrase "tmdb", and you should see several results.

Step 2: Click on the first result available in the search and it will redirect you to The Movie Database's official home page.

Step 3: You can create an account on TMDB by clicking Join TMDB.

Step 4: Complete the sign-up form with valid credentials, and then click the Sign Up button.

Step 5: After registering for a TMDB account, the next step is to confirm your TMDB account information. The next step is to go to your mailbox. You will receive a Verification required email, and you will need to click the Activate My Account button to complete the process.

Step 6: When you click the Activate My Account button in your email, you will be redirected to the TMDB login page with a banner that says Email Verified. You can now log in by entering your valid details and clicking Login.

Step 7: After successfully logging in, you will be taken to the Dashboard page, which displays all of your account information. Next, you need to generate a TMDB API key for your account by clicking the image icon in the top right corner of your dashboard. Next, locate and click on the Settings option in the dropdown menu.

Step 8: Now that you're on your account's Settings page, you'll need to generate your own API key. To begin, select the API option from the Settings Menu located in the bottom left corner. Next, click on the Create tab and choose the Developer option to register the API Key as a Developer. Following that, you will be taken to a page where you must enter certain credentials and submit a form.

NOTE: After 24 hours, TMDB will validate your request and generate your API Key. Don't panic after submitting; you'll receive an acceptance notification on your dashboard within 24 hours.

Step 9: Once your API Key creation request has been granted, return to the API option in your Settings Menu. The API Key and API Read Access Token have already been generated, but it is the API Key you should be concerned about first.

Congratulations, you have successfully generated your own TMDB API key.

How to Access TMDB Documentations

Now that you've received your API Key, let's look through the documentation to see which APIs are available for consumption.

To begin using TMDB Documentation, return to the API option of your Settings Menu and select the link below the Documentation section.

After that, you should be taken to the Getting Started section of the TMDB API Documentation.

Click on the API Reference tab in the top left corner of the Documentation section to access a list of available APIs. In the left sidebar of the page, you can see and scroll through a list of APIs once you have completed that process.

Voila, you have now explored all the APIs in TMDB. Now, add the API key you created previously to the open-source project so you can contribute to it.

How to Add Your API Key to LDBflix

Step 1: You will need to fork the Github repository where LDBflix is stored. To do so, visit the GitHub repository here and click the *fork * button.

Step 2: Next, clone the forked repository to your machine so that you can add your API Key and contribute features to the open-source project.

To begin, get the forked repository URL and clone the project to your machine.

Open the terminal/command prompt on your machine and execute the following commands:

Clone the Repo

git clone git@github.com:<your github username>/lbdflix.git

Navigate to the cloned directory

cd lbdflix

Install dependencies

npm install

Open the project in your text editor (VSCode)

code .

Step 3: After successfully cloning the project to your machine and opening it in your VSCode Text Editor, your project's folder structure should look like this.

Next, let's integrate the API Key we obtained from TMDB into our cloned open-source project. Your first step will be to create a separate branch for your changes, to do so type the following in your terminal.

Initializing the repository

git init

Create a branch

git branch <branch_name>

Checkout to the created branch

git checkout <branch_name>

Your contribution to the project is now possible since the branch has been created. To get started create a .env file in the root directory of your project and include your API Key.

It should look like this MOVIE_API = <Your API Key>

Step 4: Your API Key has now been successfully added to the project, so you will need to run it to verify everything is working. To do so, type this command in your terminal:

npm run dev

When the command executes successfully without an error, navigate to http://localhost:3000 in your browser to see the UI of your project.

Congratulations, you have successfully added your API key to the open-source project LDBflix, and can now easily contribute to the project.

Conclusion

The objective of this tutorial is to demonstrate how to generate a TMDB API key and use it to contribute to the open-source LDBflix project's front end.

We hope to see your PR soon, and here's to many more coding adventures and contributions ahead.

If you have found this helpful, please consider sharing it with others who might benefit.

From Zero to CRUD Hero: Building Your First Backend API in JavaScript

Zechariah Hounwanou — Tue, 23 Apr 2024 07:30:00 +0000

Application Programming Interface embed also known as API is the fundamental concept for interacting with data stored in a database. The process of setting it up can be time-consuming and difficult without adequate guidance. As a developer, you must understand how to efficiently develop CRUD (Create, Read, Update, and Delete) API for web applications.

For a developer to build a robust and flexible API for applications, the ability to set up routes, handle HTTP requests, send back HTTP responses, connect to the MongoDB database, and implement CRUD operations by leveraging on the capabilities of Node.js, Express.js, and MongoDB is needed.

This tutorial will walk you through the step-by-step process of building a RESTful CRUD API, from setting up the project development environment to connecting with the MongoDB database, then defining a data model with Mongoose which will interact with the MongoDB database cluster, then implementing the CRUD functionalities using Express routes and finally testing the API endpoints. You will also learn how to handle validations and errors. Upon completing this tutorial, you will be able to build dynamic CRUD APIs with efficient and safe data management capabilities.

What is Node.js

Node.js is a cross-platform runtime environment that runs JavaScript code on the server rather than in the browser. Node.js helps to create scalable and high-performance applications.

What is Express.js

Express.js is a Node.js framework that provides a robust set of features for developing Web APIs. It integrates with Node.js, making the creation of APIs simpler.

Architecture

The API will be built using a three-layer architecture based on Node.js, Express.js, and MongoDB.

The Data Access Layer is where we'll communicate and interact with our database.

Inside the Controller layer, we will handle the entire business logic that is associated with our endpoint's HTTP requests and responses.

The Router layer will send URLs to the appropriate controller functions. The router functionality will be obtained from Express.
Our API architecture for building CRUD APIs is straightforward, simple, and easy to understand.

What is CRUD API?

Since the beginning of this article, we have been hearing the term CRUD API. Let's take a closer look at it now.

A CRUD API refers to the basic operations that can be performed on the data in a database to enable it to interact with the application. They are used as building blocks in web development to create applications that require data persistence and manipulation.

So, the phrase CRUD refers to the ability to CREATE, READ, UPDATE, and DELETE entities from a database.

Understanding Each Functionality/Operation

CREATE: This functionality allows the creation of new data in the database.

READ: This functionality allows the retrieval of existing data from the database.

UPDATE: This functionality enables modification of existing data that is already in the database.

DELETE: This functionality allows the removal of existing data that is no longer wanted from the database.

Prerequisite

You do not need to be an expert to follow along with this tutorial, but you will need the following:

Solid understanding of JavaScript
Knowledge of Node.js and Express.js.
Download and install Node and Postman on your machine.
Download and install the VSCode text editor on your computer.

Setting Up Application Development Environment

This tutorial will use VSCode, but any text editor should work. To begin, let's create our development environment. We will not complicate the setup but rather create a simple and orderly project structure for our RESTful CRUD API. To make things easier, we'll split the following sections into two:

Setting up the project and installing dependencies.
Creating the Basic Express Server.

Setting up the project and installing dependencies

By typing the following command in our command prompt or command line interface, we can construct the overall project structure, including all relevant folders and files.

Navigating to the Desktop

cd Desktop

Create a project folder and navigate into it

mkdir book-management-api && cd book-management-api

Create a src folder and navigate into it

mkdir src && cd src

Create subfolders in the src folder

mkdir model && mkdir controllers && mkdir routes && mkdir db

We need to move one level up since we are in the src folder

cd ..

Create an entry point for our API in the root directory

touch index.js

Initialing our node app and creating a package.json file

npm init –y

When you run the above commands, your package.json file and application project structure should be produced. Now launch your project in VSCode using the command below.
code .

Now that you've successfully set up your development environment, your package.json file should look like the above. Next, we'll add additional development dependencies to our project. To install, open a terminal and enter the following command.

npm install express dotenv mongoose

Express: a flexible Node.js web app framework
Dotenv: it loads environment variables from a .env file
Mongoose: it is a MongoDB object modeling tool designed to work in an asynchronous environment.

After installing the essential dependencies, your updated package.json file should look like this:

Creating the Basic Express Server

Now let's configure our web server. In the entry file index.js, add the following code:

require("dotenv").config();
const express = require("express");

const app = express();

app.get("/", (req, res) => {
  res.send("Hey! Sever is Up.");
});

const PORT = process.env.PORT || 5000;

app.listen(PORT, () => {
  console.log(`Server Listening on Port ${PORT}`);
});

The code above accomplishes the following;
(i). We imported dotenv and used the .config() function to initialize it instantly.
(ii). We imported Express and assigned it to a variable named app. This variable now has access to all express methods.
(iii). Then we create a simple route (/) that sends "Hey! Server is up." We received a response when we accessed it.
(iv). Finally, we listen for all incoming requests on port 5000, which we have set as our server origin.

Let’s start the server, go back to your terminal, and run this command:

To Start the server

node index.js
Once everything is completed, open your browser and navigate to http://localhost:5000; you should see "Hey! Server is up" displayed on the screen.

We have one drawback with the node index.js command we used before, it restarts our server every time the file is altered. To make it easier to execute our Node program, we'll add a new start script to our package.json file. Use the command below to install it:

npm install -D nodemon

Once installed, insert the following script into the package.json file:

 "scripts": {
    "start": "nodemon index.js"
  },

The package.json file should look like this:

Use the following command to run the server and verify that everything is working correctly:

npm run start

NOTE: Always move to the root directory before running the server.

The message in the terminal will indicate whether or not the above command has launched the Express server.

From what we can see above our express server is running. You will also see the image below if you go to the URL http://localhost:5000 in your browser

Voila! The project is perfectly set up. In the next section, we will set up our MongoDB Atlas account, Database Cluster, and then retrieve our connection string from MongoDB.

How to Connect a Node.js application to a MongoDB Database Cluster.

In this part of the tutorial, we'll connect our MongoDB database cluster to our Node application using the connection string and also configure our Node application to connect to our database. To make learning easier, we have divided this section into 3 parts:

Setting up MongoDB Atlas, setting up the database cluster, and retrieving the connection strings.
Configuring and Connecting the Node application to the Database.
Modifying the Entry File to connect to our Express Server.

Setting up MongoDB Atlas, setting up database cluster, and retrieving the connection strings.

We will set up our MongoDB database, and then retrieve our connection string.

First, visit MongoDB Atlas and create an account, or sign in if you already have one. This article will guide you through the process of creating a MongoDB account. You should be redirected to your dashboard once you have completed the process. Locate the Connect button and click it.

The Drivers option will appear in the modal, select it so we can connect to our application immediately.

Another modal will appear. Follow the steps below to set up your MongoDB driver and get your connection string:

Select the latest Node.js driver and version.
Install the driver package with NPM and install MongoDB.
Copy and save it somewhere. The connection string will be used to connect the node application to MongoDB.

We've successfully set up our MongoDB Atlas account, configured our MongoDB Cluster, and obtained the connection string.

Configuring and Connecting the Node application to the Database.

Create a .env file in the root directory. It will be used to securely store all of our application's sensitive information. Assign a value name to the connection string inside the .env file.

MONGO_URL=mongodb+srv://<databaseUsername>:<databasePassword>@nodeexp.4glzj53.mongodb.net/BOOK-LISTING-API?retryWrites=true&w=majority

Note: Replace the above-mentioned database username and password with your own.

Within the db folder we created earlier, create a new file named connect.js. You can accomplish this by opening up the terminal and entering the following command:

Move to the src folder and then move to the db folder as well

cd src && cd db

Create a connect.js file

touch connect.js

Navigate from the db folder and then move back to the root folder

cd .. && cd ..
Now, our Node application's folder structure should look like the image below, with the newly created file included.

Next, we need to define a method within the connect.js file that facilitates the connection between our Node.js application and the database. Include the following code in the connect.js file.

const mongoose = require("mongoose");

const connectDB = (url) => {
  return mongoose.connect(url);
};

module.exports = connectDB;

In the code above, we imported Mongoose and constructed a connected function that returns a Promise that can be resolved or rejected via the URL, using the Mongoose connect() method. URL represents the connection string that should be added to the .env file.

Modifying the Entry File to connect our Express Server

In index.js, import the connectDB function at the top and construct a function that connects to our database and launches the server, which will listen for incoming requests once the connection is established.

const connectDB = require("./src/db/connect");

const start = async () => {
  try {
    await connectDB(process.env.MONGO_URL);
    app.listen(PORT, () => {
      console.log("Database & Node app connected Successfully");
    });
  } catch (error) {
    console.log(error);
  }
};

start();

Because our connectDB function returns a Promise, the preceding code uses async/await in its start function. The Express server will automatically begin listening for incoming requests once the asynchronous function is resolved and the database connection is established.

After restarting the Node application, you should see the above message, which indicates that your database and application have been synchronized. Good on so far, Let's keep going.

Creating a RESTful CRUD API.

Node JS uses the MVC (Model View Controller) architecture. It's a design pattern. Based on the idea, we will create the following API endpoints for our Book Management:

POST /book - Create or add a new book.
GET /book - Retrieve all books available.
Get /book/:id - Retrieve a specific book.
PATCH /book/:id - Update a book.
Delete /book/:id - DELETE a book.

In the first step, we will create the model, followed by the CRUD API operations which will store and retrieve all data in MongoDB.

Creating a Model

A model is a fancy constructor derived from a schema. They create and read documents from the underlying MongoDB database. In other words, they form part of the development that represents and handles data. Models are the blueprints that organize our application's data. They describe what can be created, read, updated, and deleted as well as the structure, behavior, and actions that are allowed. We can define our data structure with Mongoose's schema.

Create a Book.js file within the model folder. To accomplish this, run the following commands:

Move to the src folder and then move to the db folder as well

cd src && cd model

Create a book.js file (To Define Model structure)

touch Book.js

Navigate from the db folder and then move back to the root folder

cd .. && cd ..

After executing the command to create the Book.js model file, our Node application's folder structure should look like the image below, with the newly created file included.

Next, we'll create a simple book schema with its fields included. In the newly created Book.js file, include the following code:

const mongoose = require("mongoose");

const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  publicationYear: Number,
  isStared: Boolean,
});

const Book = mongoose.model("Book", bookSchema);

module.exports = Book;

With the code above we accomplish the following.
(i). Imported the Mongoose library to communicate with MongoDB in our Node.js project.
(ii). Used mongoose.Schema() to create the database schema structure for our book document in the MongoDB database.
(iii). Title, Author, PublicationYear, and isStared indicate the specific fields in each book document.
(iv). The mongoose.model() function creates a model based on the database schema structure we supplied. In addition, we exported the Book model so that it could be reused in other files.

Building a CRUD API that uses MongoDB

Now that we have structured the schema of our API, let's start by talking about the two most critical components of a RESTful CRUD API: controllers and routes.

Controllers are responsible for processing data, making decisions, and orchestrating API flows. They receive requests from routes, interact with the model, and determine the response to give to the client. They include business logic for handling individual requests and generating responses.

Route functions are similar to maps, directing incoming requests to the proper location inside the application. They define which URLs clients can access and what happens when they are visited. Routes are paths users can follow to explore your application, and each route corresponds to a specific function or collection of functions that process requests and respond to them.

How Controllers and Routes Work Together in Node.js Applications

Routes serve as the entry point for receiving requests in a Node.js application. When the router receives the request, it determines which route should handle it depending on the URL and HTTP method.

Next, after identifying the right route, the router calls the controller function associated with it. A controller executes business logic by retrieving data from the request and using it to perform actions such as validating input, generating a response, and retrieving data from the database.

After processing the request, handling the business logic, and generating a response, the controller returns it to the router, which sends it back to the client.

Creating a Controller

Create a file called bookControllers.js in the src/controllers folder. To accomplish this, run the following commands:

Move to the src folder and then move to the db folder as well

cd src && cd controllers

Create a bookController.js file in the controllers folder

touch bookControllers.js

Navigate from the db folder and then move back to the root folder

cd .. && cd ..

After executing the command to create the bookControllers.js file, our Node application's folder structure should look like the image below, with the newly created file included.

Next, we need to add the following functions to bookController.js, which will function as a communication interface with the Book model, as well as a method to handle CRUD API business logic, as well as a method to forward responses to other parts of the application.

const Book = require('../model/Book');

const createBook = (req, res) => {};
const getAllBooks = (req, res) => {};
const getSingleBook = (req, res) => {};
const updateSingleBook = (req, res) => {};
const deleteBook = (req, res) => {};

module.exports = {
  createBook,
  getAllBooks,
  getSingleBook,
  updateSingleBook,
  deleteBook,
};

Let's examine each controller function in the bookController.js file one by one to see how it implements the business logic.

Logic 1: Create a book

Inside the entry file index.js, add the following built-in Express middleware function:

app.use(express.json());

The code above creates middleware that parses incoming JSON data from the request body and makes it available for your express application in req.body.

Note: This is required for managing JSON data in the application, such as processing data submitted via forms or API requests.

Next, open the bookController.js file. Using the Book model, we can create a document for every book in our database cluster.

const createBook = async (req, res) => {
  const book = await Book.create(req.body);
  res.status(201).json({book})
};

Logic 2: Retrieve all books.

Next, inside the bookController.js file. To access the complete list of books available in our API, use the .find({}) function on the Book model.

const getAllBooks = async (req, res) => {
  const books = await Book.find({});
 res.status(200).json({books})
};

Logic 3: Retrieve a Single Book

Our next step will be to retrieve a single book from the database using its unique ID.

const getSingleBook = async (req, res) => {
  const { id: bookId } = req.params;
  const singleBook = await Book.findOne({ _id: bookId });
  res.status(200).json({ singleBook });
};

The code above accomplishes the following:

(i). Assign the ID parameter from the request parameter object req.params to a variable called bookId. When you make a request, the URL will include the ID.
(ii). The Book.findOne() method searches the database for a single document with the _id field matching the bookIdfrom the request parameters.

Logic 4: Update a book

Next, we'll update a book document in the database.

const updateSingleBook = async (req, res) => {
  const { id: bookId } = req.params;
  const singleBook = await Book.findOneAndUpdate({ _id: bookId }, req.body, {
    new: true,
    runValidators: true,
  });
  res.status(200).json({ singleBook });
};

In the code above, the following is done:
(i). The const {id: bookId} = req.params method extracts the id parameter from the request and applies it to the bookId variable.
(ii). The findOneAndUpdate() method changes a single book document stored in the database.
(iii). It searches for a book document using the bookId and changes it with data from the request body.
(iv). While the new:true option returns the revised document, the runValidators:true option executes Mongoose validators.

Logic 5: Delete a book

Finally, removing a single book from the database depends on its ID. Add the code below to the bookController.js file.

const deleteBook = async (req, res) => {
  const { id: bookId } = req.params;
  const deleteBook = await Book.findOneAndDelete({ _id: bookId });
  res.status(200).json({ deleteBook });
};

The above code performs the following:

(i). Assign the id parameter from the request parameter object req.params to a variable called bookId.
(ii). The Book model's findOneAndDelete() method deletes a single book document with a matching _idfield from the database.

We have developed all the business logic for the CRUD API operations we will be using. To generate the operations, we used the async and await keywords since the database query takes time, which is when the Node.js asynchronous attribute comes into play. The JSON response we return with each operation includes the status code as well as the book document stored in our database.

Defining Routes

When a client sends a request for an endpoint via HTTP requests (GET, POST, PATCH, DELETE), we need to define how the server will respond by setting up the routes.

Create a file called bookRoute.js in the src/routes folder. To do this task, open your terminal and type the following commands:

Move to the src folder and then move to the db folder as well

cd src && cd routes

Create a bookRoutes.js file in the controllers folder

touch bookRoutes.js

Navigate from the db folder and then move back to the root folder

cd .. && cd ..

After executing the command to create the bookRoutes.js file, our Node application's folder structure should look like the image below, with the newly created file included.

Next, we'll set up routes for each controller. Include the following code content:

const express = require("express");
const {
  createBook,
  getAllBooks,
  getSingleBook,
  updateSingleBook,
  deleteBook,
} = require("../controllers/bookControllers");
const router = express.Router();

router.post("/", createBook);
router.get("/", getAllBooks);
router.get("/:id", getSingleBook);
router.patch("/:id", updateSingleBook);
router.delete("/:id", deleteBook);

module.exports = router;

In the code snippet,
(i). Our API is built using the Express package, which provides the functionality that we need.
(ii). Express Router is middleware that organizes application routes. The const router = express.Router() method is used to create a new router object using Express Router.
(iii). const {...} = require("../controllers/bookControllers")imports all business logic functions from bookControllers.js.
(iv). There are four types of routes: router.post, router.get, router.patch, and router.delete, linked by URL patterns and controllers.
(v). We export the router object for use in index.js.

Finally, we must register the bookRoute.js file in our entry file index.js so that any calls to endpoints are redirected to the correct URL path. To accomplish this, we'll add the following code to the index.js file:

const bookRouter = require("./src/routes/bookRoutes");

Use the app.use() function, specifying the path and router handler.

app.use("/api/v1/books", bookRouter);

When we access the URL http://localhost:5000/api/v1/books, the router is activated. It effectively functions as a filter, determining when a particular set of routes should be used.

Here's the whole complete code for the index.js file:

require("dotenv").config();
const express = require("express");
const connectDB = require("./src/db/connect");
const bookRouter = require("./src/routes/bookRoutes");

const app = express();

app.use(express.json());

app.get("/", (req, res) => {
  res.send("Hey! Sever is Up.");
});

app.use("/api/v1/books", bookRouter);

const PORT = process.env.PORT || 3000;

const start = async () => {
  try {
    await connectDB(process.env.MONGO_URL);
    app.listen(PORT, () => {
      console.log("Database & Node app connected Successfully");
    });
  } catch (error) {
    console.log(error);
  }
};
start();

Congratulations! We have successfully integrated the MongoDB database into our Node.js application and built the CRUD API action. Before we test our API, let's add some basic validation and error handling to improve its reliability and usability.

Basic Validation and Error Handling

Let's work on improving our CRUD API now that it has connected to our MongoDB cluster and we have set up CRUD API operations.

For any API, error handling and data validation are crucial to ensuring the API responds appropriately to incorrect inputs and unexpected scenarios, thus improving the user experience.

If a user tries to add a book without a title, author, or publication year, they will be unable to do so. Without effective validation, our database may contain incomplete data. When error validation and error handling are in place, users will be informed of what went wrong rather than left in the dark.

Adding basic validation

As a first step, let's validate our Book model. Add basic validation to Book.js in the model folder.

const mongoose = require("mongoose");

const bookSchema = new mongoose.Schema({
  title: { type: String, required: [true, "Please Provide a Title"] },
  author: { type: String, required: [true, "Please Provide Author Name"] },
  publicationYear: {
    type: Number,
    required: [true, "Please Provide Publication Year"],
  },
  isStared: { type: Boolean, default: false },
});

const Book = mongoose.model("Book", bookSchema);

module.exports = Book;

Mongoose will produce an error if we create a book without a title, author, or publication year because those fields are required, and the error message will explain what went wrong.

Implementing error handling

An effective error management process involves detecting errors and responding appropriately to them. To handle errors graciously, let's improve our bookController.js CRUD API action.

Create a Book with Error Handling

const createBook = async (req, res) => {
  try {
    const book = await Book.create(req.body);
    res.status(201).json({ book });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

Retrieving All Books with Error Handling

const getAllBooks = async (req, res) => {
  try {
    const books = await Book.find({});
    res.status(200).json({ books });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

Get a Single Book with Error Handling

const getSingleBook = async (req, res) => {
  try {
    const { id: bookId } = req.params;
    const singleBook = await Book.findOne({ _id: bookId });
    if (!singleBook) {
          return res.status(404).json({ msg: `No Book with Id ${bookId}` });
    }
    res.status(200).json({ singleBook });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

Update the Book with Error Handling

const updateSingleBook = async (req, res) => {
  try {
    const { id: bookId } = req.params;
    const singleBook = await Book.findOneAndUpdate({ _id: bookId }, req.body, {
      new: true,
      runValidators: true,
    });
    if (!singleBook) {
          return res.status(404).json({ msg: `No Book with Id ${bookId}` });

    }
    res.status(200).json({ singleBook });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

Delete a Book with Error Handling

const deleteBook = async (req, res) => {
  try {
    const { id: bookId } = req.params;
    const deleteBook = await Book.findOneAndDelete({ _id: bookId });
    if (!deleteBook) {
      return res.status(404).json({ msg: `No Book with Id ${bookId}` });
    }
    res.status(200).json({ deleteBook });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

We implemented try-catch blocks in all of our CRUD API operations to ensure that every issue detected is handled appropriately. With these additions, our CRUD API now includes comprehensive error handling and validation capabilities. This not only makes our API more stable but also enhances the user experience by displaying clear and informative error messages.

Here is the complete code for the bookController.js file:

const Book = require("../model/Book");

const createBook = async (req, res) => {
  try {
    const book = await Book.create(req.body);
    res.status(201).json({ book });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

const getAllBooks = async (req, res) => {
  try {
    const books = await Book.find({});
    res.status(200).json({ books });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

const getSingleBook = async (req, res) => {
  try {
    const { id: bookId } = req.params;
    const singleBook = await Book.findOne({ _id: bookId });
    if (!singleBook) {
      return res.status(404).json({ msg: `No Book with Id ${bookId}` });
    }
    res.status(200).json({ singleBook });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

const updateSingleBook = async (req, res) => {
  try {
    const { id: bookId } = req.params;
    const singleBook = await Book.findOneAndUpdate({ _id: bookId }, req.body, {
      new: true,
      runValidators: true,
    });
    if (!singleBook) {
      return res.status(404).json({ msg: `No Book with Id ${bookId}` });
    }
    res.status(200).json({ singleBook });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

const deleteBook = async (req, res) => {
  try {
    const { id: bookId } = req.params;
    const deleteBook = await Book.findOneAndDelete({ _id: bookId });
    if (!deleteBook) {
      return res.status(404).json({ msg: `No Book with Id ${bookId}` });
    }
    res.status(200).json({ deleteBook });
  } catch (error) {
    res.status(400).json({ msg: error });
  }
};

module.exports = {
  createBook,
  getAllBooks,
  getSingleBook,
  updateSingleBook,
  deleteBook,
};

In the next section of the tutorial, we will test our CRUD API to ensure its stability and robustness. We are close to the finish line.

Testing the CRUD API

After implementing error handling and validation, it is critical to test our CRUD API. Testing ensures that everything works as planned and detects any problems before they affect our users. Let's get started testing our CRUD API using Postman.

Test each endpoint

To create a Book API, send a POST request to http://localhost:3000/api/v1/books with a JSON body that includes the book title, author, and publication year.

Send a GET request to http://localhost:3000/api/v1/books to retrieve a list of all books available in the database.

To retrieve a single book, use the GET method and include the Book ID in the URL. If the Book ID is incorrect, it will return an error message; however, if the Book ID is correct, it will provide detailed information about that book.

The content of a book can be updated by submitting a PACTH request with the new data for the specified Book ID. You will get an error message if the Book ID is incorrect. The new data should, however, be inserted correctly into the book.

To delete a book from the database, use the DELETE method on the book endpoint and enter the Book ID.

Congratulations! We did it. After testing the CRUD API we created, they are now fully operational. The tutorial started with setting up our development environment and ended with building our API. That's an impressive achievement, and we should be proud of it.

Conclusion

That was a fantastic ride. I enjoyed creating this piece of content for you and learned a lot in the process. Building a basic CRUD API from scratch is a difficult task that demands patience, perseverance, and the willingness to learn. Fortunately for me, you have shown all of these qualities and more.

In this tutorial, we looked at backend development by creating a simple Book CRUD API with Node.js and Express.js. This tutorial covered a wide range of topics, including setting up our development environment, creating our MongoDB Atlas account and retrieving our connection string, developing CRUD APIs using Express.js and Node.js, and testing them using Postman.

Congratulations on creating your CRUD API with Node.js and Express! Here's to many more coding adventures ahead. May the codes be with you!

If you could provide feedback, I would greatly appreciate it. Please post it in the comments section. If you find this tutorial helpful, please consider sharing it with others who might find it helpful too.

Demystifying HTTP: The Secret Language of the Web

Zechariah Hounwanou — Thu, 28 Mar 2024 08:00:00 +0000

In the early days of the web, there was no standard way for the browser to connect to a server. The functionality of web applications was limited because the HTTP protocol lacked valid support for various actions such as submitting form data, updating resources, or deleting resources. After all, that was beyond the simple HTML document retrieval.

HTTP methods were created to provide a uniform language for communicating on the web. These methods are globally understood by the browser and used to communicate with the server regarding what information is required or what action should be taken. There are many HTTP methods to choose from, each of which allows browsers and servers to interact with each other in various ways.

The purpose of this article is to provide you with a better understanding of the many HTTP protocols available, how data travels across the web, and how browsers and servers work together to gather accurate data.

What is HTTP?

HTTP stands for Hypertext Transfer Protocol, and it serves as a communication channel between the browser and the web server. When a website's URL is entered into a browser, it sends an HTTP request to the server. The server receives the information from the request and sends an HTTP response back to the browser, which then displays the necessary information.

Evolution of HTTP

During the early days of the internet, HTTP/0.9 was a simple protocol for retrieving only HTML documents. As the web evolved, HTTP/1.0 was introduced as a more robust way to communicate between browsers and servers. It included features such as headers and status codes, but it lacked efficiency and performance, particularly when loading multiple resources simultaneously.

HTTP/1.1 was then designed to address that issue with various enhancements such as persistent connections and caching, which dramatically improves web surfing performance. HTTP was later updated to accommodate richer content and more complicated interactions. There were more advancements in HTTP/2, including multiplexing, header compression, and server push, which improved performance and minimized latency.
Today, HTTP not only retrieves HTML web documents but also accesses databases, images, and web content. These resources are accessible with the help of APIs, and we send requests to the API and receive responses through the HTTP protocol, which allows for seamless exchange of data on the web.

How is Data Exchanged on the Web?

When we open our favorite search engine and type in a web address such as www.hashnode.com or www.twitter.com, we send a request message to the server in charge of serving those resources, and the server answers by sending a response message.

Assuming we were building a business listing application, there would be a search bar, a table to list all businesses, and the ability to search by name, state, and city. Having all business information manually coded into the business listing app would slow down the app and it would be difficult to update manually.

Instead, the app could use an API to obtain the business listing data. The app would determine the user's location, then send a request to the server and show businesses of all kinds available in the user’s location. Users can choose from a variety of request methods depending on what they are trying to accomplish with the app. A response from the server would include business information plus a few more details, depending on the API.

To keep track of requests associated with that address, the business listing app communicates with a server application located somewhere. When it receives a request, it works to fulfill it by either reading from a database, using another API, or performing a programmatic computation using the data provided by the user.

Types of HTTP Methods

HTTP is a protocol that allows the browser and the server to exchange requests and responses. It is important to note that while each method implements a different semantic, they all share some common characteristics.

POST Request

The POST request submits an entity to a specified resource, and the entity data is stored in the HTTP request body when making the request. Successful POST requests will return a 201 response code.

To add new business data to our listing API, we can use the POST method.

GET Request

A GET request is used to retrieve data from a specified resource. A successful GET request has a status code of 200 and returns a response providing the requested information. Depending on how the API is structured.

In our business listing app, we can use a GET method to obtain business information available for a certain city or the entire country.

PUT Request

The PUT requests are used to update an entity of a specific resource available on the server. The PUT request updates the entire entity with the data given in the HTTP request body. If we want to update a portion of our resource with a PUT request, we must include the entire resource's data. Otherwise, it will create a new resource. The next HTTP request will demonstrate how to overcome this obstacle.

In our business listing app, we can update each business' information using the PUT method.

PATCH Request

In a PATCH request, a resource is partially updated. We only need to provide the data that needs updating when using the PATCH method.
When a PATCH request is made, only the field that needs to be updated is updated, whereas when a PUT request is made, the whole resource is updated, even if only one field needs to be changed.

To update the address of a business in our business listing app, we can use the PATCH method.

DELETE Request

We use the DELETE request to remove a specific entity or resource from the server. The business listing app allows us to remove a business from the app if we no longer wish to list it.

CONCLUSION

In this tutorial, we have learned about how the browser communicates with the server and how we can use HTTP requests available to exchange data on the web. If you have found this helpful, please consider sharing it with others who might benefit.

Thank you for Reading.

Conquer the Challenge: A Streamlined Guide to Connecting MongoDB to Your Node Application

Zechariah Hounwanou — Tue, 12 Mar 2024 08:00:00 +0000

After creating my MongoDB Atlas account and setting up my MongoDB Atlas cluster for the first time, a big challenge arose. I didn't know what to do next. I asked myself, how can I connect to my database? What is the process for inserting data into the database? What are the options for querying the database? Those were the few questions that popped into my head. As soon as I realized these questions had to be answered, I began looking for answers. That's when I realized I needed a connection string to establish a successful connection between my Node.js application and my MongoDB cluster.

The purpose of this article is to provide you with the necessary information on how to seamlessly connect your Node.js application to your MongoDB Atlas Cluster, revealing the full potential of a scalable and flexible database solution. From creating the connection string to establishing a successful connection integration, we'll help you make sure your application communicates efficiently with MongoDB.

Prerequisites

To follow along with this article and seamlessly connect your MongoDB Cluster to your Node application, the following are necessary:

Installation of Node and NPM on your machine.
Basic understanding of JavaScript, Node.js, and Express.js.
Have a MongoDB Atlas account and already set up a Cloud Cluster. You can get the guide here if you haven't already.

What is a Connection String?

A MongoDB connection string is a piece of text that instructs the MongoDB client such as your Node.js application on how to establish a connection with the MongoDB cluster. In other words, it serves as a secret passcode that connects your Node.js application to the MongoDB cluster.

A connection string contains vital encoded information, such as the cluster's servers, the database user's password and username, and the name of the database used for query execution. The database driver requires all of these to locate and connect to the database.

Find the MongoDB Connection String.

Before we can obtain the connection string, we must first determine who will have access to our database and prevent others from altering it.

As you can see, a user is already available. We have already set up our MongoDB Cluster by providing a database username and password. If you skip that step or want to grant another user access to the database, then click the Add New Database User button.

Now that we understand what a connection string is and how vital it is for establishing a seamless connection, we need to retrieve it and use it to connect our Node.js application to our MongoDB cluster. To accomplish this, we will break this guide down into 3 sections:

Find the MongoDB Connection String.
Setting up the Development Environment for a Node.js application.
Connecting a Node.js application to a MongoDB cluster.

Find the MongoDB Connection String.

Before we can obtain the connection string, we must first determine who will have access to our database and prevent others from altering it.

After clicking the Add New Database User button, a modal will appear. Specify the new user's credentials, such as their username and password.

To configure database privileges for the new user, scroll down the modal after adding the new user credential. Click the Add a Built-in Role button.

Select the appropriate role for that user from the selection list. To complete the process, click the Add User button after adding the new user to the database.

Note: Before saving, a role must be selected for the new user, else even if the user's credentials are valid, they will not be able to connect to the MongoDB cluster.

Next, we'll set up Network Access, which specifies where we may access our database from. As you can see, an IP address is already available when we set up our MongoDB cluster, we included the IP address from which we will access our database. If you have skipped that step when setting up your cluster or you want to add an IP address to access the database, click on the Add IP Address option.

After hitting the Add IP Address button, a modal will appear allowing us to choose where we will access our database. Because we will be working locally at first, we can provide database access to our machine's current IP address, but once we deploy the web service, we must change the IP address to the host IP address, or we can choose Allow Access from Anywhere, which I recommend using when working locally.

To connect to our Node.js application, which we will be developing shortly, we need to retrieve our connection string.

In the Deployment section of the Sidebar, click on Database. This will take you to the MongoDB cluster that we have already created. To retrieve our connection string, we'll need to click the **Connect **button.

Once we click Connect, a modal will appear. Since we want to connect to our application immediately and without stress, we will use the MongoDB native driver option.

Next, we'll choose the connection method we'll use:

Select the latest Node.js driver and version.
Use the command to install the driver package.
Copy and keep the connection string for connecting the Node.js app to the MongoDB cluster very close to you.

We have now successfully configured our MongoDB Cluster's network and database access, as well as obtained our connection string. We'll be building our Node.js application.

Setting up the Development Environment for a Node.js application

In this guide, we will use VSCode, but any text editor should work. To begin, let's create our Demo Node.js application and install the required dependencies. To make things easier, we'll divide this piece into 2 sections:

Project Setup and Dependency Installation.
Create a Basic Express Server

Project Setup and Dependency Installation

Open the terminal or command prompt on your machine and run the following commands:

cd Desktop

mkdir demo-app && cd demo-app

touch app.js

npm init –y

After running the commands above correctly, your node.js application should look like this in VSCode.

Create a Basic Express Server

To set up a basic express server for Node.js, type this command in your terminal.

npm install express

Express framework helps developers develop APIs using Node.js. Once installed, Express should be present in the dependencies object.

For our server to run inside of the app.js file, we must import express, initialize it with a variable, create routes, and listen to port 5000.

const express = require("express");

const app = express();

app.get("/", (req, res) => {
  res.status(200).send("Welcome To The Demo App");
});

const port = 5000;
app.listen(port, () => {
  console.log(`Server Running on port ${port} `);
});

As a next step, we'll add a new start script to the package.json file to make it easy to execute the Demo-App project. The node app.js command restarts our server whenever we make changes to the file. However, we can fully avoid this by running our development server on Nodemon.

npm install -D nodemon

Insert the following script into the package.json file.

"scripts": {
    "start": "nodemon app.js"
  },

The package.json file should look like this

To see if everything is working properly, execute the project using the following command:

npm run start

Note: Always move to the root directory before running the server.

The message in the console indicates whether or not the above command launches the express server, from what we can see our Express server is running.

Also, if we go to the URL http://localhost:5000/ in our browser, we will get the image below:

Great! The project is set up and operating nicely. The next section will be to link our node.js application to our MongoDB cluster.

Connecting a Node.js application to a MongoDB cluster.

We will now connect our MongoDB cluster to our Node.js application using the connection string we obtained before. To begin this phase, we will install the dependencies necessary for our project.

npm install mongoose dotenv

Which will install the following packages:

Mongoose: An ODM (Object Data Modeling) library for MongoDB.

Dotenv: loads environment variable from a .env file.

Create a .env file to safely store sensitive information like the connection string. Open a terminal and run the following command:

touch .env

Note: Always create this file in the root directory

In the.env file, assign a variable to the MongoDB cluster connection string.

MONGO_URL:

Setting up MongoDB Connection Function

Next, create a folder called db, and inside it, create a connect.js file. We can also accomplish this in the terminal by using the following command:

mkdir db && cd db

touch connect.js

We need to create a function in the connect.js file that will establish a connection between our database and the node.js application so that we can access the MongoDB database on our express server.

const mongoose = require("mongoose");

const connectDB = (URL) => {
  return mongoose.connect(URL);
};

We imported the Mongoose package into the code above. Next, we define a connectDB function that returns the connect() method in Mongoose, which is a Promise. The URL represents our connection string, which will be obtained from the .env file. Finally, export the connectDB function, as we will need it in our entry file to configure our simple express server.

Updating the Entry File of our Express Server

Next, modify the app.js file. Import the dotenv package to retrieve the values stored in our.env file. Inside app.js, write a function that will connect to the database and start our Express server only when the connection is successful.

// ADD CODE INTO app.js File (entry point)

require("dotenv").config();
const connectDB = require("./db/connect");

const startConnection = async () => {
  try {
    await connectDB(process.env.MONGODB_URL);
    app.listen(port, () => {
      console.log(`Server Running on port ${port} `);
    });
  } catch (error) {
    console.log(error);
  }
};
startConnection();

The startConnection function in the preceding code uses async/await since our connectDB function produces a Promise that might be resolved or denied. Once the asynchronous function is resolved and the database connection is made, our Express server will start automatically.

If you get the above message in your terminal after running your Demo-App project, you can be certain that you have linked and synchronized your database with your application, and that everything is working properly.

Conclusion

Viola! We have successfully connected our MongoDB Cluster to our Node.js application (Demo-App). Now you can easily follow this process to connect your database to your node application. If you have found this helpful, please consider sharing it with others who might benefit.

Thank you for Reading.

MongoDB for Beginners: Setting Up Your Database with Atlas

Zechariah Hounwanou — Thu, 29 Feb 2024 01:53:44 +0000

Imagine your data as fixed columns. Every data has to fit into its exact spot. Old-school databases lock you into a super strict way of storing your data. Scaling up a database was painful, expensive, and time-consuming. All these were some of the problems before the creation of MongoDB.

MongoDB is very powerful when used along with Node.js. It is open source and it also offers fast development and efficient performance for users. Nowadays everything has been moved to the cloud. We will learn about this cloud-based database called MongoDB.

As a developer embarking on your first MongoDB project, this article will be a guide that will equip you with the knowledge on how to create a MongoDB Atlas account and how to set up a MongoDB Atlas Cloud-Cluster that can be used in any Node.js project you are working on or planning to work on.

What is MongoDB?
MongoDB Atlas is a cloud-based service that allows you to easily set up, manage, and scale your MongoDB database. It was created in 2009. MongoDB Atlas Cluster is a managed NoSQL database service. With MongoDB Atlas, you can access, and manage your MongoDB database through the web interface, command-line tool, or directly from your application and deploy your database in multiple regions around the world for low latency and high availability.

When using MongoDB Atlas cluster you do not need to worry about the cloud service configurations, as it handles this for you under the hood without stress. There are paid options for the service but you can start with the Free Tier (which we are going to be starting with), and then scale up to a premium plan later on once your application needs increase.

Below are the steps involved in creating a MongoDB account and a MongoDB cluster that you can use for your project.

How to Create a MongoDB Atlas Account
Step 1: Open up your browser and type “mongodb” Google will provide you with sufficient results for your search but we are more concerned about the first website from the result page. Click on it will take you to the official website of MongoDB

Step 2: After clicking on the link, you should be redirected to the official website of MongoDB. To create a MongoDB Atlas Account, you will need to click on the Try Free Button in the top right corner to create an account for free.

NOTE: No Credit Card info is required during account creation.

Step 3: After clicking on the Try Free Button you will need to fill up your details in the Sign Up section or you can sign up utilizing your Google Account. I would recommend you take your time to fill in your appropriate information, acknowledge the Terms of Service and Privacy Policy, and then click on the button below to Create your Atlas Account.

Step 4: MongoDB would like to verify the email address you registered with as soon as you create an account. So if you are seeing the screen below, you will need to head down to the mailbox associated with the email (you provided during registration) to verify your account by clicking the verification link in the email.

Step 5: After you have successfully created and verified your MongoDB Atlas Account, you will be redirected to the next screen below. Here MongoDB would like you to answer a few questions (like what project you will be building, the technology involved, etc.) so they can tailor your experience based on it. You shouldn't have to spend much time answering this.

After following through on the steps outlined above, your MongoDB Atlas Account is now ready for use without any hassle.

How to Create a MongoDB Atlas Cluster
Now we need to create our Cloud-Cluster which will allow us to deploy, scale, and manage our database without the need for setting up and maintaining our infrastructure.

Step 1: As a first step, we need to deploy the database we will be using for our project. From the available options, select the Free Tier (M0 Sandbox), which will provide you with limited resources ideal for development and testing purposes. Next, choose a Cloud Provider from AWS, Google Cloud, or Azure, and select the region closest to your location to ensure optimal performance. Provide a name for your cloud cluster, and then click on the Create button.

Step 2: Now that you have created the Free Cloud-Cluster that you will be using for your project, you will be redirected to this section and you will need to provide the username and password you will be using for the Cloud-Cluster you have just created.

Note: You need to use details you will be able to remember easily because during development you will need to include the username and password in your connection string so that your Node.js app can communicate with your cluster.

Step 3: After adding your cloud-cluster username and password, you will also need to connect your machine IP address to the cluster you have created. To add your IP address click on Add My Current IP Address and automatically it will pick and insert the IP address of your machine.

After you have successfully done all of the above-outlined processes, you can click on the Overview on the sidebar and you will land on this page. You should see the name of the cluster you have created in the Database Deployment section.

Congratulations! You have successfully created a free MongoDB Atlas account and Cloud-Cluster for your project. You can find more information on their official documentation.

Solving FizzBuzz Problem in JavaScript

Zechariah Hounwanou — Mon, 17 Apr 2023 08:00:39 +0000

We are going to play a game called FizzBuzz, Have you played the game before, if you havent no need to worry I will show you how. I can tell you for free that afterward you would love to play it and write a program code for it in your favorite programming language, its so enticing.

In this game we are going to start by counting from 1 and saying each number out loud but here is where the fun comes in when we get to a number that is a multiple of 3, instead of saying that number itself we say the word Fizz! And when we get to a number that is a multiple of 5 we say the word Buzz! if a number is then a multiple of both 3 and 5 we say the word FizzBuzz! cool right? I know.

My preferred language is Javascript so let's write a program to play the game using my language. Any programming will do the trick but I choose to use JS.

First, we need to tell the computer that we want to start the counting of numbers from 1. We can do that by creating a variable called count and setting it up with the value of 1.

let count = 1

Next, we need to write out the logic that will make our program say the numbers and FizzBuzz when appropriate. We can use a loop to go through all the numbers from 1 which is the count value to 100 (or any other number we wish to play up to). Inside the loop, we want to use an IF statement to check if the current number is a multiple of 3, 5, or both. If it is we can then use the console.log command to make the program say either Fizz, Buzz or FizzBuzz. Now let's write the code down

for(let count = 1; count <= 100; count++){
    if(count % 3 === 0 && count % 5 === 0){
        console.log("FizzBuzz");
    } else if (count % 3 === 0){
        console.log("Fizz");
    } else if (count % 5 === 0){
        console.log("Buzz");
    } else {
        console.log(count);
    }
}

Our code is ready to be shipped by the power in 0s and 1s. Now when we run this program, our computer will play the FizzBuzz game for us! We can change the number we wish to play with by changing the number in the loop. For example, if we want to play up to 50, we can change the loop to:

for(let count = 1; count <= 50; count++){
    //FizzBuzz Logic as above goes here
}

And thats it, my fellow developers, we have just created a FizzBuzz game program that we can play using JavaScript. Have fun coding!