chore(deps): update golang docker tag to v1.24.6

.gitea/workflows/build.yaml

@@ -11,5 +11,5 @@ jobs:
     steps:
       - name: Check out repository code
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
-      - run: docker build . -t me-fit-test
+      - run: docker build . -t web-app-template-test
-      - run: docker rmi me-fit-test
+      - run: docker rmi web-app-template-test

.gitea/workflows/buildAndPush.yaml

@@ -11,8 +11,8 @@ jobs:
       - name: Check out repository code
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
       - run: docker login git.wundenbergs.de -u tim -p ${{ secrets.DOCKER_GITEA_TOKEN }}
-      - run: docker build . -t git.wundenbergs.de/x/me-fit:latest -t git.wundenbergs.de/x/me-fit:$GITHUB_SHA
+      - run: docker build . -t git.wundenbergs.de/x/web-app-template:latest -t git.wundenbergs.de/x/web-app-template:$GITHUB_SHA
-      - run: docker push git.wundenbergs.de/x/me-fit:latest
+      - run: docker push git.wundenbergs.de/x/web-app-template:latest
-      - run: docker push git.wundenbergs.de/x/me-fit:$GITHUB_SHA
+      - run: docker push git.wundenbergs.de/x/web-app-template:$GITHUB_SHA
-      - run: docker rmi git.wundenbergs.de/x/me-fit:latest git.wundenbergs.de/x/me-fit:$GITHUB_SHA
+      - run: docker rmi git.wundenbergs.de/x/web-app-template:latest git.wundenbergs.de/x/web-app-template:$GITHUB_SHA
 

.mockery.yaml

@@ -1,12 +1,13 @@
 with-expecter: True
 dir: mocks/
 outpkg: mocks
+issue-845-fix: True
 packages:
-  me-fit/service:
+  web-app-template/service:
     interfaces:
-      RandomService:
+      Random:
-      ClockService:
+      Clock:
-      MailService:
+      Mail:
-  me-fit/db:
+  web-app-template/db:
     interfaces:
-      AuthDb:
+      Auth:

Dockerfile

@@ -1,26 +1,32 @@
-FROM golang:1.23.3@sha256:73f06be4578c9987ce560087e2e2ea6485fb605e3910542cadd8fa09fc5f3e31 AS builder_go
+FROM golang:1.24.6@sha256:2c89c41fb9efc3807029b59af69645867cfe978d2b877d475be0d72f6c6ce6f6 AS builder_go
-WORKDIR /me-fit
+WORKDIR /web-app-template
-RUN go install github.com/a-h/templ/cmd/templ@latest && go install github.com/vektra/mockery/v2@latest
+RUN go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+RUN go install github.com/a-h/templ/cmd/templ@latest
+RUN go install github.com/vektra/mockery/v2@latest
 COPY go.mod go.sum ./
 RUN go mod download
 COPY . ./
-RUN templ generate && mockery && go test ./... && go build -o /me-fit/me-fit .
+RUN templ generate
+RUN mockery --log-level warn
+RUN go test ./...
+RUN golangci-lint run ./...
+RUN go build -o /web-app-template/web-app-template .
 
 
-FROM node:22.11.0@sha256:5c76d05034644fa8ecc9c2aa84e0a83cd981d0ef13af5455b87b9adf5b216561 AS builder_node
+FROM node:22.18.0@sha256:3218f0d1b9e4b63def322e9ae362d581fbeac1ef21b51fc502ef91386667ce92 AS builder_node
-WORKDIR /me-fit
+WORKDIR /web-app-template
 COPY package.json package-lock.json ./
 RUN npm clean-install
 COPY . ./
 RUN npm run build
 
 
-FROM debian:12.8@sha256:10901ccd8d249047f9761845b4594f121edef079cfd8224edebd9ea726f0a7f6
+FROM debian:12.11@sha256:b6507e340c43553136f5078284c8c68d86ec8262b1724dde73c325e8d3dcdeba
-WORKDIR /me-fit
+WORKDIR /web-app-template
 RUN apt-get update && apt-get install -y ca-certificates && echo "" > .env
 COPY migration ./migration
-COPY --from=builder_go /me-fit/me-fit ./me-fit
+COPY --from=builder_go /web-app-template/web-app-template ./web-app-template
-COPY --from=builder_node /me-fit/static ./static
+COPY --from=builder_node /web-app-template/static ./static
 EXPOSE 8080
-ENTRYPOINT ["/me-fit/me-fit"]
+ENTRYPOINT ["/web-app-template/web-app-template"]
 

Readme.md

@@ -1,44 +1,98 @@
 
-# stackFAST
+# Web-App-Template
 
-Your (almost) independent tech stack to host on a VPC.
+A basic template with authentication to easily host on a VPC.
 
 ## Features
 
-stackFAST includes everything you need to build your App. Focus yourself on developing your idea, instead of "wasting" time on things like setting up auth and observability. This blueprint tries to include as much as possible, but still keep it simple.
+This template includes everything essential to build an app. It includes the following features:
 
-The blueprint contains the following features:
+- Authentication: Users can login, logout, register and reset their password. (for increased security TOTP is planned aswell.)
-- Authentication: Users can login, logout, register and reset their password. For increased security TOTP is available aswell.
+- Observability: The stack contains an Grafana+Prometheus instance for basic monitoring. You are able to add alerts and get notified on your phone. 
-- Observability: The stack contains an Grafana+Prometheus instance for basic monitoring. You are able to add alerts and get notified on your phone. For web analytics umami is included, which is an lighweight self hosted alternative to google analytics.
 - Mail: You are able to send mail with SMTP. You still need an external Mail Server, but a guide on how to set that up with a custom domain is included.
-- SSL: This is included by using traefik as reverse proxy. It handles SSL certificates automatically. Furthermore all services are accessible through subdomains. Best thing is, you can add your more with 3 lines of code
+- SSL: This is included by using traefik as reverse proxy. It handles SSL certificates automatically. Furthermore all services are accessible through subdomains.
-- Actual Stack: SSG SvelteKit + Tailwindcss + DaisyUI + GO Backend for easy and fast feature development
+- Stack: Tailwindcss + HTMX + GO Backend with templ and sqlite
 
 
 ## Architecture Design Decisions
 
 ### Authentication
 
-Authentication is a broad topic. Many people think you should not consider implementing authentication yourself. On the other hand, experts at OWASP don't recommend this in their cheat sheet on that topic. I'm going to explain my criterions and afterwards take a decision.
+Authentication is a broad topic. Many people think you should not consider implementing authentication yourself. On the other hand, If only security experts are allowed to write software, what does that result in? I'm going to explain my criterions and afterwards take a decision.
 
 There are a few restrictions I would like to contain:
-- I want this blueprint do as much as as possible without relying on external services. This way the things needs to be done on other website are very minimal. Furthermore I would like to take back privacy from BigTech.
+- I want this template do as much as as possible without relying on external services. This way the setup cost and dependencies can be minimized.
-- I think most cloud services are overpriced. I want to provide an alternative approach with self holsting. But I don't like the idea to spin up 30 services for a small app with 0 users. It should still be possible to run on a small VPC (2vcpu, 2GB).
+- It should still be possible to run on a small VPC (2vcpu, 2GB).
 - It should be as secure as possible
 
-As of 2024 there are 4 options:
+I determined 4 options:
-- Implement the authentication myself: If I'm holding thight to the cheat sheet, I "should" be able to doge "most" security risks and attacks according to this topic. Unfortanatly I'm not an expert in this field and will do some errors. If people will buy this blueprint, I probably can't sleep well. Especially if real users start using it. At least this has the advantage of not adding adittional services or configuration to the project.
+1. Implement the authentication myself
-- Using OAuth2 with Google and Apple: Using OAuth2 is the standard for secure applications. Google and Apple has their experts. They deal with attacks every hour of the day. This has the advantage, that users don't have to create new credentials. The only disatvantage is my personal hate on big tech.
+2. Using OAuth2 with Keycloak
-- Using OAuth2 with Keycloak: Same as above, just that the OAuth2 endpoint is another self hosted service. The only advantage is, it's not proprietary and self hosted. But users are not used to get redirected to a key cloak on sign up. They are used to sign in with Google though. Furthermore Google et. al are protecting themselves against credential stuffing attacks etc.
+3. Using OAuth2 with Google and Apple
-- Firebase, Clerk, etc.: Users have to sign up again AND blueprint users have to setup another project.
+4. Firebase, Clerk, etc.
 
