DEV Community: Lucas Neves Pereira

I Built an AI Agent Harness in Go

Lucas Neves Pereira — Thu, 02 Apr 2026 16:54:42 +0000

Hello there!

I've been using AI tools a lot lately. ChatGPT, Claude, local models with Ollama. They're great for answering questions, but I wanted something that could actually do things. Search the web, run code, save notes. Not just talk about it.

So I started building nevinho, a personal AI agent that lives in my Discord DMs. You send it a message, it figures out what tools to use, and it gets things done. All from my phone.

I wrote it in Go and I want to walk through how it works, what I got right, and what I still need to fix.

Why Go

I wanted a single binary I could drop on any machine and run. No runtime, no virtualenv, no node_modules. Go gives me that.

The standard library covers most of what I needed. HTTP clients, JSON encoding, crypto, process execution.

Go also makes concurrency explicit. Each user gets their own mutex, tool execution has panic recovery, and the OAuth polling runs in goroutines. It's not magic, but it's easy to reason about.

The architecture

The project has six packages, each with a single responsibility:

nevinho/
├── main.go           // entry point, provider detection
├── agent/            // the core loop
├── llm/              // provider abstraction (Anthropic, OpenAI, Ollama)
├── tools/            // web, code, file operations
├── discord/          // bot interface
├── auth/             // OAuth device flow + encrypted storage
└── logger/           // colored terminal output

The agent doesn't know about Discord. The tools don't know about the LLM. The LLM doesn't know about either. Everything connects through interfaces and simple function calls.

The LLM provider interface

I wanted to switch between Claude, GPT, and local Ollama models without changing any agent code. So I defined a provider interface:

type Provider interface {
    Complete(req *Request) (*Response, error)
    FormatUserMessage(text string) json.RawMessage
    FormatToolResults(results []ToolResult) []json.RawMessage
    Model() string
}

The FormatUserMessage and FormatToolResults methods exist because Anthropic and OpenAI structure their messages differently. Anthropic wraps tool results in a single user message with tool_result content blocks. OpenAI expects separate messages with a tool role. The provider handles that translation.

Switching models at runtime is a slash command. The SwitchModel method detects the provider from the model name prefix:

func (a *Agent) SwitchModel(name string) error {
    var p llm.Provider
    switch {
    case strings.HasPrefix(name, "gpt-") || strings.HasPrefix(name, "o1-") ||
         strings.HasPrefix(name, "o3-") || strings.HasPrefix(name, "o4-"):
        if a.config.OpenAIKey == "" {
            return fmt.Errorf("OPENAI_API_KEY not configured")
        }
        p = llm.NewOpenAI(a.config.OpenAIKey, "", name)
    case strings.HasPrefix(name, "claude-"):
        if a.config.AnthropicKey == "" {
            return fmt.Errorf("ANTHROPIC_API_KEY not configured")
        }
        p = llm.NewAnthropic(a.config.AnthropicKey, "", name)
    default:
        if a.config.OllamaURL != "" {
            p = llm.NewOpenAI("", a.config.OllamaURL, name)
        } else {
            return fmt.Errorf("unknown model: %s", name)
        }
    }

    a.mu.Lock()
    a.llm = p
    a.history = make(map[string][]json.RawMessage)
    a.mu.Unlock()
    return nil
}

Ollama uses the OpenAI-compatible API, so I just reuse the OpenAI provider with a different base URL. The default fallback catches anything that isn't clearly GPT or Claude and routes it to Ollama if configured.

History gets cleared on switch because message formats differ between providers.

The agent loop

The core of the project is the Chat method. It sends the conversation to the LLM, and if the model wants to use tools, it executes them and loops.

func (a *Agent) Chat(userID, text string) (string, error) {
    lock := a.getUserLock(userID)
    lock.Lock()
    defer lock.Unlock()

    // If there's a pending approval and the user said "yes", handle it
    if p := a.tools.PendingApproval(userID); p != nil && looksLikeApproval(text) {
        switch p.Kind {
        case "path":
            a.tools.ApprovePending(userID)
            text = text + "\n[Access granted to " + p.Detail + ". Retry the file operation.]"
        case "code":
            output := a.tools.ExecutePendingCode(userID)
            text = text + "\n[Code execution approved. Output:\n" + output + "]"
        }
    }

    a.appendHistory(userID, a.llm.FormatUserMessage(text))

    for range maxLoops {
        resp, err := a.llm.Complete(&llm.Request{
            SystemPrompt: systemPrompt,
            Messages:     a.history[userID],
            Tools:        a.tools.Defs(),
            MaxTokens:    maxTokens,
        })
        if err != nil {
            return "", err
        }

        a.history[userID] = append(a.history[userID], resp.AssistantMessage)

        if len(resp.ToolCalls) == 0 {
            return resp.Text, nil
        }

        var results []llm.ToolResult
        needsApproval := false
        for _, tc := range resp.ToolCalls {
            output := a.executeTool(tc.Name, tc.Input, userID)
            results = append(results, llm.ToolResult{ID: tc.ID, Output: output})
            if strings.HasPrefix(output, "NEEDS_APPROVAL:") {
                needsApproval = true
            }
        }

        // The API requires tool results after every assistant message with tool_use
        for _, msg := range a.llm.FormatToolResults(results) {
            a.history[userID] = append(a.history[userID], msg)
        }

        if needsApproval {
            return approvalMessage(a.tools.PendingApproval(userID)), nil
        }
    }

    return "I hit my limit on tool calls. Try breaking it into smaller tasks.", nil
}

The loop runs up to 10 iterations. Each time, the model either responds with text (done) or asks to use tools (execute and loop again). This is what lets the agent chain actions: search the web, read a page, then summarize.

The approval check at the top is important. When a tool needs permission, the loop stops and asks the user. On their next message, if it looks like "yes" or "oui", the pending action runs and the result gets injected into the conversation.

Each user gets their own mutex so conversations don't corrupt each other's history.

Tools

The tool registry is a simple switch:

func (r *Registry) Execute(name string, input json.RawMessage, userID string) string {
    switch name {
    case "web_read":
        return r.webRead(input)
    case "web_search":
        return r.webSearch(input)
    case "run_code":
        return r.runCode(input, userID)
    case "file_read":
        return r.fileRead(input, userID)
    case "file_write":
        return r.fileWrite(input, userID)
    default:
        return fmt.Sprintf("unknown tool: %s", name)
    }
}

Each tool gets a json.RawMessage input and returns a string. Tool definitions with JSON schemas are sent to the LLM so it knows what's available.

Web search uses the Brave Search API if you have a key, with DuckDuckGo HTML scraping as a zero-config fallback. The DDG fallback parses the actual HTML result page, no API key needed.

Web read fetches a URL and strips the HTML down to readable text. It walks the DOM, skips script/style/nav/footer elements, and looks for a <main> or <article> tag to focus on content.

Code execution runs Python, Node, or bash with a 10-second timeout via exec.CommandContext. Output is capped at 5KB.

File operations use a per-user workspace at ~/.config/nevinho/workspace/{userID}/. Relative paths stay sandboxed there. Absolute paths require explicit approval.

The approval system

Letting an AI run arbitrary code is a bad idea. So dangerous operations need approval.

The code scans for dangerous patterns using regex before executing anything:

