DEV Community: Orololuwa

Setting up handlers with the Repository Pattern: A Test-driven approach in Go.

Orololuwa — Sun, 28 Apr 2024 19:43:02 +0000

Introduction

Writing tests are essential in software development to ensure the reliability, maintainability, and quality of software products. In this article, I will be delving into a good approach to setting up and testing handlers in Go called the Repository pattern. The Repository pattern is a developmental approach that allows you to separate your database logic from your application logic to make it easy to test your code.

Prerequisite

Basic understanding of the Go programming language

Setting up a DB repo for the database logic

Before we begin setting up our handlers, we need to set up a basic connection to the database and we'd be doing that by implementing the repository pattern for a user model.
We start by initializing the app as a go module using the command

go mod init github.com/orololuwa/reimagined-robot

Typically, you would use a repository from your GitHub as the module name.

In a models package, we create a simple user model like;

package models

import "time"

type User struct {
    ID int
    FirstName string
    LastName  string
    Email     string
    Password string
    CreatedAt time.Time
    UpdatedAt time.Time
}

In a repository folder and package, we would create two files, repository.go and users.go as thus;

package repository

import "github.com/orololuwa/reimagined-robot/models"

type UserRepo interface {
    CreateAUser(user models.User) (int, error)
    GetAUser(id int) (models.User, error)
}

package repository

import (
    "context"
    "database/sql"
    "time"

    "github.com/orololuwa/reimagined-robot/models"
)

type user struct {
    DB *sql.DB
}

func NewUserRepo(conn *sql.DB) UserRepo {
    return &user{
        DB: conn,
    }
}
func (m *user) CreateAUser(user models.User) (int, error){
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    var newId int

    query := `
            INSERT into users 
                (first_name, last_name, email, password, created_at, updated_at)
            values 
                ($1, $2, $3, $4, $5, $6)
            returning id`

    err := m.DB.QueryRowContext(ctx, query, 
        user.FirstName, 
        user.LastName, 
        user.Email, 
        user.Password,
        time.Now(),
        time.Now(),
    ).Scan(&newId)

    if err != nil {
        return 0, err
    }

    return newId, nil
}


func (m *user) GetAUser(id int) (models.User, error){
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    var user models.User

    query := `
            SELECT (id, first_name, last_name, email, password, created_at, updated_at)
            from users
            WHERE
            id=$1
    `

    err := m.DB.QueryRowContext(ctx, query, id).Scan(
        &user.ID,
        &user.FirstName,
        &user.LastName,
        &user.Email,
        &user.Password,
        &user.CreatedAt,
        &user.UpdatedAt,
    )

    if err != nil {
        return user, err
    }

    return user, nil
}

In the above snippets, we create a user struct, a NewUserRepo function to initialize the struct, and receiver functions to the struct to handle the database logic. If you want to learn more about setting up a database repo, you can check this out.

Creating the handlers for the application logic

Now we create a handlers.go package where all the application logic will be done.

1) Paste the package declaration at the top of the file and import the packages that would be used in the handler.

package handlers

import (
    "database/sql"
    "encoding/json"
    "net/http"
    "strconv"

    "github.com/go-chi/chi/v5"
    "github.com/orololuwa/reimagined-robot/models"
    "github.com/orololuwa/reimagined-robot/repository"
)

2) We create a struct and an initialization function to hold the db repo and any other configs that we might need in our handlers:

type Repository struct {
    User repository.UserRepo
}

var Repo *Repository

func NewHandler(db *sql.DB) {
    r := &Repository{
        User: repository.NewUserRepo(db),
    }
    Repo = r
}

we call the struct Repository because it's going to hold references to the database repositories and any other repository we might create and make available to it, like an in-memory db repository or even an app config. We can see that the initialization function initializes the User field with the repository.NewUserRepo function from the repository package.

3) Create the CreateAUser handler function to create a user:

func (m *Repository) CreateAUser(w http.ResponseWriter, r *http.Request) {
    type userBody struct {
        FirstName string `json:"firstName"`
        LastName string `json:"lastName"`
        Email string `json:"email"`
        Password string `json:"password"`
    }

    var body userBody

    err := json.NewDecoder(r.Body).Decode(&body)
    if err != nil {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusInternalServerError)
        responseMap := map[string]interface{}{"message": "error decoding requset body",}

        jsonData, err := json.Marshal(responseMap)
        if err != nil {
            return
        }

        w.Write(jsonData)
        return
    }

    user := models.User{
        FirstName: body.FirstName,
        LastName: body.LastName,
        Email: body.Email,
        Password: body.Password,
    }

    id, err := m.User.CreateAUser(user)
    if err != nil {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusBadRequest)        
        responseMap := map[string]interface{}{"message": "error creating user",}

        jsonData, err := json.Marshal(responseMap)
        if err != nil {
            return
        }

        w.Write(jsonData)
        return
    }

    response := map[string]interface{}{"message": "user created successfully", "data": id}
    jsonResponse, err := json.Marshal(response)
    if err != nil {
        http.Error(w, "Failed to marshal response", http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(jsonResponse)
}

the handler function above receives the HTTP response and a pointer to the request. First, we decode the body of the request and pass it to the CreateAUser function made available to us from the User field. We write error messages to the client if there are any or we write the data.

4) Create the GetAUser handler to get a user by id:

