.
├── Dockerfile                # Dockerコンテナのビルドを定義するファイル
├── Makefile                  # プロジェクトのビルド・管理タスクを定義するMakefile
├── app
│   ├── adapter
│   │   ├── presentation      # プレゼンテーション層 (HTTPリクエストやレスポンスの処理)
│   │   │   └── middleware    # HTTPミドルウェア (認証、ロギングなど)
│   │   └── repository        # リポジトリ層 (データアクセスの抽象化)
│   ├── application
│   │   └── usecase           # ユースケース層 (ビジネスロジック)
│   ├── cmd
│   │   └── main.go           # エントリーポイントとなるGoのメイン関数
│   ├── domain
│   │   ├── task              # ドメイン層 (エンティティや値オブジェクト)
│   │   └── user              # ユーザー関連のドメインロジック
│   └── infrastructure
│       ├── auth              # 認証関連の処理 (JWTなど)
│       │   └── jwt           # JWTの生成や検証の実装
│       ├── db                # データベース接続やマイグレーション
│       ├── kvs               # キーバリューストア関連 (例えば、Redisなど)
│       ├── router            # ルーティングの設定
│       └── server            # サーバー設定 (HTTPサーバー、エンドポイントの設定など)
│           └── pkg           # サーバーに関連するパッケージ
├── cli
│   ├── main.go               # CLIアプリケーションのエントリーポイント
│   └── migration.go          # マイグレーション用のGoスクリプト
└── compose.yml               # Docker Composeの設定ファイル

FROM golang:1.23.1

WORKDIR /src
# ワーキングディレクトリにソースコードをコピー
COPY ./ ./ 

# github.com/kakkky/pkgの依存関係をダウンロード
WORKDIR /src/pkg
RUN go mod download

# github.com/kakkky/appの依存関係をダウンロード
WORKDIR /src/app
RUN go mod download

# 必要なツールをインストール
WORKDIR /src
RUN go install github.com/air-verse/air@latest
RUN go install go.uber.org/mock/mockgen@v0.3.0
RUN go install github.com/sqlc-dev/sqlc/cmd/sqlc@v1.23.0

# airを起動
WORKDIR /src
CMD ["air"]

services:
  api:
    build:
      dockerfile: ./Dockerfile
      context: .
    ports:
      - "8080:8080"
    volumes:
      - type: bind
        source: ./
        target: /src #コンテナ内の指定のディレクトリにマウントされる
    tty: true

api-1  | building...
api-1  | running...
api-1  | app/cmd/main.go has changed   //変更を感知
api-1  | building... //再ビルド
api-1  | running... //実行

[build]
.
.
  cmd = "go build -o ./tmp/main ./app/cmd/main.go"
.
.

todo-api  | building...
todo-api  | app/cmd/main.go:6:2: no required module provides package github.com/go-sql-driver/mysql: go.mod file not found in current directory or any parent directory; see 'go help modules'
todo-api  | failed to build, error: exit status 1

FROM golang:1.23.1

WORKDIR /src

COPY ./ ./

WORKDIR /src/app
RUN go mod download

# 必要なツールをインストール
WORKDIR /src
RUN go install github.com/air-verse/air@latest
RUN go install go.uber.org/mock/mockgen@v0.3.0
RUN go install github.com/sqlc-dev/sqlc/cmd/sqlc@v1.23.0

# airを起動
WORKDIR /src/app
CMD ["air"]

[build]
  args_bin = []
  bin = "./tmp/main"
  cmd = "go build -o ./tmp/main ./main.go"

FROM golang:1.23.1

WORKDIR /src

COPY ./ ./

WORKDIR /src/app

RUN go mod download

# 必要なツールをインストール

RUN go install github.com/air-verse/air@latest
RUN go install go.uber.org/mock/mockgen@v0.3.0
RUN go install github.com/sqlc-dev/sqlc/cmd/sqlc@v1.23.0
# 追加
RUN go install -tags 'mysql' github.com/golang-migrate/migrate/v4/cmd/migrate@latest

# airを起動
CMD ["air"]

services:
  api:
    container_name: todo-api
    build:
      dockerfile: ./Dockerfile.api
      context: .
    volumes:
      - type: bind
        source: ./
        target: /src
    ports:
      - "8080:8080"
    tty: true
    environment:
      TODO_DB_HOST: db
      TODO_DB_PORT: 3306
      TODO_DB_USER: user
      TODO_DB_PASSWORD: pswd
      TODO_DB_NAME: todo-db
    depends_on:
      - db
  db:
    container_name: todo-db
    image: mysql:8.0.40-debian
    platform: linux/amd64
    volumes:
      - type: volume
        source: db-store
        target: /var/lib/mysql
      - type: bind
        source: ./app/infrastructure/db/mysql
        target: /etc/mysql/conf.d:cached
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: todo-db
      MYSQL_USER: user
      MYSQL_PASSWORD: pswd
      MYSQL_ALLOW_EMPTY_PASSWORD: true
    tty: true
volumes:
  db-store:

todo-db   | 2024-12-03 13:27:14+00:00 [Note] [Entrypoint]: Switching to dedicated user 'mysql'
todo-db   | 2024-12-03 13:27:14+00:00 [Note] [Entrypoint]: Entrypoint script for MySQL Server 8.0.40-1debian12 started.
todo-db   | 2024-12-03T13:27:16.182055Z 0 [System] [MY-010116] [Server] /usr/sbin/mysqld (mysqld 8.0.40) starting as process 1
todo-db   | 2024-12-03T13:27:16.261596Z 1 [System] [MY-013576] [InnoDB] InnoDB initialization has started.
todo-db   | 2024-12-03T13:27:16.356023Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.356231Z 0 [ERROR] [MY-012639] [InnoDB] Write to file ./#innodb_redo/#ib_redo10_tmp failed at offset 0, 1048576 bytes should have been written, only 0 were written. Operating system error number 28. Check that your OS and file system support files of this size. Check also that the disk is not full or a disk quota exceeded.
todo-db   | 2024-12-03T13:27:16.356646Z 0 [ERROR] [MY-012640] [InnoDB] Error number 28 means 'No space left on device'
todo-db   | 2024-12-03T13:27:16.356792Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.368615Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.368644Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.380982Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.381008Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.392702Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.392736Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.405044Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.405083Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.416785Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.416825Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.429262Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.429302Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.441744Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.441793Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.453997Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.454051Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.470183Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.470216Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.484433Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.484470Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.485162Z 1 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.485314Z 1 [ERROR] [MY-012267] [InnoDB] Could not set the file size of './ibtmp1'. Probably out of disk space
todo-db   | 2024-12-03T13:27:16.485559Z 1 [ERROR] [MY-012926] [InnoDB] Unable to create the shared innodb_temporary.
todo-db   | 2024-12-03T13:27:16.485702Z 1 [ERROR] [MY-012930] [InnoDB] Plugin initialization aborted with error Generic error.
todo-db   | 2024-12-03T13:27:16.487270Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.487305Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.489702Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.489741Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.491669Z 0 [Warning] [MY-012638] [InnoDB] Retry attempts for writing partial data failed.
todo-db   | 2024-12-03T13:27:16.491713Z 0 [ERROR] [MY-012888] [InnoDB] Cannot resize redo log file ./#innodb_redo/#ib_redo10_tmp to 3 MB (Failed to set size)
todo-db   | 2024-12-03T13:27:16.871446Z 1 [ERROR] [MY-010334] [Server] Failed to initialize DD Storage Engine
todo-db   | 2024-12-03T13:27:16.873031Z 0 [ERROR] [MY-010020] [Server] Data Dictionary initialization failed.
todo-db   | 2024-12-03T13:27:16.873510Z 0 [ERROR] [MY-010119] [Server] Aborting
todo-db   | 2024-12-03T13:27:16.889285Z 0 [System] [MY-010910] [Server] /usr/sbin/mysqld: Shutdown complete (mysqld 8.0.40)  MySQL Community Server - GPL.
todo-db exited with code 1

docker system prune -a --volumes

.
.
.
r5piey5hk2vjhi2x2fji7h0yu
iq8d54zq4ouzhij2zx862o7li
hztxlogzlz749ekk8jikdfs0c

Total reclaimed space: 39.88GB

2024/12/03 18:37:08 error: failed to open database, "mysql://user:pswd@tcp(db:3306)/todo-db?parseTime=true": Error 1045: Access denied for user 'user'@'172.18.0.3' (using password: YES)
root@b21301e6461c:/src/app# 

help: # コマンド確認
	@echo "\033[32mAvailable targets:\033[0m"
	@grep "^[a-zA-Z\-]*:" Makefile | grep -v "grep" | sed -e 's/^/make /' | sed -e 's/://'


##############
### テスト ####
##############

# テスト処理の共通化
# パラメータ:
# - path=<テスト対象のパス> (デフォルト: ./...)
# - opts=<追加オプション> (デフォルト: なし)
# - tags=<ビルドタグ> (デフォルト: なし)
define tests
	$(if $(TEST_TAGS),\
		go test -timeout 10m -tags=$(TEST_TAGS) $(TEST_PATH) $(TEST_OPTIONS),\
		go test -timeout 10m $(TEST_PATH) $(TEST_OPTIONS)\
	)
endef

# appディレクトリの全体テスト
# コマンド例: $ make test-app opts="-run TestXxx"
test-app:
	$(eval TEST_PATH=./...)
	$(eval TEST_TAGS=$(tags))
	$(eval TEST_OPTIONS=${opts})
	@echo "Running all tests in app..."
	cd ./app && $(call tests)

# ドメイン層のテスト
# コマンド例: $ make test-domain path=./app/domain/... opts="-run TestXxx"
test-domain:
	$(eval TEST_PATH=$(or $(path),./app/domain/...))
	$(eval TEST_TAGS=$(tags))
	$(eval TEST_OPTIONS=${opts})
	@echo "Running tests in domain..."
	cd ./app/domain && $(call tests)

# インフラ層のテスト
# コマンド例: $ make test-infra path=./app/infrastructure/... opts="-run TestXxx"
test-infra:
	$(eval TEST_PATH=$(or $(path),./app/infrastructure/...))
	$(eval TEST_TAGS=$(tags))
	$(eval TEST_OPTIONS=${opts})
	@echo "Running tests in infrastructure..."
	cd ./app/infrastructure && $(call tests)

# pkgのテスト
# コマンド例: $ make test-pkg path=./pkg/... opts="-run TestXxx"
test-pkg:
	$(eval TEST_PATH=$(or $(path),./pkg/...))
	$(eval TEST_TAGS=$(tags))
	$(eval TEST_OPTIONS=${opts})
	@echo "Running tests in pkg..."
	cd ./pkg && $(call tests)


#####################
##### コンテナ操作 ####
#####################

# docker-composeにおけるDockerfileのビルド
build:
	@echo "Building Docker images..."
	docker compose build 

# docker compose up
up:
	@echo "Starting containers with docker-compose up..."
	docker compose up -d

# docker compose down
down:
	@echo "Stopping containers with docker-compose down..."
	docker compose down

# docker compose logs -f
logs:
	@echo "Fetching logs with docker-compose logs..."
	docker compose logs -f

# docker compose ps
ps:
	@echo "Viewing running containers with docker-compose ps..."
	docker compose ps



########################
### DBマイグレーション ####
########################

MIGRATE_PATH = app/infrastructure/db/migration
DB_URL = "mysql://user:pswd@tcp(db:3306)/todo-db?parseTime=true"

# マイグレーションファイルを作成
# コマンド例: $ make migrate-create name=<migration-name>
migrate-create:
	$(eval NAME=$(or $(name),$(error "Error: Please specify a migration name using name=<name>")))
	@echo "Creating migration file..."
	migrate create -ext sql -dir $(MIGRATE_PATH) -seq $(NAME)

# マイグレーションを適用
# コマンド例: $ make migrate-up
migrate-up:
	@echo "Applying migrations..."
	migrate --path $(MIGRATE_PATH) --database "$(DB_URL)" -verbose up

# マイグレーションをロールバック
# コマンド例: $ make migrate-down
migrate-down:
	@echo "Rolling back migrations..."
	migrate --path $(MIGRATE_PATH) --database "$(DB_URL)" -verbose down


後々、テストなどは追加で書いてくことになると思われます。一旦。

  kvs:
    container_name: todo-kvs
    image: redis:latest
    ports:
      - "6379:6379"
    volumes:
      - type: volume
        source: kvs-store
        target: /data
    tty: true

// パッケージ変数として設定
var config Config

func InitConfig() error {
	if err := envconfig.Process("", &config); err != nil {
		return err
	}
	return nil
}

version: "2"
sql:
  - engine: "mysql"
    queries: "./queries/"
    schema: "./migrations/"
    gen: 
      go:
        package: "sqlc"
        out: "./"
        emit_json_tags: true
        emit_prepared_queries: false
        emit_interface: true
        emit_exact_table_names: false
        emit_empty_slices: true

package mysql

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"time"

	_ "github.com/go-sql-driver/mysql"
	"github.com/kakkky/app/config"
)

// パッケージ変数としてDB接続を管理
var (
	db *sql.DB
)

// パッケージ変数として*sql.DBをセット
func setDB(d *sql.DB) {
	db = d
}

func GetDB() *sql.DB {
	return db
}

func NewDB(ctx context.Context, cfg *config.Config) func() {
	db, close, err := connect(
		ctx,
		cfg.MySQL.User,
		cfg.MySQL.Password,
		cfg.MySQL.Host,
		cfg.MySQL.Port,
		cfg.MySQL.Name,
	)
	if err != nil {
		// DB接続失敗は復旧不可
		panic(err)
	}
	// パッケージ変数にセット
	setDB(db)
	return close
}

const (
	maxRetriesCount = 5
	delay           = 5 * time.Second
)

// DBへ接続
// 失敗したらリトライさせる
func connect(ctx context.Context, user, password, host, port, name string) (*sql.DB, func(), error) {
	for i := 0; i < maxRetriesCount; i++ {
		dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true", user, password, host, port, name)
		db, err := sql.Open("mysql", dsn)
		if err != nil {
			return nil, nil, fmt.Errorf("failed to open db : %w", err)
		}
		// 接続確認
		if err := db.PingContext(ctx); err == nil {
			// 呼び出しもと（main）でクローズ処理を強制させるために関数を返す
			return db, func() { db.Close() }, nil
		}
		// 接続できなかったらリトライ
		log.Printf("could not connect to db: %v", err)
		log.Printf("retrying in %v seconds...", delay/time.Second)
		time.Sleep(delay)
	}
	return nil, nil, fmt.Errorf("could not connect to db after %d attempts", maxRetriesCount)
}

// *http.Server型をラップする
type server struct {
	srv *http.Server
}

// 独自のserver.Server型を返すコンストラクタ
func NewServer(port string, mux *http.ServeMux) *server {
	return &server{
		&http.Server{
			Addr:    port,
			Handler: mux,
		},
	}
}

