feat: Extract from other repo

14 files changed, 455 insertions, 0 deletions

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/README.md
diff --git a/auth/config.go b/auth/config.go
new file mode 100644
index 0000000..6a55839
--- /dev/null
+++ b/auth/config.go
@@ -0,0 +1,34 @@
+package auth
+
+import (
+	"encoding/hex"
+	"errors"
+	"os"
+
+	"github.com/martinlehoux/kagamigo/core"
+	"golang.org/x/exp/slog"
+)
+
+var (
+	ErrCookieBadLength = errors.New("cookie secret must be 32 bytes")
+)
+
+type AuthConfig struct {
+	Domain       string
+	CookieSecret []byte
+}
+
+func LoadCookieSecret(cookieSecretString string) []byte {
+	cookiesSecret, err := hex.DecodeString(cookieSecretString)
+	if err != nil {
+		err = core.Wrap(err, "error decoding cookie secret")
+		slog.Error(err.Error())
+		os.Exit(1)
+	}
+	if len(cookiesSecret) != 32 {
+		slog.Error(ErrCookieBadLength.Error())
+		os.Exit(1)
+	}
+	slog.Info("cookie secret loaded")
+	return cookiesSecret
+}
diff --git a/auth/cookie.go b/auth/cookie.go
new file mode 100644
index 0000000..61349fa
--- /dev/null
+++ b/auth/cookie.go
@@ -0,0 +1,21 @@
+package auth
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/martinlehoux/kagamigo/core"
+)
+
+func CraftCookie(id core.ID, config AuthConfig) http.Cookie {
+	expiresAt := time.Now().Add(24 * time.Hour)
+	cookieValue := encrypt(config.CookieSecret, fmt.Sprintf("%s:%d", id.String(), expiresAt.Unix()))
+	return http.Cookie{
+		Domain:  config.Domain,
+		Name:    "authentication",
+		Value:   cookieValue,
+		Expires: expiresAt,
+		Path:    "/",
+	}
+}
diff --git a/auth/crypto.go b/auth/crypto.go
new file mode 100644
index 0000000..254539f
--- /dev/null
+++ b/auth/crypto.go
@@ -0,0 +1,54 @@
+package auth
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+
+	"github.com/martinlehoux/kagamigo/core"
+)
+
+var (
+	ErrEncryptedTooShort = errors.New("encrypted text is too short")
+)
+
+func encrypt(secret []byte, plainText string) string {
+	block, err := aes.NewCipher(secret)
+	core.Expect(err, "error creating AES cipher")
+
+	aead, err := cipher.NewGCM(block)
+	core.Expect(err, "error creating AEAD")
+
+	nonce := make([]byte, aead.NonceSize())
+	_, err = rand.Read(nonce)
+	core.Expect(err, "error generating nonce")
+
+	return base64.URLEncoding.EncodeToString(aead.Seal(nonce, nonce, []byte(plainText), nil))
+}
+
+func decrypt(secret []byte, encryptedText string) (string, error) {
+	encryptedBytes, err := base64.URLEncoding.DecodeString(encryptedText)
+	if err != nil {
+		err = core.Wrap(err, "error decoding base64")
+		return "", err
+	}
+	block, err := aes.NewCipher(secret)
+	core.Expect(err, "error creating AES cipher")
+
+	aead, err := cipher.NewGCM(block)
+	core.Expect(err, "error creating AEAD")
+
+	nonceSize := aead.NonceSize()
+	if len(encryptedBytes) < nonceSize {
+		return "", ErrEncryptedTooShort
+	}
+	nonce, cipherText := encryptedBytes[:nonceSize], encryptedBytes[nonceSize:]
+	plainBytes, err := aead.Open(nil, nonce, cipherText, nil)
+	if err != nil {
+		err = core.Wrap(err, "error decrypting")
+		return "", err
+	}
+	return string(plainBytes), nil
+}
diff --git a/auth/middlewares.go b/auth/middlewares.go
new file mode 100644
index 0000000..433cbd2
--- /dev/null
+++ b/auth/middlewares.go
@@ -0,0 +1,82 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/martinlehoux/kagamigo/core"
+	"golang.org/x/exp/slog"
+)
+
+var (
+	ErrUserNotLoggedIn = errors.New("user not logged in")
+	ErrCookieExpired   = errors.New("cookie expired")
+	ErrBadCookie       = errors.New("invalid cookie")
+)
+
+type userContext struct{}
+
+func Unauthorized(w http.ResponseWriter, err error) {
+	w.WriteHeader(http.StatusUnauthorized)
+	if err != nil {
+		_, err = w.Write([]byte(err.Error()))
+		core.Expect(err, "error writing response")
+	}
+}
+
+func CookieAuthMiddleware(loadUser func(context.Context, ...any) (any, error), config AuthConfig) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := r.Context()
+			cookie, err := r.Cookie("authentication")
+			if errors.Is(err, http.ErrNoCookie) {
+				next.ServeHTTP(w, r)
+				return
+			}
+			core.Expect(err, "error reading cookie")
+
+			authentication, err := decrypt(config.CookieSecret, cookie.Value)
+			if err != nil {
+				err = core.Wrap(err, "error decrypting cookie")
+				slog.Warn(err.Error())
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			parts := strings.Split(authentication, ":")
+			if len(parts) != 2 {
+				slog.Warn(ErrBadCookie.Error())
+				http.Error(w, ErrBadCookie.Error(), http.StatusBadRequest)
+				return
+			}
+			userId, err := core.ParseID(parts[0])
+			if err != nil {
+				err = core.Wrap(err, "error parsing user id")
+				slog.Warn(err.Error())
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			expiresAtSeconds, err := strconv.Atoi(parts[1])
+			if err != nil {
+				err = core.Wrap(err, "error parsing expires at")
+				slog.Warn(err.Error())
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			expiresAt := time.Unix(int64(expiresAtSeconds), 0)
+			if time.Now().After(expiresAt) {
+				slog.Warn(ErrCookieExpired.Error())
+				http.Error(w, ErrCookieExpired.Error(), http.StatusUnauthorized)
+				return
+			}
+			user, err := loadUser(ctx, userId)
+			core.Expect(err, "error loading user")
+
+			ctx = context.WithValue(ctx, userContext{}, user)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
diff --git a/core/core.go b/core/core.go
new file mode 100644
index 0000000..5cd654d
--- /dev/null
+++ b/core/core.go
@@ -0,0 +1,34 @@
+package core
+
+import (
+	"encoding/base64"
+
+	"github.com/gofrs/uuid"
+)
+
+type ID struct {
+	uuid.UUID
+}
+
+func NewID() ID {
+	id, err := uuid.NewV4()
+	Expect(err, "error generating uuid")
+
+	return ID{id}
+}
+
+func (id ID) String() string {
+	return base64.RawURLEncoding.EncodeToString(id.Bytes())
+}
+
+func ParseID(value string) (ID, error) {
+	bytes, err := base64.RawURLEncoding.DecodeString(value)
+	if err != nil {
+		return ID{}, Wrap(err, "error decoding value")
+	}
+	id, err := uuid.FromBytes(bytes)
+	if err != nil {
+		return ID{}, Wrap(err, "error parsing uuid")
+	}
+	return ID{id}, nil
+}
diff --git a/core/error.go b/core/error.go
new file mode 100644
index 0000000..7b1871a
--- /dev/null
+++ b/core/error.go
@@ -0,0 +1,16 @@
+package core
+
+import "fmt"
+
+func Wrap(err error, msg string) error {
+	return fmt.Errorf("%s: %w", msg, err)
+}
+
+func Expect(err error, msg string) {
+	if err != nil {
+		if msg != "" {
+			err = Wrap(err, msg)
+		}
+		panic(err)
+	}
+}
diff --git a/core/file.go b/core/file.go
new file mode 100644
index 0000000..083d8f7
--- /dev/null
+++ b/core/file.go
@@ -0,0 +1,38 @@
+package core
+
+import (
+	"fmt"
+	"io"
+	"mime/multipart"
+	"os"
+)
+
+type File (string)
+
+func NewFile(ext string) File {
+	return File(NewID().String() + ext)
+}
+
+func (file File) Path() string {
+	return fmt.Sprintf("media/files/%s", file)
+}
+
+func (file *File) Save(raw multipart.File) error {
+	dest, err := os.Create(file.Path())
+	if err != nil {
+		return Wrap(err, "error creating file destination")
+	}
+	_, err = io.Copy(dest, raw)
+	if err != nil {
+		return Wrap(err, "error copying to file destination")
+	}
+	return nil
+}
+
+func (file *File) Delete() error {
+	err := os.Remove(file.Path())
+	if err != nil {
+		return Wrap(err, "error deleting file")
+	}
+	return nil
+}
diff --git a/core/http.go b/core/http.go
new file mode 100644
index 0000000..778c5c9
--- /dev/null
+++ b/core/http.go
@@ -0,0 +1,28 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"html/template"
+	"net/http"
+
+	"github.com/a-h/templ"
+)
+
+func ExecuteTemplate(w http.ResponseWriter, tpl template.Template, name string, data interface{}) {
+	var buf bytes.Buffer
+	err := tpl.ExecuteTemplate(&buf, name, data)
+	Expect(err, "error executing template")
+	w.Header().Set("Content-Type", "text/html; charset=UTF-8")
+	_, err = buf.WriteTo(w)
+	Expect(err, "error writing template to response writer")
+}
+
+func RenderPage(ctx context.Context, page templ.Component, w http.ResponseWriter) {
+	var buf bytes.Buffer
+	err := page.Render(ctx, &buf)
+	Expect(err, "error rendering page")
+	w.Header().Set("Content-Type", "text/html; charset=UTF-8")
+	_, err = buf.WriteTo(w)
+	Expect(err, "error writing page to response writer")
+}
diff --git a/core/image.go b/core/image.go
new file mode 100644
index 0000000..c06cbd8
--- /dev/null
+++ b/core/image.go
@@ -0,0 +1,38 @@
+package core
+
+import (
+	"fmt"
+	"io"
+	"mime/multipart"
+	"os"
+)
+
+type Image (ID)
+
+func NewImage() Image {
+	return Image(NewID())
+}
+
+func (image Image) Path() string {
+	return fmt.Sprintf("media/images/%s", image)
+}
+
+func (image *Image) Save(raw multipart.File) error {
+	dest, err := os.Create(image.Path())
+	if err != nil {
+		return Wrap(err, "error creating image destination")
+	}
+	_, err = io.Copy(dest, raw)
+	if err != nil {
+		return Wrap(err, "error copying to image destination")
+	}
+	return nil
+}
+
+func (image *Image) Delete() error {
+	err := os.Remove(image.Path())
+	if err != nil {
+		return Wrap(err, "error deleting image")
+	}
+	return nil
+}
diff --git a/core/middleware.go b/core/middleware.go
new file mode 100644
index 0000000..55e67fb
--- /dev/null
+++ b/core/middleware.go
@@ -0,0 +1,31 @@
+package core
+
+import (
+	"errors"
+	"net/http"
+
+	"golang.org/x/exp/slog"
+)
+
+func RecoverMiddleware(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			if rcv := recover(); rcv != nil {
+				switch err := rcv.(type) {
+				case error:
+					if errors.Is(err, http.ErrAbortHandler) {
+						panic(rcv)
+					}
+					slog.Error(err.Error())
+					http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+				default:
+					panic(err)
+				}
+			}
+		}()
+
+		next.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
diff --git a/core/template.go b/core/template.go
new file mode 100644
index 0000000..3a6833a
--- /dev/null
+++ b/core/template.go
@@ -0,0 +1,33 @@
+package core
+
+import (
+	"github.com/kataras/i18n"
+)
+
+type Tr = func(format string, args ...any) string
+
+type WithLanguage interface {
+	Language() string
+}
+
+func GetTr(wl WithLanguage) Tr {
+	lang := "en-GB"
+	if wl != nil {
+		lang = wl.Language()
+	}
+	return func(format string, args ...any) string { return i18n.Tr(lang, format, args...) }
+}
+
+type LoginContext[U any] struct {
+	IsLoggedIn bool
+	User       U
+	Tr         Tr
+}
+
+func GetLoginContext[U WithLanguage](user U, ok bool) LoginContext[U] {
+	return LoginContext[U]{
+		IsLoggedIn: ok,
+		User:       user,
+		Tr:         GetTr(user),
+	}
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..03c9fcd
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,20 @@
+module github.com/martinlehoux/kagamigo
+
+go 1.20
+
+require (
+	github.com/a-h/templ v0.2.408
+	github.com/gofrs/uuid v4.4.0+incompatible
+	github.com/kataras/i18n v0.0.8
+	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
+)
+
+require (
+	github.com/BurntSushi/toml v1.2.1 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/net v0.9.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..c3c925b
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,26 @@
+github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak=
+github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/a-h/templ v0.2.408 h1:WmXdjVjxjMJyjRg+34cgg+hRC0duDg9OJy6euZbS4ek=
+github.com/a-h/templ v0.2.408/go.mod h1:6Lfhsl3Z4/vXl7jjEjkJRCqoWDGjDnuKgzjYMDSddas=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
+github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/kataras/i18n v0.0.8 h1:thiDRqq4fN2sQOK5CwR5Yh1yT7swP6B3wnadILhqjhk=
+github.com/kataras/i18n v0.0.8/go.mod h1:M/yRAqQ3Y7z2oSpotxG/+nPrgsJLas6t0kEJfIJk98E=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=