[**Wails**](https://wails.io/) is a framework that enables development of _desktop_ applications using the **Go** programming language. 

In this article, I will provide an in-depth look at the initial project structure when a new **Wails** application is created. By examining this structure, you will gain a better understanding of how Wails operates and what the development cycle entails.

# Installing Wails

Install Wails using `go install`.

```shell
$ go install github.com/wailsapp/wails/v2/cmd/wails@latest
```

## Initialize new project

Now that **wails** cli installed, create a new project using `wails init`.

```shell
$ wails init -t vanilla -n wails-hello-world
```

This will create a new folder `wails-hello-world` with the following  project strcuture.

```text
─── wails-hello-world/
    ├── build/
    ├── frontend/
    ├── .gitignore
    ├── app.go
    ├── go.mod
    ├── main.go
    ├── README.md
    └── wails.json
```

## Run the project

From withing the project folder, run `wails dev` and you should see the following application pop up.

![Go Init Wails Application](https://tdc-public.nyc3.digitaloceanspaces.com/photos/b2eda0f6-a564-4492-a731-02311c3f2277-go-init-wails-application.png)

# Overview of Wails Architecture

To fully grasp the inner workings of Wails, I strongly suggest reading the ["How does it work?"](https://wails.io/docs/howdoesitwork) section of the official Wails documentation.

Wails is primarily composed of two parts: a **Go runtime** and a **Webkit engine** for displaying the frontend. Yes, the frontend of the application is written in JavaScript.

![Go Wails Architecture Diagram](https://tdc-public.nyc3.digitaloceanspaces.com/photos/42c29b50-f51f-4238-9963-a8e8c3333957-go-wails-architecture-diagram.png)

Wails generates **bindings** between Go and JavaScript, making it easy for you to invoke Go code from the JavaScript side.

[Here](https://wails.io/assets/images/architecture-23c8df42202276ecee3e5cb7a0c6c51a.webp) is a more detailed diagram at Wails's official website.

# Project Strcuture

Let's take a closer look at some of the files and directories within the project and gain an understanding of their purpose.

## main.go

```text
─── wails-hello-world/
    ├── build/
    ├── frontend/
    ├── .gitignore
    ├── app.go
    ├── go.mod
    ├── main.go 👈
    ├── README.md
    └── wails.json
```

This is the entrypoint of the application. `wails.Run` is the function to launch the application.

```go:main.go
package main

import (
	"embed"

	"github.com/wailsapp/wails/v2"
	"github.com/wailsapp/wails/v2/pkg/options"
	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
)

//go:embed all:frontend/dist
var assets embed.FS

func main() {
	// Create an instance of the app structure
	app := NewApp()

	// Create application with options
	err := wails.Run(&options.App{
		Title:  "wails-hello-world",
		Width:  1024,
		Height: 768,
		AssetServer: &assetserver.Options{
			Assets: assets,
		},
		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
		OnStartup:        app.startup,
		Bind: []interface{}{
			app,
		},
	})

	if err != nil {
		println("Error:", err.Error())
	}
}
```

### Frontend assets in Go binary

I want to draw attention to a specific line.

```go
//go:embed all:frontend/dist
var assets embed.FS
```

The above line loads the frontend files into the Go binary by utilizing file embedding. This forms the user interface for the application. Learn more about file embedding in Go [here](https://thedevelopercafe.com/articles/embed-file-in-a-go-binary-4bc79cfaa524).

### Go function bindings

Another code snippet that is worth taking a closer look at.

```go
err := wails.Run(&options.App{
	...
	Bind: []interface{}{
		app,
	},
})
```

This is how frontend bindings for the Go functions are generated. In this case, a function binding is generated for every public method on the `app` struct. You can add as many structs to `Bind` array as you want.

## app.go

```text
─── wails-hello-world/
    ├── build/
    ├── frontend/
    ├── .gitignore
    ├── app.go 👈
    ├── go.mod
    ├── main.go
    ├── README.md
    └── wails.json
```

There is nothing special about this file, it contains a sample application struct that has one function (`Greet`) that is accessible from the frontend (as discussed in the previous section on function bindings).

```go:app.go
package main

import (
	"context"
	"fmt"
)

type App struct {
	ctx context.Context
}

func NewApp() *App {
	return &App{}
}

func (a *App) startup(ctx context.Context) {
	a.ctx = ctx
}

func (a *App) Greet(name string) string {
	return fmt.Sprintf("Hello %s, It's show time!", name)
}
```

## frontend folder

```text
─── wails-hello-world/
    ├── build/
    ├── frontend/ 👈
    ├── .gitignore
    ├── app.go
    ├── go.mod
    ├── main.go
    ├── README.md
    └── wails.json
```

Now we come to the `frontend` folder. In Wails, the UI is built using standard **HTML**, **CSS**, and **JavaScript**. This choice of technology can be seen as either positive or negative, depending on one's personal opinion. Personally, I would have preferred a solution built entirely in Go.

When creating a new Wails application, you can choose from a list of frontend templates such as **React**, **Typescript**, and **Vue**. For instance, to initialize a React template, run the following command.

```bash
wails init -n myproject -t react
```

Visit **Create a Project** section [here](https://wails.io/docs/gettingstarted/firstproject/) on Wails website to see all the available templates.

In this article, we initialized the project with Vanilla JavaScript.

Below is the content of the frontend folder. If you have any prior experience in frontend development, most of these should look familiar to you.

```text
.
└── frontend/
    ├── dist
    ├── node_modules
    ├── src/
    │   ├── assets/
    │   │   ├── fonts
    │   │   └── images
    │   ├── app.css
    │   ├── main.js
    │   └── style.css
    ├── wailsjs/
    │   ├── go
    │   └── runtime
    ├── index.html
    ├── package-lock.json
    └── package.json
```

### index.html

Pretty standard html, css and javascript code.

```html:frontend/index.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8"/>
    <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
    <title>wails-hello-world</title>
</head>
<body>
<div id="app"></div>
<script src="./src/main.js" type="module"></script>
</body>
</html>
```

```js:frontend/src/main.js
import "./style.css";
import "./app.css";

import logo from "./assets/images/logo-universal.png";
import { Greet } from "../wailsjs/go/main/App";

document.querySelector("#app").innerHTML = `
    <img id="logo" class="logo">
      <div class="result" id="result">Please enter your name below 👇</div>
      <div class="input-box" id="input">
        <input class="input" id="name" type="text" autocomplete="off" />
        <button class="btn" onclick="greet()">Greet</button>
      </div>
    </div>
`;
document.getElementById("logo").src = logo;

let nameElement = document.getElementById("name");
nameElement.focus();
let resultElement = document.getElementById("result");

// Setup the greet function
window.greet = function () {
  // Get name
  let name = nameElement.value;

  // Check if the input is empty
  if (name === "") return;

  // Call App.Greet(name)
  try {
    Greet(name)
      .then((result) => {
        // Update result with data back from App.Greet()
        resultElement.innerText = result;
      })
      .catch((err) => {
        console.error(err);
      });
  } catch (err) {
    console.error(err);
  }
};
```

### wails folder

```text
.
└── frontend/
    ├── dist
    ├── node_modules
    ├── src/
    │   ├── assets/
    │   │   ├── fonts
    │   │   └── images
    │   ├── app.css
    │   ├── main.js
    │   └── style.css
    ├── wailsjs/ 👈
    │   ├── go
    │   └── runtime
    ├── index.html
    ├── package-lock.json
    └── package.json
```

An important thing to note is the `frontend/wailsjs` folder. This is the folder that contains the Go-Javascript generated bindings and some runtime functionality.

The `frontend/wailsjs/go/main/App.js` files contains the functions that are generated from the `Bindings` section in the [Go code](#go-function-bindings).

```js:frontend/wailsjs/go/main/App.js
// @ts-check
// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
// This file is automatically generated. DO NOT EDIT

export function Greet(arg1) {
  return window['go']['main']['App']['Greet'](arg1);
}
```

The `frontend/wailsjs/runtime/runtime.js` file holds the Wails runtime functionality, including logging and window management. You can examine it in more detail by visiting [this link](https://github.com/gurleensethi/wails-hello-world/blob/main/frontend/wailsjs/runtime/runtime.js).

# Ending

These are the primary files that you will interact with when developing desktop applications using Wails. I hope this information was helpful and you learned something new.

Wails is a framework that enables development of desktop applications using the Go programming language. In this article, I will provide an in-depth look at

Introduction to Wails - Desktop Apps in Go - Project Structure

# What is slog?

[slog](https://pkg.go.dev/golang.org/x/exp/slog) is an experimental logging package from the Go team that provides the functionality of structured logging.

**Note: At the time for writing this article, the package is still being developed separately from the Go core.**

This article gives you an overview of logging functionality in this package.

# Installation

Create a new go project or use an existing and install `slog`.

```bash
go get golang.org/x/exp/slog
```

# Using the logger

Import and start using the logger right away.

```go:main.go
package main

import (
	"golang.org/x/exp/slog"
)

func main() {
	slog.Info("Go is best language!")
}
```

Output:

```bash
$ go run main.go
2022/12/15 01:31:23 INFO Go is best language!
```

By default the output includes time, log level and message.

The following log leves are available.

```
Debug
Info
Warn
Error
```

# Structured logging

`slog` is a structured logger that supports logging in two formats: **text** and **json**.

Let's take a look at text logger.

## Text Handler

You start off by creating a text handler and a new logger.

```go:main.go
package main

import (
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	textHandler := slog.NewTextHandler(os.Stdout)
	logger := slog.New(textHandler)

	logger.Info("Go is the best language!")
}
```

Output:

```bash
$ go run main.go
time=2022-12-15T01:41:25.277-05:00 level=INFO msg="Go is the best language!"
```

Pay close attention, you will see the output is formatted as **key=value** pairs. This is also commonly referred to as [logfmt](https://brandur.org/logfmt) format.

Many modern systems can process logs in **logfmt** format. For example, [DataDog](https://docs.datadoghq.com/logs/log_configuration/parsing/?tab=matchers), [Splunk](https://dev.splunk.com/enterprise/docs/developapps/addsupport/logging/loggingbestpractices/), [Grafana Loki](https://grafana.com/docs/loki/latest/clients/promtail/stages/logfmt/). Logfmt is human readable and fairly easy to parse.

## JSON Handler

You can also output the logs in JSON format, all you have to do is switch out the handler.

```go:main.go
package main

import (
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	jsonHandler := slog.NewJSONHandler(os.Stdout)  // 👈
	logger := slog.New(jsonHandler)

	logger.Info("Go is the best language!")
}
```

Output:

```bash
$ go run main.go
{"time":"2022-12-17T18:05:48.479126-05:00","level":"INFO","msg":"Go is the best language!"}
```

Each log is logged as a json object with properties inside of it.

# Attributes

**slog** being a structured logger, provides the ability to specify attributes.

```go:main.go
package main

import (
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	textHandler := slog.NewTextHandler(os.Stdout)
	logger := slog.New(textHandler)

	logger.Info("Usage Statistics", slog.Int("current-memory", 50))
}
```

Output:

```bash
$ go run main.go
time=2022-12-17T18:28:38.246-05:00 level=INFO msg="Usage Statistics" current-memory=50
```

In the above example, an integer attributes has been added using `slog.Int`. 

Various types of attributes are available:

```
String
Int64
Int
Uint64
Float64
Bool
Time
Duration
```

You can add as many attributes as required.

```go:main.go
package main

import (
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	textHandler := slog.NewTextHandler(os.Stdout)
	logger := slog.New(textHandler)

	logger.Info("Usage Statistics",
		slog.Int("current-memory", 50),
		slog.Int("min-memory", 20),
		slog.Int("max-memory", 80),
		slog.Int("cpu", 10),
		slog.String("app-version", "v0.0.1-beta"),
	)
}
```

Output:

```bash
$ go run main.go
time=2022-12-17T18:34:12.781-05:00 level=INFO msg="Usage Statistics" current-memory=50 min-memory=20 max-memory=80 cpu=10 app-version=v0.0.1-beta
```

## Grouping Attributes

You can group attributes under a single key. For example, all the memory attributes can be grouped under the `memory` key.

```go:main.go
package main

import (
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	textHandler := slog.NewTextHandler(os.Stdout)
	logger := slog.New(textHandler)

	logger.Info("Usage Statistics",
		slog.Group("memory",
			slog.Int("current", 50),
			slog.Int("min", 20),
			slog.Int("max", 80)),
		slog.Int("cpu", 10),
		slog.String("app-version", "v0.0.1-beta"),
	)
}
```

Output:

```bash
$ go run main.go
time=2022-12-17T18:36:46.660-05:00 level=INFO msg="Usage Statistics" memory.current=50 memory.min=20 memory.max=80 cpu=10 app-version=v0.0.1-beta
```

Using a `JsonHandler` the output in json would be as follow.

```bash
$ go run main.go | jq
{
  "time": "2022-12-17T18:38:04.74786-05:00",
  "level": "INFO",
  "msg": "Usage Statistics",
  "memory": {
    "current": 50,
    "min": 20,
    "max": 80
  },
  "cpu": 10,
  "app-version": "v0.0.1-beta"
}
```

## Common Attributes

Let's say you want to have an attribute that should be included in all the logs being generated, examples of such an attribute would include **name of the service**, **application version**. 

You can attach attributes to the handler that will be included in each log statement.

```go:main.go
package main

import (
	"context"
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	textHandler := slog.NewTextHandler(os.Stdout).
		WithAttrs([]slog.Attr{slog.String("app-version", "v0.0.1-beta")}) // 👈 add attributes to all logs
	logger := slog.New(textHandler)

	logger.Info("Generating statistics")
	logger.Info("Usage Statistics",
		slog.Group("memory",
			slog.Int("current", 50),
			slog.Int("min", 20),
			slog.Int("max", 80)),
		slog.Int("cpu", 10),
	)
}
```

Output:

```bash
$ go run main.go
time=2022-12-17T20:21:27.664-05:00 level=INFO msg="Generating statistics" app-version=v0.0.1-beta
time=2022-12-17T20:21:27.664-05:00 level=INFO msg="Usage Statistics" app-version=v0.0.1-beta memory.current=50 memory.min=20 memory.max=80 cpu=10
```

You can see the `app-version`  attribute being included in both the logs. Attributes specified using [`WithAttrs`](https://pkg.go.dev/golang.org/x/exp/slog#JSONHandler.WithAttrs) function on the handler will be included in all the logs.

# Passing logger in context

You would ideally want to create a single logger with certain configurations, attributes and use it throughout the application.

**slog** has inbuilt functions that let you pass around the logger inside a `context`.

```go:main.go
package main

import (
	"context"
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	textHandler := slog.NewTextHandler(os.Stdout).
		WithAttrs([]slog.Attr{slog.String("app-version", "v0.0.1-beta")})
	logger := slog.New(textHandler)

	ctx := slog.NewContext(context.Background(), logger) // 👈 context containing logger
	sendUsageStatus(ctx)
}

func sendUsageStatus(ctx context.Context) {
	logger := slog.FromContext(ctx) // 👈 grab logger from context

	logger.Info("Generating statistics")

	logger.Info("Usage Statistics",
		slog.Group("memory",
			slog.Int("current", 50),
			slog.Int("min", 20),
			slog.Int("max", 80)),
		slog.Int("cpu", 10),
	)
}
```

Output:

```bash
$ go run main.go
time=2022-12-17T20:27:58.797-05:00 level=INFO msg="Generating statistics" app-version=v0.0.1-beta
time=2022-12-17T20:27:58.797-05:00 level=INFO msg="Usage Statistics" app-version=v0.0.1-beta memory.current=50 memory.min=20 memory.max=80 cpu=10
```

[`NewContext`](https://pkg.go.dev/golang.org/x/exp/slog#NewContext) creates a new context containing the logger.

[`FromContext`](https://pkg.go.dev/golang.org/x/exp/slog#FromContext) grabs the logger from a context. In case the context doesn't contain a logger, it returns the [default logger](https://pkg.go.dev/golang.org/x/exp/slog#Default).

# Log Level Logging

If you are using the default logger, it doesn't log debug logs because the default log level is `Info`.

You can create a new logger with the default log level set to `Debug` to show debug logs.

```go:main.go
package main

import (
	"os"

	"golang.org/x/exp/slog"
)

func main() {
	opts := slog.HandlerOptions{
		Level: slog.LevelDebug,
	}

	textHandler := opts.NewTextHandler(os.Stdout)
	logger := slog.New(textHandler)

	logger.Debug("Debug")
	logger.Info("Info")
	logger.Warn("Warn")
}
```

Output:

```bash
$ go run main.go
time=2022-12-17T23:28:29.130-05:00 level=DEBUG msg=Debug
time=2022-12-17T23:28:29.130-05:00 level=INFO msg=Info
time=2022-12-17T23:28:29.130-05:00 level=WARN msg=Warn
```

---

It is amazing to see these types of packages that could potentially make there way to golang core, makes the language so much more powerful and appealing. 

Thank you for reading the article, if you liked it please consider joining our email newsletter.

slog is a logging package from the Go team that provides the functionality of structured logging.

Logging in Go with slog

# HTTP Post request

Make an HTTP Post request with a json request body.

```go:main.go
package main

import (
	"bytes"
	"encoding/json"
	"io"
	"log"
	"net/http"
	"net/url"
)

const BASE_URL = "jsonplaceholder.typicode.com"

type PostBody struct {
	Title string `json:"title"`
}

func main() {
	// Prepare URL
	postURL := url.URL{
		Host:   BASE_URL,
		Path:   "/todos",
		Scheme: "https",
	}

	// Prepare request body
	body := PostBody{
		Title: "Hello World",
	}

	bodyBytes, err := json.Marshal(&body)
	if err != nil {
		log.Fatal(err)
	}

	reader := bytes.NewReader(bodyBytes)

	// Make HTTP POST request
	resp, err := http.Post(postURL.String(), "application/json", reader)
	if err != nil {
		log.Fatal(err)
	}

	// Close response body
	defer func() {
		err := resp.Body.Close()
		if err != nil {
			log.Fatal(err)
		}
	}()

	// Read response body
	responseBody, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	if resp.StatusCode >= 400 && resp.StatusCode <= 500 {
		log.Println("Error response. Status Code: ", resp.StatusCode)
	}

	log.Println("Response:", string(responseBody))
}
```

## Custom HTTP Client

The above uses the deafult http client 👉 `http.Post`. `http.Post` calls the `http.DefaultClient`, here is the behind the scenes code.

```go
func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
	return DefaultClient.Post(url, contentType, body)
}
```

You can create custom http client 👉 `httpClient := http.Client{}`.

```go
// Make HTTP POST request
httpClient := http.Client{}

resp, err := httpClient.Post(postURL.String(), "application/json", reader)
if err != nil {
	log.Fatal(err)
}
```

## Using http.Do

Here is another way to make the request using the `Do` function.

```go
request, err := http.NewRequest(http.MethodPost, postURL.String(), reader)
if err != nil {
	log.Fatal(err)
}

request.Header.Set("Content-Type", "application/json")

httpClient := &http.Client{}

resp, err := httpClient.Do(request)
if err != nil {
	log.Fatal(err)
}
```

# Reusable function

As you can notice making a post request can be verbose, it involves a bunch of projects. What I do in some of my projects is create a reusable function to do some of the repeated stuff.

It would look something like this,

```go
func JSONPost(url url.URL, body any) (string, error) {
	bodyBytes, err := json.Marshal(&body)
	if err != nil {
		return "", nil
	}

	reader := bytes.NewReader(bodyBytes)

	// Make HTTP POST request
	request, err := http.NewRequest(http.MethodPost, url.String(), reader)
	if err != nil {
		return "", nil
	}

	request.Header.Set("Content-Type", "application/json")

	httpClient := &http.Client{}

	resp, err := httpClient.Do(request)
	if err != nil {
		return "", nil
	}

	// Close response body
	defer func() {
		err := resp.Body.Close()
		if err != nil {
			log.Fatal(err)
		}
	}()

	// Read response body
	responseBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", nil
	}

	if resp.StatusCode >= 400 && resp.StatusCode <= 500 {
		return string(responseBody), errors.New("400/500 status code error")
	}

	return string(responseBody), nil
}
```

And then use it,

```go
func main() {
	// Prepare URL
	postURL := url.URL{
		Host:   BASE_URL,
		Path:   "/todos",
		Scheme: "https",
	}

	// Prepare request body
	body := PostBody{
		Title: "Hello World",
	}

	responseBody, err := JSONPost(postURL, &body)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("Response:", string(responseBody))
}
```

The signaure of reusable `JSONPost` can be changed according to need, for example I usually also parse the response body into a struct as well instead of returning a string response.

Make an HTTP Post request with a request body.

Make POST request in Go using net/http

# Getting Started

If you have been writing Go you probably have heard of the popular http router [chi](https://go-chi.io/#/). In this article you are going to learn how to print all the routes registered in a router, this is very helpful for debugging purposes.

If you want to learn about chi, please read [Restful routing with Chi](https://thedevelopercafe.com/articles/restful-routing-with-chi-in-go-d05a2f952b3d).

# Setting up a router

I assume you have a project with **chi** setup (if not please [install chi](https://go-chi.io/#/pages/getting_started)).

Let's assume an application that has a router with 3 routes registered.

```go:main.go
package main

import (
	"fmt"
	"github.com/go-chi/chi/v5"
	"net/http"
)

func main() {
	router := chi.NewRouter()

	router.Get("/articles", sayHello)
	router.Get("/articles/{articleID}", sayHello)

	router.With(func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			next.ServeHTTP(w, r)
		})
	}).Post("/articles", sayHello) // 👈 route with middleware
}

func sayHello(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello World"))
}
```

Look closely one of these routes (`POST` route) has a middleware setup as well. So now we want to print out **all** the routes and the **number** of middlewares setup on each routes.

# Print routes with chi.Walk

We want to print each route in the format: `[<method>]: '<route>' has <x> middlewares`.

Chi provides a built in function called [`chi.Walk`](https://github.com/go-chi/chi/blob/master/tree.go#L827-L863) that traverses the route tree and calls a calback function for each route.

It has a long function signature so scroll the code below to the right to see it all.

```go
chi.Walk(router, func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error {
	fmt.Printf("[%s]: '%s' has %d middlewares\n", method, route, len(middlewares))
	return nil
})
```

**chi** will call the passed function for each route and our `fmt` statement inside it will print the required information.

Putting it together the entire example looks like this.

```go:main.go
package main

import (
	"fmt"
	"github.com/go-chi/chi/v5"
	"net/http"
)

func main() {
	router := chi.NewRouter()

	router.Get("/articles", sayHello)
	router.Get("/articles/{articleID}", sayHello)

	router.With(func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			next.ServeHTTP(w, r)
		})
	}).Post("/articles", sayHello)

	// 👇 the walking function 🚶‍♂️
	chi.Walk(router, func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error {
		fmt.Printf("[%s]: '%s' has %d middlewares\n", method, route, len(middlewares))
		return nil
	})
}

func sayHello(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello World"))
}
```

And will print the following output.

```txt
[GET]: '/articles' has 0 middlewares
[POST]: '/articles' has 1 middlewares
[GET]: '/articles/{articleID}' has 0 middlewares
```

Thank you for reading this article 🙏🏻 hope it was helpful.

If you have been writing Go you probably have heard of the popular http router chi. In this article you are going to learn how to print all the routes...

Print all routes in Chi router

# Setting up Postgres locally

You can skip this if you already have [Postgres](https://www.postgresql.org/) running.

Starting Postgres using [Docker](https://docs.docker.com/).

```bash
docker run \
--rm --name postgres \
-e POSTGRES_USER=postgres \
-e POSTGRES_PASSWORD=postgres \
-e POSTGRES_DB=postgres \
-p 5432:5432 \
-d postgres:latest
```

# Install Postgres driver

You will be using the inbuilt [`sql`](https://pkg.go.dev/database/sql) library in Go to make queries, but you still need a **driver** for the database in use.

Install the popular [pq](https://github.com/lib/pq) Go postgres driver.

```bash
go get github.com/lib/pq
```

You  will not be using directly from this package directly, but the driver still needs to be loaded. 

Load it by importing the package.

```go:main.go
package main

import (
	_ "github.com/lib/pq"
)

func main() {
}
```

# Connecting to database

Now you will use the `sql` package in Go to connect the database.

```go:main.go
package main

import (
	"database/sql"

	_ "github.com/lib/pq"
)

func main() {
	connectionStr := "postgres://postgres:postgres@localhost:5432/postgres?sslmode=disable"

	conn, err := sql.Open("postgres", connectionStr)
	if err != nil {
		panic(err)
	}

	conn.Close()
}
```

`sql.Open` accepts a driver name and a connection string.

## Using DSN (Data Source Name)

Instead of a connection string you can also use a [DSN](https://en.wikipedia.org/wiki/Data_source_name).

```go:main.go
package main

import (
	"database/sql"

	_ "github.com/lib/pq"
)

func main() {
	connectionStr := "user=postgres password=postgres dbname=postgres port=5432 sslmode=disable"

	conn, err := sql.Open("postgres", connectionStr)
	if err != nil {
		panic(err)
	}

	conn.Close()
}
```

# Running Queries

Now you are all set, go ahead an start running some queries.

Here is a query that gets the postgres version.

```go:main.go
package main

import (
	"database/sql"
	"fmt"

	_ "github.com/lib/pq"
)

func main() {
	connectionStr := "user=postgres password=postgres dbname=postgres sslmode=disable"

	conn, err := sql.Open("postgres", connectionStr)
	if err != nil {
		panic(err)
	}

	rows, err := conn.Query("SELECT version();")
	if err != nil {
		panic(err)
	}

	for rows.Next() {
		var version string
		rows.Scan(&version)
		fmt.Println(version)
	}

	rows.Close()

	conn.Close()
}
```

Output:

```bash
PostgreSQL 15.1 (Debian 15.1-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
```


Learn how to connect to PostgreSQL database in Go and making queries.

Connect to Postgres in Go (Golang)

# Getting Started

**Twirp** is an RPC framework from Twitch which just like gRPC uses **Protobufs** and is much easier to use. In this article I am going to give you a taste of Twirp. You can find the complete code for this article in [this](https://github.com/gurleensethi/go-twirp-rpc-example) GitHub repository.

🙋‍♂️ This article presumes that you are familiar with [Protobufs](https://developers.google.com/protocol-buffers) and the concept of [RPC](https://en.wikipedia.org/wiki/Remote_procedure_call).

# Setup Project

Project creation and installation instructions for protoc tool and twirp/proto.

1. Create a new **Go** project.

```shell
$ mkdir go-twirp-rpc-example
$ cd go-twirp-rpc-example
$ go mod init github.com/gurleensethi/go-twirp-rpc-example
```

Create three folders `server`, `client` and `rpc` in the project so that the folder structure looks like this.

```text
go-twirp-rpc-example/
├─ client/
├─ server/
├─ rpc/
   ├─ notes/
```

2. Install the protoc and twirp-protoc generators (these are cli tools).

```shell
$ go install github.com/twitchtv/twirp/protoc-gen-twirp@latest
$ go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
```

3. Install protobuf and twirp modules in project.

```shell
$ go get github.com/twitchtv/twirp
$ go get google.golang.org/protobuf
```

# Writing Proto file

Since Twirp uses Protobufs to generate clients, we need to write a `.proto` file.

You will be building a simple note taking application that only has two features: 

**1. Get all notes.**
**2. Create a new note**.

Here is the proto definition model (store it in `rpc/notes/service.proto`).

```proto:rpc/notes/service.proto
syntax = "proto3";

package gotwirprpcexample.rpc.notes;
option go_package = "rpc/notes";

message Note {
    int32 id = 1;
    string text = 2;
    int64 created_at = 3;
}

message CreateNoteParams {
    string text = 1;
}

message GetAllNotesParams {
}

message GetAllNotesResult {
    repeated Note notes = 1;
}

service NotesService {    
    rpc CreateNote(CreateNoteParams) returns (Note);
    rpc GetAllNotes(GetAllNotesParams) returns (GetAllNotesResult);
}
```

If you don't understand the above code you need to learn about Protobufs [here](https://developers.google.com/protocol-buffers). In hindsight we have defined a Note type and defined two RPC calls `CreateNote` (to create a new note) `GetAllNotes` (to get all notes).

## Generating Go code

Now that proto file is in place, let's generate the go client using the `protoc` generator.

From the root of your project run the `protoc` command.

```shell
$ protoc --twirp_out=. --go_out=. rpc/notes/service.proto
```

This will generate two files `service.pb.go` and `service.twirp.go` in the `rpc/notes` directory. While not required, it is a good idea to go through the generated code to get a better understanding of what is generated.

# Writing Server Code

Server side of things involves implementing the two functions `CreateNote` and `GetAllNotes`. 

If you open the generated twirp code `rpc/notes/service.twirp.go`, you will find an interface `NotesService`, this is the interface that we will be implementing.

```go:rpc/notes/service.twirp.go
// ======================
// NotesService Interface
// ======================

type NotesService interface {
	CreateNote(context.Context, *CreateNoteParams) (*Note, error)

	GetAllNotes(context.Context, *GetAllNotesParams) (*GetAllNotesResult, error)
}
```

## Implementing functionality

1. Define a `notesService` type that holds a list of notes.

```go:server/main.go
package main

import (
	"github.com/gurleensethi/go-twirp-rpc-example/rpc/notes"
)

type notesService struct {
	Notes     []notes.Note
	CurrentId int32
}

func main() {
}
```

2. Implement the `CreateNote` function on `notesService`.

```go:server/main.go
package main

import (
	"context"
	"net/http"
	"time"

	"github.com/gurleensethi/go-twirp-rpc-example/rpc/notes"
	"github.com/twitchtv/twirp"
)

...

func (s *notesService) CreateNote(ctx context.Context, params *notes.CreateNoteParams) (*notes.Note, error) {
	if len(params.Text) < 4 {
		return nil, twirp.InvalidArgument.Error("Text should be min 4 characters.")
	}

	note := notes.Note{
		Id:        s.CurrentId,
		Text:      params.Text,
		CreatedAt: time.Now().UnixMilli(),
	}

	s.Notes = append(s.Notes, note)

	s.CurrentId++

	return &note, nil
}

...
```

Pretty straightforward stuff. One thing to notice is we are returning `twirp.InvalidArgument` in case the length of text is less than 4. Twirp errors let you easily communicate different states of errors to the client, if you return a regular error Twirp will wrap it in a `twirp.InternalError`. 

I encourage you to read the documentation on Twirp Errors [here](https://twitchtv.github.io/twirp/docs/errors.html).

3. Implement the `GetAllNotes` function on `notesService`.

```go:server/main.go
func (s *notesService) GetAllNotes(ctx context.Context, params *notes.GetAllNotesParams) (*notes.GetAllNotesResult, error) {
	allNotes := make([]*notes.Note, 0)

	for _, note := range s.Notes {
		n := note
		allNotes = append(allNotes, &n)
	}

	return &notes.GetAllNotesResult{
		Notes: allNotes,
	}, nil
}
```

## Serving over HTTP

Running a Twirp server is as easy as serving it using the deafult `net/http` package 😀.

```go:server/main.go
func main() {
	notesServer := notes.NewNotesServiceServer(&notesService{})
    
	mux := http.NewServeMux()
	mux.Handle(notesServer.PathPrefix(), notesServer)

	err := http.ListenAndServe(":8000", notesServer)
	if err != nil {
		panic(err)
	}
}
```

Run the server using `go run server/main.go`, its as easy as that. Glance at the complete server code [here](https://github.com/gurleensethi/go-twirp-rpc-example/blob/main/server/main.go).

# Writing Client Code

On the client side, let's create a new note and subsequently fetch all the notes.

1. Prepare the notes service client.

```go:client/main.go
package main

import (
	"net/http"

	"github.com/gurleensethi/go-twirp-rpc-example/rpc/notes"
)

func main() {
	client := notes.NewNotesServiceProtobufClient("http://localhost:8000", &http.Client{})
}
```

2. Call the `CreateNote` function.

```go:client/main.go
package main

import (
	"context"
	"log"
	"net/http"

	"github.com/gurleensethi/go-twirp-rpc-example/rpc/notes"
)

func main() {
	client := notes.NewNotesServiceProtobufClient("http://localhost:8000", &http.Client{})

	ctx := context.Background()

	_, err := client.CreateNote(ctx, &notes.CreateNoteParams{Text: "Hello World"})
	if err != nil {
		log.Fatal(err)
	}
}
```

3. List all the notes using `GetAllNotes`.

```go:client/main.go
func main() {
	client := notes.NewNotesServiceProtobufClient("http://localhost:8000", &http.Client{})

	ctx := context.Background()

	_, err := client.CreateNote(ctx, &notes.CreateNoteParams{Text: "Hello World"})
	if err != nil {
		log.Fatal(err)
	}

	allNotes, err := client.GetAllNotes(ctx, &notes.GetAllNotesParams{})
	if err != nil {
		log.Fatal(err)
	}

	for _, note := range allNotes.Notes {
		log.Println(note)
	}
}
```

# Call RPC via HTTP

A very lovely thing about Twirp is you can call the functions through simple HTTP calls. Everything underneath Twirp is a `POST` request.

**Request in Insomnia**

![Go Twirp POST HTTP](https://tdc-public.nyc3.digitaloceanspaces.com/photos/57d0532a-5dc8-4762-adcb-10be5ae1c8a5-go-twirp-post-http.png){.center .large}

**cURL Request**

```shell
❯ curl --request POST \
  --url http://localhost:8000/twirp/gotwirprpcexample.rpc.notes.NotesService/GetAllNotes \
  --header 'Content-Type: application/json' \
  --data '{}'

{"notes":[{"id":0,"text":"Hello World","created_at":"1668035588211"}]}
```

Read more about using cURL with Twirp [here](https://twitchtv.github.io/twirp/docs/curl.html).

# Ending

That was a quick introduction to Twirp, as next steps take a look at [Errors](https://twitchtv.github.io/twirp/docs/errors.html) and [HTTP Headers](https://twitchtv.github.io/twirp/docs/headers.html).


[Twip Documentation](https://twitchtv.github.io/twirp/docs/intro.html).

Twirp is an RPC framework from Twitch which just like gRPC uses Protobufs and is much simpler to use. In this article I am going to give you a taste of Twirp...

RPC in Go using Twitch's Twirp

# Goal of this article

The goal of this article is to teach you how to create cli applications using Go's [flag](https://pkg.go.dev/flag) package. In next article you will learn how to write the exact same application using a 3rd party cli package. The complete code for this article is available in [this](https://github.com/gurleensethi/go-cli-flag) GitHub repository.

# What are you building?

You are going to build a CLI uses the GitHub API to provide 2 commands, one for searching repos and other for searching users.

```bash
$ go run main.go -debug search-repos <name>
$ go run main.go -debug search-users -sort <sort_name> <name>
```

These commands will accept **flags** (`debug` and `sort` in above example) that are optional. So we can have multiple variations as follows.

```bash
$ go run main.go search-repos <name>
$ go run main.go -debug search-repos <name>
$ go run main.go -debug search-users -sort <sort_name> <name>
$ go run main.go search-users <name>
$ go run main.go -debug search-users <name>
```

# Project Setup

Create a new **go** project.

```bash
mkdir go-cli-flag
cd go-cli-flag
go mod init github.com/gurleensethi/go-cli-flag
```

Create a `main.go` file.

```go:main.go
package main

import "fmt"

func main() {
	fmt.Println("Hello World")
}
```

# Basic commands

Set up the program to accept 2 commands: `search-repos` and `search-users`.

The following program will print any command that you pass to the cli program. For example `go run main.go hello-world` will print `hello-world`.

```go:main.go
package main

import (
	"flag"
	"fmt"
	"os"
)

func main() {
	flag.Parse()

	if len(flag.Args()) < 1 {
		os.Exit(1)
	}

	command := flag.Args()[0]
    
    fmt.Println(command)
}
```

You are using `flag.Args()` here instead of `os.Args()` because later you will be adding a top level flag to the program.

Now allow only `search-repos` and `search-users` commands to be excuted and print a **help** message if command is invalid.

```go:main.go
package main

import (
	"flag"
	"fmt"
	"os"
)

var (
	usage = `Specify a command to execute:
  - search-repos: Search for github repos
  - search-users: Serach for users on github.`
)

func main() {
	flag.Parse()

	if len(flag.Args()) < 1 {
		fmt.Println(usage)
		os.Exit(1)
	}

	command := flag.Args()[0]

	err := executeCommand(command, flag.Args()[1:])
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func executeCommand(command string, args []string) error {
	switch command {
	case "search-repos":
		fmt.Println("search repos command")
		return nil
	case "search-users":
		fmt.Println("search users command")
		return nil
	default:
		return fmt.Errorf("invalid command: '%s'\n\n%s\n", command, usage)
	}
}
```

Now if you run with an invalid command such as `go run main.go hello-world`, you will get a help message:

```txt
❯ go run main.go hello-world
invalid command: 'hello-world'

Specify a command to execute:
  - search-repos: Search for github repos
  - search-users: Serach for users on github.

exit status 1
```

**Note:** From here on I will not be showing the complete code example as it will get too long to read so use your brain 🧠 while reading. I will focus only on parts we add or change. The complete code is available in [this](https://github.com/gurleensethi/go-cli-flag) GitHub repo.

# Debug logs under a flag

Add your first flag to the cli command, `debug`. This will be a top level flag and whenever passed will print out debug logs.

1. Declare the boolean flag.

```go:main.go
package main

import (
	"flag"
	"fmt"
	"os"
)

var (
	debug = flag.Bool("debug", false, "log out all the debug information") // 👈

	usage = `Specify a command to execute:
  - search-repos: Search for github repos
  - search-users: Serach for users on github.`
)

...
```

2. The call to `flag.Parse()` will parse this flag.

```go:main.go
...

func main() {
	flag.Parse() // 👈

	if len(flag.Args()) < 1 {
		fmt.Println(usage)
		os.Exit(1)
	}

	command := flag.Args()[0]

	err := executeCommand(command, flag.Args()[1:])
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

...
```

3. Add a function `printDebug` that prints out logs only when value of `debug` flag is true.

```go:main.go
...

var (
	debug = flag.Bool("debug", false, "log out all the debug information")
)

func main() {
	...
}

// 👇
func printDebug(msg string) {
	if *debug {
		fmt.Printf("[DEBUG]: %s\n", msg)
	}
}

...
```

4. Update `executeCommand` function, add a debug log printing the command.

```go:main.go
...

func executeCommand(command string, args []string) error {
	printDebug("Execute Command: " + command) // 👈

	switch command {
	case "search-repos":
		fmt.Println("search repos command")
		return nil
	case "search-users":
		fmt.Println("search users command")
		return nil
	default:
		return fmt.Errorf("invalid command: '%s'\n\n%s\n", command, usage)
	}
}

...
```

Run the program with the `debug` flag, for example `go run main.go -debug search-repos` will have the following output:

```txt
❯ go run main.go -debug search-repos
[DEBUG]: Execute Command: search-repos
search repos command
```

Go will try to parse anything that is a flag until it finds a non-flag input, once it does everything else will become part of the `Args`.

![Go Command Breakdown](https://tdc-public.nyc3.digitaloceanspaces.com/photos/9080bf1e-e223-4649-b473-a5492371a026-go-command-breakdown.png){.center .medium}

# Search repos command

Now you are going to implement the `search-repos` command that searches for repositories by name on github. We are focusing on the green box below (search term).

![Golang github search term repos](https://tdc-public.nyc3.digitaloceanspaces.com/photos/7c756fd9-c2c3-4447-b7f7-e7a66d8805c8-golang-github-search-term-repos.png){.center .large}

You can find the GitHub Repository Search api [here](https://docs.github.com/en/rest/search#search-repositories).

1. Let's write a function that given a search **term** searches the GitHub repositories. Brace yourself for a large (but simple) function 📄.

```go:main.go
...

func findRepos(term string) ([]string, error) {
	type repo struct {
		FullName string `json:"full_Name"`
	}

	type searchResult struct {
		Items []repo `json:"items"`
	}

	// Prepare github repository search url.
	req, err := http.NewRequest(http.MethodGet, "https://api.github.com/search/repositories", nil)
	if err != nil {
		printDebug(fmt.Sprintf("%v", err))
		return nil, errors.New("failed to connect to github")
	}

	query := req.URL.Query()
	query.Set("q", term)
	req.URL.RawQuery = query.Encode()

	// Make http request.
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		printDebug(fmt.Sprintf("%v", err))
		return nil, errors.New("failed to connect to github")
	}

	if res.StatusCode < 200 || res.StatusCode >= 300 {
		return nil, errors.New("failed to connect to github")
	}

	// Parse the json response.
	results := searchResult{}

	err = json.NewDecoder(res.Body).Decode(&results)
	if err != nil {
		printDebug(fmt.Sprintf("%v", err))
		return nil, errors.New("failed to connect to github")
	}

	// Extract out the repo names.
	repos := make([]string, 0)

	for _, r := range results.Items {
		repos = append(repos, r.FullName)
	}

	return repos, nil
}

...
```

`findRepos` will return either an error or the search results.

2. Write a function `executeSearchRepos` that parses the arguments and executes the above function.

```go:main.go
...

func executeCommand(command string, args []string) error {
	printDebug("Execute Command: " + command)

	switch command {
	case "search-repos":
		return executeSearchRepos(args) // 👈 call to function
	case "search-users":
		fmt.Println("search users command")
		return nil
	default:
		return fmt.Errorf("invalid command: '%s'\n\n%s\n", command, usage)
	}
}

// 👇 accepts the arguments and calls `findRepos`
func executeSearchRepos(args []string) error {
	if len(args) == 0 {
		return errors.New("provide a search term for searching repos: search-repos <search_term>")
	}

	searchTerm := args[0]

	printDebug(fmt.Sprintf("[search-repos] Search Term: %s", searchTerm))

	repos, err := findRepos(searchTerm)
	if err != nil {
		return err
	}

	fmt.Println(strings.Join(repos, ", "))

	return nil
}

...
```

🎉 Awesome, your cli program is now ready to search github repositories.

```txt
❯ go run main.go search-repos golang

GoesToEleven/GolangTraining, docker-library/golang, aceld/golang, astaxie/build-web-application-with-golang, xiaobaiTech/golangFamily, golang101/golang101, Alikhll/golang-developer-roadmap, golangci/golangci-lint, cncamp/golang, hackstoic/golang-open-source-projects, geektutu/7days-golang, GoogleCloudPlatform/golang-samples, senghoo/golang-design-pattern, prometheus/client_golang, rubyhan1314/Golang-100-Days, yangwenmai/learning-golang, GoesToEleven/golang-web-dev, 0voice/Introduction-to-Golang, overnote/over-golang, a8m/golang-cheat-sheet, dariubs/GoBooks, cch123/golang-notes, hyper0x/Golang_Puzzlers, Leslie1sMe/golang, polaris1119/The-Golang-Standard-Library-by-Example, shirou/gopsutil, iswbm/GolangCodingTime, Quorafind/golang-developer-roadmap-cn, hashicorp/golang-lru, gizak/termui
```

Using the `-debug` flag.

```txt
❯ go run main.go -debug search-repos golang
[DEBUG]: Execute Command: search-repos
[DEBUG]: [search-repos] Search Term: golang

GoesToEleven/GolangTraining, docker-library/golang, aceld/golang, astaxie/build-web-application-with-golang, xiaobaiTech/golangFamily, golang101/golang101, Alikhll/golang-developer-roadmap, golangci/golangci-lint, cncamp/golang, hackstoic/golang-open-source-projects, geektutu/7days-golang, GoogleCloudPlatform/golang-samples, senghoo/golang-design-pattern, prometheus/client_golang, rubyhan1314/Golang-100-Days, yangwenmai/learning-golang, GoesToEleven/golang-web-dev, 0voice/Introduction-to-Golang, overnote/over-golang, a8m/golang-cheat-sheet, dariubs/GoBooks, cch123/golang-notes, hyper0x/Golang_Puzzlers, Leslie1sMe/golang, polaris1119/The-Golang-Standard-Library-by-Example, shirou/gopsutil, iswbm/GolangCodingTime, Quorafind/golang-developer-roadmap-cn, hashicorp/golang-lru, gizak/termui
```

# Search users command

Now we are going to develop a command to **search github users** based on a search term. This one will be a bit more involved than than preivous one.

Here is the breakdown of the command.

![Golang search users breakdown](https://tdc-public.nyc3.digitaloceanspaces.com/photos/4989eb30-12b8-4115-81a0-eb0c394211f7-golang-search-users-breakdown.png)

We are going to use GitHub User Search api, you can find the documentation [here](https://docs.github.com/en/rest/search#search-users).

1. Write a function `findUsers` that makes the http call to the user search api.

Again, brace yourself for a large (but easy to understand) functon.

```go:main.go
...

func findUsers(term, sort string) ([]string, error) {
	type user struct {
		Login string `json:"login"`
	}

	type searchResult struct {
		Items []user `json:"items"`
	}

	// Prepare github repository search url.
	req, err := http.NewRequest(http.MethodGet, "https://api.github.com/search/users", nil)
	if err != nil {
		printDebug(fmt.Sprintf("%v", err))
		return nil, errors.New("failed to connect to github")
	}

	query := req.URL.Query()
	query.Set("q", term)
	query.Set("sort", sort)
	req.URL.RawQuery = query.Encode()

	// Make http request.
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		printDebug(fmt.Sprintf("%v", err))
		return nil, errors.New("failed to connect to github")
	}

	if res.StatusCode < 200 || res.StatusCode >= 300 {
		return nil, errors.New("failed to connect to github")
	}

	// Parse the json response.
	results := searchResult{}

	err = json.NewDecoder(res.Body).Decode(&results)
	if err != nil {
		printDebug(fmt.Sprintf("%v", err))
		return nil, errors.New("failed to connect to github")
	}

	// Extract out the repo names.
	repos := make([]string, 0)

	for _, r := range results.Items {
		repos = append(repos, r.Login)
	}

	return repos, nil
}

...
```

2. Write a function `executeSearchUsers` that parses the arguments (the ones in purpse and blue) and calls the `findUsers` method.

The important thing to notice here is the use of `flag.FlagSet`, you can use `flag.FlatSet` to manually parse flags from a stirng (args in our case). By default `flag.Parse()` parses flags from `os.Args()`, but you can create a new `flag.FlagSet` using `flag.NewFlagSet()` to parse them from custom slice of strings.

```go:main.go
...


func executeCommand(command string, args []string) error {
	printDebug(fmt.Sprintf("Command: %s", command))
	printDebug(fmt.Sprintf("Args: %v", args))

	switch command {
	case "search-repos":
		return executeSearchRepos(args)
	case "search-users":
		return executeSearchUsers(args) // 👈
	default:
		return fmt.Errorf("invalid command: '%s'", command)
	}
}

func executeSearchUsers(args []string) error {
	flagSet := flag.NewFlagSet("search-repos", flag.ExitOnError)

	sort := flagSet.String("sort", "", "sort results by")

	flagSet.Parse(args)

	printDebug(fmt.Sprintf("[search-repos] Args: %s", flagSet.Args()))

	if len(flagSet.Args()) == 0 {
		return errors.New("provide a search term for searching repos: search-repos <search_term>")
	}

	searchTerm := flagSet.Args()[0]

	printDebug(fmt.Sprintf("[search-repos] Search Term: %s", searchTerm))

	users, err := findUsers(searchTerm, *sort)
	if err != nil {
		return err
	}

	fmt.Println(strings.Join(users, ", "))

	return nil
}

...
```

Use the `search-users` command to search for users.

```txt
❯ go run main.go search-users john
john, john-smilga, johnpapa, johngrib, JohnHammond, johndpope, JohnSundell, johnmyleswhite, johnlindquist, johno, JohnTitor, johnafish, johnlui, jmurowaniecki, fjh658, johnBuffer, johnno1962, johnkil, jdegoes, JohnCoene, jhnwr, jeresig, jhawthorn, Lin20, johndbritton, johnpolacek, johnoseni1, johnbillion, johnymontana, jwasham
```

You can also use the `-sort` flag to sort the result.

```txt
❯ go run main.go search-users -sort followers john
jwasham, jeresig, johnpapa, john-smilga, JohnHammond, springframeworkguru, JohnSundell, topjohnwu, jdalton, johnmyleswhite, johnafish, johnlui, jwiegley, jgm, jnunemaker, johnkil, johnlindquist, flatplanet, jdegoes, johnthebrit, joschu, johno, johnBuffer, johnno1962, johndbritton, joreilly, jaewonhimnae, johnleider, john-preston, JohnTitor
```

Additionally you can also add the `-debug` flag.

```
❯ go run main.go -debug search-users -sort followers john
[DEBUG]: Command: search-users
[DEBUG]: Args: [-sort followers john]
[DEBUG]: [search-repos] Args: [john]
[DEBUG]: [search-repos] Search Term: john
jwasham, jeresig, johnpapa, john-smilga, JohnHammond, springframeworkguru, JohnSundell, topjohnwu, jdalton, johnmyleswhite, johnafish, johnlui, jwiegley, jgm, jnunemaker, johnkil, johnlindquist, flatplanet, jdegoes, johnthebrit, joschu, johno, johnBuffer, johnno1962, johndbritton, joreilly, jaewonhimnae, johnleider, john-preston, JohnTitor
```

The complete code is available in [this](https://github.com/gurleensethi/go-cli-flag) GitHub repository.

Amazing! You did it, if you made it to the end of the article you are part of the small group of people who know how to read properly.

The goal of this article is to show you how to create cli applications using Go's flag package.

Develop command line applications in Go with flag package

# Purpose of this article

In this article I want to give you a taste of what building Go web applications with [Echo](https://echo.labstack.com/) framework looks like. It is **hard and time** consuming to go through the entire documentation of a framework to just get the feel of what it is like and if the framework is for you. 

We will use the example of a Todo app for demonstration covering topics like **routing**, **middleware**, **authentication**, **path/query parameters**, **request body** and more. The complete example application can be found in [this](https://github.com/gurleensethi/echo-todo) github repository.

## Why a todo app?

I have seen a lot of hate 😠 towards todo apps being used as an example in tutorials and courses. Todo apps are a great way to showcase the technology/framework to the reader **without requiring the reader to gain additional context of the project**. When you read "todo app" you already know the what the requirements are. Additionaly todo apps cover the most common operations of framework/libraries which is **CRUD** (create, read, update, delete) data.

# Project Setup

Create a new project using `go mod init <your_module_name>` and install the echo framework.

```shell
go get github.com/labstack/echo/v4
go get github.com/labstack/echo/v4/middleware
```

# Setting up a Data Store

You need a way to store/manage the todos, you will not be using a database as that is not the focus of this article, you will be storing the data **in-memory**.

Create file in the **main** package itself called `todomanager.go` and paste the following code in it. We have something called a `TodoManager`, we will be adding all the CRUD operations as functions on this `TodoManager` so give this code a good read.

```go:todomanager.go
package main

import (
	"sync"
)

// Todo represents our todo
type Todo struct {
	ID         string `json:"id"`
	Title      string `json:"title"`
	IsComplete bool   `json:"isDone"`
}

type TodoManager struct {
	todos []Todo
	m     sync.Mutex // we want all our operations to be atomic
}

func NewTodoManager() TodoManager {
	return TodoManager{
		todos: make([]Todo, 0),
		m:     sync.Mutex{},
	}
}
```

# Setting up Echo

Now you are going to set up a simple http server using `echo`.

```go:main.go
package main

import (
	"github.com/labstack/echo/v4"
)

func main() {
	e := echo.New()

	e.Start(":8888")
}
```

Run the code using `go run main.go`. This will start an http server on port `8888` and you should see the following output in your terminal.

```shell
   ____    __
  / __/___/ /  ___
 / _// __/ _ \/ _ \
/___/\__/_//_/\___/ v4.9.0
High performance, minimalist Go web framework
https://echo.labstack.com
____________________________________O/_______
                                    O\
⇨ http server started on [::]:8888
```

# Building the app

Let's start adding functionality to the app. The steps will be quite similar for all of the operations: **1.** Add a function in `TodoManager`, **2.** Add an api endpoint in echo.

The code snippets below will only showcase new additions and leave out the already written code, if you feel lost or want to see the enitre working thing head over to the [this](https://github.com/gurleensethi/echo-todo) GitHub repo that contains the complete working example.

## Get all the todos

Inside `TodoManager` add a function to return all todos.

```go:todomanager.go
...

func (tm *TodoManager) GetAll() []Todo {
	return tm.todos
}
```

Add a `GET` route on echo.

```go:main.go
package main

import (
	"net/http"

	"github.com/labstack/echo/v4"
)

func main() {
	tm := NewTodoManager() // 👈 instance of todo manager

	e := echo.New()

	// 👇 new GET route
	e.GET("/", func(c echo.Context) error {
		todos := tm.GetAll()

		return c.JSON(http.StatusOK, todos) // 👈 sending json data back
	})
    
	e.Start(":8888")
}
```

It is as simple as using the `GET` function on **echo** and providing it with a **route path** and a **function**. 

**Note:** The function signature has a single parameter of type `echo.Context`, it is not your standard `func(http.ResponseWriter, *http.Request)` signature.

Let's send a curl request and see the output.

```bash
❯ curl -s localhost:8888/ | jq

[]
```

As expected you will see an empty array because there is no todo yet 🤷‍♂️.

## Middleware to log all requests

**Echo** has the concept of middlewares which are functions that run before the actual request function.

Let's set up a middleware to **log all the requests** to terminal.

You will be using an inbuilt middleware provided by **echo** (you will see an example of a custom middleware later) from its `github.com/labstack/echo/v4/middleware` package.

```go:main.go
package main

import (
	"net/http"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

func main() {
	tm := NewTodoManager()

	e := echo.New()

	e.Use(middleware.Logger()) // 👈 log all requests

	e.GET("/", func(c echo.Context) error {
		todos := tm.GetAll()

		return c.JSON(http.StatusOK, todos)
	})

	e.Start(":8888")
}
```

If you send a request again you should see a json object being printed in the standard output.

```shell
{"time":"2022-09-08T04:07:37.20349-04:00","id":"","remote_ip":"127.0.0.1","host":"localhost:8888","method":"GET","uri":"/","user_agent":"curl/7.79.1","status":200,"error":"","latency":72063,"latency_human":"72.063µs","bytes_in":0,"bytes_out":3}
```

Echo has a number of built in middlewares, check out the documentation on middleware [here](https://echo.labstack.com/middleware/).

## Authenticated routes

Before we proceed adding additional routes in our application, let's talk about authentication. I am not going to discuss how to do authentication (not the focus of this article). I am going to show you how to make **routes accessible only by logged in user**.

⭐️ A common pattern in backend applications is to pass an **auth token** as a header in every request, `Authorization: <auth_token>`.

You will use [Echo Groups](https://echo.labstack.com/guide/routing/#group) to group together routes that require authentication and add a custom middleware that will check for the presence of an auth token, for simplicity it will be a simple string equality check.

```go:main.go
func main() {
	...
    
	authenticatedGroup := e.Group("/todos", func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
        	// 👇 check for auth token
			authorization := c.Request().Header.Get("authorization")
			if authorization != "auth-token" {
				c.Error(echo.ErrUnauthorized)
				return nil
			}
            
            // 👇 token exists, keep moving forward
			next(c)
			return nil
		}
	})

	...
}
```

Any routes added onto `authenticatedGroup` will have the **middleware executed before the actual route** is executed.

In this middleware, there is a check for `authentication` header, if the header is empty or not valid an error is returned using echo's `c.Error`.

Sending a request without a header will give you back this response.

```bash
❯ curl -s localhost:8888/todos/ | jq

{
  "message": "Unauthorized"
}
```

## Create new todo

Using the previous **authenticated group** add a route to create a new todo.

Let's take care of the `TodoManager` part by adding a `Create` function.

```go:todomanager.go
// 👇 required data to create new todo
type CreateTodoRequest struct {
	Title string `json:"title"`
}

func (tm *TodoManager) Create(createTodoRequest CreateTodoRequest) Todo {
	tm.m.Lock()
	defer tm.m.Unlock()

	newTodo := Todo{
		ID:         strconv.FormatInt(time.Now().UnixMilli(), 10),
		Title:      createTodoRequest.Title,
		IsComplete: false,
	}

	tm.todos = append(tm.todos, newTodo)

	return newTodo
}
```

Now set up a `POST` route which will parse the request body and call the `TodoManager.Create` function.

```go:main.go
func main() {
	...

	authenticatedGroup.POST("/create", func(c echo.Context) error {
		requestBody := CreateTodoRequest{}

		// 👇 parses the body and "binds" it to the passed type
		err := c.Bind(&requestBody)
		if err != nil {
			return err
		}

		todo := tm.Create(requestBody)
        
		return c.JSON(http.StatusCreated, todo)
	})

    ...
}
```

Since this create route is on the **group** that requires **authentication** you need to pass the auth token. Making the request using `curl`, you get back a new todo.

```bash
❯ curl -s -X POST localhost:8888/todos/create \
  -H "Content-Type: application/json" \
  -H "Authorization: auth-token" \
  -d '{ "title": "Todo Title" }' \
  | jq

{
  "id": "1662719050096",
  "title": "Todo Title",
  "isDone": false
}
```

Fetch all the todos using the `GET /` endpoint.

```bash
❯ curl -s localhost:8888/ | jq

[
  {
    "id": "1662719050096",
    "title": "Todo Title",
    "isDone": false
  }
]
```

## Complete a todo

Now you will add a new `PATCH /todos/:id/complete` endpoint that marks a todo as complete. Here you will see how to parse **path parameters** in echo.

First add a new function `Complete(ID string)` in the `TodoManager`.

```go:todomanager.go
func (tm *TodoManager) Complete(ID string) error {
	tm.m.Lock()
	defer tm.m.Unlock()

	// Find the todo with id
	var todo *Todo
	var index int = -1

	for i, t := range tm.todos {
		if t.ID == ID {
			todo = &t
			index = i
		}
	}

	if todo == nil {
		return echo.ErrNotFound
	}

	// Check todo is not already completed
	if todo.IsComplete {
		err := echo.ErrBadRequest
		err.Message = "todo is already complete"
		return err
	}

	// Update todo
	tm.todos[index].IsComplete = true

	return nil
}
```

**Notice** that the errors being returned are from echo itself, `echo.ErrNotFound` and `echo.ErrBadRequest`. If these errors are passed to echo's `e.Error` function, echo will automatically set the appropriate **status code** and message in the response.

```go:main.go
func main() {
	...

	authenticatedGroup.PATCH("/:id/complete", func(c echo.Context) error {
		id := c.Param("id") // 👈 getting the path parameter

		err := tm.Complete(id)
		if err != nil {
			c.Error(err)
			return err
		}

		return nil
	})

	...
}
```

The value path parameter (`id`) is being grabbed by using `c.Param` function. There is a similar function in echo called **`c.QueryParam`** to get values of query parameters.

```bash
❯ curl -i -X PATCH localhost:8888/todos/1662757576599/complete \
-H "Content-Type: application/json" \
-H "Authorization: auth-token" 

HTTP/1.1 200 OK
Date: Fri, 09 Sep 2022 21:06:25 GMT
Content-Length: 0
```

## Deleting a todo

Add a function in `TodoManager` to remove a todo.

```go:todomanager.go
func (tm *TodoManager) Remove(ID string) error {
	tm.m.Lock()
	defer tm.m.Unlock()

	index := -1

	for i, t := range tm.todos {
		if t.ID == ID {
			index = i
			break
		}
	}

	if index == -1 {
		return echo.ErrNotFound
	}

	tm.todos = append(tm.todos[:index], tm.todos[index+1:]...)

	return nil
}
```

Add a route on authenticated group to delete a the todo.

```go:main.go
func main() {
	...
    
	authenticatedGroup.DELETE("/:id", func(c echo.Context) error {
		id := c.Param("id")

		err := tm.Remove(id)
		if err != nil {
			c.Error(err)
			return err
		}

		return nil
	})

	...
}
```

Just like the complete todo endpoint you are parsing the path parameter using `c.Param`.

```bash
❯ curl -i -X POST localhost:8888/todos/1662763466488 \
-H "Content-Type: application/json" \
-H "Authorization: auth-token"

HTTP/1.1 200 OK
Date: Fri, 09 Sep 2022 22:44:33 GMT
Content-Length: 0
```

---

I hope this article gave you a good overview of [echo](https://echo.labstack.com/) framework, there is so much more you can do with echo, if you are interested visit the echo's official page [here](https://echo.labstack.com/).

In this article I want to give you a taste of what building Go web applications with Echo framework looks like. Sometimes it quite tedious and time consuming

Echo - A Go web framework - Todo App

# Getting Started

In this article I am going to show you how to embed static files inside a Go binary. Embedding files can serve many purposes such as embedding a React app and serving it over http all inside a single Go binary.

# Embed a single file

We will start by embedding a single file and print it out to standard output.

Let's prepare a simple index.html static file.

```html:index.html
<html>
  <head>
      <title>Embedded File</title>
  </head>
  <body>
      <h1>Hello from Go!</h1>
  </body>
</html>
```

Write the Go code to embed the file.

```go:main.go
package main

import (
	_ "embed"
	"fmt"
)

//go:embed index.html
var staticFile string

func main() {
	fmt.Println(staticFile)
}
```

For embedding to work you need three things:

1. Import the `embed` package (`import _ "embed"`).
2. A variable to hold the data of embedded file (`var staticFile string`).
3. Using comment specify which file to import `//go:embed index.html`. The comment goes right above the variable.

**Note: Both `main.go` and `index.html` are in the same directory. Go will look for the file relative to the `main.go` file.**

Build the binary using `go build` and run it, the html file will be the output.

```txt
<head>
    <title>Embedded File</title>
</head>
<body>
    <h1>Hello from Go!</h1>
</body>
</html>
```

There are 3 valid types for the variable that holds embedded file: `string`, `[]byte` and `embed.FS`.

# Embed a directory

Instead of embedding a single file, we can embed an entire directory. 

Let's prepare a directory, create a new `static` folder and place the `index.html` file in it.

Create a new `page.html` file in the `static` folder.

```html:static/page.html
<html>
    <head>
        <title>Embedded File</title>
    </head>
    <body>
        <h1>Page</h1>
    </body>
</html>
```

So the folder structure looks like this.

```txt
static
  |- index.html
  |- page.html
main.go
```

Since we are embedding a directory we will use `embed.FS` type here.

```go:main.go
package main

import (
	"embed"
	"fmt"
)

//go:embed static
var fs embed.FS

func main() {
	files, _ := fs.ReadDir("static")

	for _, f := range files {
		fmt.Println(f.Name())
	}
}
```

`embed.FS` has a function called `ReadDir` that lists the content of a directory, in the above code example we list all the files inside the `static` folder.

The output will be:

```txt
index.html
page.html
```

**Reading one of the files from the directory**

```go:main.go
package main

import (
	"embed"
	"fmt"
)

//go:embed static
var fs embed.FS

func main() {
	file, _ := fs.ReadFile("static/index.html") // 👈
	fmt.Println(string(file))
}
```

# Embed multiple directories

You can go one step ahead and embed multiple folders. Let's create a new `static2` folder and paste the same `index.html` folder.

```go:main.go
package main

import (
	"embed"
	"fmt"
)

//go:embed static static2
var fs embed.FS

func main() {
	files, _ := fs.ReadDir(".")

	for _, f := range files {
		fmt.Println(f.Name())
	}
}
```

In the embedding comment, specify another folder separated with a space `//go:embed static static2`.

The output will be:

```txt
static
static2
```

# Serve embedded directory over http

We can take advantage of this embedding feature and serve our static files over http using.

```go:main.go
package main

import (
	"embed"
	"net/http"
)

//go:embed static
var fs embed.FS

func main() {
	http.Handle("/", http.FileServer(http.FS(fs)))
	http.ListenAndServe(":8080", nil)
}
```

Visit `http://localhost:8080/static/index.html` in your browser to see the file in action.

Read more about `embed` package and its functionality on the official docs [here](https://pkg.go.dev/embed).

Thank you for reading this article 🙏🏻 please consider joining the mailing list below.

In this article I am going to show you how to embed static files inside a Go binary. Embedding files can serve many purposes such as embedding a React app...

Embed file in a Go binary

# Getting Started

[SQLBoiler](https://github.com/volatiletech/sqlboiler) is a package that introspects your database schema and generates a static ORM client. In this article I am going to give you a taste of SQLBoiler, this is not an in-depth article on **SQLBoiler** (that will come later).

Below is what the workflow looks like with **SQLBoiler**.

![Go SQLBoiler workflow](https://tdc-public.nyc3.digitaloceanspaces.com/photos/a3513976-0029-4706-bdd8-37c88eaf6229-go-sqlboiler-workflow.png)

I highly recommend you to follow the article and replicate everything on your local machine. The code for this article is available in this [GitHub repository](https://github.com/gurleensethi/go-sql-boiler-example), please go ahead and clone it.

This is a fairly information packaged article 📦 so give some good amount of time to read it.

# Installing SQLBoiler CLI tool

To generate the static ORM client you need the SQLBoiler cli, install it using `go install`.

```bash
go install github.com/volatiletech/sqlboiler/v4@latest
```

SQLBoiler requires you to install a driver based on the database you are using (list of [supported databases](https://github.com/volatiletech/sqlboiler#supported-databases) by SQLBoiler).

We will be using PostgreSQL for this article, install the postgres driver.

```bash
go install github.com/volatiletech/sqlboiler/v4/drivers/sqlboiler-psql@latest
```

CLI part is all done ✅ let's move on to the project.

# Project Setup

SQLBoiler reads the schema directly from your database. We need a database with a schema. I am not going to spend time on schema creation.

I have already provided a **sample schema** in the GitHub repository of this article, all you need is **Docker** installed on your machine. Make sure you have cloned [this repository](https://github.com/gurleensethi/go-sql-boiler-example).

## Setting up database

Once the project is cloned, run `docker compose up` in the project folder and you will have the database ready to go.

Here are the `create table` queries that run behind the scenes.

```sql
CREATE TABLE author(
  id serial primary key,
  email varchar not null,
  name varchar not null
);

CREATE TABLE article(
  id serial primary key,
  title varchar not null,
  body text,
  created_at timestamp default now(),
  author_id int not null,
  constraint fk_author_id foreign key(author_id) references author(id)
);
```

You have got two tables, `author` and `article`, the relationship between them is pretty self explanatory.

![Go SQLBoiler Schema](https://tdc-public.nyc3.digitaloceanspaces.com/photos/015d093e-7241-43fc-b3d8-ec59f17d25db-go-sqlboiler-schema.png){.center .large}

## Setting up go project

Go ahead a create a new `go` project and initialize it with `go mod init` as we will be installing a handful of packages.

Install the following packages in the project.

```bash
go get github.com/lib/pq
go get github.com/volatiletech/sqlboiler/v4
go get github.com/volatiletech/null/v8
```

- [`github.com/lib/pq`](https://github.com/lib/pq) is the go postgres driver, if you have ever wrote `SQL` in `Go`, you know you need a database driver.
- [`github.com/volatiletech/sqlboiler/v4`](https://github.com/volatiletech/sqlboiler/) is the SQLBoiler package, the generated ORM code relies on this package.
- [`github.com/volatiletech/null/v8`](https://github.com/volatiletech/null) is package for better handling of `nil` types in `Go`.

Next, create the `main.go` file.

```go:main.go
package main

import (
	_ "github.com/lib/pq"
)

func main() {
}
```

# Generating Code with SQLBoiler

Before we generate the ORM client, we need to tell **SQLBoiler** how to connect to our database i.e. we need a configuration file, SQLBoiler stores it configuration in file called `sqlboiler.toml`.

## Creating SQLBoiler configuration file

Create a new file called `sqlboiler.toml`. I have documented what each property means in the code below.

```toml:sqlboiler.toml
# Directory in which the generated static code is to be kept.
output = "db/models" 

# Each time new code is generated, completely wipe out the old one.
wipe = true

# The `go` package name used in the generated code.
pkgname = "dbmodels"

# Adds global variant of the generated functions, more on this later.
add-global-variants = true

# Generates code for enum types as well.
add-enum-types = true

# This is the postgres config, which should be self explanatory.
[psql]
dbname = "postgres"
host = "localhost"
port = 2345
user = "postgres"
pass = "postgres"
sslmode = "disable"
```

## Generating the static ORM

Now that cli is installed and the configuration file is setup, you can generate the ORM client.

```bash
sqlboiler psql 
```

This will generate the static code in `db/models` directory 🎉. You can take a look at the generated code [here](https://github.com/gurleensethi/go-sql-boiler-example/tree/main/db/models).

# Using generated code

Now is the juciy part 😋 let's start uing the generate code.

First of all let's write some initialization code.

```go:main.go
package main

import (
	"database/sql"

	_ "github.com/lib/pq"
	"github.com/volatiletech/sqlboiler/v4/boil"
)

func main() {
	db := connectDB()

	boil.SetDB(db)
}

func connectDB() *sql.DB {
	db, err := sql.Open("postgres", "postgres://postgres:postgres@localhost:2345/postgres?sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}
	return db
}
```

`connectDB` is a function that relies on `Go`'s inbuilt `sql` package to connect to the postgres database.

> **Global variants**: `boil.SetDB(db)` is an interesting one, so **SQLBoiler** can generate *global variants* of the functions, these functions are appended with a `G` at the end of the function name. For example the **Insert** function will have a **InsertG** variant, the difference is that when using **Insert** function you will each time have to pass the `db` instance to it, whereas **InsertG** will use the `db` instance set using `boil.SetDB(db)`, freeing you up from the hassle of passing `db` around the functions.

## Creating Author

Write a function that creates a new author and insert it into the database.

```go:main.go
package main

import (
	"context"
	"database/sql"
	"log"

	dbmodels "github.com/gurleensethi/go-sql-boiler-example/db/models"
	_ "github.com/lib/pq"
	"github.com/volatiletech/sqlboiler/v4/boil"
)

func main() {
	ctx := context.Background()
	db := connectDB()

	boil.SetDB(db)

	author := createAuthor(ctx)
}

// 👇 function that creates a new author
func createAuthor(ctx context.Context) dbmodels.Author {
	author := dbmodels.Author{
		Name:  "John Doe",
		Email: "johndoe@email.com",
	}

	err := author.InsertG(ctx, boil.Infer()) // 👈 insert author
	if err != nil {
		log.Fatal(err)
	}

	return author
}
```

Run the code using `go run main.go`.

**SQLBoiler** generates a lot of useful types, it will generate a type for each table which has many functions on it, one of them is `InsertG` (global variant) which is used to insert data into db.

**Database Log**

If you running the database provided in the example repository of this article, I have enabled logging on the database so you can see **exactly** what queries are being run my **SQLBoiler**.

```text
LOG:  execute <unnamed>: INSERT INTO "author" ("email","name") VALUES ($1,$2) RETURNING "id"
DETAIL:  parameters: $1 = 'johndoe@email.com', $2 = 'John Doe'
```

## Creating Article

Write a function that creates a new article and insert it into the database.

```go:main.go
package main

import (
	"context"
	"database/sql"
	"log"

	dbmodels "github.com/gurleensethi/go-sql-boiler-example/db/models"
	_ "github.com/lib/pq"
	"github.com/volatiletech/null/v8"
	"github.com/volatiletech/sqlboiler/v4/boil"
)

func main() {
	ctx := context.Background()
	db := connectDB()

	boil.SetDB(db)

	author := createAuthor(ctx)
	createArticle(ctx, author) // 👈 new article
	createArticle(ctx, author) // 👈 new article
}

// 👇 function that creates a new article
func createArticle(ctx context.Context, author dbmodels.Author) dbmodels.Article {
	article := dbmodels.Article{
		Title:    "Hello World",
		Body:     null.StringFrom("Hello world, this is an article."),
		AuthorID: author.ID,
	}

	err := article.InsertG(ctx, boil.Infer()) // 👈 insert article
	if err != nil {
		log.Fatal(err)
	}

	return article
}
```

Database query log:

```text
LOG:  execute <unnamed>: INSERT INTO "article" ("title","body","created_at","author_id") VALUES ($1,$2,$3,$4) RETURNING "id"
DETAIL:  parameters: $1 = 'Hello World', $2 = 'Hello world, this is an article.', $3 = '2022-08-06 20:11:49.012108', $4 = '1'
LOG:  execute <unnamed>: INSERT INTO "article" ("title","body","created_at","author_id") VALUES ($1,$2,$3,$4) RETURNING "id"
DETAIL:  parameters: $1 = 'Hello World', $2 = 'Hello world, this is an article.', $3 = '2022-08-06 20:11:49.016963', $4 = '1'
```

## Selecting Author and Article

In this piece of code, we are selecting an `Author` by ID and then selecting all the `Article`s created by that author.

```go:main.go
package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"

	dbmodels "github.com/gurleensethi/go-sql-boiler-example/db/models"
	_ "github.com/lib/pq"
	"github.com/volatiletech/null/v8"
	"github.com/volatiletech/sqlboiler/v4/boil"
)

func main() {
	ctx := context.Background()
	db := connectDB()

	boil.SetDB(db)

	author := createAuthor(ctx)
	createArticle(ctx, author)
	createArticle(ctx, author)
	selectAuthorWithArticle(ctx, author.ID)
}

// 👇 function that selects author and articles.
func selectAuthorWithArticle(ctx context.Context, authorID int) {
	author, err := dbmodels.Authors(dbmodels.AuthorWhere.ID.EQ(authorID)).OneG(ctx)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Author: \n\tID:%d \n\tName:%s \n\tEmail:%s\n", author.ID, author.Name, author.Email)

	articles, err := author.Articles().AllG(ctx)
	if err != nil {
		log.Fatal(err)
	}

	for _, a := range articles {
		fmt.Printf("Article: \n\tID:%d \n\tTitle:%s \n\tBody:%s \n\tCreatedAt:%v\n", a.ID, a.Title, a.Body.String, a.CreatedAt.Time)
	}
}
```

Databae query log:

```text
LOG:  execute <unnamed>: SELECT "author".* FROM "author" WHERE ("author"."id" = $1) LIMIT 1;
DETAIL:  parameters: $1 = '1'
LOG:  execute <unnamed>: SELECT "article".* FROM "article" WHERE ("article"."author_id"=$1);
DETAIL:  parameters: $1 = '1'
```

## Eager loading articles

**SQLBoiler** allows for earger loading of data, in our case we can load the articles of an author when we are fetching the articles. Update the `selectAuthorWithArticle` to have eager loading.

```go:main.go
package main

import (
	// ...other imports
	"github.com/volatiletech/sqlboiler/v4/queries/qm"
)

// ...other code

func selectAuthorWithArticle(ctx context.Context, authorID int) {
	author, err := dbmodels.Authors(
		dbmodels.AuthorWhere.ID.EQ(authorID),
		qm.Load(dbmodels.AuthorRels.Articles), // 👈 eager loading articles
	).OneG(ctx)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Author: \n\tID:%d \n\tName:%s \n\tEmail:%s\n", author.ID, author.Name, author.Email)

	for _, a := range author.R.Articles {
		fmt.Printf("Article: \n\tID:%d \n\tTitle:%s \n\tBody:%s \n\tCreatedAt:%v\n", a.ID, a.Title, a.Body.String, a.CreatedAt.Time)
	}
}
```

Eagerly loaded relations are stored in the `.R` property, so here it is `author.R.Articles`.

Database query log:

```text
LOG:  execute <unnamed>: SELECT "author".* FROM "author" WHERE ("author"."id" = $1) LIMIT 1;
DETAIL:  parameters: $1 = '2'
LOG:  execute <unnamed>: SELECT * FROM "article" WHERE ("article"."author_id" IN ($1));
DETAIL:  parameters: $1 = '2'
```

## Joining Tables

If you observe the database query logs, eager loading is still sending out two queries, what if we want to fetch this data in a single query, well we can do that using using a `join`.

Let's use the `NewQuery` function to create a custom query. Updating the `selectAuthorWithArticle` to fetch data using a join.

```go:main.go
package main

import (
	// ...other imports
	"github.com/volatiletech/sqlboiler/v4/queries/qm"
)

// ...other code

func selectAuthorWithArticle(ctx context.Context, authorID int) {
	// since each database row will contain info for author and article.
	type AuthorAndArticle struct {
		Article dbmodels.Article `boil:"articles,bind"`
		Author  dbmodels.Author  `boil:"author,bind"`
	}

	authorAndArticles := make([]AuthorAndArticle, 0)

	err := dbmodels.NewQuery(
		qm.Select("*"),
		qm.From(dbmodels.TableNames.Author),
		qm.InnerJoin("articles on articles.author_id = author.id"),
		dbmodels.AuthorWhere.ID.EQ(authorID),
	).BindG(ctx, &authorAndArticles)
	if err != nil {
		log.Fatal(err)
	}

	for _, authorAndArticle := range authorAndArticles {
		author := authorAndArticle.Author
		a := authorAndArticle.Article

		fmt.Printf("Author: \n\tID:%d \n\tName:%s \n\tEmail:%s\n", author.ID, author.Name, author.Email)
		fmt.Printf("Article: \n\tID:%d \n\tTitle:%s \n\tBody:%s \n\tCreatedAt:%v\n", a.ID, a.Title, a.Body.String, a.CreatedAt.Time)
	}
}
```

Database query log:

```text
LOG:  execute <unnamed>: SELECT * FROM "author" INNER JOIN article on article.author_id = author.id WHERE ("author"."id" = $1);
DETAIL:  parameters: $1 = '4'
```

As you can observe, only one query is being sent to the database.

# Ending

In my opinion **SQLBoiler** has a lot of potential to be the go-to `SQL` package in `Go`, there are still some small quircks in the library but once addressed it will go 🚀 🌕. Definitely visit the [SQLBoiler](https://github.com/volatiletech/sqlboiler)'s official documentation and dive deep into available functionality.

Thank you for reading this article 🙏🏻 if you learned something new consider joining the mailing list to get notified about articles likes these 😀.

SQLBoiler is package that introspects your database schema and generates a static ORM client. In this article I am going to give you a taste of SQLBoiler.