-Even though I would really implement authentication myself, I think OAuth2 with external providers is the best bet. Especially because my reasoning is privacy, which most people just don't care about enough. Using this approach, adding in a keycloak is possible without breaking changes at a later point, as long as I keep the Google Sign In.
+
+#### 1. Implement the authentication myself 
+
+It's always possible to implement it myself. The topic of authentication is something special though.
+
+Pros:
+    - Great Cheat cheets from OWASP
+    - No adittional configuration or services needed
+    - Great learning experience on the topic "security"
+Cons: 
+    - Great attack vector
+    - Introcution of vlunerabillities is possible
+    - No DDOS protection
+
+#### 2. Using OAuth2 with Google and Apple
+
+Instead of implementing authentication from scratch, an external OAuth2 provider is embedded into the application.
+
+Pros:
+    - The Systems of BigTech are probably safer. They have security experts employed.
+    - The other external system is responsible to prevent credential stuffing attacks, etc.
+    - Users don't have to create new credentials
+Cons:
+    - High dependency on those providers
+    - Single Point of failure (If your account is banned, your application access get's lost as well.)
+    - It's possible that these providers ban the whole application (All users lose access)
+    - There still needs to be implemented some logic
+    - Full application integration can be difficult
+
+#### 3. Using OAuth2 with Keycloak 
+
+This option is almost identical with the previois one, but the provider is self hosted.
+
+Pros:
+    - Indipendent from 3rd party providers
+    - The credentials are stored safly
+Cons:
+    - Self hosted (no DDOS protection, etc.)
+    - There still needs to be implemented some logic server side
+    - Full application integration can be difficult
+
+
+#### 4. Firebase, Clerk, etc.
+
+Users can sign in with a seperate sdk on your website 
+
+Pros:
+    - Safe and Sound authentication
+Cons:
+    - Dependent on those providers / adittional setup needed
+    - Application can be banned
+    - Still some integration code needed
+
+#### Decision
+
+I've decided on implementing authentication myself, as this is a great learning opportunity. It may not be as secure as other solutions, but if I keep tighly to the OWASP recommendations, it should should good enough.
 
 
 ### Email
 
-For Email verification, etc. a mail server is needed, that can send a whole lot of mails. Aditionally, a mail account is needed for incoming mails. I thought about self hosting, but unfortunatly this is a hastle to maintain. Not only you have to setup a mail server, which is not as easy as it sounds, you also have to "register" your mail server for diffrent providers. Otherwise you are not able to send and receive emails. Thus, the first external service is needed.
+For Email verification, etc. a mail server is needed, that can send a whole lot of mails. Aditionally, a mail account is needed for incoming emails. I thought about self hosting, but unfortunatly this is a hastle to maintain. Not only you have to setup a mail server, which is not as easy as it sounds, you also have to "register" your mail server for diffrent providers. Otherwise you are not able to send and receive emails.
 
-In order to not vendor lock in, I decided to use an SMTP relay in favor of a vendor specific API. You are free to choose a transactional mail provider. I chose brevo.com. They have a generous free tier of 300 mails per day. You can either upgrade to a monthly plan 10$ for 20k mails or buy credits for 30$ for 5k mails. Most provider provide 100 mails / day for free.
+In order to not vendor lock in, I decided to use an SMTP relay in favor of a vendor specific API. I chose brevo.com. They have a generous free tier of 300 mails per day. You can either upgrade to a monthly plan 10$ for 20k mails or buy credits for 30$ for 5k mails.
 
 

db/auth.go

@@ -1,8 +1,8 @@
 package db
 
 import (
-	"me-fit/types"
+	"web-app-template/log"
-	"me-fit/utils"
+	"web-app-template/types"
 
 	"database/sql"
 	"errors"
@@ -13,92 +13,72 @@ import (
 )
 
 var (
-	ErrUserNotFound    = errors.New("User not found")
+	ErrNotFound      = errors.New("value not found")
-	ErrUserExists      = errors.New("User already exists")
+	ErrAlreadyExists = errors.New("row already exists")
-	ErrSessionNotFound = errors.New("Session not found")
 )
 
-type User struct {
+type Auth interface {
-	Id              uuid.UUID
+	InsertUser(user *types.User) error
-	Email           string
+	UpdateUser(user *types.User) error
-	EmailVerified   bool
+	GetUserByEmail(email string) (*types.User, error)
-	EmailVerifiedAt *time.Time
+	GetUser(userId uuid.UUID) (*types.User, error)
-	IsAdmin         bool
-	Password        []byte
-	Salt            []byte
-	CreateAt        time.Time
-}
-
-func NewUser(id uuid.UUID, email string, emailVerified bool, emailVerifiedAt *time.Time, isAdmin bool, password []byte, salt []byte, createAt time.Time) *User {
-	return &User{
-		Id:              id,
-		Email:           email,
-		EmailVerified:   emailVerified,
-		EmailVerifiedAt: emailVerifiedAt,
-		IsAdmin:         isAdmin,
-		Password:        password,
-		Salt:            salt,
-		CreateAt:        createAt,
-	}
-}
-
-type Session struct {
-	Id        string
-	UserId    uuid.UUID
-	CreatedAt time.Time
-}
-
-func NewSession(id string, userId uuid.UUID, createdAt time.Time) *Session {
-	return &Session{
-		Id:        id,
-		UserId:    userId,
-		CreatedAt: createdAt,
-	}
-}
-
-type AuthDb interface {
-	InsertUser(user *User) error
-	GetUser(email string) (*User, error)
-	GetUserById(userId uuid.UUID) (*User, error)
 	DeleteUser(userId uuid.UUID) error
-	UpdateUserPassword(userId uuid.UUID, newHash []byte) error
 
-	InsertEmailVerificationToken(userId uuid.UUID, token string) error
+	InsertToken(token *types.Token) error
-	GetEmailVerificationToken(userId uuid.UUID) (string, error)
+	GetToken(token string) (*types.Token, error)
+	GetTokensByUserIdAndType(userId uuid.UUID, tokenType types.TokenType) ([]*types.Token, error)
+	GetTokensBySessionIdAndType(sessionId string, tokenType types.TokenType) ([]*types.Token, error)
+	DeleteToken(token string) error
 
-	InsertSession(session *Session) error
+	InsertSession(session *types.Session) error
-	GetSession(sessionId string) (*Session, error)
+	GetSession(sessionId string) (*types.Session, error)
-	DeleteOldSessions(userId uuid.UUID) error
+	GetSessions(userId uuid.UUID) ([]*types.Session, error)
 	DeleteSession(sessionId string) error
+	DeleteOldSessions(userId uuid.UUID) error
 }
 
-type AuthDbSqlite struct {
+type AuthSqlite struct {
 	db *sql.DB
 }
 
-func NewAuthDbSqlite(db *sql.DB) *AuthDbSqlite {
+func NewAuthSqlite(db *sql.DB) *AuthSqlite {
-	return &AuthDbSqlite{db: db}
+	return &AuthSqlite{db: db}
 }
 
-func (db AuthDbSqlite) InsertUser(user *User) error {
+func (db AuthSqlite) InsertUser(user *types.User) error {
 	_, err := db.db.Exec(`
-		INSERT INTO user (user_uuid, email, email_verified, email_verified_at, is_admin, password, salt, created_at) 
+		INSERT INTO user (user_id, email, email_verified, email_verified_at, is_admin, password, salt, created_at) 
 		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
 		user.Id, user.Email, user.EmailVerified, user.EmailVerifiedAt, user.IsAdmin, user.Password, user.Salt, user.CreateAt)
 
 	if err != nil {
 		if strings.Contains(err.Error(), "email") {
-			return ErrUserExists
+			return ErrAlreadyExists
 		}
 
-		utils.LogError("SQL error InsertUser", err)
+		log.Error("SQL error InsertUser: %v", err)
 		return types.ErrInternal
 	}
 
 	return nil
 }
 
-func (db AuthDbSqlite) GetUser(email string) (*User, error) {
+func (db AuthSqlite) UpdateUser(user *types.User) error {
+	_, err := db.db.Exec(`
+		UPDATE user 
+		SET email_verified = ?, email_verified_at = ?, password = ?
+		WHERE user_id = ?`,
+		user.EmailVerified, user.EmailVerifiedAt, user.Password, user.Id)
+
+	if err != nil {
+		log.Error("SQL error UpdateUser: %v", err)
+		return types.ErrInternal
+	}
+
+	return nil
+}
+
+func (db AuthSqlite) GetUserByEmail(email string) (*types.User, error) {
 	var (
 		userId          uuid.UUID
 		emailVerified   bool
@@ -110,22 +90,22 @@ func (db AuthDbSqlite) GetUser(email string) (*User, error) {
 	)
 
 	err := db.db.QueryRow(`
-		SELECT user_uuid, email_verified, email_verified_at, password, salt, created_at
+		SELECT user_id, email_verified, email_verified_at, password, salt, created_at
 		FROM user 
 		WHERE email = ?`, email).Scan(&userId, &emailVerified, &emailVerifiedAt, &password, &salt, &createdAt)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, ErrUserNotFound
+			return nil, ErrNotFound
 		} else {
-			utils.LogError("SQL error GetUser", err)
+			log.Error("SQL error GetUser: %v", err)
 			return nil, types.ErrInternal
 		}
 	}
 
-	return NewUser(userId, email, emailVerified, emailVerifiedAt, isAdmin, password, salt, createdAt), nil
+	return types.NewUser(userId, email, emailVerified, emailVerifiedAt, isAdmin, password, salt, createdAt), nil
 }
 
-func (db AuthDbSqlite) GetUserById(userId uuid.UUID) (*User, error) {
+func (db AuthSqlite) GetUser(userId uuid.UUID) (*types.User, error) {
 	var (
 		email           string
 		emailVerified   bool
@@ -139,153 +119,287 @@ func (db AuthDbSqlite) GetUserById(userId uuid.UUID) (*User, error) {
 	err := db.db.QueryRow(`
 		SELECT email, email_verified, email_verified_at, password, salt, created_at
 		FROM user 
-		WHERE user_uuid = ?`, userId).Scan(&email, &emailVerified, &emailVerifiedAt, &password, &salt, &createdAt)
+		WHERE user_id = ?`, userId).Scan(&email, &emailVerified, &emailVerifiedAt, &password, &salt, &createdAt)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, ErrUserNotFound
+			return nil, ErrNotFound
 		} else {
-			utils.LogError("SQL error GetUser", err)
+			log.Error("SQL error GetUser %v", err)
 			return nil, types.ErrInternal
 		}
 	}
 
-	return NewUser(userId, email, emailVerified, emailVerifiedAt, isAdmin, password, salt, createdAt), nil
+	return types.NewUser(userId, email, emailVerified, emailVerifiedAt, isAdmin, password, salt, createdAt), nil
 }
 
-func (db AuthDbSqlite) DeleteUser(userId uuid.UUID) error {
+func (db AuthSqlite) DeleteUser(userId uuid.UUID) error {
 
 	tx, err := db.db.Begin()
 	if err != nil {
-		utils.LogError("Could not start transaction", err)
+		log.Error("Could not start transaction: %v", err)
 		return types.ErrInternal
 	}
 
 	_, err = tx.Exec("DELETE FROM workout WHERE user_id = ?", userId)
 	if err != nil {
-		tx.Rollback()
+		_ = tx.Rollback()
-		utils.LogError("Could not delete workouts", err)
+		log.Error("Could not delete workouts: %v", err)
 		return types.ErrInternal
 	}
 
-	_, err = tx.Exec("DELETE FROM user_token WHERE user_uuid = ?", userId)
+	_, err = tx.Exec("DELETE FROM token WHERE user_id = ?", userId)
 	if err != nil {
-		tx.Rollback()
+		_ = tx.Rollback()
-		utils.LogError("Could not delete user tokens", err)
+		log.Error("Could not delete user tokens: %v", err)
 		return types.ErrInternal
 	}
 
-	_, err = tx.Exec("DELETE FROM session WHERE user_uuid = ?", userId)
+	_, err = tx.Exec("DELETE FROM session WHERE user_id = ?", userId)
 	if err != nil {
-		tx.Rollback()
+		_ = tx.Rollback()
-		utils.LogError("Could not delete sessions", err)
+		log.Error("Could not delete sessions: %v", err)
 		return types.ErrInternal
 	}
 
-	_, err = tx.Exec("DELETE FROM user WHERE user_uuid = ?", userId)
+	_, err = tx.Exec("DELETE FROM user WHERE user_id = ?", userId)
 	if err != nil {
-		tx.Rollback()
+		_ = tx.Rollback()
-		utils.LogError("Could not delete user", err)
+		log.Error("Could not delete user: %v", err)
 		return types.ErrInternal
 	}
 
 	err = tx.Commit()
 	if err != nil {
-		utils.LogError("Could not commit transaction", err)
+		log.Error("Could not commit transaction: %v", err)
 		return types.ErrInternal
 	}
 
 	return nil
 }
 
-func (db AuthDbSqlite) UpdateUserPassword(userId uuid.UUID, newHash []byte) error {
+func (db AuthSqlite) InsertToken(token *types.Token) error {
-	_, err := db.db.Exec("UPDATE user SET password = ? WHERE user_uuid = ?", newHash, userId)
-	if err != nil {
-		utils.LogError("Could not update password", err)
-		return types.ErrInternal
-	}
-	return nil
-}
-
-func (db AuthDbSqlite) InsertEmailVerificationToken(userId uuid.UUID, token string) error {
 	_, err := db.db.Exec(`
-		INSERT INTO user_token (user_uuid, type, token, created_at) 
+		INSERT INTO token (user_id, session_id, type, token, created_at, expires_at)
-		VALUES (?, 'email_verify', ?, datetime())`, userId, token)
+		VALUES (?, ?, ?, ?, ?, ?)`, token.UserId, token.SessionId, token.Type, token.Token, token.CreatedAt, token.ExpiresAt)
 
 	if err != nil {
-		utils.LogError("Could not insert token", err)
+		log.Error("Could not insert token: %v", err)
 		return types.ErrInternal
 	}
 
 	return nil
 }
 
-func (db AuthDbSqlite) GetEmailVerificationToken(userId uuid.UUID) (string, error) {
+func (db AuthSqlite) GetToken(token string) (*types.Token, error) {
-	var token string
-
-	err := db.db.QueryRow(`
-		SELECT token 
-		FROM user_token 
-		WHERE user_uuid = ? 
-		AND type = 'email_verify'`, userId).Scan(&token)
-
-	if err != nil && err != sql.ErrNoRows {
-		utils.LogError("Could not get token", err)
-		return "", types.ErrInternal
-	}
-
-	return token, nil
-}
-
-func (db AuthDbSqlite) InsertSession(session *Session) error {
-
-	_, err := db.db.Exec(`
-		INSERT INTO session (session_id, user_uuid, created_at) 
-		VALUES (?, ?, ?)`, session.Id, session.UserId, session.CreatedAt)
-
-	if err != nil {
-		utils.LogError("Could not insert new session", err)
-		return types.ErrInternal
-	}
-
-	return nil
-}
-
-func (db AuthDbSqlite) GetSession(sessionId string) (*Session, error) {
-
 	var (
 		userId       uuid.UUID
-		sessionCreatedAt time.Time
+		sessionId    string
+		tokenType    types.TokenType
+		createdAtStr string
+		expiresAtStr string
+		createdAt    time.Time
+		expiresAt    time.Time
 	)
 
 	err := db.db.QueryRow(`
-			SELECT u.user_uuid, s.created_at
+		SELECT user_id, session_id, type, created_at, expires_at 
-			FROM session s
+		FROM token
-			INNER JOIN user u ON s.user_uuid = u.user_uuid
+		WHERE token = ?`, token).Scan(&userId, &sessionId, &tokenType, &createdAtStr, &expiresAtStr)
-			WHERE session_id = ?`, sessionId).Scan(&userId, &sessionCreatedAt)
 
 	if err != nil {
-		return nil, ErrSessionNotFound
+		if err == sql.ErrNoRows {
+			log.Info("Token '%v' not found", token)
+			return nil, ErrNotFound
+		} else {
+			log.Error("Could not get token: %v", err)
+			return nil, types.ErrInternal
+		}
 	}
 
-	return NewSession(sessionId, userId, sessionCreatedAt), nil
+	createdAt, err = time.Parse(time.RFC3339, createdAtStr)
-}
-
-func (db AuthDbSqlite) DeleteOldSessions(userId uuid.UUID) error {
-	// Delete old inactive sessions
-	_, err := db.db.Exec("DELETE FROM session WHERE created_at < datetime('now','-8 hours') AND user_uuid = ?", userId)
 	if err != nil {
-		utils.LogError("Could not delete old sessions", err)
+		log.Error("Could not parse token.created_at: %v", err)
+		return nil, types.ErrInternal
+	}
+
+	expiresAt, err = time.Parse(time.RFC3339, expiresAtStr)
+	if err != nil {
+		log.Error("Could not parse token.expires_at: %v", err)
+		return nil, types.ErrInternal
+	}
+
+	return types.NewToken(userId, sessionId, token, tokenType, createdAt, expiresAt), nil
+}
+
+func (db AuthSqlite) GetTokensByUserIdAndType(userId uuid.UUID, tokenType types.TokenType) ([]*types.Token, error) {
+
+	query, err := db.db.Query(`
+		SELECT token, created_at, expires_at 
+		FROM token 
+		WHERE user_id = ?
+		AND type = ?`, userId, tokenType)
+
+	if err != nil {
+		log.Error("Could not get token: %v", err)
+		return nil, types.ErrInternal
+	}
+
+	return getTokensFromQuery(query, userId, "", tokenType)
+}
+
+func (db AuthSqlite) GetTokensBySessionIdAndType(sessionId string, tokenType types.TokenType) ([]*types.Token, error) {
+
+	query, err := db.db.Query(`
+		SELECT token, created_at, expires_at 
+		FROM token 
+		WHERE session_id = ?
+		AND type = ?`, sessionId, tokenType)
+
+	if err != nil {
+		log.Error("Could not get token: %v", err)
+		return nil, types.ErrInternal
+	}
+
+	return getTokensFromQuery(query, uuid.Nil, sessionId, tokenType)
+}
+
+func getTokensFromQuery(query *sql.Rows, userId uuid.UUID, sessionId string, tokenType types.TokenType) ([]*types.Token, error) {
+	var tokens []*types.Token
+
+	hasRows := false
+	for query.Next() {
+		hasRows = true
+
+		var (
+			token        string
+			createdAtStr string
+			expiresAtStr string
+			createdAt    time.Time
+			expiresAt    time.Time
+		)
+
+		err := query.Scan(&token, &createdAtStr, &expiresAtStr)
+		if err != nil {
+			log.Error("Could not scan token: %v", err)
+			return nil, types.ErrInternal
+		}
+
+		createdAt, err = time.Parse(time.RFC3339, createdAtStr)
+		if err != nil {
+			log.Error("Could not parse token.created_at: %v", err)
+			return nil, types.ErrInternal
+		}
+
+		expiresAt, err = time.Parse(time.RFC3339, expiresAtStr)
+		if err != nil {
+			log.Error("Could not parse token.expires_at: %v", err)
+			return nil, types.ErrInternal
+		}
+
+		tokens = append(tokens, types.NewToken(userId, sessionId, token, tokenType, createdAt, expiresAt))
+	}
+
+	if !hasRows {
+		return nil, ErrNotFound
+	}
+
+	return tokens, nil
+}
+
+func (db AuthSqlite) DeleteToken(token string) error {
+	_, err := db.db.Exec("DELETE FROM token WHERE token = ?", token)
+	if err != nil {
+		log.Error("Could not delete token: %v", err)
 		return types.ErrInternal
 	}
 	return nil
 }
 
-func (db AuthDbSqlite) DeleteSession(sessionId string) error {
+func (db AuthSqlite) InsertSession(session *types.Session) error {
-	if sessionId != "" {
 
+	_, err := db.db.Exec(`
+		INSERT INTO session (session_id, user_id, created_at, expires_at) 
+		VALUES (?, ?, ?, ?)`, session.Id, session.UserId, session.CreatedAt, session.ExpiresAt)
+
+	if err != nil {
+		log.Error("Could not insert new session %v", err)
+		return types.ErrInternal
+	}
+
+	return nil
+}
+
+func (db AuthSqlite) GetSession(sessionId string) (*types.Session, error) {
+
+	var (
+		userId    uuid.UUID
+		createdAt time.Time
+		expiresAt time.Time
+	)
+
+	err := db.db.QueryRow(`
+			SELECT user_id, created_at, expires_at
+			FROM session 
+			WHERE session_id = ?`, sessionId).Scan(&userId, &createdAt, &expiresAt)
+
+	if err != nil {
+		log.Warn("Session not found: %v", err)
+		return nil, ErrNotFound
+	}
+
+	return types.NewSession(sessionId, userId, createdAt, expiresAt), nil
+}
+
+func (db AuthSqlite) GetSessions(userId uuid.UUID) ([]*types.Session, error) {
+
+	sessions, err := db.db.Query(`
+			SELECT session_id, created_at, expires_at
+			FROM session 
+			WHERE user_id = ?`, userId)
+	if err != nil {
+		log.Error("Could not get sessions: %v", err)
+		return nil, types.ErrInternal
+	}
+
+	var result []*types.Session
+
+	for sessions.Next() {
+		var (
+			sessionId string
+			createdAt time.Time
+			expiresAt time.Time
+		)
+
+		err := sessions.Scan(&sessionId, &createdAt, &expiresAt)
+		if err != nil {
+			log.Error("Could not scan session: %v", err)
+			return nil, types.ErrInternal
+		}
+
+		session := types.NewSession(sessionId, userId, createdAt, expiresAt)
+		result = append(result, session)
+	}
+
+	return result, nil
+}
+
+func (db AuthSqlite) DeleteOldSessions(userId uuid.UUID) error {
+	_, err := db.db.Exec(`
+		DELETE FROM session 
+		WHERE expires_at < datetime('now')
+		  AND user_id = ?`, userId)
+	if err != nil {
+		log.Error("Could not delete old sessions: %v", err)
+		return types.ErrInternal
+	}
+	return nil
+}
+
+func (db AuthSqlite) DeleteSession(sessionId string) error {
+	if sessionId != "" {
 		_, err := db.db.Exec("DELETE FROM session WHERE session_id = ?", sessionId)
 		if err != nil {
-			utils.LogError("Could not delete session", err)
+			log.Error("Could not delete session: %v", err)
 			return types.ErrInternal
 		}
 	}

db/auth_test.go

@@ -1,9 +1,8 @@
 package db
 
 import (
-	"me-fit/utils"
-
 	"database/sql"
+	"web-app-template/types"
 	"testing"
 	"time"
 
@@ -20,7 +19,7 @@ func setupDb(t *testing.T) *sql.DB {
 		db.Close()
 	})
 
-	err = utils.RunMigrations(db, "../")
+	err = RunMigrations(db, "../")
 	if err != nil {
 		t.Fatalf("Error running migrations: %v", err)
 	}
@@ -31,82 +30,170 @@ func setupDb(t *testing.T) *sql.DB {
 func TestUser(t *testing.T) {
 	t.Parallel()
 
-	t.Run("should return UserNotFound", func(t *testing.T) {
+	t.Run("should insert and get the same", func(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)
 
-		underTest := AuthDbSqlite{db: db}
+		underTest := AuthSqlite{db: db}
-
-		_, err := underTest.GetUser("someNonExistentEmail")
-		assert.Equal(t, ErrUserNotFound, err)
-	})
-
-	t.Run("should insert and get user", func(t *testing.T) {
-		t.Parallel()
-		db := setupDb(t)
-
-		underTest := AuthDbSqlite{db: db}
 
 		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
 		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
-		expected := NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
+		expected := types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
 
 		err := underTest.InsertUser(expected)
 		assert.Nil(t, err)
 
-		actual, err := underTest.GetUser(expected.Email)
+		actual, err := underTest.GetUser(expected.Id)
 		assert.Nil(t, err)
+		assert.Equal(t, expected, actual)
 
+		actual, err = underTest.GetUserByEmail(expected.Email)
+		assert.Nil(t, err)
 		assert.Equal(t, expected, actual)
 	})
-
+	t.Run("should return ErrNotFound", func(t *testing.T) {
-	t.Run("should throw error if user already exists", func(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)
 
-		underTest := AuthDbSqlite{db: db}
+		underTest := AuthSqlite{db: db}
+
+		_, err := underTest.GetUserByEmail("nonExistentEmail")
+		assert.Equal(t, ErrNotFound, err)
+	})
+	t.Run("should return ErrUserExist", func(t *testing.T) {
+		t.Parallel()
+		db := setupDb(t)
+
+		underTest := AuthSqlite{db: db}
 
 		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
 		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
-		user := NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
+		user := types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
 
 		err := underTest.InsertUser(user)
 		assert.Nil(t, err)
 
 		err = underTest.InsertUser(user)
-		assert.Equal(t, ErrUserExists, err)
+		assert.Equal(t, ErrAlreadyExists, err)
+	})
+	t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
+		t.Parallel()
+		db := setupDb(t)
+
+		underTest := AuthSqlite{db: db}
+
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		user := types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)
+
+		err := underTest.InsertUser(user)
+		assert.Equal(t, types.ErrInternal, err)
 	})
 }
 
-func TestEmailVerification(t *testing.T) {
+func TestToken(t *testing.T) {
 	t.Parallel()
 
-	t.Run("should return empty string if no token is safed", func(t *testing.T) {
+	t.Run("should insert and get the same", func(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)
 
-		underTest := AuthDbSqlite{db: db}
+		underTest := AuthSqlite{db: db}
 
-		token, err := underTest.GetEmailVerificationToken(uuid.New())
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		expiresAt := createAt.Add(24 * time.Hour)
+		expected := types.NewToken(uuid.New(), "sessionId", "token", types.TokenTypeCsrf, createAt, expiresAt)
 
+		err := underTest.InsertToken(expected)
 		assert.Nil(t, err)
-		assert.Equal(t, "", token)
+
+		actual, err := underTest.GetToken(expected.Token)
+		assert.Nil(t, err)
+		assert.Equal(t, expected, actual)
+
+		expected.SessionId = ""
+		actuals, err := underTest.GetTokensByUserIdAndType(expected.UserId, expected.Type)
+		assert.Nil(t, err)
+		assert.Equal(t, []*types.Token{expected}, actuals)
+
+		expected.SessionId = "sessionId"
+		expected.UserId = uuid.Nil
+		actuals, err = underTest.GetTokensBySessionIdAndType(expected.SessionId, expected.Type)
+		assert.Nil(t, err)
+		assert.Equal(t, []*types.Token{expected}, actuals)
 	})
-	t.Run("should insert and return token", func(t *testing.T) {
+	t.Run("should insert and return multiple tokens", func(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)
 
-		underTest := AuthDbSqlite{db: db}
+		underTest := AuthSqlite{db: db}
 
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		expiresAt := createAt.Add(24 * time.Hour)
 		userId := uuid.New()
-		expectedToken := "someToken"
+		expected1 := types.NewToken(userId, "sessionId", "token1", types.TokenTypeCsrf, createAt, expiresAt)
+		expected2 := types.NewToken(userId, "sessionId", "token2", types.TokenTypeCsrf, createAt, expiresAt)
 
-		err := underTest.InsertEmailVerificationToken(userId, expectedToken)
+		err := underTest.InsertToken(expected1)
+		assert.Nil(t, err)
+		err = underTest.InsertToken(expected2)
 		assert.Nil(t, err)
 
-		actualToken, err := underTest.GetEmailVerificationToken(userId)
+		expected1.UserId = uuid.Nil
+		expected2.UserId = uuid.Nil
+		actuals, err := underTest.GetTokensBySessionIdAndType(expected1.SessionId, expected1.Type)
+		assert.Nil(t, err)
+		assert.Equal(t, []*types.Token{expected1, expected2}, actuals)
+
+		expected1.SessionId = ""
+		expected2.SessionId = ""
+		expected1.UserId = userId
+		expected2.UserId = userId
+		actuals, err = underTest.GetTokensByUserIdAndType(userId, expected1.Type)
+		assert.Nil(t, err)
+		assert.Equal(t, []*types.Token{expected1, expected2}, actuals)
+
+	})
+	t.Run("should return ErrNotFound", func(t *testing.T) {
+		t.Parallel()
+		db := setupDb(t)
+
+		underTest := AuthSqlite{db: db}
+
+		_, err := underTest.GetToken("nonExistent")
+		assert.Equal(t, ErrNotFound, err)
+
+		_, err = underTest.GetTokensByUserIdAndType(uuid.New(), types.TokenTypeEmailVerify)
+		assert.Equal(t, ErrNotFound, err)
+
+		_, err = underTest.GetTokensBySessionIdAndType("sessionId", types.TokenTypeEmailVerify)
+		assert.Equal(t, ErrNotFound, err)
+	})
+	t.Run("should return ErrAlreadyExists", func(t *testing.T) {
+		t.Parallel()
+		db := setupDb(t)
+
+		underTest := AuthSqlite{db: db}
+
+		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		user := types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
+
+		err := underTest.InsertUser(user)
 		assert.Nil(t, err)
 
-		assert.Equal(t, expectedToken, actualToken)
+		err = underTest.InsertUser(user)
+		assert.Equal(t, ErrAlreadyExists, err)
+	})
+	t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
+		t.Parallel()
+		db := setupDb(t)
+
+		underTest := AuthSqlite{db: db}
+
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		user := types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)
+
+		err := underTest.InsertUser(user)
+		assert.Equal(t, types.ErrInternal, err)
 	})
 }

db/default.go

@@ -1,10 +1,11 @@
-package utils
+package db
 
 import (
+	"web-app-template/log"
+	"web-app-template/types"
+
 	"database/sql"
 	"errors"
-	"log/slog"
-	"me-fit/types"
 
 	"github.com/golang-migrate/migrate/v4"
 	"github.com/golang-migrate/migrate/v4/database/sqlite3"
@@ -14,7 +15,7 @@ import (
 func RunMigrations(db *sql.DB, pathPrefix string) error {
 	driver, err := sqlite3.WithInstance(db, &sqlite3.Config{})
 	if err != nil {
-		slog.Error("Could not create Migration instance: " + err.Error())
+		log.Error("Could not create Migration instance: %v", err)
 		return types.ErrInternal
 	}
 
@@ -23,17 +24,18 @@ func RunMigrations(db *sql.DB, pathPrefix string) error {
 		"",
 		driver)
 	if err != nil {
-		slog.Error("Could not create migrations instance: " + err.Error())
+		log.Error("Could not create migrations instance: %v", err)
 		return types.ErrInternal
 	}
 
 	err = m.Up()
 	if err != nil {
 		if !errors.Is(err, migrate.ErrNoChange) {
-			slog.Error("Could not run migrations: " + err.Error())
+			log.Error("Could not run migrations: %v", err)
 			return types.ErrInternal
 		}
 	}
 
 	return nil
 }
+

db/workout.go

@@ -1,8 +1,8 @@
 package db
 
 import (
-	"me-fit/types"
+	"web-app-template/log"
-	"me-fit/utils"
+	"web-app-template/types"
 
 	"database/sql"
 	"errors"
@@ -59,7 +59,7 @@ func (db WorkoutDbSqlite) InsertWorkout(userId uuid.UUID, workout *WorkoutInsert
 		VALUES (?, ?, ?, ?, ?) 
 		RETURNING rowid`, userId, workout.Date, workout.Type, workout.Sets, workout.Reps).Scan(&rowId)
 	if err != nil {
-		utils.LogError("Error inserting workout", err)
+		log.Error("Error inserting workout: %v", err)
 		return nil, types.ErrInternal
 	}
 
@@ -70,7 +70,7 @@ func (db WorkoutDbSqlite) GetWorkouts(userId uuid.UUID) ([]Workout, error) {
 
 	rows, err := db.db.Query("SELECT rowid, date, type, sets, reps FROM workout WHERE user_id = ? ORDER BY date desc", userId)
 	if err != nil {
-		utils.LogError("Could not get workouts", err)
+		log.Error("Could not get workouts: %v", err)
 		return nil, types.ErrInternal
 	}
 
@@ -83,13 +83,13 @@ func (db WorkoutDbSqlite) GetWorkouts(userId uuid.UUID) ([]Workout, error) {
 
 		err = rows.Scan(&workout.RowId, &date, &workout.Type, &workout.Sets, &workout.Reps)
 		if err != nil {
-			utils.LogError("Could not scan workout", err)
+			log.Error("Could not scan workout: %v", err)
 			return nil, types.ErrInternal
 		}
 
 		workout.Date, err = time.Parse("2006-01-02 15:04:05-07:00", date)
 		if err != nil {
-			utils.LogError("Could not parse date", err)
+			log.Error("Could not parse date: %v", err)
 			return nil, types.ErrInternal
 		}
 

go.mod

@@ -1,16 +1,19 @@
-module me-fit
+module web-app-template
 
-go 1.22.5
+go 1.23.0
+
+toolchain go1.24.5
 
 require (
-	github.com/a-h/templ v0.2.793
+	github.com/a-h/templ v0.3.924
-	github.com/golang-migrate/migrate/v4 v4.18.1
+	github.com/golang-migrate/migrate/v4 v4.18.3
 	github.com/google/uuid v1.6.0
 	github.com/joho/godotenv v1.5.1
-	github.com/mattn/go-sqlite3 v1.14.24
+	github.com/mattn/go-sqlite3 v1.14.30
-	github.com/prometheus/client_golang v1.20.5
+	github.com/prometheus/client_golang v1.23.0
-	github.com/stretchr/testify v1.9.0
+	github.com/stretchr/testify v1.10.0
-	golang.org/x/crypto v0.29.0
+	golang.org/x/crypto v0.40.0
+	golang.org/x/net v0.42.0
 )
 
 require (
@@ -19,15 +22,14 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
+	github.com/prometheus/common v0.65.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/prometheus/procfs v0.16.1 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
-	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/sys v0.34.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,15 +1,15 @@
-github.com/a-h/templ v0.2.793 h1:Io+/ocnfGWYO4VHdR0zBbf39PQlnzVCVVD+wEEs6/qY=
+github.com/a-h/templ v0.3.924 h1:t5gZqTneXqvehpNZsgtnlOscnBboNh9aASBH2MgV/0k=
-github.com/a-h/templ v0.2.793/go.mod h1:lq48JXoUvuQrU0VThrK31yFwdRjTCnIE5bcPCM9IP1w=
+github.com/a-h/templ v0.3.924/go.mod h1:FFAu4dI//ESmEN7PQkJ7E7QfnSEMdcnu7QrAY8Dn334=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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/golang-migrate/migrate/v4 v4.18.1 h1:JML/k+t4tpHCpQTCAD62Nu43NUFzHY4CV3uAuvHGC+Y=
+github.com/golang-migrate/migrate/v4 v4.18.3 h1:EYGkoOsvgHHfm5U/naS1RP/6PL/Xv3S4B/swMiAmDLs=
-github.com/golang-migrate/migrate/v4 v4.18.1/go.mod h1:HAX6m3sQgcdO81tdjn5exv20+3Kb13cmGli1hrD6hks=
+github.com/golang-migrate/migrate/v4 v4.18.3/go.mod h1:99BKpIi6ruaaXRM1A77eqZ+FWPQ3cfRa+ZVy5bmWMaY=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -19,8 +19,8 @@ github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+l
 github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -29,34 +29,38 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.30 h1:bVreufq3EAIG1Quvws73du3/QgdeZ3myglJlrzSYYCY=
-github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mattn/go-sqlite3 v1.14.30/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 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/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
+github.com/prometheus/client_golang v1.23.0 h1:ust4zpdl9r4trLY/gSjlm07PuiBq2ynaXXlptpfy8Uc=
-github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_golang v1.23.0/go.mod h1:i/o0R9ByOnHX0McrTMTyhYvKE4haaf2mW08I+jGAjEE=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
+github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
+github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
-github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+golang.org/x/net v0.42.0 h1:jzkYrhi3YQWD6MLBJcsklgQsoAcw89EcZbJw8Z614hs=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8=
+golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
+golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

handler/auth.go

@@ -1,115 +1,104 @@
 package handler
 
 import (
-	"me-fit/service"
+	"web-app-template/handler/middleware"
-	"me-fit/template"
+	"web-app-template/log"
-	"me-fit/template/auth"
+	"web-app-template/service"
-	"me-fit/types"
+	"web-app-template/template/auth"
-	"me-fit/utils"
+	"web-app-template/types"
+	"web-app-template/utils"
 
-	"database/sql"
 	"errors"
 	"net/http"
+	"net/url"
 	"time"
 )
 
-type HandlerAuth interface {
+type Auth interface {
-	handle(router *http.ServeMux)
+	Handle(router *http.ServeMux)
 }
 
-type HandlerAuthImpl struct {
+type AuthImpl struct {
-	db             *sql.DB
+	service service.Auth
-	service        service.AuthService
+	render  *Render
-	serverSettings *types.ServerSettings
 }
 
-func NewHandlerAuth(db *sql.DB, service service.AuthService, serverSettings *types.ServerSettings) HandlerAuth {
+func NewAuth(service service.Auth, render *Render) Auth {
-	return HandlerAuthImpl{
+	return AuthImpl{
-		db:             db,
 		service: service,
-		serverSettings: serverSettings,
+		render:  render,
 	}
 }
 
-func (handler HandlerAuthImpl) handle(router *http.ServeMux) {
+func (handler AuthImpl) Handle(router *http.ServeMux) {
-	// Don't use auth middleware for these routes, as it makes redirecting very difficult, if the mail is not yet verified
+	router.Handle("GET /auth/signin", handler.handleSignInPage())
-	router.Handle("/auth/signin", handler.handleSignInPage())
+	router.Handle("POST /api/auth/signin", handler.handleSignIn())
+
 	router.Handle("/auth/signup", handler.handleSignUpPage())
-	router.Handle("/auth/verify", handler.handleSignUpVerifyPage()) // Hint for the user to verify their email
+	router.Handle("/auth/verify", handler.handleSignUpVerifyPage())
-	router.Handle("/auth/delete-account", handler.handleDeleteAccountPage())
+	router.Handle("/api/auth/verify-resend", handler.handleVerifyResendComp())
-	router.Handle("/auth/verify-email", service.HandleSignUpVerifyResponsePage(handler.db)) // The link contained in the email
+	router.Handle("/auth/verify-email", handler.handleSignUpVerifyResponsePage())
-	router.Handle("/auth/change-password", handler.handleChangePasswordPage())
-	router.Handle("/auth/reset-password", handler.handleResetPasswordPage())
 	router.Handle("/api/auth/signup", handler.handleSignUp())
-	router.Handle("/api/auth/signin", handler.handleSignIn())
+
-	router.Handle("/api/auth/signout", handler.handleSignOut())
+	router.Handle("POST /api/auth/signout", handler.handleSignOut())
-	router.Handle("/api/auth/delete-account", handler.HandleDeleteAccountComp())
+
-	router.Handle("/api/auth/verify-resend", handler.HandleVerifyResendComp())
+	router.Handle("/auth/delete-account", handler.handleDeleteAccountPage())
-	router.Handle("/api/auth/change-password", handler.HandleChangePasswordComp())
+	router.Handle("/api/auth/delete-account", handler.handleDeleteAccountComp())
-	router.Handle("/api/auth/reset-password", service.HandleResetPasswordComp(handler.db, handler.serverSettings))
+
-	router.Handle("/api/auth/reset-password-actual", service.HandleActualResetPasswordComp(handler.db))
+	router.Handle("GET /auth/change-password", handler.handleChangePasswordPage())
+	router.Handle("POST /api/auth/change-password", handler.handleChangePasswordComp())
+
+	router.Handle("GET /auth/forgot-password", handler.handleForgotPasswordPage())
+	router.Handle("POST /api/auth/forgot-password", handler.handleForgotPasswordComp())
+	router.Handle("POST /api/auth/forgot-password-actual", handler.handleForgotPasswordResponseComp())
 }
 
 var (
 	securityWaitDuration = 250 * time.Millisecond
 )
 
-func (handler HandlerAuthImpl) handleSignInPage() http.HandlerFunc {
+func (handler AuthImpl) handleSignInPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user != nil {
-			userComp := service.UserInfoComp(nil)
-			signIn := auth.SignInOrUpComp(true)
-			err := template.Layout(signIn, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-
-			if err != nil {
-				utils.LogError("Failed to render sign in page", err)
-				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			}
-			return
-		}
-
 			if !user.EmailVerified {
 				utils.DoRedirect(w, r, "/auth/verify")
 			} else {
 				utils.DoRedirect(w, r, "/")
 			}
+			return
+		}
+
+		comp := auth.SignInOrUpComp(true)
+
+		handler.render.RenderLayout(r, w, comp, nil)
 	}
 }
 
-func (handler HandlerAuthImpl) handleSignIn() http.HandlerFunc {
+func (handler AuthImpl) handleSignIn() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := utils.WaitMinimumTime(securityWaitDuration, func() (*service.User, error) {
-			var email = r.FormValue("email")
-			var password = r.FormValue("password")
 
-			session, err := handler.service.SignIn(email, password)
+		user, err := utils.WaitMinimumTime(securityWaitDuration, func() (*types.User, error) {
+			session := middleware.GetSession(r)
+			email := r.FormValue("email")
+			password := r.FormValue("password")
+
+			session, user, err := handler.service.SignIn(session, email, password)
 			if err != nil {
 				return nil, err
 			}
 
-			cookie := http.Cookie{
+			cookie := middleware.CreateSessionCookie(session.Id)
-				Name:     "id",
-				Value:    session.Id,
-				MaxAge:   60 * 60 * 8, // 8 hours
-				Secure:   true,
-				HttpOnly: true,
-				SameSite: http.SameSiteStrictMode,
-				Path:     "/",
-			}
-
 			http.SetCookie(w, &cookie)
 
-			return session.User, nil
+			return user, nil
 		})
 
 		if err != nil {
-			if err == service.ErrInvaidCredentials {
+			if err == service.ErrInvalidCredentials {
-				utils.TriggerToast(w, r, "error", "Invalid email or password")
+				utils.TriggerToast(w, r, "error", "Invalid email or password", http.StatusUnauthorized)
-				http.Error(w, "Invalid email or password", http.StatusUnauthorized)
 			} else {
-				utils.LogError("Error signing in", err)
+				utils.TriggerToast(w, r, "error", "An error occurred", http.StatusInternalServerError)
-				http.Error(w, "An error occurred", http.StatusInternalServerError)
 			}
 			return
 		}
@@ -122,66 +111,126 @@ func (handler HandlerAuthImpl) handleSignIn() http.HandlerFunc {
 	}
 }
 
-func (handler HandlerAuthImpl) handleSignUpPage() http.HandlerFunc {
+func (handler AuthImpl) handleSignUpPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
-			userComp := service.UserInfoComp(nil)
-			signUpComp := auth.SignInOrUpComp(false)
-			err := template.Layout(signUpComp, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-
-			if err != nil {
-				utils.LogError("Failed to render sign up page", err)
-				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			}
-		}
 
+		if user != nil {
 			if !user.EmailVerified {
 				utils.DoRedirect(w, r, "/auth/verify")
 			} else {
 				utils.DoRedirect(w, r, "/")
 			}
+			return
+		}
+
+		signUpComp := auth.SignInOrUpComp(false)
+		handler.render.RenderLayout(r, w, signUpComp, nil)
 	}
 }
 
-func (handler HandlerAuthImpl) handleSignUp() http.HandlerFunc {
+func (handler AuthImpl) handleSignUpVerifyPage() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user := middleware.GetUser(r)
+		if user == nil {
+			utils.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		if user.EmailVerified {
+			utils.DoRedirect(w, r, "/")
+			return
+		}
+
+		signIn := auth.VerifyComp()
+		handler.render.RenderLayout(r, w, signIn, user)
+	}
+}
+
+func (handler AuthImpl) handleVerifyResendComp() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user := middleware.GetUser(r)
+		if user == nil {
+			utils.DoRedirect(w, r, "/auth/signin")
+			return
+		}
+
+		go handler.service.SendVerificationMail(user.Id, user.Email)
+
+		_, err := w.Write([]byte("<p class=\"mt-8\">Verification email sent</p>"))
+		if err != nil {
+			log.Error("Could not write response: %v", err)
+		}
+	}
+}
+
+func (handler AuthImpl) handleSignUpVerifyResponsePage() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		token := r.URL.Query().Get("token")
+
+		err := handler.service.VerifyUserEmail(token)
+
+		isVerified := err == nil
+		comp := auth.VerifyResponseComp(isVerified)
+
+		var status int
+		if isVerified {
+			status = http.StatusOK
+		} else {
+			status = http.StatusBadRequest
+		}
+
+		handler.render.RenderLayoutWithStatus(r, w, comp, nil, status)
+	}
+}
+
+func (handler AuthImpl) handleSignUp() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var email = r.FormValue("email")
 		var password = r.FormValue("password")
 
 		_, err := utils.WaitMinimumTime(securityWaitDuration, func() (interface{}, error) {
+			log.Info("Signing up %v", email)
 			user, err := handler.service.SignUp(email, password)
 			if err != nil {
 				return nil, err
 			}
 
+			log.Info("Sending verification email to %v", user.Email)
 			go handler.service.SendVerificationMail(user.Id, user.Email)
 			return nil, nil
 		})
 
 		if err != nil {
 			if errors.Is(err, types.ErrInternal) {
-				utils.TriggerToast(w, r, "error", "An error occurred")
+				utils.TriggerToast(w, r, "error", "An error occurred", http.StatusInternalServerError)
 				return
 			} else if errors.Is(err, service.ErrInvalidEmail) {
-				utils.TriggerToast(w, r, "error", "The email provided is invalid")
+				utils.TriggerToast(w, r, "error", "The email provided is invalid", http.StatusBadRequest)
+				return
+			} else if errors.Is(err, service.ErrInvalidPassword) {
+				utils.TriggerToast(w, r, "error", service.ErrInvalidPassword.Error(), http.StatusBadRequest)
 				return
 			}
-			// If the "service.ErrAccountExists", then just continue
+			// If err is "service.ErrAccountExists", then just continue
 		}
 
-		utils.TriggerToast(w, r, "success", "A link to activate your account has been emailed to the address provided.")
+		utils.TriggerToast(w, r, "success", "An activation link has been send to your email", http.StatusOK)
 	}
 }
 
-func (handler HandlerAuthImpl) handleSignOut() http.HandlerFunc {
+func (handler AuthImpl) handleSignOut() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		err := handler.service.SignOut(utils.GetSessionID(r))
+		session := middleware.GetSession(r)
+
+		if session != nil {
+			err := handler.service.SignOut(session.Id)
 			if err != nil {
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
+				http.Error(w, "An error occurred", http.StatusInternalServerError)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
 				return
 			}
+		}
 
 		c := http.Cookie{
 			Name:     "id",
@@ -198,122 +247,36 @@ func (handler HandlerAuthImpl) handleSignOut() http.HandlerFunc {
 	}
 }
 
-func (handler HandlerAuthImpl) handleSignUpVerifyPage() http.HandlerFunc {
+func (handler AuthImpl) handleDeleteAccountPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user == nil {
-			utils.DoRedirect(w, r, "/auth/signin")
-		}
-
-		if user.EmailVerified {
-			utils.DoRedirect(w, r, "/")
-		} else {
-			userComp := service.UserInfoComp(user)
-			signIn := auth.VerifyComp()
-			err := template.Layout(signIn, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-			if err != nil {
-				utils.LogError("Failed to render verify page", err)
-				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			}
-		}
-	}
-}
-
-func (handler HandlerAuthImpl) handleDeleteAccountPage() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		// An unverified email should be able to delete their account
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
-		if err != nil {
-			utils.DoRedirect(w, r, "/auth/signin")
-		}
-
-		userComp := service.UserInfoComp(user)
-		comp := auth.DeleteAccountComp()
-		err = template.Layout(comp, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-		if err != nil {
-			utils.LogError("Failed to render delete account page", err)
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		}
-	}
-}
-
-func (handler HandlerAuthImpl) handleChangePasswordPage() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		isPasswordReset := r.URL.Query().Has("token")
-
-		user, _ := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
-
-		if user == nil && !isPasswordReset {
-			utils.DoRedirect(w, r, "/auth/signin")
-		} else {
-			userComp := service.UserInfoComp(user)
-			comp := auth.ChangePasswordComp(isPasswordReset)
-			err := template.Layout(comp, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-			if err != nil {
-				utils.LogError("Failed to render change password page", err)
-				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			}
-		}
-	}
-}
-
-func (handler HandlerAuthImpl) handleResetPasswordPage() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
-		if err != nil {
-			utils.DoRedirect(w, r, "/auth/signin")
-		}
-
-		userComp := service.UserInfoComp(user)
-		comp := auth.ResetPasswordComp()
-		err = template.Layout(comp, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-		if err != nil {
-			utils.LogError("Failed to render change password page", err)
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		}
-	}
-}
-
-func (handler HandlerAuthImpl) HandleResetPasswordPage() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
-		if err != nil {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
 
-		userComp := service.UserInfoComp(user)
+		comp := auth.DeleteAccountComp()
-		comp := auth.ResetPasswordComp()
+		handler.render.RenderLayout(r, w, comp, user)
-		err = template.Layout(comp, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-		if err != nil {
-			utils.LogError("Failed to render change password page", err)
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		}
 	}
 }
 
-func (handler HandlerAuthImpl) HandleDeleteAccountComp() http.HandlerFunc {
+func (handler AuthImpl) handleDeleteAccountComp() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user == nil {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
 
 		password := r.FormValue("password")
 
-		_, err = handler.service.SignIn(user.Email, password)
+		err := handler.service.DeleteAccount(user, password)
 		if err != nil {
-			utils.TriggerToast(w, r, "error", "Password not correct")
+			if err == service.ErrInvalidCredentials {
-			return
+				utils.TriggerToast(w, r, "error", "Password not correct", http.StatusBadRequest)
+			} else {
+				utils.TriggerToast(w, r, "error", "Internal Server Error", http.StatusInternalServerError)
 			}
-
-		err = handler.service.DeleteAccount(user)
-		if err != nil {
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
 			return
 		}
 
@@ -321,38 +284,99 @@ func (handler HandlerAuthImpl) HandleDeleteAccountComp() http.HandlerFunc {
 	}
 }
 
-func (handler HandlerAuthImpl) HandleVerifyResendComp() http.HandlerFunc {
+func (handler AuthImpl) handleChangePasswordPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+
-		if err != nil {
+		isPasswordReset := r.URL.Query().Has("token")
+
+		user := middleware.GetUser(r)
+
+		if user == nil && !isPasswordReset {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
 
-		go handler.service.SendVerificationMail(user.Id, user.Email)
+		comp := auth.ChangePasswordComp(isPasswordReset)
-
+		handler.render.RenderLayout(r, w, comp, user)
-		w.Write([]byte("<p class=\"mt-8\">Verification email sent</p>"))
 	}
 }
 
-func (handler HandlerAuthImpl) HandleChangePasswordComp() http.HandlerFunc {
+func (handler AuthImpl) handleChangePasswordComp() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+		session := middleware.GetSession(r)
-		if err != nil {
+		user := middleware.GetUser(r)
-			utils.DoRedirect(w, r, "/auth/signin")
+		if session == nil || user == nil {
+			utils.TriggerToast(w, r, "error", "Unathorized", http.StatusUnauthorized)
 			return
 		}
 
 		currPass := r.FormValue("current-password")
 		newPass := r.FormValue("new-password")
 
-		err = handler.service.ChangePassword(user, currPass, newPass)
+		err := handler.service.ChangePassword(user, session.Id, currPass, newPass)
 		if err != nil {
-			utils.TriggerToast(w, r, "error", "Password not correct")
+			utils.TriggerToast(w, r, "error", "Password not correct", http.StatusBadRequest)
 			return
 		}
 
-		utils.TriggerToast(w, r, "success", "Password changed")
+		utils.TriggerToast(w, r, "success", "Password changed", http.StatusOK)
+	}
+}
+
+func (handler AuthImpl) handleForgotPasswordPage() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		user := middleware.GetUser(r)
+		if user != nil {
+			utils.DoRedirect(w, r, "/")
+			return
+		}
+
+		comp := auth.ResetPasswordComp()
+		handler.render.RenderLayout(r, w, comp, user)
+	}
+}
+
+func (handler AuthImpl) handleForgotPasswordComp() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		email := r.FormValue("email")
+		if email == "" {
+			utils.TriggerToast(w, r, "error", "Please enter an email", http.StatusBadRequest)
+			return
+		}
+
+		_, err := utils.WaitMinimumTime(securityWaitDuration, func() (interface{}, error) {
+			err := handler.service.SendForgotPasswordMail(email)
+			return nil, err
+		})
+
+		if err != nil {
+			utils.TriggerToast(w, r, "error", "Internal Server Error", http.StatusInternalServerError)
+		} else {
+			utils.TriggerToast(w, r, "info", "If the address exists, an email has been sent.", http.StatusOK)
+		}
+	}
+}
+
+func (handler AuthImpl) handleForgotPasswordResponseComp() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		pageUrl, err := url.Parse(r.Header.Get("HX-Current-URL"))
+		if err != nil {
+			log.Error("Could not get current URL: %v", err)
+			utils.TriggerToast(w, r, "error", "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		token := pageUrl.Query().Get("token")
+		newPass := r.FormValue("new-password")
+
+		err = handler.service.ForgotPassword(token, newPass)
+		if err != nil {
+			utils.TriggerToast(w, r, "error", err.Error(), http.StatusBadRequest)
+		} else {
+			utils.TriggerToast(w, r, "success", "Password changed", http.StatusOK)
+		}
 	}
 }

handler/default.go

@@ -1,46 +0,0 @@
-package handler
-
-import (
-	"me-fit/db"
-	"me-fit/middleware"
-	"me-fit/service"
-	"me-fit/types"
-
-	"database/sql"
-	"net/http"
-)
-
-func GetHandler(d *sql.DB, serverSettings *types.ServerSettings) http.Handler {
-	var router = http.NewServeMux()
-
-	authDb := db.NewAuthDbSqlite(d)
-	workoutDb := db.NewWorkoutDbSqlite(d)
-
-	randomService := service.NewRandomServiceImpl()
-	clockService := service.NewClockServiceImpl()
-	mailService := service.NewMailServiceImpl(serverSettings)
-	authService := service.NewAuthServiceImpl(authDb, randomService, clockService, mailService, serverSettings)
-	workoutService := service.NewWorkoutServiceImpl(workoutDb, randomService, clockService, mailService, serverSettings)
-
-	indexHandler := NewIndexHandler(d, authService, serverSettings)
-	authHandler := NewHandlerAuth(d, authService, serverSettings)
-	workoutHandler := NewWorkoutHandler(d, workoutService, authService, serverSettings)
-
-	indexHandler.handle(router)
-
-	// Serve static files (CSS, JS and images)
-	router.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static/"))))
-
-	workoutHandler.handle(router)
-
-	authHandler.handle(router)
-
-	return middleware.Wrapper(
-		router,
-		middleware.Log,
-		middleware.SecFetchFilter,
-		middleware.ContentSecurityPolicy,
-		middleware.Cors(serverSettings),
-		middleware.Corp,
-	)
-}

handler/index_and_404.go

@@ -1,57 +1,50 @@
 package handler
 
 import (
-	"me-fit/service"
+	"web-app-template/handler/middleware"
-	"me-fit/template"
+	"web-app-template/service"
-	"me-fit/types"
+	"web-app-template/template"
-	"me-fit/utils"
 
-	"database/sql"
 	"net/http"
 
 	"github.com/a-h/templ"
 )
 
-type IndexHandler interface {
+type Index interface {
-	handle(router *http.ServeMux)
+	Handle(router *http.ServeMux)
 }
 
-type IndexHandlerImpl struct {
+type IndexImpl struct {
-	db             *sql.DB
+	service service.Auth
-	service        service.AuthService
+	render  *Render
-	serverSettings *types.ServerSettings
 }
 
-func NewIndexHandler(db *sql.DB, service service.AuthService, serverSettings *types.ServerSettings) IndexHandler {
+func NewIndex(service service.Auth, render *Render) Index {
-	return IndexHandlerImpl{
+	return IndexImpl{
-		db:             db,
 		service: service,
-		serverSettings: serverSettings,
+		render:  render,
 	}
 }
 
-func (handler IndexHandlerImpl) handle(router *http.ServeMux) {
+func (handler IndexImpl) Handle(router *http.ServeMux) {
 	router.Handle("/", handler.handleIndexAnd404())
 }
 
-func (handler IndexHandlerImpl) handleIndexAnd404() http.HandlerFunc {
+func (handler IndexImpl) handleIndexAnd404() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.service.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
 
-		var comp templ.Component = nil
+		var comp templ.Component
-		userComp := service.UserInfoComp(user)
 
+		var status int
 		if r.URL.Path != "/" {
-			comp = template.Layout(template.NotFound(), userComp, handler.serverSettings.Environment)
+			comp = template.NotFound()
-			w.WriteHeader(http.StatusNotFound)
+			status = http.StatusNotFound
 		} else {
-			comp = template.Layout(template.Index(), userComp, handler.serverSettings.Environment)
+			comp = template.Index()
+			status = http.StatusOK
 		}
 
-		err = comp.Render(r.Context(), w)
+		handler.render.RenderLayoutWithStatus(r, w, comp, user, status)
-		if err != nil {
-			utils.LogError("Failed to render index", err)
-			http.Error(w, "Failed to render index", http.StatusInternalServerError)
-		}
 	}
 }

handler/middleware/authenticate.go

@@ -0,0 +1,71 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+
+	"web-app-template/service"
+	"web-app-template/types"
+)
+
+type ContextKey string
+
+var SessionKey ContextKey = "session"
+var UserKey ContextKey = "user"
+
+func Authenticate(service service.Auth) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+
+			sessionId := getSessionID(r)
+			session, user, _ := service.SignInSession(sessionId)
+
+			var err error
+			// Always sign in anonymous
+			// This way, we can always generate csrf tokens
+			if session == nil {
+				session, err = service.SignInAnonymous()
+				if err != nil {
+					http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+					return
+				}
+
+				cookie := CreateSessionCookie(session.Id)
+				http.SetCookie(w, &cookie)
+			}
+
+			ctx := r.Context()
+			ctx = context.WithValue(ctx, UserKey, user)
+			ctx = context.WithValue(ctx, SessionKey, session)
+
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
+
+func GetUser(r *http.Request) *types.User {
+	obj := r.Context().Value(UserKey)
+	if obj == nil {
+		return nil
+	}
+
+	return obj.(*types.User)
+}
+
+func GetSession(r *http.Request) *types.Session {
+	obj := r.Context().Value(SessionKey)
+	if obj == nil {
+		return nil
+	}
+
+	return obj.(*types.Session)
+}
+
+func getSessionID(r *http.Request) string {
+	cookie, err := r.Cookie("id")
+	if err != nil {
+		return ""
+	}
+
+	return cookie.Value
+}

handler/middleware/cache_control.go

@@ -0,0 +1,23 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+func CacheControl(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path := r.URL.Path
+
+		cached := false
+		if strings.HasPrefix(path, "/static") {
+			cached = true
+		}
+
+		if !cached {
+			w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}

handler/middleware/cross_site_request_forgery.go

@@ -0,0 +1,74 @@
+package middleware
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"web-app-template/log"
+	"web-app-template/service"
+	"web-app-template/types"
+	"web-app-template/utils"
+)
+
+type csrfResponseWriter struct {
+	http.ResponseWriter
+	auth    service.Auth
+	session *types.Session
+}
+
+func newCsrfResponseWriter(w http.ResponseWriter, auth service.Auth, session *types.Session) *csrfResponseWriter {
+	return &csrfResponseWriter{
+		ResponseWriter: w,
+		auth:           auth,
+		session:        session,
+	}
+}
+
+func (rr *csrfResponseWriter) Write(data []byte) (int, error) {
+	dataStr := string(data)
+	csrfToken, err := rr.auth.GetCsrfToken(rr.session)
+	if err == nil {
+		csrfInput := fmt.Sprintf(`<input type="hidden" name="csrf-token" value="%s" />`, csrfToken)
+		dataStr = strings.ReplaceAll(dataStr, "</form>", csrfInput+"</form>")
+		dataStr = strings.ReplaceAll(dataStr, "CSRF_TOKEN", csrfToken)
+	}
+
+	return rr.ResponseWriter.Write([]byte(dataStr))
+}
+
+func (rr *csrfResponseWriter) WriteHeader(statusCode int) {
+	rr.ResponseWriter.WriteHeader(statusCode)
+}
+
+func CrossSiteRequestForgery(auth service.Auth) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+
+			session := GetSession(r)
+
+			if r.Method == http.MethodPost ||
+				r.Method == http.MethodPut ||
+				r.Method == http.MethodDelete ||
+				r.Method == http.MethodPatch {
+
+				csrfToken := r.FormValue("csrf-token")
+				if csrfToken == "" {
+					csrfToken = r.Header.Get("csrf-token")
+				}
+				if session == nil || csrfToken == "" || !auth.IsCsrfTokenValid(csrfToken, session.Id) {
+					log.Info("CSRF-Token not correct")
+					if r.Header.Get("HX-Request") == "true" {
+						utils.TriggerToast(w, r, "error", "CSRF-Token not correct", http.StatusBadRequest)
+					} else {
+						http.Error(w, "CSRF-Token not correct", http.StatusBadRequest)
+					}
+					return
+				}
+			}
+
+			responseWriter := newCsrfResponseWriter(w, auth, session)
+			next.ServeHTTP(responseWriter, r)
+		})
+	}
+}

handler/middleware/default.go

@@ -0,0 +1,15 @@
+package middleware
+
+import "net/http"
+
+func CreateSessionCookie(sessionId string) http.Cookie {
+	return http.Cookie{
+		Name:     "id",
+		Value:    sessionId,
+		MaxAge:   60 * 60 * 8, // 8 hours
+		Secure:   true,
+		HttpOnly: true,
+		SameSite: http.SameSiteStrictMode,
+		Path:     "/",
+	}
+}

handler/middleware/logger.go

@@ -1,11 +1,12 @@
 package middleware
 
 import (
-	"log/slog"
 	"net/http"
 	"strconv"
 	"time"
 
+	"web-app-template/log"
+
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )
@@ -40,7 +41,7 @@ func Log(next http.Handler) http.Handler {
 		}
 		next.ServeHTTP(wrapped, r)
 
-		slog.Info(r.RemoteAddr + " " + strconv.Itoa(wrapped.StatusCode) + " " + r.Method + " " + r.URL.Path + " " + time.Since(start).String())
+		log.Info(r.RemoteAddr + " " + strconv.Itoa(wrapped.StatusCode) + " " + r.Method + " " + r.URL.Path + " " + time.Since(start).String())
 		metrics.WithLabelValues(r.URL.Path, r.Method, http.StatusText(wrapped.StatusCode)).Inc()
 	})
 }

handler/middleware/security_headers.go

@@ -0,0 +1,40 @@
+package middleware
+
+import (
+	"net/http"
+
+	"web-app-template/types"
+)
+
+func SecurityHeaders(serverSettings *types.Settings) func(http.Handler) http.Handler {
+
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("X-Content-Type-Options", "nosniff")
+			w.Header().Set("Access-Control-Allow-Origin", serverSettings.BaseUrl)
+			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE")
+			w.Header().Set("Content-Security-Policy",
+				"default-src 'none'; "+
+					"script-src 'self'; "+
+					"connect-src 'self'; "+
+					"img-src 'self'; "+
+					"style-src 'self'; "+
+					"form-action 'self'; "+
+					"frame-ancestors 'none'; ",
+			)
+			w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
+			w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
+			w.Header().Set("Cross-Origin-Embedder-Policy", "require-corp")
+			w.Header().Set("Permissions-Policy", "geolocation=(), camera=(), microphone=(), interest-cohort=()")
+			w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
+			w.Header().Set("Strict-Transport-Security", "max-age=63072000; includeSubDomains; preload")
+
+			if r.Method == "OPTIONS" {
+				w.WriteHeader(http.StatusOK)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}

handler/render.go

@@ -0,0 +1,53 @@
+package handler
+
+import (
+	"web-app-template/log"
+	"web-app-template/template"
+	"web-app-template/template/auth"
+	"web-app-template/types"
+
+	"net/http"
+
+	"github.com/a-h/templ"
+)
+
+type Render struct {
+}
+
+func NewRender() *Render {
+	return &Render{}
+}
+
+func (render *Render) RenderWithStatus(r *http.Request, w http.ResponseWriter, comp templ.Component, status int) {
+	w.Header().Set("Content-Type", "text/html")
+	w.WriteHeader(status)
+	err := comp.Render(r.Context(), w)
+	if err != nil {
+		log.Error("Failed to render layout: %v", err)
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+	}
+}
+
+func (render *Render) Render(r *http.Request, w http.ResponseWriter, comp templ.Component) {
+	render.RenderWithStatus(r, w, comp, http.StatusOK)
+}
+
+func (render *Render) RenderLayout(r *http.Request, w http.ResponseWriter, slot templ.Component, user *types.User) {
+	render.RenderLayoutWithStatus(r, w, slot, user, http.StatusOK)
+}
+
+func (render *Render) RenderLayoutWithStatus(r *http.Request, w http.ResponseWriter, slot templ.Component, user *types.User, status int) {
+	userComp := render.getUserComp(user)
+	layout := template.Layout(slot, userComp)
+
+	render.RenderWithStatus(r, w, layout, status)
+}
+
+func (render *Render) getUserComp(user *types.User) templ.Component {
+
+	if user != nil {
+		return auth.UserComp(user.Email)
+	} else {
+		return auth.UserComp("")
+	}
+}

handler/workout.go

@@ -1,69 +1,59 @@
 package handler
 
 import (
-	"me-fit/service"
+	"web-app-template/handler/middleware"
-	"me-fit/template"
+	"web-app-template/service"
-	"me-fit/template/workout"
+	"web-app-template/template/workout"
-	"me-fit/types"
+	"web-app-template/utils"
-	"me-fit/utils"
 
-	"database/sql"
-	"log/slog"
 	"net/http"
 	"strconv"
 	"time"
 )
 
-type WorkoutHandler interface {
+type Workout interface {
-	handle(router *http.ServeMux)
+	Handle(router *http.ServeMux)
 }
 
-type WorkoutHandlerImpl struct {
+type WorkoutImpl struct {
-	db             *sql.DB
+	service service.Workout
-	service        service.WorkoutService
+	auth    service.Auth
-	auth           service.AuthService
+	render  *Render
-	serverSettings *types.ServerSettings
 }
 
-func NewWorkoutHandler(db *sql.DB, service service.WorkoutService, auth service.AuthService, serverSettings *types.ServerSettings) HandlerAuth {
+func NewWorkout(service service.Workout, auth service.Auth, render *Render) Workout {
-	return WorkoutHandlerImpl{
+	return WorkoutImpl{
-		db:             db,
 		service: service,
 		auth:    auth,
-		serverSettings: serverSettings,
+		render:  render,
 	}
 }
 
-func (handler WorkoutHandlerImpl) handle(router *http.ServeMux) {
+func (handler WorkoutImpl) Handle(router *http.ServeMux) {
 	router.Handle("/workout", handler.handleWorkoutPage())
 	router.Handle("POST /api/workout", handler.handleAddWorkout())
 	router.Handle("GET /api/workout", handler.handleGetWorkout())
 	router.Handle("DELETE /api/workout/{id}", handler.handleDeleteWorkout())
 }
 
-func (handler WorkoutHandlerImpl) handleWorkoutPage() http.HandlerFunc {
+func (handler WorkoutImpl) handleWorkoutPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.auth.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user == nil {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
 
 		currentDate := time.Now().Format("2006-01-02")
-		inner := workout.WorkoutComp(currentDate)
+		comp := workout.WorkoutComp(currentDate)
-		userComp := service.UserInfoComp(user)
+		handler.render.RenderLayout(r, w, comp, user)
-		err = template.Layout(inner, userComp, handler.serverSettings.Environment).Render(r.Context(), w)
-		if err != nil {
-			utils.LogError("Failed to render workout page", err)
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		}
 	}
 }
 
-func (handler WorkoutHandlerImpl) handleAddWorkout() http.HandlerFunc {
+func (handler WorkoutImpl) handleAddWorkout() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.auth.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user == nil {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
@@ -74,27 +64,23 @@ func (handler WorkoutHandlerImpl) handleAddWorkout() http.HandlerFunc {
 		var repsStr = r.FormValue("reps")
 
 		wo := service.NewWorkoutDto("", dateStr, typeStr, setsStr, repsStr)
-		wo, err = handler.service.AddWorkout(user, wo)
+		wo, err := handler.service.AddWorkout(user, wo)
 		if err != nil {
-			utils.TriggerToast(w, r, "error", "Invalid input values")
+			utils.TriggerToast(w, r, "error", "Invalid input values", http.StatusBadRequest)
 			http.Error(w, "Invalid input values", http.StatusBadRequest)
 			return
 		}
 		wor := workout.Workout{Id: wo.RowId, Date: wo.Date, Type: wo.Type, Sets: wo.Sets, Reps: wo.Reps}
 
-		err = workout.WorkoutItemComp(wor, true).Render(r.Context(), w)
+		comp := workout.WorkoutItemComp(wor, true)
-		if err != nil {
+		handler.render.Render(r, w, comp)
-			utils.LogError("Could not render workoutitem", err)
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
 	}
 }
 
-func (handler WorkoutHandlerImpl) handleGetWorkout() http.HandlerFunc {
+func (handler WorkoutImpl) handleGetWorkout() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.auth.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user == nil {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
@@ -109,39 +95,34 @@ func (handler WorkoutHandlerImpl) handleGetWorkout() http.HandlerFunc {
 			wos = append(wos, workout.Workout{Id: wo.RowId, Date: wo.Date, Type: wo.Type, Sets: wo.Sets, Reps: wo.Reps})
 		}
 
-		workout.WorkoutListComp(wos).Render(r.Context(), w)
+		comp := workout.WorkoutListComp(wos)
+		handler.render.Render(r, w, comp)
 	}
 }
 
-func (handler WorkoutHandlerImpl) handleDeleteWorkout() http.HandlerFunc {
+func (handler WorkoutImpl) handleDeleteWorkout() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		user, err := handler.auth.GetUserFromSessionId(utils.GetSessionID(r))
+		user := middleware.GetUser(r)
-		if err != nil {
+		if user == nil {
 			utils.DoRedirect(w, r, "/auth/signin")
 			return
 		}
 
 		rowId := r.PathValue("id")
 		if rowId == "" {
-			http.Error(w, "Missing required fields", http.StatusBadRequest)
+			utils.TriggerToast(w, r, "error", "Missing ID field", http.StatusBadRequest)
-			slog.Warn("Missing required fields for workout delete")
-			utils.TriggerToast(w, r, "error", "Missing ID field")
 			return
 		}
 
 		rowIdInt, err := strconv.Atoi(rowId)
 		if err != nil {
-			http.Error(w, "Invalid ID", http.StatusBadRequest)
+			utils.TriggerToast(w, r, "error", "Invalid ID", http.StatusBadRequest)
-			slog.Warn("Invalid ID for workout delete")
-			utils.TriggerToast(w, r, "error", "Invalid ID")
 			return
 		}
 
 		err = handler.service.DeleteWorkout(user, rowIdInt)
 		if err != nil {
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			utils.TriggerToast(w, r, "error", "Internal Server Error", http.StatusInternalServerError)
-			slog.Error("Could not delete workout: " + err.Error())
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
 			return
 		}
 	}

input.css

@@ -0,0 +1,18 @@
+@import 'tailwindcss';
+
+@source './static/**/*.js';
+@source './template/**/*.templ';
+
+@theme {
+  --animate-fade: fadeOut 0.25s ease-in;
+
+  @keyframes fadeOut {
+    0% {
+      opacity: 1;
+    }
+    100% {
+      opacity: 0;
+    }
+  }
+}
+

log/default.go

@@ -0,0 +1,56 @@
+package log
+
+import (
+	"fmt"
+	"log"
+	"log/slog"
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+var (
+	errorMetric = promauto.NewCounter(
+		prometheus.CounterOpts{
+			Name: "mefit_error_total",
+			Help: "The total number of errors during processing",
+		},
+	)
+)
+
+func Fatal(message string, args ...interface{}) {
+	s := format(message, args)
+	log.Fatal(s)
+
+	errorMetric.Inc()
+}
+
+func Error(message string, args ...interface{}) {
+	s := format(message, args)
+	slog.Error(s)
+
+	errorMetric.Inc()
+}
+
+func Warn(message string, args ...interface{}) {
+	s := format(message, args)
+	slog.Warn(s)
+}
+
+func Info(message string, args ...interface{}) {
+	s := format(message, args)
+	slog.Info(s)
+}
+
+func format(message string, args []interface{}) string {
+	var w strings.Builder
+
+	if len(args) > 0 {
+		fmt.Fprintf(&w, message, args...)
+	} else {
+		w.WriteString(message)
+	}
+
+	return w.String()
+}

main.go

@@ -1,14 +1,15 @@
 package main
 
 import (
-	"me-fit/handler"
+	"web-app-template/db"
-	"me-fit/types"
+	"web-app-template/handler"
-	"me-fit/utils"
+	"web-app-template/handler/middleware"
+	"web-app-template/log"
+	"web-app-template/service"
+	"web-app-template/types"
 
 	"context"
 	"database/sql"
-	"log"
-	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
@@ -29,27 +30,26 @@ func main() {
 
 	db, err := sql.Open("sqlite3", "./data.db")
 	if err != nil {
-		log.Fatal("Could not open Database data.db: ", err)
+		log.Fatal("Could not open Database data.db: %v", err)
 	}
 	defer db.Close()
 
 	run(context.Background(), db, os.Getenv)
 }
 
-func run(ctx context.Context, db *sql.DB, env func(string) string) {
+func run(ctx context.Context, database *sql.DB, env func(string) string) {
 	ctx, cancel := signal.NotifyContext(ctx, syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()
 
-	slog.Info("Starting server...")
+	log.Info("Starting server...")
 
 	// init server settings
-	serverSettings := types.NewServerSettingsFromEnv(env)
+	serverSettings := types.NewSettingsFromEnv(env)
 
 	// init db
-	err := utils.RunMigrations(db, "")
+	err := db.RunMigrations(database, "")
 	if err != nil {
-		slog.Error("Could not run migrations: " + err.Error())
+		log.Fatal("Could not run migrations: %v", err)
-		os.Exit(1)
 	}
 
 	// init servers
@@ -64,7 +64,7 @@ func run(ctx context.Context, db *sql.DB, env func(string) string) {
 
 	httpServer := &http.Server{
 		Addr:    ":" + serverSettings.Port,
-		Handler: handler.GetHandler(db, serverSettings),
+		Handler: createHandler(database, serverSettings),
 	}
 	go startServer(httpServer)
 
@@ -77,9 +77,9 @@ func run(ctx context.Context, db *sql.DB, env func(string) string) {
 }
 
 func startServer(s *http.Server) {
-	slog.Info("Starting server on " + s.Addr)
+	log.Info("Starting server on %q", s.Addr)
 	if err := s.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-		slog.Error("error listening and serving: " + err.Error())
+		log.Error("error listening and serving: %v", err)
 	}
 }
 
@@ -94,8 +94,43 @@ func shutdownServer(s *http.Server, ctx context.Context, wg *sync.WaitGroup) {
 	shutdownCtx, cancel := context.WithTimeout(shutdownCtx, 10*time.Second)
 	defer cancel()
 	if err := s.Shutdown(shutdownCtx); err != nil {
-		slog.Error("error shutting down http server: " + err.Error())
+		log.Error("error shutting down http server: %v", err)
 	} else {
-		slog.Info("Gracefully stopped http server on " + s.Addr)
+		log.Info("Gracefully stopped http server on %v", s.Addr)
 	}
 }
+
+func createHandler(d *sql.DB, serverSettings *types.Settings) http.Handler {
+	var router = http.NewServeMux()
+
+	authDb := db.NewAuthSqlite(d)
+	workoutDb := db.NewWorkoutDbSqlite(d)
+
+	randomService := service.NewRandomImpl()
+	clockService := service.NewClockImpl()
+	mailService := service.NewMailImpl(serverSettings)
+
+	authService := service.NewAuthImpl(authDb, randomService, clockService, mailService, serverSettings)
+	workoutService := service.NewWorkoutImpl(workoutDb, randomService, clockService, mailService, serverSettings)
+
+	render := handler.NewRender()
+	indexHandler := handler.NewIndex(authService, render)
+	authHandler := handler.NewAuth(authService, render)
+	workoutHandler := handler.NewWorkout(workoutService, authService, render)
+
+	indexHandler.Handle(router)
+	workoutHandler.Handle(router)
+	authHandler.Handle(router)
+
+	// Serve static files (CSS, JS and images)
+	router.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static/"))))
+
+	return middleware.Wrapper(
+		router,
+		middleware.Log,
+		middleware.CacheControl,
+		middleware.SecurityHeaders(serverSettings),
+		middleware.Authenticate(authService),
+		middleware.CrossSiteRequestForgery(authService),
+	)
+}

middleware/content_security_policiy.go

@@ -1,14 +0,0 @@
-package middleware
-
-import "net/http"
-
-func ContentSecurityPolicy(next http.Handler) http.Handler {
-
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// While this value can be overridden, it can't be moved to after the next.ServeHTTP call,
-		// because if the response writer get's closed, the headers can't be set anymore
-		w.Header().Set("Content-Security-Policy", "default-src 'self' https://umami.me-fit.eu; frame-ancestors 'none'")
-
-		next.ServeHTTP(w, r)
-	})
-}

middleware/corp.go

@@ -1,13 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-)
-
-func Corp(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
-
-		next.ServeHTTP(w, r)
-	})
-}

middleware/cors.go

@@ -1,23 +0,0 @@
-package middleware
-
-import (
-	"me-fit/types"
-
-	"net/http"
-)
-
-func Cors(serverSettings *types.ServerSettings) func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Access-Control-Allow-Origin", serverSettings.BaseUrl)
-			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE")
-
-			if r.Method == "OPTIONS" {
-				w.WriteHeader(http.StatusOK)
-				return
-			}
-
-			next.ServeHTTP(w, r)
-		})
-	}
-}

middleware/sec_fetch_filter.go

@@ -1,29 +0,0 @@
-package middleware
-
-import "net/http"
-
-func SecFetchFilter(next http.Handler) http.Handler {
-
-	// A map is slower than a slice, but it's easier to check if a value exists
-	allowedSites := map[string]interface{}{
-		"same-origin": nil,
-		"none":        nil,
-	}
-
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		secFetchSite := r.Header.Get("Sec-Fetch-Site")
-
-		if secFetchSite == "" {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		_, exists := allowedSites[r.Header.Get("Sec-Fetch-Site")]
-		if !exists {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		w.WriteHeader(http.StatusForbidden)
-	})
-}

migration/001_initial_schema.up.sql

@@ -1,4 +1,40 @@
 
+CREATE TABLE user (
+	user_id TEXT NOT NULL UNIQUE PRIMARY KEY,
+
+	email TEXT NOT NULL UNIQUE,
+	email_verified BOOLEAN NOT NULL,
+	email_verified_at DATETIME,
+
+	is_admin BOOLEAN NOT NULL,
+
+	password BLOB NOT NULL,
+	salt BLOB NOT NULL,
+
+	created_at DATETIME NOT NULL
+) WITHOUT ROWID;
+
+CREATE TABLE session (
+	session_id TEXT NOT NULL UNIQUE PRIMARY KEY,
+	user_id TEXT NOT NULL,
+
+	created_at DATETIME NOT NULL,
+	expires_at DATETIME NOT NULL
+) WITHOUT ROWID;
+
+
+CREATE TABLE token (
+	token TEXT NOT NULL UNIQUE PRIMARY KEY,
+
+	user_id TEXT,
+	session_id TEXT,
+
+	type TEXT NOT NULL,
+
+	created_at DATETIME NOT NULL,
+	expires_at DATETIME
+);
+
 CREATE TABLE workout (
 	user_id INTEGER NOT NULL,
 	date TEXT NOT NULL,
@@ -6,4 +42,3 @@ CREATE TABLE workout (
 	sets INTEGER NOT NULL,
 	reps INTEGER NOT NULL
 );
-

migration/002_user_and_session.up.sql

@@ -1,21 +0,0 @@
-
-CREATE TABLE user (
-	user_uuid TEXT NOT NULL UNIQUE PRIMARY KEY,
-
-	email TEXT NOT NULL UNIQUE,
-	email_verified BOOLEAN NOT NULL,
-
-	is_admin BOOLEAN NOT NULL,
-
-	password BLOB NOT NULL,
-	salt BLOB NOT NULL,
-
-	created_at DATETIME NOT NULL
-) WITHOUT ROWID;
-
-CREATE TABLE session (
-	session_id TEXT NOT NULL UNIQUE PRIMARY KEY,
-	user_uuid TEXT NOT NULL,
-
-	created_at DATETIME NOT NULL
-) WITHOUT ROWID;

migration/003_user_mail_verification.up.sql

@@ -1,2 +0,0 @@
-
-ALTER TABLE user ADD COLUMN email_verified_at DATETIME DEFAULT NULL;

migration/004_user_tokens.up.sql

@@ -1,11 +0,0 @@
-
--- E.G. email-verifications, password-resets, unsubscribe-from-newsletter etc.
-CREATE TABLE user_token (
-	user_uuid TEXT NOT NULL,
-
-	type TEXT NOT NULL,
-	token TEXT NOT NULL UNIQUE PRIMARY KEY,
-
-	created_at DATETIME NOT NULL,
-	expires_at DATETIME
-);

mocks/default.go

@@ -0,0 +1 @@
+package mocks

package.json

@@ -1,19 +1,18 @@
 {
-  "name": "me-fit",
+  "name": "web-app-template",
   "version": "1.0.0",
   "description": "Your (almost) independent tech stack to host on a VPC.",
   "main": "index.js",
   "scripts": {
-    "build": "mkdir -p static/js && cp -f node_modules/htmx.org/dist/htmx.min.js static/js/htmx.min.js && tailwindcss build -o static/css/tailwind.css --minify",
+    "build": "mkdir -p static/js && cp -f node_modules/htmx.org/dist/htmx.min.js static/js/htmx.min.js && tailwindcss -i input.css -o static/css/tailwind.css --minify",
-    "watch": "mkdir -p static/js && cp -f node_modules/htmx.org/dist/htmx.min.js static/js/htmx.min.js && tailwindcss build -o static/css/tailwind.css --watch",
+    "watch": "mkdir -p static/js && cp -f node_modules/htmx.org/dist/htmx.min.js static/js/htmx.min.js && tailwindcss -i input.css -o static/css/tailwind.css --watch"
-    "test": ""
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "htmx.org": "2.0.3",
+    "htmx.org": "2.0.6",
-    "tailwindcss": "3.4.15",
+    "tailwindcss": "4.1.11",
-    "daisyui": "4.12.14"
+		"@tailwindcss/cli": "4.1.11"
   }
 }

service/auth.go

@@ -3,129 +3,175 @@ package service
 import (
 	"context"
 	"crypto/subtle"
-	"database/sql"
 	"errors"
-	"log/slog"
-	"net/http"
 	"net/mail"
-	"net/url"
 	"strings"
 	"time"
 
-	"me-fit/db"
+	"web-app-template/db"
-	"me-fit/template/auth"
+	"web-app-template/log"
-	tempMail "me-fit/template/mail"
+	mailTemplate "web-app-template/template/mail"
-	"me-fit/types"
+	"web-app-template/types"
-	"me-fit/utils"
 
-	"github.com/a-h/templ"
 	"github.com/google/uuid"
 	"golang.org/x/crypto/argon2"
 )
 
 var (
-	ErrInvaidCredentials = errors.New("Invalid email or password")
+	ErrInvalidCredentials = errors.New("invalid email or password")
-	ErrInvalidPassword   = errors.New("Password needs to be 8 characters long, contain at least one number, one special, one uppercase and one lowercase character")
+	ErrInvalidPassword    = errors.New("password needs to be 8 characters long, contain at least one number, one special, one uppercase and one lowercase character")
-	ErrInvalidEmail      = errors.New("Invalid email")
+	ErrInvalidEmail       = errors.New("invalid email")
-	ErrAccountExists     = errors.New("Account already exists")
+	ErrAccountExists      = errors.New("account already exists")
-	ErrSessionIdInvalid  = errors.New("Session ID is invalid")
+	ErrSessionIdInvalid   = errors.New("session ID is invalid")
+	ErrTokenInvalid       = errors.New("token is invalid")
 )
 
-type User struct {
+type Auth interface {
-	Id            uuid.UUID
+	SignUp(email string, password string) (*types.User, error)
-	Email         string
-	EmailVerified bool
-}
-
-func NewUser(user *db.User) *User {
-	return &User{
-		Id:            user.Id,
-		Email:         user.Email,
-		EmailVerified: user.EmailVerified,
-	}
-}
-
-type Session struct {
-	Id        string
-	CreatedAt time.Time
-	User      *User
-}
-
-func NewSession(session *db.Session, user *User) *Session {
-	return &Session{
-		Id:        session.Id,
-		CreatedAt: session.CreatedAt,
-		User:      user,
-	}
-}
-
-type AuthService interface {
-	SignIn(email string, password string) (*Session, error)
-	SignUp(email string, password string) (*User, error)
 	SendVerificationMail(userId uuid.UUID, email string)
+	VerifyUserEmail(token string) error
+
+	SignIn(session *types.Session, email string, password string) (*types.Session, *types.User, error)
+	SignInSession(sessionId string) (*types.Session, *types.User, error)
+	SignInAnonymous() (*types.Session, error)
 	SignOut(sessionId string) error
-	DeleteAccount(user *User) error
-	ChangePassword(user *User, currPass, newPass string) error
 
-	GetUserFromSessionId(sessionId string) (*User, error)
+	DeleteAccount(user *types.User, currPass string) error
+
+	ChangePassword(user *types.User, sessionId string, currPass, newPass string) error
+
+	SendForgotPasswordMail(email string) error
+	ForgotPassword(token string, newPass string) error
+
+	IsCsrfTokenValid(tokenStr string, sessionId string) bool
+	GetCsrfToken(session *types.Session) (string, error)
 }
 
-type AuthServiceImpl struct {
+type AuthImpl struct {
-	dbAuth          db.AuthDb
+	db             db.Auth
-	randomGenerator RandomService
+	random         Random
-	clock           ClockService
+	clock          Clock
-	mailService     MailService
+	mail           Mail
-	serverSettings  *types.ServerSettings
+	serverSettings *types.Settings
 }
 
-func NewAuthServiceImpl(dbAuth db.AuthDb, randomGenerator RandomService, clock ClockService, mailService MailService, serverSettings *types.ServerSettings) *AuthServiceImpl {
+func NewAuthImpl(db db.Auth, random Random, clock Clock, mail Mail, serverSettings *types.Settings) *AuthImpl {
-	return &AuthServiceImpl{
+	return &AuthImpl{
-		dbAuth:          dbAuth,
+		db:             db,
-		randomGenerator: randomGenerator,
+		random:         random,
 		clock:          clock,
-		mailService:     mailService,
+		mail:           mail,
 		serverSettings: serverSettings,
 	}
 }
 
-func (service AuthServiceImpl) SignIn(email string, password string) (*Session, error) {
+func (service AuthImpl) SignIn(session *types.Session, email string, password string) (*types.Session, *types.User, error) {
-	user, err := service.dbAuth.GetUser(email)
+	user, err := service.db.GetUserByEmail(email)
 	if err != nil {
-		if errors.Is(err, db.ErrUserNotFound) {
+		if errors.Is(err, db.ErrNotFound) {
-			return nil, ErrInvaidCredentials
+			return nil, nil, ErrInvalidCredentials
 		} else {
-			return nil, types.ErrInternal
+			return nil, nil, types.ErrInternal
 		}
 	}
 
 	hash := GetHashPassword(password, user.Salt)
 
 	if subtle.ConstantTimeCompare(hash, user.Password) == 0 {
-		return nil, ErrInvaidCredentials
+		return nil, nil, ErrInvalidCredentials
 	}
 
-	session, err := service.createSession(user.Id)
+	err = service.cleanUpSessionWithTokens(session)
+	if err != nil {
+		return nil, nil, types.ErrInternal
+	}
+
+	session, err = service.createSession(user.Id)
+	if err != nil {
+		return nil, nil, types.ErrInternal
+	}
+
+	return session, user, nil
+}
+
+func (service AuthImpl) cleanUpSessionWithTokens(session *types.Session) error {
+	if session == nil {
+		return nil
+	}
+
+	err := service.db.DeleteSession(session.Id)
+	if err != nil {
+		return types.ErrInternal
+	}
+
+	tokens, err := service.db.GetTokensBySessionIdAndType(session.Id, types.TokenTypeCsrf)
+	if err != nil {
+		return types.ErrInternal
+	}
+	for _, token := range tokens {
+		err = service.db.DeleteToken(token.Token)
+		if err != nil {
+			return types.ErrInternal
+		}
+	}
+
+	return nil
+}
+
+func (service AuthImpl) SignInSession(sessionId string) (*types.Session, *types.User, error) {
+	if sessionId == "" {
+		return nil, nil, ErrSessionIdInvalid
+	}
+
+	session, err := service.db.GetSession(sessionId)
+	if err != nil {
+		return nil, nil, types.ErrInternal
+	}
+	if session.ExpiresAt.Before(service.clock.Now()) {
+		_ = service.db.DeleteSession(sessionId)
+		return nil, nil, nil
+	}
+
+	if session.UserId == uuid.Nil {
+		return session, nil, nil
+	}
+
+	user, err := service.db.GetUser(session.UserId)
+	if err != nil {
+		return nil, nil, types.ErrInternal
+	}
+
+	return session, user, nil
+}
+
+func (service AuthImpl) SignInAnonymous() (*types.Session, error) {
+	session, err := service.createSession(uuid.Nil)
 	if err != nil {
 		return nil, types.ErrInternal
 	}
 
-	return NewSession(session, NewUser(user)), nil
+	log.Info("Anonymous session created: %v", session.Id)
+
+	return session, nil
 }
 
-func (service AuthServiceImpl) createSession(userId uuid.UUID) (*db.Session, error) {
+func (service AuthImpl) createSession(userId uuid.UUID) (*types.Session, error) {
-	sessionId, err := service.randomGenerator.String(32)
+	sessionId, err := service.random.String(32)
 	if err != nil {
 		return nil, types.ErrInternal
 	}
 
-	err = service.dbAuth.DeleteOldSessions(userId)
+	err = service.db.DeleteOldSessions(userId)
 	if err != nil {
 		return nil, types.ErrInternal
 	}
 
-	session := db.NewSession(sessionId, userId, service.clock.Now())
+	createAt := service.clock.Now()
+	expiresAt := createAt.Add(24 * time.Hour)
 
-	err = service.dbAuth.InsertSession(session)
+	session := types.NewSession(sessionId, userId, createAt, expiresAt)
+
+	err = service.db.InsertSession(session)
 	if err != nil {
 		return nil, types.ErrInternal
 	}
@@ -133,7 +179,7 @@ func (service AuthServiceImpl) createSession(userId uuid.UUID) (*db.Session, err
 	return session, nil
 }
 
-func (service AuthServiceImpl) SignUp(email string, password string) (*User, error) {
+func (service AuthImpl) SignUp(email string, password string) (*types.User, error) {
 	_, err := mail.ParseAddress(email)
 	if err != nil {
 		return nil, ErrInvalidEmail
@@ -143,155 +189,135 @@ func (service AuthServiceImpl) SignUp(email string, password string) (*User, err
 		return nil, ErrInvalidPassword
 	}
 
-	userId, err := service.randomGenerator.UUID()
+	userId, err := service.random.UUID()
 	if err != nil {
 		return nil, types.ErrInternal
 	}
 
-	salt, err := service.randomGenerator.Bytes(16)
+	salt, err := service.random.Bytes(16)
 	if err != nil {
 		return nil, types.ErrInternal
 	}
 
 	hash := GetHashPassword(password, salt)
 
-	dbUser := db.NewUser(userId, email, false, nil, false, hash, salt, service.clock.Now())
+	user := types.NewUser(userId, email, false, nil, false, hash, salt, service.clock.Now())
 
-	err = service.dbAuth.InsertUser(dbUser)
+	err = service.db.InsertUser(user)
 	if err != nil {
-		if err == db.ErrUserExists {
+		if err == db.ErrAlreadyExists {
 			return nil, ErrAccountExists
 		} else {
 			return nil, types.ErrInternal
 		}
 	}
 
-	return NewUser(dbUser), nil
+	return user, nil
 }
 
-func (service AuthServiceImpl) SendVerificationMail(userId uuid.UUID, email string) {
+func (service AuthImpl) SendVerificationMail(userId uuid.UUID, email string) {
-	var token string
 
-	token, err := service.dbAuth.GetEmailVerificationToken(userId)
+	tokens, err := service.db.GetTokensByUserIdAndType(userId, types.TokenTypeEmailVerify)
+	if err != nil && err != db.ErrNotFound {
+		return
+	}
+
+	var token *types.Token
+
+	if len(tokens) > 0 {
+		token = tokens[0]
+	}
+
+	if token == nil {
+		newTokenStr, err := service.random.String(32)
 		if err != nil {
 			return
 		}
 
-	if token == "" {
+		token = types.NewToken(userId, "", newTokenStr, types.TokenTypeEmailVerify, service.clock.Now(), service.clock.Now().Add(24*time.Hour))
-		token, err := service.randomGenerator.String(32)
-		if err != nil {
-			return
-		}
 
-		err = service.dbAuth.InsertEmailVerificationToken(userId, token)
+		err = service.db.InsertToken(token)
 		if err != nil {
 			return
 		}
 	}
 
 	var w strings.Builder
-	err = tempMail.Register(service.serverSettings.BaseUrl, token).Render(context.Background(), &w)
+	err = mailTemplate.Register(service.serverSettings.BaseUrl, token.Token).Render(context.Background(), &w)
 	if err != nil {
-		utils.LogError("Could not render welcome email", err)
+		log.Error("Could not render welcome email: %v", err)
 		return
 	}
 
-	service.mailService.SendMail(email, "Welcome to ME-FIT", w.String())
+	service.mail.SendMail(email, "Welcome to web-app-template", w.String())
 }
 
-func (service AuthServiceImpl) SignOut(sessionId string) error {
+func (service AuthImpl) VerifyUserEmail(tokenStr string) error {
 
-	return service.dbAuth.DeleteSession(sessionId)
+	if tokenStr == "" {
+		return types.ErrInternal
 	}
 
-func (service AuthServiceImpl) GetUserFromSessionId(sessionId string) (*User, error) {
+	token, err := service.db.GetToken(tokenStr)
-	if sessionId == "" {
-		return nil, ErrSessionIdInvalid
-	}
-
-	session, err := service.dbAuth.GetSession(sessionId)
 	if err != nil {
-		return nil, types.ErrInternal
+		return types.ErrInternal
 	}
 
-	user, err := service.dbAuth.GetUserById(session.UserId)
+	user, err := service.db.GetUser(token.UserId)
 	if err != nil {
-		return nil, types.ErrInternal
+		return types.ErrInternal
 	}
 
-	if session.CreatedAt.Add(time.Duration(8 * time.Hour)).Before(service.clock.Now()) {
+	if token.Type != types.TokenTypeEmailVerify {
-		return nil, nil
+		return types.ErrInternal
-	} else {
-		return NewUser(user), nil
-	}
 	}
 
-// TODO
+	now := service.clock.Now()
 
-func HandleSignUpVerifyResponsePage(db *sql.DB) http.HandlerFunc {
+	if token.ExpiresAt.Before(now) {
-	return func(w http.ResponseWriter, r *http.Request) {
+		return types.ErrInternal
-
-		token := r.URL.Query().Get("token")
-
-		if token == "" {
-			utils.DoRedirect(w, r, "/auth/verify")
-			return
 	}
 
-		result, err := db.Exec(`
+	user.EmailVerified = true
-			UPDATE user
+	user.EmailVerifiedAt = &now
-			SET email_verified = true, email_verified_at = datetime()
-			WHERE user_uuid = (
-				SELECT user_uuid
-				FROM user_token
-				WHERE type = "email_verify"
-				AND token = ?
-			);
-		`, token)
 
+	err = service.db.UpdateUser(user)
 	if err != nil {
-			utils.LogError("Could not update user on verify response", err)
+		return types.ErrInternal
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			return
 	}
 
-		i, err := result.RowsAffected()
+	_ = service.db.DeleteToken(token.Token)
+	return nil
+}
+
+func (service AuthImpl) SignOut(sessionId string) error {
+
+	return service.db.DeleteSession(sessionId)
+}
+
+func (service AuthImpl) DeleteAccount(user *types.User, currPass string) error {
+
+	userDb, err := service.db.GetUser(user.Id)
 	if err != nil {
-			utils.LogError("Could not get rows affected on verify response", err)
+		return types.ErrInternal
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			return
 	}
 
-		if i == 0 {
+	currHash := GetHashPassword(currPass, userDb.Salt)
-			utils.DoRedirect(w, r, "/")
+	if subtle.ConstantTimeCompare(currHash, userDb.Password) == 0 {
-		} else {
+		return ErrInvalidCredentials
-			utils.DoRedirect(w, r, "/auth/signin")
-		}
-	}
 	}
 
-func UserInfoComp(user *User) templ.Component {
+	err = service.db.DeleteUser(user.Id)
-
-	if user != nil {
-		return auth.UserComp(user.Email)
-	} else {
-		return auth.UserComp("")
-	}
-}
-
-func (service AuthServiceImpl) DeleteAccount(user *User) error {
-
-	err := service.dbAuth.DeleteUser(user.Id)
 	if err != nil {
 		return err
 	}
 
-	go service.mailService.SendMail(user.Email, "Account deleted", "Your account has been deleted")
+	service.mail.SendMail(user.Email, "Account deleted", "Your account has been deleted")
 
 	return nil
 }
 
-func (service AuthServiceImpl) ChangePassword(user *User, currPass, newPass string) error {
+func (service AuthImpl) ChangePassword(user *types.User, sessionId string, currPass, newPass string) error {
 
 	if !isPasswordValid(newPass) {
 		return ErrInvalidPassword
@@ -301,135 +327,160 @@ func (service AuthServiceImpl) ChangePassword(user *User, currPass, newPass stri
 		return ErrInvalidPassword
 	}
 
-	_, err := service.SignIn(user.Email, currPass)
+	currHash := GetHashPassword(currPass, user.Salt)
+
+	if subtle.ConstantTimeCompare(currHash, user.Password) == 0 {
+		return ErrInvalidCredentials
+	}
+
+	newHash := GetHashPassword(newPass, user.Salt)
+	user.Password = newHash
+
+	err := service.db.UpdateUser(user)
 	if err != nil {
 		return err
 	}
 
-	userDb, err := service.dbAuth.GetUserById(user.Id)
+	sessions, err := service.db.GetSessions(user.Id)
 	if err != nil {
-		return err
+		return types.ErrInternal
 	}
-
+	for _, s := range sessions {
-	newHash := GetHashPassword(newPass, userDb.Salt)
+		if s.Id != sessionId {
-
+			err = service.db.DeleteSession(s.Id)
-	err = service.dbAuth.UpdateUserPassword(user.Id, newHash)
 			if err != nil {
-		return err
+				return types.ErrInternal
+			}
+		}
 	}
 
 	return nil
 }
 
-func HandleActualResetPasswordComp(db *sql.DB) http.HandlerFunc {
+func (service AuthImpl) SendForgotPasswordMail(email string) error {
-	return func(w http.ResponseWriter, r *http.Request) {
+	tokenStr, err := service.random.String(32)
-
-		pageUrl, err := url.Parse(r.Header.Get("HX-Current-URL"))
 	if err != nil {
-			utils.LogError("Could not get current URL", err)
+		return err
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
-			return
 	}
 
-		token := pageUrl.Query().Get("token")
+	user, err := service.db.GetUserByEmail(email)
-		if token == "" {
+	if err != nil {
-			utils.TriggerToast(w, r, "error", "No token")
+		if err == db.ErrNotFound {
-			return
+			return nil
+		} else {
+			return types.ErrInternal
+		}
 	}
 
-		newPass := r.FormValue("new-password")
+	token := types.NewToken(user.Id, "", tokenStr, types.TokenTypePasswordReset, service.clock.Now(), service.clock.Now().Add(15*time.Minute))
+
+	err = service.db.InsertToken(token)
+	if err != nil {
+		return types.ErrInternal
+	}
+
+	var mail strings.Builder
+	err = mailTemplate.ResetPassword(service.serverSettings.BaseUrl, token.Token).Render(context.Background(), &mail)
+	if err != nil {
+		log.Error("Could not render reset password email: %v", err)
+		return types.ErrInternal
+	}
+	service.mail.SendMail(email, "Reset Password", mail.String())
+
+	return nil
+}
+
+func (service AuthImpl) ForgotPassword(tokenStr string, newPass string) error {
 
 	if !isPasswordValid(newPass) {
-			utils.TriggerToast(w, r, "error", ErrInvalidPassword.Error())
+		return ErrInvalidPassword
-			return
 	}
 
-		var (
+	token, err := service.db.GetToken(tokenStr)
-			userId uuid.UUID
-			salt   []byte
-		)
-
-		err = db.QueryRow(`
-			SELECT u.user_uuid, salt
-			FROM user_token t
-			INNER JOIN user u ON t.user_uuid = u.user_uuid
-			WHERE t.token = ? 
-			AND t.type = 'password_reset'
-			AND t.expires_at > datetime()
-			`, token).Scan(&userId, &salt)
 	if err != nil {
-			slog.Warn("Could not get user from token: " + err.Error())
+		return ErrTokenInvalid
-			utils.TriggerToast(w, r, "error", "Invalid token")
-			return
 	}
 
-		_, err = db.Exec("DELETE FROM user_token WHERE token = ? AND type = 'password_reset'", token)
+	err = service.db.DeleteToken(tokenStr)
 	if err != nil {
-			utils.LogError("Could not delete token", err)
+		return err
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
-			return
 	}
 
-		passHash := GetHashPassword(newPass, salt)
+	if token.Type != types.TokenTypePasswordReset ||
+		token.ExpiresAt.Before(service.clock.Now()) {
+		return ErrTokenInvalid
+	}
 
-		_, err = db.Exec("UPDATE user SET password = ? WHERE user_uuid = ?", passHash, userId)
+	user, err := service.db.GetUser(token.UserId)
 	if err != nil {
-			utils.LogError("Could not update password", err)
+		log.Error("Could not get user from token: %v", err)
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
+		return types.ErrInternal
-			return
 	}
 
-		utils.TriggerToast(w, r, "success", "Password changed")
+	passHash := GetHashPassword(newPass, user.Salt)
-	}
-}
 
-func HandleResetPasswordComp(db *sql.DB, serverSettings *types.ServerSettings) http.HandlerFunc {
+	user.Password = passHash
-	mailService := NewMailServiceImpl(serverSettings)
+	err = service.db.UpdateUser(user)
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		email := r.FormValue("email")
-		if email == "" {
-			utils.TriggerToast(w, r, "error", "Please enter an email")
-			return
-		}
-
-		token, err := NewRandomServiceImpl().String(32)
 	if err != nil {
-			return
+		return err
 	}
 
-		res, err := db.Exec(`
+	sessions, err := service.db.GetSessions(user.Id)
-			INSERT INTO user_token (user_uuid, type, token, created_at, expires_at)
-			SELECT user_uuid, 'password_reset', ?, datetime(), datetime('now', '+15 minute')
-			FROM user
-			WHERE email = ?
-			`, token, email)
 	if err != nil {
-			utils.LogError("Could not insert token", err)
+		return types.ErrInternal
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
-			return
 	}
 
-		i, err := res.RowsAffected()
+	for _, session := range sessions {
+		err = service.db.DeleteSession(session.Id)
 		if err != nil {
-			utils.LogError("Could not get rows affected", err)
+			return types.ErrInternal
-			utils.TriggerToast(w, r, "error", "Internal Server Error")
+		}
-			return
 	}
 
-		if i != 0 {
+	return nil
-			var mail strings.Builder
+}
-			err = tempMail.ResetPassword(serverSettings.BaseUrl, token).Render(context.Background(), &mail)
+
+func (service AuthImpl) IsCsrfTokenValid(tokenStr string, sessionId string) bool {
+	token, err := service.db.GetToken(tokenStr)
 	if err != nil {
-				utils.LogError("Could not render reset password email", err)
+		return false
-				utils.TriggerToast(w, r, "error", "Internal Server Error")
-				return
-			}
-			mailService.SendMail(email, "Reset Password", mail.String())
 	}
 
-		utils.TriggerToast(w, r, "info", "If the email exists, an email has been sent")
+	if token.Type != types.TokenTypeCsrf ||
+		token.SessionId != sessionId ||
+		token.ExpiresAt.Before(service.clock.Now()) {
+
+		return false
 	}
+
+	return true
+}
+
+func (service AuthImpl) GetCsrfToken(session *types.Session) (string, error) {
+	if session == nil {
+		return "", types.ErrInternal
+	}
+
+	tokens, _ := service.db.GetTokensBySessionIdAndType(session.Id, types.TokenTypeCsrf)
+
+	if len(tokens) > 0 {
+		return tokens[0].Token, nil
+	}
+
+	tokenStr, err := service.random.String(32)
+	if err != nil {
+		return "", types.ErrInternal
+	}
+
+	token := types.NewToken(session.UserId, session.Id, tokenStr, types.TokenTypeCsrf, service.clock.Now(), service.clock.Now().Add(8*time.Hour))
+	err = service.db.InsertToken(token)
+	if err != nil {
+		return "", types.ErrInternal
+	}
+
+	log.Info("CSRF-Token created: %v", tokenStr)
+
+	return tokenStr, nil
 }
 
 func GetHashPassword(password string, salt []byte) []byte {

service/auth_test.go

@@ -1,11 +1,10 @@
 package service
 
 import (
-	"me-fit/db"
+	"web-app-template/db"
-	"me-fit/mocks"
+	"web-app-template/mocks"
-	"me-fit/types"
+	"web-app-template/types"
 
-	"errors"
 	"strings"
 	"testing"
 	"time"
@@ -15,115 +14,17 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
-func TestSignIn(t *testing.T) {
-
-	t.Parallel()
-	t.Run("should return user if password is correct", func(t *testing.T) {
-		t.Parallel()
-		salt := []byte("salt")
-		verifiedAt := time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC)
-		user := db.NewUser(
-			uuid.New(),
-			"test@test.de",
-			true,
-			&verifiedAt,
-			false,
-			GetHashPassword("password", salt),
-			salt,
-			time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC),
-		)
-
-		dbSession := db.NewSession("sessionId", user.Id, time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC))
-
-		mockAuthDb := mocks.NewMockAuthDb(t)
-		mockAuthDb.EXPECT().GetUser("test@test.de").Return(user, nil)
-		mockAuthDb.EXPECT().DeleteOldSessions(user.Id).Return(nil)
-		mockAuthDb.EXPECT().InsertSession(dbSession).Return(nil)
-		mockRandom := mocks.NewMockRandomService(t)
-		mockRandom.EXPECT().String(32).Return("sessionId", nil)
-		mockClock := mocks.NewMockClockService(t)
-		mockClock.EXPECT().Now().Return(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC))
-		mockMail := mocks.NewMockMailService(t)
-
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
-
-		actualSession, err := underTest.SignIn(user.Email, "password")
-		assert.Nil(t, err)
-
-		expectedSession := NewSession(dbSession, NewUser(user))
-		assert.Equal(t, expectedSession, actualSession)
-	})
-
-	t.Run("should return ErrInvalidCretentials if password is not correct", func(t *testing.T) {
-		t.Parallel()
-		salt := []byte("salt")
-		verifiedAt := time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC)
-
-		user := db.NewUser(
-			uuid.New(),
-			"test@test.de",
-			true,
-			&verifiedAt,
-			false,
-			GetHashPassword("password", salt),
-			salt,
-			time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC),
-		)
-
-		mockAuthDb := mocks.NewMockAuthDb(t)
-		mockAuthDb.EXPECT().GetUser(user.Email).Return(user, nil)
-		mockRandom := mocks.NewMockRandomService(t)
-		mockClock := mocks.NewMockClockService(t)
-		mockMail := mocks.NewMockMailService(t)
-
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
-
-		_, err := underTest.SignIn("test@test.de", "wrong password")
-
-		assert.Equal(t, ErrInvaidCredentials, err)
-	})
-	t.Run("should return ErrInvalidCretentials if user has not been found", func(t *testing.T) {
-		t.Parallel()
-
-		mockAuthDb := mocks.NewMockAuthDb(t)
-		mockAuthDb.EXPECT().GetUser("test").Return(nil, db.ErrUserNotFound)
-		mockRandom := mocks.NewMockRandomService(t)
-		mockClock := mocks.NewMockClockService(t)
-		mockMail := mocks.NewMockMailService(t)
-
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
-
-		_, err := underTest.SignIn("test", "test")
-		assert.Equal(t, ErrInvaidCredentials, err)
-	})
-	t.Run("should forward ErrInternal on any other error", func(t *testing.T) {
-		t.Parallel()
-
-		mockAuthDb := mocks.NewMockAuthDb(t)
-		mockAuthDb.EXPECT().GetUser("test").Return(nil, errors.New("Some undefined error"))
-		mockRandom := mocks.NewMockRandomService(t)
-		mockClock := mocks.NewMockClockService(t)
-		mockMail := mocks.NewMockMailService(t)
-
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
-
-		_, err := underTest.SignIn("test", "test")
-
-		assert.Equal(t, types.ErrInternal, err)
-	})
-}
-
 func TestSignUp(t *testing.T) {
 	t.Parallel()
 	t.Run("should check for correct email address", func(t *testing.T) {
 		t.Parallel()
 
-		mockAuthDb := mocks.NewMockAuthDb(t)
+		mockAuthDb := mocks.NewMockAuth(t)
-		mockRandom := mocks.NewMockRandomService(t)
+		mockRandom := mocks.NewMockRandom(t)
-		mockClock := mocks.NewMockClockService(t)
+		mockClock := mocks.NewMockClock(t)
-		mockMail := mocks.NewMockMailService(t)
+		mockMail := mocks.NewMockMail(t)
 
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
+		underTest := NewAuthImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.Settings{})
 
 		_, err := underTest.SignUp("invalid email address", "SomeStrongPassword123!")
 
@@ -132,12 +33,12 @@ func TestSignUp(t *testing.T) {
 	t.Run("should check for password complexity", func(t *testing.T) {
 		t.Parallel()
 
-		mockAuthDb := mocks.NewMockAuthDb(t)
+		mockAuthDb := mocks.NewMockAuth(t)
-		mockRandom := mocks.NewMockRandomService(t)
+		mockRandom := mocks.NewMockRandom(t)
-		mockClock := mocks.NewMockClockService(t)
+		mockClock := mocks.NewMockClock(t)
-		mockMail := mocks.NewMockMailService(t)
+		mockMail := mocks.NewMockMail(t)
 
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
+		underTest := NewAuthImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.Settings{})
 
 		weakPasswords := []string{
 			"123!ab", // too short
@@ -154,69 +55,55 @@ func TestSignUp(t *testing.T) {
 	t.Run("should signup correctly", func(t *testing.T) {
 		t.Parallel()
 
-		mockAuthDb := mocks.NewMockAuthDb(t)
+		mockAuthDb := mocks.NewMockAuth(t)
-		mockRandom := mocks.NewMockRandomService(t)
+		mockRandom := mocks.NewMockRandom(t)
-		mockClock := mocks.NewMockClockService(t)
+		mockClock := mocks.NewMockClock(t)
-		mockMail := mocks.NewMockMailService(t)
+		mockMail := mocks.NewMockMail(t)
 
-		expected := User{
+		userId := uuid.New()
-			Id:            uuid.New(),
+		email := "mail@mail.de"
-			Email:         "some@valid.email",
-			EmailVerified: false,
-		}
-
-		random := NewRandomServiceImpl()
-		salt, err := random.Bytes(16)
-		assert.Nil(t, err)
 		password := "SomeStrongPassword123!"
-
+		salt := []byte("salt")
-		mockRandom.EXPECT().UUID().Return(expected.Id, nil)
-		mockRandom.EXPECT().Bytes(16).Return(salt, nil)
-
 		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 
+		expected := types.NewUser(userId, email, false, nil, false, GetHashPassword(password, salt), salt, createTime)
+
+		mockRandom.EXPECT().UUID().Return(userId, nil)
+		mockRandom.EXPECT().Bytes(16).Return(salt, nil)
 		mockClock.EXPECT().Now().Return(createTime)
+		mockAuthDb.EXPECT().InsertUser(expected).Return(nil)
 
-		mockAuthDb.EXPECT().InsertUser(db.NewUser(expected.Id, expected.Email, false, nil, false, GetHashPassword(password, salt), salt, createTime)).Return(nil)
+		underTest := NewAuthImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.Settings{})
-
+		actual, err := underTest.SignUp(email, password)
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
-
-		actual, err := underTest.SignUp(expected.Email, password)
 
 		assert.Nil(t, err)
 
-		assert.Equal(t, expected, *actual)
+		assert.Equal(t, expected, actual)
 	})
 	t.Run("should return ErrAccountExists", func(t *testing.T) {
 		t.Parallel()
 
-		mockAuthDb := mocks.NewMockAuthDb(t)
+		mockAuthDb := mocks.NewMockAuth(t)
-		mockRandom := mocks.NewMockRandomService(t)
+		mockRandom := mocks.NewMockRandom(t)
-		mockClock := mocks.NewMockClockService(t)
+		mockClock := mocks.NewMockClock(t)
-		mockMail := mocks.NewMockMailService(t)
+		mockMail := mocks.NewMockMail(t)
 
-		user := User{
+		userId := uuid.New()
-			Id:    uuid.New(),
+		email := "some@valid.email"
-			Email: "some@valid.email",
+		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
-		}
-
-		random := NewRandomServiceImpl()
-		salt, err := random.Bytes(16)
-		assert.Nil(t, err)
 		password := "SomeStrongPassword123!"
+		salt := []byte("salt")
+		user := types.NewUser(userId, email, false, nil, false, GetHashPassword(password, salt), salt, createTime)
 
 		mockRandom.EXPECT().UUID().Return(user.Id, nil)
 		mockRandom.EXPECT().Bytes(16).Return(salt, nil)
-
-		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
-
 		mockClock.EXPECT().Now().Return(createTime)
 
-		mockAuthDb.EXPECT().InsertUser(db.NewUser(user.Id, user.Email, false, nil, false, GetHashPassword(password, salt), salt, createTime)).Return(db.ErrUserExists)
+		mockAuthDb.EXPECT().InsertUser(user).Return(db.ErrAlreadyExists)
 
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
+		underTest := NewAuthImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.Settings{})
 
-		_, err = underTest.SignUp(user.Email, password)
+		_, err := underTest.SignUp(user.Email, password)
 		assert.Equal(t, ErrAccountExists, err)
 	})
 }
@@ -227,20 +114,24 @@ func TestSendVerificationMail(t *testing.T) {
 	t.Run("should use stored token and send mail", func(t *testing.T) {
 		t.Parallel()
 
-		token := "someRandomTokenToUse"
+		token := types.NewToken(uuid.New(), "sessionId", "someRandomTokenToUse", types.TokenTypeEmailVerify, time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC))
+		tokens := []*types.Token{token}
+
 		email := "some@email.de"
 		userId := uuid.New()
 
-		mockAuthDb := mocks.NewMockAuthDb(t)
+		mockAuthDb := mocks.NewMockAuth(t)
-		mockRandom := mocks.NewMockRandomService(t)
+		mockRandom := mocks.NewMockRandom(t)
-		mockClock := mocks.NewMockClockService(t)
+		mockClock := mocks.NewMockClock(t)
-		mockMail := mocks.NewMockMailService(t)
+		mockMail := mocks.NewMockMail(t)
 
-		mockAuthDb.EXPECT().GetEmailVerificationToken(userId).Return(token, nil)
+		mockAuthDb.EXPECT().GetTokensByUserIdAndType(userId, types.TokenTypeEmailVerify).Return(tokens, nil)
 
-		mockMail.EXPECT().SendMail(email, "Welcome to ME-FIT", mock.MatchedBy(func(message string) bool { return strings.Contains(message, token) })).Return(nil)
+		mockMail.EXPECT().SendMail(email, "Welcome to web-app-template", mock.MatchedBy(func(message string) bool {
+			return strings.Contains(message, token.Token)
+		})).Return()
 
-		underTest := NewAuthServiceImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.ServerSettings{})
+		underTest := NewAuthImpl(mockAuthDb, mockRandom, mockClock, mockMail, &types.Settings{})
 
 		underTest.SendVerificationMail(userId, email)
 	})

service/clock.go

@@ -2,16 +2,16 @@ package service
 
 import "time"
 
-type ClockService interface {
+type Clock interface {
 	Now() time.Time
 }
 
-type ClockServiceImpl struct{}
+type ClockImpl struct{}
 
-func NewClockServiceImpl() ClockService {
+func NewClockImpl() Clock {
-	return &ClockServiceImpl{}
+	return &ClockImpl{}
 }
 
-func (c *ClockServiceImpl) Now() time.Time {
+func (c *ClockImpl) Now() time.Time {
 	return time.Now()
 }

service/mail.go

@@ -1,33 +1,44 @@
 package service
 
 import (
+	"web-app-template/log"
+	"web-app-template/types"
+
 	"fmt"
-	"me-fit/types"
 	"net/smtp"
 )
 
-type MailService interface {
+type Mail interface {
-	SendMail(to string, subject string, message string) error
+	// Sending an email is a fire and forget operation. Thus no error handling
+	SendMail(to string, subject string, message string)
 }
 
-type MailServiceImpl struct {
+type MailImpl struct {
-	serverSettings *types.ServerSettings
+	server *types.Settings
 }
 
-func NewMailServiceImpl(serverSettings *types.ServerSettings) MailServiceImpl {
+func NewMailImpl(server *types.Settings) MailImpl {
-	return MailServiceImpl{serverSettings: serverSettings}
+	return MailImpl{server: server}
 }
 
-func (m MailServiceImpl) SendMail(to string, subject string, message string) error {
+func (m MailImpl) SendMail(to string, subject string, message string) {
-	if m.serverSettings.Smtp == nil {
+	go m.internalSendMail(to, subject, message)
-		return nil
 }
 
-	s := m.serverSettings.Smtp
+func (m MailImpl) internalSendMail(to string, subject string, message string) {
+	if m.server.Smtp == nil {
+		return
+	}
+
+	s := m.server.Smtp
 
 	auth := smtp.PlainAuth("", s.User, s.Pass, s.Host)
 
 	msg := fmt.Sprintf("From: %v <%v>\nTo: %v\nSubject: %v\nMIME-version: 1.0;\nContent-Type: text/html; charset=\"UTF-8\";\n\n%v", s.FromName, s.FromMail, to, subject, message)
 
-	return smtp.SendMail(s.Host+":"+s.Port, auth, s.FromMail, []string{to}, []byte(msg))
+	log.Info("Sending mail to %v", to)
+	err := smtp.SendMail(s.Host+":"+s.Port, auth, s.FromMail, []string{to}, []byte(msg))
+	if err != nil {
+		log.Error("Error sending mail: %v", err)
+	}
 }

service/random_generator.go

@@ -1,48 +1,49 @@
 package service
 
 import (
-	"me-fit/types"
+	"web-app-template/log"
+	"web-app-template/types"
 
 	"crypto/rand"
 	"encoding/base64"
-	"log/slog"
 
 	"github.com/google/uuid"
 )
 
-type RandomService interface {
+type Random interface {
 	Bytes(size int) ([]byte, error)
 	String(size int) (string, error)
 	UUID() (uuid.UUID, error)
 }
 
-type RandomServiceImpl struct {
+type RandomImpl struct {
 }
 
-func NewRandomServiceImpl() *RandomServiceImpl {
+func NewRandomImpl() *RandomImpl {
-	return &RandomServiceImpl{}
+	return &RandomImpl{}
 }
 
-func (r *RandomServiceImpl) Bytes(size int) ([]byte, error) {
+func (r *RandomImpl) Bytes(size int) ([]byte, error) {
 	b := make([]byte, 32)
 	_, err := rand.Read(b)
 	if err != nil {
-		slog.Error("Error generating random bytes: " + err.Error())
+		log.Error("Error generating random bytes: %v", err)
 		return []byte{}, types.ErrInternal
 	}
 
 	return b, nil
 }
 
-func (r *RandomServiceImpl) String(size int) (string, error) {
+func (r *RandomImpl) String(size int) (string, error) {
 	bytes, err := r.Bytes(size)
 	if err != nil {
+		log.Error("Error generating random string: %v", err)
 		return "", types.ErrInternal
 	}
 
 	return base64.StdEncoding.EncodeToString(bytes), nil
 }
 
-func (r *RandomServiceImpl) UUID() (uuid.UUID, error) {
+func (r *RandomImpl) UUID() (uuid.UUID, error) {
 	return uuid.NewRandom()
 }

service/workout.go

@@ -1,35 +1,35 @@
 package service
 
 import (
-	"me-fit/db"
+	"web-app-template/db"
-	"me-fit/types"
+	"web-app-template/types"
 
 	"errors"
 	"strconv"
 	"time"
 )
 
-type WorkoutService interface {
+type Workout interface {
-	AddWorkout(user *User, workoutDto *WorkoutDto) (*WorkoutDto, error)
+	AddWorkout(user *types.User, workoutDto *WorkoutDto) (*WorkoutDto, error)
-	DeleteWorkout(user *User, rowId int) error
+	DeleteWorkout(user *types.User, rowId int) error
-	GetWorkouts(user *User) ([]*WorkoutDto, error)
+	GetWorkouts(user *types.User) ([]*WorkoutDto, error)
 }
 
-type WorkoutServiceImpl struct {
+type WorkoutImpl struct {
-	dbWorkout       db.WorkoutDb
+	db       db.WorkoutDb
-	randomGenerator RandomService
+	random   Random
-	clock           ClockService
+	clock    Clock
-	mailService     MailService
+	mail     Mail
-	serverSettings  *types.ServerSettings
+	settings *types.Settings
 }
 
-func NewWorkoutServiceImpl(dbWorkout db.WorkoutDb, randomGenerator RandomService, clock ClockService, mailService MailService, serverSettings *types.ServerSettings) WorkoutService {
+func NewWorkoutImpl(db db.WorkoutDb, random Random, clock Clock, mail Mail, settings *types.Settings) Workout {
-	return WorkoutServiceImpl{
+	return WorkoutImpl{
-		dbWorkout:       dbWorkout,
+		db:       db,
-		randomGenerator: randomGenerator,
+		random:   random,
 		clock:    clock,
-		mailService:     mailService,
+		mail:     mail,
-		serverSettings:  serverSettings,
+		settings: settings,
 	}
 }
 
@@ -61,10 +61,10 @@ func NewWorkoutDto(rowId string, date string, workoutType string, sets string, r
 }
 
 var (
-	ErrInputValues = errors.New("Invalid input values")
+	ErrInputValues = errors.New("invalid input values")
 )
 
-func (service WorkoutServiceImpl) AddWorkout(user *User, workoutDto *WorkoutDto) (*WorkoutDto, error) {
+func (service WorkoutImpl) AddWorkout(user *types.User, workoutDto *WorkoutDto) (*WorkoutDto, error) {
 
 	if workoutDto.Date == "" || workoutDto.Type == "" || workoutDto.Sets == "" || workoutDto.Reps == "" {
 		return nil, ErrInputValues
@@ -87,7 +87,7 @@ func (service WorkoutServiceImpl) AddWorkout(user *User, workoutDto *WorkoutDto)
 
 	workoutInsert := db.NewWorkoutInsert(date, workoutDto.Type, sets, reps)
 
-	workout, err := service.dbWorkout.InsertWorkout(user.Id, workoutInsert)
+	workout, err := service.db.InsertWorkout(user.Id, workoutInsert)
 	if err != nil {
 		return nil, err
 	}
@@ -95,20 +95,20 @@ func (service WorkoutServiceImpl) AddWorkout(user *User, workoutDto *WorkoutDto)
 	return NewWorkoutDtoFromDb(workout), nil
 }
 
-func (service WorkoutServiceImpl) DeleteWorkout(user *User, rowId int) error {
+func (service WorkoutImpl) DeleteWorkout(user *types.User, rowId int) error {
 	if user == nil {
 		return types.ErrInternal
 	}
 
-	return service.dbWorkout.DeleteWorkout(user.Id, rowId)
+	return service.db.DeleteWorkout(user.Id, rowId)
 }
 
-func (service WorkoutServiceImpl) GetWorkouts(user *User) ([]*WorkoutDto, error) {
+func (service WorkoutImpl) GetWorkouts(user *types.User) ([]*WorkoutDto, error) {
 	if user == nil {
 		return nil, types.ErrInternal
 	}
 
-	workouts, err := service.dbWorkout.GetWorkouts(user.Id)
+	workouts, err := service.db.GetWorkouts(user.Id)
 	if err != nil {
 		return nil, err
 	}
@@ -125,15 +125,6 @@ func (service WorkoutServiceImpl) GetWorkouts(user *User) ([]*WorkoutDto, error)
 	return workoutsDto, nil
 }
 
-func renderDateStr(date string) (string, error) {
-	t, err := time.Parse("2006-01-02 15:04:05-07:00", date)
-	if err != nil {
-		return "", err
-	}
-
-	return renderDate(t), nil
-}
-
 func renderDate(date time.Time) string {
 	return date.Format("2006-01-02")
 }

tailwind.config.js

@@ -1,26 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-	content: ["./template/**/*.templ", "./static/**/*.js"],
-	theme: {
-		extend: {
-
-			animation: {
-				fade: 'fadeOut 0.25s ease-in',
-			},
-
-			keyframes: _ => ({
-				fadeOut: {
-					'0%': { opacity: '1' },
-					'100%': { opacity: '0' },
-				},
-			}),
-		},
-	},
-	plugins: [
-		require('daisyui'),
-	],
-	daisyui: {
-		themes: ["retro"],
-	},
-}
-

template/auth/change_password.templ

@@ -4,7 +4,7 @@ templ ChangePasswordComp(isPasswordReset bool) {
 	<form
 		class="max-w-xl px-2 mx-auto flex flex-col gap-4 h-full justify-center"
 		if isPasswordReset {
-			hx-post="/api/auth/reset-password-actual"
+			hx-post="/api/auth/forgot-password-actual"
 		} else {
 			hx-post="/api/auth/change-password"
 		}
@@ -15,11 +15,29 @@ templ ChangePasswordComp(isPasswordReset bool) {
 		</h2>
 		if !isPasswordReset {
 			<label class="input input-bordered flex items-center gap-2">
-				<input type="password" class="grow" placeholder="Current Password" name="current-password"/>
+				<input
+					type="password"
+					class="grow"
+					placeholder="Current Password"
+					name="current-password"
+					spellcheck="false"
+					autocomplete="off"
+					autocorrect="off"
+					autocapitalize="off"
+				/>
 			</label>
 		}
 		<label class="input input-bordered flex items-center gap-2">
-			<input type="password" class="grow" placeholder="New Password" name="new-password"/>
+			<input
+				type="password"
+				class="grow"
+				placeholder="New Password"
+				name="new-password"
+				spellcheck="false"
+				autocomplete="off"
+				autocorrect="off"
+				autocapitalize="off"
+			/>
 		</label>
 		<button class="btn btn-primary self-end">
 			Change Password

template/auth/delete_account.templ

@@ -12,10 +12,19 @@ templ DeleteAccountComp() {
 		<p class="text-xl text-red-500 mb-4">
 			Are you sure you want to delete your account? This action is irreversible.
 		</p>
-		<label class="input input-bordered flex items-center gap-2">
+		<label class="flex items-center gap-2">
-			<input type="password" class="grow" placeholder="Password" name="password"/>
+			<input
+				type="password"
+				class="grow"
+				placeholder="Password"
+				name="password"
+				spellcheck="false"
+				autocomplete="off"
+				autocorrect="off"
+				autocapitalize="off"
+			/>
 		</label>
-		<button class="btn btn-error self-end">
+		<button class="self-end">
 			Delete Account
 		</button>
 	</form>

template/auth/reset_password.templ

@@ -3,14 +3,23 @@ package auth
 templ ResetPasswordComp() {
 	<form
 		class="max-w-xl px-2 mx-auto flex flex-col gap-4 h-full justify-center"
-		hx-post="/api/auth/reset-password"
+		hx-post="/api/auth/forgot-password"
 		hx-swap="none"
 	>
 		<h2 class="text-6xl mb-10">
 			Reset Password
 		</h2>
 		<label class="input input-bordered flex items-center gap-2">
-			<input type="email" class="grow" placeholder="E-Mail" name="email"/>
+			<input
+				type="email"
+				class="grow"
+				placeholder="E-Mail"
+				name="email"
+				spellcheck="false"
+				autocomplete="off"
+				autocorrect="off"
+				autocapitalize="off"
+			/>
 		</label>
 		<button class="btn btn-primary self-end">
 			Request Password Reset

template/auth/sign_in_or_up.templ

@@ -1,14 +1,18 @@
 package auth
 
 templ SignInOrUpComp(isSignIn bool) {
+	{{
+var postUrl string
+if isSignIn {
+	postUrl = "/api/auth/signin"
+} else {
+	postUrl = "/api/auth/signup"
+}
+	}}
 	<form
 		class="max-w-xl px-2 mx-auto flex flex-col gap-4 h-full justify-center"
 		hx-target="#sign-in-or-up-error"
-		if isSignIn {
+		hx-post={ postUrl }
-			hx-post="/api/auth/signin"
-		} else {
-			hx-post="/api/auth/signup"
-		}
 	>
 		<h2 class="text-6xl mb-10">
 			if isSignIn {
@@ -18,12 +22,7 @@ templ SignInOrUpComp(isSignIn bool) {
 			}
 		</h2>
 		<label class="input input-bordered flex items-center gap-2">
-			<svg
+			<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="currentColor" class="h-4 w-4 opacity-70">
-				xmlns="http://www.w3.org/2000/svg"
-				viewBox="0 0 16 16"
-				fill="currentColor"
-				class="h-4 w-4 opacity-70"
-			>
 				<path
 					d="M2.5 3A1.5 1.5 0 0 0 1 4.5v.793c.026.009.051.02.076.032L7.674 8.51c.206.1.446.1.652 0l6.598-3.185A.755.755 0 0 1 15 5.293V4.5A1.5 1.5 0 0 0 13.5 3h-11Z"
 				></path>
@@ -31,26 +30,39 @@ templ SignInOrUpComp(isSignIn bool) {
 					d="M15 6.954 8.978 9.86a2.25 2.25 0 0 1-1.956 0L1 6.954V11.5A1.5 1.5 0 0 0 2.5 13h11a1.5 1.5 0 0 0 1.5-1.5V6.954Z"
 				></path>
 			</svg>
-			<input type="text" class="grow" placeholder="Email" name="email"/>
+			<input
+				type="text"
+				class="grow"
+				placeholder="Email"
+				name="email"
+				spellcheck="false"
+				autocomplete="off"
+				autocorrect="off"
+				autocapitalize="off"
+			/>
 		</label>
 		<label class="input input-bordered flex items-center gap-2">
-			<svg
+			<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="currentColor" class="h-4 w-4 opacity-70">
-				xmlns="http://www.w3.org/2000/svg"
-				viewBox="0 0 16 16"
-				fill="currentColor"
-				class="h-4 w-4 opacity-70"
-			>
 				<path
 					fill-rule="evenodd"
 					d="M14 6a4 4 0 0 1-4.899 3.899l-1.955 1.955a.5.5 0 0 1-.353.146H5v1.5a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1-.5-.5v-2.293a.5.5 0 0 1 .146-.353l3.955-3.955A4 4 0 1 1 14 6Zm-4-2a.75.75 0 0 0 0 1.5.5.5 0 0 1 .5.5.75.75 0 0 0 1.5 0 2 2 0 0 0-2-2Z"
 					clip-rule="evenodd"
 				></path>
 			</svg>
-			<input type="password" class="grow" placeholder="Password" name="password"/>
+			<input
+				type="password"
+				class="grow"
+				placeholder="Password"
+				name="password"
+				spellcheck="false"
+				autocomplete="off"
+				autocorrect="off"
+				autocapitalize="off"
+			/>
 		</label>
 		<div class="flex justify-end items-center gap-2">
 			if isSignIn {
-				<a href="/auth/reset-password" class="grow link text-gray-500 text-sm">Forgot Password?</a>
+				<a href="/auth/forgot-password" class="grow link text-gray-500 text-sm">Forgot Password?</a>
 				<a href="/auth/signup" class="link text-gray-500 text-sm">Don't have an account? Sign Up</a>
 				<button class="btn btn-primary">
 					Sign In

template/auth/user.templ

@@ -3,36 +3,28 @@ package auth
 templ UserComp(user string) {
 	<div id="user-info" class="flex gap-5 items-center">
 		if user != "" {
-			<div class="group inline-block relative">
+			<div class="inline-block relative">
-				<button
+				<button class="font-semibold py-2 px-4 inline-flex items-center">
-					class="font-semibold py-2 px-4 inline-flex items-center"
-				>
 					<span class="mr-1">{ user }</span>
-					<svg
+					<svg class="fill-current h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
-						class="fill-current h-4 w-4"
+						<path d="M9.293 12.95l.707.707L15.657 8l-1.414-1.414L10 10.828 5.757 6.586 4.343 8z"></path>
-						xmlns="http://www.w3.org/2000/svg"
-						viewBox="0 0 20 20"
-					>
-						<path
-							d="M9.293 12.95l.707.707L15.657 8l-1.414-1.414L10 10.828 5.757 6.586 4.343 8z"
-						></path>
 					</svg>
 				</button>
 				<div class="absolute hidden group-hover:block w-full">
-					<ul class="menu bg-base-300 rounded-box w-fit float-right mr-4 p-3">
+					<ul class="w-fit float-right mr-4 p-3">
 						<li class="mb-1">
-							<a hx-get="/api/auth/signout" hx-target="#user-info">Sign Out</a>
+							<a hx-post="/api/auth/signout" hx-target="#user-info">Sign Out</a>
 						</li>
 						<li class="mb-1">
 							<a href="/auth/change-password">Change Password</a>
 						</li>
-						<li><a href="/auth/delete-account" class="text-error">Delete Account</a></li>
+						<li><a href="/auth/delete-account" class="">Delete Account</a></li>
 					</ul>
 				</div>
 			</div>
 		} else {
-			<a href="/auth/signup" class="btn btn-sm">Sign Up</a>
+			<a href="/auth/signup" class="">Sign Up</a>
-			<a href="/auth/signin" class="btn btn-sm">Sign In</a>
+			<a href="/auth/signin" class="">Sign In</a>
 		}
 	</div>
 }

template/auth/verify.templ

@@ -12,7 +12,7 @@ templ VerifyComp() {
 			<p class="text-lg text-center">
 				Please check your inbox/spam and click on the link to verify your account.
 			</p>
-			<button class="btn mt-8" hx-get="/api/auth/verify-resend" hx-sync="this:drop" hx-swap="outerHTML">
+			<button class="mt-8" hx-get="/api/auth/verify-resend" hx-sync="this:drop" hx-swap="outerHTML">
 				resend verification email
 			</button>
 		</div>

template/auth/verify_response.templ

@@ -0,0 +1,29 @@
+package auth
+
+templ VerifyResponseComp(isVerified bool) {
+	<main>
+		<div class="flex flex-col items-center justify-center h-screen">
+			if isVerified {
+				<h2 class="text-6xl mb-10">
+					Your email has been verified
+				</h2>
+				<p class="text-lg text-center">
+					You have completed the verification process. Thank you!
+				</p>
+				<a class="mt-8" href="/">
+					Go Home
+				</a>
+			} else {
+				<h2 class="text-6xl mb-10">
+					Error during verification
+				</h2>
+				<p class="text-lg text-center">
+					Please try again by sign up process
+				</p>
+				<a class="mt-8" href="/auth/signup">
+					Sign Up
+				</a>
+			}
+		</div>
+	</main>
+}

template/index.templ

@@ -1,15 +1,15 @@
 package template
 
 templ Index() {
-	<div class="hero bg-base-200 h-full">
+	<div class="h-full">
-		<div class="hero-content text-center">
+		<div class="text-center">
 			<div class="max-w-md">
 				<h1 class="text-5xl font-bold">Next Level Workout Tracker</h1>
 				<p class="py-6">
-					Ever wanted to track your workouts and see your progress over time? ME-FIT is the perfect
+					Ever wanted to track your workouts and see your progress over time? web-app-template is the perfect
 					solution for you.
 				</p>
-				<a href="/workout" class="btn btn-primary">Get Started</a>
+				<a href="/workout" class="">Get Started</a>
 			</div>
 		</div>
 	</div>

template/layout.templ

@@ -1,33 +1,31 @@
 package template
 
-templ Layout(slot templ.Component, user templ.Component, environment string) {
+templ Layout(slot templ.Component, user templ.Component) {
 	<!DOCTYPE html>
 	<html lang="en">
-
 		<head>
 			<meta charset="utf-8"/>
-	<title>ME-FIT</title>
+			<title>web-app-template</title>
 			<link rel="icon" href="/static/favicon.svg"/>
 			<link rel="stylesheet" href="/static/css/tailwind.css"/>
 			<meta name="viewport" content="width=device-width, initial-scale=1"/>
-	if environment == "prod" {
+			<meta
-	<script defer src="https://umami.me-fit.eu/script.js" data-website-id="3c8efb09-44e4-4372-8a1e-c3bc675cd89a"></script>
+				name="htmx-config"
-	}
+				content='{
-	<meta name="htmx-config" content='{
 					"includeIndicatorStyles": false,
 					"selfRequestsOnly": true,
 					"allowScriptTags": false
-	}' />
+				}'
+			/>
 			<script src="/static/js/htmx.min.js"></script>
 			<script src="/static/js/toast.js"></script>
 		</head>
-
+		<body hx-headers='{"csrf-token": "CSRF_TOKEN"}'>
-<body>
 			<div class="h-screen flex flex-col">
-		<div class="flex justify-end items-center gap-2 py-1 px-2 h-12 md:gap-10 md:px-10 md:py-2 shadow">
+				<div class="flex justify-end items-center gap-2 py-1 px-2 h-12 md:gap-10 md:px-10 md:py-2 shadow-sm">
 					<a href="/" class="flex-1 flex gap-2">
-				<img src="/static/favicon.svg" alt="ME-FIT logo" />
+						<img src="/static/favicon.svg" alt="web-app-template logo"/>
-				<span>ME-FIT</span>
+						<span>web-app-template</span>
 					</a>
 					@user
 				</div>
@@ -37,12 +35,11 @@ templ Layout(slot templ.Component, user templ.Component, environment string) {
 					}
 				</div>
 			</div>
-	<div class="toast" id="toasts">
+			<div class="" id="toasts">
-		<div class="hidden alert" id="toast">
+				<div class="hidden" id="toast">
 					New message arrived.
 				</div>
 			</div>
 		</body>
-
 	</html>
 }

template/mail/register.templ

@@ -5,15 +5,19 @@ import "net/url"
 templ Register(baseUrl string, token string) {
 <!DOCTYPE html>
 <html lang="en">
+
 <head>
 	<meta charset="UTF-8" />
 	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 	<title>Welcome</title>
 </head>
+
 <body>
 	<h4>Thank you for Sign Up!</h4>
-			<p>Click <a href={ templ.URL(baseUrl + "/auth/verify-email?token=" + url.QueryEscape(token)) }>here</a> to verify your account.</p>
+	<p>Click <a href={ templ.URL(baseUrl + "/auth/verify-email?token=" + url.QueryEscape(token)) }>here</a> to finalize
+		your registration.</p>
 	<p>Kind regards</p>
 </body>
+
 </html>
 }

template/not_found.templ

@@ -2,10 +2,10 @@ package template
 
 templ NotFound() {
 	<main class="flex h-full justify-center items-center">
-		<div class="bg-error p-16 rounded-lg">
+		<div class="p-16 rounded-lg">
-			<h1 class="text-4xl text-error-content mb-5">Not Found</h1>
+			<h1 class="text-4xl mb-5">Not Found</h1>
-			<p class="text-lg text-error-content mb-5">The page you are looking for does not exist.</p>
+			<p class="text-lg mb-5">The page you are looking for does not exist.</p>
-			<a href="/" class="btn btn-lg btn-primary">Go back to home</a>
+			<a href="/" class="">Go back to home</a>
 		</div>
 	</main>
 }

template/workout/workout.templ

@@ -9,14 +9,14 @@ templ WorkoutComp(currentDate string) {
 			hx-swap="outerHTML"
 		>
 			<h2 class="text-4xl mb-8">Track your workout</h2>
-			<input id="date" type="date" class="input input-bordered" value={ currentDate } name="date"/>
+			<input id="date" type="date" class="" value={ currentDate } name="date"/>
-			<select class="select select-bordered w-full" name="type">
+			<select class="w-full" name="type">
 				<option>Push Ups</option>
 				<option>Pull Ups</option>
 			</select>
-			<input type="number" class="input input-bordered" placeholder="Sets" name="sets"/>
+			<input type="number" class="" placeholder="Sets" name="sets"/>
-			<input type="number" class="input input-bordered" placeholder="Reps" name="reps"/>
+			<input type="number" class="" placeholder="Reps" name="reps"/>
-			<button class="btn btn-primary self-end">Save</button>
+			<button class="self-end">Save</button>
 		</form>
 		<div hx-get="/api/workout" hx-trigger="load"></div>
 	</main>
@@ -31,7 +31,7 @@ type Workout struct {
 }
 
 templ WorkoutListComp(workouts []Workout) {
-	<div class="overflow-x-auto mx-auto max-w-screen-lg">
+	<div class="overflow-x-auto mx-auto max-w-lg">
 		<h2 class="text-4xl mt-14 mb-8">Workout history</h2>
 		<table class="table table-auto max-w-full">
 			<thead>
@@ -64,7 +64,7 @@ templ WorkoutItemComp(w Workout, includePlaceholder bool) {
 		<th>{ w.Reps }</th>
 		<th>
 			<div class="tooltip" data-tip="Delete Entry">
-				<button hx-delete={ "api/workout/" + w.Id } hx-target="closest tr">
+				<button hx-delete={ "api/workout/" + w.Id } hx-target="closest tr" type="submit">
 					Delete
 				</button>
 			</div>

types/auth.go

@@ -0,0 +1,75 @@
+package types
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type User struct {
+	Id              uuid.UUID
+	Email           string
+	EmailVerified   bool
+	EmailVerifiedAt *time.Time
+	IsAdmin         bool
+	Password        []byte
+	Salt            []byte
+	CreateAt        time.Time
+}
+
+func NewUser(id uuid.UUID, email string, emailVerified bool, emailVerifiedAt *time.Time, isAdmin bool, password []byte, salt []byte, createAt time.Time) *User {
+	return &User{
+		Id:              id,
+		Email:           email,
+		EmailVerified:   emailVerified,
+		EmailVerifiedAt: emailVerifiedAt,
+		IsAdmin:         isAdmin,
+		Password:        password,
+		Salt:            salt,
+		CreateAt:        createAt,
+	}
+}
+
+type Session struct {
+	Id        string
+	UserId    uuid.UUID
+	CreatedAt time.Time
+	ExpiresAt time.Time
+}
+
+func NewSession(id string, userId uuid.UUID, createdAt time.Time, expiresAt time.Time) *Session {
+	return &Session{
+		Id:        id,
+		UserId:    userId,
+		CreatedAt: createdAt,
+		ExpiresAt: expiresAt,
+	}
+}
+
+type Token struct {
+	UserId    uuid.UUID
+	SessionId string
+	Token     string
+	Type      TokenType
+	CreatedAt time.Time
+	ExpiresAt time.Time
+}
+
+type TokenType string
+
+var (
+	TokenTypeEmailVerify   TokenType = "email_verify"
+	TokenTypePasswordReset TokenType = "password_reset"
+	TokenTypeCsrf          TokenType = "csrf"
+)
+
+func NewToken(userId uuid.UUID, sessionId string, token string, tokenType TokenType, createdAt time.Time, expiresAt time.Time) *Token {
+	return &Token{
+		UserId:    userId,
+		SessionId: sessionId,
+		Token:     token,
+		Type:      tokenType,
+		CreatedAt: createdAt,
+		ExpiresAt: expiresAt,
+	}
+}

types/settings.go

@@ -1,11 +1,10 @@
 package types
 
 import (
-	"log"
+	"web-app-template/log"
-	"log/slog"
 )
 
-type ServerSettings struct {
+type Settings struct {
 	Port              string
 	PrometheusEnabled bool
 
@@ -23,7 +22,7 @@ type SmtpSettings struct {
 	FromName string
 }
 
-func NewServerSettingsFromEnv(env func(string) string) *ServerSettings {
+func NewSettingsFromEnv(env func(string) string) *Settings {
 
 	var smtp *SmtpSettings
 	if env("SMTP_ENABLED") == "true" {
@@ -56,7 +55,7 @@ func NewServerSettingsFromEnv(env func(string) string) *ServerSettings {
 		}
 	}
 
-	settings := &ServerSettings{
+	settings := &Settings{
 		Port:              env("PORT"),
 		PrometheusEnabled: env("PROMETHEUS_ENABLED") == "true",
 		BaseUrl:           env("BASE_URL"),
@@ -78,8 +77,8 @@ func NewServerSettingsFromEnv(env func(string) string) *ServerSettings {
 		log.Fatal("SMTP and Prometheus must be enabled in production")
 	}
 
-	slog.Info("BASE_URL is " + settings.BaseUrl)
+	log.Info("BASE_URL is %q", settings.BaseUrl)
-	slog.Info("ENVIRONMENT is " + settings.Environment)
+	log.Info("ENVIRONMENT is %q", settings.Environment)
 
 	return settings
 }

types/types.go

@@ -5,5 +5,5 @@ import (
 )
 
 var (
-	ErrInternal = errors.New("Internal server error")
+	ErrInternal = errors.New("internal server error")
 )

utils/http.go

@@ -2,43 +2,18 @@ package utils
 
 import (
 	"fmt"
-	"log/slog"
 	"net/http"
 	"time"
 
-	"github.com/prometheus/client_golang/prometheus"
+	"web-app-template/log"
-	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
-type ContextKey string
+func TriggerToast(w http.ResponseWriter, r *http.Request, class string, message string, statusCode int) {
-
-const (
-	ContextKeyUser ContextKey = "user_id"
-)
-
-var (
-	errorMetric = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "mefit_error_total",
-			Help: "The total number of errors during processing",
-		},
-	)
-)
-
-func LogError(message string, err error) {
-	slog.Error(message + ": " + err.Error())
-	errorMetric.Inc()
-}
-func LogErrorMsg(message string) {
-	slog.Error(message)
-	errorMetric.Inc()
-}
-
-func TriggerToast(w http.ResponseWriter, r *http.Request, class string, message string) {
 	if isHtmx(r) {
 		w.Header().Set("HX-Trigger", fmt.Sprintf(`{"toast": "%v|%v"}`, class, message))
+		w.WriteHeader(statusCode)
 	} else {
-		LogErrorMsg("Trying to trigger toast in non-HTMX request")
+		log.Error("Trying to trigger toast in non-HTMX request")
 	}
 }
 
@@ -57,15 +32,6 @@ func WaitMinimumTime[T interface{}](waitTime time.Duration, function func() (T,
 	return result, err
 }
 
-func GetSessionID(r *http.Request) string {
-	for _, c := range r.Cookies() {
-		if c.Name == "id" {
-			return c.Value
-		}
-	}
-	return ""
-}
-
 func isHtmx(r *http.Request) bool {
 	return r.Header.Get("HX-Request") == "true"
 }