var dangerousPatterns = []*regexp.Regexp{
    regexp.MustCompile(`\brm\b`),
    regexp.MustCompile(`\bsudo\b`),
    regexp.MustCompile(`\bchmod\b`),
    regexp.MustCompile(`\bkill\b`),
    regexp.MustCompile(`\bcurl\b.*\|`),
    regexp.MustCompile(`:\(\)\s*\{`), // fork bomb
    // ... and more
}

It also checks for sensitive paths like .ssh, .aws, .env, and credentials. If anything matches, the tool returns a NEEDS_APPROVAL: prefix instead of executing. The agent loop catches this, sends the user a preview of what it wants to do, and stops.

The user replies "yes" (or "oui") and the pending action runs. Approved directories persist to a JSON file on disk so you don't get asked twice.

There are two types of approval: path approval (for writing outside the workspace) and code approval (for dangerous commands). Path approvals are remembered. Code approvals are one-shot.

URL validation

Before fetching any URL, the web tools validate it to prevent SSRF:

func validateURL(rawURL string) error {
    u, err := url.Parse(rawURL)
    if err != nil {
        return fmt.Errorf("invalid URL")
    }
    if u.Scheme != "http" && u.Scheme != "https" {
        return fmt.Errorf("only http/https allowed")
    }

    ips, err := net.LookupIP(u.Hostname())
    if err != nil {
        return fmt.Errorf("cannot resolve host")
    }
    for _, ip := range ips {
        if ip.IsLoopback() || ip.IsPrivate() || ip.IsLinkLocalUnicast() {
            return fmt.Errorf("internal addresses not allowed")
        }
    }
    return nil
}

Only http/https allowed, and it does a DNS lookup to block requests to localhost, private IPs, and link-local addresses. Without this, the model could try to hit internal services.

OAuth with device flow

I wanted nevinho to connect to GitHub and Google. But OAuth on a bot is tricky because there's no browser to redirect to.

The solution is the OAuth Device Flow:

The bot requests a device code from GitHub/Google
It shows the user a short code and a URL
The user opens the URL on any device, enters the code
The bot polls until authorization completes

From Discord it looks like this:

> /connect github
Bot: **Connect GitHub**
     1. Open: https://github.com/login/device
     2. Enter code: ABCD-1234
     Waiting for authorization...

Bot: Connected to GitHub as **lucasnevespereira**!

The polling runs in a goroutine so it doesn't block the bot. If GitHub says "slow down", it bumps the poll interval by 5 seconds.

Right now the tokens are stored but not wired to any tools yet. That's next on the list.

Encrypted credential storage

OAuth tokens shouldn't sit in a plain JSON file. So I encrypt them with AES-256-GCM using Go's standard crypto package:

func encrypt(key [32]byte, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key[:])
    if err != nil {
        return nil, err
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    nonce := make([]byte, gcm.NonceSize())
    if _, err := rand.Read(nonce); err != nil {
        return nil, err
    }
    return gcm.Seal(nonce, nonce, plaintext, nil), nil
}

The encryption key comes from a NEVINHO_SECRET env var (hashed with SHA-256) or an auto-generated key file at ~/.config/nevinho/secret.key. Credentials are written with 0600 permissions.

Discord as the interface

I picked Discord because I already use it daily and it works on my phone. The bot only responds to DMs from a single owner configured via DISCORD_OWNER_ID.

Messages over 2000 characters get split at newline boundaries. Slash commands handle /new, /model, /status, /paths, /connect, /disconnect, /accounts, and /help. The same commands also work as plain text messages in the chat.

What's missing

I want to be honest about this. The project works, but it's not where I want it to be yet. Here's what a proper agent harness should have that I haven't built:

No retry logic. If the LLM API returns a 429 or 5xx, the conversation just fails. I need exponential backoff.

Sequential tool execution. When the model requests three tool calls at once, I run them one by one. They should run in parallel with goroutines and a WaitGroup.

No streaming. The bot waits for the full LLM response before showing anything. On long responses, Discord's typing indicator expires after 10 seconds and the user thinks it's stuck.

Message-count history trimming. I trim conversation history at 20 messages regardless of size. A message with 10KB of tool output uses the same slot as a 50-char user message. This should be token-aware.

No tool result summarization. When web_read returns 10KB of text, all of it goes into the history. That eats through the context window fast. Long tool outputs should be summarized before going back to the model.

These are all solvable. I'm working through them.

What I learned

The LLM API differences are annoying but manageable. Anthropic and OpenAI have different message formats, different tool call structures, different system prompt handling. But once you define a clean interface, each adapter is about 100 lines.

Safety is where most of the thinking goes. The agent loop itself is straightforward. The hard part is approving dangerous operations, sandboxing file paths, validating URLs, preventing SSRF. Every tool I add needs its own threat model.

Go was the right choice for this. Single binary, good concurrency primitives, a rich standard library. No framework needed. The whole project is about 2800 lines across 12 files.

Try it out

The project is open source. Feel free to check it out, open issues, or contribute.

GitHub: github.com/lucasnevespereira/nevinho

Hope you find it useful!

I Built a CLI Tool That Writes My Commit Messages

Lucas Neves Pereira — Fri, 20 Mar 2026 19:12:28 +0000

Hello guys! We've all been there. You just finished a feature, you're ready to commit, and then you stare at the terminal for 30 seconds trying to come up with a decent commit message.

Sometimes I'd spend more time thinking about the message than writing the actual code. So I did what any developer would do. I automated it.

How it started

I already had Claude installed on my machine. One day I realized I could just pipe my git diff into it and ask for a commit message. So I added this little function to my .zshrc:

gpm() {
  git diff HEAD | claude -p "propose a conventional commit message for these changes. output only the message, nothing else."
}

That was it. Run gpm, get a message, copy paste it. Simple.

Then I wanted to go further. Why not commit directly with the proposed message?

gac() {
  msg=$(git diff HEAD | claude -p "propose a conventional commit message for these changes, one line only. output only the message, nothing else.")
  echo "\n$msg\n"
  read "confirm?Commit with this message? [y/N] "
  if [[ "$confirm" == "y" ]]; then
    git add -A && git commit -m "$msg"
  fi
}

This worked great for a while. But I kept wanting more. What about code review? PR descriptions? What if I could choose the model? What about using the API directly instead of going through the CLI?

At some point I realized these shell functions were becoming a full tool. So I decided to build one.

Meet claude-git

claude-git is a CLI that reads your git diff and sends it to Claude to generate commit messages, review code, write PR descriptions, and more. It's written in bash, runs entirely in your terminal, and installs in one command.

curl -fsSL https://raw.githubusercontent.com/lucasnevespereira/claude-git/main/install.sh | bash

Let's go through the main features.

Proposing a commit message

The most basic command. Stage your changes, run claude-git msg, and you get a conventional commit message.

claude-git msg
# -> feat: add user authentication with JWT tokens

That's it. It reads the diff, sends it to Claude, and outputs a message. You can copy it or use it however you want.

Committing directly

If you don't want to copy paste, claude-git commit will propose a message and ask you to confirm before committing.

claude-git commit

feat: add user authentication with JWT tokens

Commit with this message? [y/N] y

And if you're feeling confident and want to skip the confirmation:

claude-git commit -y

Prefix mode

