Forem: Hephzy

Day 2 & 3: Building a simple CRUD API using Express and MongoDB

Hephzy — Thu, 22 Aug 2024 21:24:03 +0000

Hi Everyone!

It’s currently day 3 of the #100DaysofMiva challenge, and for the past two days, I’ve been working on building a CRUD API. While I created two versions of the API—one with Node.js and the other with TypeScript—this post will focus on the TypeScript API

TypeScript

I created an API which performs CRUD operations (Create, Read, Update, Delete).

db.js

I had connected my MongoDB database in this file, calling in my database URI from my .env file

const connect = async () => {
  try {
    if (!config.DB_URI) {
      throw new Error("DB_URI is undefined. Ensure that your .env file is configured correctly.");
    }

    await mongoose.connect(config.DB_URI);
    console.log('MongoDB connected');
  } catch (err) {
    if (err instanceof Error) { // Type narrowing
      console.error(err.message);
    } else {
      console.error("An unknown error occurred:", err);
    }
    process.exit(1);
  }
};

export default connect;

Create

This endpoint allows the creation of new users and saves them to the database.

Code

const createUser = async (req: Request, res: Response) => {
  try {
    const { name, email } = req.body;

    if (!email || !name) {
      throw new Error('Email and name are required');
    }

    const check = await User.findOne({email});

    if (check) {
      throw Error('This user already exists');
    }
    const newUser = new User({ name, email });
    await newUser.save();

    res.status(201).json({ message: 'New user created', newUser})
  } catch (err) {
    if (err instanceof Error) { // Type narrowing
      console.error(err.message);
      res.status(400).json({ message: err.message});

    } else {
      console.error("An unknown error occurred:", err);
      res.status(500).json(err);
    }
  }
};

Request

Route
POST http://localhost:4080/user/create

Payload Example

{
  "name": "Hephzy",
  "email": "hzdelight01@gmail.com"
}

Responses

On a successful request, the API returns the created user’s details.

Response Example

Status Code: 201 Created

{
  "message": "New user has been created",
  "newUser": {
    "name": "Hephzy",
    "email": "hzdelight01@gmail.com",
    "_id": "66c7926c7457846bb26790a5"
  }
}

Read

This endpoint retrieves a specific user from the database by email.

Code

async function getUser (req: Request, res: Response) {
  try {
    const { email } = req.body;

    if (!email) {
      throw new Error('Email is required');
    }

    const findUser = await User.findOne({ email });

    if (!findUser) {
      throw Error('User cannot be found')
    }

    res.status(200).json({ message: "Here is the user details:", findUser });
  } catch (err) {
    if (err instanceof Error) { // Type narrowing
      console.error(err.message);
      res.status(400).json({ message: err.message});

    } else {
      console.error("An unknown error occurred:", err);
      res.status(500).json(err);
    }
  }
};

Request

Route
GET http://localhost:4080/user/get

Payload Example

{
  "message": "hzdelight01@gmail.com"
}

Response

On success, the API returns user's details based on email.

Response Example

Status Code: 200 OK

{
  "message": "Here is the user details: ",
  "findUser": {
    "_id": "66c7926c7457846bb26790a5",
    "name": "Hephzy",
    "email": "hzdelight01@gmail.com",
    "__v": 0
  }
}

Update

This endpoint updates an existing user's details, specifically the name, in the database.

Code

async function updateUser(req: Request, res: Response) {
  try {
    const { name, email } = req.body;

    if (!email || !name) {
      throw new Error('Email and name is required');
    }

    const find = await User.findOne({ email });

    if (!find) {
      throw Error('User not found');
    }

    const update = await User.updateOne({ name });
    res.status(200).json({
      message: 'Name has been updated'
    });
  } catch (err) {
    if (err instanceof Error) {
      console.error(err.message);
      res.status(400).json({ message: err.message});
    } else {
      console.error("An unknown error occurred:", err);
      res.status(500).json(err);
    }
  }
};

Request

Route

PUT http://localhost:4080/user/update

Payload Example

{
  "name": "Hephzibah",
  "email": "hzdelight01@gmail.com"
}

Response

On success, the API returns the updated user object along with a status code of 200 (OK).

Response Example

Status Code: 200 OK

{
  "message": "User name has been updated"
}

Delete

This endpoint deletes a user from the database.

Code

const deleteUser = async (req: Request, res: Response) => {
  try {
    const { email } = req.body;

    if (!email) {
      throw new Error('Email is required');
    }
    const find = await User.findOne({ email });

    if (!find) {
      throw Error('User not found')
    }

    const del = await User.deleteOne({ email });

    res.status(200).json({ message: 'User details has been deleted'});
  } catch (err) {
    if (err instanceof Error) {
      console.error(err.message);
      res.status(400).json({ message: err.message});
    } else {
      console.error("An unknown error occurred:", err);
      res.status(500).json(err);
    }
  }
};

Request

Route

DELETE http://localhost:4080/user/delete

Response

On success, the API returns a message confirming the deletion along with a status code of 200 (OK).

Response Example

Status Code: 200 OK

{
  "message": "User details has been deleted"
}

I’ve got some projects coming up, and I’m sure many of them will need CRUD operations. So, I figured I’d knock this out all at once. I hope you had as much fun with this as I did! The only hiccup was how much time it took. Writing two APIs was a bit more of a marathon than I expected.

Anyway, if you want to check out the source code, it’s right here for you. Enjoy and happy coding!
CRUD API Day 2 and 3

Day 1: How to create a simple server using TypeScript and NodeJS.

Hephzy — Wed, 21 Aug 2024 00:31:47 +0000

Introduction

