DEV Community: Yassine BENNKHAY

Build and deploy a domain name info checker API with Node Js and Express Js

Yassine BENNKHAY — Thu, 09 Mar 2023 00:22:20 +0000

This post was created originally on my website.
Have you ever wondered how you find any domain name information? I think you did! and it's pretty easy to google it in seconds to find a bunch of websites that offer domain name information, but in this article, we're going to create our own NodeJs and ExpressJs API that will return us the info of any given domain name.

The structure of our API will have an apiController that has a getDomainInfo method, an apiRoute, and the entry point of our API which is server.js--This is just how I like to organize my code, otherwise, you can write all the logic in one file, but I don't recommend it:)

Sound exciting enough? so Let's get right into it!

The project folder structure:

domain_checker_api/
  |- node_modules/
  |- .env
  |- routes/
  |    |- apiRoute.js
  |- controllers/
  |    |- apiController.js
  |- package.json
  |- package-lock.json
  |- server.js

If you want to follow up make sure to have NodeJs installed on your machine, or you can install it from here.

So the first step is to install some dependencies express , dotenv and whois-json

In your terminal run:

npm install express whois-json dotenv

In our server.js file let's set up our Express server:

First, we require express module and create an express app instance using the express( ) function, and define the port that our server will listen to.

const express=require("express")
const app=express()
const PORT = process.env.PORT || 3000;

The port will be in a separate file and we access it by process.env.PORT.

PORT=8080

Set up the route for the request that starts with"/api/v1/domain".

we use app.use()to mount the router that will be defined in"./routes/apiRoute"

The apiRoutefile will be created later on.

app.use("/api/v1/domain",require("./routes/apiRoute"))

Start the server and listen to any incoming requests on the specified port.

app.listen(PORT,()=>console.log(`Server is Running on the Port ${PORT}`))

The server.js
should look something like this:

const express=require("express")
const app=express()
const PORT=8080
app.use("/api/v1/domain",require("./routes/apiRoute"))
app.listen(PORT,()=>console.log(`Server is Running on the Port ${PORT}`))

Now our server is up and running, let’s create apiController.js file that has a getDomainInfo method that will retrieve the domain info.

first thing first let’s require the necessary modules;

dnsis a built-in NodeJs module that resolves domain names to IP addresses and the whois-json is a third-party library that allows us to retrieve WHOIS information in JSON format.

const dns = require("dns");
const whois = require("whois-json");

We define a method called getDomainInfothat takes as a parameter req and resobjects

then we extract the domain from the request parameters and store it in the domainvariable.

we use dns.lookup method to resolve the domain into an IP address.

If there is an error we return the 400 status code with the error message as JSON.

var data;
const getDomainInfo = async (req, res) => {
  const domain = req.params.domain;
  dns.lookup(domain, (err, address) => {
    if (err) {
      res.status(400).json({
        error: err.message,
      });
    }
    data = { domain, address };
  });

If everything went okay we store the domain and the ip address in the datavariable.

Now that we have the IP address we can use the whois-json module to retrieve additional information about the domain.

 const results = await whois(`${domain}`);

and return the info as a JSON object like follow:

 res.status(200).json({
    domain: data.domain,
    registrarUrl: results.registrarUrl,
    nameServer: results.nameServer,
    creationDate: results.creationDate,
    updatedDate: results.updatedDate,
    expirationDate: results.registrarRegistrationExpirationDate,
    registrantName: results.registrantName,
    registrantCountry: results.registrantCountry,
    adminName: results.adminName,
    adminPhone: results.adminPhone,
  });
};

defining a welcomemethod that returns a JSON welcome message to the user.

const welcome = (req, res) => {
  res.status(200).json({
    message:
      "Welcome to the domain name API checker, hit the endpoint /api/v1/domain/ and type your domain name without https:// to get the domain info.",
  });
};

Finally, we export the getDomainInfo and the welcomemethods so that we can use them in the router.

