feat(middleware): use slogger #19

···

       
7
       
 
       
	"github.com/go-chi/chi/v5"

     

       
8
       
 
       


     

       
9
       
 
       
	"yoten.app/internal/server"

     

       
0
       
 
       

     

       
10
       
 
       
	"yoten.app/internal/server/middleware"

     

       
11
       
 
       
	"yoten.app/internal/server/views"

     

       
12
       
 
       
)

     
···

       
25
       
 
       
		h.Oauth,

     

       
26
       
 
       
		h.Db,

     

       
27
       
 
       
		h.IdResolver,

     

       
0
       
 
       

     

       
28
       
 
       
	)

     

       
29
       
 
       


     

       
30
       
 
       
	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

···

       
7
       
 
       
	"github.com/go-chi/chi/v5"

     

       
8
       
 
       


     

       
9
       
 
       
	"yoten.app/internal/server"

     

       
10
       
+
       
	"yoten.app/internal/server/log"

     

       
11
       
 
       
	"yoten.app/internal/server/middleware"

     

       
12
       
 
       
	"yoten.app/internal/server/views"

     

       
13
       
 
       
)

     
···

       
26
       
 
       
		h.Oauth,

     

       
27
       
 
       
		h.Db,

     

       
28
       
 
       
		h.IdResolver,

     

       
29
       
+
       
		log.SubLogger(h.Logger, "middleware"),

     

       
30
       
 
       
	)

     

       
31
       
 
       


     

       
32
       
 
       
	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"context"

     

       
5
       
 
       
	"fmt"

     

       
6
       
-
       
	"log"

     

       
7
       
 
       
	"net/http"

     

       
8
       
 
       
	"net/url"

     

       
9
       
 
       
	"slices"

     
···

       
25
       
 
       
	oauth      *oauth.OAuth

     

       
26
       
 
       
	db         *db.DB

     

       
27
       
 
       
	idResolver *atproto.Resolver

     

       
0
       
 
       

     

       
28
       
 
       
}

     

       
29
       
 
       


     

       
30
       
-
       
