DEV Community: Sheena Zien

A Final Step, Connect Database And The Seeder (Part 3)

Sheena Zien — Sat, 27 Jul 2024 12:06:33 +0000

Hey there! Welcome back to our Golang API series. In Part 2, we set up the basic structure and routing for our API. Now, it's time to level up by adding JWT-based authentication and database migrations. Let's get started!

Setting Up JWT Authentication

First, let's install the JWT package:

go get github.com/gofiber/contrib/jwt

Update Router to Use JWT Middleware

Next, we'll update our router to include routes that require JWT authentication. Update router/router.go:

package router

import (
    "your_project/pkg/controllers"
    "your_project/pkg/middleware"

    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/cors"
)

func SetupRouter(app *fiber.App) {
    app.Use(cors.New())

    // Guest route
    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World!")
    })
    loginController := controllers.LoginController{}
    app.Post("/login", loginController.Login)

    // The middleware
    p := config.Config("APP_SCREET")
    app.Use(jwtware.New(jwtware.Config{
        SigningKey: jwtware.SigningKey{Key: []byte(p)},
    }))

    // Protected route
    app.Get("/profile", loginController.Profile)
}

Create The Controller

Let's create a LoginController that has a Login and Profile function in pkg/controllers/login-controller.go:

package controllers

import (
    "your_project/db"
    "your_project/pkg/models"
    "your_project/pkg/utils"
    "github.com/gofiber/fiber/v2"
    "golang.org/x/crypto/bcrypt"
)

type LoginController struct {
}

func (s LoginController) Login(c *fiber.Ctx) error {
    var input struct {
        Email    string `json:"email"`
        Password string `json:"password"`
    }
    if err := c.BodyParser(&input); err != nil {
        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
    }

    var user models.User
    if err := db.DB.Where("email = ?", input.Email).First(&user).Error; err != nil {
        return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid credentials"})
    }

    if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(input.Password)); err != nil {
        return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "Invalid credentials"})
    }

    token, err := utils.GenerateJWT(user.ID)
    if err != nil {
        return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
    }

    return c.JSON(fiber.Map{"token": token})
}

func (s LoginController) Profile(c *fiber.Ctx) error {
    userID := c.Locals("user_id").(uint)
    var user models.User
    if err := db.DB.First(&user, userID).Error; err != nil {
        return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
    }

    return c.JSON(user)
}

Create User Model

Ensure your user model has the necessary fields for registration and authentication. Update pkg/models/user.go:

package models

import "gorm.io/gorm"

type User struct {
    gorm.Model
    Name     string `json:"name"`
    Email    string `json:"email" gorm:"unique"`
    Password string `json:"-"`
}

Create JWT Utility

We'll create a utility function to generate JWT tokens. Create pkg/utils/jwt.go:

package utils

import (
    "time"

    "github.com/golang-jwt/jwt"
    "your_project/config"
)

func GenerateJWT(userID uint) (string, error) {
    secret := config.Config("APP_SECRET")
    claims := jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(time.Hour * 72).Unix(),
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString([]byte(secret))
}

Setting Up Database Migrations with Dbmate

Install Dbmate

go get github.com/amacneil/dbmate

Create Migration File

Create a migration file with make create-migration command then you can add the file name users this is will be generate timestamp_users.sql inside db/migrations directory, then you can the sql code with the following content:

-- migrate:up
CREATE SEQUENCE users_id_seq START WITH 1;
CREATE TABLE "users"(
    "id" int8 NOT NULL DEFAULT nextval('users_id_seq'::regclass),
    "email" TEXT,
    "password" TEXT,
    "created_at" timestamptz,
    "updated_at" timestamptz,
    "deleted_at" timestamptz,
    PRIMARY KEY("id"),
    UNIQUE("email")
);

-- migrate:down
DROP TABLE "users";
DROP SEQUENCE users_id_seq;

Running Migrations

make migrate

Create Seeder File

Let's create a seeder to populate our database with initial data, update your main.go

func main() {
    // other code ...
    app := fiber.New()
    db.ConnectDB()
    Seed()
   // other code ...
}

func Seed() {
    password, err := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
    if err != nil {
        log.Fatalf("Failed to hash password: %v", err)
    }

    user := models.User{
        Name:     "Admin",
        Email:    "admin@example.com",
        Password: string(password),
    }

    if err := db.DB.Create(&user).Error; err != nil {
        log.Fatalf("Failed to seed user: %v", err)
    }
}

Running the Project

With all the setup complete, you can now run your project. Open your terminal and run:

make watch

This will start the Fiber server, and you can now access your API at http://localhost:3000/.
And we have api in our application is:

We've completed the last part 🚀

Stay tuned on this repository where we'll continue to enhance our boilerplate, add more features, and improve our project structure even further. Happy coding!

Create The Router and The Config (Part 2)

Sheena Zien — Sat, 27 Jul 2024 12:06:13 +0000

Welcome back! In Part 1, we set up our project structure and created a basic Makefile. In this part, we’ll dive into coding and start setting up our Golang API using the packages we discussed.

