Forem: Ndifreke Friday

Build a Nodejs Restful API with Express and MongoDB

Ndifreke Friday — Wed, 15 Jan 2020 15:00:36 +0000

This Article was first published on voidnerd.com/

In this tutorial, we are going to build an authenticated nodejs api with express, hash passwords with bcryptjs and secure your API with JWT.

Prerequisite

Make sure you have the following installed on your system

Nodejs >= v12
Mongo >= v4
Postman (To test your endpoints)

Now that we have the prerequisites out of the way, let's create a directory for our app, run below this bash command for this.

$ mkdir node-api && cd node-api

NPM utility will walk you through creating a package.json file. Follow the prompt and press enter all through to use the defaults.

$ npm init

Create Files and Folders in your node-api directory like so:

--model
-----user.js
-----index.js
--controllers
-----auth.js
-----user.js
-----index.js
--public
--.env
--middleware.js
--.gitignore
--routes.js
--server.js

Notice the .evn file; this is where we will store our sensitive values as enviromental variables.

.gitignore is where we specify files or folders we don't want git to track; this is so we don't push sensitive or unwaranted data to github (or your prefered source code repository).

public folder for serving your static files.

Install project dependencies

In your project directory run below command to install dependencies.

$ npm install express mongoose morgan parse-error dotenv bcryptjs jsonwebtoken indicative

For further reading on these dependencies

Express - https://expressjs.com/
Mongoose -https://mongoosejs.com/
morgan - https://www.npmjs.com/package/morgan
indicative - https://github.com/poppinss/indicative
dotenv - https://www.npmjs.com/package/dotenv
jsonwebtoken - https://www.npmjs.com/package/jsonwebtoken
bcryptjs - https://www.npmjs.com/package/bcryptjs
parse-error - https://www.npmjs.com/package/parse-error

Moving on...

Register.

Just like every other thing on earth, we are going to start with creation (pun intended). In this section, we will focus on setting up our app and enabling user creation. Less talk, more code, let's roll :) .

Add needed enviromental variables to your .env file like so:

MONGO_URL=mongodb://127.0.0.1:27017/nodeApp
JWT_SECRET=thisisasecretlongstring

Add paths we would like git to ignore in .gitignore file like so:

node_modules/
.env

Type in the following code in model/User.js .

const  mongoose = require('mongoose')
const  Schema = mongoose.Schema;
const  bcrypt = require('bcryptjs');
const  JWT = require('jsonwebtoken')

const  jwtSecret = process.env.JWT_SECRET

let  userSchema = Schema({
    name:  String,
    email: {
    type:  String,
    required:  true,
    unique:  true
    },
    password:  String
})

// hash passwords for new records before saving
userSchema.pre('save', function(next) {
if(this.isNew) {
    var  salt = bcrypt.genSaltSync(10)
    var  hash = bcrypt.hashSync(this.password, salt)
    this.password = hash
}
next();
});
//validate user password
userSchema.methods.validPassword = function(inputedPassword) {
    return  bcrypt.compareSync(inputedPassword, this.password)
}

//sign token for this user
userSchema.methods.getJWT = function() {
    return  JWT.sign({ userId:  this._id }, jwtSecret)
}
module.exports = mongoose.model('User', userSchema)

In the above sample we are defining our user schema and hashing our password for new records(this.isNew in pre save hook) . We also made available validPassword method for validating passwords and getJWT method of retrived user specific token.

Add this to models/index.js, this will help us have access to all the modules in models folders when we import just the folder [e.g require('./models').

var  normalizedPath = require("path").join(__dirname);
require("fs").readdirSync(normalizedPath).forEach(function(file) {

    if(!file.includes('index')) {
        var  moduleName = file.split('.')[0];
        exports[moduleName] = require('./' + moduleName);
    }
});

For our registration logic, add below code to controllers/auth.js

const { validate } = require('indicative').validator;
const {User } = require('../models')


exports.register = async (req, res) => {

    //Validate request data
    const  rules = {
        name:  'required|string',
        email:  'required|email',
        password:  'required|min:6|max:30'
    }


    validate(req.body, rules).catch((errors) => {
        return  res.status(422).json(errors[0])
    });
    try {
        const  user = new  User  //initialize mongoose Model
        user.name = req.body.name
        user.email = req.body.email
        user.password = req.body.password
        await  user.save() //save user record to database

        const  token = user.getJWT();

        // data { user, token } = data {user: user, token token}
        return  res.status(201).json({data: { user, token }});
    } catch (err) {
        //return error if user unique field already exists
        if(err.name === 'MongoError' && err.code === 11000) {

        field = Object.keys(err.keyValue)[0]
        const response = {
            message:  `${field} already exists!`, field:  field
        }   
        return  res.status(422).json(response)
    }

    return  res.status(409).json({message:  "error saving data"})

    }
}

In the above code we validated our request with indicative, save out user record to mongodb and return the appropriate responses to our users.

Add this to constrollers/index.js to have access to all modules in controllers folder.

var  normalizedPath = require("path").join(__dirname);
require("fs").readdirSync(normalizedPath).forEach(function(file) {

    if(!file.includes('index')) {
        var  moduleName = file.split('.')[0];
        exports[moduleName] = require('./' + moduleName);
    }
});

let's work on our routes on routes.js

var  express = require('express')
var  router = express.Router()

/* Import Controllers*/
const  controllers = require('./controllers');


/* Define all your routes*/

router.post('/register', controllers.auth.register)
router.post('/login', controllers.auth.login)


/*Export your routes*/
module.exports = router;

See how neat our routes are, when we use controllers. I love it :)

Let's get down to our Server Logic. Add below code to server.js.

const  express = require('express')
const  app = express()
const  path = require('path') //native module, no need to install
require('dotenv').config()
const  logger = require('morgan')
const  mongoose = require('mongoose')
const  pe = require('parse-error')
const  routes = require('./routes')

const  port = 3000 // server starts on this port

//mongoose options
const  mongooseOptions = {
    useUnifiedTopology:  true,
    useNewUrlParser:  true,
    useCreateIndex:  true
}

//connect to database
mongoose.connect(process.env.MONGO_URL, mongooseOptions)
    .then(
    () =>  console.log('Database Connection established!'),
    err  =>  console.log(err)
)

app.use(logger('dev')) // For logging out errors to the console
app.use(express.json()) // for parsing application/json
app.use(express.urlencoded({ extended:  true })) // for parsing application/x-www-form-urlencoded
app.use(express.static(path.join(__dirname, 'public'))) // For serving static files
//use routes
app.use('/api', routes)

//handle unhandled error
process.on('unhandledRejection', error  => {
    console.error('Uncaught Error', pe(error))
    return
})

app.listen(port, () => {
    console.log(`Server Stated on http://localhost:${port}`)
})

Change directory to your project and run the command

node server.js

Test your api with postman using the register endpoint http://localhost:3000/api/register and you should get a successful response like the image below.

Login

Our Initial setup is going to be really helpful from here on out.

For our login logic, add code to controllers/auth.js just below your register logic

...
exports.login = async (req, res) => {
    const  rules = {
        email:  'required|email',
        password:  'required|min:6|max:30'
    }

    validate(req.body, rules).catch((errors) => {
        return  res.status(422).json(errors[0])
    });

    try {
        const  user = await  User.findOne({email:  req.body.email})

        if(!user) throw  new  Error("Invalid Email or Password")

        if(!user.validPassword(req.body.password) ) {
            throw  new  Error("Invalid Email or Password")
        }

        const  token = user.getJWT();

        return  res.status(200).json({data: { user, token }});

    } catch (err) {
        console.log(err)
        if(err) return  res.status(401).json({message:  err.message})
    }
}

In the above code we validated incoming request, checked if it's user has correct credentials and returned the appropriate response.

Now add this to your routes.js file just below your register route.

...

router.post('/login', controllers.auth.login)

...

Ctrl C to stop your app if it is running and re-run it

$ node server.js

Test your api with postman using the login endpoint http://localhost:3000/api/login .

User Profile

For our grand finale, we are going to have one route(user profile) of which users need the right access get a successful response.

Add this to middleware.js

const  JWT = require('jsonwebtoken');
const {User } = require('./models')

const  jwtSecret = process.env.JWT_SECRET

