refactor sqlite repository

api/nkode_api.go

@@ -20,16 +20,16 @@ const (
 )
 
 type NKodeAPI struct {
-	Db                 repository.CustomerUserRepository
-	SignupSessionCache *cache.Cache
-	EmailQueue         *email.Queue
+	repo               repository.CustomerUserRepository
+	signupSessionCache *cache.Cache
+	emailQueue         *email.Queue
 }
 
-func NewNKodeAPI(db repository.CustomerUserRepository, queue *email.Queue) NKodeAPI {
+func NewNKodeAPI(repo repository.CustomerUserRepository, queue *email.Queue) NKodeAPI {
 	return NKodeAPI{
-		Db:                 db,
-		EmailQueue:         queue,
-		SignupSessionCache: cache.New(sessionExpiration, sessionCleanupInterval),
+		repo:               repo,
+		emailQueue:         queue,
+		signupSessionCache: cache.New(sessionExpiration, sessionCleanupInterval),
 	}
 }
 
@@ -41,7 +41,7 @@ func (n *NKodeAPI) CreateNewCustomer(nkodePolicy entities.NKodePolicy, id *entit
 	if err != nil {
 		return nil, err
 	}
-	err = n.Db.CreateCustomer(*newCustomer)
+	err = n.repo.CreateCustomer(*newCustomer)
 
 	if err != nil {
 		return nil, err
@@ -50,7 +50,7 @@ func (n *NKodeAPI) CreateNewCustomer(nkodePolicy entities.NKodePolicy, id *entit
 }
 
 func (n *NKodeAPI) GenerateSignupResetInterface(userEmail entities.UserEmail, customerId entities.CustomerId, kp entities.KeypadDimension, reset bool) (*entities.SignupResetInterface, error) {
-	user, err := n.Db.GetUser(userEmail, customerId)
+	user, err := n.repo.GetUser(userEmail, customerId)
 	if err != nil {
 		return nil, err
 	}
@@ -58,7 +58,7 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail entities.UserEmail, cu
 		log.Printf("user %s already exists", string(userEmail))
 		return nil, config.ErrUserAlreadyExists
 	}
-	svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
+	svgIdxInterface, err := n.repo.RandomSvgIdxInterface(kp)
 	if err != nil {
 		return nil, err
 	}
@@ -66,10 +66,10 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail entities.UserEmail, cu
 	if err != nil {
 		return nil, err
 	}
-	if err := n.SignupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
+	if err := n.signupSessionCache.Add(signupSession.Id.String(), *signupSession, sessionExpiration); err != nil {
 		return nil, err
 	}
-	svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
+	svgInterface, err := n.repo.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
 
 	if err != nil {
 		return nil, err
@@ -84,12 +84,12 @@ func (n *NKodeAPI) GenerateSignupResetInterface(userEmail entities.UserEmail, cu
 }
 
 func (n *NKodeAPI) SetNKode(customerId entities.CustomerId, sessionId entities.SessionId, keySelection entities.KeySelection) (entities.IdxInterface, error) {
-	_, err := n.Db.GetCustomer(customerId)
+	_, err := n.repo.GetCustomer(customerId)
 
 	if err != nil {
 		return nil, err
 	}
-	session, exists := n.SignupSessionCache.Get(sessionId.String())
+	session, exists := n.signupSessionCache.Get(sessionId.String())
 	if !exists {
 		log.Printf("session id does not exist %s", sessionId)
 		return nil, config.ErrSignupSessionDNE
@@ -103,12 +103,12 @@ func (n *NKodeAPI) SetNKode(customerId entities.CustomerId, sessionId entities.S
 	if err != nil {
 		return nil, err
 	}
-	n.SignupSessionCache.Set(sessionId.String(), userSession, sessionExpiration)
+	n.signupSessionCache.Set(sessionId.String(), userSession, sessionExpiration)
 	return confirmInterface, nil
 }
 
 func (n *NKodeAPI) ConfirmNKode(customerId entities.CustomerId, sessionId entities.SessionId, keySelection entities.KeySelection) error {
-	session, exists := n.SignupSessionCache.Get(sessionId.String())
+	session, exists := n.signupSessionCache.Get(sessionId.String())
 	if !exists {
 		log.Printf("session id does not exist %s", sessionId)
 		return config.ErrSignupSessionDNE
@@ -118,7 +118,7 @@ func (n *NKodeAPI) ConfirmNKode(customerId entities.CustomerId, sessionId entiti
 		// handle the case where the type assertion fails
 		return config.ErrSignupSessionDNE
 	}
-	customer, err := n.Db.GetCustomer(customerId)
+	customer, err := n.repo.GetCustomer(customerId)
 	if err != nil {
 		return err
 	}
@@ -134,16 +134,16 @@ func (n *NKodeAPI) ConfirmNKode(customerId entities.CustomerId, sessionId entiti
 		return err
 	}
 	if userSession.Reset {
-		err = n.Db.UpdateUserNKode(*user)
+		err = n.repo.UpdateUserNKode(*user)
 	} else {
-		err = n.Db.WriteNewUser(*user)
+		err = n.repo.WriteNewUser(*user)
 	}
-	n.SignupSessionCache.Delete(userSession.Id.String())
+	n.signupSessionCache.Delete(userSession.Id.String())
 	return err
 }
 
 func (n *NKodeAPI) GetLoginInterface(userEmail entities.UserEmail, customerId entities.CustomerId) (*entities.LoginInterface, error) {
-	user, err := n.Db.GetUser(userEmail, customerId)
+	user, err := n.repo.GetUser(userEmail, customerId)
 	if err != nil {
 		return nil, err
 	}
@@ -151,7 +151,7 @@ func (n *NKodeAPI) GetLoginInterface(userEmail entities.UserEmail, customerId en
 		log.Printf("user %s for customer %s dne", userEmail, customerId)
 		return nil, config.ErrUserForCustomerDNE
 	}
-	svgInterface, err := n.Db.GetSvgStringInterface(user.Interface.SvgId)
+	svgInterface, err := n.repo.GetSvgStringInterface(user.Interface.SvgId)
 	if err != nil {
 		return nil, err
 	}
@@ -166,11 +166,11 @@ func (n *NKodeAPI) GetLoginInterface(userEmail entities.UserEmail, customerId en
 }
 
 func (n *NKodeAPI) Login(customerId entities.CustomerId, userEmail entities.UserEmail, keySelection entities.KeySelection) (*security.AuthenticationTokens, error) {
-	customer, err := n.Db.GetCustomer(customerId)
+	customer, err := n.repo.GetCustomer(customerId)
 	if err != nil {
 		return nil, err
 	}
-	user, err := n.Db.GetUser(userEmail, customerId)
+	user, err := n.repo.GetUser(userEmail, customerId)
 	if err != nil {
 		return nil, err
 	}
@@ -184,37 +184,38 @@ func (n *NKodeAPI) Login(customerId entities.CustomerId, userEmail entities.User
 	}
 
 	if user.Renew {
-		err = n.Db.RefreshUserPasscode(*user, passcode, customer.Attributes)
+		err = n.repo.RefreshUserPasscode(*user, passcode, customer.Attributes)
 		if err != nil {
 			return nil, err
 		}
 	}
+
 	jwtToken, err := security.NewAuthenticationTokens(string(user.Email), uuid.UUID(customerId))
 	if err != nil {
 		return nil, err
 	}
-	if err = n.Db.UpdateUserRefreshToken(user.Id, jwtToken.RefreshToken); err != nil {
+	if err = n.repo.UpdateUserRefreshToken(user.Id, jwtToken.RefreshToken); err != nil {
 		return nil, err
 	}
 	if err = user.Interface.LoginShuffle(); err != nil {
 		return nil, err
 	}
-	if err = n.Db.UpdateUserInterface(user.Id, user.Interface); err != nil {
+	if err = n.repo.UpdateUserInterface(user.Id, user.Interface); err != nil {
 		return nil, err
 	}
 	return &jwtToken, nil
 }
 
 func (n *NKodeAPI) RenewAttributes(customerId entities.CustomerId) error {
-	return n.Db.Renew(customerId)
+	return n.repo.Renew(customerId)
 }
 
 func (n *NKodeAPI) RandomSvgInterface() ([]string, error) {
-	return n.Db.RandomSvgInterface(entities.KeypadMax)
+	return n.repo.RandomSvgInterface(entities.KeypadMax)
 }
 
 func (n *NKodeAPI) RefreshToken(userEmail entities.UserEmail, customerId entities.CustomerId, refreshToken string) (string, error) {
-	user, err := n.Db.GetUser(userEmail, customerId)
+	user, err := n.repo.GetUser(userEmail, customerId)
 	if err != nil {
 		return "", err
 	}
@@ -237,7 +238,7 @@ func (n *NKodeAPI) RefreshToken(userEmail entities.UserEmail, customerId entitie
 }
 
 func (n *NKodeAPI) ResetNKode(userEmail entities.UserEmail, customerId entities.CustomerId) error {
-	user, err := n.Db.GetUser(userEmail, customerId)
+	user, err := n.repo.GetUser(userEmail, customerId)
 	if err != nil {
 		return fmt.Errorf("error getting user in rest nkode %v", err)
 	}
@@ -261,6 +262,6 @@ func (n *NKodeAPI) ResetNKode(userEmail entities.UserEmail, customerId entities.
 		Subject:   "nKode Reset",
 		Content:   htmlBody,
 	}
-	n.EmailQueue.AddEmail(email)
+	n.emailQueue.AddEmail(email)
 	return nil
 }

api/nkode_api_test.go

@@ -18,7 +18,7 @@ func TestNKodeAPI(t *testing.T) {
 
 	dbPath := os.Getenv("TEST_DB")
 	ctx := context.Background()
-	sqlitedb, err := repository.NewSqliteRepository(dbPath, ctx)
+	sqlitedb, err := repository.NewSqliteRepository(ctx, dbPath)
 	if err != nil {
 		log.Fatal(err)
 	}

cmd/nkode/nkode.go

@@ -29,7 +29,7 @@ func main() {
 		log.Fatal(err)
 	}
 	ctx := context.Background()
-	sqliteRepo, err := repository.NewSqliteRepository(*dbPath, ctx)
+	sqliteRepo, err := repository.NewSqliteRepository(ctx, *dbPath)
 	sqliteRepo.Start()
 	defer func(sqliteRepo *repository.SqliteRepository) {
 		if err := sqliteRepo.Stop(); err != nil {

repository/sqlite_repository.go

@@ -20,7 +20,7 @@ type SqliteRepository struct {
 	ctx   context.Context
 }
 
-func NewSqliteRepository(dbPath string, ctx context.Context) (*SqliteRepository, error) {
+func NewSqliteRepository(ctx context.Context, dbPath string) (*SqliteRepository, error) {
 	sqliteDb, err := sqlc.OpenSqliteDb(dbPath)
 	if err != nil {
 		return nil, err

repository/sqlite_repository_test.go

@@ -11,7 +11,7 @@ import (
 func TestNewSqliteDB(t *testing.T) {
 	dbPath := os.Getenv("TEST_DB")
 	ctx := context.Background()
-	sqliteDb, err := NewSqliteRepository(dbPath, ctx)
+	sqliteDb, err := NewSqliteRepository(ctx, dbPath)
 	assert.NoError(t, err)
 	sqliteDb.Start()
 	defer func(t *testing.T, sqliteDb *SqliteRepository) {

sqlc/sqlite_queue.go

@@ -10,11 +10,11 @@ import (
 
 const writeBufferSize = 100
 
-type SqlcGeneric func(*Queries, context.Context, any) error
+type GenericQuery func(*Queries, context.Context, any) error
 
 type WriteTx struct {
 	ErrChan chan error
-	Query   SqlcGeneric
+	Query   GenericQuery
 	Args    interface{}
 }
 
@@ -63,7 +63,7 @@ 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) error {
 	select {
 	case <-d.ctx.Done():
 		return errors.New("database is shutting down")