refactor nkode-core

internal/api/handler.go

@@ -5,16 +5,17 @@ import (
 	"errors"
 	"github.com/google/uuid"
 	"go-nkode/config"
-	"go-nkode/internal/entities"
 	"go-nkode/internal/models"
-	"go-nkode/internal/security"
+	"go-nkode/pkg/nkode-core/api"
+	"go-nkode/pkg/nkode-core/entities"
+	"go-nkode/pkg/nkode-core/security"
 	"log"
 	"net/http"
 	"strings"
 )
 
 type NKodeHandler struct {
-	Api NKodeAPI
+	Api api.NKodeAPI
 }
 
 const (
@@ -122,12 +123,12 @@ func (h *NKodeHandler) GenerateSignupResetInterfaceHandler(w http.ResponseWriter
 		badRequest(w, malformedCustomerId)
 		return
 	}
-	userEmail, err := models.ParseEmail(signupResetPost.UserEmail)
+	userEmail, err := entities.ParseEmail(signupResetPost.UserEmail)
 	if err != nil {
 		badRequest(w, malformedUserEmail)
 		return
 	}
-	resp, err := h.Api.GenerateSignupResetInterface(userEmail, models.CustomerId(customerId), kp, signupResetPost.Reset)
+	resp, err := h.Api.GenerateSignupResetInterface(userEmail, entities.CustomerId(customerId), kp, signupResetPost.Reset)
 	if err != nil {
 		handleError(w, err)
 		return
@@ -156,7 +157,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(entities.CustomerId(customerId), entities.SessionId(sessionId), setNKodePost.KeySelection)
 	if err != nil {
 		handleError(w, err)
 		return
@@ -186,7 +187,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(entities.CustomerId(customerId), entities.SessionId(sessionId), confirmNKodePost.KeySelection); err != nil {
 		handleError(w, err)
 		return
 	}
@@ -208,11 +209,11 @@ func (h *NKodeHandler) GetLoginInterfaceHandler(w http.ResponseWriter, r *http.R
 		badRequest(w, malformedCustomerId)
 		return
 	}
-	userEmail, err := models.ParseEmail(loginInterfacePost.UserEmail)
+	userEmail, err := entities.ParseEmail(loginInterfacePost.UserEmail)
 	if err != nil {
 		badRequest(w, malformedUserEmail)
 	}
-	loginInterface, err := h.Api.GetLoginInterface(userEmail, models.CustomerId(customerId))
+	loginInterface, err := h.Api.GetLoginInterface(userEmail, entities.CustomerId(customerId))
 	if err != nil {
 		handleError(w, err)
 		return
@@ -236,12 +237,12 @@ func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
 		badRequest(w, malformedCustomerId)
 		return
 	}
-	userEmail, err := models.ParseEmail(loginPost.UserEmail)
+	userEmail, err := entities.ParseEmail(loginPost.UserEmail)
 	if err != nil {
 		badRequest(w, malformedUserEmail)
 		return
 	}
-	jwtTokens, err := h.Api.Login(models.CustomerId(customerId), userEmail, loginPost.KeySelection)
+	jwtTokens, err := h.Api.Login(entities.CustomerId(customerId), userEmail, loginPost.KeySelection)
 	if err != nil {
 		handleError(w, err)
 		return
@@ -265,7 +266,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(entities.CustomerId(customerId)); err != nil {
 		handleError(w, err)
 		return
 	}
@@ -286,7 +287,7 @@ func (h *NKodeHandler) RandomSvgInterfaceHandler(w http.ResponseWriter, r *http.
 
 	respBody := models.RandomSvgInterfaceResp{
 		Svgs:   svgs,
-		Colors: models.SetColors,
+		Colors: entities.SetColors,
 	}
 
 	marshalAndWriteBytes(w, respBody)
@@ -308,13 +309,13 @@ func (h *NKodeHandler) RefreshTokenHandler(w http.ResponseWriter, r *http.Reques
 		badRequest(w, malformedCustomerId)
 		return
 	}
-	userEmail, err := models.ParseEmail(refreshClaims.Subject)
+	userEmail, err := entities.ParseEmail(refreshClaims.Subject)
 	if err != nil {
 		badRequest(w, malformedUserEmail)
 		log.Println(err)
 		return
 	}
-	accessToken, err := h.Api.RefreshToken(userEmail, models.CustomerId(customerId), refreshToken)
+	accessToken, err := h.Api.RefreshToken(userEmail, entities.CustomerId(customerId), refreshToken)
 
 	if err != nil {
 		handleError(w, err)
@@ -340,13 +341,13 @@ func (h *NKodeHandler) ResetNKode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	userEmail, err := models.ParseEmail(resetNKodePost.UserEmail)
+	userEmail, err := entities.ParseEmail(resetNKodePost.UserEmail)
 	if err != nil {
 		badRequest(w, malformedUserEmail)
 		return
 	}
 
-	if err = h.Api.ResetNKode(userEmail, models.CustomerId(customerId)); err != nil {
+	if err = h.Api.ResetNKode(userEmail, entities.CustomerId(customerId)); err != nil {
 		internalServerError(w)
 		log.Println(err)
 		return

internal/api/nkode_api.go

@@ -1,268 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"github.com/google/uuid"
-	"github.com/patrickmn/go-cache"
-	"go-nkode/config"
-	"go-nkode/internal/email"
-	"go-nkode/internal/entities"
-	"go-nkode/internal/models"
-	"go-nkode/internal/repository"
-	"go-nkode/internal/security"
-	"log"
-	"os"
-	"time"
-)
-
-const (
-	sessionExpiration      = 5 * time.Minute
-	sessionCleanupInterval = 10 * time.Minute
-)
-
-type NKodeAPI struct {
-	Db                 repository.CustomerUserRepository
-	SignupSessionCache *cache.Cache
-	EmailQueue         *email.Queue
-}
-
-func NewNKodeAPI(db repository.CustomerUserRepository, queue *email.Queue) NKodeAPI {
-	return NKodeAPI{
-		Db:                 db,
-		EmailQueue:         queue,
-		SignupSessionCache: cache.New(sessionExpiration, sessionCleanupInterval),
-	}
-}
-
-func (n *NKodeAPI) CreateNewCustomer(nkodePolicy models.NKodePolicy, id *models.CustomerId) (*models.CustomerId, error) {
-	newCustomer, err := entities.NewCustomer(nkodePolicy)
-	if id != nil {
-		newCustomer.Id = *id
-	}
-	if err != nil {
-		return nil, err
-	}
-	err = n.Db.CreateCustomer(*newCustomer)
-
-	if err != nil {
-		return nil, err
-	}
-	return &newCustomer.Id, nil
-}
-
-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
-	}
-	if user != nil && !reset {
-		log.Printf("user %s already exists", string(userEmail))
-		return nil, config.ErrUserAlreadyExists
-	}
-	svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
-	if err != nil {
-		return nil, err
-	}
-	signupSession, err := entities.NewSignupResetSession(userEmail, kp, customerId, svgIdxInterface, reset)
-	if err != nil {
-		return nil, err
-	}
-	//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
-	}
-	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
-	}
-	session, exists := n.SignupSessionCache.Get(sessionId.String())
-	if !exists {
-		log.Printf("session id does not exist %s", sessionId)
-		return nil, config.ErrSignupSessionDNE
-	}
-	userSession, ok := session.(entities.UserSignSession)
-	if !ok {
-		// handle the case where the type assertion fails
-		return nil, config.ErrSignupSessionDNE
-	}
-	confirmInterface, err := userSession.SetUserNKode(keySelection)
-	if err != nil {
-		return nil, err
-	}
-	n.SignupSessionCache.Set(sessionId.String(), userSession, sessionExpiration)
-	return confirmInterface, nil
-}
-
-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)
-		return config.ErrSignupSessionDNE
-	}
-	userSession, ok := session.(entities.UserSignSession)
-	if !ok {
-		// handle the case where the type assertion fails
-		return config.ErrSignupSessionDNE
-	}
-	customer, err := n.Db.GetCustomer(customerId)
-	if err != nil {
-		return err
-	}
-	passcode, err := userSession.DeducePasscode(keySelection)
-	if err != nil {
-		return err
-	}
-	if err = customer.IsValidNKode(userSession.Kp, passcode); err != nil {
-		return err
-	}
-	user, err := entities.NewUser(*customer, string(userSession.UserEmail), passcode, userSession.LoginUserInterface, userSession.Kp)
-	if err != nil {
-		return err
-	}
-	if userSession.Reset {
-		err = n.Db.UpdateUserNKode(*user)
-	} else {
-		err = n.Db.WriteNewUser(*user)
-	}
-	n.SignupSessionCache.Delete(userSession.Id.String())
-	return err
-}
-
-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
-	}
-	if user == nil {
-		log.Printf("user %s for customer %s dne", userEmail, customerId)
-		return nil, config.ErrUserForCustomerDNE
-	}
-	svgInterface, err := n.Db.GetSvgStringInterface(user.Interface.SvgId)
-	if err != nil {
-		return nil, err
-	}
-	resp := models.GetLoginInterfaceResp{
-		UserIdxInterface: user.Interface.IdxInterface,
-		SvgInterface:     svgInterface,
-		NumbOfKeys:       user.Kp.NumbOfKeys,
-		AttrsPerKey:      user.Kp.AttrsPerKey,
-		Colors:           models.SetColors,
-	}
-	return &resp, nil
-}
-
-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
-	}
-	user, err := n.Db.GetUser(userEmail, customerId)
-	if err != nil {
-		return nil, err
-	}
-	if user == nil {
-		log.Printf("user %s for customer %s dne", userEmail, customerId)
-		return nil, config.ErrUserForCustomerDNE
-	}
-	passcode, err := entities.ValidKeyEntry(*user, *customer, keySelection)
-	if err != nil {
-		return nil, err
-	}
-
-	if user.Renew {
-		err = n.Db.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 {
-		return nil, err
-	}
-	if err = user.Interface.LoginShuffle(); err != nil {
-		return nil, err
-	}
-	if err = n.Db.UpdateUserInterface(user.Id, user.Interface); err != nil {
-		return nil, err
-	}
-	return &jwtToken, nil
-}
-
-func (n *NKodeAPI) RenewAttributes(customerId models.CustomerId) error {
-	return n.Db.Renew(customerId)
-}
-
-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) {
-	user, err := n.Db.GetUser(userEmail, customerId)
-	if err != nil {
-		return "", err
-	}
-	if user == nil {
-		log.Printf("user %s for customer %s dne", userEmail, customerId)
-		return "", config.ErrUserForCustomerDNE
-	}
-	if user.RefreshToken != refreshToken {
-		return "", config.ErrRefreshTokenInvalid
-	}
-	refreshClaims, err := security.ParseRegisteredClaimToken(refreshToken)
-	if err != nil {
-		return "", err
-	}
-	if err = security.ClaimExpired(*refreshClaims); err != nil {
-		return "", err
-	}
-	newAccessClaims := security.NewAccessClaim(string(userEmail), uuid.UUID(customerId))
-	return security.EncodeAndSignClaims(newAccessClaims)
-}
-
-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
-	}
-	frontendHost := os.Getenv("FRONTEND_HOST")
-	if frontendHost == "" {
-		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{
-		Sender:    "no-reply@nkode.tech",
-		Recipient: string(userEmail),
-		Subject:   "nKode Reset",
-		Content:   htmlBody,
-	}
-	n.EmailQueue.AddEmail(email)
-	return nil
-}