module.exports = {
  getDomainInfo,
  welcome

};

the apiController.js file should look like this:

const dns = require("dns");
const whois = require("whois-json");
var data;

const getDomainInfo = async (req, res) => {
  const domain = req.params.domain;
  dns.lookup(domain, (err, address) => {
    if (err) {
      res.status(400).json({
        error: err.message,
      });
    }
    data = { domain, address };
  });

  // whois domain info
  const results = await whois(`${domain}`);
  res.status(200).json({
    domain: data.domain,
    ip: data.address,
    registrarUrl: results.registrarUrl,
    nameServer: results.nameServer,
    creationDate: results.creationDate,
    updatedDate: results.updatedDate,
    expirationDate: results.registrarRegistrationExpirationDate,
    registrantName: results.registrantName,
    registrantCountry: results.registrantCountry,
    adminName: results.adminName,
    adminPhone: results.adminPhone,
  });
};

module.exports = {
  getDomainInfo,
  welcome
};

Now let’s work on the route.

In theapiRoute.js file we require getDomainInfo from apiController file, express and create a routerinstance using express.Router() method.

const express = require("express");
const { getDomainInfo } = require("../controllers/apiController");
const router = express.Router();

Set up a GET route for the endpoint "/api/v1/domain/:domain". When a GET request is made to this endpoint the router will call the getDomainInfopassing in the domain parameter from the request URL.

router.get("/api/v1/domain/:domain", getDomainInfo);

the root of the API is a welcome message when a request is made to the root “/” the welcome method gets called.

router.get("/", welcome);

The apiRoute.js file should look something like this:

const express = require("express");
const { getDomainInfo, welcome } = require("../controllers/apiController");
const router = express.Router();

router.get("/api/v1/domain/:domain", getDomainInfo);
router.get("/", welcome);
module.exports = router;

to test our API we run:

node server

and go to our browser and type:http://localhost:8080

you should see something like this.

Let’s say that we want to get information about my domain name yassinebenkhay.com we hit the endpoint :http://localhost:8080/api/v1/domain/yassinebenkhay.com and we should see the information below:

The final step is to deploy this API to a hosting service, I think the easiest way to do so is with Heroku, so let’s go with that.

In your Heroku account create a new app like this:

now we need to push the project from our local machine to GitHub.

in your GitHub account create a new repo and push the project to it.

Don’t remove node_modules when you upload the project to the repo, otherwise, the API won’t work once we link the repo with Heroku.

Also, you need to add the node js version in your package.json file in order for Heroku to download it.

 ...
 "engines": {
    "node": "v16.x"
  }

now go to Heroku and like the repo, with the app, we have just created.

After the repo and the app are linked click deploy as shown below:

Wait for the process to finish, If everything went well you will have your API link just like this:

https://domain-name-checker-api.herokuapp.com/

I hope that this Tutorial was helpful, if you have any suggestions please consider dropping them in the comments section below.

Flutter Roadmap | How To Learn Flutter In 2022 The Right Way

Yassine BENNKHAY — Wed, 24 Aug 2022 19:17:49 +0000

This Article was published originally on my own blog yassinebenkhay.com.

With the growth and popularity Flutter is getting, many people are trying to learn it, but it is confusing for beginners to find the best Flutter Roadmap to learn flutter in 2022 the right way, In this article, I will provide you with all the resources and courses you’ll ever need to learn Flutter, but before getting started, let’s know what’s flutter.

What is Flutter?

Flutter is one of the most famous frameworks nowadays for mobile application developments, In this post, I will show you a step-by-step roadmap on how to learn flutter the right way, 500k apps built using Flutter since its first release in 2018 and this tells the power Flutter has been gained so quickly.
If you’re here that means you want a clear roadmap that you will follow to learn flutter.

Before thinking to learn Flutter you definitely should Learn its programming language Dart even if you have a programming background.

Why Should you learn Flutter?

Most beginners get confused when it comes to which Mobile apps framework/programming language to choose and learn.
Here are some of the solid reason that makes Flutter worth learning:
With Flutter, you can create Mobile apps that work on Android, iOS, and desktop apps that work on macOS, Linux, Windows, and the web, isn’t that amazing?
There are several top apps built with flutter like the Xianyu app by Alibaba, google ads app, Philips Hue by BMW, etc.
Flutter has huge community support and it’s growing fast!

Learn Dart First!

Since Flutter is built on top of Dart programming language, having the basics of Dart is necessary.
There are several courses and websites you can learn Dart from but I’ll address here the most beginner-friendly ones, here are some paid courses:
The Complete Dart Language Guide for Beginners and Beyond

This course is created by Andrea Bizzotto, as a beginner in mobile developments, this course will teach you Dart Programming in depth. Includes: basic to advanced topics, exercises, and projects. It’s updated to version Dart 2.15.
Dart - from Novice to Expert Complete Course

In this course, Tiberiu Potec will teach you, Dart, by visualizing the most important concepts of Dart Language, getting deeper into Dart fundamentals, and advanced topics such as sound null safety and OOP.

Paid courses are great but some of you may not afford them that’s why I collected some good free YouTube channels that teach Flutter and Dart in a great way:
FullStack School

This free Tutorial FullStack School will teach you all the basics of Dart that will allow you to get right into starting learning flutter which provide you best courses in the next paragraphs.
FreeCodeCamp

When it comes to learning computer science and programming FreeCodeCamp is a great choice, in this Dart Programming Tutorial-Full Course, the instructor is covering Dart from its basics to advanced topics.
Vandad Nahavandipoor(advanced topics)

Vandad Nahavandipoor in this course dives into Dart in detail and explores all its concepts.

If you are a reader and you like to learn by reading, I got you covered! here are some good websites to learn Dart from:

Dart's official website is the first resource I’m addressing, from a personal perspective learning from the official docs is a very good choice for developers who wants to learn things from its sources.
Tutorialspoint
Javapoint
geeksforgeeks

After getting familiar with Dart and having surrounded your head about its concepts, It’s time to jump into Flutter.

Learn Flutter

Now let’s take you one step further in your mobile developments journey and start learning Flutter, The courses I will recommend to you, it’s better to take them by order since will take you from the basics of Flutter to Advanced Topics such as State management and how to create complex applications.
So the first course that focuses on the basics of Flutter is The Complete 2021 Flutter Development Bootcamp with Dart by Dr. Angela Yu.

This course is officially created in collaboration with the google flutter team and it aims to teach especially beginners how to learn flutter in a way that focuses on fundamentals.
Once you took this course and have understood Flutter widgets, how to use them, and created several basics apps, the second course I’d recommend that focus on advanced topics is
Flutter & Dart - The Complete Guide [2022 Edition]

In this course, Maximilian Schwarzmüller teaches you Flutter and Dart in a depth, besides that he always tries to make you feel the importance of writing clean code and structuring the application so it will be easy to maintain in the future.

What’s Next?

By taking the courses above you will be ready to jump into practicing by yourself, and build stuff because let’s be honest, taking the courses will not take you that far if you don’t put the knowledge you have learned into practice, the name of the game is consistency and not giving up, fortunately, the Flutter Community is very helpful and people there are willing to help, if you find yourself stuck at something don’t get discouraged you can reach out the Community and describe your issue and definitely will find someone who will help you.

Fetch Data from the Internet with Flutter.

Yassine BENNKHAY — Mon, 26 Apr 2021 16:17:12 +0000

This article was posted in my Blog also, so I'll be happy if you check it out :)
Most apps need to deal with the internet and fetching data from it is necessary. Flutter and Dart provide tools such as the http package regarding this matter. to fetch data and display it in your app there're steps we'll follow and they're the following:

add the http package
make a network request using http package
convert the response into a Dart object
Fetch and display data with Flutter

In this article I'm going to use JSONPlaceholder to fetch a Post using http.get( ) method. So let's get Started!

1-add the http package:
in the pubspec.yaml file adds the latest version of the http package and get dependencies.

dependencies:
  http: <latest_version>

2-make a network request using http package:
we create a method of type ** Future of http.Response*. then we store the Response we get from our **http.get( )* method in the gettedPost variable .then we check if the gettedPost has data or not through the if statement as you can see in the code snippet below.

Future<http.Response> getPostDetails()async{
    http.Response gettedPost=
    await http.get(Uri.https('jsonplaceholder.typicode.com', 'posts/1'),);
    if(gettedPost.statusCode==200){
      //success
print(futurePost.body);//just printing out the data in the console for now!
      return null;
    }else{
//failed for some reason.
      throw Exception('we cant load your data ');
    }
  }

for testing purposes, I printed out the response in the console first :)

3-Convert the response into a custom Dart object:

the http.Response class contains the data received from a successful http call, however, we need to convert it to a custom dart object so we make life easier for us!
for that, we create a Post class that contains the data from the network request.
The Post class contains a factory constructor to create a Post.

class Post{
  int userId;
      int id;
  String title;
  String body;
  Post({this.body,this.title,this.id,this.userId});
factory Post.fromJson(Map<String,dynamic>comingJson){
  return Post(
    id: comingJson['id'],
    userId: comingJson['userId'],
    title: comingJson['title'],
    body: comingJson['body'],
  );
}
}

now we need to convert the http.Response to a Post using the dart:convert
and update the getPostDetails( ) to return a Future of Post.
If the server does return an OK response with a status code of 200, then convert the JSON Map into a Post using the fromJson() factory method.

If the server does not return an OK response with a status code of 200, then throw an exception.

import 'dart:convert';
  Future<Post> getPostDetails()async{
    http.Response futurePost=
    await http.get(Uri.https('jsonplaceholder.typicode.com', 'posts/1'),);
    if(futurePost.statusCode==200){
    /*if the server return an Ok status code 200 then convert the JSON Map into a Post*/
      return Post.fromJson(jsonDecode(futurePost.body));
    }else{
      /*if the server did not return an status code then throw exception*/
      throw Exception('we cant load your data ');
    }
  }

Great till now, we're quite close!
4-Fetch & Display Data:

to Fetch the data we create a variable to hold the getPostDetails( ) in the initState() method like this:

 Future<Post> postData;
@override
  initState(){
super.initState();
postData=getPostDetails();
  }

the last thing is to display the data in the user interface and for that, we'll use FutureBuilder widget and give it the future parameter you want to work with, in this case, getPostDetails( ) and the builder function that tells Flutter what to render.

FutureBuilder(
          future: postData,
          builder: (context,snapShot){
           if(snapShot.hasData){
             return Padding(
               padding: const EdgeInsets.all(8.0),
               child: Column(
                 children: [
               Text('the user id is: ${snapShot.data.userId}'),
                   Text('the id is : ${snapShot.data.id}'),
                   Text('the title is : ${snapShot.data.title}'),
                   Text('the body is: ${snapShot.data.body}'),
                 ],
               ),
             );
           }else if(snapShot.hasError){
             return Text("${snapShot.error}");
           }
           return CircularProgressIndicator();
          },
        ),

The Complete Example:

The Post Model:

class Post{
  int userId;
      int id;
  String title;
  String body;
  Post({this.body,this.title,this.id,this.userId});
factory Post.fromJson(Map<String,dynamic>comingJson){
  return Post(
    id: comingJson['id'],
    userId: comingJson['userId'],
    title: comingJson['title'],
    body: comingJson['body'],
  );
}
}

main ( ):

import 'dart:convert';

import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:http/http.dart 'as http;

