Day 50 to 60 - New year, clear horizons
Day 50 - Half way through!! - 10/01/2025
To start off the year officially, and with all my previous steps/projects already finished, I am now learning how to code a MySQL CRUD API. For this task I am also using the local Debian 12 VM I did set up for the database connection tutorial.
Here it is my current initial code:
package main
import (
"database/sql"
"log"
"net/http"
"github.com/go-sql-driver/mysql"
)
type Album struct {
ID int
Title string
Artist string
Price float32
}
func main() {
cfg := mysql.Config{
User: "mysqlu", //This value were hardcoded
Passwd: "pwd", // this one too
User: os.Getenv("DBUSER"),
Passwd: os.Getenv("DBPASS"),
Net: "tcp",
Addr: "192.168.1.134:3306",
DBName: "MUSIC",
}
r := http.NewServeMux()
r.HandleFunc("GET /albums", getAlbums)
log.Print("Starting server on port :8080...")
log.Fatal(http.ListenAndServe(":8090", r))
}
func getAlbums(w http.ResponseWriter, r *http.Request) {
// Get a database Handle -- Initialize DB connection
db, err := sql.Open("mysql", cfg.FormatDSN())
if err != nil {
log.Fatal(err)
}
}
Day 51 - 12/01/2025 && 14/01/2025
More methods! I got the Read method for my CRUD API done as well as the Create one! Here are the functions isolated. Wanna check the code?
func getAlbums(db *sql.DB) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var albums []Album
rows, err := db.Query("SELECT * FROM Albums")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer rows.Close()
for rows.Next() {
var alb Album
if err := rows.Scan(&alb.ID, &alb.Title, &alb.Artist, &alb.Price); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
albums = append(albums, alb)
}
if err := rows.Err(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
if len(albums) > 0 {
if err := json.NewEncoder(w).Encode(albums); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} else {
w.Write([]byte("No albums found"))
}
}
}
func addAlbum(db *sql.DB) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var alb Album
err := json.NewDecoder(r.Body).Decode(&alb)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
result, err := db.Exec("INSERT into Albums VALUES ((select max(ID)+1 from Albums a),?, ?, ?);", alb.Title, alb.Artist, alb.Price)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
id, err := result.LastInsertId()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
alb.ID = int(id)
json.NewEncoder(w).Encode(alb)
}
}
/*
curl http://localhost:8090/albums/add \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"Title": "The Modern Sound of Betty Carter","Artist": "Betty Carter","Price": 49.99}'
*/
Day 52 - 16/01/2025
More functionality for the API! This time, I implemented (and tested) the Update method, as of now it went pretty much as reviewing other API examples and imitating the Insert function from before.
func updateAlbum(db *sql.DB) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var alb Album
err := json.NewDecoder(r.Body).Decode(&alb)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
_, err = db.Exec("UPDATE Albums SET Title = ? WHERE ID = ?", alb.Title, alb.ID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
}
/*
curl http://localhost:8090/albums/update \
--include \
--header "Content-Type: application/json" \
--request "PUT" \
--data '{"ID" : 9,"Title": "Test"}'
*/
The expected behavior is to parse the curl request with a JSON body and take the values as arguments for the UPDATE statement.
Day 53 - 17/01/2025
Making the last basic functionality for the CRUD API has been more complex, at first I expected it to be really similar to the UPDATE method, but for the DELETE one, it required me to check about HTTP methods and other MySQL APIs workarounds, yet I ended up asking to the community and here it is the end up result:
func deleteAlbum(db *sql.DB) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var alb Album
err := json.NewDecoder(r.Body).Decode(&alb)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
_, err = db.Exec("DELETE FROM Albums WHERE ID = ?", alb.ID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusNoContent)
}
}
/*
-- REQUIRES TO AVOID ESCAPING LINES
curl -X DELETE http://localhost:8090/albums/delete -H "Content-Type: application/json" -d '{"ID" : 8}'
*/
It is worth mentioning that it took quite some time to make this work, because of a rather funny (or exhausting) mistake, since the new lines were escaped, it didn’t interpret the instruction properly, once it was placed on a single line, the curl command worked.
Overall I know that this is a pretty basic API, I could add more specific INSERT statements as well as UPDATE or DELETE ones, so I prefer to pivot into a new project, or rather a new approach to the same one.
Days 54 - 55 - 56 - 18/01/2025 - 22/01/2025 - 30/01/2025
After spending time coding and finishing some projects, I’ve been investing the last two week (Just pointing three days because is a rather more justified and not unfair way to show how much time I’ve spent on this) looking around for which project to commit to next, for which I stumbled upon htmx and website projects. The core idea is to develop a mutable html file with more flexible components, and during this journey, refresh some of my knowledge with web development, may be even expanding to know the basics of a framework such as Tailwind CSS.
In any case, just to not go too far and lose track of the scale of this project, I will stick as much as I can to a project concept and keep things simple aesthetic-wise.
Some resources I found & stored along the way:
Codez Up - Creating a real-time chat application with Golang and Websockets
Medium - Simple chat application with Golang and Websocket
Youtube - Generic search for chat application with Golang
Package main - Youtube channel
Alongside other go-related yet just for curiosity articles
Day 57 - 05/02/2025
Today I took a breather of preparing my next project and went ahead about finishing the App Engine introductory labs for Google Cloud, this is of importance to me since one of them included the Golang language, which could lead for future options of deploying microservicies on a cloud provider. This also helped to refresh how to use the GCP component in on itself.
On the other hand, I was also able to finish the initial setup for my local proxmox server to be remotely managed via Ansible. Also deployed a simple Rocky Linux server with Docker and Portainer onto it.
Day 58 && 59 - 10/02/2025 && 15/02/2025
Today I took a turn over…yet again. This time I totally ditched the idea of a chat application (for now), but, as of today, the idea is still to learn about Golang alongside Htmx for its webdev capabilities. More specifically I am planning onto taking advantage of my current Backend API and prepare a simple frontend so, once I get everything done, I could create a fully functional microservice environment with three containers or Apps separated from one another (Backend service, Frontend site and Database).
Here are some more resources I’ve found for the development of this frontend part.
Get Started With Golang Echo + HTMX
Day 60 - 61 - 62 - 22/02/2025 - 2/03/2025 - 09/03/2025
Keeping things straight, today I’ve started learning Templ as it is a requirement for the stack I’m aiming for. Even so, I have a base site with some tests I’ve made with a functional template-like workflow.
I continued moving around and at some point started mixing things up, thing is, Templs is just one of the multiple options to work with templates, and at the time of writing I was mixing text/template package from Go’s default library and Templs possibilities within a scoped project that aimed to learn about Templ all at once, given that I was wrongly understanding my progress, I wiped the project idea, with a single technology in mind, might not be as fancy as Templ, but it is included within Go by default and should make things easier.
I’m talking about html/template package. Source
Now I will keep on learning more about its possibilities and how to implement HTMX within it. After some time, I got a simple operational state that gets me a simple map being displayed only if I press a certain button.
Current Go code:
package main
import (
"fmt"
"html/template"
"log"
"net/http"
)
type Disc struct {
Title string
Group string
}
func main() {
fmt.Println("Hi")
// Initial page load
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
tmpl := template.Must(template.ParseFiles("index.html"))
// Initial data (empty or nil)
tmpl.Execute(w, nil)
})
// Handler for HTMX read request
http.HandleFunc("/read/", func(w http.ResponseWriter, r *http.Request) {
tmpl := template.Must(template.ParseFiles("index.html"))
// Fetch data (replace with database call)
data := getDiscsFromDB()
// Render only the partial template
tmpl.ExecuteTemplate(w, "discs-partial", data)
})
log.Fatal(http.ListenAndServe(":8080", nil))
}
// Simulate database fetch
func getDiscsFromDB() map[string][]Disc {
return map[string][]Disc{
"Discs": {
{Title: "From Zero", Group: "Linkin Park"},
{Title: "Scoring the End of the World", Group: "Motionless in White"},
},
}
}
Current index.html code:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<script src="https://unpkg.com/@tailwindcss/browser@4"></script>
<script src="https://unpkg.com/htmx.org@1.9.6"></script>
<title>Document</title>
</head>
<body>
<button class="flex-1 bg-green-500 text-white py-2 px-4 hover:bg-green-600"
hx-get="/read/"
hx-target="#discs-container">
Read
</button>
<div id="discs-container">
</div>
</body>
</html>
<div> by </div>
<div>No discs to display. Click "Read" to load.</div>
Day 63 - 64 - 17/03/2025 - 19/03/2025
Today I got a bit of a rough start, as I intended to implement a bit of a “Create” button, that should show a form, in order to perform the insert method over the database once it is submitted.
Now, to be clear, What do I want to do in the first place?: - Show “Create” and “Read” buttons at first time that the page loads - Once the Create button is clicked, clean the view and show a form to allow the user to insert data into the DB. - Once the Read button is clicked, clean the view and show the content of the DB.
I’ve not even reached the backend call yet, as my main goal is to prepare the frontend aspect of this API, given that once the first form shows just fine as intended, I’ll just need to tune the HTML part to adapt to the other two methods.