DEV Community: Temitope Agbaje

Postman: VS Code Extension

Temitope Agbaje — Wed, 02 Aug 2023 00:16:22 +0000

Prerequisities

VS code

Introduction

Postman is a collaboration platform and API (Application Programming Interface) development tool used to build, test, and document APIs. It allows users to make HTTP requests, view responses, and analyze API endpoints.

Postman has features like API Testing, API Documentation, Collaboration, Mock Servers, Monitoring, Environment Management, Collection Runner.

How to install the extension

Recently, Postman VS Code extension was released. Now, you can develop and test your APIs in Postman straight from Visual Studio Code thanks to the Postman VS Code extension. To install Postman and use on VS Code :

Go to extension on VS Code and Install Postman extension

You will notice the postman icon on the left side bar, then sign in to your postman account or create an account if you do not have one
Once you sign in, you can start sending requests

Conclusion

The Postman VS Code extension :

simplifies the process of working with APIs.
lets you easily create and send HTTP, WebSocket, and gRPC requests.
allows you to manage collections and environments effortlessly
import data with cURL commands
create and send cookies with your requests.

It makes API development and testing straightforward, leading to improved efficiency and productivity in your workflow

A blogging api

Temitope Agbaje — Tue, 10 Jan 2023 00:13:42 +0000

Introduction

This is a simple blogging API using Expressjs and MongoDB as the database. It allows authenticated users to access the blog post and also add blog posts.

These are the endpoints available on the API.

Methods	Endpoints	Description
POST	/signup	This is the signup endpoint
POST	/login	Logs an existing user
POST	/blog/post	this is to add a blog
GET	/blog/post	Gets all blog posts in the database
GET	/blog/post/:id	Get a single blog post using the id
PUT	/blog/post/:id	Updates the blog post
DELETE	/blog/post/:id	Deletes the blog post

Tools used

ExpressJs
MongoDB
Postman or Thunderclient ( a vscode extension)

Prerequisites

Code Editor (most preferably vscode)
Have Knowledge of Javascript and Nodejs
should have installed npm and nodejs

Let's code

Step 1: Set up your project folders

Create a folder, you can call it myBloggingApi
Open this folder in your code editor
In your code editor terminal run npm init, this initializes the npm package and creates a package.json file

Then install the libraries you need for the project using npm install <package-name>. Packages to install include Express, mongoose, dotenv, express, jsonwebtoken e.t.c

Step 2: Set up Database and Database connection

Login to MongoDB atlas or sign up if you have never signed up before
On the MongoDB atlas, click on Connect, then Connect your application, copy the link posted there and create a .env file and paste the link there with the name of MONGODB_CONNECTION_URI

MONGODB_CONNECTION_URI=mongodb+srv://TemitopeAgbaje:<password>.@cluster0.wzcue.mongodb.net/<name-of-database>?retryWrites=true&w=majority

Then create a new folder in myBloggingApi folder, called database and then a file called db.js.
Paste this code into it

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

const MONGODB_CONNECTION_URI = process.env.MONGODB_CONNECTION_URI;

mongoose.set("strictQuery", false);

//connect to MongoDB
function connectToMongoDB() {
  mongoose.connect(MONGODB_CONNECTION_URI);

  mongoose.connection.on("connected", async () => {
    console.log("Connected to MongoDB successfully");
  });

  mongoose.connection.on("error", (err) => {
    console.log("Error connecting to MongoDB", err);
  });
}

module.exports = { connectToMongoDB };

Remember to install the packages dotenv and mongoose. This code above helps you connect the database

Step 3: Create the index.js and server.js files

Index.js

Express package should have been installed
Install the package body-parser

const express = require("express");
const bodyParser = require("body-parser");

const app = express();

app.use(bodyParser.json());
app.use(express.static("public"));
app.use(express.urlencoded({ extended: false }));

app.get("/", (req, res) => {
  res.send("Welcome to my blog!");
});

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ message: "Something broke!" });
});