// サーバーを起動する
func (s *server) Run(ctx context.Context) error {
	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
	// シグナルの監視をやめてリソースを開放する
	defer stop()
	eg, ctx := errgroup.WithContext(ctx)
	eg.Go(func() error {
		// サーバー起動中にエラーが起きると、ctxに伝達される（Shutdownによるエラーは正常なので無視）
		if err := s.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Printf("http server on %s failed : %+v", s.srv.Addr, err)
			return err
		}
		return nil
	})
	// サーバーからのエラーとシグナルを待機する
	<-ctx.Done()
	// シャットダウンをするまでのタイムアウト時間を設定
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	// シャットダウン
	if err := s.srv.Shutdown(ctx); err != nil {
		log.Fatalf("failed to shutdown http server on %s : %+v", s.srv.Addr, err)
	}
	// ゴルーチンのクロージャ内のエラーを返す
	// ゴルーチンを待機する
	return eg.Wait()
}

// 省略

eg, ctx := errgroup.WithContext(ctx)
	eg.Go(func() error {
		// サーバー起動中にエラーが起きると、ctxに伝達される（Shutdownによるエラーは正常なので無視）
		if err := s.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Printf("http server on %s failed : %+v", s.srv.Addr, err)
			return err
		}
		return nil
	})

// 省略

	// ゴルーチンのクロージャ内のエラーを返す
	// ゴルーチンを待機する
	return eg.Wait()

<-ctx.Done  //　終了通知を受け付ける
// シャットダウン処理

func WithContext(ctx context.Context) (*Group, context.Context) {
    // ctxにキャンセル処理を付け足している
	ctx, cancel := withCancelCause(ctx)
	return &Group{cancel: cancel}, ctx
}

return eg.Wait() //errorを返す

	// サーバーからのエラーとシグナルを待機する
	<-ctx.Done()
	// シャットダウンをするまでのタイムアウト時間を設定
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	// 
	if err := s.srv.Shutdown(ctx); err != nil {
		log.Fatalf("failed to shutdown http server on %s : %+v", s.srv.Addr, err)
	}

func (srv *Server) Shutdown(ctx context.Context) error {
	// 省略
	for {
		if srv.closeIdleConns() {
			return lnerr
		}
		select {
		case <-ctx.Done(): //キャンセル通知を待ち受けている
			return ctx.Err() // エラーを返す
		case <-timer.C:
			timer.Reset(nextPollInterval())
		}
	}
}

ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
	// シグナルの監視をやめてリソースを開放する
	defer stop()
// 省略
// サーバーからのエラーとシグナルを待機する
	<-ctx.Done()

// The stop function releases resources associated with it, so code should
// call stop as soon as the operations running in this Context complete and
// signals no longer need to be diverted to the context.

func NotifyContext(parent context.Context, signals ...os.Signal) (ctx context.Context, stop context.CancelFunc) {
	ctx, cancel := context.WithCancel(parent)
	// 省略
	return c, c.stop
}

// ルーティングを登録したマルチプレクサを返す
func NewMux() *http.ServeMux {
	mux := http.NewServeMux()
	handleHealth(mux)
	return mux
}

// ヘルスチェック
func handleHealth(mux *http.ServeMux) {
	h := func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-type", "application/json;charset=utf-8")
		w.WriteHeader(http.StatusOK)
		s := fmt.Sprintf("%d %s", http.StatusOK, "OK")
		m := map[string]string{"status": s}
		if err := json.NewEncoder(w).Encode(m); err != nil {
			log.Printf("failed to encode to json : %v", err)
		}
	}
	mux.HandleFunc("/health/", h)
}

// マルチプレクサをDI
srv := server.NewServer(cfg.Server.Port, router.NewMux())
srv.Run(ctx)

// 適用させたい順で、ミドルウェアを引数に入れる
// composeMiddewares(M1,M2,M3)とした場合、M1(M2(M3()))といったようにラップされたミドルウェアを返す
func composeMiddlewares(middlewares ...func(http.Handler) http.Handler) func(http.Handler) http.Handler {
	return func(h http.Handler) http.Handler {
		for i := range middlewares {
			h = middlewares[len(middlewares)-(i+1)](h)
		}
		return h
	}
}

// ヘルスチェック
func handleHealth(mux *http.ServeMux) {
	mdw := composeMiddlewares(middleware.LoggingMiddleware)  // ❶
	h := func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-type", "application/json;charset=utf-8")
		w.WriteHeader(http.StatusOK)
		s := fmt.Sprintf("%d %s", http.StatusOK, "OK")
		m := map[string]string{"status": s}
		if err := json.NewEncoder(w).Encode(m); err != nil {
			log.Printf("failed to encode to json : %v", err)
		}
	}
	mux.Handle("/health/", mdw(http.HandlerFunc(h)))  // ❷
}

FROM golang:1.23.1
// 省略
RUN go install github.com/air-verse/air@latest
RUN go install go.uber.org/mock/mockgen@v0.3.0
RUN go install github.com/sqlc-dev/sqlc/cmd/sqlc@v1.23.0
RUN go install github.com/swaggo/swag/cmd/swag@latest  //追加
RUN go install -tags 'mysql' github.com/golang-migrate/migrate/v4/cmd/migrate@latest
// 省略

swag init

 ├── docs
│   │   ├── docs.go
│   │   ├── swagger.json
│   │   └── swagger.yaml

import (
	"context"
	"log"

	"github.com/kakkky/app/config"
	_ "github.com/kakkky/app/docs"
	"github.com/kakkky/app/infrastructure/db/mysql"
	"github.com/kakkky/app/infrastructure/router"
	"github.com/kakkky/app/infrastructure/server"
)

// @title       TodoAPI
// @version     2.0
// @description This is TodoAPI by golang.
// @host        localhost
// @BasePath    /api/v2/
func main() {
	ctx := context.Background()
	cfg, err := config.NewConfig()
	if err != nil {
		log.Fatalf("failed to read config : %v", err)
	}
	if err := run(ctx, cfg); err != nil {
		// エラー処理
	}
}

// HealthCheckHandler godoc
// @Summary     apiのヘルスチェックを行う
// @Description Returns the health status of the API
// @Router      /health [get]
func HealthCheckHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json;charset=utf-8")
	body := map[string]string{"message": "health check"}
	if err := json.NewEncoder(w).Encode(body); err != nil {
		log.Printf("failed to encode to json : %v", err)
	}
}

#############
## swagger ##
#############

# コメントをパースしてドキュメント生成
swag:
	@echo "Generating document by swagger..."
	cd ./app && swag fmt &&swag init

package errors

import (
	"errors"
)

// ユーザー関連
var (
	ErrInvalidEmail     = errors.New("invalid email address")
	ErrPasswordTooShort = errors.New("password is too short")
)

// errors.Isをラップ
// パッケージ名の衝突を考慮
func Is(err, target error) bool {
	return errors.Is(err, target)
}

type SuccessResponse[T any] struct {
	Status int `json:"status"`
	Data   T   `json:"data"`
}

func RespondStatusOK[T any](w http.ResponseWriter, respBody T) {
	respondSuccess(w, http.StatusOK, respBody)
}

func respondSuccess[T any](w http.ResponseWriter, statusCode int, respBody T) {
	w.Header().Set("Content-Type", "application/json;charset=utf-8")
	w.WriteHeader(statusCode)
	jsonResp := SuccessResponse[T]{
		Status: statusCode,
		Data:   respBody,
	}
	if err := json.NewEncoder(w).Encode(jsonResp); err != nil {
		RespondStatusInternalServerError(w, err.Error())
	}
}

type SuccessResponse[T any] struct {
	Status int `json:"status"`
	Data   T   `json:"data"`
}

func RespondStatusOK[T any](w http.ResponseWriter, respBody T) {
	respondSuccess(w, http.StatusOK, respBody)
}

func respondSuccess[T any](w http.ResponseWriter, statusCode int, respBody T) {
	w.Header().Set("Content-Type", "application/json;charset=utf-8")
	w.WriteHeader(statusCode)
	jsonResp := SuccessResponse[T]{
		Status: statusCode,
		Data:   respBody,
	}
	if err := json.NewEncoder(w).Encode(jsonResp); err != nil {
		RespondStatusInternalServerError(w, err.Error())
	}
}

// HealthCheckHandler godoc
// @Summary     apiのヘルスチェックを行う
// @Description apiのヘルスチェックを行う。ルーティングが正常に登録されているかを確かめる。
// @Success     200 {object} presenter.SuccessResponse[healthResponse] "Health check message""
// @Router      /health [get]
func HealthCheckHandler(w http.ResponseWriter, r *http.Request) {
	resp := healthResponse{
		HealthCheck: "ok",
	}
	presenter.RespondStatusOK(w, resp)
}

type healthResponse struct {
	HealthCheck string `json:"health_check"`
}

% curl -i  http://localhost:8080/health
HTTP/1.1 200 OK
Content-Type: application/json;charset=utf-8
Date: Mon, 09 Dec 2024 07:57:58 GMT
Content-Length: 44

{"status":200,"data":{"health_check":"ok"}}

// @Success     200 {object} presenter.SuccessResponse[healthResponse] "Health check message""

// ローカルパッケージをインポート
require github.com/kakkky/pkg v0.0.0
replace github.com/kakkky/pkg => ../pkg

package user

import (
	"unicode/utf8"

	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/pkg/hash"
)

type password struct {
	value string
}

const (
	minPasswordLength = 6
)

func newPassword(value string) (password, error) {
	// バリデーション
	if minPasswordLength >= utf8.RuneCountInString(value) {
		return password{}, errors.ErrPasswordTooShort
	}
	// ハッシュ化する
	hashed, err := hash.Hash(value)
	if err != nil {
		return password{}, err
	}

	return password{value: string(hashed)}, nil
}

func reconstructPassword(hashedValue string) password {
	return password{value: hashedValue}
}

// ハッシュ化されたパスワードと比較
func (p password) Compare(target string) bool {
	return hash.Compare(p.value, target)
}

type User struct {
	id       string
	email    email
	name     string
	password password
}

// 新たなユーザーを作成する
func NewUser(
	email string,
	name string,
	password string,
) (*User, error) {
	validatedEmail, err := newEmail(email)
	if err != nil {
		return nil, err
	}
	HashedPassword, err := newPassword(password)
	if err != nil {
		return nil, err
	}
	return &User{
		id:       ulid.NewUlid(),
		email:    validatedEmail,
		name:     name,
		password: HashedPassword,
	}, nil
}

// 既存のユーザーを返す
// リポジトリからのみ使用する
// インスタンスの再構成
func ReconstructUser(
	id string,
	email string,
	name string,
	password string,
) *User {
	return &User{
		id:       id,
		email:    reconstructEmail(email),
		name:     name,
		password: reconstructPassword(password),
	}
}

func TestNewUser(t *testing.T) {
	t.Parallel()
	type args struct {
		name     string
		email    string
		password string
	}
	tests := []struct {
		name    string
		args    args
		want    *User
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				name:     "test",
				email:    "example@test.com",
				password: "password",
			},
			want: &User{
				email: email{value: "example@test.com"},
				name:  "test",
			},
			wantErr: false,
		},
		{
			name: "異常系：emailアドレスが不正",
			args: args{
				email: "test.com",
			},
			wantErr: true,
		},
		{
			name: "異常系：パスワードが短い(4文字)",
			args: args{
				password: "test",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got, err := NewUser(tt.args.email, tt.args.name, tt.args.password)
			if (err != nil) != tt.wantErr {
				t.Fatalf("NewUser() error=%v,but wantErr %v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(User{}, email{}, password{}), cmpopts.IgnoreFields(User{}, "id", "password")); diff != "" {
				t.Errorf("NewProduct() -got,+want :%v ", diff)
			}
		})
	}
}

mysql> show full columns
    ->  from users;
+----------+-----------+--------------------+------+-----+---------+-------+---------------------------------+---------+
| Field    | Type      | Collation          | Null | Key | Default | Extra | Privileges                      | Comment |
+----------+-----------+--------------------+------+-----+---------+-------+---------------------------------+---------+
| id       | char(26)  | utf8mb4_0900_ai_ci | NO   | PRI | NULL    |       | select,insert,update,references |         |
| email    | char(254) | utf8mb4_0900_ai_ci | NO   | MUL | NULL    |       | select,insert,update,references |         |
| name     | char(255) | utf8mb4_0900_ai_ci | NO   |     | NULL    |       | select,insert,update,references |         |
| password | char(255) | utf8mb4_0900_ai_ci | NO   |     | NULL    |       | select,insert,update,references |         |
+----------+-----------+--------------------+------+-----+---------+-------+---------------------------------+---------+
4 rows in set (0.06 sec)

DB_URL = mysql://user:pswd@tcp(db:3306)/todo-db?parseTime=true

# マイグレーションを適用
# コマンド例: $ make migrate-up
migrate-up:
	@echo "Applying migrations..."
	docker compose run api migrate --path $(MIGRATE_PATH) --database "$(DB_URL)" -verbose up

name: test

on:
    # トリガー
    push:
        branches:
            - main
        # 非機能要件のファイルの変更は除外
        paths-ignore:
            - "app/docs/**"
            - "Dockerfile.**"
            - "compose.yml"
            - "air.toml"
jobs:
    # ユニットテスト
    unit-test:
        name: Run Unit Tests
        runs-on: ubuntu-latest
        steps:
            # チェックアウト
            - name: Checkout Code
              uses: actions/checkout@v4
            # Goのセットアップ
            - name: Go Setup
              uses: actions/setup-go@v5
              with:
                # goバージョンを参照するファイル
                go-version-file: app/go.mod
                # キャッシュ
                cache: true
                # 依存関係のキャッシュにおける追跡ファイル
                cache-dependency-path: app/go.sum
            # マルチモジュールを１つのワークスペースで管理
            - name: Setup Workspace
              run: go work init ./pkg ./app
            # appモジュールのテスト
            - name: Run App Test
              run: make test-app
            # pkgモジュールのテスト
            - name: Run Pkg Test
              run: make test-pkg

func (uds userDomainService) IsExists(ctx context.Context, email email) (bool, error) {
	user, err := uds.userRepository.FindByEmail(ctx, email)
	// ユーザーが見つからない場合はエラーではない
	if err != nil && errors.Is(err, errors.ErrNotFoundUser) {
		return false, nil
	}
	// それ以外ならエラーとして返す
	if err != nil {
		return false, err
	}
	return user != nil, nil
}

func TestUserDomainService_IsExists(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		email   email
		mockFn  func(m *MockUserRepository)
		want    bool
		wantErr bool
	}{
		{
			name:  "正常系: ユーザー存在する",
			email: email{value: "test@example.com"},
			mockFn: func(m *MockUserRepository) {
				// ErrNotFoundUserを返す
				m.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(&User{}, nil)
			},
			want:    true,
			wantErr: false,
		},
		{
			name:  "正常系: ユーザーが存在しない",
			email: email{value: "test@example.com"},
			mockFn: func(m *MockUserRepository) {
				m.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(nil, errors.ErrNotFoundUser)
			},
			want:    false,
			wantErr: false,
		},
		{
			name:  "異常系:リポジトリからErrNotFoundUser以外のエラーが返る場合",
			email: email{value: "test@example.com"},
			mockFn: func(m *MockUserRepository) {
				m.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(nil, errors.New("Database error"))
			},
			want:    false,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			ctrl := gomock.NewController(t)
			mockUserRepository := NewMockUserRepository(ctrl)
			// モック呼び出しの設定
			tt.mockFn(mockUserRepository)
			// ドメインサービスを作成
			sut := NewUserDomainService(mockUserRepository)
			ctx := context.Background()
			got, err := sut.IsExists(ctx, tt.email)
			if (err != nil) != tt.wantErr {
				t.Errorf("want error %v,but got %v : %v", tt.wantErr, got, err)
			}
			if got != tt.want {
				t.Errorf("userDomainService.IsExists()= %v,but want %v", got, tt.want)
			}

		})
	}
}