func (m *Repository) GetAUser(w http.ResponseWriter, r *http.Request){
    exploded := strings.Split(r.RequestURI, "/")
    id, err := strconv.Atoi(exploded[2])
    if err != nil {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusInternalServerError)
        responseMap := map[string]interface{}{"message": "error decoding id",}

        jsonData, err := json.Marshal(responseMap)
        if err != nil {
            return
        }

        w.Write(jsonData)
        return
    }

    user, err := m.User.GetAUser(id)
    if err != nil {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusNotFound)
        responseMap := map[string]interface{}{"message": "error getting user",}

        jsonData, err := json.Marshal(responseMap)
        if err != nil {
            return
        }

        w.Write(jsonData)
        return
    }

    response := map[string]interface{}{"message": "user created successfully", "data": user}
    jsonResponse, err := json.Marshal(response)
    if err != nil {
        http.Error(w, "Failed to marshal response", http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(jsonResponse)
}

In the handler function above, we decode the id of the user from the URL param, using the function from the chi router. You can install chi router with go get github.com/go-chi/chi/v5. We pass the id to the GetAUser function made available to us from the User field and write the data to the client.

The `main.go` file.

1) First we create a main.go file, declare the package main, and import the other packages that would be used in the file.

package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
    _ "github.com/jackc/pgx/v5/stdlib"
    "github.com/orololuwa/reimagined-robot/handlers"
)

2) We declare a run function where we create a connection to the database, initialize our handlers package with the NewHandler function and declare our routes.To open a connection to the database, I'm using a pgx driver called jackc and you can install it using go get github.com/jackc/pgx/v5
At the top of the file, we import the router, the pgx driver with a blank import, and, the other packages used in the main.go file.

func run()(*sql.DB, *chi.Mux, error){
    dbHost := "localhost"
    dbPort := "5432"
    dbName := "bookings"
    dbUser := "orololuwa"
    dbPassword := ""
    dbSSL := "disable"

    // Connecto to DB
    log.Println("Connecting to dabase")
    dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s sslmode=%s", dbHost, dbPort, dbName, dbUser, dbPassword, dbSSL)

    db, err := sql.Open("pgx", dsn)
    if err != nil {
        log.Fatal("Cannot conect to database: Dying!", err)
    }
    if err = db.Ping(); err != nil {
        panic(err)
    }
    log.Println("Connected to database")

    handlers.NewHandler(db)
    router := chi.NewRouter()

    router.Use(middleware.Logger)

    router.Post("/user", handlers.Repo.CreateAUser)
    router.Get("/user/{id}", handlers.Repo.GetAUser)
    return db, router, nil
}

Ideally, you should store your database connection details as environment variables.
3) Lastly, we create the main function, call the run function inside of it, and serve our application.

const portNumber = ":8080"
func main(){
    db, route, err := run()
    if (err != nil){
        log.Fatal(err)
    }
    defer db.Close()

    fmt.Println(fmt.Sprintf("Staring application on port %s", portNumber))

    srv := &http.Server{
        Addr: portNumber,
        Handler: route,
    }

    err = srv.ListenAndServe()
    if err != nil {
        log.Fatal(err)
    }
}

Now, when we run go run main.go and test on Postman, we get the following result:

Writing Tests

Here comes the fun part 🤩.
The first thing we want to do is create mock implementations of our database logic functions, the UserRepo functions in this case. So, we would create a new file test-repo.go under the package repository with the following steps.
1) Declare the package repository and import the necessary packages.

package repository

import (
    "database/sql"
    "errors"

    "github.com/orololuwa/reimagined-robot/models"
)

2) Next, we create a test repo struct and an initialization function to implement the UserRepo interface we previously had.

type testUserDBRepo struct {
    DB *sql.DB
}

func NewUserTestingDBRepo() UserRepo {
    return &testUserDBRepo{
    }
}

3) Next, we create the mock implementation of the UserRepo functions as thus;

func (m *testUserDBRepo) CreateAUser(user models.User) (int, error){
    var newId int

    if user.Password == "invalid"{
        return newId, errors.New("CreateAUser: DB repo fail")
    }

    return newId, nil
}

func (m *testUserDBRepo) GetAUser(id int)(models.User, error){
    var user models.User

    if id == 0{
        return user, errors.New("GetAUser: DB repo fail")
    }

    return user, nil
}

In the CreateAUser function above, we create a scenario where the function returns an error. Likewise, the GetAUser function.
Now that we've mocked our UserRepo functions, we would go ahead and write tests for the handlers.

The Handlers
In the handlers package/folder, we would create a file called setup_test.go to set up what we would need in the actual test. In this file, we would go ahead and initialize a test db repo with the mocked functions. Your test files have to end with the suffix _test.go to allow the go compiler to see it in the testing environment. In the file, we would put the following code;

package handlers

import (
    "os"
    "testing"

    "github.com/orololuwa/reimagined-robot/repository"
)

func NewTestingHandler() {
    r := &Repository{
        User: repository.NewUserTestingDBRepo(),
    }
    Repo = r
}

func TestMain(m *testing.M){
    NewTestingHandler()
    os.Exit(m.Run())
}

In the code above, the TestMain function is going to run before any other test functions we'd create later. It receives a pointer to testing.M, which makes available to us, a Run function.
Next, we would go ahead and install an external package for creating mocking data.