exports.auth = async (req, res, next) => {
    try {
        //get token from header: Bearer <token>
        const  token = req.headers.authorization.split(' ')[1];
        //verify this token was signed by your server
        const  decodedToken = JWT.verify(token, jwtSecret);
        ///Get user details
        let  user = await  User.findById(decodedToken.userId)
        if(!user) throw  Error("Unauthenticated")
        //put user in req object; so the controller can access current user
        req.user = user
        next();
    } catch {
        return res.status(401).json({
        message:  "Unauthenticated"
        });
    }
}

In the above code, we get the bearer token from the authorization header, verify the token, get user details and pass those details to the next function(controller).

Add below code to controllers/users.js

exports.currentUser = (req, res) => {
    return  res.status(200).json(req.user);
}

And finally, your routes.js should look like the one below

var  express = require('express')
var  router = express.Router()

/* Import Controllers*/
const  controllers = require('./controllers');

/* Import Middleware*/
const  middleware = require('./middleware')

/* Define all your routes*/
router.post('/register', controllers.auth.register)
router.post('/login', controllers.auth.login)

router.get('/profile', middleware.auth, controllers.users.currentUser)


/*Export your routes*/
module.exports = router;

Ctrl C to stop your app if it is running and re-run it

$ node server.js

Test your protected endpoing http://localhost:3000/api/profile .

Tip: Pay attention to the Headers section and the Authorization value.
Tip 2: Get your token from a successful login/register response.

Where do I go from here? Well there are a lot more ways we could improve our current API; you could add bonus routes like: delete user, get all users, get single user, update user and search users . I will leave this to you as a challenge, have fun :) .

Here's a link to the full code on github.

Wow, you got this far!! You are super awesome. As always, I would like to see your contributions down in the comments.

Thanks for taking your time out to read all through :), Adios!

Build a JWT Authenticated API with Lumen(v5.8)

Ndifreke Friday — Sat, 24 Aug 2019 21:26:15 +0000

In this tutorial, we will be using lumen; a super-fast micro-framework by laravel to build a simple and secure REST API. At the end of this tutorial, you should be able to build production-ready APIs. Let's get started!

Prerequisite

Make sure you have the essentials, I beg of you.

PHP >= 7.1.3
OpenSSL PHP Extension
PDO PHP Extension
Mbstring PHP Extension
Mysql >= 5.7
Composer (Dependency Manager for PHP)
Postman (To test your endpoints)

Installation

First things first, you need to get lumen's cli.

$ composer global require "laravel/lumen-installer"

If your download was successful, run below command to confirm you have lumen installed.

$ lumen

If you encounter an error like -bash: lumen: command not found, you need to add composer's vender bin to your path.

If all is in order, you should see something like so.

Now run this command to create the lumen project

$ lumen new auth-app

Enter the project folder

$ cd auth-app

Run the app

$ php -S localhost:8000 -t public

Load localhost:8000 on your browsers address bar and it should render a result as shown below.

Open up the project (auth-app) in your preferred editor.

Create a .env file, copy all contents in .env.example into the .env file and add your database configurations.

In boostrap/app.php uncomment the facades and eloquent method

//before

// $app->withFacades();

// $app->withEloquent();

//after

$app->withFacades();

$app->withEloquent();

Turning on withFacades inject the application IoC to Illuminate\Support\Facades\Facade. Without doing so even if you're importing Illuminate\Support\Facades\File it wouldn't work. Credit

The $app->withEloquent() method actually enables the query builder too. It's registering the DatabaseServiceProvider, which is required to use the query builder. Credit.

Create a user

Make user's database migration

$ php artisan make:migration create_users_table --create=users