//go:generate mockgen -package=user -source=./interface_user_repository.go -destination=./mock_user_repository.go
type UserRepository interface {
	Save(ctx context.Context, user *User) error
	FindByEmail(ctx context.Context, email Email) (*User, error)
	FetchAllUsers(ctx context.Context) (Users, error)
	Update(ctx context.Context, user *User) error
	Delete(ctx context.Context, user *User) error
}

version: "2"
sql:
  - engine: "mysql"
    queries: "./queries/"
    schema: "../migrations/"
    gen: 
      go:
        package: "sqlc"
        out: "./"
        emit_json_tags: false #構造体にjsonタグをつけない
        emit_prepared_queries: true #プリペアードステートメント
        emit_interface: true #queryごとにインターフェースを生成
        emit_exact_table_names: false #テーブル名(s抜き)がそのまま構造体としない
        emit_empty_slices: true #:manyクエリでnilの代わりに空スライスが返される

func (q *Queries) FetchAllUser(ctx context.Context) ([]FetchAllUserRow, error) {
    //省略
}

func New(db DBTX) *Queries {
	return &Queries{db: db}
}

package sqlc

// パッケージ変数としてQueriesを保持
var (
	queries *Queries
)

func SetQueries(db DBTX) {
	queries = New(db)
}

func GetQueries() *Queries {
	return queries
}

func run(ctx context.Context,cfg *config.Config) error {
	// データベース接続を初期化し、終了時にクローズする
	close := db.NewDB(ctx, cfg)
	defer close()

	// sqlc を使用したクエリ実行のために、sqlcパッケージにクエリオブジェクト変数を設定
	sqlc.SetQueries(db.GetDB())

	// サーバーを起動し、指定したポートでリクエストを処理
	srv := server.NewServer(cfg.Server.Port, router.NewMux())
	srv.Run(ctx)

	return nil
}

func (ur *userRepository) Save(ctx context.Context, user *user.User) error {
    //パッケージ変数から取得
	queries := sqlc.GetQueries()
	
}

const insertUser = `-- name: InsertUser :exec
insert into users (
    name,
    email
) values (
    $1,
    $2
)
`

func (q *Queries) InsertUser(ctx context.Context) error {
	_, err := q.exec(ctx, q.insertUserStmt, insertUser)
	return err
}

-- name: InsertUser :exec
insert into users (
    name,
    email,
    hashed_password
) values (
    sqlc.arg(name),
    sqlc.arg(email),
    sqlc.arg(hashed_password)
);

const insertUser = `-- name: InsertUser :exec
insert into users (
    name,
    email,
    hashed_password
) values (
    ?,
    ?,
    ?
)
`

type InsertUserParams struct {
	Name           string
	Email          string
	HashedPassword string
}

func (q *Queries) InsertUser(ctx context.Context, arg InsertUserParams) error {
	_, err := q.db.ExecContext(ctx, insertUser, arg.Name, arg.Email, arg.HashedPassword)
	return err
}

func (ur *userRepository) Save(ctx context.Context, user *user.User) error {
	queries := sqlc.GetQueries()
	params := sqlc.InsertUserParams{
		Name:           user.GetName(),
		Email:          user.GetEmail().Value(),
		HashedPassword: user.GetHashedPassword().Value(),
	}
	if err := queries.InsertUser(ctx, params); err != nil {
		return err
	}
	return nil
}

func (ur *userRepository) FindByEmail(ctx context.Context, email user.Email) (*user.User, error) {
	queries := sqlc.GetQueries()
	u, err := queries.FindUserByEmail(ctx, email.Value())
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundUser
	}
	if err != nil {
		return nil, err
	}
	user := user.ReconstructUser(
		u.ID,
		u.Email,
		u.Name,
		u.HashedPassword,
	)
	return user, nil
}

func (ur *userRepository) FetchAllUsers(ctx context.Context) (user.Users, error) {
	queries := sqlc.GetQueries()
	us, err := queries.FetchAllUser(ctx)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundUser
	}
	if err != nil {
		return nil, err
	}
	// あらかじめ配列のキャパを確保しておく
	users := make(user.Users, 0, len(us))
	for _, u := range us {
		user := user.ReconstructUser(
			u.ID,
			u.Email,
			u.Name,
			u.HashedPassword,
		)
		users = append(users, user)
	}
	return users, nil
}

func (ur *userRepository) Update(ctx context.Context, user *user.User) error {
	queries := sqlc.GetQueries()
	params := sqlc.UpdateUserParams{
		ID:    user.GetID(),
		Name:  user.GetName(),
		Email: user.GetEmail().Value(),
	}
	if err := queries.UpdateUser(ctx, params); err != nil {
		return err
	}
	return nil
}

func (ur *userRepository) Delete(ctx context.Context, user *user.User) error {
	queries := sqlc.GetQueries()
	if err := queries.DeleteUser(ctx, user.GetID()); err != nil {
		return err
	}
	return nil
}

func (q *Queries) FindUserByEmail(ctx context.Context, email string) (FindUserByEmailRow, error) {
	row := q.db.QueryRowContext(ctx, findUserByEmail, email)
	var i FindUserByEmailRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.Name,
		&i.HashedPassword,
	)
	return i, err
}

unc (ur *userRepository) FindByEmail(ctx context.Context, email user.Email) (*user.User, error) {
	queries := sqlc.GetQueries()
	u, err := queries.FindUserByEmail(ctx, email.Value())
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundUser
	}
	if err != nil {
		return nil, err
	}
	user := user.ReconstructUser(
		u.ID,
		u.Email,
		u.Name,
		u.HashedPassword,
	)
	return user, nil
}

var (
	user_name = "root"
	password  = "secret"
	hostname  = "localhost"
	dbName    = "test-db"
	port      int //ポート番号は起動したコンテナから取得する（ランダム）
)

// DockerTestのコンテナを起動
func NewDockerTestContainer() (*dockertest.Pool, *dockertest.Resource) {
	// デフォルトでUnixソケットを使用する
	pool, err := dockertest.NewPool("root:")
	if err != nil {
		log.Fatalf("failled to construct pool:%v", err)
	}
	// Dockerに接続確認
	if err := pool.Client.Ping(); err != nil {
		log.Fatalf("failed to connect to Docker: %v", err)
	}
	// コンテナの起動設定を指定
	runOptions := &dockertest.RunOptions{
		Repository: "mysql",
		Tag:        "8",
		Env: []string{
			"MYSQL_ROOT_PASSWORD=" + password,
			"MYSQL_DATABASE=" + dbName,
		},
		// 開発環境の設定に揃える
		Cmd: []string{
			"mysqld",
			"--character-set-server=utf8mb4",
			"--collation-server=utf8mb4_unicode_ci",
		},
	}
	resource, err := pool.RunWithOptions(runOptions, func(hc *docker.HostConfig) {
		// コンテナは停止後に自動削除される
		hc.AutoRemove = true
		// コンテナが異常終了しても再起動しない
		hc.RestartPolicy = docker.RestartPolicy{
			Name: "no",
		}
	})
	if err != nil {
		log.Fatalf("failed to start resource: %v", err)
	}
	return pool, resource
}

