DEV Community: Abdulfatai Suleiman

Getting started with Fauna and Node.js using Express

Abdulfatai Suleiman — Sat, 03 Jul 2021 09:03:29 +0000

What is Fauna?

FaunaDB is a global cloud database created to integrate with the JAMStack and modern serverless architecture. FaunaDb is not just a flexible and transactional database; it is a developer-friendly database that exposes you to building a fast, secured, and scalable cloud API with native GraphQL.

Some of the great things about FaunaDB are that you don’t even need to worry about database provisioning, scaling, sharding, replication, or correctness again because these are handled at the core of the database infrastructure.

In this article, we will explore the FaunaDB practically by building a fully functioning API and demonstrating the popular CRUD application using Node.js and FaunaDB.

Let’s dive right into building it!

Step 1: Set Up Our Fauna Database

To get started with our CRUD app, we need to create the database for our CRUD app in the Fauna dashboard.

To create an account, head over to the official website and register https://dashboard.fauna.com/accounts/register.

In the dashboard, click on the "NEW DATABASE" button, provide a name for your database then press the SAVE button.

You will be asked for the database name on this screen, whether you want to pre-populate the database, and there's a tip for you if you are migrating from another database to Fauna.

For now, we will enter the database name and press the "SAVE" button. Then, it will present you with a screen like the one below.

Step 2: Generating the Fauna API Key

We will need to create a Fauna API key to connect the database to our CRUD app. To do this, navigate to the security settings on the Fauna sidebar (left side of the screen).

Once you have done this, it will present you with your API key. You should copy the API key as soon as it is generated then stored somewhere easily retrievable.

Step 3: Creating the Fauna Collection

We will need to create a collection we're going to be interacting with within our Code.

after that you click the Save Button

Step 4: Connecting Fauna into Nodejs

Next, we need to get the Nodejs package for Fauna and Express. It's available on npm and can be installed with a single line in our terminal.

$ npm install --save faunadb express

After this is installed, we are going to run the sample code provided in Fauna Javascript driver docs.

    const express = require('express');
    const faunadb = require('faunadb'),
      q = faunadb.query;

    const client = new faunadb.Client({
      secret: 'YOUR_FAUNADB_SECRET',
    });

    const app = express();
    app.use(express.json())
    const PORT = process.env.PORT || 8000;

    app.get('/', async (req, res) => {
      try {
        const createP = await client.query(
          q.Create(q.Collection('todos'), { data: { testField: 'testValue' } })
        );
        console.log(createP);
      } catch (error) {
        console.log(error);
      }
    });

    app.listen(PORT, () => console.log(`Listening at port ${PORT}`));

To test this route, we can use any HTTP client. I will be using Postman (which you can download here), but you can use whatever you're most comfortable with (e.g., cURL, Insomnia, Postwoman, etc.).

Don't forget to use this command to your start dev server:

node src/index.js

Let's make a GET request to:

http://localhost:8000/

After doing that, if you check your terminal, you should see something like this:

    {
      ref: Ref(Collection("todos"), "302049452692079110"),
      ts: 1624315655320000,
      data: { testField: 'testValue' }
    }

Step 5: Retrieving all todos

Let's create our first express route which will allow us to get all todos from a collection.

    app.get('/todos', async (req, res) => {
      try {
        let todos = await client.query(
          q.Map(
            q.Paginate(q.Documents(q.Collection("todos"))),
            q.Lambda("X", q.Get(q.Var("X")))
          )
        )

        res.status(200).json(todos)
      } catch (error) {
        res.status(500).json({error: error.description})
      }
    });

Step 6: Retrieving single todo

This section we will be creating express route which will allow us to retrieve todo from a collection by specifying it id

    app.get('/todos/:id', async (req, res) => {
      try {
        const {data} = await client.query(
          q.Get(q.Ref(q.Collection('todos'), req.params.id))
        );
        res.status(200).json(data)
      } catch (error) {
        res.status(500).json({error: error.description})
      }
    });