At work we often need to prefix commits with a ticket ID. Something like PROJ-42: fix login redirect. I got tired of typing the prefix manually so I added a prefix command that auto detects the ticket from your branch name.

If your branch is called feature/PROJ-42-login-fix, running claude-git prefix will automatically extract PROJ-42 and prepend it to the message.

claude-git prefix
# -> PROJ-42: fix login redirect after session expiry

You can also pass the prefix manually:

claude-git prefix PROJ-42

Code review

Before pushing, I sometimes want a quick sanity check. The review command sends your diff to Claude and asks it to flag bugs, security issues, or logic errors.

claude-git review

It's not a replacement for a real code review, but it's useful to catch obvious mistakes before opening a PR.

PR descriptions

Writing PR descriptions is another thing that takes longer than it should. The pr command looks at all commits and the full diff against your base branch and generates a structured description.

claude-git pr

By default it compares against main, but you can specify another branch:

claude-git pr develop

Explaining changes

Sometimes you come back to some changes you made yesterday and forgot what they do. The explain command gives you a quick summary.

claude-git explain
# -> These changes add rate limiting to the API endpoints using a token bucket...

Short aliases

I like short commands. The installer automatically adds aliases to your shell config:

cg      # claude-git
cgm     # claude-git msg
cgc     # claude-git commit
cgcy    # claude-git commit --yes
cgrev   # claude-git review
cgpr    # claude-git pr
cgex    # claude-git explain
cgpx    # claude-git prefix

So in practice, committing with AI looks like this:

cgcy

Three characters and you're done.

Configuration

You can configure the model, the max diff size, and whether to use the API directly or go through the Claude CLI.

claude-git config model sonnet      # use a more capable model
claude-git config api_key sk-ant-...  # use API calls directly (faster)
claude-git config max_lines 5000    # handle larger diffs

By default it uses Haiku which is fast and cheap. If you set an API key, it will call the Anthropic API directly instead of going through Claude Code, which is noticeably faster.

The config lives in ~/.claude-git as a simple key=value file. Nothing fancy.

Why bash?

I get this question a lot. Bash is not glamorous. But for a tool that wraps git commands and pipes text to an API, it's actually the perfect fit. No compile step, no dependencies, no runtime. It just works on any machine that has bash and git.

The entire tool is a single file. That makes it easy to install, easy to read, and easy to contribute to.

What I learned

Building this tool taught me a few things. First, sometimes the best projects come from automating your own annoyances. I didn't sit down and plan this. It grew from a two line function in my shell config.

Second, keeping things simple pays off. bash is not the fanciest choice but it made the tool easy to distribute and maintain. No build system, no package manager drama.

And finally, AI is really good at reading diffs. The commit messages Claude generates are genuinely useful. Most of the time I accept them as is.

Try it out

If you want to give it a try:

curl -fsSL https://raw.githubusercontent.com/lucasnevespereira/claude-git/main/install.sh | bash

The repo is here: github.com/lucasnevespereira/claude-git

It's open source under MIT. Feedback and contributions are welcome.

Hope you find it useful!

Deploy a Docker App to Coolify in 5 Minutes

Lucas Neves Pereira — Wed, 21 May 2025 13:16:51 +0000

In this quick guide, we’ll walk through how to deploy a Docker application to Coolify in just five minutes. Coolify is a self-hosted platform that makes it easy to manage your applications with a user-friendly interface. Let’s get started!!

Key Takeaways

Set up a Coolify project to manage your application.
Create a GitHub repository for your Dockerized app.
Build and deploy your application using a Dockerfile.
Access your app through a generated domain.

What Is Coolify?

Coolify is a platform that allows you to self-host applications easily. Think of it as your own version of Vercel, but with more control. You can deploy various applications, and it provides a clean UI to manage everything.

Setting Up Your Coolify Project

To begin, you need to have Coolify installed on your VPS. Once that’s done, follow these steps:

Create a New Project: In the Coolify dashboard, create a new project. Let’s call it Coolify App.
Connect Your GitHub Repository: You’ll need a GitHub repo to store your Dockerized application. Create a new repository named Coolify App as well.
Link the Repository: Copy the GitHub URL and paste it into the Coolify dashboard to connect your project.

Creating Your Dockerized Application

Now that your project is set up, it’s time to create a simple Dockerized application. Here’s how:

Clone Your GitHub Repository: Start by cloning the repository you just created.
Set Up Your Application: Create a new package.json file and install Express. This will be the framework for your simple server.
Here’s a quick example of what your index.js might look like:
Create a .gitignore File: Don’t forget to add a .gitignore file to exclude node_modules from your repository.
Create Your Dockerfile: This file tells Docker how to build your application. Here’s a simple Dockerfile:

Deploying to Coolify

With your application ready, it’s time to deploy:

Push Your Code: Push your changes to the GitHub repository.
Create a Deployment in Coolify: Back in the Coolify dashboard, create a new deployment. Coolify should automatically detect your Dockerfile.
Monitor the Build Process: You can check the logs to see if the build is successful. Look for a message indicating that your app is running on port 3000.

Accessing Your Application

Once the deployment is complete, Coolify will generate a domain for your application. You can visit this domain to see your app in action. If everything went well, you should see the message you set up in your Express server.

Conclusion

And there you have it! In just five minutes, you’ve deployed a Dockerized application to Coolify. This platform makes it super easy to manage your apps without the hassle of complex setups. Give it a try, and see how it can simplify your development workflow!

Build your own LinkTree with Go and GitHub Pages

Lucas Neves Pereira — Thu, 22 Aug 2024 21:28:12 +0000

Hello there! Lately I've been working on my personal website, I wanted to rebuild it to a very simple single page served by GitHub Pages.

I used to build my website using a known tool named Hugo, a static site generator. I also have a LinkTree account that displays all of my links.

So I started wondering for my new website if I could build something similar, only with the core functionalities I want, a minimal version of a static site generator.

I would just need a config.yml file containing my page configuration (site name, meta, links...), parse it to a struct and then inject it to an HTML template.

Finally, I would have to build the template and copy it's output + assets to the root of my repository, ready to be served by GitHub Pages.

How to implement this

Let's start by creating a config.yml file at the root of our project with some fields, this will contain our site configuration.

# config.yml
name: "Lucas Neves Pereira"
picture: "picture.jpg" # paste an img at root of project or an image source url
bio: "Software Engineer from Portugal living in Paris, France"
meta:
  lang: "en"
  description: "Software Engineer from Portugal living in Paris, France"
  title: "Lucas Neves Pereira"
  author: "Lucas Neves Pereira"
  siteUrl: "https://lucasnevespereira.github.io"
links:
  - name: "Github"
    url: "https://github.com/lucasnevespereira"
  - name: "LinkedIn"
    url: "https://www.linkedin.com/in/lucasnevespereira/"
  - name: "Youtube"
    url: "https://www.youtube.com/c/lucaasnp"
  - name: "Twitter/X"
    url: "https://twitter.com/lucaasnp_"
  - name: "Dev.to"
    url: "https://dev.to/lucasnevespereira"
theme: "custom"

Now we can init a go module and add a main.go⁣ file with a package main to the root of our project.

go mod init gopagelink

//main.go
package main

import "fmt"

func main() {}

Load config data

We need to first load the yaml configuration from our config.yml into a struct that we could inject later to a template.

