pico

refactor: remove unused db methods rss
created pr with 97.1 on 2025-12-18T04:19:09Z · by c8ef7d19
added 97.2 on 2025-12-18T04:36:52Z · by c8ef7d19
1: fdc255e = 1: fdc255e refactor: remove unused db methods
2: 3f855f6 = 2: 3f855f6 chore: add tests for postgres db impl
3: 7cd29a6 = 3: 7cd29a6 refactor: use sqlx interface
4: acd449e = 4: acd449e chore: add db tags
5: f6ed0d7 = 5: f6ed0d7 refactor: use sqlx
6: 29035c6 = 6: 29035c6 refactor: replace custom sql functions with sqlx
7: d4ea6d9 = 7: d4ea6d9 refactor: inline all sql queries
-: ------- > 8: 4bd37ed refactor: use `select * from` where possible
cmds
checkout latest patchset: 
ssh pr.pico.sh print 97 | git am -3
checkout any patchset in a patch request: 
ssh pr.pico.sh print 97.[rev] | git am -3
add changes to patch request: 
git format-patch main --stdout | ssh pr.pico.sh pr add 97

Patchset 97.2 on 2025-12-18T04:36:52Z · commit f6ed0d7

refactor: remove unused db methods
Eric Bower 2025-12-18T03:03:10Z
 chore: add tests for postgres db impl
Eric Bower 2025-12-18T03:17:57Z
 refactor: use sqlx interface
Eric Bower 2025-12-18T03:27:57Z
 chore: add db tags
Eric Bower 2025-12-18T03:31:25Z
 → refactor: use sqlx
Eric Bower 2025-12-18T03:43:01Z
 refactor: replace custom sql functions with sqlx
Eric Bower 2025-12-18T03:57:00Z
 refactor: inline all sql queries
Eric Bower 2025-12-18T04:02:50Z
 refactor: use `select * from` where possible