Locate the migration file database/migrations/*_create_users_table.php and add neede table columns(name, email, password); see code below:

...
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->string('email')->unique()->notNullable();
            $table->string('password');
            $table->timestamps();
        });
    }
...

Migrate your database

$ php artisan migrate

Add register route which as the name implies; register users. Locate routes/web.php and insert the needed code as seen below

// API route group
$router->group(['prefix' => 'api'], function () use ($router) {
   // Matches "/api/register
   $router->post('register', 'AuthController@register');

});

Since we are going to prefix api in all our endpoint, to reduce repetition we will use route grouping to do just that.

This method ($router->post($uri, $callback); takes in a $url and a $callback parameter. In the $callback, AuthController is our controller class (we will create this class in a bit) and register is a method in said class.

Let's create our AuthControler.

Create file app/Http/Controllers/AuthController.php and populate it with code as seen below.


<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use  App\User;

class AuthController extends Controller
{
    /**
     * Store a new user.
     *
     * @param  Request  $request
     * @return Response
     */
    public function register(Request $request)
    {
        //validate incoming request 
        $this->validate($request, [
            'name' => 'required|string',
            'email' => 'required|email|unique:users',
            'password' => 'required|confirmed',
        ]);

        try {

            $user = new User;
            $user->name = $request->input('name');
            $user->email = $request->input('email');
            $plainPassword = $request->input('password');
            $user->password = app('hash')->make($plainPassword);

            $user->save();

            //return successful response
            return response()->json(['user' => $user, 'message' => 'CREATED'], 201);

        } catch (\Exception $e) {
            //return error message
            return response()->json(['message' => 'User Registration Failed!'], 409);
        }

    }


}

User sign in

Pull in the JWT authentication package.

$ composer require tymon/jwt-auth:dev-develop

Generate your API secret

$ php artisan jwt:secret

create file config/auth.php with below config

//config.auth.php

<?php

return [
    'defaults' => [
        'guard' => 'api',
        'passwords' => 'users',
    ],

    'guards' => [
        'api' => [
            'driver' => 'jwt',
            'provider' => 'users',
        ],
    ],

    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => \App\User::class
        ]
    ]
];

Make some changes to your User model(app/User.php) to fit tymon/jwt-auth's requirements. Keep your eye out for everything that includes "JWT".

<?php

namespace App;

use Illuminate\Auth\Authenticatable;
use Laravel\Lumen\Auth\Authorizable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\Access\Authorizable as AuthorizableContract;


use Tymon\JWTAuth\Contracts\JWTSubject;

class User extends Model implements AuthenticatableContract, AuthorizableContract, JWTSubject
{
    use Authenticatable, Authorizable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'email'
    ];

    /**
     * The attributes excluded from the model's JSON form.
     *
     * @var array
     */
    protected $hidden = [
        'password',
    ];




    /**
     * Get the identifier that will be stored in the subject claim of the JWT.
     *
     * @return mixed
     */
    public function getJWTIdentifier()
    {
        return $this->getKey();
    }

    /**
     * Return a key value array, containing any custom claims to be added to the JWT.
     *
     * @return array
     */
    public function getJWTCustomClaims()
    {
        return [];
    }
}

Make some changes to bootstrap/app.php

//before
// $app->routeMiddleware([
//     'auth' => App\Http\Middleware\Authenticate::class,
// ]);

//After
$app->routeMiddleware([
    'auth' => App\Http\Middleware\Authenticate::class,
]);

//before
 // $app->register(App\Providers\AppServiceProvider::class);
 // $app->register(App\Providers\AuthServiceProvider::class);
 // $app->register(App\Providers\EventServiceProvider::class);

//After
 // $app->register(App\Providers\AppServiceProvider::class);
 $app->register(App\Providers\AuthServiceProvider::class);
 // $app->register(App\Providers\EventServiceProvider::class);

 // Add this line
 $app->register(Tymon\JWTAuth\Providers\LumenServiceProvider::class);

Add login route in routes/web.php

// API route group
$router->group(['prefix' => 'api'], function () use ($router) {
     // Matches "/api/register
    $router->post('register', 'AuthController@register');

      // Matches "/api/login
     $router->post('login', 'AuthController@login');
});

Add a global respondWithToken method to Controller class in app/Http/Controllers/Controller.php. This is so we could access it from any other controller.

   ...
  //import auth facades
  use Illuminate\Support\Facades\Auth;


  //Add this method to the Controller class
  protected function respondWithToken($token)
    {
        return response()->json([
            'token' => $token,
            'token_type' => 'bearer',
            'expires_in' => Auth::factory()->getTTL() * 60
        ], 200);
    }