For that, we can create a package configs, so let's create a configs/ directory and add a site.go file.

go get -u gopkg.in/yaml.v2

// configs/site.go
package configs

import (
    "os"

    "gopkg.in/yaml.v2"
)

type SiteConfig struct {
    Name    string  `yaml:"name"`
    Bio     string  `yaml:"bio"`
    Picture string  `yaml:"picture"`
    Meta    Meta    `yaml:"meta"`
    Links   []Link  `yaml:"links"`
        Theme   string  `yaml:"theme"`
}

type Meta struct {
    Title       string `yaml:"title"`
    Description string `yaml:"description"`
    Lang        string `yaml:"lang"`
    Author      string `yaml:"author"`
    SiteUrl     string `yaml:"siteUrl"`
}

type Link struct {
    Name string `yaml:"name"`
    URL  string `yaml:"url"`
}

func LoadSiteConfig(path string) (*SiteConfig, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, err
    }

    var config SiteConfig
    err = yaml.Unmarshal(data, &config)
    if err != nil {
        return nil, err
    }

    return &config, nil
}

Here, we've created a function LoadSiteConfig that will simply read a file from a path and parse it's yaml content to a Go struct SiteConfig. We can go back to our entry file and use this LoadSiteConfig.

//main.go
package main

import (
"log"
"gopagelink/configs"
)

func main {
 // Load configuration
 config, err := configs.LoadSiteConfig("config.yml")
 if err != nil {
   log.Fatalf("Error loading config: %v", err)
 }

}

Set up our first theme

Let's create a themes directory where we will store the HTML, CSS, and JavaScript for our page. The idea is to select the appropriate files based on the theme specified in the config.yml. Each subdirectory within the themes directory will represent a different theme.

For example, if our theme is set to "custom," we will use the following directory: themes/custom/.

I'll start by writing an index.html with the structure I want for my page and let's already put the fields we want from our SiteConfig struct that we will populate later.

<!-- themes/custom/index.html -->

<html lang="{{.Config.Meta.Lang}}">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initialscale=1.0" />
    <meta name="description" content="{{.Config.Meta.Description}}"/>
    <title>{{.Config.Meta.Title}}</title>
    <meta name="author" content="{{.Config.Meta.Author}}" />
    <link rel="canonical" href="{{.Config.Meta.SiteUrl}}" />
    <link rel="icon" type="image/x-icon" href="/assets/icons/favicon.ico" />
    <link rel="shortcut icon" href="/assetsicons/favicon.ico" />
    <link
      rel="stylesheet"
      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap"
    />
    <link rel="stylesheet" href="/assets/css/styles.css" />

    <meta property="og:title" content="{{.Config.Meta.Title}}" />
    <meta property="og:site_name" content="{{.Config.Meta.Title}}" />
    <meta property="og:description" content="{{.Config.Meta.Description}}" />
    <meta property="og:locale" content="{{.Config.Meta.Lang}}" />

    <meta name="twitter:title" content="{{.Config.Meta.Title}}" />
    <meta name="twitter:description" content="{{.Config.Meta.Description}}" />
    <meta name="language" content="{{.Config.Meta.Lang}}" />
  </head>
  <body>
    <header>
      <img src="{{.Config.Picture}}" alt="Picture" class="avatar" />
      <h1>{{.Config.Name}}</h1>
      <small class="bio">{{.Config.Bio}}</small>
    </header>
    <main>
      <section class="links">
        {{range .Config.Links}}
        <a
          class="link-item"
          href="{{.URL}}"
          target="_blank"
          rel="noopener noreferrer"
          ><p>{{.Name}}</p>
        </a>
        {{end}}
      </section>
    </main>
    <footer>
      <small>© <span class="year"></span> {{.Config.Meta.Author}} </small>
    </footer>
    <script src="/assets/js/script.js"></script>
  </body>
</html>

Next, I'll set up an assets folder within the theme directory that will contain js, css and icons files.

// themes/custom/assets/js/script.js
console.log("scripts loaded");

const yearDate = new Date().getFullYear().toString();
document.querySelector(".year").innerText = yearDate;

/* themes/custom/assets/css/styles.css */
/* CSS Reset */
* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

/* Variables */
:root {
  --max-width: 600px;
  --font-family: 'Inter', sans-serif;
  --padding: 1rem;
  --header-margin-bottom: 1rem;
  --line-height: 2;
  --font-size: 16px;

  --primary-color-light: #ffffff;
  --background-color-light: #f0f0f0;
  --text-color-light: #333;
  --link-color-light: #1a73e8;
  --bio-color-light: #666;

  --primary-color-dark: #1e1e1e;
  --background-color-dark: #121212;
  --text-color-dark: #e0e0e0;
  --link-color-dark: #8ab4f8;
  --bio-color-dark: #aaa;
}

/* Light Theme */
@media (prefers-color-scheme: light) {
  :root {
    --primary-color: var(--primary-color-light);
    --background-color: var(--background-color-light);
    --text-color: var(--text-color-light);
    --link-color: var(--link-color-light);
    --bio-color: var(--bio-color-light);
  }
}

/* Dark Theme */
@media (prefers-color-scheme: dark) {
  :root {
    --primary-color: var(--primary-color-dark);
    --background-color: var(--background-color-dark);
    --text-color: var(--text-color-dark);
    --link-color: var(--link-color-dark);
    --bio-color: var(--bio-color-dark);
  }
}

/* Global Styles */
html {
  font-family: var(--font-family);
  font-size: var(--font-size);
  line-height: var(--line-height);
}

body {
  max-width: var(--max-width);
  min-height: 100dvh;
  margin: 0 auto;
  display: flex;
  flex-direction: column;
  align-items: center;
  background-color: var(--background-color);
  color: var(--text-color);
  padding: var(--padding);
}

/* Header Styles */
header {
  padding: var(--padding) 0;
  margin-bottom: var(--header-margin-bottom);
  width: 100%;
  display: flex;
  flex-direction: column;
  justify-content: space-between;
  align-items: center;
  text-align: center;
}

.avatar {
  width: 100px;
  height: 100px;
  border-radius: 50%; 
  object-fit: cover;
  border: 2px solid var(--primary-color);
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
  display: flex;
  justify-content: center;
}

h1 {
  font-size: 24px;
  margin-bottom: 0.5rem;
}

.bio {
  font-size: 14px;
  color: var(--bio-color);
  margin-bottom: 1rem;
}

/* Main Content Styles */
main {
  width: 100%;
  flex: 1;
}

.links {
  display: flex;
  flex-direction: column;
  gap: 1rem;
  text-align: center;
  overflow-y: scroll;
  max-height: 400px;
}

.link-item {
  display: block;
  padding: 16px 20px;
  text-decoration: none;
  color: var(--link-color);
  background: var(--primary-color);
  border-radius: 12px;
  border: 1px solid var(--link-color);
  border-radius: 14px;
  transition: box-shadow 0.25s cubic-bezier(0.08, 0.59, 0.29, 0.99), border-color 0.25s cubic-bezier(0.08, 0.59, 0.29, 0.99), transform 0.25s cubic-bezier(0.08, 0.59, 0.29, 0.99), background-color 0.25s cubic-bezier(0.08, 0.59, 0.29, 0.99);
}

