refacto: refacto repo layer code while adding new usecase methods

Makefile

@@ -46,7 +46,7 @@ format: # format code.
 
 .PHONY: add-copyright
 add-copyright: # add license to file headers.
-	@addlicense -v -f $(ROOT_DIR)/LICENSE $(ROOT_DIR) --skip-files=database.yml --skip-dirs=$(OUTPUT_DIR),deployment,migrations,configs,sqlc,web
+	@addlicense -v -f $(ROOT_DIR)/LICENSE $(ROOT_DIR) --skip-files=database.yml --skip-dirs=$(OUTPUT_DIR),deployment,migrations,configs,sqlc,web,mock
 
 .PHONY: swagger
 swagger: # Run swagger.

README.md

@@ -24,6 +24,8 @@
     - [2024/10/15](#20241015)
     - [2024/10/16](#20241016)
     - [2024/10/17](#20241017)
+    - [2024/10/18](#20241018)
+    - [2024/10/19](#20241019)
 <!--toc:end-->
 
 A tricount like expense-sharing system written in Go
@@ -519,3 +521,64 @@ is on my future learning plan!
 _I found it quite interesting that simply with SQL, we can simulate the most
 business logic. It is a must-have competence for software design and
 development._
+
+### 2024/10/20
+
+I was thinking that I should write test for `sqlc` generated code. And then
+I found out `gomock` and see how it is done in the project of
+`techschoo/simplebank`. It's a great tutorial project. It makes me questioning
+my own project's structure. It seems overwhelmed at least at the repo level.
+
+I don't actually use the sqlc generated object, instead I do a conversion to
+my `Retrieved` objects. But with some advanced configuration we could make the
+output of sqlc object directly usable. That will save a lot of code.
+
+The problem I saw here is the dependency on `sqlc/models`, and the model
+designed there has no business logic. Everything is done in the handlers
+and the handlers query directly the DB.
+
+More concretely, `sqlc` generates `RawJSON` for some fields that are embedded
+structs. So I have to do the translation somewhere.
+
+So I will just stick to the plan and keep going with the predefined structure.
+
+I have to figure out how to use the generated mock files.
+
+The goals for the next week is to finish the basic operations for each level
+and run some integration tests with `curl`.
+
+### 2024/10/22
+
+I am facing come difficulties on testing of the `repo` functions.
+
+First, I have to keep the business logic in the service layer. That means I
+have to create the transaction at the service layer. I don't need to depend
+on the implementation detail. So I have created a Transaction interface.
+
+I don't care of the type of `tx` because I will pass it to repo layer and I
+suppose that it knows what it is doing. Considering this, my repo `Create`
+function will have to take an any and deduct the type of `tx`. So the layer
+becomes untestable, because I have to pass a *sql.Tx into it and create a
+querier.
+
+Since this repo layer is just a wrapping layer between the `sqlc.models` and
+my own models, I can extract the conversion part to functions and test them.
+I'm not testing the whole thing but I test what I can.
+
+### 2024/10/24
+
+When writing the tests. I am asking myself the differences between `[]T`,
+`[]*T` and `*[]T`.
+
+`*[]T` is simple, it is a reference to the original slice. So modifying it
+means modifying the original slice.
+
+But between `[]*T` and `[]T`, the only difference that I see (pointed out by
+`ChatGPT`) is how the memory is allocated. With `[]T` it might be better for
+the GC to deal with the memory free. I thing for my project I will stick to
+`[]T`.
+
+### 2024/10/25
+
+Read this [article](https://konradreiche.com/blog/two-common-go-interface-misuses/)
+today, maybe I am abusing the usage of interfaces?

go.mod

@@ -18,7 +18,7 @@ require (
 	github.com/stretchr/testify v1.9.0
 	go.uber.org/zap v1.27.0
 	golang.org/x/crypto v0.27.0
-	golang.org/x/net v0.25.0
+	golang.org/x/net v0.26.0
 )
 
 require (

go.sum

@@ -153,8 +153,8 @@ golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
 golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
-golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
+golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
 golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/howmuch/adapter/repo/db.go

@@ -25,7 +25,9 @@ package repo
 import (
 	"context"
 	"database/sql"
+	"time"
 
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/adapter/repo/sqlc"
 	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/usecase/repo"
 	"git.vinchent.xyz/vinchent/howmuch/internal/pkg/log"
 )
@@ -34,6 +36,8 @@ type dbRepository struct {
 	db *sql.DB
 }
 
+const queryTimeout = 3 * time.Second
+
 func NewDBRepository(db *sql.DB) repo.DBRepository {
 	return &dbRepository{
 		db: db,
@@ -66,3 +70,11 @@ func (dr *dbRepository) Transaction(
 	data, err := txFunc(ctx, tx)
 	return data, err
 }
+
+func getQueries(queries *sqlc.Queries, tx any) *sqlc.Queries {
+	transaction, ok := tx.(*sql.Tx)
+	if ok {
+		return sqlc.New(transaction)
+	}
+	return queries
+}

internal/howmuch/adapter/repo/event.go

@@ -0,0 +1,276 @@
+// MIT License
+//
+// Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"time"
+
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/adapter/repo/sqlc"
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/model"
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/usecase/repo"
+	"git.vinchent.xyz/vinchent/howmuch/internal/pkg/log"
+)
+
+type eventRepository struct {
+	queries *sqlc.Queries
+}
+
+func NewEventRepository(db *sql.DB) repo.EventRepository {
+	return &eventRepository{
+		queries: sqlc.New(db),
+	}
+}
+
+// Create implements repo.EventRepository.
+func (e *eventRepository) Create(
+	ctx context.Context,
+	evEntity *model.EventEntity,
+	tx any,
+) (*model.EventEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	event, err := queries.InsertEvent(timeoutCtx, sqlc.InsertEventParams{
+		Name:            evEntity.Name,
+		Description:     sql.NullString{String: evEntity.Description, Valid: true},
+		TotalAmount:     sql.NullInt32{Int32: int32(evEntity.TotalAmount), Valid: true},
+		DefaultCurrency: evEntity.DefaultCurrency,
+		OwnerID:         int32(evEntity.OwnerID),
+		CreatedAt:       time.Now(),
+		UpdatedAt:       time.Now(),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &model.EventEntity{
+		ID:              int(event.ID),
+		Name:            event.Name,
+		Description:     event.Description.String,
+		TotalAmount:     int(event.TotalAmount.Int32),
+		DefaultCurrency: event.DefaultCurrency,
+		OwnerID:         int(event.OwnerID),
+		CreatedAt:       event.CreatedAt,
+		UpdatedAt:       event.UpdatedAt,
+	}, nil
+}
+
+func convToEventRetrieved(eventDTO *sqlc.GetEventByIDRow) (*model.EventRetrieved, error) {
+	// marshal owner and users
+	var owner model.UserBaseRetrieved
+	err := json.Unmarshal(eventDTO.Owner, &owner)
+	if err != nil {
+		// Unexpected
+		log.ErrorLog("json unmarshal error", "err", err)
+		return nil, err
+	}
+
+	var users []model.UserBaseRetrieved
+	err = json.Unmarshal(eventDTO.Users, &users)
+	if err != nil {
+		// Unexpected
+		log.ErrorLog("json unmarshal error", "err", err)
+		return nil, err
+	}
+
+	eventRetrieved := &model.EventRetrieved{
+		ID:          int(eventDTO.ID),
+		Name:        eventDTO.Name,
+		Description: eventDTO.Description.String,
+		TotalAmount: model.MakeMoney(
+			int(eventDTO.TotalAmount.Int32),
+			model.Currency(eventDTO.DefaultCurrency),
+		),
+		DefaultCurrency: model.Currency(eventDTO.DefaultCurrency),
+		CreatedAt:       eventDTO.CreatedAt,
+		UpdatedAt:       eventDTO.UpdatedAt,
+		Owner:           &owner,
+		Users:           users,
+	}
+
+	return eventRetrieved, nil
+}
+
+// GetByID implements repo.EventRepository.
+func (e *eventRepository) GetByID(
+	ctx context.Context,
+	eventID int,
+	tx any,
+) (*model.EventRetrieved, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	eventDTO, err := queries.GetEventByID(timeoutCtx, int32(eventID))
+	if err != nil {
+		log.ErrorLog("query error", "err", err)
+		return nil, err
+	}
+
+	return convToEventRetrieved(&eventDTO)
+}
+
+func convToEventList(eventsDTO []sqlc.ListEventsByUserIDRow) ([]model.EventListRetrieved, error) {
+	events := make([]model.EventListRetrieved, len(eventsDTO))
+
+	for i, evDTO := range eventsDTO {
+		var owner model.UserBaseRetrieved
+		err := json.Unmarshal(evDTO.Owner, &owner)
+		if err != nil {
+			// Unexpected
+			log.ErrorLog("json unmarshal error", "err", err)
+			return nil, err
+		}
+		ev := model.EventListRetrieved{
+			ID:          int(evDTO.ID),
+			Name:        evDTO.Name,
+			Description: evDTO.Description.String,
+			Owner:       &owner,
+			CreatedAt:   evDTO.CreatedAt,
+		}
+
+		events[i] = ev
+	}
+
+	return events, nil
+}
+
+// ListEventsByUserID implements repo.EventRepository.
+func (e *eventRepository) ListEventsByUserID(
+	ctx context.Context,
+	userID int,
+	tx any,
+) ([]model.EventListRetrieved, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	eventsDTO, err := queries.ListEventsByUserID(timeoutCtx, int32(userID))
+	if err != nil {
+		log.ErrorLog("query error", "err", err)
+		return nil, err
+	}
+
+	return convToEventList(eventsDTO)
+}
+
+// UpdateInfo implements repo.EventRepository.
+func (e *eventRepository) UpdateEventByID(
+	ctx context.Context,
+	event *model.EventUpdateEntity,
+	tx any,
+) error {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	err := queries.UpdateEventByID(timeoutCtx, sqlc.UpdateEventByIDParams{
+		ID:          int32(event.ID),
+		Name:        event.Name,
+		Description: sql.NullString{String: event.Description, Valid: true},
+		UpdatedAt:   time.Now(),
+	})
+	return err
+}
+
+// GetParticipation implements repo.EventRepository.
+func (e *eventRepository) GetParticipation(
+	ctx context.Context,
+	userID, eventID int,
+	tx any,
+) (*model.ParticipationEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	partDTO, err := queries.GetParticipation(timeoutCtx, sqlc.GetParticipationParams{
+		UserID:  int32(userID),
+		EventID: int32(eventID),
+	})
+
+	if errors.Is(err, sql.ErrNoRows) {
+		// No error, but participation not found
+		return nil, nil
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &model.ParticipationEntity{
+		ID:              int(partDTO.ID),
+		UserID:          int(partDTO.UserID),
+		EventID:         int(partDTO.EventID),
+		InvitedByUserID: int(partDTO.InvitedByUserID.Int32),
+		CreatedAt:       partDTO.CreatedAt,
+		UpdatedAt:       partDTO.UpdatedAt,
+	}, nil
+}
+
+// InsertParticipation implements repo.EventRepository.
+func (e *eventRepository) InsertParticipation(
+	ctx context.Context,
+	userID int,
+	eventID int,
+	invitedByUserID int,
+	tx any,
+) (*model.ParticipationEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	var invitedBy sql.NullInt32
+	if invitedByUserID == 0 {
+		invitedBy = sql.NullInt32{Int32: 0, Valid: false}
+	} else {
+		invitedBy = sql.NullInt32{Int32: int32(invitedByUserID), Valid: true}
+	}
+	participationDTO, err := queries.InsertParticipation(timeoutCtx, sqlc.InsertParticipationParams{
+		UserID:          int32(userID),
+		EventID:         int32(eventID),
+		InvitedByUserID: invitedBy,
+		CreatedAt:       time.Now(),
+		UpdatedAt:       time.Now(),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &model.ParticipationEntity{
+		ID:              int(participationDTO.ID),
+		UserID:          int(participationDTO.UserID),
+		EventID:         int(participationDTO.EventID),
+		InvitedByUserID: int(participationDTO.InvitedByUserID.Int32),
+		CreatedAt:       participationDTO.CreatedAt,
+		UpdatedAt:       participationDTO.UpdatedAt,
+	}, nil
+}

internal/howmuch/adapter/repo/event_test.go

@@ -0,0 +1,122 @@
+// MIT License
+//
+// Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package repo
+
+import (
+	"database/sql"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/adapter/repo/sqlc"
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/model"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConvToEventRetrieved(t *testing.T) {
+	input := &sqlc.GetEventByIDRow{
+		ID:              123,
+		Name:            "event",
+		Description:     sql.NullString{Valid: false},
+		TotalAmount:     sql.NullInt32{Valid: false},
+		DefaultCurrency: "EUR",
+		CreatedAt:       time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		UpdatedAt:       time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		Owner:           json.RawMessage(`{"id":1, "first_name":"owner", "last_name":"owner"}`),
+		Users:           json.RawMessage(`[{"id":1, "first_name":"owner", "last_name":"owner"}]`),
+	}
+
+	want := &model.EventRetrieved{
+		ID:              123,
+		Name:            "event",
+		Description:     "",
+		TotalAmount:     model.Money{Amount: 0, Currency: "EUR"},
+		DefaultCurrency: model.Currency("EUR"),
+		CreatedAt:       time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		UpdatedAt:       time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		Owner: &model.UserBaseRetrieved{
+			ID:        1,
+			FirstName: "owner",
+			LastName:  "owner",
+		},
+		Users: []model.UserBaseRetrieved{
+			{
+				ID:        1,
+				FirstName: "owner",
+				LastName:  "owner",
+			},
+		},
+	}
+
+	got, err := convToEventRetrieved(input)
+	assert.NoError(t, err)
+	assert.Equal(t, want, got)
+}
+
+func TestConvToEventList(t *testing.T) {
+	input := []sqlc.ListEventsByUserIDRow{
+		{
+			ID:          123,
+			Name:        "event",
+			Description: sql.NullString{Valid: false},
+			CreatedAt:   time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+			Owner:       json.RawMessage(`{"id":1, "first_name":"owner", "last_name":"owner"}`),
+		},
+		{
+			ID:          456,
+			Name:        "event2",
+			Description: sql.NullString{String: "super event", Valid: true},
+			CreatedAt:   time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+			Owner:       json.RawMessage(`{"id":1, "first_name":"owner", "last_name":"owner"}`),
+		},
+	}
+
+	want := []model.EventListRetrieved{
+		{
+			ID:          123,
+			Name:        "event",
+			Description: "",
+			CreatedAt:   time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+			Owner: &model.UserBaseRetrieved{
+				ID:        1,
+				FirstName: "owner",
+				LastName:  "owner",
+			},
+		},
+		{
+			ID:          456,
+			Name:        "event2",
+			Description: "super event",
+			CreatedAt:   time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+			Owner: &model.UserBaseRetrieved{
+				ID:        1,
+				FirstName: "owner",
+				LastName:  "owner",
+			},
+		},
+	}
+
+	got, err := convToEventList(input)
+	assert.NoError(t, err)
+	assert.Equal(t, want, got)
+}

internal/howmuch/adapter/repo/expense.go

@@ -0,0 +1,267 @@
+// MIT License
+//
+// Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package repo
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"time"
+
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/adapter/repo/sqlc"
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/model"
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/usecase/repo"
+	"git.vinchent.xyz/vinchent/howmuch/internal/pkg/log"
+)
+
+type expenseRepository struct {
+	queries *sqlc.Queries
+}
+
+func NewExpenseRepository(db *sql.DB) repo.ExpenseRepository {
+	return &expenseRepository{
+		queries: sqlc.New(db),
+	}
+}
+
+// DeleteExpense implements repo.ExpenseRepository.
+func (e *expenseRepository) DeleteExpense(ctx context.Context, expenseID int, tx any) error {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+	return queries.DeleteExpense(timeoutCtx, int32(expenseID))
+}
+
+// DeleteTransactionsOfExpense implements repo.ExpenseRepository.
+func (e *expenseRepository) DeleteTransactionsOfExpense(
+	ctx context.Context,
+	expenseID int,
+	tx any,
+) error {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+	return queries.DeleteTransactionsOfExpenseID(timeoutCtx, int32(expenseID))
+}
+
+// GetExpenseByID implements repo.ExpenseRepository.
+func (e *expenseRepository) GetExpenseByID(
+	ctx context.Context,
+	expenseID int,
+	tx any,
+) (*model.ExpenseRetrieved, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	expenseDTO, err := queries.GetExpenseByID(timeoutCtx, int32(expenseID))
+	if err != nil {
+		return nil, err
+	}
+	expense, err := convToExpenseRetrieved(&expenseDTO)
+	if err != nil {
+		return nil, err
+	}
+	return expense, nil
+}
+
+func convToPayments(raw json.RawMessage) ([]model.Payment, error) {
+	var paymentsRetrieved []model.PaymentRetrieved
+	err := json.Unmarshal(raw, &paymentsRetrieved)
+	if err != nil {
+		// Unexpected
+		log.ErrorLog("json unmarshal error", "err", err)
+		return nil, err
+	}
+
+	payments := make([]model.Payment, len(paymentsRetrieved))
+	for i, p := range paymentsRetrieved {
+		payment := model.Payment{
+			PayerID:        p.PayerID,
+			PayerFirstName: p.PayerFirstName,
+			PayerLastName:  p.PayerLastName,
+			Amount:         model.MakeMoney(p.Amount, model.Currency(p.Currency)),
+		}
+		payments[i] = payment
+	}
+
+	return payments, nil
+}
+
+func convToBenefits(raw json.RawMessage) ([]model.Benefit, error) {
+	var benefitsRetrieved []model.BenefitRetrieved
+	err := json.Unmarshal(raw, &benefitsRetrieved)
+	if err != nil {
+		// Unexpected
+		log.ErrorLog("json unmarshal error", "err", err)
+		return nil, err
+	}
+
+	benefits := make([]model.Benefit, len(benefitsRetrieved))
+	for i, b := range benefitsRetrieved {
+		benefit := model.Benefit{
+			RecipientID:        b.RecipientID,
+			RecipientFirstName: b.RecipientFirstName,
+			RecipientLastName:  b.RecipientLastName,
+			Amount:             model.MakeMoney(b.Amount, model.Currency(b.Currency)),
+		}
+		benefits[i] = benefit
+	}
+
+	return benefits, nil
+}
+
+func convToExpenseRetrieved(expenseDTO *sqlc.GetExpenseByIDRow) (*model.ExpenseRetrieved, error) {
+	payments, err := convToPayments(expenseDTO.Payments)
+	if err != nil {
+		// Unexpected
+		return nil, err
+	}
+
+	benefits, err := convToBenefits(expenseDTO.Benefits)
+	if err != nil {
+		// Unexpected
+		return nil, err
+	}
+
+	expenseRetrieved := &model.ExpenseRetrieved{
+		ID:        int(expenseDTO.ID),
+		CreatedAt: expenseDTO.CreatedAt,
+		UpdatedAt: expenseDTO.UpdatedAt,
+		Amount:    model.MakeMoney(int(expenseDTO.Amount), model.Currency(expenseDTO.Currency)),
+		EventID:   int(expenseDTO.EventID),
+		Detail: model.ExpenseDetail{
+			Name:  expenseDTO.Name.String,
+			Place: expenseDTO.Place.String,
+		},
+		Payments: payments,
+		Benefits: benefits,
+	}
+
+	return expenseRetrieved, nil
+}
+
+// InsertExpense implements repo.ExpenseRepository.
+func (e *expenseRepository) InsertExpense(
+	ctx context.Context,
+	expenseEntity *model.ExpenseEntity,
+	tx any,
+) (*model.ExpenseEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	expenseDTO, err := queries.InsertExpense(timeoutCtx, sqlc.InsertExpenseParams{
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+		Amount:    int32(expenseEntity.Amount),
+		Currency:  expenseEntity.Currency,
+		EventID:   int32(expenseEntity.EventID),
+		Name:      sql.NullString{String: expenseEntity.Name, Valid: true},
+		Place:     sql.NullString{String: expenseEntity.Place, Valid: true},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &model.ExpenseEntity{
+		ID:        int(expenseDTO.ID),
+		CreatedAt: expenseDTO.CreatedAt,
+		UpdatedAt: expenseDTO.CreatedAt,
+		Amount:    int(expenseDTO.Amount),
+		Currency:  expenseDTO.Currency,
+		EventID:   int(expenseDTO.EventID),
+		Name:      expenseDTO.Name.String,
+		Place:     expenseDTO.Place.String,
+	}, nil
+}
+
+// ListExpensesByEventID implements repo.ExpenseRepository.
+func (e *expenseRepository) ListExpensesByEventID(
+	ctx context.Context,
+	id int,
+	tx any,
+) ([]model.ExpensesListRetrieved, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	listDTO, err := queries.ListExpensesByEventID(timeoutCtx, int32(id))
+	if err != nil {
+		return nil, err
+	}
+	res := make([]model.ExpensesListRetrieved, len(listDTO))
+	for i, dto := range listDTO {
+		elem := model.ExpensesListRetrieved{
+			ID:        int(dto.ID),
+			CreatedAt: dto.CreatedAt,
+			UpdatedAt: dto.UpdatedAt,
+			Amount:    model.MakeMoney(int(dto.Amount), model.Currency(dto.Currency)),
+			EventID:   int(dto.EventID),
+			Detail: model.ExpenseDetail{
+				Name:  dto.Name.String,
+				Place: dto.Place.String,
+			},
+		}
+		res[i] = elem
+	}
+	return res, nil
+}
+
+// UpdateExpenseByID implements repo.ExpenseRepository.
+func (e *expenseRepository) UpdateExpenseByID(
+	ctx context.Context,
+	expenseUpdate *model.ExpenseUpdateEntity,
+	tx any,
+) (*model.ExpenseEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(e.queries, tx)
+
+	expenseDTO, err := queries.UpdateExpenseByID(timeoutCtx, sqlc.UpdateExpenseByIDParams{
+		ID:        int32(expenseUpdate.ID),
+		UpdatedAt: time.Now(),
+		Amount:    int32(expenseUpdate.Amount),
+		Currency:  expenseUpdate.Currency,
+		Name:      sql.NullString{String: expenseUpdate.Name, Valid: true},
+		Place:     sql.NullString{String: expenseUpdate.Place, Valid: true},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &model.ExpenseEntity{
+		ID:        int(expenseDTO.ID),
+		CreatedAt: expenseDTO.CreatedAt,
+		UpdatedAt: expenseDTO.CreatedAt,
+		Amount:    int(expenseDTO.Amount),
+		Currency:  expenseDTO.Currency,
+		EventID:   int(expenseDTO.EventID),
+		Name:      expenseDTO.Name.String,
+		Place:     expenseDTO.Place.String,
+	}, nil
+}

internal/howmuch/adapter/repo/expense_test.go

@@ -0,0 +1,96 @@
+// MIT License
+//
+// Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package repo
+
+import (
+	"database/sql"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/adapter/repo/sqlc"
+	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/model"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConvToExpenseRetrieved(t *testing.T) {
+	input := &sqlc.GetExpenseByIDRow{
+		ID:        123,
+		CreatedAt: time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		UpdatedAt: time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		Amount:    123,
+		Currency:  "EUR",
+		EventID:   123,
+		Name:      sql.NullString{Valid: false},
+		Place:     sql.NullString{Valid: false},
+		Payments: json.RawMessage(
+			`[{"payer_id": 1, "payer_first_name": "toto", "payer_last_name": "titi", "amount": 10, "currency": "EUR"},
+            {"payer_id": 2, "payer_first_name": "tata", "payer_last_name": "titi", "amount": 10, "currency": "EUR"}]`,
+		),
+		Benefits: json.RawMessage(
+			`[{"recipient_id": 1, "recipient_first_name": "toto", "recipient_last_name": "titi", "amount": 10, "currency": "EUR"},
+            {"recipient_id": 2, "recipient_first_name": "tata", "recipient_last_name": "titi", "amount": 10, "currency": "EUR"}]`,
+		),
+	}
+
+	want := &model.ExpenseRetrieved{
+		ID:        123,
+		CreatedAt: time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		UpdatedAt: time.Date(2000, time.April, 11, 0, 0, 0, 0, time.UTC),
+		Amount:    model.Money{Amount: 123, Currency: model.Currency("EUR")},
+		EventID:   123,
+		Detail:    model.ExpenseDetail{},
+		Payments: []model.Payment{
+			{
+				PayerID:        1,
+				PayerFirstName: "toto",
+				PayerLastName:  "titi",
+				Amount:         model.Money{Amount: 10, Currency: model.Currency("EUR")},
+			},
+			{
+				PayerID:        2,
+				PayerFirstName: "tata",
+				PayerLastName:  "titi",
+				Amount:         model.Money{Amount: 10, Currency: model.Currency("EUR")},
+			},
+		},
+		Benefits: []model.Benefit{
+			{
+				RecipientID:        1,
+				RecipientFirstName: "toto",
+				RecipientLastName:  "titi",
+				Amount:             model.Money{Amount: 10, Currency: model.Currency("EUR")},
+			},
+			{
+				RecipientID:        2,
+				RecipientFirstName: "tata",
+				RecipientLastName:  "titi",
+				Amount:             model.Money{Amount: 10, Currency: model.Currency("EUR")},
+			},
+		},
+	}
+
+	got, err := convToExpenseRetrieved(input)
+	assert.NoError(t, err)
+	assert.Equal(t, want, got)
+}

internal/howmuch/adapter/repo/sqlc/expense.sql

@@ -24,14 +24,6 @@ FROM "expense" ex
 JOIN "event" ev ON ev.id = ex.event_id
 WHERE ev.id = $1;
 
--- name: ListExpensesByEventIDByUserID :many
-SELECT
-    ex.id, ex.created_at, ex.updated_at, ex.amount, ex.currency, ex.event_id,
-    ex.name, ex.place
-FROM "expense" ex
-JOIN "event" ev ON ev.id = ex.event_id
-WHERE ev.id = $1;
-
 -- name: GetExpenseByID :one
 WITH payer_transaction as (
     SELECT pt.expense_id,

internal/howmuch/adapter/repo/sqlc/expense.sql.go

@@ -183,47 +183,6 @@ func (q *Queries) ListExpensesByEventID(ctx context.Context, id int32) ([]Expens
 	return items, nil
 }
 
-const listExpensesByEventIDByUserID = `-- name: ListExpensesByEventIDByUserID :many
-SELECT
-    ex.id, ex.created_at, ex.updated_at, ex.amount, ex.currency, ex.event_id,
-    ex.name, ex.place
-FROM "expense" ex
-JOIN "event" ev ON ev.id = ex.event_id
-WHERE ev.id = $1
-`
-
-func (q *Queries) ListExpensesByEventIDByUserID(ctx context.Context, id int32) ([]Expense, error) {
-	rows, err := q.db.QueryContext(ctx, listExpensesByEventIDByUserID, id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Expense
-	for rows.Next() {
-		var i Expense
-		if err := rows.Scan(
-			&i.ID,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-			&i.Amount,
-			&i.Currency,
-			&i.EventID,
-			&i.Name,
-			&i.Place,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
 const updateExpenseByID = `-- name: UpdateExpenseByID :one
 UPDATE "expense"
 SET updated_at = $2, amount = $3, currency = $4, name = $5, place = $6

internal/howmuch/adapter/repo/sqlc/participation.sql

@@ -3,3 +3,8 @@ INSERT INTO participation (
     user_id, event_id, invited_by_user_id, created_at, updated_at
 ) VALUES ($1, $2, $3, $4, $5)
 RETURNING *;
+
+-- name: GetParticipation :one
+SELECT id, user_id, event_id, invited_by_user_id, created_at, updated_at
+FROM "participation"
+WHERE user_id = $1 AND event_id = $2;

internal/howmuch/adapter/repo/sqlc/participation.sql.go

@@ -11,6 +11,31 @@ import (
 	"time"
 )
 
+const getParticipation = `-- name: GetParticipation :one
+SELECT id, user_id, event_id, invited_by_user_id, created_at, updated_at
+FROM "participation"
+WHERE user_id = $1 AND event_id = $2
+`
+
+type GetParticipationParams struct {
+	UserID  int32
+	EventID int32
+}
+
+func (q *Queries) GetParticipation(ctx context.Context, arg GetParticipationParams) (Participation, error) {
+	row := q.db.QueryRowContext(ctx, getParticipation, arg.UserID, arg.EventID)
+	var i Participation
+	err := row.Scan(
+		&i.ID,
+		&i.UserID,
+		&i.EventID,
+		&i.InvitedByUserID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
 const insertParticipation = `-- name: InsertParticipation :one
 INSERT INTO participation (
     user_id, event_id, invited_by_user_id, created_at, updated_at

internal/howmuch/adapter/repo/sqlc/querier.go

@@ -0,0 +1,30 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.27.0
+
+package sqlc
+
+import (
+	"context"
+)
+
+type Querier interface {
+	DeleteExpense(ctx context.Context, id int32) error
+	DeleteTransactionsOfExpenseID(ctx context.Context, expenseID int32) error
+	GetEventByID(ctx context.Context, id int32) (GetEventByIDRow, error)
+	GetExpenseByID(ctx context.Context, id int32) (GetExpenseByIDRow, error)
+	GetParticipation(ctx context.Context, arg GetParticipationParams) (Participation, error)
+	GetUserByEmail(ctx context.Context, email string) (User, error)
+	GetUserByID(ctx context.Context, id int32) (User, error)
+	InsertEvent(ctx context.Context, arg InsertEventParams) (Event, error)
+	InsertExpense(ctx context.Context, arg InsertExpenseParams) (Expense, error)
+	InsertParticipation(ctx context.Context, arg InsertParticipationParams) (Participation, error)
+	InsertTransaction(ctx context.Context, arg InsertTransactionParams) error
+	InsertUser(ctx context.Context, arg InsertUserParams) (User, error)
+	ListEventsByUserID(ctx context.Context, userID int32) ([]ListEventsByUserIDRow, error)
+	ListExpensesByEventID(ctx context.Context, id int32) ([]Expense, error)
+	UpdateEventByID(ctx context.Context, arg UpdateEventByIDParams) error
+	UpdateExpenseByID(ctx context.Context, arg UpdateExpenseByIDParams) (Expense, error)
+}
+
+var _ Querier = (*Queries)(nil)

internal/howmuch/adapter/repo/sqlc/user.sql

@@ -1,25 +1,3 @@
--- MIT License
---
--- Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
---
--- Permission is hereby granted, free of charge, to any person obtaining a copy
--- of this software and associated documentation files (the "Software"), to deal
--- in the Software without restriction, including without limitation the rights
--- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
--- copies of the Software, and to permit persons to whom the Software is
--- furnished to do so, subject to the following conditions:
---
--- The above copyright notice and this permission notice shall be included in all
--- copies or substantial portions of the Software.
---
--- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
--- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
--- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
--- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
--- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
--- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
--- SOFTWARE.
-
 -- name: InsertUser :one
 INSERT INTO "user" (
     email, first_name, last_name, password, created_at, updated_at

internal/howmuch/adapter/repo/sqlc/user.sql.go

@@ -53,7 +53,6 @@ func (q *Queries) GetUserByID(ctx context.Context, id int32) (User, error) {
 }
 
 const insertUser = `-- name: InsertUser :one
-
 INSERT INTO "user" (
     email, first_name, last_name, password, created_at, updated_at
 ) VALUES ( $1, $2, $3, $4, $5, $6 )
@@ -69,27 +68,6 @@ type InsertUserParams struct {
 	UpdatedAt time.Time
 }
 
-// MIT License
-//
-// Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
 func (q *Queries) InsertUser(ctx context.Context, arg InsertUserParams) (User, error) {
 	row := q.db.QueryRowContext(ctx, insertUser,
 		arg.Email,

internal/howmuch/adapter/repo/user.go

@@ -31,47 +31,37 @@ import (
 	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/adapter/repo/sqlc"
 	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/model"
 	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/usecase/repo"
-	"github.com/jackc/pgx/v5"
 )
 
 type userRepository struct {
-	db *sql.DB
+	queries *sqlc.Queries
 }
 
-const insertTimeout = 1 * time.Second
-
 func NewUserRepository(db *sql.DB) repo.UserRepository {
 	return &userRepository{
-		db: db,
+		queries: sqlc.New(db),
 	}
 }
 
 // Create
-func (ur *userRepository) Create(
+func (u *userRepository) Create(
 	ctx context.Context,
-	transaction interface{},
-	u *model.UserEntity,
+	userEntity *model.UserEntity,
+	tx any,
 ) (*model.UserEntity, error) {
-	timeoutCtx, cancel := context.WithTimeout(ctx, insertTimeout)
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
 	defer cancel()
 
-	args := sqlc.InsertUserParams{
-		Email:     u.Email,
-		FirstName: u.FirstName,
-		LastName:  u.LastName,
-		Password:  u.Password,
+	queries := getQueries(u.queries, tx)
+
+	userDB, err := queries.InsertUser(timeoutCtx, sqlc.InsertUserParams{
+		Email:     userEntity.Email,
+		FirstName: userEntity.FirstName,
+		LastName:  userEntity.LastName,
+		Password:  userEntity.Password,
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
-	}
-
-	tx, ok := transaction.(*sql.Tx)
-	if !ok {
-		return nil, errors.New("transaction is not a pgx.Tx")
-	}
-
-	queries := sqlc.New(tx)
-
-	userDB, err := queries.InsertUser(timeoutCtx, args)
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -88,10 +78,18 @@ func (ur *userRepository) Create(
 }
 
 // GetByEmail if not found, return nil for user but not error.
-func (ur *userRepository) GetByEmail(ctx context.Context, email string) (*model.UserEntity, error) {
-	queries := sqlc.New(ur.db)
-	userDB, err := queries.GetUserByEmail(ctx, email)
-	if errors.Is(err, pgx.ErrNoRows) {
+func (u *userRepository) GetByEmail(
+	ctx context.Context,
+	email string,
+	tx any,
+) (*model.UserEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(u.queries, tx)
+
+	userDB, err := queries.GetUserByEmail(timeoutCtx, email)
+	if errors.Is(err, sql.ErrNoRows) {
 		// No query error, but user not found
 		return nil, nil
 	} else if err != nil {
@@ -109,10 +107,14 @@ func (ur *userRepository) GetByEmail(ctx context.Context, email string) (*model.
 	}, nil
 }
 
-func (ur *userRepository) GetByID(ctx context.Context, id int) (*model.UserEntity, error) {
-	queries := sqlc.New(ur.db)
-	userDB, err := queries.GetUserByID(ctx, int32(id))
-	if errors.Is(err, pgx.ErrNoRows) {
+func (u *userRepository) GetByID(ctx context.Context, id int, tx any) (*model.UserEntity, error) {
+	timeoutCtx, cancel := context.WithTimeout(ctx, queryTimeout)
+	defer cancel()
+
+	queries := getQueries(u.queries, tx)
+
+	userDB, err := queries.GetUserByID(timeoutCtx, int32(id))
+	if errors.Is(err, sql.ErrNoRows) {
 		// No query error, but user not found
 		return nil, nil
 	} else if err != nil {

internal/howmuch/model/event.go

@@ -36,7 +36,7 @@ type EventCreateRequest struct {
 // }}}
 // {{{ Response View Object (from service to controller)
 
-type EventBaseItemResponse struct {
+type EventListResponse struct {
 	ID          int
 	Name        string
 	Description string
@@ -57,19 +57,11 @@ type EventInfoResponse struct {
 	CreatedAt time.Time
 	UpdatedAt time.Time
 
-	Users []*UserBaseResponse
+	Users []UserBaseResponse
 }
 
 // }}}
-// {{{ Entity Persistant Object (Between the service and the repository)
-
-type EventBaseItemEntity struct {
-	ID          int
-	Name        string
-	Description string
-	OwnerID     int
-	CreatedAt   time.Time
-}
+// {{{ Entity (DB In)
 
 type EventEntity struct {
 	ID int
@@ -84,19 +76,54 @@ type EventEntity struct {
 	UpdatedAt time.Time
 }
 
+type EventUpdateEntity struct {
+	ID          int
+	Name        string
+	Description string
+	CreatedAt   time.Time
+	// TODO: maybe I can change owner too
+}
+
+// }}}
+// {{{ Retrieved (DB out)
+
+type EventRetrieved struct {
+	ID int
+
+	Name        string
+	Description string
+
+	Users []UserBaseRetrieved
+
+	TotalAmount     Money
+	DefaultCurrency Currency
+	Owner           *UserBaseRetrieved
+
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+type EventListRetrieved struct {
+	ID          int
+	Name        string
+	Description string
+	CreatedAt   time.Time
+	Owner       *UserBaseRetrieved
+}
+
 // }}}
 // {{{ DO Domain Object (Contains the domain service)
 
-type EventDO struct {
+type Event struct {
 	ID int
 
 	Name        string
 	Description string
 
 	// lazy get using participation join
-	Users []*UserDO
+	Users []UserDO
 	// lazy get
-	Expenses []*Expense
+	Expenses []Expense
 
 	TotalAmount     Money
 	DefaultCurrency Currency

internal/howmuch/model/expense.go

@@ -37,7 +37,17 @@ type ExpenseRequest struct {
 // }}}
 // {{{ Response
 
-type ExpensesListResponse struct {
+type (
+	ExpenseGetResponse Expense
+	ExpenseResponse    ExpenseRetrieved
+)
+
+// }}}
+// {{{ Retrieved
+
+type ExpenseRetrieved Expense
+
+type ExpensesListRetrieved struct {
 	ID        int       `json:"id"`
 	CreatedAt time.Time `json:"created_at"`
 	UpdatedAt time.Time `json:"updated_at"`
@@ -48,12 +58,21 @@ type ExpensesListResponse struct {
 	Detail ExpenseDetail `json:"detail"`
 }
 
-type ExpenseGetResponse Expense
+type PaymentRetrieved struct {
+	PayerID        int    `json:"payer_id"`
+	PayerFirstName string `json:"payer_first_name"`
+	PayerLastName  string `json:"payer_last_name"`
+	Amount         int    `json:"amount"`
+	Currency       string `json:"currency"`
+}
 
-// }}}
-// {{{ Retrieved
-
-type ExpensesListRetrieved ExpensesListResponse
+type BenefitRetrieved struct {
+	RecipientID        int    `json:"recipient_id"`
+	RecipientFirstName string `json:"recipient_first_name"`
+	RecipientLastName  string `json:"recipient_last_name"`
+	Amount             int    `json:"amount"`
+	Currency           string `json:"currency"`
+}
 
 // }}}
 // {{{ Entity
@@ -72,6 +91,18 @@ type ExpenseEntity struct {
 	Place string
 }
 
+type ExpenseUpdateEntity struct {
+	ID        int
+	UpdatedAt time.Time
+
+	Amount   int
+	Currency string
+
+	// Expense Detail
+	Name  string
+	Place string
+}
+
 // }}}
 // {{{ Domain Models
 

internal/howmuch/model/user.go

@@ -41,11 +41,7 @@ type UserExistRequest struct {
 // }}}
 // {{{ Response View Object (from service to controller)
 
-type UserBaseResponse struct {
-	ID        int    `json:"id"`
-	FirstName string `json:"first_name"`
-	LastName  string `json:"last_name"`
-}
+type UserBaseResponse UserBaseRetrieved
 
 type UserInfoResponse struct {
 	// UserBaseResponse
@@ -59,7 +55,7 @@ type UserInfoResponse struct {
 }
 
 // }}}
-// {{{ Entity Persistant Object (Between the service and the repository)
+// {{{ Entity (DB In)
 
 type UserEntity struct {
 	ID int
@@ -73,6 +69,15 @@ type UserEntity struct {
 	UpdatedAt time.Time
 }
 
+// }}}
+// {{{ Retrieved (DB out)
+
+type UserBaseRetrieved struct {
+	ID        int    `json:"id"`
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"`
+}
+
 // }}}
 // {{{ DO Domain Object (Contains the domain service)
 

internal/howmuch/usecase/repo/db.go

@@ -22,7 +22,9 @@
 
 package repo
 
-import "context"
+import (
+	"context"
+)
 
 type DBRepository interface {
 	Transaction(

internal/howmuch/usecase/repo/event.go

@@ -29,37 +29,46 @@ import (
 )
 
 type EventRepository interface {
-	Create(ctx context.Context, evEntity *model.EventEntity) (*model.EventEntity, error)
+	Create(ctx context.Context, evEntity *model.EventEntity, tx any) (*model.EventEntity, error)
 
-	// UpdateInfo updates the event related information (name, descriptions)
-	UpdateInfo()
+	// UpdateEventByID updates the event related information (name, descriptions)
+	UpdateEventByID(ctx context.Context, event *model.EventUpdateEntity, tx any) error
 
-	Delete() // XXX: Pay attention to the foreign key relationships
-
-	GetByID(ctx context.Context, eventID int) (*model.EventEntity, error)
-
-	ListExpensesByUserID()
+	GetByID(ctx context.Context, eventID int, tx any) (*model.EventRetrieved, error)
 
 	// related to events of a user
-	ListEventsByUserID(ctx context.Context, userID int) ([]model.EventBaseItemEntity, error)
+	ListEventsByUserID(ctx context.Context, userID int, tx any) ([]model.EventListRetrieved, error)
+
+	InsertParticipation(
+		ctx context.Context,
+		userID, eventID, invitedByUserID int,
+		tx any,
+	) (*model.ParticipationEntity, error)
+
+	GetParticipation(
+		ctx context.Context,
+		userID, eventID int,
+		tx any,
+	) (*model.ParticipationEntity, error)
 }
 
 type ExpenseRepository interface {
-	Create()
-	Update()
-	Delete() // Delete also the related transactions
-
-	GetByID()
-}
-
-type ParticipationRepository interface {
-	Create()
-	Delete()
-	CheckParticipation(ctx context.Context, userID, eventID int) error
-}
-
-type TransactionRepository interface {
-	Create()
-	// Delete() might be handled in the Expense
-	// Transaction is a joined entity, we don't provide diret read operation
+	DeleteExpense(ctx context.Context, expenseID int, tx any) error
+	DeleteTransactionsOfExpense(ctx context.Context, expenseID int, tx any) error
+	GetExpenseByID(ctx context.Context, expenseID int, tx any) (*model.ExpenseRetrieved, error)
+	InsertExpense(
+		ctx context.Context,
+		expenseEntity *model.ExpenseEntity,
+		tx any,
+	) (*model.ExpenseEntity, error)
+	ListExpensesByEventID(
+		ctx context.Context,
+		id int,
+		tx any,
+	) ([]model.ExpensesListRetrieved, error)
+	UpdateExpenseByID(
+		ctx context.Context,
+		expenseUpdate *model.ExpenseUpdateEntity,
+		tx any,
+	) (*model.ExpenseEntity, error)
 }

internal/howmuch/usecase/repo/user.go

@@ -29,7 +29,11 @@ import (
 )
 
 type UserRepository interface {
-	Create(ctx context.Context, transaction interface{}, u *model.UserEntity) (*model.UserEntity, error)
-	GetByEmail(ctx context.Context, email string) (*model.UserEntity, error)
-	GetByID(ctx context.Context, id int) (*model.UserEntity, error)
+	Create(
+		ctx context.Context,
+		u *model.UserEntity,
+		tx any,
+	) (*model.UserEntity, error)
+	GetByEmail(ctx context.Context, email string, tx any) (*model.UserEntity, error)
+	GetByID(ctx context.Context, id int, tx any) (*model.UserEntity, error)
 }

internal/howmuch/usecase/usecase/event.go

@@ -33,11 +33,9 @@ import (
 )
 
 type eventUsecase struct {
-	userUC            User
-	eventRepo         repo.EventRepository
-	expenseRepo       repo.ExpenseRepository
-	participationRepo repo.ParticipationRepository
-	transactionRepo   repo.TransactionRepository
+	userUC      User
+	eventRepo   repo.EventRepository
+	expenseRepo repo.ExpenseRepository
 
 	dbRepo repo.DBRepository
 }
@@ -55,18 +53,16 @@ func NewEventUsecase(
 	uuc User,
 	ev repo.EventRepository,
 	ex repo.ExpenseRepository,
-	pa repo.ParticipationRepository, // XXX: Might be handled in event
-	tr repo.TransactionRepository, // XXX: Might be handled in event
 	db repo.DBRepository,
 ) Event {
-	return &eventUsecase{uuc, ev, ex, pa, tr, db}
+	return &eventUsecase{uuc, ev, ex, db}
 }
 
 func (evuc *eventUsecase) CreateEvent(
 	ctx context.Context,
 	evRequest *model.EventCreateRequest,
 ) (*model.EventInfoResponse, error) {
-	// transfer evRequest to PO
+	// transfer evRequest to evEntity
 
 	evEntity := &model.EventEntity{
 		Name:            evRequest.Name,
@@ -78,12 +74,37 @@ func (evuc *eventUsecase) CreateEvent(
 
 	data, err := evuc.dbRepo.Transaction(
 		ctx,
-		func(txCtx context.Context, tx interface{}) (interface{}, error) {
-			created, err := evuc.eventRepo.Create(ctx, evEntity)
+		func(txCtx context.Context, tx any) (any, error) {
+			// Create the event
+			created, err := evuc.eventRepo.Create(ctx, evEntity, tx)
 			if err != nil {
 				return nil, err
 			}
 
+			// participate to the event
+			participation, err := evuc.eventRepo.InsertParticipation(
+				ctx,
+				created.OwnerID,
+				created.ID,
+				0,
+				tx,
+			)
+			if err != nil {
+				return nil, err
+			}
+
+			if participation == nil {
+				// Unexpected error
+				log.ErrorLog(
+					"participation existed for event-user pair",
+					"userID",
+					created.OwnerID,
+					"eventID",
+					created.ID,
+				)
+				return nil, errno.InternalServerErr
+			}
+
 			// TODO: App log, maybe can be sent to some third party service.
 			log.InfoLog(
 				"created new event",
@@ -93,6 +114,7 @@ func (evuc *eventUsecase) CreateEvent(
 				created.OwnerID,
 			)
 
+			// Construct the response
 			ownerResponse, err := evuc.userUC.GetUserBaseResponseByID(ctx, created.OwnerID)
 			if err != nil {
 				return nil, err
@@ -108,9 +130,12 @@ func (evuc *eventUsecase) CreateEvent(
 				),
 				Owner:     ownerResponse,
 				CreatedAt: created.CreatedAt,
+				UpdatedAt: created.UpdatedAt,
+				Users:     []model.UserBaseResponse{*ownerResponse},
 			}
 			return evResponse, err
-		})
+		},
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -123,8 +148,28 @@ func (evuc *eventUsecase) CreateEvent(
 func (evuc *eventUsecase) ListEvents(
 	ctx context.Context,
 	userID int,
-) ([]model.EventBaseItemResponse, error) {
-	return nil, nil
+) ([]model.EventListResponse, error) {
+	eventListRetrieved, err := evuc.eventRepo.ListEventsByUserID(ctx, userID, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Check if the user is a member of the event
+
+	responses := make([]model.EventListResponse, len(eventListRetrieved))
+
+	for i, retrieved := range eventListRetrieved {
+		ownner := model.UserBaseResponse(*retrieved.Owner)
+		res := model.EventListResponse{
+			ID:          retrieved.ID,
+			Name:        retrieved.Name,
+			Description: retrieved.Description,
+			Owner:       &ownner,
+			CreatedAt:   retrieved.CreatedAt,
+		}
+		responses[i] = res
+	}
+	return responses, nil
 }
 
 // GetEventDetail
@@ -133,10 +178,10 @@ func (evuc *eventUsecase) GetEventDetail(
 	userID, eventID int,
 ) (*model.EventInfoResponse, error) {
 	// Check if the user has the right to get this event
-	err := evuc.participationRepo.CheckParticipation(ctx, userID, eventID)
-	if err != nil {
-		return nil, ErrNoParticipation
-	}
+	// err := evuc.participationRepo.CheckParticipation(ctx, userID, eventID)
+	// if err != nil {
+	// 	return nil, ErrNoParticipation
+	// }
 
 	// Get the eventDetail
 	// TODO: This can also be put into the cache

internal/howmuch/usecase/usecase/repomock/testdbrepo.go

@@ -22,7 +22,9 @@
 
 package repomock
 
-import "context"
+import (
+	"context"
+)
 
 type TestDBRepository struct{}
 

internal/howmuch/usecase/usecase/repomock/testuserrepo.go

@@ -36,8 +36,8 @@ type TestUserRepository struct{}
 
 func (tur *TestUserRepository) Create(
 	ctx context.Context,
-	transaction interface{},
 	u *model.UserEntity,
+	tx any,
 ) (*model.UserEntity, error) {
 	user := *u
 
@@ -53,6 +53,7 @@ func (tur *TestUserRepository) Create(
 func (tur *TestUserRepository) GetByEmail(
 	ctx context.Context,
 	email string,
+	tx any,
 ) (*model.UserEntity, error) {
 	hashedPwd, _ := bcrypt.GenerateFromPassword([]byte("strongHashed"), 12)
 	switch email {
@@ -71,7 +72,11 @@ func (tur *TestUserRepository) GetByEmail(
 	return nil, UserTestDummyErr
 }
 
-func (tur *TestUserRepository) GetByID(ctx context.Context, id int) (*model.UserEntity, error) {
+func (tur *TestUserRepository) GetByID(
+	ctx context.Context,
+	id int,
+	tx any,
+) (*model.UserEntity, error) {
 	hashedPwd, _ := bcrypt.GenerateFromPassword([]byte("strongHashed"), 12)
 	switch id {
 	case 123:

internal/howmuch/usecase/usecase/user.go

@@ -86,12 +86,12 @@ func (uuc *userUsecase) Create(
 	data, err := uuc.dbRepo.Transaction(
 		ctx,
 		func(txCtx context.Context, tx interface{}) (interface{}, error) {
-			created, err := uuc.userRepo.Create(txCtx, tx, &model.UserEntity{
+			created, err := uuc.userRepo.Create(txCtx, &model.UserEntity{
 				Email:     u.Email,
 				Password:  u.Password,
 				FirstName: u.FirstName,
 				LastName:  u.LastName,
-			})
+			}, tx)
 			if err != nil {
 				match, _ := regexp.MatchString("SQLSTATE 23505", err.Error())
 				if match {
@@ -132,7 +132,7 @@ func (uuc *userUsecase) Create(
 }
 
 func (uuc *userUsecase) Exist(ctx context.Context, u *model.UserExistRequest) error {
-	got, err := uuc.userRepo.GetByEmail(ctx, u.Email)
+	got, err := uuc.userRepo.GetByEmail(ctx, u.Email, nil)
 	// Any query error?
 	if err != nil {
 		return err
@@ -160,7 +160,7 @@ func (uuc *userUsecase) GetUserBaseResponseByID(
 	// If not exists, get from the DB. And then put back
 	// into the cache with a timeout.
 	// Refresh the cache when the user data is updated (for now it cannot be updated)
-	got, err := uuc.userRepo.GetByID(ctx, userID)
+	got, err := uuc.userRepo.GetByID(ctx, userID, nil)
 	if err != nil {
 		return nil, err
 	}

sqlc.yml

@@ -28,3 +28,4 @@ sql:
     gen:
       go:
         out: "internal/howmuch/adapter/repo/sqlc"
+        emit_interface: true

web/package-lock.json

@@ -8,6 +8,7 @@
       "name": "web",
       "version": "0.0.0",
       "dependencies": {
+        "axios": "^1.7.7",
         "vue": "^3.4.29",
         "vue-router": "^4.3.3"
       },
@@ -2299,8 +2300,17 @@
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
-      "dev": true
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "node_modules/axios": {
+      "version": "1.7.7",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
+      "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
     },
     "node_modules/balanced-match": {
       "version": "1.0.2",
@@ -2497,7 +2507,6 @@
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
       "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
-      "dev": true,
       "dependencies": {
         "delayed-stream": "~1.0.0"
       },
@@ -2710,7 +2719,6 @@
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
       "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
-      "dev": true,
       "engines": {
         "node": ">=0.4.0"
       }
@@ -3256,6 +3264,25 @@
       "integrity": "sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==",
       "dev": true
     },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/foreground-child": {
       "version": "3.3.0",
       "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz",
@@ -3276,7 +3303,6 @@
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
       "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
-      "dev": true,
       "dependencies": {
         "asynckit": "^0.4.0",
         "combined-stream": "^1.0.8",
@@ -4041,7 +4067,6 @@
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
       "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
-      "dev": true,
       "engines": {
         "node": ">= 0.6"
       }
@@ -4050,7 +4075,6 @@
       "version": "2.1.35",
       "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
       "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
-      "dev": true,
       "dependencies": {
         "mime-db": "1.52.0"
       },
@@ -4614,6 +4638,11 @@
       "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==",
       "dev": true
     },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
     "node_modules/psl": {
       "version": "1.9.0",
       "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz",

web/package.json

@@ -14,6 +14,7 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
+    "axios": "^1.7.7",
     "vue": "^3.4.29",
     "vue-router": "^4.3.3"
   },

web/src/App.vue

@@ -37,6 +37,8 @@ import HelloWorld from './components/HelloWorld.vue'
       <nav>
         <RouterLink to="/">Home</RouterLink>
         <RouterLink to="/about">About</RouterLink>
+        <RouterLink to="/login">Login</RouterLink>
+        <RouterLink to="/Signup">Signup</RouterLink>
       </nav>
     </div>
   </header>

web/src/router/index.ts

@@ -40,6 +40,16 @@ const router = createRouter({
       // this generates a separate chunk (About.[hash].js) for this route
       // which is lazy-loaded when the route is visited.
       component: () => import('../views/AboutView.vue')
+    },
+    {
+      path: '/login',
+      name: 'login',
+      component: () => import('../views/LoginView.vue')
+    },
+    {
+      path: '/signup',
+      name: 'signup',
+      component: () => import('../views/SignupView.vue')
     }
   ]
 })

web/src/views/LoginView.vue

@@ -0,0 +1,83 @@
+<!--
+ MIT License
+
+ Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-->
+<template>
+  <div class="login-container">
+    <h2>Login</h2>
+    <form @submit.prevent="handleLogin">
+      <div class="form-group">
+        <label for="email">Email:</label>
+        <input type="text" id="email" v-model="email" required />
+      </div>
+      <div class="form-group">
+        <label for="password">Password:</label>
+        <input type="password" id="password" v-model="password" required />
+      </div>
+      <button type="submit">Login</button>
+    </form>
+    <p v-if="error" class="error">{{ error }}</p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { useRouter } from 'vue-router'
+import axios from 'axios'
+
+const email = ref('')
+const password = ref('')
+const error = ref('')
+
+const router = useRouter()
+
+const handleLogin = async () => {
+  try {
+    const response = await axios.post('http://localhost:8000/v1/session/create', {
+      email: email.value,
+      password: password.value
+    })
+
+    if (response.status === 200) {
+      // Clear error message
+      error.value = ''
+      // Redirect to dashboard or another route
+      router.push('/about')
+    } else {
+      error.value = 'Invalid email or password'
+    }
+  } catch (err) {
+    error.value = 'An error occurred. Please try again.'
+    console.error(err)
+  }
+}
+</script>
+
+<style>
+@media (min-width: 1024px) {
+  .about {
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+  }
+}
+</style>

web/src/views/SignupView.vue

@@ -0,0 +1,95 @@
+<!--
+ MIT License
+
+ Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-->
+<template>
+  <div class="signup-container">
+    <h2>Signup</h2>
+    <form @submit.prevent="handleSignup">
+      <div class="form-group">
+        <label for="email">Email:</label>
+        <input type="text" id="email" v-model="email" required />
+      </div>
+      <div class="form-group">
+        <label for="password">Password:</label>
+        <input type="password" id="password" v-model="password" required />
+      </div>
+      <div class="form-group">
+        <label for="first_name">First Name:</label>
+        <input type="first_name" id="first_name" v-model="first_name" required />
+      </div>
+      <div class="form-group">
+        <label for="last_name">Last Name:</label>
+        <input type="last_name" id="last_name" v-model="last_name" required />
+      </div>
+      <button type="submit">Signup</button>
+    </form>
+    <p v-if="error" class="error">{{ error }}</p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { useRouter } from 'vue-router'
+import axios from 'axios'
+
+const first_name = ref('')
+const last_name = ref('')
+const email = ref('')
+const password = ref('')
+const error = ref('')
+
+const router = useRouter()
+
+const handleSignup = async () => {
+  try {
+    const response = await axios.post('http://localhost:8000/v1/user/create', {
+      email: email.value,
+      password: password.value,
+      first_name: first_name.value,
+      last_name: last_name.value
+    })
+
+    if (response.status === 200) {
+      // Clear error message
+      error.value = ''
+      // Redirect to dashboard or another route
+      router.push('/login')
+    } else {
+      error.value = 'Failed to signup'
+    }
+  } catch (err) {
+    error.value = 'An error occurred. Please try again.'
+    console.error(err)
+  }
+}
+</script>
+
+<style>
+@media (min-width: 1024px) {
+  .about {
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+  }
+}
+</style>