Add a login method to your AuthController class in app/Http/Controllers/AuthController.php

   ...

   //import auth facades
   use Illuminate\Support\Facades\Auth;

   ...

     /**
     * Get a JWT via given credentials.
     *
     * @param  Request  $request
     * @return Response
     */
    public function login(Request $request)
    {
          //validate incoming request 
        $this->validate($request, [
            'email' => 'required|string',
            'password' => 'required|string',
        ]);

        $credentials = $request->only(['email', 'password']);

        if (! $token = Auth::attempt($credentials)) {
            return response()->json(['message' => 'Unauthorized'], 401);
        }

        return $this->respondWithToken($token);
    }

Authenticated routes

For our grand finale, we are going to make some authenticated routes.

Add a couple of routes to routes/web.php

...
// API route group
$router->group(['prefix' => 'api'], function () use ($router) {
    // Matches "/api/register
   $router->post('register', 'AuthController@register');
     // Matches "/api/login
    $router->post('login', 'AuthController@login');

    // Matches "/api/profile
    $router->get('profile', 'UserController@profile');

    // Matches "/api/users/1 
    //get one user by id
    $router->get('users/{id}', 'UserController@singleUser');

    // Matches "/api/users
    $router->get('users', 'UserController@allUsers');
});

...

Create a file app/Http/Controllers/UserController.php and populate it with this elegant looking code.

<?php

namespace App\Http\Controllers;

use Illuminate\Support\Facades\Auth;
use  App\User;

class UserController extends Controller
{
     /**
     * Instantiate a new UserController instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth');
    }

    /**
     * Get the authenticated User.
     *
     * @return Response
     */
    public function profile()
    {
        return response()->json(['user' => Auth::user()], 200);
    }

    /**
     * Get all User.
     *
     * @return Response
     */
    public function allUsers()
    {
         return response()->json(['users' =>  User::all()], 200);
    }

    /**
     * Get one user.
     *
     * @return Response
     */
    public function singleUser($id)
    {
        try {
            $user = User::findOrFail($id);

            return response()->json(['user' => $user], 200);

        } catch (\Exception $e) {

            return response()->json(['message' => 'user not found!'], 404);
        }

    }

}

Below is an example call to one of the three newly added endpoints

Here's a link to the full code on github.

The end-ish!

I hope this article has helped you in some way, and that you build upon this knowledge to deploy awesome APIs in the nearest future. I would like to see your contributions down in the comments too.

Hasta la vista.

Deploying Laravel on shared Hosting

Ndifreke Friday — Mon, 12 Aug 2019 09:59:55 +0000

If you are here, you are probably exploring how laravel works on shared hosting, on some low-budget project or just have reasons you prefer shared hosting. Alright, let's get down to business.

Here are the steps to get laravel up and running on shared hosting:

(1) Run php artisan config:clear; this clears the cache config. Since you are going to be editing .env online; you don't need your local configurations cached.