import 'model/post.dart';
void main() {
  runApp(MyApp());
}
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
  Future<Post> postData;
@override
  initState(){
super.initState();
postData=getPostDetails();
  }
  Future<Post> getPostDetails()async{
    http.Response futurePost=
    await http.get(Uri.https('jsonplaceholder.typicode.com', 'posts/1'),);
    if(futurePost.statusCode==200){
    /*if the server return an Ok status code 200 then convert the JSON Map into a Post*/
      return Post.fromJson(jsonDecode(futurePost.body));
    }else{
      /*if the server did not return an status code then throw exception*/
      throw Exception('we cant load your data ');
    }
  }
  @override
  Widget build(BuildContext context) {
    return Scaffold(
appBar: AppBar(title: Text('getting data from the internet.'),),
      body: Center(
        child:FutureBuilder(
          future: postData,
          builder: (context,snapShot){
           if(snapShot.hasData){
             return Padding(
               padding: const EdgeInsets.all(8.0),
               child: Column(
                 children: [
               Text('the user id is: ${snapShot.data.userId}'),
                   Text('the id is : ${snapShot.data.id}'),
                   Text('the title is : ${snapShot.data.title}'),
                   Text('the body is: ${snapShot.data.body}'),
                 ],
               ),
             );
           }else if(snapShot.hasError){
             return Text("${snapShot.error}");
           }
           return CircularProgressIndicator();
          },
        ),
      ),
    );
  }
}

Alright! that was how to fetch a simple Post from the Internet with Flutter.

❤ ❤ Thanks for reading this article ❤❤

Please If I got something wrong? Let me know in the comments. I would love to improve!
if you find this article helpful click that like button and don't forget to check my Instagram for more Content about Flutter❤

The ultimate collection of vscode extensions for flutter.

Yassine BENNKHAY — Mon, 19 Apr 2021 17:38:47 +0000

Flutter has been gained big popularity in the last few years, and today I'm going to show you the must-have Vscode Extensions to work comfortably with it and to multiply your productivity, so without any further words let go into it!

1-Flutter :
This VS Code extension adds support for effectively editing, refactoring, running, and reloading Flutter mobile apps, as well as support for the Dart programming language.

2-Dart :
Dart Code extends VS Code with support for the Dart programming language and provides tools for effectively editing, refactoring, running, and reloading Flutter mobile apps, and AngularDart web apps.

3-Better Comments:
Better Comments
The Better Comments extension will help you create more human-friendly comments in your code.
With this extension, you will be able to categorize your annotations into:

Alerts
Queries
TODOs
Highlights

Commented out code can also be styled to make it clear the code shouldn't be there
Any other comment styles you'd like can be specified in the settings.

4-Bracket Pair Colorizer 2:
This extension allows matching brackets to be identified with colors. The user can define which tokens to match, and which colors to use

5-Dart Data Class Generator:
Create dart data classes easily, fast, and without writing boilerplate or running code generation.

6- Gradle Language Support:
An extension to provide Gradle language support for Visual Studio Code, including advanced functionalities like Syntax Highlighting, Keyword Auto-completion Proposals, and Duplication Validation.

7-Material Icon Theme: an extension to get the Material Design icons into your VS Code.

8-Pubspec Assist:
Pubspec Assist is a Visual Studio Code extension that allows you to easily add dependencies to your Dart and Flutter project's pubspec.yaml, all without leaving your editor.

9-Awesome Flutter Snippets:
Awesome Flutter Snippets is a collection of commonly used Flutter classes and methods. It increases your speed of development by eliminating most of the boilerplate code associated with creating a widget

10- Error Lens:
ErrorLens turbo-charges language diagnostic features by making diagnostics stand out more prominently, highlighting the entire line wherever a diagnostic is generated by the language and also prints the message inline.

Did I miss any extensions? Let me know in the comments.
If you find this useful give it a like and don't forget to follow me on Instagram and on my Blog for more useful stuff about flutter.