【備忘録】REST・Clean・DDDを意識して認証APIを実装してみた話（Go）

// サインアップ用ユースケースの生成
signupUC := authuc.SignupUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
// ログイン用ユースケースの生成
loginUC := authuc.LoginUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
// 自分の情報取得用ユースケースの生成
getMeUC := meuc.GetMeUsecase{Users: d.Users}

// ハンドラーにユースケースを渡して生成
ah := authhttp.AuthHandler{Signup: signupUC, Login: loginUC}
// GET /v1/me に対応するハンドラー
mh := mehttp.MeHandler{GetMe: getMeUC}

// エラーをHTTPレスポンスに変換
if errors.Is(err, auth.ErrInvalidCredentials) {
    http.Error(w, "unauthorized", http.StatusUnauthorized) // ステータスコード 401
    return
}
if errors.Is(err, auth.ErrEmailAlreadyExists) {
    http.Error(w, "email already exists", http.StatusConflict) // ステータスコード 409
    return
}

// トークンが有効かを先に確認
let (meData, meResponse) = try await apiClient.request(
    "GET",
    path: "v1/me",
    requiresAuth: true
)
let meBody = String(data: meData, encoding: .utf8) ?? "<non-utf8 response>"
try apiClient.validate(meResponse, data: meData)
print("[Debug][me] status=\(meResponse.statusCode) body=\(meBody)")

// JWTトークンの発行例
tok, exp, err := uc.Tokens.IssueAccessToken(rec.ID, uc.TTL)
if err != nil {
    return LoginOutput{}, err
}

// トークンと有効期限を返す
return LoginOutput{AccessToken: tok, ExpiresIn: exp}, nil

Cache-Control: no-store
Pragma: no-cache

type Deps struct {
    Users       port.UserRepo       // Infrastructure
    Hasher      port.PasswordHasher // Application Logic
    Tokens      port.TokenIssuer    // Domain Logic
    DB          *pgxpool.Pool       // Infrastructure
    ShareTokens port.ShareTokenGenerator // Application Logic
}

func NewRouter(d Deps) http.Handler { ... }

signupUC := authuc.SignupUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
loginUC := authuc.LoginUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
getMeUC := meuc.GetMeUsecase{Users: d.Users}

r.Route("/v1", func(r chi.Router) {
    r.Post("/auth/signup", ah.SignupHTTP) // signupエンドポイント
    r.Post("/auth/login", ah.LoginHTTP)   // loginエンドポイント
    r.Get("/me", mh.MeHTTP)               // meエンドポイント
})

type PasswordHasher interface {
    Hash(plain string) (string, error)     // ハッシュ化
    Verify(hash, plain string) bool       // 検証
}

type Hasher struct {
    Cost int // bcryptのコスト設定
}

func (h Hasher) Hash(plain string) (string, error) {
    password, err := bcrypt.GenerateFromPassword([]byte(plain), h.Cost)
    return string(password), err
}

func (h Hasher) Verify(hash, plain string) bool {
    return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
}

type PasswordHasher interface {
    Hash(plain string) (string, error)
    Verify(hash, plain string) bool
}

type Deps struct {
    Users       port.UserRepo
    Hasher      port.PasswordHasher
    Tokens      port.TokenIssuer
    DB          *pgxpool.Pool
    ShareTokens port.ShareTokenGenerator
}

func NewRouter(d Deps) http.Handler {
    // DIで依存関係を注入し、高レベルモジュールと低レベルモジュールを分離
    loginUC := authuc.LoginUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
}

type Email string

func NewEmail(e string) (Email, error) {
    e = strings.TrimSpace(strings.ToLower(e))
    if e == "" {
        return "", errors.New("email is empty")
    }
    if !emailRegexp.MatchString(e) {
        return "", errors.New("email is invalid")
    }
    return Email(e), nil
}

signupUC := authuc.SignupUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
loginUC := authuc.LoginUsecase{Users: d.Users, Hasher: d.Hasher, Tokens: d.Tokens, TTL: 15 * time.Minute}
getMeUC := meuc.GetMeUsecase{Users: d.Users}

