.
├── README.md
├── cmd
│   └── main.go
├── config
│   └── config.go
├── db
│   └── setup.sql
├── domain
│   └── user.go
├── infrastructure
│   ├── datastore
│   │   └── db.go
│   ├── router
│   │   └── router.go
│   └── server
│       └── server.go
├── interface
│   ├── controllers
│   │   ├── app_controller.go
│   │   ├── auth_controller.go
│   │   ├── user_controller.go
│   │   └── middleware
│   │       └── auth.go
│   ├── database
│   │   ├── sql_repository.go
│   │   └── user_repository.go
│   ├── dcontext
│   │   └── dcontext.go
│   └── network
│       └── network.go
└── usecase
    ├── repository
    │   └── user_repository.go
    └── service
        ├── auth_service.go
        └── user_service.go

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

    "CleanArchitecture_SampleApp/config"
    "CleanArchitecture_SampleApp/interface/database"

    // blank import for MySQL driver
    _ "github.com/go-sql-driver/mysql"
)

type ConnectedSql struct {
    DB *sql.DB
}

//データベースの起動
func BootMysqlDB() *ConnectedSql {

    //configからDBの読み取り
    connectionCmd := fmt.Sprintf(
        "%s:%s@tcp(%s:%s)/%s",
        config.Conf.Database.User,
        config.Conf.Database.Password,
        config.Conf.Database.Host,
        config.Conf.Database.Port,
        config.Conf.Database.Db,
    )

    // 接続情報
    var err error
    DB, err := sql.Open("mysql", connectionCmd)
    if err != nil {
        log.Fatal(err)
    }

    //接続確認
    err = DB.Ping()
    if err != nil {
        log.Fatal(err)
    }

    //外部のDBをConnectedSqlとして公開
    conn := ConnectedSql{DB: DB}

    return &conn
}

//interface層で使用可能なsqlのクエリ操作定義
func (conn *ConnectedSql) Exec(cmd string, args ...interface{}) (database.Result, error) {
    result, err := conn.DB.Exec(cmd, args...)
    if err != nil {
        return nil, err
    }
    return &SqlResult{Result: result}, nil
}

//interface層で使用可能なsqlのクエリ操作定義
func (conn *ConnectedSql) Query(cmd string, args ...interface{}) (database.Rows, error) {
    rows, err := conn.DB.Query(cmd, args...)
    if err != nil {
        return nil, err
    }
    return &SqlRows{Rows: rows}, nil
}

func (conn *ConnectedSql) QueryRow(cmd string, args ...interface{}) database.Row {
    row := conn.DB.QueryRow(cmd, args...)
    return &SqlRow{Row: row}
}

type SqlResult struct {
    Result sql.Result
}

func (r *SqlResult) LastInsertId() (int64, error) {
    return r.Result.LastInsertId()
}

func (r *SqlResult) RowsAffected() (int64, error) {
    return r.Result.RowsAffected()
}

type SqlRows struct {
    Rows *sql.Rows
}

func (r SqlRows) Scan(ctr ...interface{}) error {
    return r.Rows.Scan(ctr...)
}

func (r SqlRows) Next() bool {
    return r.Rows.Next()
}

func (r SqlRows) Close() error {
    return r.Rows.Close()
}

type SqlRow struct {
    Row *sql.Row
}

func (r SqlRow) Scan(ctr ...interface{}) error {
    return r.Row.Scan(ctr...)
}

func (ac *authController) CreateUser(ar network.ApiResponser) {

    var authCreateRequest AuthCreateRequest
    err := json.NewDecoder(ar.GetRequest().GetBody()).Decode(&authCreateRequest)
    if err != nil {
        log.Printf("%+v\n", err)
        ar.BadRequest("Invalid Request")
        return
    }

    authToken, err := ac.authService.CreateUser(&authCreateRequest.Name)
    if err != nil {
        return
    }

    authCreateResponse := AuthCreateResponse{
        Token: *authToken,
    }

    ar.Success(authCreateResponse)
}

type userRepository struct {
    db ConnectedDB
}

type UserRepository interface {
    Store(user domain.User) error
    FindByAuthToken(authToken string) (*domain.User, error)
    FindByUserID(userID string) (*domain.User, error)
    UpdateByUserID(userID string, name string) error
}

func NewUserRepository(db ConnectedDB) UserRepository {
    return &userRepository{db}
}