func New(oauth *oauth.OAuth, db *db.DB, idResolver *atproto.Resolver) Middleware {

     

       
31
       
 
       
	return Middleware{

     

       
32
       
 
       
		oauth:      oauth,

     

       
33
       
 
       
		db:         db,

     

       
34
       
 
       
		idResolver: idResolver,

     

       
0
       
 
       

     

       
35
       
 
       
	}

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
 
       
type middlewareFunc func(http.Handler) http.Handler

     

       
39
       
 
       


     

       
40
       
 
       
func AuthMiddleware(o *oauth.OAuth) middlewareFunc {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
41
       
 
       
	return func(next http.Handler) http.Handler {

     

       
42
       
 
       
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       
43
       
 
       
			returnURL := "/"

     
···

       
59
       
 
       


     

       
60
       
 
       
			sess, err := o.ResumeSession(r)

     

       
61
       
 
       
			if err != nil {

     

       
62
       
-
       
				log.Println("failed to resume session, redirecting...", "err", err, "url", r.URL.String())

     

       
63
       
 
       
				redirectFunc(w, r)

     

       
64
       
 
       
				return

     

       
65
       
 
       
			}

     

       
66
       
 
       


     

       
67
       
 
       
			if sess == nil {

     

       
68
       
-
       
				log.Printf("session is nil, redirecting...")

     

       
69
       
 
       
				redirectFunc(w, r)

     

       
70
       
 
       
				return

     

       
71
       
 
       
			}

     
···

       
76
       
 
       
}

     

       
77
       
 
       


     

       
78
       
 
       
func (mw Middleware) ResolveIdent() middlewareFunc {

     

       
0
       
 
       

     

       
79
       
 
       
	excluded := []string{"favicon.ico"}

     

       
80
       
 
       


     

       
81
       
 
       
	return func(next http.Handler) http.Handler {

     
···

       
90
       
 
       


     

       
91
       
 
       
			id, err := mw.idResolver.ResolveIdent(r.Context(), didOrHandle)

     

       
92
       
 
       
			if err != nil {

     

       
93
       
-
       
				log.Println("failed to resolve did/handle:", err)

     

       
94
       
 
       
				w.WriteHeader(http.StatusNotFound)

     

       
95
       
 
       
				views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)

     

       
96
       
 
       
				return

     
···

       
104
       
 
       
}

     

       
105
       
 
       


     

       
106
       
 
       
func (mw Middleware) LoadUnreadNotificationCount() middlewareFunc {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
107
       
 
       
	return func(next http.Handler) http.Handler {

     

       
108
       
 
       
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       
109
       
 
       
			user := mw.oauth.GetUser(r)

     
···

       
114
       
 
       


     

       
115
       
 
       
			count, err := db.GetUnreadNotificationCount(mw.db, user.Did)

     

       
116
       
 
       
			if err != nil {

     

       
117
       
-
       
				log.Println("failed to get notification count:", err)

     

       
118
       
 
       
			}

     

       
119
       
 
       


     

       
120
       
 
       
			ctx := context.WithValue(r.Context(), UnreadNotificationCountCtxKey, count)

     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"context"

     

       
5
       
 
       
	"fmt"

     

       
6
       
+
       
	"log/slog"

     

       
7
       
 
       
	"net/http"

     

       
8
       
 
       
	"net/url"

     

       
9
       
 
       
	"slices"

     
···

       
25
       
 
       
	oauth      *oauth.OAuth

     

       
26
       
 
       
	db         *db.DB

     

       
27
       
 
       
	idResolver *atproto.Resolver

     

       
28
       
+
       
	logger     *slog.Logger

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
31
       
+
       
func New(oauth *oauth.OAuth, db *db.DB, idResolver *atproto.Resolver, logger *slog.Logger) Middleware {

     

       
32
       
 
       
	return Middleware{

     

       
33
       
 
       
		oauth:      oauth,

     

       
34
       
 
       
		db:         db,

     

       
35
       
 
       
		idResolver: idResolver,

     

       
36
       
+
       
		logger:     logger,

     

       
37
       
 
       
	}

     

       
38
       
 
       
}

     

       
39
       
 
       


     

       
40
       
 
       
type middlewareFunc func(http.Handler) http.Handler

     

       
41
       
 
       


     

       
42
       
 
       
func AuthMiddleware(o *oauth.OAuth) middlewareFunc {

     

       
43
       
+
       
	l := o.Logger.With("middleware", "AuthMiddleware")

     

       
44
       
+
       


     

       
45
       
 
       
	return func(next http.Handler) http.Handler {

     

       
46
       
 
       
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       
47
       
 
       
			returnURL := "/"

     
···

       
63
       
 
       


     

       
64
       
 
       
			sess, err := o.ResumeSession(r)

     

       
65
       
 
       
			if err != nil {

     

       
66
       
+
       
				l.Error("failed to resume session, redirecting...", "err", err, "url", r.URL.String())

     

       
67
       
 
       
				redirectFunc(w, r)

     

       
68
       
 
       
				return

     

       
69
       
 
       
			}

     

       
70
       
 
       


     

       
71
       
 
       
			if sess == nil {

     

       
72
       
+
       
				l.Warn("session is nil, redirecting...")

     

       
73
       
 
       
				redirectFunc(w, r)

     

       
74
       
 
       
				return

     

       
75
       
 
       
			}

     
···

       
80
       
 
       
}

     

       
81
       
 
       


     

       
82
       
 
       
func (mw Middleware) ResolveIdent() middlewareFunc {

     

       
83
       
+
       
	l := mw.logger.With("middleware", "ResolveIdent")

     

       
84
       
 
       
	excluded := []string{"favicon.ico"}

     

       
85
       
 
       


     

       
86
       
 
       
	return func(next http.Handler) http.Handler {

     
···

       
95
       
 
       


     

       
96
       
 
       
			id, err := mw.idResolver.ResolveIdent(r.Context(), didOrHandle)

     

       
97
       
 
       
			if err != nil {

     

       
98
       
+
       
				l.Error("failed to resolve did/handle", "err", err)

     

       
99
       
 
       
				w.WriteHeader(http.StatusNotFound)

     

       
100
       
 
       
				views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)

     

       
101
       
 
       
				return

     
···

       
109
       
 
       
}

     

       
110
       
 
       


     

       
111
       
 
       
func (mw Middleware) LoadUnreadNotificationCount() middlewareFunc {

     

       
112
       
+
       
	l := mw.logger.With("middleware", "LoadUnreadNotificationCount")

     

       
113
       
+
       


     

       
114
       
 
       
	return func(next http.Handler) http.Handler {

     

       
115
       
 
       
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       
116
       
 
       
			user := mw.oauth.GetUser(r)

     
···

       
121
       
 
       


     

       
122
       
 
       
			count, err := db.GetUnreadNotificationCount(mw.db, user.Did)

     

       
123
       
 
       
			if err != nil {

     

       
124
       
+
       
				l.Error("failed to get notification count", "err", err)

     

       
125
       
 
       
			}

     

       
126
       
 
       


     

       
127
       
 
       
			ctx := context.WithValue(r.Context(), UnreadNotificationCountCtxKey, count)