module.exports = app;

Server.js

Add the PORT to .env folder

require("dotenv").config(); //process.env
const app = require("./index");
const db = require("./config/db")

const PORT = process.env.PORT || 4500;
db.connectToMongoDB() //connect to mongoDB


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

Step 4: Write the Schema

Create a new folder in myBloggingApi folder, and name it models, then create the files for userModel.js and blogModel.js

userModel.js

Install bcrypt package

const mongoose = require("mongoose");
const bcrypt = require("bcrypt");
const Schema = mongoose.Schema;

const userSchema = new Schema({
  first_name: { type: String, required: true },
  last_name: { type: String, required: true },
  email: {
    type: String,
    required: true,
    unique: true,
  },
  password: {
    type: String,
  },
});

userSchema.pre("save", async function (next) {
  const hashedPassword = await bcrypt.hash(this.password, 10);
  this.password = hashedPassword;
  next();
});

userSchema.methods.isPassword = async function (inputedPassword) {
  const isCorrectPassword = await bcrypt.compare(
    inputedPassword,
    this.password
  );
  return isCorrectPassword;
};

const User = mongoose.model("User", userSchema);

module.exports = User;

userSchema.pre method using bcrypt helps hash the password before saving it to the database
userSchema.methods.isPassword method using bcrypt helps to compare the password

blogModel.js

const mongoose = require("mongoose");

const Schema = mongoose.Schema;

const blogSchema = new Schema({
  title: {
    type: String,
    required: "Please add a title",
  },
  description: String,
  author: String,
  state: {
    type: String,
    enum: ["draft", "published"],
    default: "draft",
  },
  read_count: { type: Number, default: 0 },
  reading_time: String,
  tags: Array,
  body: {
    type: String,
    required: "Please add a body",
  },
  timestamp: Date,
});

const Blog = mongoose.model("Blog", blogSchema);

module.exports = Blog;

Step 5: Create the auth middleware

Create a new folder in myBloggingApi folder, and name it middleware then create the file auth.js
In your vscode terminal, install passport and passport-jwt package

const passport = require("passport");
const JWTStrategy = require("passport-jwt").Strategy;
const ExtractJWT = require("passport-jwt").ExtractJwt;
require("dotenv").config();

passport.use(
  "jwt",
  new JWTStrategy(
    {
      jwtFromRequest: ExtractJWT.fromAuthHeaderAsBearerToken(),
      secretOrKey: process.env.JWT_SECRET,
    },
    (payload, done) => {
      try {
        done(null, payload.user);
      } catch (err) {
        done(err);
      }
    }
  )
);

Step 6: Create Controllers

Add a new folder with the name Controllers and create the authContoller.js and blogController.js files
Run npm install jsonwebtoken in your vscode terminal

authContoller.js

const jwt = require("jsonwebtoken");
const User = require("../models/userModel");

exports.signup = async (req, res) => {
  const userExistInDB = await User.findOne({ email: req.body.email });

  if (userExistInDB) {
    return res.status(409).json({ message: "Email exists" });
  }

  const user = await User.create(req.body);

  user.password = undefined;
  const payload = { user };

  const token = jwt.sign(payload, process.env.JWT_SECRET, {
    expiresIn: "1h",
  });
  return res.status(201).json({
    user,
    token,
  });
};

exports.login = async (req, res, next) => {
  const { email, password } = req.body;
  const user = await User.findOne({ email: email });
blogController
  if (!user) {
    return res.status(400).json({message: "User does not exist"})
  }

  const isCorrectPassword = await user.isPassword(password);
  if (!isCorrectPassword) {
    return res.status(400).json({message: "Incorrect Password"})
  }

  user.password = undefined;
  const payload = { user };
  const token = jwt.sign(payload, process.env.JWT_SECRET, { expiresIn: "1h" });
  return res.status(200).json({ user, token });
};

blogController.js

const blogModel = require("../models/blogModel");
const moment = require("moment");