// データベースにUserを登録する
func (userRepository *userRepository) Store(user domain.User) error {
    _, err := userRepository.db.Exec("INSERT INTO user(user_id, auth_token, name) VALUES (?, ? ,?)", user.UserID, user.AuthToken, user.Name)
    if err != nil {
        log.Println(err)
        return err
    }
    return nil
}

// AuthTokenを条件にレコードを取得する
func (userRepository *userRepository) FindByAuthToken(authToken string) (*domain.User, error) {
    row := userRepository.db.QueryRow("SELECT * FROM user WHERE auth_token=?", authToken)
    return ConvertToUser(row)
}

// UserIDを条件にレコードを取得する
func (userRepository *userRepository) FindByUserID(userID string) (*domain.User, error) {
    row := userRepository.db.QueryRow("SELECT * FROM user WHERE user_id=?", userID)
    return ConvertToUser(row)
}

// UserIDを条件にレコードを更新する
func (userRepository *userRepository) UpdateByUserID(userID string, name string) error {
    _, err := userRepository.db.Exec("UPDATE user SET name=? WHERE user_id=?", name, userID)
    if err != nil {
        log.Println(err)
        return err
    }
    return nil
}

// convertToUser rowデータをUserデータへ変換する
func ConvertToUser(row Row) (*domain.User, error) {
    user := domain.User{}
    err := row.Scan(&user.UserID, &user.AuthToken, &user.Name)
    if err != nil {
        log.Println(err)
        return nil, err
    }
    return &user, nil
}

type ConnectedDB interface {
    Exec(string, ...interface{}) (Result, error)
    Query(string, ...interface{}) (Rows, error)
    QueryRow(string, ...interface{}) Row
}

type Result interface {
    LastInsertId() (int64, error)
    RowsAffected() (int64, error)
}

type Rows interface {
    Scan(...interface{}) error
    Next() bool
    Close() error
}

type Row interface {
    Scan(...interface{}) error
}

func (authService *authService) CreateUser(userName *string) (*string, error) {
    // UUIDでユーザIDを生成する
    userID, err := uuid.NewRandom()
    if err != nil {
        log.Println(err)
        return nil, err
    }
    userIDString := userID.String()

    // UUIDで認証トークンを生成する
    authToken, err := uuid.NewRandom()
    if err != nil {
        log.Println(err)
        return nil, err
    }
    authTokenString := authToken.String()

    user := domain.User{
        UserID:    userIDString,
        AuthToken: authTokenString,
        Name:      *userName,
    }

    // データベースにユーザデータを登録する
    err = authService.UserRepository.Store(user)
    if err != nil {
        log.Println(err)
        return nil, err
    }

    return &authTokenString, nil
}

package repository

import (
    "CleanArchitecture_SampleApp/domain"
)

//DIP(依存関係の逆転の原則）
type UserRepository interface {
    Insert(user domain.User) error
    SelectByAuthToken(authToken string) (*domain.User, error)
    SelectByPrimaryKey(userID string) (*domain.User, error)
    UpdateByPrimaryKey(userID string, name string) error
}

package domain

type User struct {
    UserID    string
    AuthToken string
    Name      string
}

func NewAuthController(db database.ConnectedDB) AuthController {
    return &authController{
        authService: service.NewAuthService(
            database.NewUserRepository(db),
        ),
    }
}

package database

type ConnectedDB interface {
    Exec(string, ...interface{}) (Result, error)
    Query(string, ...interface{}) (Rows, error)
    QueryRow(string, ...interface{}) Row
}

package datastore

type ConnectedSql struct {
    DB *sql.DB
}

//interface層で使用可能なsqlのクエリ操作定義
func (conn *ConnectedSql) Exec(cmd string, args ...interface{}) (database.Result, error) {
    result, err := conn.DB.Exec(cmd, args...)
    if err != nil {
        return nil, err
    }
    return &SqlResult{Result: result}, nil
}

//interface層で使用可能なsqlのクエリ操作定義
func (conn *ConnectedSql) Query(cmd string, args ...interface{}) (database.Rows, error) {
    rows, err := conn.DB.Query(cmd, args...)
    if err != nil {
        return nil, err
    }
    return &SqlRows{Rows: rows}, nil
}

func (conn *ConnectedSql) QueryRow(cmd string, args ...interface{}) database.Row {
    row := conn.DB.QueryRow(cmd, args...)
    return &SqlRow{Row: row}
}