dkelly/go-nkode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rigged shuffle

Browse Source
This commit is contained in:
Donovan
2025-08-01 10:49:46 -05:00
parent 3ed12cee68
commit 8d4c8f71b0
21 changed files with 578 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
internal/api/handler.go
View File

@@ -103,12 +103,10 @@ func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter
methodNotAllowed(w)
return
}
var signupResetPost models.GenerateSignupRestInterfacePost
if err := decodeJson(w, r, &signupResetPost); err != nil {
return
}
kp := entities.KeypadDimension{
AttrsPerKey: signupResetPost.AttrsPerKey,
NumbOfKeys: signupResetPost.NumbOfKeys,
@@ -127,12 +125,11 @@ func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter
badRequest(w, malformedUserEmail)
return
}
resp, err := h.Api.GenerateSignupResetInterface(userEmail, models.CustomerId(customerId), kp, signupResetPost.Reset)
resp, err := h.Api.GenerateSignupResetInterface(userEmail, models.CustomerID(customerId), kp, signupResetPost.Reset)
if err != nil {
handleError(w, err)
return
}
marshalAndWriteBytes(w, resp)
}
@@ -156,7 +153,7 @@ func (h *NKodeHandler) SetNKodeHandler(w http.ResponseWriter, r *http.Request) {
badRequest(w, malformedSessionId)
return
}
confirmInterface, err := h.Api.SetNKode(models.CustomerId(customerId), models.SessionId(sessionId), setNKodePost.KeySelection)
confirmInterface, err := h.Api.SetNKode(models.CustomerID(customerId), models.SessionId(sessionId), setNKodePost.KeySelection)
if err != nil {
handleError(w, err)
return
@@ -186,7 +183,7 @@ func (h *NKodeHandler) ConfirmNKodeHandler(w http.ResponseWriter, r *http.Reques
badRequest(w, malformedSessionId)
return
}
if err = h.Api.ConfirmNKode(models.CustomerId(customerId), models.SessionId(sessionId), confirmNKodePost.KeySelection); err != nil {
if err = h.Api.ConfirmNKode(models.CustomerID(customerId), models.SessionId(sessionId), confirmNKodePost.KeySelection); err != nil {
handleError(w, err)
return
}
@@ -212,7 +209,7 @@ func (h *NKodeHandler) GetLoginInterfaceHandler(w http.ResponseWriter, r *http.R
if err != nil {
badRequest(w, malformedUserEmail)
}
loginInterface, err := h.Api.GetLoginInterface(userEmail, models.CustomerId(customerId))
loginInterface, err := h.Api.GetLoginInterface(userEmail, models.CustomerID(customerId))
if err != nil {
handleError(w, err)
return
@@ -241,7 +238,7 @@ func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
badRequest(w, malformedUserEmail)
return
}
jwtTokens, err := h.Api.Login(models.CustomerId(customerId), userEmail, loginPost.KeySelection)
jwtTokens, err := h.Api.Login(models.CustomerID(customerId), userEmail, loginPost.KeySelection)
if err != nil {
handleError(w, err)
return
@@ -265,7 +262,7 @@ func (h *NKodeHandler) RenewAttributesHandler(w http.ResponseWriter, r *http.Req
badRequest(w, malformedCustomerId)
return
}
if err = h.Api.RenewAttributes(models.CustomerId(customerId)); err != nil {
if err = h.Api.RenewAttributes(models.CustomerID(customerId)); err != nil {
handleError(w, err)
return
}
@@ -314,7 +311,7 @@ func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Reques
log.Println(err)
return
}
accessToken, err := h.Api.RefreshToken(userEmail, models.CustomerId(customerId), refreshToken)
accessToken, err := h.Api.RefreshToken(userEmail, models.CustomerID(customerId), refreshToken)
if err != nil {
handleError(w, err)
@@ -346,7 +343,7 @@ func (h *NKodeHandler) ResetNKode(w http.ResponseWriter, r *http.Request) {
return
}
if err = h.Api.ResetNKode(userEmail, models.CustomerId(customerId)); err != nil {
if err = h.Api.ResetNKode(userEmail, models.CustomerID(customerId)); err != nil {
internalServerError(w)
log.Println(err)
return

77
internal/api/nkode_api.go
View File

@@ -34,23 +34,22 @@ func NewNKodeAPI(db repository.CustomerUserRepository, queue *email.Queue) NKode
}
}
func (n *NKodeAPI) CreateNewCustomer(nkodePolicy models.NKodePolicy, id *models.CustomerId) (*models.CustomerId, error) {
func (n *NKodeAPI) CreateNewCustomer(nkodePolicy models.NKodePolicy, id *models.CustomerID) (*models.CustomerID, error) {
newCustomer, err := entities.NewCustomer(nkodePolicy)
if id != nil {
newCustomer.Id = *id
newCustomer.ID = *id
}
if err != nil {
return nil, err
}
err = n.Db.CreateCustomer(*newCustomer)
if err != nil {
return nil, err
}
return &newCustomer.Id, nil
return &newCustomer.ID, nil
}
func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, customerId models.CustomerId, kp entities.KeypadDimension, reset bool) (*models.GenerateSignupResetInterfaceResp, error) {
func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, customerId models.CustomerID, kp entities.KeypadDimension, reset bool) (*models.GenerateSignupResetInterfaceResp, error) {
user, err := n.Db.GetUser(userEmail, customerId)
if err != nil {
return nil, err
@@ -59,20 +58,23 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, cust
log.Printf("user %s already exists", string(userEmail))
return nil, config.ErrUserAlreadyExists
}
svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
if err != nil {
return nil, err
//svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
//if err != nil {
// return nil, err
//}
svgIdxInterface := make(models.SvgIdInterface, 54)
for idx := range 54 {
svgIdxInterface[idx] = idx + 1
}
signupSession, err := entities.NewSignupResetSession(userEmail, kp, customerId, svgIdxInterface, reset)
if err != nil {
return nil, err
}
//n.SignupSessions[signupSession.Id] = *signupSession
//n.SignupSessions[signupSession.ID] = *signupSession
if err := n.SignupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
return nil, err
}
svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
if err != nil {
return nil, err
}
@@ -85,9 +87,41 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail models.UserEmail, cust
return &resp, nil
}
func (n *NKodeAPI) SetNKode(customerId models.CustomerId, sessionId models.SessionId, keySelection models.KeySelection) (models.IdxInterface, error) {
_, err := n.Db.GetCustomer(customerId)
func (n *NKodeAPI) GenerateSignupResetInterfaceRigged(userEmail models.UserEmail, customerId models.CustomerID, kp entities.KeypadDimension, reset bool) (*models.GenerateSignupResetInterfaceResp, error) {
user, err := n.Db.GetUser(userEmail, customerId)
if err != nil {
return nil, err
}
if user != nil && !reset {
log.Printf("user %s already exists", string(userEmail))
return nil, config.ErrUserAlreadyExists
}
svgIdxInterface := make(models.SvgIdInterface, kp.TotalAttrs())
for idx := range kp.TotalAttrs() {
svgIdxInterface[idx] = idx
}
signupSession, err := entities.NewSignupResetSessionRigged(userEmail, kp, customerId, svgIdxInterface, reset)
if err != nil {
return nil, err
}
if err := n.SignupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
return nil, err
}
svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
if err != nil {
return nil, err
}
resp := models.GenerateSignupResetInterfaceResp{
UserIdxInterface: signupSession.SetIdxInterface,
SvgInterface: svgInterface,
SessionId: uuid.UUID(signupSession.Id).String(),
Colors: signupSession.Colors,
}
return &resp, nil
}
func (n *NKodeAPI) SetNKode(customerId models.CustomerID, sessionId models.SessionId, keySelection models.KeySelection) (models.IdxInterface, error) {
_, err := n.Db.GetCustomer(customerId)
if err != nil {
return nil, err
}
@@ -109,7 +143,7 @@ func (n *NKodeAPI) SetNKode(customerId models.CustomerId, sessionId models.Sessi
return confirmInterface, nil
}
func (n *NKodeAPI) ConfirmNKode(customerId models.CustomerId, sessionId models.SessionId, keySelection models.KeySelection) error {
func (n *NKodeAPI) ConfirmNKode(customerId models.CustomerID, sessionId models.SessionId, keySelection models.KeySelection) error {
session, exists := n.SignupSessionCache.Get(sessionId.String())
if !exists {
log.Printf("session id does not exist %s", sessionId)
@@ -144,7 +178,7 @@ func (n *NKodeAPI) ConfirmNKode(customerId models.CustomerId, sessionId models.S
return err
}
func (n *NKodeAPI) GetLoginInterface(userEmail models.UserEmail, customerId models.CustomerId) (*models.GetLoginInterfaceResp, error) {
func (n *NKodeAPI) GetLoginInterface(userEmail models.UserEmail, customerId models.CustomerID) (*models.GetLoginInterfaceResp, error) {
user, err := n.Db.GetUser(userEmail, customerId)
if err != nil {
return nil, err
@@ -167,7 +201,7 @@ func (n *NKodeAPI) GetLoginInterface(userEmail models.UserEmail, customerId mode
return &resp, nil
}
func (n *NKodeAPI) Login(customerId models.CustomerId, userEmail models.UserEmail, keySelection models.KeySelection) (*security.AuthenticationTokens, error) {
func (n *NKodeAPI) Login(customerId models.CustomerID, userEmail models.UserEmail, keySelection models.KeySelection) (*security.AuthenticationTokens, error) {
customer, err := n.Db.GetCustomer(customerId)
if err != nil {
return nil, err
@@ -184,7 +218,6 @@ func (n *NKodeAPI) Login(customerId models.CustomerId, userEmail models.UserEmai
if err != nil {
return nil, err
}
if user.Renew {
err = n.Db.RefreshUserPasscode(*user, passcode, customer.Attributes)
if err != nil {
@@ -207,7 +240,7 @@ func (n *NKodeAPI) Login(customerId models.CustomerId, userEmail models.UserEmai
return &jwtToken, nil
}
func (n *NKodeAPI) RenewAttributes(customerId models.CustomerId) error {
func (n *NKodeAPI) RenewAttributes(customerId models.CustomerID) error {
return n.Db.Renew(customerId)
}
@@ -215,7 +248,7 @@ func (n *NKodeAPI) RandomSvgInterface() ([]string, error) {
return n.Db.RandomSvgInterface(entities.KeypadMax)
}
func (n *NKodeAPI) RefreshToken(userEmail models.UserEmail, customerId models.CustomerId, refreshToken string) (string, error) {
func (n *NKodeAPI) RefreshToken(userEmail models.UserEmail, customerId models.CustomerID, refreshToken string) (string, error) {
user, err := n.Db.GetUser(userEmail, customerId)
if err != nil {
return "", err
@@ -238,16 +271,14 @@ func (n *NKodeAPI) RefreshToken(userEmail models.UserEmail, customerId models.Cu
return security.EncodeAndSignClaims(newAccessClaims)
}
func (n *NKodeAPI) ResetNKode(userEmail models.UserEmail, customerId models.CustomerId) error {
func (n *NKodeAPI) ResetNKode(userEmail models.UserEmail, customerId models.CustomerID) error {
user, err := n.Db.GetUser(userEmail, customerId)
if err != nil {
return fmt.Errorf("error getting user in rest nkode %v", err)
}
if user == nil {
return nil
}
nkodeResetJwt, err := security.ResetNKodeToken(string(userEmail), uuid.UUID(customerId))
if err != nil {
return err
@@ -257,12 +288,12 @@ func (n *NKodeAPI) ResetNKode(userEmail models.UserEmail, customerId models.Cust
frontendHost = config.FrontendHost
}
htmlBody := fmt.Sprintf("<h1>Hello!</h1><p>Click the link to reset your nKode.</p><a href=\"%s?token=%s\">Reset nKode</a>", frontendHost, nkodeResetJwt)
email := email.Email{
emailData := email.Email{
Sender: "no-reply@nkode.tech",
Recipient: string(userEmail),
Subject: "nKode Reset",
Content: htmlBody,
}
n.EmailQueue.AddEmail(email)
n.EmailQueue.AddEmail(emailData)
return nil
}

4
internal/api/nkode_api_test.go
View File

@@ -23,7 +23,7 @@ func TestNKodeAPI(t *testing.T) {
sqliteDb, err := sqlite_queue.OpenSqliteDb(dbPath)
assert.NoError(t, err)
queue, err := sqlite_queue.NewQueue(sqliteDb, ctx)
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb)
assert.NoError(t, err)
queue.Start()
defer func(queue *sqlite_queue.Queue) {
@@ -31,7 +31,7 @@ func TestNKodeAPI(t *testing.T) {
log.Fatal(err)
}
}(queue)
sqlitedb := repository.NewSqliteRepository(queue, ctx)
sqlitedb := repository.NewSqliteRepository(ctx, queue)
testNKodeAPI(t, &sqlitedb)
//if _, err := os.Stat(dbPath); err == nil {

6
internal/entities/customer.go
View File

@@ -11,7 +11,7 @@ import (
)
type Customer struct {
Id models.CustomerId
ID models.CustomerID
NKodePolicy models.NKodePolicy
Attributes CustomerAttributes
}
@@ -22,7 +22,7 @@ func NewCustomer(nkodePolicy models.NKodePolicy) (*Customer, error) {
return nil, err
}
customer := Customer{
Id: models.CustomerId(uuid.New()),
ID: models.CustomerID(uuid.New()),
NKodePolicy: nkodePolicy,
Attributes: *customerAttrs,
}
@@ -88,7 +88,7 @@ func (c *Customer) RenewKeys() ([]uint64, []uint64, error) {
func (c *Customer) ToSqlcCreateCustomerParams() sqlc.CreateCustomerParams {
return sqlc.CreateCustomerParams{
ID: uuid.UUID(c.Id).String(),
ID: uuid.UUID(c.ID).String(),
MaxNkodeLen: int64(c.NKodePolicy.MaxNkodeLen),
MinNkodeLen: int64(c.NKodePolicy.MinNkodeLen),
DistinctSets: int64(c.NKodePolicy.DistinctSets),

4
internal/entities/user.go
View File

@@ -10,7 +10,7 @@ import (
type User struct {
Id models.UserId
CustomerId models.CustomerId
CustomerId models.CustomerID
Email models.UserEmail
EncipheredPasscode models.EncipheredNKode
Kp KeypadDimension
@@ -137,7 +137,7 @@ func NewUser(customer Customer, userEmail string, passcodeIdx []int, ui UserInte
CipherKeys: *newKeys,
Interface: ui,
Kp: kp,
CustomerId: customer.Id,
CustomerId: customer.ID,
}
return &newUser, nil
}

29
internal/entities/user_signup_session.go
View File

@@ -13,7 +13,7 @@ import (
type UserSignSession struct {
Id models.SessionId
CustomerId models.CustomerId
CustomerId models.CustomerID
LoginUserInterface UserInterface
Kp KeypadDimension
SetIdxInterface models.IdxInterface
@@ -25,7 +25,31 @@ type UserSignSession struct {
Colors []models.RGBColor
}
func NewSignupResetSession(userEmail models.UserEmail, kp KeypadDimension, customerId models.CustomerId, svgInterface models.SvgIdInterface, reset bool) (*UserSignSession, error) {
func NewSignupResetSessionRigged(userEmail models.UserEmail, kp KeypadDimension, customerId models.CustomerID, svgInterface models.SvgIdInterface, reset bool) (*UserSignSession, error) {
loginInterface, err := NewUserInterface(&kp, svgInterface)
if err != nil {
return nil, err
}
setIdxInterface := make(models.IdxInterface, 36)
for idx := range 36 {
setIdxInterface[idx] = idx
}
session := UserSignSession{
Id: models.SessionId(uuid.New()),
CustomerId: customerId,
LoginUserInterface: *loginInterface,
SetIdxInterface: setIdxInterface,
ConfirmIdxInterface: nil,
SetKeySelection: nil,
UserEmail: userEmail,
Kp: kp,
Reset: reset,
Colors: []models.RGBColor{},
}
return &session, nil
}
func NewSignupResetSession(userEmail models.UserEmail, kp KeypadDimension, customerId models.CustomerID, svgInterface models.SvgIdInterface, reset bool) (*UserSignSession, error) {
loginInterface, err := NewUserInterface(&kp, svgInterface)
if err != nil {
return nil, err
@@ -46,7 +70,6 @@ func NewSignupResetSession(userEmail models.UserEmail, kp KeypadDimension, custo
Reset: reset,
Colors: colors,
}
return &session, nil
}

12
internal/models/models.go
View File

@@ -90,13 +90,21 @@ type GetLoginInterfaceResp struct {
type KeySelection []int
type CustomerId uuid.UUID
type CustomerID uuid.UUID
func CustomerIdToString(customerId CustomerId) string {
func CustomerIdToString(customerId CustomerID) string {
customerUuid := uuid.UUID(customerId)
return customerUuid.String()
}
func CustomerIDFromString(customerID string) (CustomerID, error) {
id, err := uuid.Parse(customerID)
if err != nil {
return CustomerID{}, err
}
return CustomerID(id), nil
}
type SessionId uuid.UUID
type UserId uuid.UUID

7
internal/repository/customer_user_repository.go
View File

@@ -6,16 +6,17 @@ import (
)
type CustomerUserRepository interface {
GetCustomer(models.CustomerId) (*entities.Customer, error)
GetUser(models.UserEmail, models.CustomerId) (*entities.User, error)
GetCustomer(models.CustomerID) (*entities.Customer, error)
GetUser(models.UserEmail, models.CustomerID) (*entities.User, error)
CreateCustomer(entities.Customer) error
WriteNewUser(entities.User) error
UpdateUserNKode(entities.User) error
UpdateUserInterface(models.UserId, entities.UserInterface) error
UpdateUserRefreshToken(models.UserId, string) error
Renew(models.CustomerId) error
Renew(models.CustomerID) error
RefreshUserPasscode(entities.User, []int, entities.CustomerAttributes) error
RandomSvgInterface(entities.KeypadDimension) ([]string, error)
RandomSvgIdxInterface(entities.KeypadDimension) (models.SvgIdInterface, error)
GetSvgStringInterface(models.SvgIdInterface) ([]string, error)
AddSVGIcon(svgStr string) (int64, error)
}

20
internal/repository/in_memory_db.go
View File

@@ -8,28 +8,28 @@ import (
)
type InMemoryDb struct {
Customers map[models.CustomerId]entities.Customer
Customers map[models.CustomerID]entities.Customer
Users map[models.UserId]entities.User
userIdMap map[string]models.UserId
}
func NewInMemoryDb() InMemoryDb {
return InMemoryDb{
Customers: make(map[models.CustomerId]entities.Customer),
Customers: make(map[models.CustomerID]entities.Customer),
Users: make(map[models.UserId]entities.User),
userIdMap: make(map[string]models.UserId),
}
}
func (db *InMemoryDb) GetCustomer(id models.CustomerId) (*entities.Customer, error) {
func (db *InMemoryDb) GetCustomer(id models.CustomerID) (*entities.Customer, error) {
customer, exists := db.Customers[id]
if !exists {
return nil, errors.New(fmt.Sprintf("customer %s dne", customer.Id))
return nil, errors.New(fmt.Sprintf("customer %s dne", customer.ID))
}
return &customer, nil
}
func (db *InMemoryDb) GetUser(username models.UserEmail, customerId models.CustomerId) (*entities.User, error) {
func (db *InMemoryDb) GetUser(username models.UserEmail, customerId models.CustomerID) (*entities.User, error) {
key := userIdKey(customerId, username)
userId, exists := db.userIdMap[key]
if !exists {
@@ -43,12 +43,12 @@ func (db *InMemoryDb) GetUser(username models.UserEmail, customerId models.Custo
}
func (db *InMemoryDb) CreateCustomer(customer entities.Customer) error {
_, exists := db.Customers[customer.Id]
_, exists := db.Customers[customer.ID]
if exists {
return errors.New(fmt.Sprintf("can write customer %s; already exists", customer.Id))
return errors.New(fmt.Sprintf("can write customer %s; already exists", customer.ID))
}
db.Customers[customer.Id] = customer
db.Customers[customer.ID] = customer
return nil
}
@@ -86,7 +86,7 @@ func (db *InMemoryDb) UpdateUserRefreshToken(userId models.UserId, refreshToken
return nil
}
func (db *InMemoryDb) Renew(id models.CustomerId) error {
func (db *InMemoryDb) Renew(id models.CustomerID) error {
customer, exists := db.Customers[id]
if !exists {
return errors.New(fmt.Sprintf("customer %s does not exist", id))
@@ -133,7 +133,7 @@ func (db *InMemoryDb) GetSvgStringInterface(idxs models.SvgIdInterface) ([]strin
return make([]string, len(idxs)), nil
}
func userIdKey(customerId models.CustomerId, username models.UserEmail) string {
func userIdKey(customerId models.CustomerID, username models.UserEmail) string {
key := fmt.Sprintf("%s:%s", customerId, username)
return key
}

124
internal/repository/sqlite_repository.go
View File

@@ -21,7 +21,7 @@ type SqliteRepository struct {
ctx context.Context
}
func NewSqliteRepository(queue *sqlc.Queue, ctx context.Context) SqliteRepository {
func NewSqliteRepository(ctx context.Context, queue *sqlc.Queue) SqliteRepository {
return SqliteRepository{
Queue: queue,
ctx: ctx,
@@ -29,27 +29,27 @@ func NewSqliteRepository(queue *sqlc.Queue, ctx context.Context) SqliteRepositor
}
func (d *SqliteRepository) CreateCustomer(c entities.Customer) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.CreateCustomerParams)
if !ok {
return fmt.Errorf("invalid argument type: expected CreateCustomerParams")
return nil, fmt.Errorf("invalid argument type: expected CreateCustomerParams")
}
return q.CreateCustomer(ctx, params)
return nil, q.CreateCustomer(ctx, params)
}
return d.Queue.EnqueueWriteTx(queryFunc, c.ToSqlcCreateCustomerParams())
_, err := d.Queue.EnqueueWriteTx(queryFunc, c.ToSqlcCreateCustomerParams())
return err
}
func (d *SqliteRepository) WriteNewUser(u entities.User) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.CreateUserParams)
if !ok {
return fmt.Errorf("invalid argument type: expected CreateUserParams")
return nil, fmt.Errorf("invalid argument type: expected CreateUserParams")
}
return q.CreateUser(ctx, params)
return nil, q.CreateUser(ctx, params)
}
// Use the wrapped function in EnqueueWriteTx
renew := 0
if u.Renew {
renew = 1
@@ -75,16 +75,17 @@ func (d *SqliteRepository) WriteNewUser(u entities.User) error {
SvgIDInterface: security.IntArrToByteArr(u.Interface.SvgId),
CreatedAt: sql.NullString{String: utils.TimeStamp(), Valid: true},
}
return d.Queue.EnqueueWriteTx(queryFunc, params)
_, err := d.Queue.EnqueueWriteTx(queryFunc, params)
return err
}
func (d *SqliteRepository) UpdateUserNKode(u entities.User) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.UpdateUserParams)
if !ok {
return fmt.Errorf("invalid argument type: expected UpdateUserParams")
return nil, fmt.Errorf("invalid argument type: expected UpdateUserParams")
}
return q.UpdateUser(ctx, params)
return nil, q.UpdateUser(ctx, params)
}
// Use the wrapped function in EnqueueWriteTx
renew := 0
@@ -109,33 +110,34 @@ func (d *SqliteRepository) UpdateUserNKode(u entities.User) error {
IdxInterface: security.IntArrToByteArr(u.Interface.IdxInterface),
SvgIDInterface: security.IntArrToByteArr(u.Interface.SvgId),
}
return d.Queue.EnqueueWriteTx(queryFunc, params)
_, err := d.Queue.EnqueueWriteTx(queryFunc, params)
return err
}
func (d *SqliteRepository) UpdateUserInterface(id models.UserId, ui entities.UserInterface) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.UpdateUserInterfaceParams)
if !ok {
return fmt.Errorf("invalid argument type: expected UpdateUserInterfaceParams")
return nil, fmt.Errorf("invalid argument type: expected UpdateUserInterfaceParams")
}
return q.UpdateUserInterface(ctx, params)
return nil, q.UpdateUserInterface(ctx, params)
}
params := sqlc.UpdateUserInterfaceParams{
IdxInterface: security.IntArrToByteArr(ui.IdxInterface),
LastLogin: utils.TimeStamp(),
ID: uuid.UUID(id).String(),
}
return d.Queue.EnqueueWriteTx(queryFunc, params)
_, err := d.Queue.EnqueueWriteTx(queryFunc, params)
return err
}
func (d *SqliteRepository) UpdateUserRefreshToken(id models.UserId, refreshToken string) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.UpdateUserRefreshTokenParams)
if !ok {
return fmt.Errorf("invalid argument type: expected UpdateUserRefreshToken")
return nil, fmt.Errorf("invalid argument type: expected UpdateUserRefreshToken")
}
return q.UpdateUserRefreshToken(ctx, params)
return nil, q.UpdateUserRefreshToken(ctx, params)
}
params := sqlc.UpdateUserRefreshTokenParams{
RefreshToken: sql.NullString{
@@ -144,21 +146,23 @@ func (d *SqliteRepository) UpdateUserRefreshToken(id models.UserId, refreshToken
},
ID: uuid.UUID(id).String(),
}
return d.Queue.EnqueueWriteTx(queryFunc, params)
_, err := d.Queue.EnqueueWriteTx(queryFunc, params)
return err
}
func (d *SqliteRepository) RenewCustomer(renewParams sqlc.RenewCustomerParams) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.RenewCustomerParams)
if !ok {
return nil, fmt.Errorf("invalid argument type: expected RenewCustomerParams")
}
return q.RenewCustomer(ctx, params)
return nil, q.RenewCustomer(ctx, params)
}
return d.Queue.EnqueueWriteTx(queryFunc, renewParams)
_, err := d.Queue.EnqueueWriteTx(queryFunc, renewParams)
return err
}
func (d *SqliteRepository) Renew(id models.CustomerId) error {
func (d *SqliteRepository) Renew(id models.CustomerID) error {
setXor, attrXor, err := d.renewCustomer(id)
if err != nil {
return err
@@ -168,19 +172,17 @@ func (d *SqliteRepository) Renew(id models.CustomerId) error {
if err != nil {
return err
}
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.RenewUserParams)
if !ok {
return fmt.Errorf("invalid argument type: expected RenewUserParams")
return nil, fmt.Errorf("invalid argument type: expected RenewUserParams")
}
return q.RenewUser(ctx, params)
return nil, q.RenewUser(ctx, params)
}
for _, row := range userRenewRows {
user := entities.User{
Id: models.UserIdFromString(row.ID),
CustomerId: models.CustomerId{},
CustomerId: models.CustomerID{},
Email: "",
EncipheredPasscode: models.EncipheredNKode{},
Kp: entities.KeypadDimension{
@@ -194,7 +196,6 @@ func (d *SqliteRepository) Renew(id models.CustomerId) error {
Interface: entities.UserInterface{},
Renew: false,
}
if err = user.RenewKeys(setXor, attrXor); err != nil {
return err
}
@@ -204,14 +205,14 @@ func (d *SqliteRepository) Renew(id models.CustomerId) error {
Renew: 1,
ID: uuid.UUID(user.Id).String(),
}
if err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
if _, err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
return err
}
}
return nil
}
func (d *SqliteRepository) renewCustomer(id models.CustomerId) ([]uint64, []uint64, error) {
func (d *SqliteRepository) renewCustomer(id models.CustomerID) ([]uint64, []uint64, error) {
customer, err := d.GetCustomer(id)
if err != nil {
return nil, nil, err
@@ -220,21 +221,19 @@ func (d *SqliteRepository) renewCustomer(id models.CustomerId) ([]uint64, []uint
if err != nil {
return nil, nil, err
}
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.RenewCustomerParams)
if !ok {
return fmt.Errorf("invalid argument type: expected RenewCustomerParams")
return nil, fmt.Errorf("invalid argument type: expected RenewCustomerParams")
}
return q.RenewCustomer(ctx, params)
return nil, q.RenewCustomer(ctx, params)
}
params := sqlc.RenewCustomerParams{
AttributeValues: security.Uint64ArrToByteArr(customer.Attributes.AttrVals),
SetValues: security.Uint64ArrToByteArr(customer.Attributes.SetVals),
ID: uuid.UUID(customer.Id).String(),
ID: uuid.UUID(customer.ID).String(),
}
if err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
if _, err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
return nil, nil, err
}
return setXor, attrXor, nil
@@ -244,12 +243,12 @@ func (d *SqliteRepository) RefreshUserPasscode(user entities.User, passcodeIdx [
if err := user.RefreshPasscode(passcodeIdx, customerAttr); err != nil {
return err
}
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(sqlc.RefreshUserPasscodeParams)
if !ok {
return fmt.Errorf("invalid argument type: expected RefreshUserPasscodeParams")
return nil, fmt.Errorf("invalid argument type: expected RefreshUserPasscodeParams")
}
return q.RefreshUserPasscode(ctx, params)
return nil, q.RefreshUserPasscode(ctx, params)
}
params := sqlc.RefreshUserPasscodeParams{
Renew: 0,
@@ -262,17 +261,17 @@ func (d *SqliteRepository) RefreshUserPasscode(user entities.User, passcodeIdx [
Salt: user.CipherKeys.Salt,
ID: uuid.UUID(user.Id).String(),
}
return d.Queue.EnqueueWriteTx(queryFunc, params)
_, err := d.Queue.EnqueueWriteTx(queryFunc, params)
return err
}
func (d *SqliteRepository) GetCustomer(id models.CustomerId) (*entities.Customer, error) {
func (d *SqliteRepository) GetCustomer(id models.CustomerID) (*entities.Customer, error) {
customer, err := d.Queue.Queries.GetCustomer(d.ctx, uuid.UUID(id).String())
if err != nil {
return nil, err
}
return &entities.Customer{
Id: id,
ID: id,
NKodePolicy: models.NKodePolicy{
MaxNkodeLen: int(customer.MaxNkodeLen),
MinNkodeLen: int(customer.MinNkodeLen),
@@ -285,7 +284,7 @@ func (d *SqliteRepository) GetCustomer(id models.CustomerId) (*entities.Customer
}, nil
}
func (d *SqliteRepository) GetUser(email models.UserEmail, customerId models.CustomerId) (*entities.User, error) {
func (d *SqliteRepository) GetUser(email models.UserEmail, customerId models.CustomerID) (*entities.User, error) {
userRow, err := d.Queue.Queries.GetUser(d.ctx, sqlc.GetUserParams{
Email: string(email),
CustomerID: uuid.UUID(customerId).String(),
@@ -296,12 +295,10 @@ func (d *SqliteRepository) GetUser(email models.UserEmail, customerId models.Cus
}
return nil, fmt.Errorf("failed to get user: %w", err)
}
kp := entities.KeypadDimension{
AttrsPerKey: int(userRow.AttributesPerKey),
NumbOfKeys: int(userRow.NumberOfKeys),
}
renew := false
if userRow.Renew == 1 {
renew = true
@@ -351,6 +348,25 @@ func (d *SqliteRepository) GetSvgStringInterface(idxs models.SvgIdInterface) ([]
return d.getSvgsById(idxs)
}
func (d *SqliteRepository) AddSVGIcon(svgStr string) (int64, error) {
queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) (any, error) {
params, ok := args.(string)
if !ok {
return nil, fmt.Errorf("invalid argument type: expected string")
}
return q.AddSVGIcon(ctx, params)
}
svgID, err := d.Queue.EnqueueWriteTx(queryFunc, svgStr)
if err != nil {
return -1, err
}
svgIDInt64, ok := svgID.(int64)
if !ok {
return -1, errors.New("svgID in DB isn't int64")
}
return svgIDInt64, nil
}
func (d *SqliteRepository) getSvgsById(ids []int) ([]string, error) {
svgs := make([]string, len(ids))
for idx, id := range ids {

10
internal/repository/sqlite_repository_test.go
View File

@@ -17,12 +17,12 @@ func TestNewSqliteDB(t *testing.T) {
sqliteDb, err := sqlite_queue.OpenSqliteDb(dbPath)
assert.NoError(t, err)
queue, err := sqlite_queue.NewQueue(sqliteDb, ctx)
queue, err := sqlite_queue.NewQueue(ctx, sqliteDb)
assert.NoError(t, err)
queue.Start()
defer queue.Stop()
db := NewSqliteRepository(queue, ctx)
db := NewSqliteRepository(ctx, queue)
assert.NoError(t, err)
testSignupLoginRenew(t, &db)
testSqliteDBRandomSvgInterface(t, &db)
@@ -34,7 +34,7 @@ func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) {
assert.NoError(t, err)
err = db.CreateCustomer(*customerOrig)
assert.NoError(t, err)
customer, err := db.GetCustomer(customerOrig.Id)
customer, err := db.GetCustomer(customerOrig.ID)
assert.NoError(t, err)
assert.Equal(t, customerOrig, customer)
username := "test_user@example.com"
@@ -47,11 +47,11 @@ func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) {
assert.NoError(t, err)
err = db.WriteNewUser(*userOrig)
assert.NoError(t, err)
user, err := db.GetUser(models.UserEmail(username), customer.Id)
user, err := db.GetUser(models.UserEmail(username), customer.ID)
assert.NoError(t, err)
assert.Equal(t, userOrig, user)
err = db.Renew(customer.Id)
err = db.Renew(customer.ID)
assert.NoError(t, err)
}

13
internal/sqlc/query.sql.go
View File

@@ -10,6 +10,19 @@ import (
"database/sql"
)
const addSVGIcon = `-- name: AddSVGIcon :one
INSERT INTO svg_icon (svg)
VALUES (?)
RETURNING id
`
func (q *Queries) AddSVGIcon(ctx context.Context, svg string) (int64, error) {
row := q.db.QueryRowContext(ctx, addSVGIcon, svg)
var id int64
err := row.Scan(&id)
return id, err
}
const createCustomer = `-- name: CreateCustomer :exec
INSERT INTO customer (
id

36
internal/sqlc/sqlite_queue.go
View File

@@ -10,12 +10,13 @@ import (
const writeBufferSize = 100
type SqlcGeneric func(*Queries, context.Context, any) error
type GenericQuery func(*Queries, context.Context, any) (any, error)
type WriteTx struct {
ErrChan chan error
Query SqlcGeneric
Args interface{}
ErrChan chan error
ReturnChan chan any
Query GenericQuery
Args any
}
type Queue struct {
@@ -27,7 +28,7 @@ type Queue struct {
cancel context.CancelFunc
}
func NewQueue(sqlDb *sql.DB, ctx context.Context) (*Queue, error) {
func NewQueue(ctx context.Context, sqlDb *sql.DB) (*Queue, error) {
ctx, cancel := context.WithCancel(context.Background())
sqldb := &Queue{
Queries: New(sqlDb),
@@ -42,15 +43,19 @@ func NewQueue(sqlDb *sql.DB, ctx context.Context) (*Queue, error) {
func (d *Queue) Start() {
d.wg.Add(1)
defer d.wg.Done()
go func() {
// TODO: I think this might be a naive approach.
defer d.wg.Done()
for {
select {
case <-d.ctx.Done():
return
case writeTx := <-d.WriteQueue:
err := writeTx.Query(d.Queries, d.ctx, writeTx.Args)
ret, err := writeTx.Query(d.Queries, d.ctx, writeTx.Args)
writeTx.ErrChan <- err
writeTx.ReturnChan <- ret
close(writeTx.ErrChan)
close(writeTx.ReturnChan)
}
}
}()
@@ -63,21 +68,24 @@ func (d *Queue) Stop() error {
return d.Db.Close()
}
func (d *Queue) EnqueueWriteTx(queryFunc SqlcGeneric, args any) error {
func (d *Queue) EnqueueWriteTx(queryFunc GenericQuery, args any) (any, error) {
select {
case <-d.ctx.Done():
return errors.New("database is shutting down")
return nil, errors.New("database is shutting down")
default:
}
errChan := make(chan error, 1)
retChan := make(chan any, 1)
writeTx := WriteTx{
Query: queryFunc,
Args: args,
ErrChan: errChan,
Query: queryFunc,
Args: args,
ErrChan: errChan,
ReturnChan: retChan,
}
d.WriteQueue <- writeTx
return <-errChan
err := <-errChan
val := <-retChan
return val, err
}
func OpenSqliteDb(dbPath string) (*sql.DB, error) {