// コンテナを削除する
func RemoveDockerTestContainer(pool *dockertest.Pool, resource *dockertest.Resource) {
	if err := pool.Purge(resource); err != nil {
		log.Fatalf("failed to  purge resource: %s", err)
	}
}

// DBに接続する
func NewDB(pool *dockertest.Pool, resource *dockertest.Resource) *sql.DB {
	var db *sql.DB
	// エラーだと再実行を繰り返す
	if err := pool.Retry(func() error {
		var err error
		// 公開ポート番号を取得
		port, err = strconv.Atoi(resource.GetPort("3306/tcp")) //コンテナ内のポート番号は3306
		if err != nil {
			return err
		}
		// DBに接続
		db, err = sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?parseTime=true", user_name, password, hostname, port, dbName))
		if err != nil {
			return err
		}
		// 接続確認
		return db.Ping()
	}); err != nil {
		log.Fatalf("failed to connect to database: %v", err)
	}
	return db
}

func SetupDB() {
	migrationsPath := getMigrationsPath()
	m, err := migrate.New(migrationsPath, fmt.Sprintf("mysql://%s:%s@tcp(%s:%d)/%s?parseTime=true", userName, password, hostname, port, dbName))
	if err != nil {
		log.Fatalf("failed to create migrate instance:%v", err)
	}
	// マイグレーションをテストDBに適用させる
	if err := m.Up(); err != nil {
		if errors.Is(err, migrate.ErrNoChange) {
			log.Println("migrations have already been applied")
		} else {
			log.Fatalf("failed to up migrations:%v", err)
		}
	}
}

const migrationsRelativePath = "../migrations"

// どこからSetupDBを呼び出してもmigrationsファイルへのパスを取得できるようにする
func getMigrationsPath() string {
	// コールスタックを遡って、Callerを呼んだ階層の情報を取得する
	// Callerを呼んだ階層とは、つまりこのcontainerディレクトリのこと
	_, callerFile, _, ok := runtime.Caller(0)
	if !ok {
		log.Fatal("failed to get caller directory")
	}

	callerPath := filepath.Dir(callerFile)
	migratiionsAbsPath := "file://" + filepath.Join(callerPath, migrationsRelativePath)
	return migratiionsAbsPath
}

app/infrastructure/db
├── connect.go
├── container
│   ├── db.go　//ここを記述中
│   └── dockertest.go
├── migrations  // ここを適用してくれる
│   ├── 000001_create_users_table.down.sql
│   ├── 000001_create_users_table.up.sql
│   ├── 000002_change_column_password_to_hashed_password.down.sql
│   ├── 000002_change_column_password_to_hashed_password.up.sql
│   ├── 000003_add_column_timestamp_to_users.down.sql
│   └── 000003_add_column_timestamp_to_users.up.sql
├── mysql
│   └── conf.d
│       └── my.conf
└── sqlc
    ├── db.go
    ├── models.go
    ├── querier.go
    ├── queries
    │   └── user.sql
    ├── queries.go
    ├── sqlc.yml
    └── user.sql.go

├── adapter
│   │   ├── presentation
│   │   │   ├── health
│   │   │   │   ├── handler.go
│   │   │   │   └── response.go
│   │   │   ├── middleware
│   │   │   └── presenter
│   │   │       ├── failure.go
│   │   │       └── success.go
│   │   ├── query_service
│   │   └── repository      //ここから、../migrationsを探す　＝＞ない。
│   │       ├── repository_test.go
│   │       ├── user_repository.go
│   │       └── user_repository_test.go

2024/12/13 18:09:48 failed to create migrate instance:failed to open source, "file:///Users/yutakakiki/practice_environment/go/todo-rest-api/app/adapter/migrations": open .: no such file or directory

func TestMain(m *testing.M) {
	//dockertestコンテナを起動
	pool, resource := container.NewDockerTestContainer()
	log.Println("success to start dockertest container")
	defer func() {
		container.RemoveDockerTestContainer(pool, resource)
		log.Println("success to remove dockertest container")
	}()
	// DBに接続
	testDB := container.NewDB(pool, resource)
	log.Println("success to connect test-db")
	defer testDB.Close()
	// マイグレーションを適用させる
	container.SetupDB()
	log.Println("success to apply migrations")
	// dbパッケージ変数にテスト用DBをセット
	db.SetDB(testDB)
	// sqlcパッケージ変数*Queriesをセット
	sqlc.SetQueries(db.GetDB())
	log.Println("dockertest & test-db settings complete")
	m.Run()
}

func TestUserRepository_Save_And_FindByEmail(t *testing.T) {
	t.Parallel()
	// ユーザーインスタンスを用意
	user1, _ := user.NewUser(
		"user1@example.com",
		"user1",
		"password",
	)
	userRepository := NewUserRepository()
	type arg struct {
		user  *user.User
		email user.Email
	}
	// テストテーブル
	tests := []struct {
		name    string
		arg     arg
		want    *user.User
		wantErr bool
	}{
		{
			name: "正常系: 1人ユーザーが追加され、emailで検索できる",
			arg: arg{
				user:  user1,
				email: user1.GetEmail(),
			},
			want:    user1,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			ctx := context.Background()
			// ユーザーを保存
			if err := userRepository.Save(ctx, tt.arg.user); (err != nil) != tt.wantErr {
				t.Errorf("userRepository.Save()=error %v ,but wantErr:%v", err, tt.wantErr)
			}
			// ユーザーをemailで検索
			got, err := userRepository.FindByEmail(ctx, tt.arg.email)
			// 返すエラーはErrNotFoundUserのみであるべき
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FindByEmail() =　error %v,but wantErr :%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FindByEmail() -got,+want :%v ", diff)
			}
		})
	}
}

func SetupFixtures(t *testing.T, fixture_path string) {
	t.Helper()
	fixtures, err := testfixtures.New(
		testfixtures.Database(db.GetDB()),
		testfixtures.Dialect("mysql"),
		testfixtures.SkipResetSequences(),
		testfixtures.Files(
			fixture_path,
		),
	)
	if err != nil {
		log.Printf("testfixtures failed to create Loader instance:%v", err)
	}
	// テーブルのデータを削除&用意
	if err := fixtures.Load(); err != nil {
		log.Printf("testfixtures failed to load fixtures:%v", err)
	}
}

func TestUserRepository_FindByEmail(t *testing.T) {
	t.Parallel()
	userRepository := NewUserRepository()
	user1, _ := user.NewUser(
		"user1@test.com",
		"user1",
		"password",
	)
	user2, _ := user.NewUser(
		"user2@test.com",
		"user2",
		"password",
	)
	type args struct {
		email user.Email
	}
	tests := []struct {
		name    string
		args    args
		want    *user.User
		errType error
		wantErr bool
	}{
		{
			name: "正常系：ユーザーを検索できる",
			args: args{
				email: user1.GetEmail(),
			},
			want:    user1,
			wantErr: false,
		},
		{
			name: "準正常系：ユーザーが見つからなければErrNotFoundUserが返ってくる",
			args: args{
				// 存在しないuser2のemailで検索
				email: user2.GetEmail(),
			},
			errType: errors.ErrNotFoundUser,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// user1のみがDBに保存されている
			testhelper.SetupFixtures(t, "testdata/fixtures/users/users.yml")
			ctx := context.Background()
			got, err := userRepository.FindByEmail(ctx, tt.args.email)
			// 期待されるエラータイプが設定されている場合はそれも検証
			if (err != nil) != tt.wantErr && tt.errType != nil {
				t.Errorf("userRepository.FindByEmail() =error:%v, want errType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FindByEmail() =error:%v, wantErr:%v", err, err)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FindByEmail() -got,+want :%v ", diff)
			}
		})
	}
}

   ├── application