exports.createBlogPost = async (req, res) => {
  const text = req.body.body;
  const wpm = 225;
  const words = text.trim().split(/\s+/).length;
  const time = Math.ceil(words / wpm);

  const blogPost = await blogModel.create({
    author: req.body.author,
    description: req.body.description,
    timestamp: moment().toDate(),
    reading_time: `${time} mins`,
    title: req.body.title,
    body: req.body.body,
    tags: req.body.tags,
  });
  return res.status(201).json({ status: "New Post", blogPost });
};

exports.getBlogPosts = async (req, res) => {
  const { query } = req;

  const {
    timestamp,
    state,
    page = 1,
    per_page = 20,
    read_count,
    reading_time,
    author,
    title,
    tags,
  } = query;

  let findQuery = {};

  if (timestamp) {
    findQuery.timestamp = {
      $gt: moment(timestamp).startOf("day").toDate(),
      $lt: moment(timestamp).endOf("day").toDate(),
    };
  }

  if (state) {
    findQuery.state = state;
  }

  if (read_count) {
    findQuery.read_count = read_count;
  }

  if (reading_time) {
    findQuery = {
      ...findQuery,
      reading_time: { $regex: reading_time, $options: "i" },
    };
  }

  if (author) {
    // findQuery.author = author;
    findQuery = { ...findQuery, author: { $regex: author, $options: "i" } };
  }

  if (title) {
    findQuery = { ...findQuery, title: { $regex: title, $options: "i" } };
  }

  if (tags) {
    findQuery = { ...findQuery, tags: { $in: tags } };
  }

  const blogPosts = await blogModel
    .find(findQuery)
    .skip(page - 1)
    .limit(per_page);
  return res.status(200).json({ status: "All Post Loaded", blogPosts });
};

exports.getBlogPost = async (req, res) => {
  try {
    const { id } = req.params;

    const blogPost = await blogModel.findById({ _id: id });

    if (!blogPost) {
      return res.status(404).json({ status: "Blog Post Not found" });
    }

    if (blogPost.state === "published") {
      blogPost.read_count = blogPost.read_count += 1;
    }

    await blogPost.save();

    return res.status(200).json({ status: "Blog Post Loaded", blogPost });
  } catch (err) {
    return res.status(400).json({ message: "Bad Request" });
  }
};

exports.updateBlogPost = async (req, res, next) => {
  const { id } = req.params;
  const blogPost = await blogModel.findById({ _id: id });

  if (!blogPost) {
    return res.status(400).json({ message: "No blog Post" });
  }

  if (req.body.state) {
    blogPost.state = req.body.state;
  }

  if (req.body.author) {
    blogPost.author = req.body.author;
  }

  if (req.body.body) {
    blogPost.body = req.body.body;
  }

  if (req.body.tags) {
    blogPost.tags = req.body.tags;
  }

  await blogPost.save();

  return res.status(200).json({ status: "Post Updated", blogPost });
};

exports.deleteBlogPost = async (req, res) => {
  const { id } = req.params;

  const blogPost = await blogModel.findById({ _id: id });

  if (!blogPost) {
    return res.status(400).json({ message: "No blog Post" });
  }

  await blogPost.delete();

  return res.status(200).json({ status: "Deleted successfully"});
};

Step 7: Routes

In myBoggingApi folder, add routes folder and in it we have the authRoute.js and blogRoutes.js

authRoute.js

const express = require("express");


const AuthController = require("../controllers/authController");

const authRouter = express.Router();

authRouter.post("/signup", AuthController.signup);

authRouter.post("/login", AuthController.login);

module.exports = authRouter;

blogRoutes.js

const express = require("express");
const BlogController = require("../controllers/blogController");

const blogRouter = express.Router();

blogRouter.post("/post", BlogController.createBlogPost);

blogRouter.get("/posts", BlogController.getBlogPosts);

blogRouter.get("/post/:id", BlogController.getBlogPost);

blogRouter.put("/post/:id", BlogController.updateBlogPost);

