bagashiz/go-pos

Simple RESTful Point of Sale (POS) Service API written in Go using Gin web framework, PostgreSQL database, and Redis cache. Proof of concept of implementing Hexagonal Architecture in Go.

Go POS

Description

A simple RESTful Point of Sale (POS) web service written in Go programming language. This project is a part of my learning process in understanding Hexagonal Architecture in Go.

It uses Gin as the HTTP framework and PostgreSQL as the database with pgx as the driver and Squirrel as the query builder. It also utilizes Redis as the caching layer with go-redis as the client.

This project idea was inspired by the Ide Project untuk Upgrade Portfolio Backend Engineer video on YouTube by Asdita Prasetya, which provided valuable guidance and inspiration for its development.

Getting Started

1. If you do not use devcontainer, ensure you have Go 1.23 or higher and Task installed on your machine:

   go version && task --version

2. Create a copy of the .env.example file and rename it to .env:

   cp .env.example .env

   Update configuration values as needed.

3. Install all dependencies, run docker compose, create database schema, and run database migrations:

   task

4. Run the project in development mode:

   task dev

Documentation

For database schema documentation, see here, powered by dbdocs.io.

API documentation can be found in docs/ directory. To view the documentation, open the browser and go to http://localhost:8080/docs/index.html. The documentation is generated using swaggo with gin-swagger middleware.

Contributing

Developers interested in contributing to Go POS project can refer to the CONTRIBUTING file for detailed guidelines and instructions on how to contribute.

License

Go POS project is licensed under the MIT License, providing an open and permissive licensing approach for further development and usage.

Learning References

• Hexagonal Architecture by Alistair Cockburn
• Ready for changes with Hexagonal Architecture by Netflix Technology Blog
• Hexagonal Architecture in Go by Matias Varela

go-pos's Issues

feat(order): domain, service, repo, and handler

title.

test(product): add product service unit test

unit testing stuff

feat(user): domain, service, and repo

core business logic and stuff, you know the drill

test(category): add category service unit test

implement unit test for category service.

feat(category): domain, service, repo, and handler

title.

fix(ci): update golangci lint timeout

Naming convention in Hexagonal architecture

Hi,

I took a look at your article about Hexagonal architecture, and I really appreciate your effort.

I was wondering If we could rename CacheService into CacheRepository since it's implemented inside the Adapter layer and the Core layer is using it?

type CacheService interface {
	// Set stores the value in the cache
	Set(ctx context.Context, key string, value []byte, ttl time.Duration) error
	// Get retrieves the value from the cache
	Get(ctx context.Context, key string) ([]byte, error)
	// Delete removes the value from the cache
	Delete(ctx context.Context, key string) error
	// DeleteByPrefix removes the value from the cache with the given prefix
	DeleteByPrefix(ctx context.Context, prefix string) error
	// Close closes the connection to the cache server
	Close() error
}

Is there a general rule in this architecture, stating that any interface provided by the Core layer should have a name ending with Service and anything else provided by the Adapter Layer to end with Repository? I'm specifically thinking about interfaces residing inside the Port directory.

bug(user): update user service requires all column to update

use postgres' coalesce function and sql.NullString to implement partial update.

docs: API documentation

use swagger or postman idk

feat(deploy): containerized

dockerrrrr babyyyyy

feat(core): setup domain and ports

i'm feeling hexagonal today

feat: better logging

slog package implementation for gin http server.

https://github.com/samber/slog-gin

refactor: domain error

domain error should be put inside domain package, not port.

feat: embed db migration files

this image could be smaller

refactor: tidy up

tidying some code

Domain != Presentation

I really l liked your architecture - but intent of a domain is to be agnostic to outside world, and why do we have a key-word like json in the domain struct?

go-pos/internal/core/domain/category.go

Line 7 in f17b11a

ID uint64 `json:"id"`

test(user): add user service unit test

implement user service unit test.

feat(product): domain, service, repo, and handler

title.

refactor(order): improve order service

dont have time for unit testing so just refactor

test(payment): add payment service unit test

unit something test yada yada

feat: use config container

with so much env variables to store, why not use config container such as viper.

refactor: rewrite using gorm package

I gave up and just use ORM

docs: add more response

// adminMiddleware is a middleware to check if the user is an admin
func adminMiddleware() gin.HandlerFunc {
	return func(ctx *gin.Context) {
		payload := getAuthPayload(ctx, authorizationPayloadKey)

		isAdmin := payload.Role == domain.Admin
		if !isAdmin {
			err := port.ErrForbidden
			handleAbort(ctx, err)
			return
		}

		ctx.Next()
	}
}

need to add 403 forbidden

refactor: tidy up

clean the smelly code🤮

test: implement unit tests

title.

refactor: cleaning up & restructure

after learning some best practices and reviewing my code, I decided to do some refactoring.

feat(db): setup db repository

create query repository with sqlc.

feat(user): implement authentication & authorization

use JWT or something idk

feat(payment): domain, service, repo, and handler

next one is payment.

chore(workflow): add devcontainer

I start playing around with devcontainer recently, because why not

Migrate from paseto

Hi. You are using the paseto library in your project, but it has not been supported for more than two years. It's not very safe, it's best to use another library.

feat(db): setup database migrations

create database migration files based on schema defined in schema.dbml.

suggestion

Hi,

I think this example would be improved if it didn't have an anemic domain model, read about it here https://en.wikipedia.org/wiki/Anemic_domain_model

I'm saying this since your domain only contains the structs for your models without any business logic at all

This is just a suggestion you didn't ask for, so take it with a grain of salt :)

feat(cache): implement redis

use redis for caching data

fix: error response not error responding

current:

should have been: