refactor: cmd & adapter

.vscode/launch.json

@@ -22,11 +22,9 @@
             "mode": "auto",
             "program": "${workspaceFolder}",
             "envFile": "${workspaceFolder}/.env",
-            "env": {
-                "ENVIRONMENT": "production"
-            },
             "args": [
                 "server",
+                "--prod"
             ]
         },
         {

cmd/server.go

@@ -2,35 +2,29 @@ package cmd
 
 import (
 	"fmt"
+	"os"
 	"strings"
 
 	"github.com/labasubagia/realworld-backend/internal/adapter/handler/restful"
 	"github.com/labasubagia/realworld-backend/internal/adapter/logger"
 	"github.com/labasubagia/realworld-backend/internal/adapter/repository"
 	"github.com/labasubagia/realworld-backend/internal/core/service"
+	"github.com/labasubagia/realworld-backend/internal/core/util"
 	"github.com/spf13/cobra"
 )
 
+var (
+	dbTypeStr  = strings.Join(repository.Keys(), ", ")
+	logTypeStr = strings.Join(logger.Keys(), ", ")
+)
+
 func init() {
 	rootCmd.AddCommand(serverCmd)
-	serverCmd.Flags().IntP(
-		"port",
-		"p",
-		config.HTTPServerPort,
-		"server port number",
-	)
-	serverCmd.Flags().StringP(
-		"database",
-		"d",
-		repository.DefaultRepoKey,
-		fmt.Sprintf("database type in (%s)", strings.Join(repository.Keys(), ", ")),
-	)
-	serverCmd.Flags().StringP(
-		"log",
-		"l",
-		logger.DefaultKey,
-		fmt.Sprintf("log type in (%s)", strings.Join(logger.Keys(), ",")),
-	)
+
+	serverCmd.Flags().Bool("prod", false, "use for production")
+	serverCmd.Flags().IntP("port", "p", config.HTTPServerPort, "server port number")
+	serverCmd.Flags().StringP("database", "d", repository.DefaultType, fmt.Sprintf("database type in (%s)", dbTypeStr))
+	serverCmd.Flags().StringP("log", "l", logger.DefaultType, fmt.Sprintf("log type in (%s)", logTypeStr))
 }
 
 var serverCmd = &cobra.Command{
@@ -39,40 +33,59 @@ var serverCmd = &cobra.Command{
 	Long:  "Run gin server restful API",
 	Run: func(cmd *cobra.Command, args []string) {
 
-		logType := cmd.Flag("log").Value.String()
-		log := logger.FnNewMap[logType](config)
+		// is_prod
+		isProduction, err := cmd.Flags().GetBool("prod")
+		if err == nil && isProduction {
+			config.Environment = util.EnvProduction
+		}
 
+		// port
 		port, err := cmd.Flags().GetInt("port")
+		if err == nil {
+			config.HTTPServerPort = port
+		}
+
+		// logger
+		logType, err := cmd.Flags().GetString("log")
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed to get flag port")
+			fmt.Fprintf(os.Stderr, "failed get log type flag: %s", err)
+			os.Exit(1)
 		}
-		config.HTTPServerPort = port
+		newLogger, ok := logger.FnNewMap[logType]
+		if !ok {
+			logType = logger.DefaultType
+			newLogger = logger.NewLogger
+		}
+		logger := newLogger(config)
+		logger.Info().Msgf("use logger %s", logType)
 
+		// db
 		dbType, err := cmd.Flags().GetString("database")
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed to get flag database")
+			logger.Fatal().Err(err).Msg("failed get log type flag")
 		}
 		dbType = strings.ToLower(dbType)
-
-		newRepo, exist := repository.FnNewMap[dbType]
-		if !exist {
-			fmt.Println()
-			log.Fatal().Err(err).Msg("failed to get flag port")
+		newRepo, ok := repository.FnNewMap[dbType]
+		if !ok {
+			dbType = repository.DefaultType
+			newRepo = repository.NewRepository
 		}
+		logger.Info().Msgf("use database %s", dbType)
 
-		repo, err := newRepo(config, log)
+		repo, err := newRepo(config, logger)
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed to load repository")
+			logger.Fatal().Err(err).Msg("failed to load repository")
 		}
 
-		service, err := service.NewService(config, repo, log)
+		service, err := service.NewService(config, repo, logger)
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed to load service")
+			logger.Fatal().Err(err).Msg("failed to load service")
 		}
 
-		server := restful.NewServer(config, service, log)
+		logger.Info().Msgf("listen to port %d", config.HTTPServerPort)
+		server := restful.NewServer(config, service, logger)
 		if server.Start(); err != nil {
-			log.Fatal().Err(err).Msg("failed to load service")
+			logger.Fatal().Err(err).Msg("failed to load service")
 		}
 	},
 }

