comb19 · keito0tada · May 24, 2025 · May 18, 2025 · May 20, 2025 · May 20, 2025
diff --git a/.gitignore b/.gitignore
@@ -23,3 +23,4 @@ go.work.sum
 
 # env file
 .env
+.env.*
diff --git a/Makefile b/Makefile
@@ -1,18 +1,42 @@
-.PHONY: migrate, update, cleanup, test
+include .env
+.PHONY: init, restart, migrate, update, clean, test, dev-migrate, test-migrate
 
-migrate:
-	docker compose down
-	docker volume rm chat_back_db_store_dev
+init:
+	$(MAKE) clean
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=DEVELOPMENT \
 	docker compose up -d --build
+	docker compose down db-dev db-test-dev
+
+restart:
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=DEVELOPMENT \
+	docker compose restart app db db-test
 
 update:
-	docker compose up -d --build
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=DEVELOPMENT \
+	docker compose up app -d --build
 
-cleanup:
-	docker compose down
-	docker volume rm chat_back_db_store
-	docker volume rm chat_back_db_store_dev
-	docker compose up -d --build
+clean:
+	docker compose down -v
 
 test:
-	docker container exec -it chat_back-app-1 go test ./test
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${TEST_POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=TEST \
+	docker compose restart app	
+	docker container exec -it ${APP_CONTAINER_NAME} go test ./test
+
+migrate:
+	$(MAKE) dev-migrate
+	$(MAKE) test-migrate
+
+dev-migrate:
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=DEVELOPMENT \
+	docker compose up db-dev -d
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=DEVELOPMENT \
+	docker compose up migrate
+	docker compose down db-dev
+
+test-migrate:
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${TEST_POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=TEST \
+	docker compose up db-test-dev -d
+	env DATABASE_URL="postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${TEST_POSTGRES_HOSTNAME}:5432/${POSTGRES_DB}?sslmode=disable" ENV=TEST \
+	docker compose up test-migrate
+	docker compose down db-test-dev
diff --git a/api/cmd/app/app.go b/api/cmd/app/app.go
@@ -4,6 +4,7 @@ import (
 	"chat_back/infrastructure/config"
 	"chat_back/infrastructure/persistence"
 	"chat_back/interface/handler"
+	"chat_back/service"
 	"chat_back/usecase"
 	"context"
 	"fmt"
@@ -119,29 +120,31 @@ func SetupRouter() *gin.Engine {
 
 	db := config.Init()
 
+	// infrastructure
 	userPersistence := persistence.NewUserPersistence(db)
-	userUseCase := usecase.NewUserUsecase(userPersistence)
-	userHandler := handler.NewUserHandler(wh, userUseCase)
-
 	userChannelsPersistence := persistence.NewUserChannelsPersistence(db)
 	userGuildsPersistence := persistence.NewUserGuildsPersistence(db)
+	guildPersistence := persistence.NewGuildPersistence(db)
+	channelPersistence := persistence.NewChannelPersistence(db)
+	messagePersistence := persistence.NewMessagePersistence(db)
+	guildInvitationPersistence := persistence.NewGuildInvitationPersistence(db)
 
-	authorizationUseCase := usecase.NewAuthorizationUsecase(userChannelsPersistence)
+	// service
+	authorizationService := service.NewAuthorizationService(userGuildsPersistence, userChannelsPersistence, channelPersistence)
 
-	messagePersistence := persistence.NewMessagePersistence(db)
+	// usecase
+	authorizationUseCase := usecase.NewAuthorizationUsecase(authorizationService)
+	userUseCase := usecase.NewUserUsecase(userPersistence)
 	messageUseCase := usecase.NewMessageUsecase(messagePersistence)
-	messageHandler := handler.NewMessageHandler(messageUseCase, authorizationUseCase)
+	channelUseCase := usecase.NewChannelUsecase(userChannelsPersistence, channelPersistence, messagePersistence, authorizationService)
+	guildUseCase := usecase.NewGuildUseCase(guildPersistence, userGuildsPersistence, channelPersistence, userChannelsPersistence)
+	guildInvitationUsecase := usecase.NewGuildInvitationUsecase(guildInvitationPersistence, userGuildsPersistence)
 
-	channelPersistence := persistence.NewChannelPersistence(db)
-	channelUseCase := usecase.NewChannelUsecase(userChannelsPersistence, channelPersistence, messagePersistence)
+	// interface
+	userHandler := handler.NewUserHandler(wh, userUseCase)
+	messageHandler := handler.NewMessageHandler(messageUseCase, authorizationUseCase)
 	channelHandler := handler.NewChannelHandler(channelUseCase)
-
-	guildPersistence := persistence.NewGuildPersistence(db)
-	guildUseCase := usecase.NewGuildUseCase(guildPersistence, userGuildsPersistence, channelPersistence, userChannelsPersistence)
 	guildHandler := handler.NewGuildHandler(guildUseCase)
-
-	guildInvitationPersistence := persistence.NewGuildInvitationPersistence(db)
-	guildInvitationUsecase := usecase.NewGuildInvitationUsecase(guildInvitationPersistence, userGuildsPersistence)
 	guildInvitationHandler := handler.NewGuildInvitationHandler(guildInvitationUsecase)
 
 	router := gin.Default()

diff --git a/api/interface/handler/message.go b/api/interface/handler/message.go
@@ -135,14 +135,13 @@ func (c *Client) readPump(uc usecase.MessageUsecase, user *clerk.User) {
 
 		var msg types.Message
 		if err := json.Unmarshal(rawMsg, &msg); err != nil {
-			slog.Debug(err.Error())
+			slog.Error(err.Error())
 			break
 		}
-		fmt.Println("read", msg)
 
 		insertedMsg, err := uc.Insert(msg.ChannelID, user.ID, msg.Content)
 		if err != nil {
-			slog.Debug(err.Error())
+			slog.Error(err.Error())
 			break
 		}
 
@@ -219,16 +218,14 @@ func (mh messageHandler) HandleMessageWebSocket(ctx *gin.Context) {
 	slog.DebugContext(ctx, "HandleMessageWebSocket")
 
 	var messageURI types.MessageURI
-	if err := ctx.ShouldBindUri(&messageURI); err != nil {
+	if err := ctx.BindUri(&messageURI); err != nil {
 		slog.ErrorContext(ctx, err.Error())
-		ctx.JSON(http.StatusBadRequest, gin.H{"error": "bad request"})
 		return
 	}
 
 	conn, err := mh.wsUpgrader.Upgrade(ctx.Writer, ctx.Request, nil)
 	if err != nil {
 		slog.ErrorContext(ctx, err.Error())
-		fmt.Println("websocket upgrade err:", err)
 		return
 	}
 
@@ -253,9 +250,9 @@ func (mh messageHandler) HandleMessageWebSocket(ctx *gin.Context) {
 		conn.Close()
 		return
 	}
-	fmt.Println("authorizationMessage", authorizationMessage)
+	slog.DebugContext(ctx, fmt.Sprintln("authorizationMessage", authorizationMessage))
 	if authorizationMessage.ChannelID != messageURI.ChannelID {
-		fmt.Println("Channel ID mismatch")
+		slog.ErrorContext(ctx, fmt.Sprintf("Channel ID mismatch: %s, %s", authorizationMessage.ChannelID, messageURI.ChannelID))
 		conn.Close()
 		return
 	}
@@ -267,7 +264,7 @@ func (mh messageHandler) HandleMessageWebSocket(ctx *gin.Context) {
 		return
 	}
 	if user == nil {
-		fmt.Println("User not found or no permission")
+		slog.ErrorContext(ctx, "User not found or no permission")
 		conn.Close()
 		return
 	}
@@ -278,17 +275,16 @@ func (mh messageHandler) HandleMessageWebSocket(ctx *gin.Context) {
 }
 
 func (mh messageHandler) HandleMessageByID(ctx *gin.Context) {
-	fmt.Println("HandleMessageByID")
+	slog.DebugContext(ctx, "HandleMessageByID")
 
 	var messageURI types.MessageURI
-	if err := ctx.ShouldBindUri(&messageURI); err != nil {
-		ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
+	if err := ctx.BindUri(&messageURI); err != nil {
 		return
 	}
 
 	message, err := mh.messageUseCase.GetByID(messageURI.ChannelID)
 	if err != nil {
-		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get message"})
+		ctx.Status(http.StatusInternalServerError)
 		return
 	}
 	ctx.JSON(http.StatusOK, message)

diff --git a/api/service/authorization.go b/api/service/authorization.go
@@ -7,22 +7,47 @@ type AuthorizationService interface {
 }
 
 type authorizationService struct {
+	userGuildsRepository   repository.UserGuildsRepository
 	userChannelsRepository repository.UserChannelsRepository
+	channelRepository      repository.ChannelRepository
 }
 
-func NewAuthorizationService(userChannelsRepository repository.UserChannelsRepository) AuthorizationService {
+func NewAuthorizationService(userGuildsRepository repository.UserGuildsRepository, userChannelsRepository repository.UserChannelsRepository, channelRepository repository.ChannelRepository) AuthorizationService {
 	return &authorizationService{
+		userGuildsRepository:   userGuildsRepository,
 		userChannelsRepository: userChannelsRepository,
+		channelRepository:      channelRepository,
 	}
 }
 
 func (as authorizationService) CheckAuthorizationAccessToChannel(userID, channelID string) (bool, error) {
+	channel, err := as.channelRepository.Find(channelID)
+	if err != nil {
+		return false, err
+	}
+	if channel == nil {
+		return false, nil
+	}
+
+	userGuild, err := as.userGuildsRepository.Find(userID, *channel.GuildID)
+	if err != nil {
+		return false, err
+	}
+	if userGuild == nil {
+		return false, nil
+	}
+
+	if !channel.Private {
+		return true, nil
+	}
+
 	userChannel, err := as.userChannelsRepository.Find(userID, channelID)
 	if err != nil {
 		return false, err
 	}
-	if userChannel != nil {
+	if userChannel == nil {
 		return false, nil
 	}
+
 	return true, nil
 }
diff --git a/api/usecase/authorization.go b/api/usecase/authorization.go
@@ -1,7 +1,7 @@
 package usecase
 
 import (
-	"chat_back/domain/repository"
+	"chat_back/service"
 	"context"
 	"log/slog"
 
@@ -15,12 +15,12 @@ type AuthorizationUsecase interface {
 }
 
 type authorizationUsecase struct {
-	userChannelsRepository repository.UserChannelsRepository
+	authorizationService service.AuthorizationService
 }
 
-func NewAuthorizationUsecase(userChannelsRepository repository.UserChannelsRepository) AuthorizationUsecase {
+func NewAuthorizationUsecase(authorizationService service.AuthorizationService) AuthorizationUsecase {
 	return &authorizationUsecase{
-		userChannelsRepository: userChannelsRepository,
+		authorizationService: authorizationService,
 	}
 }
 
@@ -42,13 +42,11 @@ func (au *authorizationUsecase) CheckPermission(channelID string, token string)
 		return nil, err
 	}
 
-	userChannels, err := au.userChannelsRepository.Find(user.ID, channelID)
+	isAuthorized, err := au.authorizationService.CheckAuthorizationAccessToChannel(user.ID, channelID)
 	if err != nil {
-		slog.ErrorContext(ctx, err.Error())
 		return nil, err
 	}
-	if userChannels == nil {
-		slog.ErrorContext(ctx, "a relation between user and channel is not found")
+	if !isAuthorized {
 		return nil, nil
 	}
 

diff --git a/api/usecase/channel.go b/api/usecase/channel.go
@@ -3,6 +3,7 @@ package usecase
 import (
 	"chat_back/domain/model"
 	"chat_back/domain/repository"
+	"chat_back/service"
 	"fmt"
 )
 
@@ -18,13 +19,15 @@ type channelUseCase struct {
 	userChannelsRespository repository.UserChannelsRepository
 	channelRepository       repository.ChannelRepository
 	messageRepository       repository.MessageRepository
+	authorizationService    service.AuthorizationService
 }
 
-func NewChannelUsecase(userChannelsRepository repository.UserChannelsRepository, channelRepository repository.ChannelRepository, messageRepository repository.MessageRepository) ChannelUsecase {
+func NewChannelUsecase(userChannelsRepository repository.UserChannelsRepository, channelRepository repository.ChannelRepository, messageRepository repository.MessageRepository, authorizationService service.AuthorizationService) ChannelUsecase {
 	return &channelUseCase{
 		userChannelsRespository: userChannelsRepository,
 		channelRepository:       channelRepository,
 		messageRepository:       messageRepository,
+		authorizationService:    authorizationService,
 	}
 }
 
@@ -79,11 +82,11 @@ func (cu channelUseCase) AddUserToChannel(id string, userIDs []string) (*model.C
 }
 
 func (cu channelUseCase) GetMessagesOfChannel(id, userID string) (*[]*model.Message, error) {
-	userChannels, err := cu.userChannelsRespository.Find(userID, id)
+	isAuthorized, err := cu.authorizationService.CheckAuthorizationAccessToChannel(userID, id)
 	if err != nil {
 		return nil, err
 	}
-	if userChannels == nil {
+	if !isAuthorized {
 		return nil, nil
 	}