Posted on Jan 1, 2021 • Edited on Jan 4, 2021

Golang: Create Authentication JWT #1

After all this time we learned Golang which is a simple application application, finally we want to make a complete application but we are stuck with the question, how do we authenticate in Golang? That was also my question when I decided to move from node-js to golang.

Folder structure introduction

In this tutorial we will use the folder structure that I usually use
├───app
├───domain
├───entities
│ └───helper
├───interface
│ └───http
└───services
└───user
├───repository
│ └───postgres
└───usecase
app: contains main.package which will be executed the first time the go program is run.
domain: contains the struct domain
entities/helper: contains helper functions
interface/http: contains the gin gonic routing handler
service: contains service
usecase: where to put usecase instead of the user.
repository: where to put the repository

now run go mod init shellrean.com/auth in the created folder.

Create a table in postgresql

For our DBMS, this time using PostgreSQL, create a table with the names of users with the following specifications:

id (int) auto increment
name (string)
email (string)
password (string)
created_at (timestamp)
updated_at (timestamp) Then create 1 dummy user, make it free to generate passwords from bcrypt using the online tool at Bcrypt-Generator ## Create domain files create user.go file and save it in the domain folder, we will create a domain struct and user interface in this file.

package domain import ( "time" "context" ) type User struct { ID int64 `json:"id"` Name string `json:"name" validate:"required"` Email string `json:"email" validate:"required,email"` Password string `json:"password" validate:"required,min=6"` CreatedAt time.Time `json:"created_at"` UpdatedAt time.Time `json:"updated_at"` } type UserUsecase interface { Authentication(ctx context.Context, ur DTOUserLoginRequest) (DTOTokenResponse, error) RefreshToken(ctx context.Context, ur DTOTokenResponse) (DTOTokenResponse, error) } type UserRepository interface { GetByID(ctx context.Context, id int64) (User, error) GetByEmail(ctx context.Context, email string) (User, error) }

create a domain.go file then save it in the same folder, we will make a domain struck for the token in this file

package domain type TokenDetails struct { AccessToken string RefreshToken string AtExpires int64 RtExpires int64 }

Create a file repository

create main_user.go file and save it in the services/user/repository/postgres folder, we will create a repository function for retrieving data from the database.

package postgres import ( "context" "database/sql" "shellrean.com/auth/domain" ) type postgresUserRepository struct { Conn *sql.DB } func NewPostgresUserRepository(Conn *sql.DB) domain.UserRepository { return &postgresUserRepository{ Conn, } } func (m *postgresUserRepository) GetByEmail(ctx context.Context, email string) (u domain.User, err error) { query := `SELECT id,name,email,password,created_at,updated_at FROM users WHERE email=$1` err = m.Conn.QueryRowContext(ctx, query,email). Scan(&u.ID,&t.Name,&t.Email,&t.Password,&t.CreatedAt,&t.UpdatedAt) if err != nil { return err } return }

Create a helper file

create token.go file and save it in the entities /helper folder, we will create a helper function that will perform the operation with JWT

package helper import ( "strings" "time" "github.com/dgrijalva/jwt-go" "shellrean.com/auth/domain" ) func GenerateTokenDetail(td *domain.TokenDetails) { td.AtExpires = time.Now().Add(time.Minute * 15).Unix() td.RtExpires = time.Now().Add(time.Hour * 24 * 7).Unix() } func CreateAccessToken(key string, user domain.User, td *domain.TokenDetails) (err error) { atClaims := jwt.MapClaims{} atClaims["authorized"] = true atClaims["user_id"] = user.ID atClaims["exp"] = td.AtExpires at := jwt.NewWithClaims(jwt.SigningMethodHS256, atClaims) td.AccessToken, err = at.SignedString([]byte(key)) if err != nil { return domain.ErrSessDecode } return } func ExtractToken(bearer string) (res string) { str := strings.Split(bearer, " ") if len(str) == 2 { res = str[1] return } return } func VerifyToken(key string, tokenString string) (*jwt.Token, error) { token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok { return nil, domain.ErrSessDecode } return []byte(key), nil }) if err != nil { return nil, domain.ErrSessVerifation } return token, nil } func TokenValid(token *jwt.Token) error { if _, ok := token.Claims.(jwt.Claims); !ok || !token.Valid { return domain.ErrSessInvalid } return nil } func ExtractTokenMetadata(token *jwt.Token) map[string]interface{}{ claims, ok := token.Claims.(jwt.MapClaims) if ok && token.Valid { return claims } return nil }