Step 7: Create todo

In this section, we will be creating an express route that will allow us to create/add todo into a collection.

    app.post('/todos', async (req, res) => {

      try {
        const {title, description } = req.body;
        const { data } = await client.query(
          q.Create(q.Collection('todos'), { data: { title, description } })
        );

        res.status(201).json(data);
      } catch (error) {
        res.status(500).json({error: error.description})
      }
    });

Step 8: Update todo

In this section, we will be creating an express route that will allow us to update a todo by specifying its id

    app.put('/todos/:id', async (req, res) => {

      try {
        const {title, description } = req.body;
        const { data } = await client.query(
          q.Update(q.Ref(q.Collection('todos'), req.params.id), 
          { data: { title, description } },
          )
        );

        res.status(201).json(data);
      } catch (error) {
        res.status(500).json({error: error.description})
      }
    });

Step 7: Delete todo

In this section, we will be creating an express route that will allow us to delete a todo by specifying its id

   app.delete('/todos/:id', async (req, res) => {

      try {
        const { data } = await client.query(
          q.Delete(q.Ref(q.Collection('todos'),  req.params.id))
        );

        res.status(204).json(data);
      } catch (error) {
        res.status(500).json({error: error.description})
      }
    });

Next, we will be testing our Code using Postman, which I talked about earlier:

Let's make a GET request to get all todos:

http://localhost:8000/todos

Let's try this out by making a GET request to get a todo by id:

http://localhost:8000/todos/302052755930874368

Let's try this out by making a POST request to add/create a todo:

http://localhost:8000/todos/302052755930874368

Let's try this out by making a PUT request to update a todo:

http://localhost:8000/todos/302052755930874368

Let's try this out by making a DELETE request to remove a todo:

http://localhost:8000/todos/302052755930874368

Conclusion

In this article, you learned how to make CRUD operations with Fauna and Nodejs using ExpressJs.
The source code of the demo application is available on GitHub.

If you have any questions, don't hesitate to contact me on Twitter: @iamnotstatic

How to Host Nodejs/Express Applications on Namecheap cPanel

Abdulfatai Suleiman — Mon, 08 Feb 2021 15:46:34 +0000

What is Namecheap?

Namecheap is an ICANN-accredited domain name registrar, which provides domain name registration and web hosting.

Getting Started

Step 1: Write some code!

We will create a simple Express application and host it on Namecheap on this tutorial.

Write some code!

const express = require('express');
const app = express();

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

app.get('/', (req, res) => {
  res.send('Hello world');
});

app.get('/:name', (req, res) => {
  const name = req.params.name;
  res.send(`Hello ${name}`);
});

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

Save the code above in a file named app.js. When you run it, you should get a result similar to the images below.

Hosting Express on cPanel

This section assumes we have created a Namecheap account and purchased a domain along with hosting.

Step 2: Log in to cPanel

Step 3: Create a NodeJs Application

cPanel has tools for operations like SSL management, Databases, File management, Emails, Site metrics, Domain management, etc. Navigate to the SOFTWARE section and select Setup Node.js App.

The following interface will be displayed there:

Next, click the CREATE APPLICATION button on the right side of the screen.

You will see a screen similar to the one above, select a Node.js version (preferably the latest). Provide a name for your application in the Application root form field, and select the domain/subdomain you want the app hosted on in the Application URL section.

Step 4: Upload the Express Application to cPanel

Navigate to the FILES section in cPanel and select File Manager. It is a tool that allows for the management of files on our server.

Next, zip your local project, upload it to the cPanel file manager. Then unzip it on the server.

Step 5: Install Project Dependencies

Open the Node.js App page again and scroll down and open the project.

Click on the Run NPM Install button.

Step 6: Restart the Node.js Application

Whenever you make changes to the web application, you have to restart the application to effect the changes. To do this, scroll up on the Node.js App page and locate the RESTART button, then click it.

Congratulations! You have successfully hosted a Node.js/Express application on Namecheap cPanel. It is accessible via the domain you linked to the app during its creation.