internal/api/nkode_api_test.go

@@ -1,125 +0,0 @@
-package api
-
-import (
-	"context"
-	"github.com/stretchr/testify/assert"
-	"go-nkode/internal/email"
-	"go-nkode/internal/entities"
-	"go-nkode/internal/models"
-	"go-nkode/internal/repository"
-	"go-nkode/internal/security"
-	sqlite_queue "go-nkode/internal/sqlc"
-	"log"
-	"os"
-	"testing"
-)
-
-func TestNKodeAPI(t *testing.T) {
-	//db1 := NewInMemoryDb()
-	//testNKodeAPI(t, &db1)
-
-	dbPath := os.Getenv("TEST_DB")
-	ctx := context.Background()
-	sqliteDb, err := sqlite_queue.OpenSqliteDb(dbPath)
-	assert.NoError(t, err)
-
-	queue, err := sqlite_queue.NewQueue(sqliteDb, ctx)
-	assert.NoError(t, err)
-	queue.Start()
-	defer func(queue *sqlite_queue.Queue) {
-		if err := queue.Stop(); err != nil {
-			log.Fatal(err)
-		}
-	}(queue)
-	sqlitedb := repository.NewSqliteRepository(queue, ctx)
-	testNKodeAPI(t, &sqlitedb)
-
-	//if _, err := os.Stat(dbPath); err == nil {
-	//	err = os.Remove(dbPath)
-	//	assert.NoError(t, err)
-	//} else {
-	//	assert.NoError(t, err)
-	//}
-}
-
-func testNKodeAPI(t *testing.T, db repository.CustomerUserRepository) {
-	bufferSize := 100
-	emailsPerSec := 14
-	testClient := email.TestEmailClient{}
-	queue := email.NewEmailQueue(bufferSize, emailsPerSec, &testClient)
-	queue.Start()
-	defer queue.Stop()
-	attrsPerKey := 5
-	numbOfKeys := 4
-	for idx := 0; idx < 1; idx++ {
-		userEmail := models.UserEmail("test_username" + security.GenerateRandomString(12) + "@example.com")
-		passcodeLen := 4
-		nkodePolicy := models.NewDefaultNKodePolicy()
-		keypadSize := entities.KeypadDimension{AttrsPerKey: attrsPerKey, NumbOfKeys: numbOfKeys}
-		nkodeApi := NewNKodeAPI(db, queue)
-		customerId, err := nkodeApi.CreateNewCustomer(nkodePolicy, nil)
-		assert.NoError(t, err)
-		signupResponse, err := nkodeApi.GenerateSignupResetInterface(userEmail, *customerId, keypadSize, false)
-		assert.NoError(t, err)
-		setInterface := signupResponse.UserIdxInterface
-		sessionIdStr := signupResponse.SessionId
-		sessionId, err := models.SessionIdFromString(sessionIdStr)
-		assert.NoError(t, err)
-		keypadSize = entities.KeypadDimension{AttrsPerKey: numbOfKeys, NumbOfKeys: numbOfKeys}
-		userPasscode := setInterface[:passcodeLen]
-		setKeySelect, err := entities.SelectKeyByAttrIdx(setInterface, userPasscode, keypadSize)
-		assert.NoError(t, err)
-		confirmInterface, err := nkodeApi.SetNKode(*customerId, sessionId, setKeySelect)
-		assert.NoError(t, err)
-		confirmKeySelect, err := entities.SelectKeyByAttrIdx(confirmInterface, userPasscode, keypadSize)
-		err = nkodeApi.ConfirmNKode(*customerId, sessionId, confirmKeySelect)
-		assert.NoError(t, err)
-
-		keypadSize = entities.KeypadDimension{AttrsPerKey: attrsPerKey, NumbOfKeys: numbOfKeys}
-		loginInterface, err := nkodeApi.GetLoginInterface(userEmail, *customerId)
-		assert.NoError(t, err)
-		loginKeySelection, err := entities.SelectKeyByAttrIdx(loginInterface.UserIdxInterface, userPasscode, keypadSize)
-		assert.NoError(t, err)
-		_, err = nkodeApi.Login(*customerId, userEmail, loginKeySelection)
-		assert.NoError(t, err)
-
-		err = nkodeApi.RenewAttributes(*customerId)
-		assert.NoError(t, err)
-
-		loginInterface, err = nkodeApi.GetLoginInterface(userEmail, *customerId)
-		assert.NoError(t, err)
-		loginKeySelection, err = entities.SelectKeyByAttrIdx(loginInterface.UserIdxInterface, userPasscode, keypadSize)
-		assert.NoError(t, err)
-		_, err = nkodeApi.Login(*customerId, userEmail, loginKeySelection)
-		assert.NoError(t, err)
-
-		/// Reset nKode
-		attrsPerKey = 6
-		keypadSize = entities.KeypadDimension{AttrsPerKey: attrsPerKey, NumbOfKeys: numbOfKeys}
-		resetResponse, err := nkodeApi.GenerateSignupResetInterface(userEmail, *customerId, keypadSize, true)
-		assert.NoError(t, err)
-		setInterface = resetResponse.UserIdxInterface
-		sessionIdStr = resetResponse.SessionId
-		sessionId, err = models.SessionIdFromString(sessionIdStr)
-		assert.NoError(t, err)
-		keypadSize = entities.KeypadDimension{AttrsPerKey: numbOfKeys, NumbOfKeys: numbOfKeys}
-		userPasscode = setInterface[:passcodeLen]
-		setKeySelect, err = entities.SelectKeyByAttrIdx(setInterface, userPasscode, keypadSize)
-		assert.NoError(t, err)
-		confirmInterface, err = nkodeApi.SetNKode(*customerId, sessionId, setKeySelect)
-		assert.NoError(t, err)
-		confirmKeySelect, err = entities.SelectKeyByAttrIdx(confirmInterface, userPasscode, keypadSize)
-		err = nkodeApi.ConfirmNKode(*customerId, sessionId, confirmKeySelect)
-		assert.NoError(t, err)
-
-		keypadSize = entities.KeypadDimension{AttrsPerKey: attrsPerKey, NumbOfKeys: numbOfKeys}
-		loginInterface2, err := nkodeApi.GetLoginInterface(userEmail, *customerId)
-		assert.NoError(t, err)
-		loginKeySelection, err = entities.SelectKeyByAttrIdx(loginInterface2.UserIdxInterface, userPasscode, keypadSize)
-		assert.NoError(t, err)
-		_, err = nkodeApi.Login(*customerId, userEmail, loginKeySelection)
-		assert.NoError(t, err)
-		signupResponse, err = nkodeApi.GenerateSignupResetInterface(userEmail, *customerId, keypadSize, false)
-		assert.Error(t, err)
-	}
-}