(2) Export Your migrated Database to a file (db.sql) without the create database statement, like so:

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (
 `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
 `title` varchar(255) DEFAULT NULL,
 `name` varchar(255) NOT NULL,
 `facebook_id` varchar(255) DEFAULT NULL,
 `google_id` varchar(255) DEFAULT NULL,
 `linkedin_id` varchar(255) DEFAULT NULL,
 `tagline` varchar(255) DEFAULT NULL,
 `email` varchar(255) DEFAULT NULL,
 `username` varchar(255) DEFAULT NULL,
 `email_verification_code` varchar(255) DEFAULT NULL,
 `email_verified_at` timestamp NULL DEFAULT NULL,

 `password` varchar(255) DEFAULT NULL,
 `remember_token` varchar(100) DEFAULT NULL,
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB;

DROP TABLE IF EXISTS `password_resets`;

CREATE TABLE `password_resets` (
 `email` varchar(254) NOT NULL,
 `token` varchar(254) NOT NULL,
 `created_at` timestamp NULL DEFAULT NULL,
 KEY `password_resets_email_index` (`email`)
) ENGINE=InnoDB;

(3) go to MultiPHP Manager on c-panel and confirm you have php 7.1 or higher.

(4) Zip the finished project (we will call this myproject from now on) and upload to root directory of hosting storage through File Manager (c-panel) or FileZilla; it should be something like /home/domain-name.

(5) Extract myproject in root directory(/home/domain-name) of hosting storage.

(6) Enable "Show Hidden Files". This is so you could see files like .htaccess, .env, etc.

(7) In myproject/public, move all it's contents to /public_html.

(8) Now edit /public_html/index.php to point to your laravel project, like so:

//previous state
require __DIR__.'/../vendor/autoload.php';

// changed to
require __DIR__.'/../myproject/vendor/autoload.php';

//previous state
$app = require_once __DIR__.'/../bootstrap/app.php';

//changed to
$app = require_once __DIR__.'/../myproject/bootstrap/app.php';

(9) Edit .env in /myproject with your config keys

(10) Import and run the db.sql script you exported earlier on your created database through phpmyadmin on c-panel.

The end!

Introduction to OOP in Javascript

Ndifreke Friday — Fri, 17 Nov 2017 15:07:13 +0000

What is this OOP thingy.

"Object-oriented programming (OOP) is a programming language model organized around objects rather than "actions" and data rather than logic" - Margeret Rouse.

To better understand let's have a look at Person as an Object, what attributes can a person have? legs, hands, head etc; these are the properties of the Person. Okay so what can a person do, run, walk, crawl, talk, sit, stand etc; these are methods of the Person object. Notice that I keep using capital "P" when I refer to the Person object, well that's how class names are written.

The basic idea of OOP is that we use objects to model real world things that we want to represent inside our programs - developer.mozilla.org

let's see some code examples shall we;

Defining Classes

We define classes using the class keyword and name ("Person"). Properties are written in the constructor method. The this keyword assigns properties to the class, this here refers to an instance of the class, think of this as a pronoun if class was a noun.

//class declaration

class Person {
     constructor() {
        this.name = "Isaac";
         this.age = 21;
     }
}

let person = new Person();

console.log(person.name); // logs - Isaac

This looks fine, but what if we want users of our programme to enter their name and age, just what if, then we have to add parameters to our constructor method. Parameters are placeholders use in functions to accept arguments( what are arguments again? just values pal). code below:

class Person {
     constructor(name, age) {
        this.name = name;
         this.age = age;
     }
}

let person = new Person("Isaac", 23);

let person1 = new Person("Bob", 28);

console.log(person.name); // logs - Isaac
console.log(person1.name);// logs - Bob

Class Methods

That was cool, now let's look at methods (getters, setters etc), they are not scary at all, let's look at an example:

class Person {
    constructor(name, age) {
       this.name = name;
       this.age = age;
    }

   // setter
   setName(name) {
       this.name = name;
   }

   //getter
   bio() {
       return this.description();
   }

   //some method with a lil logic
   description(){
       return this.name + " is " + this.age + "years old.";
   }

}

let person = new Person("Isaac", 23);

person.setName("Joy");

console.log(person.bio()); // logs -  Joy is 23years old.

I told you they were not scary, getters just get property values while setters change property values
and I used this opportunity to show you you can return another method with another, note that we can simply do return this.name + " is " + this.age + "years old."; in our bio() method.

Inheritance

Now we have a nice Person class that describes a Person,but as we go down our programme we may have other classes like Boss, Father, Mother, Worker etc. All this class will have same properties of the Person class and more. Why write same codes over and over again when you can use inheritance.

Here, a Father inherits properties/methods of Person.

 //Parent class
class Person {
    constructor(name, age) {
       this.name = name;
       this.age = age;
    }
   setName(name) {
       this.name = name;
   }
   bio() {
       return this.description();
   }
   description(){
       return this.name + " is " + this.age + "years old.";
   }

}

//child class
class Father extends Person {

    bio(){
        return super.bio();
    }
}

var father = new Father("Isaac", 34);

console.log(father.name) //logs - Isaac
console.log(father.bio()); //logs - Isaac is 34years old.

We used extends to allow Father access to properties/methods of Person.
Noticed the super used to return bio()?

We use super to access methods of parent-class("Person").

Conclusion

We covered class definition, properties, methods and inheritance, if you need more information,mozilla is always there to help;

I will be waiting for your awesome contributions down in the comment section.

Thanks for taking your time to read till the end, I appreciate, Bye.