DEV Community: Muhammad Adam

How to Build REST API using Lumen 8

Muhammad Adam — Mon, 08 Aug 2022 06:39:00 +0000

REST API is a mandatory skill that must be mastered by backend developers today, several well-known frameworks that help you develop it are Lumen. Lumen is a derivative project from Laravel that focuses on developing micro-frameworks, you could say this framework is smaller and faster. Therefore in this session, I will write for you how to create a REST API using the Lumen Framework.

Installation Lumen

Before making a REST API of course we will first install lumen on local using composer, here is the command to install Lumen :

composer create-project --prefer-dist laravel/lumen rest-api-lumen

after the installation process is complete, it will automatically create a new folder called rest-api-lumen, open the folder using your favorite text editor and then we will start configuring the project.

Step 1 : Configuration

Open the .env file, find the following key and adjust it as below:

DB_CONNECTION=sqlite

DB_HOST=

DB_PORT=

DB_DATABASE=storage/database.sqlite

DB_USERNAME=

DB_PASSWORD=

CACHE_DRIVER=array

QUEUE_DRIVER=database

QUEUE_CONNECTION=sync

At this time we will use an SQLite database as a place to store data.

Step 2: Database and Migrations

After the configuration process is complete, we will first create the table using migration, run the command below to create a new migration file:

php artisan make:migration create_products_table

After that the new migration file is in the **database/migrations **folder, this time the example table that we will create is the product table which contains several attributes, namely name, price and description. follow the code below:

Then follow the command below to run the process of creating the product table:

php artisan migrate

Step 3: Create Model

The next step we will create a model for the product table by creating a new file called Product.php in the app/Models folder and then following the code below:

Unlike laravel, our lumen framework must first configure when using Eloquent and Facades by opening the bootstrap/app.php file, then uncommenting the following code:

Step 4: Create Controller

The next step we will create a new controller file called ProductController.php, put the file into the app/Http/Controller folder, then follow the code below:

Step 5: Setup Routes

The next step we will customize the routes file, open the web.php file in the routes folder and follow the code below :

In the picture above we create a route url prefix with the name api/v1 then we create another prefix group for our api products, after everything is done, it’s time for us to start testing the API to make sure it runs smoothly.

Step 6: Testing API

Pada langkah terakhir ini kita akan mencoba api yang sudah kita buat sebelumnya, untuk test apinya aku memakai extensinon Thunder Client pada Visual Studi Code atau bisa memakai Postman, Sebelum test API kita jalankan terlebih dahulu lumen menggunakan perintah dibawah ini :

php -S 0.0.0.0:8000 -t public/

kemudian bisa dilanjutkan untuk test APInya, berikut adalah hasil dari test API :

GET All Products

Get Product By ID

Create Product

Update Product

Delete Product

Conclusion

We have been able to create a REST API for a product using the Lumen framework, of course, this is not enough because basically making a REST API requires other components such as Authorization, Rate Limiting, etc. You can see the source code of this article on my github **account,** don’t forget to give a star and share this article if it is useful for you.

Thanks For Reading!

Available for a new project! Let’s have a talk :
email : bangadam.dev@gmail.com
LinkedIn : https://www.linkedin.com/in/bangadam

Do You Need A Implementation Jwt In Go (Golang)?

Muhammad Adam — Mon, 08 Aug 2022 06:37:55 +0000

Go is becoming very popular for backend development, and JWT’s are one of the most popular ways to handle authentication on API requests. In this article, we are going to go over the basics of JWT’s and how to implement a secure authentication strategy in Go! Let’s go

What is a JWT?

JSON Web Token (JWT, pronounced /dʒɒt/, same as the word “jot”[1]) is a proposed Internet standard for creating data with optional signature and/or optional encryption whose payload holds JSON that asserts some number of claims. The tokens are signed either using a private secret or a public/private key.

JWTs have essentially encoded JSON objects that have been signed by the server, proving their authenticity.

For example, when a user login into a website secured via JWTs, the flow should look something like this:

The user sends a username and password to the server
The server verifies username and password are correct
The server creates a JSON object that looks like this:
{“username”: “adam”}
The server encodes and signs the JSON object, creating a JWT:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
The user’s web client saves the JWT for later use
When the user makes a request to a protected endpoint, the JWT is passed along in an HTTP header
The server checks the signature on the JWT to make sure the JWT was originally created by the same server
The server reads the claims and gives permission to the request to operate as “adam”