go get -u github.com/go-faker/faker/v4

Now we create a new file; handlers_test.go where we write the tests for the handlers as thus:
1) Declare the package and import every other package that would be used.

package handlers

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/go-faker/faker/v4"
)

2) Next, we create a TestCreateAUser function to test the CreateAUser handler.

func TestCreateAUser(t *testing.T){
    type UserBody struct {
        FirstName string `json:"firstName" faker:"first_name"`
        LastName string `json:"lastName" faker:"last_name"`
        Email string `json:"email" faker:"email"`
        Password string `json:"password" faker:"password"`
    }

    body := UserBody{}
    err := faker.FakeData(&body)
    if err != nil {
        t.Log(err)
    }

    jsonBody, err := json.Marshal(body)
    if err != nil {
        t.Log("Error:", err)
        return
    }

    // Test for success
    req, _ := http.NewRequest("POST", "/user", bytes.NewBuffer(jsonBody))
    rr := httptest.NewRecorder()

    handler := http.HandlerFunc(Repo.CreateAUser)
    handler.ServeHTTP(rr, req)

    if rr.Code != http.StatusCreated {
        t.Errorf("CreateAUser handler returned wrong response code: got %d, wanted %d", rr.Code, http.StatusCreated)
    }

    // Test for missing request body
    req, _ = http.NewRequest("POST", "/user", bytes.NewBuffer([]byte(``)))
    rr = httptest.NewRecorder()

    handler = http.HandlerFunc(Repo.CreateAUser)
    handler.ServeHTTP(rr, req)

    if rr.Code != http.StatusInternalServerError {
        t.Errorf("CreateAUser handler returned wrong response code for missing body: got %d, wanted %d", rr.Code, http.StatusInternalServerError)
    }

    // Test for failed DB insert
    body.Password = "invalid"
    jsonBody, err = json.Marshal(body)
    if err != nil {
        t.Log("Error:", err)
        return
    }

    req, _ = http.NewRequest("POST", "/user", bytes.NewBuffer(jsonBody))
    rr = httptest.NewRecorder()

    handler = http.HandlerFunc(Repo.CreateAUser)
    handler.ServeHTTP(rr, req)

    if rr.Code != http.StatusBadRequest {
        t.Errorf("CreateAUser handler returned wrong response code for failed UserRepo db function: got %d, wanted %d", rr.Code, http.StatusBadRequest)
    }
}

In the snippet above, we declare the Userbody struct with struct tags including the JSON and Faker metadata. We create mock data into the body variable with the Faker package and encode it into JSON into the jsonBody variable. We create instances of the HTTP Request and ResponseRecorder and test them according to different cases. In this, we tested for cases of a successful request, missing request body, and failed DB operation.
3) Still in the same file, we create a TestGetAUser function to test the GetAUser handler

func TestGetAUser(t *testing.T){
    // test for success
    req, _ := http.NewRequest("GET", "/user/1", nil)
    req.Header.Set("Content-Type", "application/json")
    req.RequestURI = "/user/1"  
    res := httptest.NewRecorder()

    handler := http.HandlerFunc(Repo.GetAUser)  
    handler.ServeHTTP(res, req)

    if res.Code != http.StatusOK {
        t.Errorf("GetAUser handler returned wrong response code: got %d, wanted %d", res.Code, http.StatusOK)
    }

    // test valid id in the path variable
    req, _ = http.NewRequest("GET", "/room", nil)
    req.Header.Set("Content-Type", "application/json")
    req.RequestURI = "/room/one"

    res = httptest.NewRecorder()

    handler = http.HandlerFunc(Repo.GetAUser)

    handler.ServeHTTP(res, req)

    if res.Code != http.StatusInternalServerError {
        t.Errorf("GetAUser handler returned wrong response code for invalid query param 'id': got %d, wanted %d", res.Code, http.StatusInternalServerError)
    }

    // test for failed db operation
    req, _ = http.NewRequest("GET", "/room", nil)
    req.Header.Set("Content-Type", "application/json")  
    req.RequestURI = "/room/0"


    res = httptest.NewRecorder()

    handler = http.HandlerFunc(Repo.GetAUser)

    handler.ServeHTTP(res, req)

    if res.Code != http.StatusNotFound {
        t.Errorf("GetAUser handler returned wrong response code for failed UserRepo function: got %d, wanted %d", res.Code, http.StatusNotFound)
    }
}

In the snippet above, we create instances of the HTTP Request and ResponseRecorder and test for cases where the request is successful, the id is missing or invalid, and a failed DB operation.

The main file
Testing the main file is quite easy. We create a main_test.go file in the root under the main package and try to run the "run" function as thus:

package main

import "testing"

func TestRun(t *testing.T){
    _, _, err := run();
    if err != nil {
        t.Error("failed run")
    }
}

Running the test commands
There are different ways to run the test.
1) You can do so with a simple test command without any flags

go test ./...

2) You can run it with the -v (verbose) flag to get more details about which test functions passed or failed.

go test -v ./...

3) Running it with -cover flag to get the percentage of obvious test cases that were covered in the test.

go test -cover ./...

4) Running it to get the coverage output as an HTML file.

go test -coverprofile=coverage.out  ./... && go tool cover -html=coverage.out

Conclusion