│   │   └── usecase
│   │       └── user
│   │           ├── edit_profile_usecase.go  //編集
│   │           ├── list_users_usecase.go //ユーザーをリスト化
│   │           ├── register_usecase.go // 登録
│   │           └── unregister_usecase.go //退会

// ユーザー関連のドメインエラー
var (
	ErrAlreadyRegisterd = newErrDomain("ErrAlreadyRegisterd", "you have been already registerd")
	ErrInvalidEmail     = newErrDomain("ErrInvalidEmail", "invalid email address")
	ErrPasswordTooShort = newErrDomain("ErrPasswordTooShort", "password is too short")
	ErrNotFoundUser     = newErrDomain("ErrNotFoundUser", "user not found")
)

// タスク関係のドメインエラー
var ()

// ドメインエラー
type ErrDomain struct {
	err error
}

// ドメインエラーのコンストラクタ
func newErrDomain(errType, message string) *ErrDomain {
	return &ErrDomain{
		err: fmt.Errorf("errType => %v,Message => %v", errType, message),
	}
}

// ドメインエラーかどうか
func IsDomainErr(target error) bool {
	var errDomain *ErrDomain
	return errors.As(target, &errDomain)
}

// errorインターフェースを満たすため
func (e *ErrDomain) Error() string {
	return e.err.Error()
}

// errors.Isをラップ
// パッケージ名の衝突を考慮
func Is(err, target error) bool {
	return errors.Is(err, target)
}
func New(message string) error {
	return errors.New(message)
}

func TestErrors(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name string
		fn   func() error
		err  *ErrDomain
	}{
		{
			name: "ErrDomain型としても、個別のエラー型としても判別できる",
			fn: func() error {
				return ErrNotFoundUser
			},
			err: ErrNotFoundUser,
		},
		{
			name: "エラー型がラップされていても判別できる",
			fn: func() error {
				wrappedErr := fmt.Errorf("error occured:%w", ErrNotFoundUser)
				return fmt.Errorf("error occured:%w", wrappedErr)
			},
			err: ErrNotFoundUser,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			err := tt.fn()
			if err != nil && !Is(err, tt.err) {
				t.Errorf("failed to identificate error")
			}
			if !IsDomainErr(err) {
				t.Errorf("failed to identificate ErrDomain")
			}
		})
	}
}

// ハッシュ化されたパスワードと比較
func (p HashedPassword) Compare(target string) bool {
	return hash.Compare(p.value, target)
}

// パスワードを比較する
func (u *User) ComparePassword(plainPassword string) bool {
	return u.hashedPassword.compare(plainPassword)
}

// ハッシュ化されたパスワードと比較
// 集約ルートUserから呼び出す
func (p HashedPassword) compare(target string) bool {
	return hash.Compare(p.value, target)
}

type PostUserHandler struct {
	registerUsecase *user.RegisterUsecase
}

func NewPostUserHandler(registerUsecase *user.RegisterUsecase) *PostUserHandler {
	return &PostUserHandler{
		registerUsecase: registerUsecase,
	}
}

// @Summary     ユーザーの作成
// @Description 新しいユーザーを作成します。
// @Tags        User
// @Accept      json
// @Produce     json
// @Param       request body     PostUserRequest                             true "ユーザー作成のための情報"
// @Success     201     {object} presenter.SuccessResponse[PostUserResponse] "作成されたユーザーの情報"
// @Failure     400     {object} presenter.FailureResponse                   "不正なリクエスト"
// @Failure     500     {object} presenter.FailureResponse                   "内部サーバーエラー"
// @Router      /user [post]
func (puh *PostUserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// jsonをデコード
	var params PostUserRequest
	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
		presenter.RespondBadRequest(w, err.Error())
		return
	}
	if err := validation.NewValidation().Struct(&params); err != nil {
		presenter.RespondBadRequest(w, err.Error())
		return
	}
	// DTOに詰め替える
	input := user.RegisterUsecaseInputDTO{
		Name:     params.Name,
		Email:    params.Email,
		Password: params.Password,
	}
	// ユースケースに渡して実行
	ctx := r.Context()
	output, err := puh.registerUsecase.Run(ctx, input)
	if (err != nil) && errors.IsDomainErr(err) {
		presenter.RespondBadRequest(w, err.Error())
		return
	}
	if err != nil {
		presenter.RespondInternalServerError(w, err.Error())
		return
	}
	resp := PostUserResponse{
		Email: output.Email,
		Name:  output.Name,
	}
	presenter.RespondCreated(w, resp)
}

func RespondNoContent(w http.ResponseWriter) {
	w.WriteHeader(http.StatusNoContent)
}

func (epu *UpdateProfileUsecase) Run(ctx context.Context, input UpdateProfileUsecaseInputDTO) (
	*UpdateProfileUsecaseOutputDTO, error,
) {
	u, err := epu.userRepository.FindById(ctx, input.ID)
	if err != nil || u == nil {
		return nil, err
	}
	// ここが怪しい
	u = user.ReconstructUser(
		input.ID,
		input.Email,
		input.Name,
		"",
	)
	if err := epu.userRepository.Update(ctx, u); err != nil {
		return nil, err
	}
	return &UpdateProfileUsecaseOutputDTO{
		ID:    u.GetID(),
		Email: u.GetEmail().Value(),
		Name:  u.GetName(),
	}, nil
}

// 既存のユーザーを返す
// インスタンスの再構成
func ReconstructUser(
	id string,
	email string,
	name string,
	hashedPassword string,
) *User {
	return &User{
		id:             id,
		email:          reconstructEmail(email),
		name:           name,
		hashedPassword: reconstructHashedPassword(hashedPassword),
	}
}

// ユーザーオブジェクト更新
func UpdateUser(
	id string,
	email string,
	name string,
	hashedPassword string,
) (*User, error) {
	validatedEmail, err := newEmail(email)
	if err != nil {
		return nil, err
	}
	return &User{
		id:             id,
		email:          validatedEmail,
		name:           name,
		hashedPassword: reconstructHashedPassword(hashedPassword),
	}, nil
}

func (epu *UpdateProfileUsecase) Run(ctx context.Context, input UpdateProfileUsecaseInputDTO) (
	*UpdateProfileUsecaseOutputDTO, error,
) {
	// 存在しているユーザーしか編集できない
	u, err := epu.userRepository.FindById(ctx, input.ID)
	// エラーかユーザーがnilの場合はエラー
	if err != nil || u == nil {
		return nil, err
	}
	// 値が空の場合は既存情報を入れる
	if input.Name == "" {
		input.Name = u.GetName()
	}
	if input.Email == "" {
		input.Email = u.GetEmail().Value()
	}
	// input情報をもとに、更新情報を反映したインスタンスを作成
	updatedUser, err := user.UpdateUser(
		input.ID,
		input.Email,
		input.Name,
		u.GetHashedPassword().Value(), //パスワードはそのまま
	)
	if err != nil {
		return nil, err
	}
	if err := epu.userRepository.Update(ctx, u); err != nil {
		return nil, err
	}
	// 更新したオブジェクトをDTOに詰め替える
	return &UpdateProfileUsecaseOutputDTO{
		ID:    updatedUser.GetID(),
		Email: updatedUser.GetEmail().Value(),
		Name:  updatedUser.GetName(),
	}, nil
}

// HTTP リクエストとレスポンスをログに記録するミドルウェア
func Logger(h http.Handler) http.Handler {
	return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
		// リクエストの処理
		requestLog(r)

		// レスポンス用ラッパーを作成
		buf := &bytes.Buffer{} //レスポンスボディを書き込むためのバッファ
		rww := newResponseWrapper(rw, buf)

		// ハンドラ呼び出し
		// ラッパーをResponseWriterとして渡し、バッファにもレスポンスを書き込むようにする
		h.ServeHTTP(rww, r)

		// レスポンスの処理
		responseLog(rww, buf)
	})
}

