trev/trevstack
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Releases 9 Activity

feat: bob

Browse Source
This commit is contained in:
trev
2025-04-10 00:59:28 -04:00
parent dfd6789aa9
commit e9c44cbc94
58 changed files with 1649 additions and 3104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
server/internal/handlers/file.go → server/internal/handlers/file/file.go
View File

@ -1,18 +1,21 @@
package handlers
package file
import (
"context"
"database/sql"
"errors"
"log"
"net/http"
"strconv"
"strings"
"github.com/spotdemo4/trevstack/server/internal/interceptors"
"github.com/spotdemo4/trevstack/server/internal/models"
"gorm.io/gorm"
"github.com/stephenafamo/bob"
"github.com/stephenafamo/bob/dialect/sqlite"
)
type FileHandler struct {
db *gorm.DB
db *bob.DB
key []byte
}
@ -23,37 +26,45 @@ func (h *FileHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
return
}
// Make sure this is a GET request
if r.Method != http.MethodGet {
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
return
}
// Get the file id from the path
pathItems := strings.Split(r.URL.Path, "/")
if len(pathItems) < 3 {
http.Redirect(w, r, "/auth", http.StatusFound)
return
}
id := pathItems[2]
// Get the file from the database
file := models.File{}
if err := h.db.First(&file, "id = ? AND user_id = ?", id, userid).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
http.Error(w, "File not found", http.StatusNotFound)
return
}
log.Println(err)
id, err := strconv.Atoi(pathItems[2])
if err != nil {
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
return
}
// Serve the file
if r.Method == http.MethodGet {
w.Header().Set("Content-Type", http.DetectContentType(file.Data))
w.Write(file.Data)
} else {
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
// Get the file from the database
file, err := models.Files.Query(
sqlite.WhereAnd(
models.SelectWhere.Files.ID.EQ(int64(id)),
models.SelectWhere.Files.UserID.EQ(userid),
),
).One(context.Background(), h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
http.Error(w, "Not Found", http.StatusNotFound)
}
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", http.DetectContentType(file.Data))
w.Write(file.Data)
}
func NewFileHandler(db *gorm.DB, key string) http.Handler {
func NewFileHandler(db *bob.DB, key string) http.Handler {
return interceptors.WithAuthRedirect(
&FileHandler{
db: db,

139
server/internal/handlers/item/v1/item.go
View File

@ -2,21 +2,39 @@ package item
import (
"context"
"database/sql"
"errors"
"fmt"
"net/http"
"time"
"connectrpc.com/connect"
"github.com/aarondl/opt/omit"
"github.com/aarondl/opt/omitnull"
"github.com/spotdemo4/trevstack/server/internal/interceptors"
"github.com/spotdemo4/trevstack/server/internal/models"
itemv1 "github.com/spotdemo4/trevstack/server/internal/services/item/v1"
"github.com/spotdemo4/trevstack/server/internal/services/item/v1/itemv1connect"
"gorm.io/gorm"
"github.com/stephenafamo/bob"
"github.com/stephenafamo/bob/dialect/sqlite"
"github.com/stephenafamo/bob/dialect/sqlite/sm"
"google.golang.org/protobuf/types/known/timestamppb"
)
func itemToConnect(item *models.Item) *itemv1.Item {
timestamp := timestamppb.New(item.Added)
return &itemv1.Item{
Id: &item.ID,
Name: item.Name,
Description: item.Description.GetOrZero(),
Price: item.Price.GetOrZero(),
Quantity: int32(item.Quantity.GetOrZero()),
Added: timestamp,
}
}
type Handler struct {
db *gorm.DB
db *bob.DB
key []byte
}
@ -27,13 +45,22 @@ func (h *Handler) GetItem(ctx context.Context, req *connect.Request[itemv1.GetIt
}
// Get item
item := models.Item{}
if err := h.db.First(&item, "id = ? AND user_id = ?", req.Msg.Id, userid).Error; err != nil {
return nil, connect.NewError(connect.CodeNotFound, err)
item, err := models.Items.Query(
sqlite.WhereAnd(
models.SelectWhere.Items.ID.EQ(req.Msg.Id),
models.SelectWhere.Items.UserID.EQ(userid),
),
).One(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
res := connect.NewResponse(&itemv1.GetItemResponse{
Item: item.ToConnectV1(),
Item: itemToConnect(item),
})
return res, nil
}
@ -45,45 +72,55 @@ func (h *Handler) GetItems(ctx context.Context, req *connect.Request[itemv1.GetI
}
// Filters
sql := h.db.Where("user_id = ?", userid)
query := models.Items.Query(models.SelectWhere.Items.UserID.EQ(userid))
countQuery := models.Items.Query(models.SelectWhere.Items.UserID.EQ(userid))
// Counted filters
if req.Msg.Start != nil {
sql = sql.Where("added >= ?", req.Msg.Start.AsTime())
query.Apply(models.SelectWhere.Items.Added.GTE(req.Msg.Start.AsTime()))
countQuery.Apply(models.SelectWhere.Items.Added.GTE(req.Msg.Start.AsTime()))
}
if req.Msg.End != nil {
sql = sql.Where("added <= ?", req.Msg.End.AsTime())
query.Apply(models.SelectWhere.Items.Added.LTE(req.Msg.End.AsTime()))
countQuery.Apply(models.SelectWhere.Items.Added.LTE(req.Msg.End.AsTime()))
}
if req.Msg.Filter != nil {
sql = sql.Where("name LIKE ?", fmt.Sprintf("%%%s%%", *req.Msg.Filter))
if req.Msg.Filter != nil && *req.Msg.Filter != "" {
query.Apply(models.SelectWhere.Items.Name.Like("%" + *req.Msg.Filter + "%"))
countQuery.Apply(models.SelectWhere.Items.Name.Like(*req.Msg.Filter))
}
// Uncounted filters
sqlu := sql.Session(&gorm.Session{})
if req.Msg.Limit != nil {
sqlu = sqlu.Limit(int(*req.Msg.Limit))
query.Apply(sm.Limit(*req.Msg.Limit))
}
if req.Msg.Offset != nil {
sqlu = sqlu.Offset(int(*req.Msg.Offset))
query.Apply(sm.Offset(*req.Msg.Offset))
}
// Get items & count
items := []models.Item{}
var count int64
if err := sqlu.Order("added desc").Find(&items).Error; err != nil {
return nil, connect.NewError(connect.CodeNotFound, err)
items, err := query.All(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
if err := sql.Model(&items).Count(&count).Error; err != nil {
count, err := query.Count(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// Convert to connect v1 items
resItems := []*itemv1.Item{}
for _, item := range items {
resItems = append(resItems, item.ToConnectV1())
resItems = append(resItems, itemToConnect(item))
}
res := connect.NewResponse(&itemv1.GetItemsResponse{
Items: resItems,
Count: uint64(count),
Count: count,
})
return res, nil
}
@ -94,21 +131,20 @@ func (h *Handler) CreateItem(ctx context.Context, req *connect.Request[itemv1.Cr
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("unauthenticated"))
}
// Create item
item := models.Item{
Name: req.Msg.Item.Name,
Description: req.Msg.Item.Description,
Price: req.Msg.Item.Price,
Quantity: int(req.Msg.Item.Quantity),
Added: time.Now(),
UserID: uint(userid),
}
if err := h.db.Create(&item).Error; err != nil {
item, err := models.Items.Insert(&models.ItemSetter{
Name: omit.From(req.Msg.Item.Name),
Description: omitnull.From(req.Msg.Item.Description),
Price: omitnull.From(req.Msg.Item.Price),
Quantity: omitnull.From(int64(req.Msg.Item.Quantity)),
Added: omit.From(time.Now()),
UserID: omit.From(userid),
}).One(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
res := connect.NewResponse(&itemv1.CreateItemResponse{
Item: item.ToConnectV1(),
Item: itemToConnect(item),
})
return res, nil
}
@ -125,20 +161,27 @@ func (h *Handler) UpdateItem(ctx context.Context, req *connect.Request[itemv1.Up
}
// Update item
item := models.Item{
ID: *req.Msg.Item.Id,
Name: req.Msg.Item.Name,
Description: req.Msg.Item.Description,
Price: req.Msg.Item.Price,
Quantity: int(req.Msg.Item.Quantity),
UserID: uint(userid),
}
if err := h.db.Where("id = ? AND user_id = ?", req.Msg.Item.Id, userid).Updates(&item).Error; err != nil {
item, err := models.Items.Update(
// Set col
models.ItemSetter{
Name: omit.From(req.Msg.Item.Name),
Description: omitnull.From(req.Msg.Item.Description),
Price: omitnull.From(req.Msg.Item.Price),
Quantity: omitnull.From(int64(req.Msg.Item.Quantity)),
}.UpdateMod(),
// Where
sqlite.WhereAnd(
models.UpdateWhere.Items.ID.EQ(*req.Msg.Item.Id),
models.UpdateWhere.Items.UserID.EQ(userid),
),
).One(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
res := connect.NewResponse(&itemv1.UpdateItemResponse{
Item: item.ToConnectV1(),
Item: itemToConnect(item),
})
return res, nil
}
@ -150,7 +193,13 @@ func (h *Handler) DeleteItem(ctx context.Context, req *connect.Request[itemv1.De
}
// Delete item
if err := h.db.Delete(&models.Item{}, "id = ? AND user_id = ?", req.Msg.Id, userid).Error; err != nil {
_, err := models.Items.Delete(
sqlite.WhereAnd(
models.DeleteWhere.Items.ID.EQ(req.Msg.Id),
models.DeleteWhere.Items.UserID.EQ(userid),
),
).Exec(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -158,7 +207,7 @@ func (h *Handler) DeleteItem(ctx context.Context, req *connect.Request[itemv1.De
return res, nil
}
func NewHandler(db *gorm.DB, key string) (string, http.Handler) {
func NewHandler(db *bob.DB, key string) (string, http.Handler) {
interceptors := connect.WithInterceptors(interceptors.NewAuthInterceptor(key))
return itemv1connect.NewItemServiceHandler(

206
server/internal/handlers/user/v1/auth.go
View File

@ -2,38 +2,44 @@ package user
import (
"context"
"database/sql"
"errors"
"net/http"
"strconv"
"time"
_ "crypto/sha256"
_ "crypto/sha256" // Crypto
"connectrpc.com/connect"
"github.com/aarondl/opt/omit"
"github.com/golang-jwt/jwt/v5"
"github.com/spotdemo4/trevstack/server/internal/interceptors"
"github.com/spotdemo4/trevstack/server/internal/models"
userv1 "github.com/spotdemo4/trevstack/server/internal/services/user/v1"
"github.com/spotdemo4/trevstack/server/internal/services/user/v1/userv1connect"
"github.com/veraison/go-cose"
"github.com/stephenafamo/bob"
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
)
type AuthHandler struct {
db *gorm.DB
db *bob.DB
key []byte
}
func (h *AuthHandler) Login(_ context.Context, req *connect.Request[userv1.LoginRequest]) (*connect.Response[userv1.LoginResponse], error) {
// Validate
user := models.User{}
if err := h.db.First(&user, "username = ?", req.Msg.Username).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, connect.NewError(connect.CodePermissionDenied, errors.New("invalid username or password"))
func (h *AuthHandler) Login(ctx context.Context, req *connect.Request[userv1.LoginRequest]) (*connect.Response[userv1.LoginResponse], error) {
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.Username.EQ(req.Msg.Username),
).One(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodePermissionDenied, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
// Check password
if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.Msg.Password)); err != nil {
return nil, connect.NewError(connect.CodePermissionDenied, errors.New("invalid username or password"))
}
@ -72,15 +78,21 @@ func (h *AuthHandler) Login(_ context.Context, req *connect.Request[userv1.Login
return res, nil
}
func (h *AuthHandler) SignUp(_ context.Context, req *connect.Request[userv1.SignUpRequest]) (*connect.Response[userv1.SignUpResponse], error) {
// Validate
if err := h.db.First(&models.User{}, "username = ?", req.Msg.Username).Error; err != nil {
if !errors.Is(err, gorm.ErrRecordNotFound) {
func (h *AuthHandler) SignUp(ctx context.Context, req *connect.Request[userv1.SignUpRequest]) (*connect.Response[userv1.SignUpResponse], error) {
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.Username.EQ(req.Msg.Username),
).One(ctx, h.db)
if err != nil {
if !errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeInternal, err)
}
} else {
}
if user != nil {
return nil, connect.NewError(connect.CodeAlreadyExists, errors.New("username already exists"))
}
// Check if confirmation passwords match
if req.Msg.Password != req.Msg.ConfirmPassword {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("passwords do not match"))
}
@ -92,11 +104,11 @@ func (h *AuthHandler) SignUp(_ context.Context, req *connect.Request[userv1.Sign
}
// Create user
user := models.User{
Username: req.Msg.Username,
Password: string(hash),
}
if err := h.db.Create(&user).Error; err != nil {
_, err = models.Users.Insert(&models.UserSetter{
Username: omit.From(req.Msg.Username),
Password: omit.From(string(hash)),
}).One(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -121,95 +133,95 @@ func (h *AuthHandler) Logout(_ context.Context, _ *connect.Request[userv1.Logout
return res, nil
}
func (h *AuthHandler) GetPasskeyIDs(_ context.Context, req *connect.Request[userv1.GetPasskeyIDsRequest]) (*connect.Response[userv1.GetPasskeyIDsResponse], error) {
// Get user
user := models.User{}
if err := h.db.Preload("Passkeys").First(&user, "username = ?", req.Msg.Username).Error; err != nil {
return nil, connect.NewError(connect.CodeNotFound, err)
}
// func (h *AuthHandler) GetPasskeyIDs(_ context.Context, req *connect.Request[userv1.GetPasskeyIDsRequest]) (*connect.Response[userv1.GetPasskeyIDsResponse], error) {
// // Get user
// user := models.User{}
// if err := h.db.Preload("Passkeys").First(&user, "username = ?", req.Msg.Username).Error; err != nil {
// return nil, connect.NewError(connect.CodeNotFound, err)
// }
// Get IDs
ids := []string{}
for _, passkey := range user.Passkeys {
ids = append(ids, passkey.ID)
}
// // Get IDs
// ids := []string{}
// for _, passkey := range user.Passkeys {
// ids = append(ids, passkey.ID)
// }
return connect.NewResponse(&userv1.GetPasskeyIDsResponse{
PasskeyIds: ids,
}), nil
}
// return connect.NewResponse(&userv1.GetPasskeyIDsResponse{
// PasskeyIds: ids,
// }), nil
// }
func (h *AuthHandler) PasskeyLogin(_ context.Context, req *connect.Request[userv1.PasskeyLoginRequest]) (*connect.Response[userv1.PasskeyLoginResponse], error) {
// Get passkey
passkey := models.Passkey{}
if err := h.db.First(&passkey, "id = ?", req.Msg.Id).Error; err != nil {
return nil, connect.NewError(connect.CodeNotFound, err)
}
// func (h *AuthHandler) PasskeyLogin(_ context.Context, req *connect.Request[userv1.PasskeyLoginRequest]) (*connect.Response[userv1.PasskeyLoginResponse], error) {
// // Get passkey
// passkey := models.Passkey{}
// if err := h.db.First(&passkey, "id = ?", req.Msg.Id).Error; err != nil {
// return nil, connect.NewError(connect.CodeNotFound, err)
// }
// create a verifier from a trusted private key
var verifier cose.Verifier
var err error
switch req.Msg.Algorithm {
case -7:
verifier, err = cose.NewVerifier(cose.AlgorithmES256, passkey.PublicKey)
// // create a verifier from a trusted private key
// var verifier cose.Verifier
// var err error
// switch req.Msg.Algorithm {
// case -7:
// verifier, err = cose.NewVerifier(cose.AlgorithmES256, passkey.PublicKey)
case -257:
verifier, err = cose.NewVerifier(cose.AlgorithmRS256, passkey.PublicKey)
// case -257:
// verifier, err = cose.NewVerifier(cose.AlgorithmRS256, passkey.PublicKey)
default:
return nil, connect.NewError(connect.CodeInternal, errors.New("decode algorithm not implemented"))
}
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// default:
// return nil, connect.NewError(connect.CodeInternal, errors.New("decode algorithm not implemented"))
// }
// if err != nil {
// return nil, connect.NewError(connect.CodeInternal, err)
// }
// create a sign message from a raw signature payload
var msg cose.Sign1Message
if err = msg.UnmarshalCBOR(req.Msg.Signature); err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// // create a sign message from a raw signature payload
// var msg cose.Sign1Message
// if err = msg.UnmarshalCBOR(req.Msg.Signature); err != nil {
// return nil, connect.NewError(connect.CodeInternal, err)
// }
// Validate passkey
err = msg.Verify(nil, verifier)
if err != nil {
return nil, connect.NewError(connect.CodeUnauthenticated, err)
}
// // Validate passkey
// err = msg.Verify(nil, verifier)
// if err != nil {
// return nil, connect.NewError(connect.CodeUnauthenticated, err)
// }
// Generate JWT
t := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.RegisteredClaims{
Issuer: "trevstack",
Subject: strconv.FormatUint(uint64(passkey.UserID), 10),
IssuedAt: &jwt.NumericDate{
Time: time.Now(),
},
ExpiresAt: &jwt.NumericDate{
Time: time.Now().Add(time.Hour * 24),
},
})
ss, err := t.SignedString(h.key)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// // Generate JWT
// t := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.RegisteredClaims{
// Issuer: "trevstack",
// Subject: strconv.FormatUint(uint64(passkey.UserID), 10),
// IssuedAt: &jwt.NumericDate{
// Time: time.Now(),
// },
// ExpiresAt: &jwt.NumericDate{
// Time: time.Now().Add(time.Hour * 24),
// },
// })
// ss, err := t.SignedString(h.key)
// if err != nil {
// return nil, connect.NewError(connect.CodeInternal, err)
// }
// Create cookie
cookie := http.Cookie{
Name: "token",
Value: ss,
Path: "/",
MaxAge: 86400,
HttpOnly: true,
Secure: true,
SameSite: http.SameSiteStrictMode,
}
// // Create cookie
// cookie := http.Cookie{
// Name: "token",
// Value: ss,
// Path: "/",
// MaxAge: 86400,
// HttpOnly: true,
// Secure: true,
// SameSite: http.SameSiteStrictMode,
// }
res := connect.NewResponse(&userv1.PasskeyLoginResponse{
Token: ss,
})
res.Header().Set("Set-Cookie", cookie.String())
return res, nil
}
// res := connect.NewResponse(&userv1.PasskeyLoginResponse{
// Token: ss,
// })
// res.Header().Set("Set-Cookie", cookie.String())
// return res, nil
// }
func NewAuthHandler(db *gorm.DB, key string) (string, http.Handler) {
func NewAuthHandler(db *bob.DB, key string) (string, http.Handler) {
interceptors := connect.WithInterceptors(interceptors.NewRateLimitInterceptor(key))
return userv1connect.NewAuthServiceHandler(

153
server/internal/handlers/user/v1/user.go
View File

@ -2,23 +2,34 @@ package user
import (
"context"
"database/sql"
"errors"
"net/http"
"strconv"
"time"
"connectrpc.com/connect"
"github.com/aarondl/opt/omit"
"github.com/aarondl/opt/omitnull"
"github.com/golang-jwt/jwt/v5"
"github.com/spotdemo4/trevstack/server/internal/interceptors"
"github.com/spotdemo4/trevstack/server/internal/models"
userv1 "github.com/spotdemo4/trevstack/server/internal/services/user/v1"
"github.com/spotdemo4/trevstack/server/internal/services/user/v1/userv1connect"
"github.com/stephenafamo/bob"
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
)
func userToConnect(item *models.User) *userv1.User {
return &userv1.User{
Id: item.ID,
Username: item.Username,
ProfilePictureId: item.ProfilePictureID.Ptr(),
}
}
type Handler struct {
db *gorm.DB
db *bob.DB
key []byte
}
@ -29,13 +40,19 @@ func (h *Handler) GetUser(ctx context.Context, _ *connect.Request[userv1.GetUser
}
// Get user
user := models.User{}
if err := h.db.Preload("ProfilePicture").First(&user, "id = ?", userid).Error; err != nil {
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
res := connect.NewResponse(&userv1.GetUserResponse{
User: user.ToConnectV1(),
User: userToConnect(user),
})
return res, nil
}
@ -47,8 +64,14 @@ func (h *Handler) UpdatePassword(ctx context.Context, req *connect.Request[userv
}
// Get user
user := models.User{}
if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -67,7 +90,10 @@ func (h *Handler) UpdatePassword(ctx context.Context, req *connect.Request[userv
}
// Update password
if err := h.db.Model(&user).Update("password", string(hash)).Error; err != nil {
err = user.Update(ctx, h.db, &models.UserSetter{
Password: omit.From(string(hash)),
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -82,8 +108,14 @@ func (h *Handler) GetAPIKey(ctx context.Context, req *connect.Request[userv1.Get
}
// Get user
user := models.User{}
if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -98,7 +130,7 @@ func (h *Handler) GetAPIKey(ctx context.Context, req *connect.Request[userv1.Get
// Generate JWT
t := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.RegisteredClaims{
Issuer: "trevstack",
Subject: strconv.FormatUint(uint64(user.ID), 10),
Subject: strconv.FormatInt(user.ID, 10),
IssuedAt: &jwt.NumericDate{
Time: time.Now(),
},
@ -127,79 +159,88 @@ func (h *Handler) UpdateProfilePicture(ctx context.Context, req *connect.Request
}
// Save bytes into file
file := models.File{
Name: req.Msg.FileName,
Data: req.Msg.Data,
UserID: uint(userid),
}
if err := h.db.Create(&file).Error; err != nil {
file, err := models.Files.Insert(&models.FileSetter{
Name: omit.From(req.Msg.FileName),
Data: omit.From(req.Msg.Data),
UserID: omit.From(userid),
}).One(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// Get user info
user := models.User{}
if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
}
return nil, connect.NewError(connect.CodeInternal, err)
}
// Get old profile picture ID
var ppid *uint32
if user.ProfilePicture != nil {
ppid = &user.ProfilePicture.ID
var ppid *int64
if user.ProfilePictureID.Ptr() != nil {
ppid = user.ProfilePictureID.Ptr()
}
// Update user profile picture
fid := uint(file.ID)
user.ProfilePictureID = &fid
user.ProfilePicture = &file
if err := h.db.Save(&user).Error; err != nil {
err = user.Update(ctx, h.db, &models.UserSetter{
ProfilePictureID: omitnull.From(file.ID),
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// Delete old profile picture if exists
if ppid != nil {
if err := h.db.Delete(models.File{}, "id = ?", *ppid).Error; err != nil {
_, err = models.Files.Delete(
models.DeleteWhere.Files.ID.EQ(*ppid),
).Exec(ctx, h.db)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
}
res := connect.NewResponse(&userv1.UpdateProfilePictureResponse{
User: user.ToConnectV1(),
User: userToConnect(user),
})
return res, nil
}
func (h *Handler) BeginPasskeyRegistration(ctx context.Context, req *connect.Request[userv1.BeginPasskeyRegistrationRequest]) (*connect.Response[userv1.BeginPasskeyRegistrationResponse], error) {
// Get user ID from context
userid, ok := interceptors.GetUserContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("user not authenticated"))
}
// func (h *Handler) BeginPasskeyRegistration(ctx context.Context, req *connect.Request[userv1.BeginPasskeyRegistrationRequest]) (*connect.Response[userv1.BeginPasskeyRegistrationResponse], error) {
// // Get user ID from context
// userid, ok := interceptors.GetUserContext(ctx)
// if !ok {
// return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("user not authenticated"))
// }
// Get user
user := models.User{}
if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// // Get user
// user := models.User{}
// if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
// return nil, connect.NewError(connect.CodeInternal, err)
// }
return connect.NewResponse(&userv1.BeginPasskeyRegistrationResponse{}), nil
}
// return connect.NewResponse(&userv1.BeginPasskeyRegistrationResponse{}), nil
// }
func (h *Handler) FinishPasskeyRegistration(ctx context.Context, req *connect.Request[userv1.FinishPasskeyRegistrationRequest]) (*connect.Response[userv1.FinishPasskeyRegistrationResponse], error) {
// Get user ID from context
userid, ok := interceptors.GetUserContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("user not authenticated"))
}
// func (h *Handler) FinishPasskeyRegistration(ctx context.Context, req *connect.Request[userv1.FinishPasskeyRegistrationRequest]) (*connect.Response[userv1.FinishPasskeyRegistrationResponse], error) {
// // Get user ID from context
// userid, ok := interceptors.GetUserContext(ctx)
// if !ok {
// return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("user not authenticated"))
// }
// Get user
user := models.User{}
if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// // Get user
// user := models.User{}
// if err := h.db.First(&user, "id = ?", userid).Error; err != nil {
// return nil, connect.NewError(connect.CodeInternal, err)
// }
return connect.NewResponse(&userv1.FinishPasskeyRegistrationResponse{}), nil
}
// return connect.NewResponse(&userv1.FinishPasskeyRegistrationResponse{}), nil
// }
// func BeginRegistration(ctx context.Context) error {
// userid, ok := interceptors.GetUserContext(ctx)
@ -231,7 +272,7 @@ func (h *Handler) FinishPasskeyRegistration(ctx context.Context, req *connect.Re
// return nil
// }
func NewHandler(db *gorm.DB, key string) (string, http.Handler) {
func NewHandler(db *bob.DB, key string) (string, http.Handler) {
interceptors := connect.WithInterceptors(interceptors.NewAuthInterceptor(key))
return userv1connect.NewUserServiceHandler(