.link-item:hover,
.link-item:focus {
  background-color: var(--link-color);
  color: var(--primary-color);
}

.link-item p {
  line-height: 1.5;
  font-weight: 500;
}

/* Footer Styles */
footer {
  width: 100%;
  text-align: center;
  padding: 1rem 0;
  font-size: 14px;
  gap: 1rem;
  display: flex;
  justify-content: center;
  align-items: center;
}

/* SrollBar */
/* width */
::-webkit-scrollbar {
  width: 5px;
}

/* Track */
::-webkit-scrollbar-track {
  background: transparent;
}

/* Handle */
::-webkit-scrollbar-thumb {
  background: transparent;
}

/* Handle on hover */
::-webkit-scrollbar-thumb:hover {
  background: transparent;
}

And the icons needed, like favicon.ico for example into themes/custom/assets/icons/.

With that, our first theme is created! Feel free to customize or create different themes (sub-directories) for your page.

Populate theme template

Back to our main.go file we are going to create a function generateHTML.

package main

import (
"log"
"gopagelink/configs"
)

func main {
 // Load configuration
 config, err := configs.LoadSiteConfig("config.yaml")
 if err != nil {
   log.Fatalf("Error loading config: %v", err)
 }

// Generate HTML
err = generateHTML(config)
if err != nil {
  log.Fatalf("Error generating HTML: %v", err)
}


fmt.Println("Site generated successfully!")

}

func generateHTML(config *configs.SiteConfig) error {   
  themeFile := fmt.Sprintf("themes/%s/index.html", 
  config.Theme)

  // Load HTML template
  tmpl, err := template.ParseFiles(themeFile)
  if err != nil {
    return err
  }

  // Open output file
  outputFile, err := os.Create("index.html")
  if err != nil {
    return err
  }
  defer outputFile.Close()

  // Define data to pass to the template
  data := struct {
    Config  *configs.SiteConfig
  }{
    Config:  config,
  }

  // Execute template with data
  return tmpl.Execute(outputFile, data)
}