In this article, we explored a basic way to set up handlers and write proper tests. You can build on it as your code gets robust and complicated. The source code is available on my Github

Setting up a Database Driver, Repository and Implementation of a transaction function for your Go App

Orololuwa — Mon, 22 Apr 2024 09:21:32 +0000

Overview

Databases are the foundation for building any app as it stores the data for implementing the architectural design. It is important to set it up in the best possible way that will allow for optimal performance of the app and also to make it seamless when writing tests. In this article, I will be taking you on a step-by-step journey on how to set up your database connection and repository.

Prerequisite

Basic understanding of the Go programming language

Getting Started

Sometimes, backend developers tend to opt for an ORM library because it provides an abstraction between your app and the database and thus there is little or no need to write raw queries and migrations which is nice. However, if you want to get better at writing queries (SQL for example), you need to learn how to build your repositories without an ORM. To open a database handle, you can either do it directly from the database driver or do it from database/sql with the driver passed into it. I will be opening the connection with database/sql together with pgx which is a driver and toolkit for PostgreSQL. Walk with me.

First things first, we start by installing pgx with the command below.

go get github.com/jackc/pgx/v5

In a driver.go file, put the following code

package driver

import (
    "database/sql"

    _ "github.com/jackc/pgx/v5/stdlib"
)

type DB struct {
    SQL *sql.DB
}

var dbConn = &DB{}

func ConnectSQL(dsn string)(*DB, error){
    db, err := sql.Open("pgx", dsn)

    if err := db.Ping(); err != nil {
        panic(err)
    }

    dbConn.SQL = db

    return dbConn, err
}

In the above snippet, we import database/sql and do a blank import of github.com/jackc/pgx/v5/stdlib. The essence of the blank import is to make the package available to the driver from database/sql. sql.Open returns a pointer to sql.DB so we, first of all, create a struct DB with a field SQL that can hold it and declare it into dbConn. The essence of having a struct is so it can hold a variety of different connections, for example, if you were to open another connection to a MongoDB database, you could store it in a field called Mongo in the DB struct. Afterward, we open a connection in the ConnectSQL function, test for an error by pinging it, and assign it to dbConn.

Then in our main.go file we call the ConnectSQL function as thus.

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/orololuwa/crispy-octo-guacamole/driver"
)
const portNumber = ":8080"

func main(){
    db, err := run()
    if (err != nil){
        log.Fatal(err)
    }
    defer db.SQL.Close()

    fmt.Println(fmt.Sprintf("Staring application on port %s", portNumber))


    srv := &http.Server{
        Addr: portNumber,
        Handler: nil,
    }

    err = srv.ListenAndServe()
    if err != nil {
        log.Fatal(err)
    }
}

func run()(*driver.DB, error){
    dbHost := "localhost"
    dbPort := "5432"
    dbName := "your_db_name"
    dbUser := "your_user"
    dbPassword := ""
    dbSSL := "disable"

    // Connecto to DB
    log.Println("Connecting to dabase")
    connectionString := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s sslmode=%s", dbHost, dbPort, dbName, dbUser, dbPassword, dbSSL)

    db, err := driver.ConnectSQL(connectionString)
    if err != nil {
        log.Fatal("Cannot conect to database: Dying!", err)
    }
    log.Println("Connected to database")

    return db, nil
}

In the main.go file above, we have a run function where we call the ConnectSQL function to open a connection to the database, and is passed to the main function after which we call defer db.SQL.Close() to close the connection when the main function is done executing.

Next, we create two files repository.go and users.go in a folder or package repository, but before then we have to define the user model. So in a models.go file, we define the model with fields as thus:

package models

import "time"

type User struct {
    ID int
    FirstName string
    LastName  string
    Email     string
    Password string
    CreatedAt time.Time
    UpdatedAt time.Time
}

I'm guessing you know how to create migrations to populate your database, if not you can check out an amazing package I use called fizz.

Next, in the repository.go file, we put the following code:

package repository

import (
    "github.com/orololuwa/crispy-octo-guacamole/models"
)

type UserRepo interface {
    CreateAUser(user models.User) (int, error)
    GetAUser(id int) (models.User, error)
    GetAllUser() ([]models.User, error)
    UpdateAUsersName(id int, firstName, lastName string)(error)
    DeleteUserByID(id int) error
}

In the snippet above, the UserRepo is an interface that defines all the functions that a user repo struct should implement.

Next, in the users.go file, we would go ahead and create a user repo struct, a New-like function to initialize it, and receiver functions to the user repo struct that satisfies the UserRepo interface as thus:

package repository

import (
    "context"
    "database/sql"
    "time"

    "github.com/orololuwa/crispy-octo-guacamole/models"
)

type user struct {
    DB *sql.DB
}

func NewUserRepo(conn *sql.DB) UserRepo {
    return &user{
        DB: conn,
    }
}

func (m *user) CreateAUser(user models.User) (int, error){
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    var newId int

    query := `
            INSERT into users 
                (first_name, last_name, email, password, created_at, updated_at)
            values 
                ($1, $2, $3, $4, $5, $6)
            returning id`

    err := m.DB.QueryRowContext(ctx, query, 
        user.FirstName, 
        user.LastName, 
        user.Email, 
        user.Password,
        time.Now(),
        time.Now(),
    ).Scan(&newId)

    if err != nil {
        return 0, err
    }

    return newId, nil
}

