RWANDA TVET BOARD Kigali-Rwanda

ACADEMIC YEAR 2023-2024 World Mission High School

SECTOR:ICT
TRADE:SOFTWARE DEVELOPMENT
LEVEL:4
MODULE:DEVELOP A BACKEND APPLICATION WITH NODE.JS
CODE:SFDNJS501
TRAINER:SAMIE TWAHIRWA

Ele
TABLE OF CONTENT

Unit 1. Develop RESTFUL APIs with Node JS

1.1 Development environment is properly arranged based on coding
architecture methodology
1.2 Server and database connection are properly established according to
development environment
1.3 RESTFUL APIs are effectively implemented based on backend
functionalities

Unit 2.Secure Backend Application

2.1 Data encryption is correctly applied based on system security
2.2 Third-party libraries are carefully checked based on system security
2.3 User Authentication, Authorization and Accountability (AAA) are
carefully applied based on NPM Universal Access Control (UAC)
2.4 Environment variables are carefully Secured according to system security

Unit 3. Test Backend Application

3.1 Unit tests are appropriately conducted based on software testing
techniques
3.2 Usability is correctly tested according to expected results
3.3 Security is properly tested based on system threats

Unit 4.Manage Backend Application

4.1 Application is appropriately deployed based on FURPS requirements
4.2 Backend is effectively maintained according to the system Functionalities
4.3 Application documentation is properly generated according to the
system backend

Unit 1. Develop RESTFUL APIs with Node JS

 1.1 Development environment is properly arranged based on coding architecture
methodology

What is a REST API?

REST, which stands for REpresentational State Transfer, is a software

development architecture that defines a set of rules for communication
between a client and a server. Let’s break this down a little more:

 A REST client is a code or app used to communicate with REST servers.

 A server contains resources that the client wants to access or change.
 A resource is any information that the API can return.

A REST API, also known as a RESTful API, is an API that conforms to the REST
architecture. These APIs use the HTTP protocol to access and manipulate data on
the server.

The essential components of a REST API include the HTTP method, endpoint,
headers, and body. Here’s an example of a REST API that gives you a list of
astronauts who are currently in space.

HTTP methods

The HTTP method defines the action the client wants to make on the server,
which includes creating, reading, updating, or deleting resources (CRUD). Here
are four HTTP methods that are commonly used in REST APIs:

 GET: used to retrieve resources.

 POST: used to add resources.
 PUT: used to update resources.
 DELETE: used to delete resources.

What is Node.js?
By definition, Node.js is an open source and cross-platform JavaScript runtime
environment that runs based on Chrome’s V8 engine.
 Why should you use Node.js and Express to
build your REST API?
Here are four key advantages of Node.js and Express:

1. The ability to use a single language (JavaScript) for both client-side and
server-side development.
2. Fast and powerful performance, owing to the ability to run multiple requests
in parallel.
3. Middleware and routing capabilities that are built into Express to make API
development quick and easy.
4. A large, active community of developers contributing to the ecosystem.

Choosing the Right Coding Architecture Methodology:

The choice of coding architecture methodology plays a vital role in

how your Restful API will be structured and developed. Two popular
methodologies that work well with Node.js are the Model-View-
Controller (MVC) and the Model-View-Controller-Service (MVCS)
patterns.

Model-View-Controller (MVC):

Model: Represents the data and database interactions.

View: Handles user interface and presentation.

Controller: Manages the flow of data between the Model and View.

Model-View-Controller-Service (MVCS):

Model: Data and database logic.

View: User interface and presentation.

Controller: Routes HTTP requests.

Service: Business logic and data manipulation.

Setting Up the Development Environment:

To arrange a development environment based on your chosen

coding architecture methodology:

 Choose a Node.js Framework: Node.js frameworks like

Express.js are excellent for building Restful APIs. They provide
essential tools for routing, middleware, and request handling.
 Version Control: Use a version control system like Git to track
changes and collaborate with a team. Platforms like GitHub or
GitLab can help manage repositories.
 Project Structure: Organize your project files and directories
according to your chosen methodology. For example, if using
MVC, separate your code into "models," "views," and
"controllers" folders. In MVCS, include a "services" folder for
business logic.
 Dependency Management: Utilize npm (Node Package
Manager) to manage project dependencies. Maintain a
package.json file to keep track of packages and their versions.
 Database Integration: If your API interacts with a database,
choose an appropriate database system (e.g., MongoDB,
PostgreSQL) and set up database connections and schema
models accordingly.

 Middleware: Implement middleware for tasks like

authentication, logging, and error handling. Middleware helps in
maintaining a modular and organized codebase.
 Testing: Integrate testing frameworks like Mocha, Chai, or Jest
to ensure the reliability and quality of your API.
 Documentation: Create clear and comprehensive API
documentation using tools like Swagger or OpenAPI. Proper
documentation is essential for developers who will use your
API.
 Security: Implement security measures like input validation,
authentication, and authorization to protect your API from
potential threats.
 Continuous Integration/Continuous Deployment (CI/CD): Set up
CI/CD pipelines to automate testing and deployment
processes, ensuring a smooth development workflow.

Setting up a Node.js app

