// 簡易な設定（ローカル環境や、同じAWS EC2インスタンス内でポート番号違いなど）
e.Use(middleware.CORS())

// 厳密な設定
e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
  AllowOrigins: []string{"https://labstack.com", "https://labstack.net"},
  AllowHeaders: []string{echo.HeaderOrigin, echo.HeaderContentType, echo.HeaderAccept},
}))

├── Go
│   └── src
│       └── sample
│           ├── api
│           │   └─ user.go
│           ├── conf
│           │   └─ config.go
│           ├── go.mod
│           ├── go.sum
│           ├── main.go
│           ├── model
│           │   ├── db.go
│           │   └── user.go
│           └── router
│               └── router.go
│ 
└── React

package api

import (
    "time"

    "sample/model"

    "github.com/dgrijalva/jwt-go"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
    "github.com/valyala/fasthttp"
    "golang.org/x/crypto/bcrypt"
)

// jwtCustomClaims are custom claims extending default ones.
type jwtCustomClaims struct {
    UID  uint   `json:"uid"`
    Name string `json:"name"`
    jwt.StandardClaims
}

var signingKey = []byte("secret")

var Config = middleware.JWTConfig{
    Claims:     &jwtCustomClaims{},
    SigningKey: signingKey,
}

type User struct {
    ID       uint   `json:"id" form:"id" query:"id"`
    Name     string `json:"name" form:"name" query:"name"`
    Password string `json:"password" form:"password" query:"password"`
}

func MethodOverride(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        if c.Request().Method == "POST" {
            method := c.Request().PostFormValue("_method")
            if method == "PUT" || method == "PATCH" || method == "DELETE" {
                c.Request().Method = method
            }
        }
        return next(c)
    }
}

func Login(c echo.Context) error {
    username := c.FormValue("name")
    password := c.FormValue("password")

    user := model.User{}
    user.FirstByName(username)

    // Throws unauthorized error
    err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password))
    if err != nil {
        return echo.ErrUnauthorized
    }

    // Set custom claims
    claims := &jwtCustomClaims{
        user.ID,
        user.Name,
        jwt.StandardClaims{
            ExpiresAt: time.Now().Add(time.Hour * 72).Unix(),
        },
    }

    // Create token with claims
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

    // Generate encoded token and send it as response.
    t, err := token.SignedString(signingKey)
    if err != nil {
        return err
    }

    return c.JSON(http.StatusOK, echo.Map{
        "token": t,
    })
}

func Mypage(c echo.Context) error {
    return c.Render(http.StatusOK, "mypage.html", map[string]interface{}{
        "title": "Mypage",
    })
}

func SignUp(c echo.Context) error {
    return c.Render(http.StatusOK, "signup.html", map[string]interface{}{
        "title": "Login / Signup Form",
    })
}

func CreateUser(c echo.Context) error {
    name := c.FormValue("name")
    p := c.FormValue("password")
    hashed, _ := bcrypt.GenerateFromPassword([]byte(p), 12)
    password := string(hashed)

    user := model.User{
        Name:     name,
        Password: password,
    }
    user.Create()

    return c.Render(http.StatusOK, "signup.html", map[string]interface{}{
        "title": "Your account was created successfully",
    })
}

func Restricted(c echo.Context) error {
    user := c.Get("user").(*jwt.Token)
    claims := user.Claims.(*jwtCustomClaims)
    name := claims.Name
    return c.JSON(http.StatusOK, echo.Map{
        "name": name,
    })
}

package conf

const (
    USER string = "root"
    PASSWORD string = "password"
    DB string = "db_name"
    HOST string = "127.0.0.1"
    PORT string = "3306"
)

package model

import (
	"log"
	"sample/conf"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var DB *gorm.DB
var err error

func init() {
	dsn := conf.USER + ":" + conf.PASSWORD + "@tcp(" + conf.HOST + ":" + conf.PORT + ")/" + conf.DB + "?charset=utf8mb4&parseTime=True&loc=Local"
	DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatalln(dsn + "database can't connect")
	}
	DB.AutoMigrate(&User{})
}