Create a JWT

Before we create a JWT, we are going to use a library for dealing with JSON Web Token in go using golang-jwt. Make sure you have the code cloned in your local by running the below command :

go get github.com/golang-jwt/jwt/v4

This implies that we presume the server that generates the JWTs will also be the sole server that verifies them.

First, define a struct that will be used to represent claims or identity for users data :

The jwt.StandardClaims struct contains useful fields like expiry, issuer name, Subject and etc. Now we will create some actual claims for the user that just logged in :

After that, Create an unsigned token from the claims :

token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

Sign the token using a secure private key. Make sure you use a real private key, preferably at least 256 bits in length:

signedToken, err := token.SignedString([]byte(“secureSecretText”))

Now the signed token can be sent back to the client.

Validating a JWT

When a client requests a secured endpoint, we may use the following steps to validate the JWT.

Note: To use the Authorization HTTP header is idiomatic:

Authorization: Bearer {jwt}

After obtaining the JWT, use the same private key to validate the claims and verify the signature.

token, err := jwt.ParseWithClaims(
    jwtFromHeader,
    &customClaims{},
    func(token *jwt.Token) (interface{}, error) {
        return []byte("secureSecretText"), nil 
    },
)

The err variable will not be null if the claims have been tampered with. Parse the following claims from the token:

claims, ok := token.Claims.(*customClaims)
if !ok {
    return errors.New("Couldn't parse claims")
}

Check if the token is expired:

if claims.ExpiresAt < time.Now().UTC().Unix() {
    return errors.New("JWT is expired")
}

You now know the username of the authenticated user!

username := claims.Username

For full examples take a look at this example.

Thanks For Reading!

Available for a new project! Let’s have a talk bangadam.dev@gmail.com

Writing Unit Test in Golang Easily

Muhammad Adam — Thu, 04 Aug 2022 00:58:00 +0000

Writing Unit Test in Golang Easily

Unit testing is the most important thing in developing an application, which aims to minimize the occurrence of errors, therefore software developers are obliged to master it. In this article, we will write unit tests in the Golang programming language using the unit testing package provided by Golang.

Let’s get started!

What are Unit Tests?

In computer programming, **unit testing **is a software testing method by which individual units of source code — sets of one or more computer program modules together with associated control data, usage procedures, and operating procedures — are tested to determine whether they are fit for use

Developers use unit testing to validate individual functions, methods, modules, and packages. Unit testing aids in the discovery and elimination of issues early in the development cycle, as well as the prevention of regressions during refactoring. A decent unit test may also act as documentation for new developers on the project.

Goals

In this article, it is hoped that readers will get an insight into how to do basic testing on the Golang programming language using the standard package, namely “testing”.

Step 1: project structure

In a project belonging to someone else, surely you have encountered a file that has the prefix _test.go, right? and always in the same directory as the main file to be tested. At this time we will first create the project structure as below:

project/
 - main.go
 - main_test.go

don’t forget to run go mod init to initialize the project on Golang.

$ go mod init

Step 2: make simple func

We will create a simple function that we will test later, the name of the function is Calculate(). This Calculate() function has the aim of adding a number and adding 2, it’s quite easy isn’t it, let’s make the code as below:

Step 3: Create a test file

after we create the Calculate() function, the next step is that we will create a test file for the function. Create a new file called main_test.go and put it in the same directory, follow the code below:

Step 4: Running Tests

After we have created the test file, it’s time for us to try to run the testing command by calling the go test command on the terminal or CMD, as below:

$ go test

If the process is successful then the display of the test process will be as shown below:

easy isn’t it? This is more or less how to make a test in the Golang programming language.

Table Driven Testing

After we succeeded in creating a test file in the previous Calculate() function, there is actually another way to make the test code better and dynamic, namely by creating an array model. You can see an example of this code below:

With the above code, we can declare the input and expected values for each test case in the data array above. After you add it, try running the test one more time:

Conclusion

in this article, it can be concluded that writing unit tests is very important for the development process so that it can help carry out test code that has been made according to expectations or not, in the next stage maybe I will discuss code coverage on unit tests that we have made previously. If you need the source code above, just check my GitHub here https://github.com/bangadam/go-test-introduction

Thanks For Reading!

Available for a new project! Let’s have a talk :
Email: bangadam.dev@gmail.com
Linkedin: https://www.linkedin.com/in/bangadam