Setting Up the Configuration

First, let's create a configuration file to manage our environment variables. Create a .env file in the root of your project with the following content:

APP_SCREET=app_screet
APP_PORT=3000
DB_DRIVER=postgres
DB_HOST=localhost
DB_NAME=dbname
DB_USER=postgres
DB_PASSWORD=postgres
DB_PORT=5432

Now, create config/config.go to load these environment variables:

package config

import (
    "fmt"
    "os"

    "github.com/joho/godotenv"
)

func Config(key string) string {
    err := godotenv.Load(".env")
    if err != nil {
        fmt.Print("Error loading .env file")
    }

    return os.Getenv(key)
}

Setting Up the Fiber Framework

Let's set up our main entry point. Create main.go:

package main

import (
    "log"

    "your_project/config"
    "your_project/router"

    "github.com/gofiber/fiber/v2"
)

func main() {
    secret := config.Config("APP_SECRET")
    if secret == "" {
        log.Panic("You must generate the secret key first")
    }

    app := fiber.New()
    port := config.Config("APP_PORT")

    router.SetupRouter(app)

    if err := app.Listen(":" + port); err != nil {
        log.Panic("Server won't run: ", err.Error())
    }
}

Setting Up the Router

Now, let's create the router. Create router/router.go:

package router

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/cors"
)

func SetupRouter(app *fiber.App) {
    app.Use(cors.New())

    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World!")
    })
}

Yay!! 🎉 now we've done to set up the main function of the API, let's try to run it using make command

make watch

This will start the Fiber server, and you can now access your API at http://localhost:3000/

Next Steps

In the next part of this series, we’ll enhance our boilerplate by adding JWT-based authentication and middleware. We’ll also cover how to connect to the database and create the migration file.

Stay tuned for Part 3!

Setup The Structure of Your Boilerplate (Part 1)

Sheena Zien — Thu, 25 Jul 2024 10:26:11 +0000

Hello there!

In this blog, I will share how I write my API using Golang with a simple boilerplate that I create. This guide will help you set up a robust starting point for your Golang API projects.

What you need is:

Reflect
Reflex is a small tool to watch a directory and rerun a command when certain files change. If you are familiar with the JavaScript ecosystem, you’ll find this package similar to npm watch.
Fiber
Fiber is an Express-inspired web framework built on top of Fasthttp, the fastest HTTP engine for Go. We'll use Fiber for our API framework.
Dotenv
For managing configuration files, we'll use dotenv. This package loads environment variables from a .env file into os.Getenv().
JWT
For authorization, we will use JWT (JSON Web Tokens).
GORM
GORM is an ORM library for Golang. We’ll use GORM to handle database operations.
Dbmate
Dbmate is a database migration tool. We’ll use Dbmate for handling database migrations.

Now we're ready to create the boilerplate, let's get started 🚀

Setting Up the Boilerplate

Let's get started by setting up the boilerplate structure. Here's what our project structure will look like:

├── Makefile
├── README.md
├── config
│   └── config.go
├── db
│   ├── connect.go
│   ├── migrations
│   │   ├── 20240722151143_users.sql
│   ├── schema.sql
│   └── seeder.go
├── go.mod
├── go.sum
├── main.go
├── pkg
│   ├── controllers
│   │   ├── login-controller.go
│   ├── dto
│   │   ├── user-dto.go
│   ├── models
│   │   └── user.go
│   └── utils
│       ├── pagination.go
│       └── validator.go
├── router
│   └── router.go
└── server

File and Directory Descriptions

Makefile: Automates common tasks like running tests, building the project, and generating files.
README.md: Documentation for the project.
config/config.go: Handles configuration loading and setup.
db/:
- connect.go: Manages database connections.
- migrations/: Contains SQL migration files.
- schema.sql: Defines the database schema.
- seeder.go: Seeds the database with initial data.
go.mod and go.sum: Dependency management files.
main.go: The entry point of the application.
pkg/:
- controllers/: Contains the controller logic.
- dto/: Data transfer objects.
- models/: Defines the data models.
- utils/: Utility functions.
router/router.go: Sets up the routing for the application.
server/: Manages server startup and configuration.

Creating the Makefile

Next, we’ll create a Makefile to automate simple tasks such as generating migration files and models.

Here is a basic Makefile example:

.PHONY: migrate
migrate:
    dbmate up

.PHONY: rollback
rollback:
    dbmate down

.PHONY: create-migration
create-migration:
    dbmate new $(name)

build:
    go build -o server main.go

run: build
    ./server

watch:
    reflex -s -r '\.go$$' make run

Next Steps

In the next part of this series, we'll start coding and set up our project by creating the necessary configuration files, setting up the Fiber framework, and initializing the database.

Stay tuned for Part 2, where we dive into the actual coding!

Gorm Pagination With Ease

Sheena Zien — Sat, 20 Jul 2024 03:26:53 +0000

