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

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)
}