Conclusion

We saw the possibility of hosting Node.js web applications on cPanels like Namecheap and learned how to host a Node.js project on cPanel. If you have any questions, don't hesitate to contact me on Twitter: @iamnotstatic

Introduction to Web Scraping with Nodejs

Abdulfatai Suleiman — Tue, 22 Dec 2020 09:49:22 +0000

What is Web scraping?

Web scraping is the process of extracting content and data from a website. Unlike screen scraping, which only copies pixels displayed onscreen, web scraping extracts underlying HTML code and with it, data stored in a database.

Note: Not all site are allowed to be scraped, you should make enquiries about a site before scraping.
Before scraping a site make an enquiry if you are allowed to scrap the site, you can check the site privacy policy and terms and condition.

Fetching the webpage

The site we will be scraping is Stackoverflow Jobs it is a section where job vacancies are listed.

Getting started

Step 1: Setting up the working directory

Now that we have Node.js and npm installed, we can start with the project. Open up your preferred terminal and run these commands:

if you don't have Nodejs and npm installed you can check there official docs on how to do that NodeJs Docs.

Create a directory
Move into the directory

mkdir web-scraper 
cd web-scraper

Now we have a directory for our web-scraper, but we need a package.json, this tells npm information about our project. To do this, (in the same terminal window) we need to run this:

npm init

This command will tell npm to initialize a pre-made package.json in our project directory. Just hit enter at all of the prompts, we can worry about those later.

Step 2: Install necessary packages

For this project, we will only need two(2) npm package axios and cheerio. An npm package is essentially a piece of code (“package”) in the npm registry that we can download with a simple command, npm install.

npm install axios
npm install cheerio

Step 3: Write some code!

const axios = require("axios");
const cheerio = require("cheerio");

const url = "https://stackoverflow.com/jobs";

(async () => {
    try {
        const res = await axios.get(url);
        const html = res.data;

        //loading response data into a Cheerio instance
        const $ = cheerio.load(html);

        const siteName = $(".-logo").text();

        // This would return the site Name
        console.log(siteName);

    } catch (error) {
        console.log(error);
    }
})();

Essentially, what this above code does is:

To include the modules used in the project with the require function, which is built-in within Node.js.
To make a GET HTTP request to the target web page with Axios..

Notice that when a request is sent to the web page, it returns a response. This Axios response object is made up of various components, including data that refers to the payload returned from the server.

So, when a GET request is made, we output the data from the response, which is in HTML format.

We loaded the response data into a Cheerio instance. This way, we can create a Cheerio object to help us in parsing through the HTML from the target web page and finding the DOM elements for the data we want—just like when using jQuery.

To uphold the infamous jQuery convention, we’ll name the Cheerio object, $.

We used the Cheerio’s selectors syntax to search the elements containing the data we want which is the site name:

Now, run the app.js file with this command:

node app.js

You should see something like this:

static@Abdulfatais-MacBook web-scraper $ node app.js

Stack Overflow

Now let's proceed with writing script to get job vacancies.

The Below. code looks for a parent class for every job listing and loop through it and then get it properties eg: title, link and date.
You can still select more like the location and amount just target the element name.

After that, it stores the values in an object then console log the data.

const axios = require("axios");
const cheerio = require("cheerio");

const url = "https://stackoverflow.com/jobs";

(async () => {
    try {
        const res = await axios.get(url);
        const html = res.data;

        //loading response data into a Cheerio instance
        const $ = cheerio.load(html);

        $('.fl1').each((i, el) => {
            const title = $(el).find('.fs-body3').text().replace(/s\s+/g, '');
            const link = $(el).find('.s-link').attr('href');
            const date = $(el).find('.fc-orange-400').text();
            const data = {
                title,
                link: `https://stackoverflow.com/${link}`,
                date
            }

            console.log(data);
        });

    } catch (error) {
        console.log(error);
    }
})();

If everything goes well you should get this response on your console.