// リクエストボディを取得しログに出力
func requestLog(r *http.Request) {
	reqBody, _ := io.ReadAll(r.Body)
	defer r.Body.Close()

	strReqBody := string(reqBody)
	if strReqBody == "" {
		strReqBody = "{}"
	}

	// リクエストボディをログに記録
	fmt.Printf("-----------------------------------------------------------------------------------------------------\n"+
		"[REQUEST]\n"+
		"Timestamp  : %s\n"+
		"Method     : %s\n"+
		"URL        : %s\n"+
		"Body       : \n%s\n",
		time.Now().Format(time.RFC3339),
		r.Method,
		r.URL.Path,
		strReqBody)

	// リクエストボディを再代入
	r.Body = io.NopCloser(bytes.NewBuffer(reqBody))
}

// 　レスポンスボディを整形しログに出力
func responseLog(rww *rwWrapper, buf *bytes.Buffer) {
	var formattedRespBody bytes.Buffer
	json.Indent(&formattedRespBody, buf.Bytes(), "", "    ")
	status := rww.statusCode
	fmt.Printf(
		"\n[RESPONSE]\n"+
			"Status     : %d\n"+
			"Body       :\n%s"+
			"-----------------------------------------------------------------------------------------------------\n",
		status,
		&formattedRespBody,
	)
}

// レスポンスのログ記録用にレスポンスをラップ
type rwWrapper struct {
	rw          http.ResponseWriter
	multiWriter io.Writer
	statusCode  int
}

func newResponseWrapper(rw http.ResponseWriter, buf io.Writer) *rwWrapper {
	return &rwWrapper{
		rw:          rw,
		multiWriter: io.MultiWriter(rw, buf),
	}
}

// http.ResponseWriterインターフェースを満たすためのメソッド
func (rww *rwWrapper) Header() http.Header {
	return rww.rw.Header()
}
func (rww *rwWrapper) Write(b []byte) (int, error) {
	return rww.multiWriter.Write(b)
}

func (rww *rwWrapper) WriteHeader(statusCode int) {
	rww.statusCode = statusCode
	rww.rw.WriteHeader(statusCode)
}

type ResponseWriter interface {
	Header() Header
	Write([]byte) (int, error)
	WriteHeader(statusCode int)
}

type rwWrapper struct {
	rw          http.ResponseWriter
	multiWriter io.Writer
	statusCode  int
}

// MultiWriter は、提供された複数の writer への書き込みを複製する writer を作成します。
// これは、Unix の tee(1) コマンドに似ています。
//
// 各書き込みは、リストされた各 writer に対して順番に書き込まれます。
// もしリストされた writer のいずれかがエラーを返した場合、
// その書き込み操作全体が停止し、エラーが返されます。
// リストの後続の writer への書き込みは行われません。
func MultiWriter(writers ...Writer) Writer {
    //省略
}

func newResponseWrapper(rw http.ResponseWriter, buf io.Writer) *rwWrapper {
	return &rwWrapper{
		rw:          rw,
		multiWriter: io.MultiWriter(rw, buf),
	}
}

func (rww *rwWrapper) Write(b []byte) (int, error) {
	return rww.multiWriter.Write(b)
}

├── app
│   ├── adapter
│   │   ├── repository
│   │   │   ├── token_authenticator_repository.go //kvsでトークンを操作する
│   │   │   
│   ├── application
│   │   └── usecase
│   │       └── user
│   │           ├── auth //ユーザ認証系ユースケース
│   │           │   ├── interface_token_authenticator_repository.go //リポジトリのインタフェース
│   │           │   └── interface_token_authenticator.go //トークンを生成する処理のインターフェーす
│   ├── domain
│   ├── infrastructure
│   │   ├── auth
│   │   │   └── jwt_authenticator.go　//トークンを生成する・認証する処理の具体実装

openssl genrsa 4096 > ./app/infrastructure/auth/certificate/private.pem

openssl rsa -pubout < ./app/infrastructure/auth/certificate/private.pem > ./app/infrastructure/auth/certificate/public.pem
writing RSA key

type UserIDKey struct{}

func Authorication(tokenAuthenticator auth.TokenAuthenticator, tokenAuthenticatorRepository auth.TokenAuthenticatorRepository) func(h http.Handler) http.Handler {
	return func(h http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			userID, err := authenticateRequest(r, tokenAuthenticator, tokenAuthenticatorRepository)
			if err != nil {
				presenter.RespondUnAuthorized(w, err.Error())
				return
			}
			// コンテキストにuserIDを含める
			ctx := context.WithValue(r.Context(), UserIDKey{}, userID)
			// 後続の処理（ハンドラ）を実行する
			h.ServeHTTP(w, r.WithContext(ctx))
		})
	}
}

func authenticateRequest(r *http.Request, tokenAuthenticator auth.TokenAuthenticator, tokenAuthenticatorRepository auth.TokenAuthenticatorRepository) (string, error) {
	// JWT トークンを取得
	signedToken, err := getSignedToken(r)
	if err != nil {
		return "", err
	}

	// トークンを検証
	token, err := tokenAuthenticator.VerifyToken(signedToken)
	if err != nil {
		return "", err
	}

	// トークンの有効期限を検証
	if err := tokenAuthenticator.VerifyExpiresAt(token); err != nil {
		return "", err
	}

	// JWT クレームから情報を取得
	jti, err := tokenAuthenticator.GetJWTIDFromClaim(token)
	if err != nil {
		return "", err
	}
	userID, err := tokenAuthenticator.GetSubFromClaim(token)
	if err != nil {
		return "", err
	}

	// KVS から保存された jti を取得
	jtiFromKVS, err := tokenAuthenticatorRepository.Load(r.Context(), userID)
	if err != nil {
		return "", err
	}

	// jti が一致しない場合はエラー
	if jti != jtiFromKVS {
		return "", errors.New("invalid JWT ID")
	}

	return userID, nil
}

func getSignedToken(r *http.Request) (string, error) {
	authorizationHeader := r.Header.Get("Authorization")
	if authorizationHeader == "" {
		return "", errors.New("Authorization Header is missing")
	}

	// スペースを区切りとして最大２つに分割
	parts := strings.SplitN(authorizationHeader, " ", 2)
	if len(parts) != 2 || parts[0] != "Bearer" {
		return "", errors.New("invalid Authorization header format")
	}

	return parts[1], nil
}

func Authorication(authorizationUsecase *auth.AuthorizationUsecase) func(h http.Handler) http.Handler {
	return func(h http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			signedToken, err := getSignedToken(r)
			if err != nil {
				presenter.RespondUnAuthorized(w, err.Error())
				return
			}
			input := auth.AuthorizationInputDTO{SignedToken: signedToken}
			output, err := authorizationUsecase.Run(r.Context(), input)
			if err != nil {
				presenter.RespondUnAuthorized(w, err.Error())
			}
			userID := output.UserID
			// コンテキストにuserIDを含める
			ctx := context.WithValue(r.Context(), UserIDKey{}, userID)
			// 後続の処理（ハンドラ）を実行する
			h.ServeHTTP(w, r.WithContext(ctx))
		})
	}
}

func getSignedToken(r *http.Request) (string, error) {
	authorizationHeader := r.Header.Get("Authorization")
	if authorizationHeader == "" {
		return "", errors.New("Authorization Header is missing")
	}
	// スペースを区切りとして最大２つに分割
	parts := strings.SplitN(authorizationHeader, " ", 2)
	if len(parts) != 2 || parts[0] != "Bearer" {
		return "", errors.New("invalid Authorization header format")
	}
	return parts[1], nil
}