this repo has no description
lint stuff (#6)
* lint stuff
* oh fix this
authored by
Will Andrews
and committed by
GitHub
be674d20
31cb6877
+34
-76
+16
-52
auth_handlers.go
+16
-52
auth_handlers.go
···
8
8
"log/slog"
9
9
"net/http"
10
10
"strconv"
11
-
"strings"
12
11
"time"
13
12
14
13
"github.com/golang-jwt/jwt/v5"
···
35
34
b, err := io.ReadAll(r.Body)
36
35
if err != nil {
37
36
slog.Error("failed to read body", "error", err)
38
-
frontend.LoginForm("", "bad request").Render(r.Context(), w)
37
+
_ = frontend.LoginForm("", "bad request").Render(r.Context(), w)
39
38
return
40
39
}
41
40
···
43
42
err = json.Unmarshal(b, &loginReq)
44
43
if err != nil {
45
44
slog.Error("failed to unmarshal body", "error", err)
46
-
frontend.LoginForm("", "bad request").Render(r.Context(), w)
45
+
_ = frontend.LoginForm("", "bad request").Render(r.Context(), w)
47
46
return
48
47
}
49
48
url := fmt.Sprintf("%s/com.atproto.server.createsession", bskyBaseURL)
···
56
55
data, err := json.Marshal(requestData)
57
56
if err != nil {
58
57
slog.Error("failed marshal POST request to sign into Bsky", "error", err)
59
-
frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
58
+
_ = frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
60
59
return
61
60
}
62
61
···
65
64
req, err := http.NewRequest("POST", url, reader)
66
65
if err != nil {
67
66
slog.Error("failed to create POST request to sign into Bsky", "error", err)
68
-
frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
67
+
_ = frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
69
68
return
70
69
}
71
70
···
75
74
res, err := http.DefaultClient.Do(req)
76
75
if err != nil {
77
76
slog.Error("failed to make POST request to sign into Bsky", "error", err)
78
-
frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
77
+
_ = frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
79
78
return
80
79
}
81
80
···
85
84
86
85
if res.StatusCode != 200 {
87
86
slog.Error("failed to log into bluesky", "status code", res.StatusCode)
88
-
frontend.LoginForm(loginReq.Handle, "not authorized").Render(r.Context(), w)
87
+
_ = frontend.LoginForm(loginReq.Handle, "not authorized").Render(r.Context(), w)
89
88
return
90
89
}
91
90
92
91
resBody, err := io.ReadAll(res.Body)
93
92
if err != nil {
94
93
slog.Error("failed read response from Bsky login", "error", err)
95
-
frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
94
+
_ = frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
96
95
return
97
96
}
98
97
···
100
99
err = json.Unmarshal(resBody, &loginResp)
101
100
if err != nil {
102
101
slog.Error("failed unmarshal response from Bsky login", "error", err)
103
-
frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
102
+
_ = frontend.LoginForm(loginReq.Handle, "internal error").Render(r.Context(), w)
104
103
return
105
104
}
106
105
···
128
127
Value: "",
129
128
})
130
129
131
-
frontend.Login("", "").Render(r.Context(), w)
130
+
_ = frontend.Login("", "").Render(r.Context(), w)
132
131
}
133
132
134
133
func (s *Server) authMiddleware(next func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
···
136
135
jwtCookie, err := r.Cookie(jwtCookieName)
137
136
if err != nil {
138
137
slog.Error("read JWT cookie", "error", err)
139
-
frontend.Login("", "").Render(r.Context(), w)
138
+
_ = frontend.Login("", "").Render(r.Context(), w)
140
139
return
141
140
}
142
141
if jwtCookie == nil {
143
142
slog.Error("missing JWT cookie")
144
-
frontend.Login("", "").Render(r.Context(), w)
143
+
_ = frontend.Login("", "").Render(r.Context(), w)
145
144
return
146
145
}
147
146
148
147
didCookie, err := r.Cookie(didCookieName)
149
148
if err != nil {
150
149
slog.Error("read DID cookie", "error", err)
151
-
frontend.Login("", "").Render(r.Context(), w)
150
+
_ = frontend.Login("", "").Render(r.Context(), w)
152
151
return
153
152
}
154
153
if didCookie == nil {
155
154
slog.Error("missing DID cookie")
156
-
frontend.Login("", "").Render(r.Context(), w)
155
+
_ = frontend.Login("", "").Render(r.Context(), w)
157
156
return
158
157
}
159
158
···
161
160
_, _, err = jwt.NewParser().ParseUnverified(jwtCookie.Value, &claims)
162
161
if err != nil {
163
162
slog.Error("parsing JWT", "error", err)
164
-
frontend.Login("", "").Render(r.Context(), w)
163
+
_ = frontend.Login("", "").Render(r.Context(), w)
165
164
return
166
165
}
167
166
···
169
168
expiryInt, err := strconv.Atoi(expiry)
170
169
if err != nil {
171
170
slog.Error("invalid claims from token", "error", err)
172
-
frontend.Login("", "").Render(r.Context(), w)
171
+
_ = frontend.Login("", "").Render(r.Context(), w)
173
172
return
174
173
}
175
174
176
175
if time.Now().Unix() > int64(expiryInt) {
177
-
frontend.Login("", "").Render(r.Context(), w)
176
+
_ = frontend.Login("", "").Render(r.Context(), w)
178
177
return
179
178
}
180
179
}
181
180
next(w, r)
182
181
}
183
182
}
184
-
185
-
func resolveDid(did string) (string, error) {
186
-
resp, err := http.DefaultClient.Get(fmt.Sprintf("https://plc.directory/%s", did))
187
-
if err != nil {
188
-
return "", fmt.Errorf("error making request to resolve did: %w", err)
189
-
}
190
-
defer resp.Body.Close()
191
-
192
-
if resp.StatusCode != http.StatusOK {
193
-
return "", fmt.Errorf("got response %d", resp.StatusCode)
194
-
}
195
-
196
-
type resolvedDid struct {
197
-
Aka []string `json:"alsoKnownAs"`
198
-
}
199
-
200
-
b, err := io.ReadAll(resp.Body)
201
-
if err != nil {
202
-
return "", fmt.Errorf("reading response body: %w", err)
203
-
}
204
-
205
-
var resolved resolvedDid
206
-
err = json.Unmarshal(b, &resolved)
207
-
if err != nil {
208
-
return "", fmt.Errorf("decode response body: %w", err)
209
-
}
210
-
211
-
if len(resolved.Aka) == 0 {
212
-
return "", nil
213
-
}
214
-
215
-
res := strings.ReplaceAll(resolved.Aka[0], "at://", "")
216
-
217
-
return res, nil
218
-
}
+8
-10
bookmark_handler.go
+8
-10
bookmark_handler.go
···
20
20
usersDid, err := getUsersDidFromRequestCookie(r)
21
21
if err != nil {
22
22
slog.Error("getting users did from request", "error", err)
23
-
frontend.Login("", "").Render(r.Context(), w)
23
+
_ = frontend.Login("", "").Render(r.Context(), w)
24
24
return
25
25
}
26
26
···
93
93
Content: content,
94
94
}
95
95
96
-
frontend.NewBookmarkRow(bookmark).Render(r.Context(), w)
96
+
_ = frontend.NewBookmarkRow(bookmark).Render(r.Context(), w)
97
97
}
98
98
99
99
func convertPostURIToAtValidURI(input string) (string, error) {
···
118
118
usersDid, err := getUsersDidFromRequestCookie(r)
119
119
if err != nil {
120
120
slog.Error("getting users did from request", "error", err)
121
-
frontend.Login("", "").Render(r.Context(), w)
121
+
_ = frontend.Login("", "").Render(r.Context(), w)
122
122
return
123
123
}
124
124
···
145
145
}
146
146
147
147
w.WriteHeader(http.StatusAccepted)
148
-
w.Write([]byte("{}"))
148
+
_, _ = w.Write([]byte("{}"))
149
149
}
150
150
151
151
func (s *Server) HandleGetBookmarks(w http.ResponseWriter, r *http.Request) {
152
152
usersDid, err := getUsersDidFromRequestCookie(r)
153
153
if err != nil {
154
154
slog.Error("getting users did from request", "error", err)
155
-
frontend.Login("", "").Render(r.Context(), w)
155
+
_ = frontend.Login("", "").Render(r.Context(), w)
156
156
return
157
157
}
158
158
159
159
bookmarks, err := s.bookmarkStore.GetBookmarksForUser(usersDid)
160
160
if err != nil {
161
161
slog.Error("error getting bookmarks for user", "error", err)
162
-
frontend.Bookmarks(nil).Render(r.Context(), w)
162
+
_ = frontend.Bookmarks(nil).Render(r.Context(), w)
163
163
return
164
164
}
165
165
166
166
resp := make([]store.Bookmark, 0, len(bookmarks))
167
-
for _, bookmark := range bookmarks {
168
-
resp = append(resp, bookmark)
169
-
}
167
+
resp = append(resp, bookmarks...)
170
168
171
-
frontend.Bookmarks(resp).Render(r.Context(), w)
169
+
_ = frontend.Bookmarks(resp).Render(r.Context(), w)
172
170
}
173
171
174
172
func resolveHandle(handle string) (string, error) {
+3
-3
feed_handlers.go
+3
-3
feed_handlers.go
···
86
86
87
87
w.Header().Set("Content-Type", "application/json")
88
88
89
-
w.Write(b)
89
+
_, _ = w.Write(b)
90
90
}
91
91
92
92
type DescribeFeedResponse struct {
···
115
115
return
116
116
}
117
117
118
-
w.Write(b)
118
+
_, _ = w.Write(b)
119
119
}
120
120
121
121
func (s *Server) HandleWellKnown(w http.ResponseWriter, r *http.Request) {
···
138
138
return
139
139
}
140
140
141
-
w.Write(b)
141
+
_, _ = w.Write(b)
142
142
}
+1
-1
feedgenerator.go
+1
-1
feedgenerator.go
+2
-6
firehose_handler.go
+2
-6
firehose_handler.go
···
13
13
"github.com/willdot/bskyfeedgen/store"
14
14
)
15
15
16
-
const (
17
-
myDid = "did:plc:dadhhalkfcq3gucaq25hjqon"
18
-
)
19
-
20
16
type HandlerStore interface {
21
17
AddFeedPost(feedItem store.FeedPost) error
22
18
GetBookmarksForPost(postURI string) ([]string, error)
···
81
77
dids, err := h.store.GetBookmarksForPost(postURI)
82
78
if err != nil {
83
79
slog.Error("getting bookmarks for post", "error", err)
84
-
bugsnag.Notify(err)
80
+
_ = bugsnag.Notify(err)
85
81
}
86
82
87
83
return dids
···
98
94
err := h.store.AddFeedPost(feedItem)
99
95
if err != nil {
100
96
slog.Error("add users feed item", "error", err, "did", did, "reply post URI", replyPostURI)
101
-
bugsnag.Notify(err)
97
+
_ = bugsnag.Notify(err)
102
98
continue
103
99
}
104
100
}
+2
-2
main.go
+2
-2
main.go
···
68
68
store, err := store.New(dbFilename)
69
69
if err != nil {
70
70
slog.Error("create new store", "error", err)
71
-
bugsnag.Notify(err)
71
+
_ = bugsnag.Notify(err)
72
72
return
73
73
}
74
74
defer store.Close()
···
108
108
109
109
consumer := NewConsumer(jsServerAddr, slog.Default(), &handler)
110
110
111
-
retry.Do(func() error {
111
+
_ = retry.Do(func() error {
112
112
err := consumer.Consume(ctx)
113
113
if err != nil {
114
114
if errors.Is(err, context.Canceled) {
+1
-1
server.go
+1
-1
server.go
+1
-1
store/bookmark.go
+1
-1
store/bookmark.go
···
117
117
}
118
118
defer rows.Close()
119
119
120
-
for rows.Next() {
120
+
if rows.Next() {
121
121
var bookmark Bookmark
122
122
if err := rows.Scan(&bookmark.ID, &bookmark.PostRKey, &bookmark.PostURI, &bookmark.PostATURI, &bookmark.AuthorDID, &bookmark.AuthorHandle, &bookmark.UserDID, &bookmark.Content); err != nil {
123
123
return nil, fmt.Errorf("scan row: %w", err)