Eric Bower 2025-12-18T04:33:58Z
refactor: use sqlx
Eric Bower 2025-12-18T03:43:01Z
Semantic diff summary
1 added, 31 modified, 6 signature changed, 0 removed across 6 analyzed files
pkg/apps/pico/file_handler.go
pkg/db/db.go
pkg/db/postgres/storage.go
pkg/db/postgres/storage_test.go
pkg/db/stub/stub.go
pkg/tui/pubkeys.go
+1 -1 pkg/apps/pico/file_handler.go #
......@@ -247,7 +247,7 @@ func (h *UploadHandler) ProcessAuthorizedKeys(text []byte, logger *slog.Logger,
247247 _, _ = fmt.Fprintf(s.Stderr(), "adding pubkey (%s)\n", key)
248248 logger.Info("adding pubkey", "pubkey", key)
249249
250- err = dbpool.InsertPublicKey(user.ID, key, pk.Comment, nil)
250+ err = dbpool.InsertPublicKey(user.ID, key, pk.Comment)
251251 if err != nil {
252252 _, _ = fmt.Fprintf(s.Stderr(), "error: could not insert pubkey: %s (%s)\n", err.Error(), key)
253253 logger.Error("could not insert pubkey", "err", err.Error())
+1 -1 pkg/db/db.go #
......@@ -390,7 +390,7 @@ var DenyList = []string{
390390 type DB interface {
391391 RegisterUser(name, pubkey, comment string) (*User, error)
392392 UpdatePublicKey(pubkeyID, name string) (*PublicKey, error)
393- InsertPublicKey(userID, pubkey, name string, tx *sql.Tx) error
393+ InsertPublicKey(userID, pubkey, name string) error
394394 FindKeysForUser(user *User) ([]*PublicKey, error)
395395 RemoveKeys(pubkeyIDs []string) error
396396
+61 -299 pkg/db/postgres/storage.go #
......@@ -1,7 +1,6 @@
11 package postgres
22
33 import (
4- "context"
54 "database/sql"
65 "errors"
76 "fmt"
......@@ -125,10 +124,10 @@ var (
125124 const (
126125 sqlSelectPublicKey = `SELECT id, user_id, name, public_key, created_at FROM public_keys WHERE public_key = $1`
127126 sqlSelectPublicKeys = `SELECT id, user_id, name, public_key, created_at FROM public_keys WHERE user_id = $1 ORDER BY created_at ASC`
128- sqlSelectUser = `SELECT id, name, created_at FROM app_users WHERE id = $1`
127+ sqlSelectUser = `SELECT id, COALESCE(name, '') as name, created_at FROM app_users WHERE id = $1`
129128 sqlSelectUserForName = `SELECT id, name, created_at FROM app_users WHERE name = $1`
130129 sqlSelectUserForNameAndKey = `SELECT app_users.id, app_users.name, app_users.created_at, public_keys.id as pk_id, public_keys.public_key, public_keys.created_at as pk_created_at FROM app_users LEFT JOIN public_keys ON public_keys.user_id = app_users.id WHERE app_users.name = $1 AND public_keys.public_key = $2`
131- sqlSelectUsers = `SELECT id, name, created_at FROM app_users ORDER BY name ASC`
130+ sqlSelectUsers = `SELECT id, COALESCE(name, '') as name, created_at FROM app_users ORDER BY name ASC`
132131
133132 sqlSelectUserForToken = `
134133 SELECT app_users.id, app_users.name, app_users.created_at
......@@ -313,30 +312,21 @@ func (me *PsqlDB) RegisterUser(username, pubkey, comment string) (*db.User, erro
313312 return nil, err
314313 }
315314
316- ctx := context.Background()
317- tx, err := me.Db.BeginTx(ctx, nil)
315+ tx, err := me.Db.Beginx()
318316 if err != nil {
319317 return nil, err
320318 }
321319 defer func() {
322- err = tx.Rollback()
323- }()
324-
325- stmt, err := tx.Prepare(sqlInsertUser)
326- if err != nil {
327- return nil, err
328- }
329- defer func() {
330- _ = stmt.Close()
320+ _ = tx.Rollback()
331321 }()
332322
333323 var id string
334- err = stmt.QueryRow(lowerName).Scan(&id)
324+ err = tx.QueryRow(sqlInsertUser, lowerName).Scan(&id)
335325 if err != nil {
336326 return nil, err
337327 }
338328
339- err = me.InsertPublicKey(id, pubkey, comment, tx)
329+ err = me.insertPublicKeyWithTx(id, pubkey, comment, tx)
340330 if err != nil {
341331 return nil, err
342332 }
......@@ -349,23 +339,24 @@ func (me *PsqlDB) RegisterUser(username, pubkey, comment string) (*db.User, erro
349339 return me.FindUserForKey(username, pubkey)
350340 }
351341
352-func (me *PsqlDB) InsertPublicKey(userID, key, name string, tx *sql.Tx) error {
342+func (me *PsqlDB) insertPublicKeyWithTx(userID, key, name string, tx *sqlx.Tx) error {
353343 pk, _ := me.findPublicKeyForKey(key)
354344 if pk != nil {
355345 return db.ErrPublicKeyTaken
356346 }
357347 query := `INSERT INTO public_keys (user_id, public_key, name) VALUES ($1, $2, $3)`
358- var err error
359- if tx != nil {
360- _, err = tx.Exec(query, userID, key, name)
361- } else {
362- _, err = me.Db.Exec(query, userID, key, name)
363- }
364- if err != nil {
365- return err
366- }
348+ _, err := tx.Exec(query, userID, key, name)
349+ return err
350+}
367351
368- return nil
352+func (me *PsqlDB) InsertPublicKey(userID, key, name string) error {
353+ pk, _ := me.findPublicKeyForKey(key)
354+ if pk != nil {
355+ return db.ErrPublicKeyTaken
356+ }
357+ query := `INSERT INTO public_keys (user_id, public_key, name) VALUES ($1, $2, $3)`
358+ _, err := me.Db.Exec(query, userID, key, name)
359+ return err
369360 }
370361
371362 func (me *PsqlDB) UpdatePublicKey(pubkeyID, name string) (*db.PublicKey, error) {
......@@ -424,50 +415,19 @@ func (me *PsqlDB) findPublicKeyForKey(key string) (*db.PublicKey, error) {
424415 }
425416
426417 func (me *PsqlDB) findPublicKey(pubkeyID string) (*db.PublicKey, error) {
427- var keys []*db.PublicKey
428- rs, err := me.Db.Query(`SELECT id, user_id, name, public_key, created_at FROM public_keys WHERE id = $1`, pubkeyID)
418+ pk := &db.PublicKey{}
419+ err := me.Db.Get(pk, `SELECT id, user_id, name, public_key, created_at FROM public_keys WHERE id = $1`, pubkeyID)
429420 if err != nil {
430421 return nil, err
431422 }
432-
433- for rs.Next() {
434- pk := &db.PublicKey{}
435- err := rs.Scan(&pk.ID, &pk.UserID, &pk.Name, &pk.Key, &pk.CreatedAt)
436- if err != nil {
437- return nil, err
438- }
439-
440- keys = append(keys, pk)
441- }
442-
443- if rs.Err() != nil {
444- return nil, rs.Err()
445- }
446-
447- if len(keys) == 0 {
448- return nil, errors.New("no public keys found for key provided")
449- }
450-
451- return keys[0], nil
423+ return pk, nil
452424 }
453425
454426 func (me *PsqlDB) FindKeysForUser(user *db.User) ([]*db.PublicKey, error) {
455427 var keys []*db.PublicKey
456- rs, err := me.Db.Query(sqlSelectPublicKeys, user.ID)
428+ err := me.Db.Select(&keys, sqlSelectPublicKeys, user.ID)
457429 if err != nil {
458- return keys, err
459- }
460- for rs.Next() {
461- pk := &db.PublicKey{}
462- err := rs.Scan(&pk.ID, &pk.UserID, &pk.Name, &pk.Key, &pk.CreatedAt)
463- if err != nil {
464- return keys, err
465- }
466-
467- keys = append(keys, pk)
468- }
469- if rs.Err() != nil {
470- return keys, rs.Err()
430+ return nil, err
471431 }
472432 return keys, nil
473433 }
......@@ -559,15 +519,10 @@ func (me *PsqlDB) FindUserByPubkey(key string) (*db.User, error) {
559519
560520 func (me *PsqlDB) FindUser(userID string) (*db.User, error) {
561521 user := &db.User{}
562- var un sql.NullString
563- r := me.Db.QueryRow(sqlSelectUser, userID)
564- err := r.Scan(&user.ID, &un, &user.CreatedAt)
522+ err := me.Db.Get(user, sqlSelectUser, userID)
565523 if err != nil {
566524 return nil, err
567525 }
568- if un.Valid {
569- user.Name = un.String
570- }
571526 return user, nil
572527 }
573528
......@@ -589,8 +544,7 @@ func (me *PsqlDB) validateName(name string) (bool, error) {
589544
590545 func (me *PsqlDB) FindUserByName(name string) (*db.User, error) {
591546 user := &db.User{}
592- r := me.Db.QueryRow(sqlSelectUserForName, strings.ToLower(name))
593- err := r.Scan(&user.ID, &user.Name, &user.CreatedAt)
547+ err := me.Db.Get(user, sqlSelectUserForName, strings.ToLower(name))
594548 if err != nil {
595549 return nil, err
596550 }
......@@ -613,13 +567,10 @@ func (me *PsqlDB) findUserForNameAndKey(name string, key string) (*db.User, erro
613567
614568 func (me *PsqlDB) FindUserForToken(token string) (*db.User, error) {
615569 user := &db.User{}
616-
617- r := me.Db.QueryRow(sqlSelectUserForToken, token)
618- err := r.Scan(&user.ID, &user.Name, &user.CreatedAt)
570+ err := me.Db.Get(user, sqlSelectUserForToken, token)
619571 if err != nil {
620572 return nil, err
621573 }
622-
623574 return user, nil
624575 }
625576
......@@ -1126,37 +1077,19 @@ func (me *PsqlDB) FindVisitSiteList(opts *db.SummaryOpts) ([]*db.VisitUrl, error
11261077
11271078 func (me *PsqlDB) FindUsers() ([]*db.User, error) {
11281079 var users []*db.User
1129- rs, err := me.Db.Query(sqlSelectUsers)
1080+ err := me.Db.Select(&users, sqlSelectUsers)
11301081 if err != nil {
1131- return users, err
1132- }
1133- for rs.Next() {
1134- var name sql.NullString
1135- user := &db.User{}
1136- err := rs.Scan(
1137- &user.ID,
1138- &name,
1139- &user.CreatedAt,
1140- )
1141- if err != nil {
1142- return users, err
1143- }
1144- user.Name = name.String
1145-
1146- users = append(users, user)
1147- }
1148- if rs.Err() != nil {
1149- return users, rs.Err()
1082+ return nil, err
11501083 }
11511084 return users, nil
11521085 }
11531086
1154-func (me *PsqlDB) removeTagsForPost(tx *sql.Tx, postID string) error {
1087+func (me *PsqlDB) removeTagsForPost(tx *sqlx.Tx, postID string) error {
11551088 _, err := tx.Exec(sqlRemoveTagsByPost, postID)
11561089 return err
11571090 }
11581091
1159-func (me *PsqlDB) insertTagsForPost(tx *sql.Tx, tags []string, postID string) ([]string, error) {
1092+func (me *PsqlDB) insertTagsForPost(tx *sqlx.Tx, tags []string, postID string) ([]string, error) {
11601093 ids := make([]string, 0)
11611094 for _, tag := range tags {
11621095 id := ""
......@@ -1171,13 +1104,12 @@ func (me *PsqlDB) insertTagsForPost(tx *sql.Tx, tags []string, postID string) ([
11711104 }
11721105
11731106 func (me *PsqlDB) ReplaceTagsForPost(tags []string, postID string) error {
1174- ctx := context.Background()
1175- tx, err := me.Db.BeginTx(ctx, nil)
1107+ tx, err := me.Db.Beginx()
11761108 if err != nil {
11771109 return err
11781110 }
11791111 defer func() {
1180- err = tx.Rollback()
1112+ _ = tx.Rollback()
11811113 }()
11821114
11831115 err = me.removeTagsForPost(tx, postID)
......@@ -1194,12 +1126,12 @@ func (me *PsqlDB) ReplaceTagsForPost(tags []string, postID string) error {
11941126 return err
11951127 }
11961128
1197-func (me *PsqlDB) removeAliasesForPost(tx *sql.Tx, postID string) error {
1129+func (me *PsqlDB) removeAliasesForPost(tx *sqlx.Tx, postID string) error {
11981130 _, err := tx.Exec(sqlRemoveAliasesByPost, postID)
11991131 return err
12001132 }
12011133
1202-func (me *PsqlDB) insertAliasesForPost(tx *sql.Tx, aliases []string, postID string) ([]string, error) {
1134+func (me *PsqlDB) insertAliasesForPost(tx *sqlx.Tx, aliases []string, postID string) ([]string, error) {
12031135 // hardcoded
12041136 denyList := []string{
12051137 "rss",
......@@ -1241,13 +1173,12 @@ func (me *PsqlDB) insertAliasesForPost(tx *sql.Tx, aliases []string, postID stri
12411173 }
12421174
12431175 func (me *PsqlDB) ReplaceAliasesForPost(aliases []string, postID string) error {
1244- ctx := context.Background()
1245- tx, err := me.Db.BeginTx(ctx, nil)
1176+ tx, err := me.Db.Beginx()
12461177 if err != nil {
12471178 return err
12481179 }
12491180 defer func() {
1250- err = tx.Rollback()
1181+ _ = tx.Rollback()
12511182 }()
12521183
12531184 err = me.removeAliasesForPost(tx, postID)
......@@ -1342,24 +1273,10 @@ func (me *PsqlDB) FindPopularTags(space string) ([]string, error) {
13421273
13431274 func (me *PsqlDB) FindFeature(userID string, feature string) (*db.FeatureFlag, error) {
13441275 ff := &db.FeatureFlag{}
1345- // payment history is allowed to be null
1346- // https://devtidbits.com/2020/08/03/go-sql-error-converting-null-to-string-is-unsupported/
1347- var paymentHistoryID sql.NullString
1348- err := me.Db.QueryRow(sqlSelectFeatureForUser, userID, feature).Scan(
1349- &ff.ID,
1350- &ff.UserID,
1351- &paymentHistoryID,
1352- &ff.Name,
1353- &ff.Data,
1354- &ff.CreatedAt,
1355- &ff.ExpiresAt,
1356- )
1276+ err := me.Db.Get(ff, sqlSelectFeatureForUser, userID, feature)
13571277 if err != nil {
13581278 return nil, err
13591279 }
1360-
1361- ff.PaymentHistoryID = paymentHistoryID
1362-
13631280 return ff, nil
13641281 }
13651282
......@@ -1371,31 +1288,9 @@ func (me *PsqlDB) FindFeaturesForUser(userID string) ([]*db.FeatureFlag, error)
13711288 FROM feature_flags
13721289 WHERE user_id=$1
13731290 ORDER BY name, expires_at DESC;`
1374- rs, err := me.Db.Query(query, userID)
1291+ err := me.Db.Select(&features, query, userID)
13751292 if err != nil {
1376- return features, err
1377- }
1378- for rs.Next() {
1379- var paymentHistoryID sql.NullString
1380- ff := &db.FeatureFlag{}
1381- err := rs.Scan(
1382- &ff.ID,
1383- &ff.UserID,
1384- &paymentHistoryID,
1385- &ff.Name,
1386- &ff.Data,
1387- &ff.CreatedAt,
1388- &ff.ExpiresAt,
1389- )
1390- if err != nil {
1391- return features, err
1392- }
1393- ff.PaymentHistoryID = paymentHistoryID
1394-
1395- features = append(features, ff)
1396- }
1397- if rs.Err() != nil {
1398- return features, rs.Err()
1293+ return nil, err
13991294 }
14001295 return features, nil
14011296 }
......@@ -1409,13 +1304,12 @@ func (me *PsqlDB) HasFeatureForUser(userID string, feature string) bool {
14091304 }
14101305
14111306 func (me *PsqlDB) InsertFeedItems(postID string, items []*db.FeedItem) error {
1412- ctx := context.Background()
1413- tx, err := me.Db.BeginTx(ctx, nil)
1307+ tx, err := me.Db.Beginx()
14141308 if err != nil {
14151309 return err
14161310 }
14171311 defer func() {
1418- err = tx.Rollback()
1312+ _ = tx.Rollback()
14191313 }()
14201314
14211315 for _, item := range items {
......@@ -1438,33 +1332,11 @@ func (me *PsqlDB) InsertFeedItems(postID string, items []*db.FeedItem) error {
14381332 }
14391333
14401334 func (me *PsqlDB) FindFeedItemsByPostID(postID string) ([]*db.FeedItem, error) {
1441- // sqlSelectFeedItemsByPost
1442- items := make([]*db.FeedItem, 0)
1443- rs, err := me.Db.Query(sqlSelectFeedItemsByPost, postID)
1335+ var items []*db.FeedItem
1336+ err := me.Db.Select(&items, sqlSelectFeedItemsByPost, postID)
14441337 if err != nil {
1445- return items, err
1446- }
1447-
1448- for rs.Next() {
1449- item := &db.FeedItem{}
1450- err := rs.Scan(
1451- &item.ID,
1452- &item.PostID,
1453- &item.GUID,
1454- &item.Data,
1455- &item.CreatedAt,
1456- )
1457- if err != nil {
1458- return items, err
1459- }
1460-
1461- items = append(items, item)
1462- }
1463-
1464- if rs.Err() != nil {
1465- return items, rs.Err()
1338+ return nil, err
14661339 }
1467-
14681340 return items, nil
14691341 }
14701342
......@@ -1488,21 +1360,10 @@ func (me *PsqlDB) UpdateProject(userID, name string) error {
14881360
14891361 func (me *PsqlDB) FindProjectByName(userID, name string) (*db.Project, error) {
14901362 project := &db.Project{}
1491- r := me.Db.QueryRow(sqlFindProjectByName, userID, name)
1492- err := r.Scan(
1493- &project.ID,
1494- &project.UserID,
1495- &project.Name,
1496- &project.ProjectDir,
1497- &project.Acl,
1498- &project.Blocked,
1499- &project.CreatedAt,
1500- &project.UpdatedAt,
1501- )
1363+ err := me.Db.Get(project, sqlFindProjectByName, userID, name)
15021364 if err != nil {
15031365 return nil, err
15041366 }
1505-
15061367 return project, nil
15071368 }
15081369
......@@ -1540,24 +1401,12 @@ func (me *PsqlDB) RemoveToken(tokenID string) error {
15401401 }
15411402
15421403 func (me *PsqlDB) FindTokensForUser(userID string) ([]*db.Token, error) {
1543- var keys []*db.Token
1544- rs, err := me.Db.Query(sqlSelectTokensForUser, userID)
1404+ var tokens []*db.Token
1405+ err := me.Db.Select(&tokens, sqlSelectTokensForUser, userID)
15451406 if err != nil {
1546- return keys, err
1547- }
1548- for rs.Next() {
1549- pk := &db.Token{}
1550- err := rs.Scan(&pk.ID, &pk.UserID, &pk.Name, &pk.CreatedAt, &pk.ExpiresAt)
1551- if err != nil {
1552- return keys, err
1553- }
1554-
1555- keys = append(keys, pk)
1556- }
1557- if rs.Err() != nil {
1558- return keys, rs.Err()
1407+ return nil, err
15591408 }
1560- return keys, nil
1409+ return tokens, nil
15611410 }
15621411
15631412 func (me *PsqlDB) InsertFeature(userID, name string, expiresAt time.Time) (*db.FeatureFlag, error) {
......@@ -1602,13 +1451,12 @@ func (me *PsqlDB) AddPicoPlusUser(username, email, paymentType, txId string) err
16021451 return err
16031452 }
16041453
1605- ctx := context.Background()
1606- tx, err := me.Db.BeginTx(ctx, nil)
1454+ tx, err := me.Db.Beginx()
16071455 if err != nil {
16081456 return err
16091457 }
16101458 defer func() {
1611- err = tx.Rollback()
1459+ _ = tx.Rollback()
16121460 }()
16131461
16141462 var paymentHistoryId sql.NullString
......@@ -1688,60 +1536,24 @@ func (me *PsqlDB) InsertTunsEventLog(log *db.TunsEventLog) error {
16881536 }
16891537
16901538 func (me *PsqlDB) FindTunsEventLogsByAddr(userID, addr string) ([]*db.TunsEventLog, error) {
1691- logs := []*db.TunsEventLog{}
1692- rs, err := me.Db.Query(
1539+ var logs []*db.TunsEventLog
1540+ err := me.Db.Select(&logs,
16931541 `SELECT id, user_id, server_id, remote_addr, event_type, tunnel_type, connection_type, tunnel_id, created_at
16941542 FROM tuns_event_logs WHERE user_id=$1 AND tunnel_id=$2 ORDER BY created_at DESC`, userID, addr)
16951543 if err != nil {
16961544 return nil, err
16971545 }
1698-
1699- for rs.Next() {
1700- log := db.TunsEventLog{}
1701- err := rs.Scan(
1702- &log.ID, &log.UserId, &log.ServerID, &log.RemoteAddr,
1703- &log.EventType, &log.TunnelType, &log.ConnectionType,
1704- &log.TunnelID, &log.CreatedAt,
1705- )
1706- if err != nil {
1707- return nil, err
1708- }
1709- logs = append(logs, &log)
1710- }
1711-
1712- if rs.Err() != nil {
1713- return nil, rs.Err()
1714- }
1715-
17161546 return logs, nil
17171547 }
17181548
17191549 func (me *PsqlDB) FindTunsEventLogs(userID string) ([]*db.TunsEventLog, error) {
1720- logs := []*db.TunsEventLog{}
1721- rs, err := me.Db.Query(
1550+ var logs []*db.TunsEventLog
1551+ err := me.Db.Select(&logs,
17221552 `SELECT id, user_id, server_id, remote_addr, event_type, tunnel_type, connection_type, tunnel_id, created_at
17231553 FROM tuns_event_logs WHERE user_id=$1 ORDER BY created_at DESC`, userID)
17241554 if err != nil {
17251555 return nil, err
17261556 }
1727-
1728- for rs.Next() {
1729- log := db.TunsEventLog{}
1730- err := rs.Scan(
1731- &log.ID, &log.UserId, &log.ServerID, &log.RemoteAddr,
1732- &log.EventType, &log.TunnelType, &log.ConnectionType,
1733- &log.TunnelID, &log.CreatedAt,
1734- )
1735- if err != nil {
1736- return nil, err
1737- }
1738- logs = append(logs, &log)
1739- }
1740-
1741- if rs.Err() != nil {
1742- return nil, rs.Err()
1743- }
1744-
17451557 return logs, nil
17461558 }
17471559
......@@ -1781,79 +1593,29 @@ func (me *PsqlDB) FindUserStats(userID string) (*db.UserStats, error) {
17811593 }
17821594
17831595 func (me *PsqlDB) FindAccessLogs(userID string, fromDate *time.Time) ([]*db.AccessLog, error) {
1784- logs := []*db.AccessLog{}
1785- rs, err := me.Db.Query(
1786- `SELECT id, user_id, service, pubkey, identity, created_at FROM access_logs WHERE user_id=$1 AND created_at >= $2 ORDER BY created_at DESC`, userID, fromDate)
1596+ var logs []*db.AccessLog
1597+ err := me.Db.Select(&logs, `SELECT id, user_id, service, pubkey, identity, created_at FROM access_logs WHERE user_id=$1 AND created_at >= $2 ORDER BY created_at DESC`, userID, fromDate)
17871598 if err != nil {
17881599 return nil, err
17891600 }
1790-
1791- for rs.Next() {
1792- log := db.AccessLog{}
1793- err := rs.Scan(
1794- &log.ID, &log.UserID, &log.Service, &log.Pubkey, &log.Identity, &log.CreatedAt,
1795- )
1796- if err != nil {
1797- return nil, err
1798- }
1799- logs = append(logs, &log)
1800- }
1801-
1802- if rs.Err() != nil {
1803- return nil, rs.Err()
1804- }
1805-
18061601 return logs, nil
18071602 }
18081603
18091604 func (me *PsqlDB) FindAccessLogsByPubkey(pubkey string, fromDate *time.Time) ([]*db.AccessLog, error) {
1810- logs := []*db.AccessLog{}
1811- rs, err := me.Db.Query(
1812- `SELECT id, user_id, service, pubkey, identity, created_at FROM access_logs WHERE pubkey=$1 AND created_at >= $2 ORDER BY created_at DESC`, pubkey, fromDate)
1605+ var logs []*db.AccessLog
1606+ err := me.Db.Select(&logs, `SELECT id, user_id, service, pubkey, identity, created_at FROM access_logs WHERE pubkey=$1 AND created_at >= $2 ORDER BY created_at DESC`, pubkey, fromDate)
18131607 if err != nil {
18141608 return nil, err
18151609 }
1816-
1817- for rs.Next() {
1818- log := db.AccessLog{}
1819- err := rs.Scan(
1820- &log.ID, &log.UserID, &log.Service, &log.Pubkey, &log.Identity, &log.CreatedAt,
1821- )
1822- if err != nil {
1823- return nil, err
1824- }
1825- logs = append(logs, &log)
1826- }
1827-
1828- if rs.Err() != nil {
1829- return nil, rs.Err()
1830- }
1831-
18321610 return logs, nil
18331611 }
18341612
18351613 func (me *PsqlDB) FindPubkeysInAccessLogs(userID string) ([]string, error) {
1836- pubkeys := []string{}
1837- rs, err := me.Db.Query(
1838- `SELECT DISTINCT(pubkey) FROM access_logs WHERE user_id=$1`, userID,
1839- )
1614+ var pubkeys []string
1615+ err := me.Db.Select(&pubkeys, `SELECT DISTINCT(pubkey) FROM access_logs WHERE user_id=$1`, userID)
18401616 if err != nil {
18411617 return nil, err
18421618 }
1843-
1844- for rs.Next() {
1845- pubkey := ""
1846- err := rs.Scan(&pubkey)
1847- if err != nil {
1848- return nil, err
1849- }
1850- pubkeys = append(pubkeys, pubkey)
1851- }
1852-
1853- if rs.Err() != nil {
1854- return nil, rs.Err()
1855- }
1856-
18571619 return pubkeys, nil
18581620 }
18591621
+4 -4 pkg/db/postgres/storage_test.go #
......@@ -342,7 +342,7 @@ func TestInsertPublicKey_Success(t *testing.T) {
342342 t.Fatalf("RegisterUser failed: %v", err)
343343 }
344344
345- err = testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI secondkey", "second key", nil)
345+ err = testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI secondkey", "second key")
346346 if err != nil {
347347 t.Fatalf("InsertPublicKey failed: %v", err)
348348 }
......@@ -361,7 +361,7 @@ func TestInsertPublicKey_Duplicate(t *testing.T) {
361361
362362 user, _ := testDB.RegisterUser("dupkeyowner", "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI dupkey", "comment")
363363
364- err := testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI dupkey", "same key", nil)
364+ err := testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI dupkey", "same key")
365365 if err == nil {
366366 t.Error("expected error for duplicate key, got nil")
367367 }
......@@ -385,7 +385,7 @@ func TestFindKeysForUser(t *testing.T) {
385385 cleanupTestData(t)
386386
387387 user, _ := testDB.RegisterUser("multikeyowner", "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI multikeyowner1", "key1")
388- _ = testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI multikeyowner2", "key2", nil)
388+ _ = testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI multikeyowner2", "key2")
389389
390390 keys, err := testDB.FindKeysForUser(user)
391391 if err != nil {
......@@ -400,7 +400,7 @@ func TestRemoveKeys(t *testing.T) {
400400 cleanupTestData(t)
401401
402402 user, _ := testDB.RegisterUser("removekeyowner", "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI removekeyowner", "key1")
403- _ = testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI removekeyowner2", "key2", nil)
403+ _ = testDB.InsertPublicKey(user.ID, "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI removekeyowner2", "key2")
404404
405405 keys, _ := testDB.FindKeysForUser(user)
406406 if len(keys) != 2 {
+1 -2 pkg/db/stub/stub.go #
......@@ -1,7 +1,6 @@
11 package stub
22
33 import (
4- "database/sql"
54 "fmt"
65 "log/slog"
76 "time"
......@@ -33,7 +32,7 @@ func (me *StubDB) UpdatePublicKey(pubkeyID, name string) (*db.PublicKey, error)
3332 return nil, errNotImpl
3433 }
3534
36-func (me *StubDB) InsertPublicKey(userID, key, name string, tx *sql.Tx) error {
35+func (me *StubDB) InsertPublicKey(userID, key, name string) error {
3736 return errNotImpl
3837 }
3938
+1 -1 pkg/tui/pubkeys.go #
......@@ -256,7 +256,7 @@ func (m *AddKeyPage) addPubkey(pubkey string) error {
256256 key := utils.KeyForKeyText(pk)
257257
258258 return m.shared.Dbpool.InsertPublicKey(
259- m.shared.User.ID, key, comment, nil,
259+ m.shared.User.ID, key, comment,
260260 )
261261 }
262262
Back to top