blogRouter.delete("/post/:id",BlogController.deleteBlogPost);

module.exports = blogRouter;

Step 8: Updating index.js

securing the blog route
initialize passport

const express = require("express");
const passport = require("passport");
const blogRouter = require("./routes/blogRoutes");
const authRouter = require("./routes/authRoutes");
const bodyParser = require("body-parser");

const app = express();

app.use(bodyParser.json());
// app.use(express.json());
app.use(express.static("public"));
app.use(express.urlencoded({ extended: false }));

app.use(passport.initialize());
require("./middlewares/auth");

app.get("/", (req, res) => {
  res.send("<h2>Welcome to my blog!</h2>");
});

app.use("/blog", passport.authenticate("jwt", { session: false }), blogRouter);
app.use("/", authRouter);

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ message: "Something broke!" });
});

module.exports = app;

Conclusion

I hope with this article you can create your blogging API.

I hosted it with render, Click here to try it out

Link to the GitHub repository:https://github.com/TemitopeAgbaje/blogging-api

My journey into open-source

Temitope Agbaje — Sun, 05 Sep 2021 16:49:31 +0000

It all started when I got a message from my sister,containing a link to a post detailing a competition called the Open Source Challenge 2021 hosted by the Open Source Community Africa(OSCA). I'm a newbie software developer, still getting to grips with the different terminologies thrown around in the world of technology. I had been seeing the term "open source" here and there, and I had an idea, but didn't exactly know what it meant.

This was an opportunity to get to know more about what open source meant by actively participating in a challenge, while also standing a chance to win a prize. Naturally, I was excited about this opportunity and proceeded to read some articles about what it meant for a project to be open source and where to start contributing.

Open source refers to projects whose design and implementation is freely available to be modified and shared by anybody. The source code of such projects can be contributed to by anybody interested in the project, after a process of reviewing by the original authors of the project. The changes that can be made by the public to the project are not restricted to code changes only, errors in documentation can also be corrected, as well as addition of more descriptive text to explain the project and what it does.
After learning what open source was and how to get started, I was ready to start contributing.

I attempted joining the discord community for the open source challenge but I was having some issues with the discord app and logging in. At this point, other stuff came up and I briefly forgot about the challenge. About a week later, my attention got called back to it and I ended up finding a solution to the discord issue and joined the community proper.

The commit message attached to my first pull request did not properly convey the message of the change I made. This was pointed out to me nicely by the project's author, after which I made the requested change. That was a nice bit of learning on how to write meaningful commit messages so the reviewer has proper context when looking through the changes before merging them. I kept contributing to beginner-friendly open source projects, documentation mostly and some code changes too.

Overall, exploring the open source world been a good ride that I hope to continue on. The importance of open source projects cannot be over-emphasized, in that the source code for the project can be gone through if the documentation is not sufficient and the it also improves overall project quality, owing to the fact that mistakes and better implementations can be pointed out by the public.

Thanks for reading🤗!!!

Javascript: Data type and variables

Temitope Agbaje — Thu, 18 Mar 2021 14:51:20 +0000

Data types are concepts to be able to operate on variables.
JavaScript variables can hold Data types like Strings, numbers, arrays, and so on.

Strings
Strings are written in double quotes(" ") or single quotes(' ').

In the image below..you can use a double quote and single quote interchangeably or when using two double quotes or a single quote in a sentence, a backslash can be used in front.

Number
For the number data type, It is either a negative or a positive number. It can also be a decimal number.

Booleans
In boolean, It is either true or false, Yes or no, off or on.

Arrays
It is used to store a list of data. Arrays are written using square brackets [ ].

An array can be written inside another array.Arrays can be accessed by their index. Every array has an index that starts with 0.

Objects
The object is a data type that allows the storage of collections of data. They are denoted using square brackets { }.

To access the data of an object: ObjectName.keyName

Undefined
If a variable has been declared but has not been assigned a value, has the value undefined.