ah := authhttp.AuthHandler{Signup: signupUC, Login: loginUC} // 認証用エンドポイント
mh := mehttp.MeHandler{GetMe: getMeUC}                       // 現在のユーザー情報取得

r.Route("/v1", func(r chi.Router) {
    r.Post("/auth/signup", ah.SignupHTTP) // サインアップ処理
    r.Post("/auth/login", ah.LoginHTTP)   // ログイン処理
    r.Get("/me", mh.MeHTTP)               // ユーザー情報取得
})

type LoginUsecase struct {
    Users  port.UserRepo
    Hasher port.PasswordHasher
    Tokens port.TokenIssuer
}

func (uc LoginUsecase) Execute(ctx context.Context, in LoginInput) (LoginOutput, error) {
    em, err := user.NewEmail(in.Email)
    if err != nil { return LoginOutput{}, ErrBadRequest }
    rec, err := uc.Users.FindByEmail(ctx, em)
    if err != nil || !uc.Hasher.Verify(rec.PasswordHash, in.Password) { return LoginOutput{}, ErrInvalidCredentials }
    tok, exp, err := uc.Tokens.IssueAccessToken(rec.ID, uc.TTL)
    return LoginOutput{AccessToken: tok, ExpiresIn: exp}, nil
}

type PostRepository struct {
    Pool *pgxpool.Pool
}

func (r *PostRepository) Insert(ctx context.Context, p *dpost.Post) (*dpost.Post, error) {
    const q = `
        INSERT INTO quote_posts (
          user_id, book_id, quote_text, note_text, page, visibility, share_token, created_at
        ) VALUES (
          $1, $2, $3, $4, $5, $6, $7, $8
        ) RETURNING id, created_at
    `
    var id string
    var createdAt time.Time
    err := r.Pool.QueryRow(ctx, q, ...).Scan(&id, &createdAt)
    return p, err
}

users := newMemUserRepo()
hasher := bcrypt.Hasher{Cost: 4} 
tokens := jwt.Issuer{Secret: "supersecret_supersecret"}

srv := httptest.NewServer(httpad.NewRouter(httpad.Deps{
    Users: users, Hasher: hasher, Tokens: tokens,
}))

signupBody := []byte(`{"email":"test@example.com","password":"password123"}`)
res, err := http.Post(srv.URL+"/v1/auth/signup", "application/json", bytes.NewReader(signupBody))
if res.StatusCode != http.StatusCreated {
    t.Fatalf("signup status=%d", res.StatusCode)
}

type User struct {
    ID    UserID
    Email Email
}

func (uc LoginUsecase) Execute(ctx context.Context, in LoginInput) (LoginOutput, error) {
    ...
}

type Deps struct {
    Users port.UserRepo
    ...
}

func NewRouter(d Deps) http.Handler {
    ...
}

FROM golang:1.24-alpine AS build
COPY services/backend ./services/backend
RUN go build -o /bin/api ./services/backend/cmd/api

// Email はメールアドレスを表す値オブジェクト（Value Object）です
// 役割：正規化とバリデーション
package user

import (
	"errors"
	"regexp"
	"strings"
)

// emailの正規表現（最低限なルール）
var emailRegexp = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)

type Email string

// VOを生成する関数
func NewEmail(e string) (Email, error) {
	e = strings.TrimSpace(strings.ToLower(e))
	// バリデーション
	if e == "" {
		return "", errors.New("email is empty")
	}
	if !emailRegexp.MatchString(e) {
		return "", errors.New("email is invalid")
	}
	return Email(e), nil
}

func (e Email) String() string {
	return string(e)
}

package user

type User struct {
    ID    UserID
    Email Email
    Role  string
}

users := postgres.UserRepo{DB: db}

var (
  ErrInvalidCredentials = errors.New("invalid credentials")
)

if errors.Is(err, ErrInvalidCredentials) {
    http.Error(w, "unauthorized", http.StatusUnauthorized)
    return
}