Recently I've been struggling with pagination on Gorm, indeed gorm has an example that you need for this case, but it's a limit and offset query, the case I faced is to return the pagination information, Like Count, CurrentPage, FirstItem, HasMorePages, LastItem, LastPage, PerPage, and Total

So after a ton of browsing this case on the internet, I decided to create it.

1. Create The Struct

First, we need to define the necessary structs for pagination. We'll start by creating a resolver struct to hold all the required pagination information.

type PaginaterResolver struct {
    PaginatorInfo *PaginatorInfo `json:"paginatorInfo"`
    Data          interface{}    `json:"data"`
    model         interface{}
    request       Request
    stmt          *gorm.DB
}

Next, we create the PaginatorInfo struct to display the pagination details.

type PaginatorInfo struct {
    Count        int  `json:"count"`
    CurrentPage  int  `json:"currentPage"`
    FirstItem    int  `json:"firstItem"`
    HasMorePages bool `json:"hasMorePages"`
    LastItem     int  `json:"lastItem"`
    LastPage     int  `json:"lastPage"`
    PerPage      int  `json:"perPage"`
    Total        int  `json:"total"`
}

Then, we create the Request struct for pagination query parameters.

type Request struct {
    Offset   int
    Page     int
    PageSize int
}

2. Create the Setter Methods

We'll add setter methods to set up the statement, model, and request.

func (s *PaginaterResolver) Stmt(stmt *gorm.DB) *PaginaterResolver {
    s.stmt = stmt

    return s
}

func (s *PaginaterResolver) Model(model interface{}) *PaginaterResolver {
    s.model = model

    return s
}

For this example, we use GraphQL's ResolveParams to set the request parameters.

func (s *PaginaterResolver) Request(p graphql.ResolveParams) *PaginaterResolver {
    var page = 1
    if p.Args["page"] != nil {
        page = p.Args["page"].(int)
    }

    var pageSize = 10
    if p.Args["page_size"] != nil {
        pageSize = p.Args["page_size"].(int)
    }
    switch {
    case pageSize > 100:
        pageSize = 100
    case pageSize <= 0:
        pageSize = 10
    }
    offset := (page - 1) * pageSize
    s.request = Request{Offset: offset, Page: page, PageSize: pageSize}

    return s
}

You can customize this to accept different request types.

type RequestParams struct {
    Page     int
    PageSize int
}
func (s *PaginaterResolver) Request(p RequestParams) *PaginaterResolver {
    // Set request based on RequestParams
    return s
}

🎉 We've set up our initial requirements!

3. Create the Main Methods for Pagination

We need two main methods: Paginate() to fill the PaginatorInfo struct, and Paging() to apply the scope for pagination.

func (s *PaginaterResolver) Paginate() (PaginaterResolver, error) {
    var totalCount int64

    s.stmt.Model(s.model).Count(&totalCount)
    limit := s.request.PageSize
    page := s.request.Page
    offset := s.request.Offset
    lastPage := int((totalCount + int64(limit) - 1) / int64(limit))

    result := s.stmt.Scopes(s.Paging()).Find(s.model)
    if result.RowsAffected == 0 {
        config.LOG.Println("No data found")

        return PaginaterResolver{Data: []interface{}{}}, nil
    }

    paginatorInfo := &PaginatorInfo{
        Count:        int(result.RowsAffected),
        CurrentPage:  page,
        FirstItem:    offset + 1,
        HasMorePages: page < lastPage,
        LastItem:     offset + int(result.RowsAffected),
        LastPage:     lastPage,
        PerPage:      limit,
        Total:        int(totalCount),
    }

    s.PaginatorInfo = paginatorInfo
    s.Data = s.model

    return *s, nil
}

func (s *PaginaterResolver) Paging() func(db *gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        return db.Offset(s.request.Offset).Limit(s.request.PageSize)
    }
}

🔥 Now, we can use this pagination code in our GORM queries. Here's an example:

paginaterResolver := new(scopes.PaginaterResolver)
query := config.DB.Scopes(
    post.GetPage,
    post.GetOnlyPublish,
    scopes.Order(orderBy[0]),
).Preload(clause.Associations).Find(&posts)

if query.Error != nil {
    return scopes.PaginaterResolver{}, query.Error
}

paginater, err := paginaterResolver.
    Request(p).
    Stmt(query).
    Model(&posts).
    Paginate()

Below is the result.

{
    "data": {
        "paymentMethods": {
            "data": [
                {
                    "id": 7,
                    "slug": "payment-method-2",
                    "type": "paymentmethod"
                },
                // More items...
            ],
            "paginatorInfo": {
                "count": 10,
                "currentPage": 1,
                "firstItem": 1,
                "hasMorePages": true,
                "lastItem": 10,
                "lastPage": 2,
                "perPage": 10,
                "total": 16
            }
        }
    }
}

Conclusion

Implementing pagination in GORM can be challenging, but by creating custom structs and methods, we can effectively manage pagination information. This approach ensures that all necessary pagination details are included in our API responses, making it easier to work with large datasets.

Feel free to customize and extend this implementation to suit your specific needs. Happy coding! 🎉