As you can guess reading the comments we are loading the template of our theme, creating an output index.html at the root of project (that's what will be served by GitHub Pages). Next, we define a data struct with our config, and lastly we execute our template with our data injected!

A last step we need to do is to copy our theme assets to root directory to be served with our html. For that let's create a function named copyAssets.

//main.go
package main

import (
    "bytes"
    "fmt"
    "html/template"
    "io"
    "log"
    "gopagelink/configs"
    "os"
    "path/filepath"
)

func main {

 // Load configuration
 config, err := configs.LoadSiteConfig("config.yaml")
 if err != nil {
   log.Fatalf("Error loading config: %v", err)
 }

// Generate HTML
err = generateHTML(config, htmlContent)
if err != nil {
  log.Fatalf("Error generating HTML: %v", err)
}

// Copy assets
err = copyAssets(config.Theme)
if err != nil {
  log.Fatalf("Error copying and minifying assets: %v", err)
}


fmt.Println("Site generated successfully!")
}

func generateHTML(config *configs.SiteConfig) error {   
  templateFile := fmt.Sprintf("internal/templates/%s/index.html", 
  config.Theme)

  // Load HTML template
  tmpl, err := template.ParseFiles(templateFile)
  if err != nil {
    return err
  }

  // Open output file
  outputFile, err := os.Create("index.html")
  if err != nil {
    return err
  }
  defer outputFile.Close()

  // Define data to pass to the template
  data := struct {
    Config  *configs.SiteConfig
  }{
    Config:  config,
  }

  // Execute template with data
  return tmpl.Execute(outputFile, data)
}

func copyAssets(theme string) error {
  // Create assets directories if they don't exist
  if err := os.MkdirAll("assets/css", os.ModePerm); err != nil{
    return fmt.Errorf("failed to create assets/css directory: 
     %w",err)
  }
  if err := os.MkdirAll("assets/js", os.ModePerm); err != nil {
    return fmt.Errorf("failed to create assets/js directory: %w", 
    err)
  }
  if err := os.MkdirAll("assets/icons", os.ModePerm); err != nil {
    return fmt.Errorf("failed to create assets/icons directory: %w", 
    err)
  }

 // Get theme assets files
 cssFiles, err := 
   filepath.Glob(fmt.Sprintf("themes/%s/assets/css/*.css", 
   theme))
   if err != nil {
     return fmt.Errorf("failed to list CSS files: %w", err)
   }
 if err := copyFiles(cssFiles, "assets/css"); err != nil {
    return fmt.Errorf("failed to copy css files: %w", err)
 }

 jsFiles, err := 
  filepath.Glob(fmt.Sprintf("themes/%s/assets/js/*.js", 
  theme))
 if err != nil {
    return fmt.Errorf("failed to list JS files: %w", err)
 }
 if err := copyFiles(jsFiles, "assets/js"); err != nil {
    return fmt.Errorf("failed to copy js files: %w", err)
 }

 // Copy favicons
 iconsFiles, err := 
  filepath.Glob(fmt.Sprintf("themes/%s/assets/icons/*", 
  theme))
  if err != nil {
    return fmt.Errorf("failed to list icon files: %w", err)
  }
  if err := copyFiles(iconsFiles, "assets/icons"); err != nil {
    return fmt.Errorf("failed to copy icon files: %w", err)
  }

 return nil

}

func copyFiles(files []string, outputDir string) error {
    for _, file := range files {
        data, err := os.ReadFile(file)
        if err != nil {
            return fmt.Errorf("failed to read %s: %w", file, err)
        }

        outputPath := filepath.Join(outputDir, filepath.Base(file))
        outFile, err := os.Create(outputPath)
        if err != nil {
            return fmt.Errorf("failed to create %s: %w", outputPath, err)
        }
        defer outFile.Close()

        if _, err := io.Copy(outFile, bytes.NewReader(data)); err != nil {
            return fmt.Errorf("failed to copy data to %s: %w", outputPath, err)
        }
    }

    return nil
}

Quick Note: Besides copying the assets, it would be a good practice to minify our js and css files, if you are interested in implementing that you can use libraries like tdewolff/minify

Minify Assets

Here’s how we could handle both minification and copying of js and css files by creating a minifyAndCopyFiles function.

go get github.com/tdewolff/minify

func minifyAndCopyFiles(files []string, destDir string, fileType string) error {
    m := minify.New()
    switch fileType {
    case "text/javascript":
        m.AddFunc("text/javascript", js.Minify)
    case "text/css":
        m.AddFunc("text/css", css.Minify)
    default:
        return fmt.Errorf("unsupported file type: %s", fileType)
    }

    for _, file := range files {
        content, err := os.ReadFile(file)
        if err != nil {
            return fmt.Errorf("failed to read file %s: %w", file, err)
        }

        minifiedContent, err := m.Bytes(fileType, content)
        if err != nil {
            return fmt.Errorf("failed to minify file %s: %w", file, err)
        }

        destPath := filepath.Join(destDir, filepath.Base(file))
        if err := os.WriteFile(destPath, minifiedContent, os.ModePerm); err != nil {
            return fmt.Errorf("failed to write minified file to %s: %w", destPath, err)
        }
    }

    return nil
}

// main.go
package main
....
func copyAssets(theme string) error {
    // Create assets directories if they don't exist
    if err := os.MkdirAll("assets/css", os.ModePerm); err != nil {
        return fmt.Errorf("failed to create assets/css directory: %w", err)
    }
    if err := os.MkdirAll("assets/js", os.ModePerm); err != nil {
        return fmt.Errorf("failed to create assets/js directory: %w", err)
    }
    if err := os.MkdirAll("assets/icons", os.ModePerm); err != nil {
        return fmt.Errorf("failed to create assets/icons directory: %w", err)
    }

    // Get theme assets files
    cssFiles, err := filepath.Glob(fmt.Sprintf("themes/%s/assets/css/*.css", theme))
    if err != nil {
        return fmt.Errorf("failed to list CSS files: %w", err)
    }
    if err := minifyAndCopyFiles(cssFiles, "assets/css", "text/css"); err != nil {
        return fmt.Errorf("failed to copy css files: %w", err)
    }

    jsFiles, err := filepath.Glob(fmt.Sprintf("themes/%s/assets/js/*.js", theme))
    if err != nil {
        return fmt.Errorf("failed to list JS files: %w", err)
    }
    if err := minifyAndCopyFiles(jsFiles, "assets/js", "text/javascript"); err != nil {
        return fmt.Errorf("failed to copy js files: %w", err)
    }

    // Copy favicons
    iconsFiles, err := filepath.Glob(fmt.Sprintf("themes/%s/assets/icons/*", theme))
    if err != nil {
        return fmt.Errorf("failed to list icon files: %w", err)
    }
    if err := copyFiles(iconsFiles, "assets/icons"); err != nil {
        return fmt.Errorf("failed to copy icon files: %w", err)
    }

    return nil
}
...

This updated copyAssets function now includes minification for js and css files.

Building site

Now that we are ready to build and test this, we can create a simple Makefile

.PHONY: clean site

clean:
    @echo "Cleaning site..."
    rm -rf index.html
    rm -rf assets

site: clean
    @echo "Building site..."
    go run main.go

Let's build our site by running make site

This should have generated our assets and index.html at the root of our project.

If we open our html in a default browser we could see the result of it.

Deploying with GitHub Pages

Now that our site is built, let's deploy it using GitHub Pages.

Follow the steps below:

Push code to a GitHub repository:

Ensure that all your changes, including the generated index.html and assets, are committed to your repository.

Push the changes to your GitHub repository using the following commands:

 git add --all
 git commit -m "Deploy my site"
 git push origin main

Set Up GitHub Pages:

Navigate to your repository on GitHub.
Go to the Settings tab.
Scroll down to the Pages section on the left-hand side.
In the Source section, select the branch main.
Choose the root folder (/) as the source directory for your site.
Click Save.

Wait for Deployment:

After saving, GitHub Pages will automatically start building your site.
You should see a notification on the Pages section that your site is being deployed.
Once the deployment is successful, you will be given a URL where your site is hosted.

Access Your Site:

Visit the URL provided by GitHub Pages to see your live site.
The URL usually follows the pattern https://<username>.github.io/<repository-name>/.

Quick Note: If you want GithubPages to serve to https://yourusername.github.io you must name your repository yourusername.github.io

Conclusion

There it is, this is how I've built my self a static site.

You can find the source code for this article is here.

Hope this can be useful for some of you. 😀

See you soon 👋🏼

Build a desktop app with Wails & Vue

Lucas Neves Pereira — Tue, 10 Aug 2021 18:23:14 +0000

Hi everyone!
In this post I want to show how to quickly setup a desktop app using this amazing Go library Wails.

Basically, Wails allows to write desktop softwares using web technologies like Angular, React, Vue, Svelte..

Installing Wails

Getting started with this library is quite easy, if you have all the prerequesites you just need to run a go get to install it in your local machine, if you need details this is going to add wails to the pkg directory of your GOPATH.

Go ahead and run the following command:

go get -u github.com/wailsapp/wails/cmd/wails

Once you've installed it you can run wails init to create a new wails application.

How Wails work

Normally, the wails init command prompt you some questions like the name of your app but also the frontend tecnhology you want to use.

I've named my app randomapp and I am choosing VueJS as a frontend framework.

This is going to generate all the files you need to get started.

What I found very cool is the way that wails allows you to connect your backend logic to your frontend.

There is a wails function named bind that does all the work for you as you can see in their example when you open main.go.

Here app.Bind(basic) is binding the basic function, and we can access it from the frontend.

Let's serve the application so I can show you how, for development the best way to serve this app is by open two terminal windows.

One placed in the root of the project to run the backend with the following command:

wails serve

And a second one placed in the frontend directory to run the frontend with the following command:

npm run serve

Now if we visit http://localhost:8080, we can see our application

Good! Let's open a console in our browser to fetch that backend data by simply calling backend.basic().

We can see that we have access to our basic function binded from the backend that returns a "Hello, World!" string.

That's basically how things work with Wails. Now let's put all of this in practice and build a random application.

Build the actual application

Backend

Starting from the backend I'll get rid of the basic bind and function. Also I'll add a resizable option set to true in wails.CreateApp config so that our window later can be, well, resizable 🙂.

So, instead of that basic function I'll create a very simple package that I will name server with a server.go file.

There I'll create a struct and a New function to return an instance of my server struct.

Next, I'll add to that a receiver function of Server that will just return some random data.

Now the last step is to bind this using app.Bind in our main.go file.

That's all we have to do for the backend data, we have kept it simple.

Frontend

Let's jump now to our frontend directory that is a VueJs app with some components already in place, we have a Home and an About page.

I want to keep it simple so I'll delete the components, store and views folders. We only need the App.vue.

Make sure to remove the unnecessary html tags from App.vue and to remove the use(store) and use(router) from the create app mount function in the main.js file.

Okay, next let's add a button to our template with a click event binded to a fetchData.

That fetchData method will call our backend as we did in the browser console previously. To the that we use window.backend and the we have access to our Server (because we bind it 💪🏻) and it's GetRandomData() function.

The result from GetRandomData will be assigned to a template variable and the work is done!

Let's package of our code to test this out as a desktop app.

Package the final application

The final step is to simply package the application, or build the desktop app ready to use.

For that we can stop the process running in our terminal windows for development and instead run the following command in the root of our project:

wails build -p

Now if you go to the build directory of your project you have a .app or .exe depends on what operating system you are using.

You just have to open it and test our application!!

*Quick Note: * I've changed the colour property in main.go to have a white background and then run wails build -p again 🙂

Seems to work just fine 👍🏼

Conclusion

That's it for this post, you now have an idea on how you can build your next desktop application using this Golang framework.

Hope this will be helpful 😀

See you soon 👋🏼

SQL Migrations with Cobra & Golang Migrate

Lucas Neves Pereira — Tue, 04 May 2021 18:04:41 +0000

Hello dear readers, lately I've been struggling to run database migrations in Golang with sqlite3 but I have found a solution and I want to share it with you guys.

Let's do this

Start by creating a simple project Golang project in your computer

mkdir migration-cli
cd migration-cli
go mod init migration-cli

Then get the cobra package

go get -u github.com/spf13/cobra

Open this in your favourite code editor and create and add a main.go file

Adding Cobra

We are going to start by creating a package cmd with a root.go file.

There we are going to setup a root command for our cli using cobra of course. The name of this cli will be mcli for example purposes.

SubCommands

Let's create a subcommand named migrate that will have a another up and down subcommand.

migrate.go will be a very simple file, it is like a subroot command that is added to the root command 🙂

Now we can create migrateUp.go and migrateDown.go that are subcommands for migrate. The difference is that up and down will have an extra Run cobra property where we are going to write the actual logic to run our migrations.

To finish setting this up, in our main.go we need to call Execute() from our cmd/root.go file.

To test if the commands are called you can either build your program with a custom name and then call it

go build -o mcli
./mcli migrate up

or for now just use go run

go run main.go migrate up

Setup Database

I'll be using sqlite3 for the database, I'm gonna start by creating a database package with a config file.

In that config file I'll write a Open method that will return an instance of my database.

For that I'll need the sqlite3 driver package

go get -u github.com/mattn/go-sqlite3

Now we can call database.Open() in our migrate subcommands to test the database connection.

go build -o mcli
./mcli migrate up

It's working and as you can see it created a myDB file.
I will open this file in DB Browser for Sqlite that is a GUI for SQLITE.

Okay we know how to open our database let's write our migrations.

Migrations

In a new directory migrations I am going to create a 1_install.up.sql file and a 1_install.down.sql, this syntax will allow golang migrate to know the version of our migration file as well as the action.

Now let's add golang migrate

go get -u github.com/golang-migrate/migrate/v4

Back to migrateUp.go we are going to write the logic to run our up migration using golang migrate package.

Let's build the program and run ./mcli migrate up again to test this 🙂

Seems to be working, if we open the myDB file in DB Browser for Sqlite again we should see our tables.

Perfect! Now let's do the same thing for migrate down the logic is basically the same but instead of call the golang migrate built in func Up() we call Down().

Let's test migrate down 👍🏼

Now if you open your myDB file again our tables should be gone.

Conclusion

Okay, that's it! I hope this article will help 😀
The code source is here.
Youtube video here.

See you soon 👋🏼

Implementing testing in Golang

Lucas Neves Pereira — Sat, 01 May 2021 09:39:54 +0000

Hello dear readers, being a Junior to Mid Developer myself I've been of course faced to this weird "fear" of testing my code. Maybe it isn't fear, maybe we just do not talk much about it.

But either way I've been recently learning to program in Golang and I want it to do it seriously, in the right way. That's why this time I did not skip the tests subject.

In this article I want to show how easily testing our code can be, it is not an effort, specially with the testing standard package incorporated in Go.

As an example I am going to implement and test a method that checks if a phrase is a heterogram or not.

An heterogram is basically a word that doesn't contain a repeating letter. However it can contain multiple spaces or symbols like hyphens (-).

Let's get into it! Writing our first test

I've started by creating a Golang app using go modules,go mod init my app. Then i've created a package heterogram containing anheterogram.gowith an IsHeterogram() method and also I've created anheterogram_test.gofile for our testing functions. Finally a main.go file where I could possibly import my heterogram method to run it.

In our heterogram_test.gofile let's import the golang testing package and create a function TestIsHeterogram, passing in parameter a pointer to the struct T of that package to manage test state and support formatted test logs. We're going to define an input that is the string we want to check and also what we excepect of it.

For example, the string (input) toto is expected to return false because the "o" letter is present 2 times.

So if IsHeterogram("toto") returns false the test passes and if it returns true the tests fails.

Now to start using this very simple test we need to actually start implementing our heterogram method.

Implementing Heterogram algorithm

As you may have guessed our method is going to receive a string in parameter, we then are going to to loop trough that string and check each character. We are using the range keyword in our loop that returns a rune , that is basically a superset of the ASCII table that can handle more characters. We are going to append each character (runes) to a slice named exists to store the existing letters.

Now we need to check if the following character (rune) of our loop is present in our slice exists, if it is then we return false. For that we are going to write another helper function that we are going to call simply contains(). This method is going to loop trough a slice of runes and check if a rune is present or not.

Now back to IsHeterogram() we can check if a character of our string is already in the exists slice. If it does exists then we return false,if not at the end of our loop our method is going to return true.

Let's go back to our test function and run it. To run a test simply run go test inside of the heterogram package (cd into that folder) or use your IDE to run it.

We can see that our test has passed. Now let's try something, let's see if our method is well tested, change the input from "toto" to "Alpha" and run the test again. The world "Alpha" has two "a" so the test should pass right ? It should return false.

Well as we can see it has failed, the result for "Alpha" is true. And this shows that our method IsHeterogram is not finished, we didn't handled the uppercase letters. See how testing can improve our development ?\
Let's quickly fix our method by lowercase all of our inputs using the package strings.

Okay perfect, what if we wanted to test the case of "six-year-old" for example, remember that hyphens (-) are allowed. Well we could change again the input variable but let me show a better way to handle multiple test cases 🙂.

Add multiple test cases

We have tested both "toto" and "Alpha" but now we also want to test double hyphens with "six-year-old" that should be true and maybe an empty string as well "" that should be true too. We are starting to have multiple cases to test and instead of changing manually let's create a case_test.go file in our heterogram package where we can store this test cases.

We are going to do this by defining a struct with 3 fields: description, input and expected. We are going to pass in as many cases as we want. Then all we have to do is go back to our TestHeterogram function and replace the previous code by a for loop that ranges our struct of cases.

See how simple our test file looks now. We can run all our tests cases in a single time.

Before running go test one last time let's fix our IsHeterogram method to handle double hyphens. To do this before before checking if the exists slice contains our letter I am going to check if it is actually a letter by using the unicode package.

Okay now we are ready hit that go test one final time and all our tests should pass 🙂.

Conclusion

Thank you all for reading this article, if you have any questions don't hesitate to contact me. For those of you who are more visual learners I've filmed a video about this you can go check it out here 😀.

See you soon ! 🙂

Gituser CLI - Switch between git accounts easily

Lucas Neves Pereira — Fri, 16 Apr 2021 18:51:37 +0000

Hello there 🙂

First of all you all may be wondering "What in the world is gituser??"

Gituser is a command line interface made with Golang that helps to switch between different git user accounts.

I have built this cli because I was using my laptop for my personal projects, my school projects and my work related projects. Meaning I had multiple git user accounts in my machine.

Every time I had to type the following command:

git config --global user.name "myUserName"
git config --global user.email "myEmail"

This may not be the need of a lot of developers but I've decided to put this program as open source in case other developers need it. You can find the project here as well as the contribution guide I have wrote.

Being a newbie to golang and open source projects I think that this program as a lot of room for improvement.

Usage

Gituser can be use globally in your machine, that's the point of cli tools I guess 😀 , therefore there is a few steps that you need to make like exporting variables on your PATH, I have also wrote a guide about how to proceed on MacOS. You can find it here. I know that this can be improved but I just don't have enough experience about building "installers".

Once you have the tool on your machine you can test it out by running gituser on a terminal.

This will print you a manual.

Modes

There are currently 3 modes available in the program:

💻 work : for a work related git account.
📚 school : for a school related git account.
🏠 personal : for a personal related git account.

You can run gituser -now to see what mode you are using.

To switch from a mode to another you just have to run gituser <mode>.

Examples:

gituser work
```

gituser school

gituser personal




## Data configuration

The modes are cool but we need to actually add our multiple git accounts data to our program. 

To do so you just have to run:

gituser config




This will prompt you to a select where you can choose what mode account you want to configure.

![Screenshot 2021-04-16 at 20.42.19](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8kejmc9kmldt6qlq6l0s.png)

After choosing your mode you just have to enter your username and email of the related git account.

![Screenshot 2021-04-16 at 20.43.49](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y5gp0pqqb6bufnuwkkfx.png)

This will then write your data to a local ``data.json``file that you normally exported to your PATH if you followed the [installation guide](https://github.com/lucasnevespereira/go-gituser/blob/main/MACOS_PATH.md) 👍🏼

## Conclusion
That's basically what I have for now! You can use **gituser**   and test it out.

Hope this helps developers that have the same need as I. Feel free to leave some remarks, I know there is a quite of them. Once again I am very new to this world 😀.

Find the [project here](https://github.com/lucasnevespereira/go-gituser).

See you soon! 👋🏼

Write a Simple REST API in Golang

Lucas Neves Pereira — Tue, 13 Apr 2021 17:35:37 +0000

Hello there 😀

In this brief article I will explain how I write a REST API using Golang trying to follow some best practices.

The source code to follow along if needed is here.

Let's do this 👍🏻

As an example we'll be creating a very simple Post API.

Structure the project

Let's jump to our terminal and create a new directory for our project and then init a go module.

mkdir postapi
cd postapi
go mod init postapi

Note: Best practice for module naming is to use <domain>/<nameOfApp>

Now that we have this let's open our project in our favorite code editor and create a main.go file with a package main. This will be the entry point of our application.

Next, create a package app with a app.go file

Inside of it we are going to create an ** App struct** that will represent the structure of our app. There will be two fields on this struct, our app is going to have a DB and a Router.
The router will be a gorilla/mux router, so let's go ahead and and import it:

go get -u github.com/gorilla/mux

Let's add it to our struct

Now we are gonna create a New() func that will be in charge of returning the actual application based on our struct.

Now in our main.go file we can call this function and create a new app.

Okay, the entry point of the app is structured, let's continue with the routing.

Routing

Let's use the Router of our App that we defined before to implement basic routing.
In our app.go file we are going to create an InitRoutes func that will be called inside of our New() func when we create the application. This function will be a receiver of our App. Actually a lot of our methods we will be receivers from our app from now. Since our Router fields in our struct App is of type gorilla/mux router we have access to it's methods.

Let's very quickly replace the nil with a simple handler for our index route. For that create a handlers.go file in our package app. This is where we are going to store the handlers for our routes. I am going to create an IndexHandler() handler that will return an http.HandlerFunc printing a response "Welcome to Post API".

Now let's call this handler in our route.

Perfect, to test this out, we need to go back to the main.go file to serve the app on a port of our choice and the redirect it to our app Router. Also I've made a check function to print help with error handling.

Ok, now we can run our app with go run main.go and curl the endpoint to see if we get a response.

curl http://localhost:9000

Cool, routing seems to be working!

Database

It is time to setup our database, I have chosen to go with PostgreSQL, to avoid local setup I'll be running my database on a Docker container.

I'll be using the following command:

docker run --name postapidb --env POSTGRES_PASSWORD=postgres -p 5432:5432 -d postgres

Note: To stop you just need to run docker stop postapidb and to remove it docker rm postapidb

Okay, now we have a database running let's jump to the code and create a new package database inside of our app package.

Let's create a db.go file and inside we are going to have an interface. I am going to call it PostDB, this interface it's like a contract (methods to implement) that we have to respect if we want our database to be a PostDB database. Let's start by saying that a PostDB should implement a Open() and a Close method that can return an error.

We are also going to have a DB structure like for our app that will have a single field db of type sqlx DB that is like a superset of database/sql from the Go standard library. Let's run a go get for sqlx and lib/pq (postgres sql driver) and then implement this.

go get -u github.com/jmoiron/sqlx
go get -u github.com/lib/pq

Now before writing the body of our Open() and Close() we can add a database fields to our App struct in app.go saying we are using a PostDB in this app 🙂

Moving on, starting with our Open method let's open a new connection to our postgres database.

To establish this connection, the second argument of the sqlx.Open() method is a postgres connection string. Let's build this string in a seperate file called config.go still in the database package.

Another thing I want to do is create a SQL schema that will be run after the connection. This schema will just create a table posts in our db in case there is not one. Let's add this to a schemas.go file.

Our Close method will be a lot simpler. We just need call the method Close from sqlx

Before writing some methods for our data, let's jump to the main.go file and init the connection to the database.

Let's run go run main.go

The database is configured but is not quite finished because I want to implement some methods (like CreatePost and GetPosts) but for that we first need a Post Model.

Models

Go ahead and create a new package models inside of the app package and create a post.go file. Inside of it we are going to have a Post struct with 4 fields.

Since this is a REST API we are later going to be mapping our responses to JSON and sometimes the fields from our database might not correspond to our json fields or maybe we want to have flexibility to add new fields or remove fields.
For that, let's already create a JsonPost struct to our file.

Last thing I want to add to this file is going to be useful in a few seconds. When we add a post to our database the ID is auto incremented, meaning we do not have to pass the ID when making a request to create a new post. So let's create a PostRequest struct for that.

Back to our database in our db.go file I want to add 2 methods to my PostDB interface, GetPosts and CreatePost.

Note: I'll not be implementing all the REST verbs endpoints (trying to keep it short) just a simple GET and POST.

In our schemas.go file I want to add a simple insertPostSchema for my CreatePost method.

Let's create a methods.go file and write our methods.

Http Handlers

Now that we have all of our methods to interact with our database, let's write our http handlers as we did before for the IndexHandler. In our handlers.go file let's start with the CreatePostHandler.

What we are going to do is initialize an empty PostRequest struct, the parse the request body that the user entered to that struct. To parse or map the request body I am going to write a helper func named simply parse that I will put in a helpers.go file.

Once again, this is a REST API so it is good practice to send a http status. We are going to send a lot of responses with an http status, so I will write another helper func for this in the helpers.go file that sends a JSON response with a status.

By the way, remember we had a JsonPost struct in case we want that flexibility? Let's add a last helper function (helpers.go) just to map data to that struct.

Continuing with the CreatePostHandler, now that we have parsed the request body we need to use that data to create a new post and save it in our database.

Now to finish the CreatePostHandler we just have to create a new route in our func initRoutes from our app.go file and call our handler.

Run go run main.go again and let's test this on Insomnia.

Seems to be working 👍🏻

Before moving on to tests let's implement GetPostHandler that should be simpler.

Relaunch the app

Test with insomnia

Perfect, this is working 🙂

Tests

It is also very good practice to test our code, that's why we need to try to add test coverage to our app. For that you can create a test package and add a test file for what you want to test, for example handler_test.go or db_test.go.

I have actually made a video and wrote an article about implementing tests in Golang so you can can check those out 🙂

Conclusion

That's it! I am going to stop this article here, I know there is room for improvement but I wanted to keep this short and just talk about the foundation.

As always don't hesitate to give me feedback, the role of a developer today is to keep improving and that's what I want to do 🙂

Don't hesitate to check my Youtube Channel, you can also contact me on my twitter account and of course I will link the github repository for this article.

See you soon! 👋🏻