Hi everyone. I'm starting the #100DaysofMiva coding challenge. I'm a day late but better late than never. I started my journey with TypeScript and today, I am going to take us through the process of creating a simple API server with both TypeScript and a plain NodeJS environment.

What is NodeJS

NodeJS is an open-source and cross-platform runtime environment built on Chrome’s V8 JavaScript engine for executing JavaScript code outside of a browser. It provides an event-driven, non-blocking (asynchronous) I/O and cross-platform runtime environment for building highly scalable server-side applications using JavaScript.

What is TypeScript?

TypeScript is a free and open-source high-level programming language developed by Microsoft that adds static typing with optional type annotations to JavaScript. It is a strict superset of JavaScript, which adds type to the JavaScript and helps you avoid potential bugs that occur at runtime.

Benefits of NodeJS

Asynchronous Programming
Scalability
Fast Performance

Benefits of TypeScript

Static Typing
Code completion
Refactoring

Setting Up a NodeJS Server

In order to set up a node.js server, there are a few things you need before you can start.

Prerequisites

NodeJS and Npm: You need to have NodeJS installed on your system. You can do that by going to the NodeJS official website and downloading NodeJS.

Steps

a. Create a new folder and navigate to it

  mkdir hello-world-api
  cd hello-world-api

b. Initialize node.js

  npm init -y

c. Install necessary dependencies:

npm install express 
npm install nodemon

d. Create a new file called app.js and add the following code.

import express from 'express';

const app = express();
const port = 3000;

// Define a route handler for the default home page
app.get('/', (req, res) => {
  res.status(200).json({message: 'Hello, World!'});
});

// Start the Express server
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

e. Add this script to your package.json file.

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

f. Start the server:

   npm start

For development mode (with auto-reloading):

   npm run dev

g. Access the API: Open your browser or use a tool like Postman to navigate to http://localhost:3000/, and you should see "Hello, World!" displayed.

Setting Up a TypeScript Server

Prerequisites

NodeJS and Npm should be installed.
Additionally, you can install typescript globally

  npm install -g typescript

Steps
a. Initialize a NodeJS project

mkdir hello-world-api
cd hello-world-api
npm init -y

b. Install necessary dependencies:

npm install express
npm install --save-dev typescript @types/node @types/express ts-node nodemon

c. Initialize TypeScript:

npx tsc --init

d. Configure tsconfig.json file

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist"
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

e. Create a src/index.ts directory and input this code:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

// Define a route handler for the default home page
app.get('/', (req: Request, res: Response) => {
  res.status(200).json({message: 'Hello, World!'});
});

// Start the Express server
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

f. Add this script to your package.json file.

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

g. Start the server:

   npm start

For development mode (with auto-reloading):

   npm run dev

h. Access the API by visiting http://localhost:3000/ in your browser, or to whatever port you specified in your project. You should also have this message showing in your terminal:

   Server is running on port 3000

That's it! You now have a simple API server up and running using both TypeScript and Node.js. Check out my GitHub repo for the full code. Stay tuned for the next post in the #100DaysofMiva challenge!

Day 1: #100DaysofMiva

A Simple Fix to A Major Banking Blunder

Hephzy — Sat, 29 Jun 2024 21:49:09 +0000

As a developer, I've come to understand that even minor oversights can lead to significant outcomes. I recently discovered a flaw in an API used for banking operations that might have let users take out more money than they had in their accounts. Upon finding the defect, I promptly set out to work on a remedy to block any unauthorized withdrawals.

Overview of the Banking Blunder

Upon examining the API code, it was evident that the withdrawal function lacked a critical validation step. In the absence of this check, users could potentially withdraw amounts exceeding their account balances, leading to overdrafts and severe financial implications. Such a vulnerability poses a considerable risk to the banking sector, eroding the trust and security customers anticipate in financial dealings. Banks must swiftly rectify these issues to preserve their credibility and safeguard client assets.

The Simple Fix

To tackle this problem, I implemented a straightforward validation check that compares the withdrawal amount to the account balance. If the withdrawal amount is greater than the balance, the system issues an error message for insufficient funds. This measure helps to prevent customers from overdrawing their accounts and incurring hefty fees.

By instituting this validation check, banks can markedly decrease the incidence of overdrafts and the fees customers accrue. This enhancement not only boosts customer satisfaction but also economizes bank resources by reducing the necessity to reverse transactions or manage overdrafts.

Steps to Implement the Fix

In tackling the problem, I devised an asynchronous function tasked with verifying the user's current balance.

async function checkBalance(accountNumber) {
  const query = `
    SELECT Balance
    FROM Accounts
    WHERE Account_No = ?
  `;
  const values = [accountNumber];
  const result = (await dB).query(query, values);
  console.log(result);
  return result; // You have to extract the balance from the result
}

Then, I compare that with the amount the user wishes to withdraw.

const hasAmount = await checkBalance(Source_account)
      console.log(hasAmount[0][0].Balance);

      if (hasAmount[0][0].Balance <= Amount) {
        throw Error (`Not Enough Balance`);
      }

Conclusion

In software development, attention to detail is crucial. By catching this defect and implementing a simple validation check, I prevented a potential banking blunder. This experience serves as a reminder that even the smallest fixes can have a significant impact on the reliability and security of our systems.

Banks need to emphasize the potential risks and consequences of overlooking such issues. It is imperative for banks to prioritize implementing these simple fixes to maintain trust and credibility with their customers.

NOTE
This article serves as Assignment - Task 0 for the HNG Internship programme, a rapid programme designed to provide beginners in technology with fundamental training in various fields. It offers the opportunity to gain experience by working as interns, collaborating with peers to accomplish tasks, or submitting projects before deadlines. Additionally, there is a HNG premium space where tech enthusiasts can connect, participate in mock interviews, have their CVs reviewed, and explore opportunities.