internal/adapter/handler/restful/server.go

@@ -86,7 +86,6 @@ func (server *Server) Start() error {
 	}
 
 	go func() {
-		server.logger.Info().Msgf("listen to port %d", server.config.HTTPServerPort)
 		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			server.logger.Fatal().Err(err).Msg("failed listen")
 		}

internal/adapter/logger/main.go

@@ -7,14 +7,13 @@ import (
 	"github.com/labasubagia/realworld-backend/internal/core/util"
 )
 
-const DefaultKey = "default"
-
 type FnNew func(util.Config) port.Logger
 
+const DefaultType = TypeZeroLog
+
 var FnNewMap = map[string]FnNew{
-	DefaultKey: NewZeroLogLogger,
-	"zerolog":  NewZeroLogLogger,
-	"zap":      NewZapLogger,
+	TypeZeroLog: NewZeroLogLogger,
+	TypeZap:     NewZapLogger,
 }
 
 func Keys() (keys []string) {
@@ -26,5 +25,5 @@ func Keys() (keys []string) {
 }
 
 func NewLogger(config util.Config) port.Logger {
-	return FnNewMap[DefaultKey](config)
+	return FnNewMap[DefaultType](config)
 }

internal/adapter/logger/zap.go

@@ -9,6 +9,8 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+const TypeZap = "zap"
+
 type zapLogger struct {
 	config util.Config
 	level  zapcore.Level

internal/adapter/logger/zerolog.go

@@ -10,6 +10,8 @@ import (
 	"github.com/rs/zerolog"
 )
 
+const TypeZeroLog = "zerolog"
+
 type zeroLogLogger struct {
 	logger zerolog.Logger
 	fields map[string]any

internal/adapter/repository/main.go

@@ -9,14 +9,13 @@ import (
 	"github.com/labasubagia/realworld-backend/internal/core/util"
 )
 
-const DefaultRepoKey = "default"
-
 type FnNew func(util.Config, port.Logger) (port.Repository, error)
 
+const DefaultType = sql.TypePostgres
+
 var FnNewMap = map[string]FnNew{
-	DefaultRepoKey: sql.NewSQLRepository,
-	"postgres":     sql.NewSQLRepository,
-	"mongo":        mongo.NewMongoRepository,
+	sql.TypePostgres: sql.NewSQLRepository,
+	mongo.TypeMongo:  mongo.NewMongoRepository,
 }
 
 func Keys() (keys []string) {
@@ -40,5 +39,5 @@ func ListRepository(config util.Config, logger port.Logger) ([]port.Repository,
 }
 
 func NewRepository(config util.Config, logger port.Logger) (port.Repository, error) {
-	return FnNewMap[DefaultRepoKey](config, logger)
+	return FnNewMap[DefaultType](config, logger)
 }

internal/adapter/repository/mongo/repository.go

@@ -10,6 +10,8 @@ import (
 	"go.mongodb.org/mongo-driver/mongo/writeconcern"
 )
 
+const TypeMongo = "mongo"
+
 type mongoRepo struct {
 	db          DB
 	logger      port.Logger

internal/adapter/repository/sql/db/db.go

@@ -35,7 +35,6 @@ func New(config util.Config, logger port.Logger) (*DB, error) {
 	if err := database.migrate(); err != nil {
 		return nil, err
 	}
-	database.logger.Info().Msg("database migration ok")
 	return database, nil
 }
 

internal/adapter/repository/sql/repository.go

@@ -10,6 +10,8 @@ import (
 	"github.com/uptrace/bun"
 )
 
+const TypePostgres = "postgres"
+
 type sqlRepo struct {
 	db          bun.IDB
 	logger      port.Logger

internal/core/util/config.go

@@ -4,6 +4,11 @@ import (
 	"github.com/spf13/viper"
 )
 
+const (
+	EnvProduction  = "production"
+	EnvDevelopment = "development"
+)
+
 type Config struct {
 	Environment string `mapstructure:"ENVIRONMENT"`
 
@@ -20,7 +25,7 @@ type Config struct {
 }
 
 func (c Config) IsProduction() bool {
-	return c.Environment == "production"
+	return c.Environment == EnvProduction
 }
 
 func (c Config) IsTestAllRepo() bool {