func (m *user) GetAUser(id int) (models.User, error){
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    var user models.User

    query := `
            SELECT id, first_name, last_name, email, password, created_at, updated_at
            from users
            WHERE
            id=$1
    `

    err := m.DB.QueryRowContext(ctx, query, id).Scan(
        &user.ID,
        &user.FirstName,
        &user.LastName,
        &user.Email,
        &user.Password,
        &user.CreatedAt,
        &user.UpdatedAt,
    )

    if err != nil {
        return user, err
    }

    return user, nil
}

func (m *user) GetAllUser() ([]models.User, error){
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    var users = make([]models.User, 0)

    query := `
        SELECT id, first_name, last_name, email, password, created_at, updated_at
        from users
    `

    rows, err := m.DB.QueryContext(ctx, query)
    if err != nil {
        return users, err
    }

    for rows.Next(){
        var user models.User
        err := rows.Scan(
            &user.ID,
            &user.FirstName,
            &user.LastName,
            &user.Email,
            &user.Password,
            &user.CreatedAt,
            &user.UpdatedAt,
        )
        if err != nil {
            return users, err
        }
        users = append(users, user)
    }

    if err = rows.Err(); err != nil {
        return users, err
    }

    return users, nil
}

func (m *user) UpdateAUsersName(id int, firstName, lastName string)(error){
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    query := `
        UPDATE 
            users set (first_name, last_name) = ($1, $2)
        WHERE
            id = $3
    `

    _, err := m.DB.ExecContext(ctx, query, firstName, lastName, id)
    if err != nil{
        return  err
    }

    return nil
}

func (m *user) DeleteUserByID(id int) error {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    query := "DELETE FROM users WHERE id = $1"

    _, err := m.DB.ExecContext(ctx, query, id)
    if err != nil {
        return err
    }

    return nil
}

The standard convention across all repositories involves an initialization pattern, where a New-like function takes a database connection to initialize the type, thereby assigning it to an unexported field. Some refer to this convention as the Repository Pattern. The function NewUserRepo takes in a connection and initializes a new repo from the user struct, it also returns the UserRepo to ensure that the struct properly implements the functions in the UserRepo interface.
Without going too deep, the functions create, read from, update, and delete a user from the database. You'd notice that the values were being passed into the query in the format of $1, $2; it is a good practice to pass it as such to prevent SQL injection.

Next, in the main.go file, I would create a handler that will call one of the DatabaseRepo functions to test as thus:

package main

import (
+   "encoding/json"
    "fmt"
    "log"
    "net/http"

+   "github.com/go-chi/chi/v5"
    "github.com/orololuwa/crispy-octo-guacamole/driver"
+   "github.com/orololuwa/crispy-octo-guacamole/models"
+   "github.com/orololuwa/crispy-octo-guacamole/repository"
)
const portNumber = ":8080"

func main(){
-   db, err := run()
+   db, route, err := run()
    if (err != nil){
        log.Fatal(err)
    }
    defer db.SQL.Close()

    fmt.Println(fmt.Sprintf("Staring application on port %s", portNumber))


    srv := &http.Server{
        Addr: portNumber,
-       Handler: nil,
+       Handler: route,
    }

    err = srv.ListenAndServe()
    if err != nil {
        log.Fatal(err)
    }
}