Step 1: Install Node.js and NPM

The first thing we’ll need to do is install Node.js on our machine. You can
download the latest LTS version from the official Node.js website. Follow the
prompts in the Node.js Installer and customize the defaults, if necessary. When
you’re done, you should have installed Node.js, as well as NPM (Node Package
Manager). You can verify the installation by running the following commands in
your terminal:

node -v
npm -v

If you see the versions of Node.js and NPM show up, your installation was
successful.

Step 2: Create a new project folder

Next, we’ll create a new folder for the project by running the following
command in your terminal (note that entering this command as-is will name
your project “node rest api,” but you can change the name, if you’d like):

mkdir node-rest-api

To navigate to your project, enter this command:

cd node-rest-api

Step 3: Initialize a new Node.js application

To initialize your app, run the following command in your terminal:

npm init

You will be prompted to enter your project name, description, and GitHub
repository. You can accept the defaults by pressing Enter/Return, or customize
them.

Next, open this project in your editor, where you will see a new file
called package.json. This file contains the data you added about your project
in the terminal. It also describes how you’re going to run the project and lists its
dependencies (frameworks and libraries).

Step 4: Install Express and other dependencies

From here on, you can run all your commands in your editor’s terminal.

Run the following command to install the Express framework:

npm install express

Step 5: Import necessary modules

We’ll start by creating a new file named app.js in the root of the project
directory. We’ll use this file to set up the app. Then, we’ll load the dependencies
so we can use them. In the app.js file, add the following code to import
Express:

const express = require(‘express’);

Now, let’s set up Express to create an app and configure it to parse requests
with JSON payloads. Here’s the code you can add to do that:

const app = express ();

app.use(express.json());

Step 6: Define a route that listens to requests

Now we need to make this application a server by getting it to listen for
connections. To do this, we’ll connect to a port to listen for incoming requests.

Create a new file called config.js. In this file, we’ll add the following code to
set a default port:

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

With the process.env.PORT variable, we set up the port automatically by

allowing the API to be deployed to a cloud platform like AWS or Azure. In case
the process.env.PORT variable is not set, we’ll default to using port 3000.

Next, we’ll add the following code to the the app.js file in order to set up the
server to listen on the specified port:

app.listen(PORT, () => {
console.log("Server Listening on PORT:", port);
});

Step 7: Define an endpoint

Let’s start by defining a status endpoint to ensure the API is working.

Express lets you define routes using the app.METHOD() function. Here, METHOD
refers to the different HTTP methods, like GET, POST, PUT, and DELETE. For a
GET request, you’d define the route by adding an app.get() function. This
function has two parameters. We’ll use the first parameter to define the path. In
this case, it is the /status endpoint:

app.get(“/status”, ());

Next, we’ll add a callback function as the second parameter, which defines what
we will do when the request is called. This function has two parameters: the
request object (which contains details like the HTTP method, headers, and
request body) and the response object (which defines the information that we
want to send). The response (res) object contains different methods of sending
a response to the client, such as res.send(), res.json(), and res.render().
Here’s what it looks like now:

app.get(“/status”, (request, response));

With response.send(), we then define the response we want to return. But

since we want to send back JSON, we’ll need to first define a JSON object. So,
we define a status variable and create an object:

response.send(status) is now a function that takes the JSON object as

the argument.

app.get(“/status”, (request, response) => {

const status = {
“Status”: “Running”
};

response.send(status);
});

Exercises:

Exercise 1: Multiple Choice Which of the following is a popular

coding architecture methodology for setting up a development
environment? a) IDE b) API c) MVC d) CPU

Exercise 2: True or False True or False: Using a version control

system like Git is not necessary when setting up a development
environment.

Exercise 3: Fill in the Blank The ____________ folder in the

project structure is responsible for managing the flow of data
between the Model and View in the MVC architecture.

Exercise 4: Short Answer Name two examples of Node.js

frameworks commonly used for building Restful APIs.
Exercise 5: Matching Match the following terms to their
corresponding descriptions:

Middleware

Continuous Integration/Continuous Deployment (CI/CD)

Database Integration

API Documentation

Descriptions:

Automates testing and deployment processes.

Handles tasks like authentication and error handling.

Involves connecting your API to a database system.

Provides clear and comprehensive information about your API for

developers.
1.2 Server and database connection are properly established according
to development environment

In the process of developing a RESTful API with Node.js, one of

the foundational pillars of success is the establishment of robust
server and database connections within the development
environment. A well-structured and properly configured connection
between the server and the database is crucial for the API's
performance, security, and scalability. This note highlights the
significance of establishing these connections in the context of
developing a RESTful API using Node.js.
PRACTICE SESSIONS

Project 1:create a project involves creating a basic RESTful

API using the Flask framework to manage a list of tasks. Users
can add, retrieve, update, and delete tasks. You'll also need to
set up a SQLite database to store task data.

Project 2:

Project Question: Building a To-Do List Application

Description:
You are tasked with building a basic To-Do List application that
allows users to create, read, update, and delete tasks. The
application should provide a RESTful API for managing tasks,
and tasks should be stored in a SQLite database. You should use
the Flask framework for building the API
End Of Note.