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

feat: sqlc, nix formatting

Browse Source
This commit is contained in:
trev
2025-04-16 00:58:44 -04:00
parent 32f85fd0be
commit 967e2650ad
74 changed files with 1962 additions and 6811 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
server/internal/handlers/file/file.go
View File

@ -1,7 +1,6 @@
package file
import (
"context"
"database/sql"
"errors"
"net/http"
@ -9,13 +8,11 @@ import (
"strings"
"github.com/spotdemo4/trevstack/server/internal/interceptors"
"github.com/spotdemo4/trevstack/server/internal/models"
"github.com/stephenafamo/bob"
"github.com/stephenafamo/bob/dialect/sqlite"
"github.com/spotdemo4/trevstack/server/internal/sqlc"
)
type FileHandler struct {
db *bob.DB
db *sqlc.Queries
key []byte
}
@ -45,12 +42,10 @@ func (h *FileHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
}
// 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)
file, err := h.db.GetFile(r.Context(), sqlc.GetFileParams{
ID: int64(id),
UserID: userid,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
http.Error(w, "Not Found", http.StatusNotFound)
@ -64,7 +59,7 @@ func (h *FileHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.Write(file.Data)
}
func NewFileHandler(db *bob.DB, key string) http.Handler {
func NewFileHandler(db *sqlc.Queries, key string) http.Handler {
return interceptors.WithAuthRedirect(
&FileHandler{
db: db,

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

@ -8,32 +8,29 @@ import (
"time"
"connectrpc.com/connect"
"github.com/aarondl/opt/omit"
itemv1 "github.com/spotdemo4/trevstack/server/internal/connect/item/v1"
"github.com/spotdemo4/trevstack/server/internal/connect/item/v1/itemv1connect"
"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"
"github.com/stephenafamo/bob"
"github.com/stephenafamo/bob/dialect/sqlite"
"github.com/stephenafamo/bob/dialect/sqlite/sm"
"github.com/spotdemo4/trevstack/server/internal/sqlc"
"github.com/spotdemo4/trevstack/server/internal/util"
"google.golang.org/protobuf/types/known/timestamppb"
)
func itemToConnect(item *models.Item) *itemv1.Item {
func itemToConnect(item sqlc.Item) *itemv1.Item {
timestamp := timestamppb.New(item.Added)
return &itemv1.Item{
Id: &item.ID,
Id: item.ID,
Name: item.Name,
Description: item.Description,
Price: item.Price,
Price: float32(item.Price),
Quantity: int32(item.Quantity),
Added: timestamp,
}
}
type Handler struct {
db *bob.DB
db *sqlc.Queries
key []byte
}
@ -44,12 +41,10 @@ func (h *Handler) GetItem(ctx context.Context, req *connect.Request[itemv1.GetIt
}
// Get item
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)
item, err := h.db.GetItem(ctx, sqlc.GetItemParams{
ID: req.Msg.Id,
UserID: userid,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
@ -70,34 +65,26 @@ func (h *Handler) GetItems(ctx context.Context, req *connect.Request[itemv1.GetI
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("unauthenticated"))
}
// Filters
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 {
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 {
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 && *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
if req.Msg.Limit != nil {
query.Apply(sm.Limit(*req.Msg.Limit))
}
// Verify
offset := 0
if req.Msg.Offset != nil {
query.Apply(sm.Offset(*req.Msg.Offset))
offset = int(*req.Msg.Offset)
}
// Get items & count
items, err := query.All(ctx, h.db)
limit := 10
if req.Msg.Limit != nil {
limit = int(*req.Msg.Limit)
}
// Get items
items, err := h.db.GetItems(ctx, sqlc.GetItemsParams{
UserID: userid,
Name: util.NullLike(req.Msg.Filter),
Start: util.NullTimestamp(req.Msg.Start),
End: util.NullTimestamp(req.Msg.End),
Offset: int64(offset),
Limit: int64(limit),
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
@ -106,12 +93,18 @@ func (h *Handler) GetItems(ctx context.Context, req *connect.Request[itemv1.GetI
return nil, connect.NewError(connect.CodeInternal, err)
}
count, err := query.Count(ctx, h.db)
// Get items count
count, err := h.db.GetItemsCount(ctx, sqlc.GetItemsCountParams{
UserID: userid,
Name: util.NullLike(req.Msg.Filter),
Start: util.NullTimestamp(req.Msg.Start),
End: util.NullTimestamp(req.Msg.End),
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// Convert to connect v1 items
// Convert to connect items
resItems := []*itemv1.Item{}
for _, item := range items {
resItems = append(resItems, itemToConnect(item))
@ -130,20 +123,24 @@ func (h *Handler) CreateItem(ctx context.Context, req *connect.Request[itemv1.Cr
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("unauthenticated"))
}
item, err := models.Items.Insert(&models.ItemSetter{
Name: omit.From(req.Msg.Item.Name),
Description: omit.From(req.Msg.Item.Description),
Price: omit.From(req.Msg.Item.Price),
Quantity: omit.From(int64(req.Msg.Item.Quantity)),
Added: omit.From(time.Now()),
UserID: omit.From(userid),
}).One(ctx, h.db)
time := time.Now()
// Insert item
id, err := h.db.InsertItem(ctx, sqlc.InsertItemParams{
Name: req.Msg.Name,
Added: time,
Description: req.Msg.Description,
Price: float64(req.Msg.Price),
Quantity: int64(req.Msg.Quantity),
UserID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
res := connect.NewResponse(&itemv1.CreateItemResponse{
Item: itemToConnect(item),
Id: id,
Added: timestamppb.New(time),
})
return res, nil
}
@ -154,34 +151,23 @@ func (h *Handler) UpdateItem(ctx context.Context, req *connect.Request[itemv1.Up
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("unauthenticated"))
}
// Validate
if req.Msg.Item.Id == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("id is required"))
}
// Update item
item, err := models.Items.Update(
// Set col
models.ItemSetter{
Name: omit.From(req.Msg.Item.Name),
Description: omit.From(req.Msg.Item.Description),
Price: omit.From(req.Msg.Item.Price),
Quantity: omit.From(int64(req.Msg.Item.Quantity)),
}.UpdateMod(),
err := h.db.UpdateItem(ctx, sqlc.UpdateItemParams{
// set
Name: req.Msg.Name,
Description: req.Msg.Description,
Price: util.NullFloat64(req.Msg.Price),
Quantity: util.NullInt64(req.Msg.Quantity),
// Where
sqlite.WhereAnd(
models.UpdateWhere.Items.ID.EQ(*req.Msg.Item.Id),
models.UpdateWhere.Items.UserID.EQ(userid),
),
).One(ctx, h.db)
// where
ID: req.Msg.Id,
UserID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
res := connect.NewResponse(&itemv1.UpdateItemResponse{
Item: itemToConnect(item),
})
res := connect.NewResponse(&itemv1.UpdateItemResponse{})
return res, nil
}
@ -192,12 +178,10 @@ func (h *Handler) DeleteItem(ctx context.Context, req *connect.Request[itemv1.De
}
// Delete item
_, err := models.Items.Delete(
sqlite.WhereAnd(
models.DeleteWhere.Items.ID.EQ(req.Msg.Id),
models.DeleteWhere.Items.UserID.EQ(userid),
),
).Exec(ctx, h.db)
err := h.db.DeleteItem(ctx, sqlc.DeleteItemParams{
ID: req.Msg.Id,
UserID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -206,7 +190,7 @@ func (h *Handler) DeleteItem(ctx context.Context, req *connect.Request[itemv1.De
return res, nil
}
func NewHandler(db *bob.DB, key string) (string, http.Handler) {
func NewHandler(db *sqlc.Queries, key string) (string, http.Handler) {
interceptors := connect.WithInterceptors(interceptors.NewAuthInterceptor(key))
return itemv1connect.NewItemServiceHandler(

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

@ -11,26 +11,22 @@ import (
_ "crypto/sha256" // Crypto
"connectrpc.com/connect"
"github.com/aarondl/opt/omit"
"github.com/golang-jwt/jwt/v5"
userv1 "github.com/spotdemo4/trevstack/server/internal/connect/user/v1"
"github.com/spotdemo4/trevstack/server/internal/connect/user/v1/userv1connect"
"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"
"github.com/spotdemo4/trevstack/server/internal/sqlc"
"golang.org/x/crypto/bcrypt"
)
type AuthHandler struct {
db *bob.DB
db *sqlc.Queries
key []byte
}
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)
user, err := h.db.GetUserbyUsername(ctx, req.Msg.Username)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodePermissionDenied, err)
@ -47,7 +43,7 @@ func (h *AuthHandler) Login(ctx context.Context, req *connect.Request[userv1.Log
// 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(),
},
@ -80,16 +76,13 @@ func (h *AuthHandler) Login(ctx context.Context, req *connect.Request[userv1.Log
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)
_, err := h.db.GetUserbyUsername(ctx, req.Msg.Username)
if err != nil {
if !errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeInternal, err)
}
}
if user != nil {
return nil, connect.NewError(connect.CodeAlreadyExists, errors.New("username already exists"))
} else {
return nil, connect.NewError(connect.CodeAlreadyExists, err)
}
// Check if confirmation passwords match
@ -104,10 +97,10 @@ func (h *AuthHandler) SignUp(ctx context.Context, req *connect.Request[userv1.Si
}
// Create user
_, err = models.Users.Insert(&models.UserSetter{
Username: omit.From(req.Msg.Username),
Password: omit.From(string(hash)),
}).One(ctx, h.db)
_, err = h.db.InsertUser(ctx, sqlc.InsertUserParams{
Username: req.Msg.Username,
Password: string(hash),
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -221,7 +214,7 @@ func (h *AuthHandler) Logout(_ context.Context, _ *connect.Request[userv1.Logout
// return res, nil
// }
func NewAuthHandler(db *bob.DB, key string) (string, http.Handler) {
func NewAuthHandler(db *sqlc.Queries, key string) (string, http.Handler) {
interceptors := connect.WithInterceptors(interceptors.NewRateLimitInterceptor(key))
return userv1connect.NewAuthServiceHandler(

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

@ -9,27 +9,25 @@ import (
"time"
"connectrpc.com/connect"
"github.com/aarondl/opt/omit"
"github.com/aarondl/opt/omitnull"
"github.com/golang-jwt/jwt/v5"
userv1 "github.com/spotdemo4/trevstack/server/internal/connect/user/v1"
"github.com/spotdemo4/trevstack/server/internal/connect/user/v1/userv1connect"
"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"
"github.com/spotdemo4/trevstack/server/internal/sqlc"
"github.com/spotdemo4/trevstack/server/internal/util"
"golang.org/x/crypto/bcrypt"
)
func userToConnect(item *models.User) *userv1.User {
func userToConnect(item sqlc.User) *userv1.User {
return &userv1.User{
Id: item.ID,
Username: item.Username,
ProfilePictureId: item.ProfilePictureID.Ptr(),
ProfilePictureId: item.ProfilePictureID,
}
}
type Handler struct {
db *bob.DB
db *sqlc.Queries
key []byte
}
@ -40,9 +38,7 @@ func (h *Handler) GetUser(ctx context.Context, _ *connect.Request[userv1.GetUser
}
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
user, err := h.db.GetUser(ctx, userid)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
@ -64,9 +60,7 @@ func (h *Handler) UpdatePassword(ctx context.Context, req *connect.Request[userv
}
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
user, err := h.db.GetUser(ctx, userid)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
@ -90,8 +84,9 @@ func (h *Handler) UpdatePassword(ctx context.Context, req *connect.Request[userv
}
// Update password
err = user.Update(ctx, h.db, &models.UserSetter{
Password: omit.From(string(hash)),
err = h.db.UpdateUser(ctx, sqlc.UpdateUserParams{
Password: util.ToPointer(string(hash)),
ID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
@ -108,9 +103,7 @@ func (h *Handler) GetAPIKey(ctx context.Context, req *connect.Request[userv1.Get
}
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
user, err := h.db.GetUser(ctx, userid)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
@ -159,19 +152,17 @@ func (h *Handler) UpdateProfilePicture(ctx context.Context, req *connect.Request
}
// Save bytes into file
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)
fileID, err := h.db.InsertFile(ctx, sqlc.InsertFileParams{
Name: req.Msg.FileName,
Data: req.Msg.Data,
UserID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// Get user
user, err := models.Users.Query(
models.SelectWhere.Users.ID.EQ(userid),
).One(ctx, h.db)
user, err := h.db.GetUser(ctx, userid)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, connect.NewError(connect.CodeNotFound, err)
@ -180,25 +171,24 @@ func (h *Handler) UpdateProfilePicture(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeInternal, err)
}
// Get old profile picture ID
var ppid *int64
if user.ProfilePictureID.Ptr() != nil {
ppid = user.ProfilePictureID.Ptr()
}
// Update user profile picture
err = user.Update(ctx, h.db, &models.UserSetter{
ProfilePictureID: omitnull.From(file.ID),
err = h.db.UpdateUser(ctx, sqlc.UpdateUserParams{
// set
ProfilePictureID: &fileID,
// where
ID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
// Delete old profile picture if exists
if ppid != nil {
_, err = models.Files.Delete(
models.DeleteWhere.Files.ID.EQ(*ppid),
).Exec(ctx, h.db)
if user.ProfilePictureID != nil {
err = h.db.DeleteFile(ctx, sqlc.DeleteFileParams{
ID: *user.ProfilePictureID,
UserID: userid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
@ -272,7 +262,7 @@ func (h *Handler) UpdateProfilePicture(ctx context.Context, req *connect.Request
// return nil
// }
func NewHandler(db *bob.DB, key string) (string, http.Handler) {
func NewHandler(db *sqlc.Queries, key string) (string, http.Handler) {
interceptors := connect.WithInterceptors(interceptors.NewAuthInterceptor(key))
return userv1connect.NewUserServiceHandler(