static@Abdulfatais-MacBook web-scraper $ node app.js

{
  title: '\nFull-Stack Software Engineer            ',
  link: 'https://stackoverflow.com//jobs/471179/full-stack-software-engineer-unhedged',
  date: '5d ago'
}
{
  title: '\nSoftware Engineering            ',
  link: 'https://stackoverflow.com//jobs/473617/software-engineering-jpmorgan-chase-bank-na',
  date: '5h ago'
}
{
  title: '\nSenior Software Engineer (Backend) (m/w/d)            ',
  link: 'https://stackoverflow.com//jobs/471126/senior-software-engineer-backend-m-w-d-gp-9000-gmbh',
  date: '7d ago'
}
{
  title: '\nSenior Backend Engineer Who LoveTypescript            ',
  link: 'https://stackoverflow.com//jobs/470542/senior-backend-engineer-who-loves-typescript-well-health-inc',
  date: '6d ago'
}
{
  title: '\nJava Developer - Software Engineering            ',
  link: 'https://stackoverflow.com//jobs/473621/java-developer-software-engineering-jpmorgan-chase-bank-na',
  date: '5h ago'
}
{
  title: '\nSenior Software Engineer            ',
  link: 'https://stackoverflow.com//jobs/473494/senior-software-engineer-nori',
  date: '7h ago'
}

Hopefully, this article was able to take you through the steps of scraping your first website.

In my other articles to come, if I have the opportunity, I would write about topics on Node.js. Kindly drop your requests in the comment section as well as like.

You can also check out my previous article on Creating a Telegram Bot with Nodejs.

Conclusion

We saw the possibility of web scraping with Nodejs and learned how to scrap a site with nodejs. If you have any questions, don't hesitate to contact me on Twitter: @iamnotstatic

Build your first telegram Bot with Nodejs

Abdulfatai Suleiman — Sat, 28 Nov 2020 10:37:54 +0000

What is telegram?

Telegram is one of top social media apps/platforms that offers security with encryption and on a completely free, fast, and distributed system.

What is a chatbot?

A bot is a software program that operates on the Internet and performs repetitive tasks.

What is a Telegram Bot?

Telegram Bots are accounts operated by software – not people – and they'll often have AI features. ... They can do anything – teach, play, search, broadcast, remind, connect, integrate with other services, or even pass commands to the Internet of Things.

Getting started

Step 1: Getting Permission From BotFather

We’ll now invoke the process of creating a new bot with:

/newbot

Give it a name and a username:

Once that process is complete, you’ll get an API Token to use, copy it somewhere, we’ll be using it soon in our application.

Step 2: Set up your project directory

Now that we have Node.js and npm installed and our Telegram account is ready, we can start with the project. Open up your preferred terminal and run these commands:

Create a directory

mkdir movie-finder-telegram-bot

Move into the directory

cd movie-finder-telegram-bot

Now we have a directory for our Telegram bot, but we need a package.json, this tells npm information about our project. To do this, (in the same terminal window) we need to run this:

Continue Reading at https://iamnotstatic.hashnode.dev/build-your-first-telegram-bot-with-nodejs

Hopefully, this article can be useful for readers. If given the opportunity, I will explain about Node.js again or anyone has a request?
Please criticize and advise, do not forget to leave a comment and give Clap 👏👏

Validate a Nigerian Phone Number in Laravel

Abdulfatai Suleiman — Tue, 05 May 2020 00:37:11 +0000

There are times when you just want to make an input field accept values in the phone number format. In this article, I show just how to go about it in laravel. Any string taken in is checked to see if it has ‘+234’ as the first three numbers and if the remaining numbers are just 10 in length.
So, here it goes.

Thanks for staying with me until this point.
Please I would love to receive your questions and reviews on this.

Things you need to know before you start Coding

Abdulfatai Suleiman — Sat, 03 Aug 2019 23:00:28 +0000

Get the basics right
Build patience
Set a goal & move towards it
Do more projects
Get into social coding
Balance your learning