-func run()(*driver.DB, error){
+func run()(*driver.DB, *chi.Mux, error){
    dbHost := "localhost"
    dbPort := "5432"
    dbName := "bookings"
    dbUser := "orololuwa"
    dbPassword := ""
    dbSSL := "disable"

    // Connecto to DB
    log.Println("Connecting to dabase")
    connectionString := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s sslmode=%s", dbHost, dbPort, dbName, dbUser, dbPassword, dbSSL)

    db, err := driver.ConnectSQL(connectionString)
    if err != nil {
        log.Fatal("Cannot conect to database: Dying!", err)
    }
    log.Println("Connected to database")
+   userRepo := repository.NewUserRepo(db.SQL)
+   router := chi.NewRouter()
+
+   router.Post("/user", func(w http.ResponseWriter, r *http.Request) {
+       type userBody struct {
+           FirstName string `json:"firstName"`
+           LastName string `json:"lastName"`
+           Email string `json:"email"`
+           Password string `json:"password"`
+       }
+
+       var body userBody
+       
+       err := json.NewDecoder(r.Body).Decode(&body)
+       if err != nil {
+           w.Header().Set("Content-Type", "application/json")
+           +w.WriteHeader(http.StatusInternalServerError)
+           return
+       }
+
+       user := models.User{
+           FirstName: body.FirstName,
+           LastName: body.LastName,
+           Email: body.Email,
+           Password: body.Password,
+       }
+       
+       id, err := userRepo.CreateAUser(user)
+       if err != nil {
+           w.Header().Set("Content-Type", "application/json")
+           +w.WriteHeader(http.StatusInternalServerError)
+           return
+       }
+
+       response := map[string]interface{}{"message": "user created successfully", "data": id}
+       jsonResponse, err := json.Marshal(response)
+       if err != nil {
+           http.Error(w, "Failed to marshal response", http.StatusInternalServerError)
+           return
+       }
+       w.Header().Set("Content-Type", "application/json")
+       w.WriteHeader(http.StatusOK)
+       w.Write(jsonResponse)
+   })
+
-   return db, nil
+   return db, router, nil
}

in the code above, we register a new router (chi router is being used here), create a post handler and assign it to a /user route. In the handler, we decode the data from the request's body and pass it into the CreateAUser function which is available to us in the userRepo. You can run your application and go ahead to test it on Postman.

Part 2: Implementing a transaction function

There are some queries you want to either completely succeed or fail, e.g. If you have an e-commerce system that has a wallet feature; When a user buys a product, you want to debit the wallet and reduce the product count in the inventory. These two actions in the database have to either completely succeed or completely fail.
Transaction functions are very crucial to maintaining data consistency. They have a state and all queries executed in the transaction function are tagged to the state after which you can decide to commit the results of executing those queries or rollback if there is an error with either one of the queries.
To start, we'd create a new file under the repository package and name it. you can name it whatever you want, i'd go ahead and name mine db-repo.go. In the file, we'd use the repository pattern to initialize a new instance, but before then we need to create an interface that declares the transaction function that should be implemented. So, we would go ahead and update the repository.go file with this.

package repository

import (
+   "context"
+   "database/sql"
+
    "github.com/orololuwa/crispy-octo-guacamole/models"
)

type UserRepo interface {
    CreateAUser(user models.User) (int, error)
    GetAUser(id int) (models.User, error)
    GetAllUser() ([]models.User, error)
    UpdateAUsersName(id int, firstName, lastName string)(error)
    DeleteUserByID(id int) error
}

+type DBRepo interface {
+   Transaction(ctx context.Context, operation func(context.Context, *sql.Tx) error) error 
+}

Then, in the db-repo.go file, we go ahead and put the following code.

package repository

import (
    "context"
    "database/sql"
)

type dbRepo struct {
    DB *sql.DB
}

func NewDBRepo(conn *sql.DB) DBRepo {
    return &dbRepo{
        DB: conn,
    }
}

func (m *dbRepo) Transaction(ctx context.Context, operation func(context.Context, *sql.Tx) error) error {
    tx, err := m.DB.BeginTx(ctx, nil)
    if err != nil {
        return err
    }

    defer func() error{
        if err != nil {
            tx.Rollback()
            return err
        }

        if err := tx.Commit(); err != nil {
            return err
        }

        return nil
    }()

    if err := operation(ctx, tx); err != nil {
        return err
    }

    return nil
}

In the code above, we declare a dbRepo struct and a function to initialize it and implement the DBRepo interface. The transaction function takes in a context and a function that uses the context and the transaction that was started inside the parent function to execute queries.
The BeginTx function from *sql.DB takes in two variables, the context and an object where you can specify the isolation level of the transaction. A function is run after the transaction has been called where there is a rollback if an error occurs or the changes are committed if no error occurs.
Now we would have to refactor the UserRepo functions to accept the context and the transaction reference.

package repository

import (
    "context"
    "database/sql"

    "github.com/orololuwa/crispy-octo-guacamole/models"
)

type UserRepo interface {
-   CreateAUser(user models.User) (int, error)
-   GetAUser(id int) (models.User, error)
-   GetAllUser() ([]models.User, error)
-   UpdateAUsersName(id int, firstName, lastName string)(error)
-   DeleteUserByID(id int) error
+   CreateAUser(ctx context.Context, tx *sql.Tx, user models.User) (int, error)
+   GetAUser(ctx context.Context, tx *sql.Tx, id int) (models.User, error)
+   GetAllUser(ctx context.Context, tx *sql.Tx) ([]models.User, error)
+   UpdateAUsersName(ctx context.Context, tx *sql.Tx, id int, firstName, lastName string)(error)
+   DeleteUserByID(ctx context.Context, tx *sql.Tx, id int) error
}

type DBRepo interface {
    Transaction(ctx context.Context, operation func(context.Context, *sql.Tx) error) error 
}

Using the CreateAUser function to highlight the difference in the user.go file, we have;

-func (m *user) CreateAUser(user models.User) (int, error){
-   ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+func (m *user) CreateAUser(ctx context.Context, tx *sql.Tx, user models.User) (int, error){
+   ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    var newId int

    query := `
            INSERT into users 
                (first_name, last_name, email, password, created_at, updated_at)
            values 
                ($1, $2, $3, $4, $5, $6)
            returning id`

-   err := m.DB.QueryRowContext(ctx, query, 
+   var err error;
+   if tx != nil {
+       err = tx.QueryRowContext(ctx, query, 
+           user.FirstName, 
+           user.LastName, 
+           user.Email, 
+           user.Password,
+           time.Now(),
+           time.Now(),
+       ).Scan(&newId)
+   }else{
        err = m.DB.QueryRowContext(ctx, query, 
            user.FirstName, 
            user.LastName, 
            user.Email, 
            user.Password,
            time.Now(),
            time.Now(),
        ).Scan(&newId)
+   }

we now use the context obtained from the function variable and dependent on whether a transaction is passed, we use the tx variable to execute our queries. The full updated code for all the UserRepo functions:

package repository

import (
    "context"
    "database/sql"
    "time"

    "github.com/orololuwa/crispy-octo-guacamole/models"
)

type user struct {
    DB *sql.DB
}

func NewUserRepo(conn *sql.DB) UserRepo {
    return &user{
        DB: conn,
    }
}

func (m *user) CreateAUser(ctx context.Context, tx *sql.Tx, user models.User) (int, error){
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    var newId int

    query := `
            INSERT into users 
                (first_name, last_name, email, password, created_at, updated_at)
            values 
                ($1, $2, $3, $4, $5, $6)
            returning id`

    var err error;
    if tx != nil {
        err = tx.QueryRowContext(ctx, query, 
            user.FirstName, 
            user.LastName, 
            user.Email, 
            user.Password,
            time.Now(),
            time.Now(),
        ).Scan(&newId)
    }else{
        err = m.DB.QueryRowContext(ctx, query, 
            user.FirstName, 
            user.LastName, 
            user.Email, 
            user.Password,
            time.Now(),
            time.Now(),
        ).Scan(&newId)
    }

    if err != nil {
        return 0, err
    }

    return newId, nil
}

func (m *user) GetAUser(ctx context.Context, tx *sql.Tx, id int) (models.User, error){
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    var user models.User

    query := `
            SELECT (id, first_name, last_name, email, password, created_at, updated_at)
            from users
            WHERE
            id=$1
    `

    var err error
    if tx != nil {
        err = tx.QueryRowContext(ctx, query, id).Scan(
            &user.ID,
            &user.FirstName,
            &user.LastName,
            &user.Email,
            &user.Password,
            &user.CreatedAt,
            &user.UpdatedAt,
        )
    }else{
        err = m.DB.QueryRowContext(ctx, query, id).Scan(
            &user.ID,
            &user.FirstName,
            &user.LastName,
            &user.Email,
            &user.Password,
            &user.CreatedAt,
            &user.UpdatedAt,
        )
    }

    if err != nil {
        return user, err
    }

    return user, nil
}

func (m *user) GetAllUser(ctx context.Context, tx *sql.Tx) ([]models.User, error){
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    var users = make([]models.User, 0)

    query := `
        SELECT (id, first_name, last_name, email, password, created_at, updated_at)
        from users
    `

    var rows *sql.Rows
    var err error

    if tx != nil {
        rows, err = tx.QueryContext(ctx, query)
    }else{
        rows, err = m.DB.QueryContext(ctx, query)
    }
    if err != nil {
        return users, err
    }

    for rows.Next(){
        var user models.User
        err := rows.Scan(
            &user.ID,
            &user.FirstName,
            &user.LastName,
            &user.Email,
            &user.Password,
            &user.CreatedAt,
            &user.UpdatedAt,
        )
        if err != nil {
            return users, err
        }
        users = append(users, user)
    }

    if err = rows.Err(); err != nil {
        return users, err
    }

    return users, nil
}

func (m *user) UpdateAUsersName(ctx context.Context, tx *sql.Tx, id int, firstName, lastName string)(error){
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    query := `
        UPDATE 
            users set (first_name, last_name) = ($1, $2)
        WHERE
            id = $3
    `

    var err error
    if tx != nil{
        _, err = tx.ExecContext(ctx, query, firstName, lastName, id)
    }else{
        _, err = m.DB.ExecContext(ctx, query, firstName, lastName, id)
    }

    if err != nil{
        return  err
    }

    return nil
}

func (m *user) DeleteUserByID(ctx context.Context, tx *sql.Tx, id int) error {
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    query := "DELETE FROM users WHERE id = $1"

    var err error 

    if tx != nil {
        _, err = tx.ExecContext(ctx, query, id)
    }else{
        _, err = m.DB.ExecContext(ctx, query, id)
    }

    if err != nil {
        return err
    }

    return nil
}

Then in your handler, you can go ahead and call the transaction function as thus:

package main

import (
+   "context"
+   "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "net/http"

    "github.com/go-chi/chi/v5"
    "github.com/orololuwa/crispy-octo-guacamole/driver"
    "github.com/orololuwa/crispy-octo-guacamole/models"
    "github.com/orololuwa/crispy-octo-guacamole/repository"
)
const portNumber = ":8080"

func main(){
    db, route, err := run()
    if (err != nil){
        log.Fatal(err)
    }
    defer db.SQL.Close()

    fmt.Println(fmt.Sprintf("Staring application on port %s", portNumber))


    srv := &http.Server{
        Addr: portNumber,
        Handler: route,
    }

    err = srv.ListenAndServe()
    if err != nil {
        log.Fatal(err)
    }
}

func run()(*driver.DB, *chi.Mux, error){
    dbHost := "localhost"
    dbPort := "5432"
    dbName := "bookings"
    dbUser := "orololuwa"
    dbPassword := ""
    dbSSL := "disable"

    // Connecto to DB
    log.Println("Connecting to dabase")
    connectionString := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s sslmode=%s", dbHost, dbPort, dbName, dbUser, dbPassword, dbSSL)

    db, err := driver.ConnectSQL(connectionString)
    if err != nil {
        log.Fatal("Cannot conect to database: Dying!", err)
    }
    log.Println("Connected to database")

    userRepo := repository.NewUserRepo(db.SQL)
    dbRepo := repository.NewDBRepo(db.SQL)
    router := chi.NewRouter()

    router.Post("/user", func(w http.ResponseWriter, r *http.Request) {
        type userBody struct {
            FirstName string `json:"firstName"`
            LastName string `json:"lastName"`
            Email string `json:"email"`
            Password string `json:"password"`
        }

        var body userBody

        err := json.NewDecoder(r.Body).Decode(&body)
        if err != nil {
            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        user := models.User{
            FirstName: body.FirstName,
            LastName: body.LastName,
            Email: body.Email,
            Password: body.Password,
        }

-       id, err := userRepo.CreateAUser(user)
+       ctx := context.Background()
+       var id int

+       err = dbRepo.Transaction(ctx, func(ctx context.Context, tx *sql.Tx) error {
+           id, err = userRepo.CreateAUser(ctx, tx, user)
+           if err != nil {
+               return err
+           }
+
+           userRepo.UpdateAUsersName(ctx, tx, id, body.FirstName, "test")
+           if err != nil {
+               return err
+           }
+
+           return nil
+       })
+       
        if err != nil {
            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        response := map[string]interface{}{"message": "user created successfully", "data": id}
        jsonResponse, err := json.Marshal(response)
        if err != nil {
            http.Error(w, "Failed to marshal response", http.StatusInternalServerError)
            return
        }
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        w.Write(jsonResponse)
    })

    return db, router, nil
}

The full code is available here on Github

What next?

You'd probably want to learn how to properly set up and test handlers. Stay tuned 🧏🏽

Accessing Child Element States and functions using forwardRef , useImperativeHandle and the useRef hook

Orololuwa — Fri, 19 Nov 2021 21:25:47 +0000

So I was working on a project and was trying to create a custom input component of type number and I did not want to do the whole state management and functions for incrementing and decrementing from the parent element, but instead inside the custom input element itself.

So I started thinking of ways to get the input value from the parent element, lo and behold I stumbled across forwardRef and useImperativeHandle and was able to solve my problem.

In this article I'm going to walk you through the steps of using these functions by building the custom input component;

First, we initialize a project using create-react-app using any of the three commands below.
npx create-react-app my-app, npm init react-app my-app, yarn create react-app

Secondly, we create a custom component CustomInput.js and start with forwardRef.

What the forwardRef basically does as the name implies is forward the ref attribute of the component so that whatever parent element that is using the component will have a direct access to the default properties of the component like name, value, type et cetera
All you have to do is wrap the component with forwardRef, expect a ref attribute along side your props in the component and pass the ref into the returned element.

CustomInput.js

import { forwardRef} from "react";

export const InputNumber = forwardRef((props, ref) => {

  return (
    <input type="number" ref={ref} />
  );
});

So now what if I want to access more than just the default properties of the component?
What if I want to access say for example the state in the component?

That's where the useImperativeHandle hook comes in

With the useImperativeHandle hook, you can pass a value or a state to the parent element. It takes in two values;

the ref
a callback function that returns an object with keys and their respective values of properties to be passed together with the ref.

CustomInput.js

import { useState, forwardRef, useImperativeHandle } from "react";
import "./style.css";

export const InputNumber = forwardRef((props, ref) => {
  const [state, setState] = useState(0);

  const increment = () => {
    setState((prev) => prev + 1);
  };

  const decrement = () => {
    setState((prev) => {
      if (prev === 0) {
        return prev;
      }
      return prev - 1;
    });
  };

  useImperativeHandle(ref, () => ({
    inputValue: state,
  }));

  return (
    <div className="input">
      <span className="input-left" onClick={decrement}>
        -
      </span>
      <span>{state}</span>
      <span className="input-right" onClick={increment}>
        +
      </span>
    </div>
  );
});

In the parent element, you can access the inputValue property by calling the useRef hook on the component.

App.js

import { useRef } from "react";
import "./App.css";
import { InputNumber } from "./InputNumber";

function App() {
  const inputRef = useRef();

  const addToCartHandler= () => {
    const noOfCartItems = inputRef.current.inputValue;
    alert("you have " + noOfCartItems + "item(s) in the cart");
  };

  return (
    <div className="App">
      <InputNumber ref={inputRef} />
      <button onClick={addToCartHandler}>Add to Cart</button>
    </div>
  );
}

export default App;

The css file for CustomeInput.js

CustomInputStyle.css

.input {
  background: #d36666;
  border-color: #d36666;
  position: relative;
  cursor: default;
  padding: 10px 30px;
  color: #fafafa;
  width: 50px;
  margin: 15px 0;
}

.input-left,
.input-right {
  position: absolute;
  top: 0;
  padding: 2.5px;
  cursor: pointer;
  height: 100%;
  display: inline-flex;
  align-items: center;
  justify-content: center;
}

.input-left {
  left: 5px;
}

.input-right {
  right: 2.5px;
}

DEV Community: Orololuwa

Setting up handlers with the Repository Pattern: A Test-driven approach in Go.

Introduction

Prerequisite

Setting up a DB repo for the database logic

Creating the handlers for the application logic

The main.go file.

Writing Tests

Conclusion

Setting up a Database Driver, Repository and Implementation of a transaction function for your Go App

Overview

Prerequisite

Getting Started

Part 2: Implementing a transaction function

What next?

Accessing Child Element States and functions using forwardRef , useImperativeHandle and the useRef hook

CustomInput.js

That's where the useImperativeHandle hook comes in

CustomInput.js

App.js

CustomInputStyle.css

The `main.go` file.