feature/1120 leverage service authorization (#1188)

* refactor: remove redundant branch trigger for scheduled releases

* refactor: simplify process-compose commands and improve logging

* refactor: remove redundant  command

* refactor: remove unused error variables and simplify database configuration

* feat: introduce task runner for project automation

* refactor: Remove hardcoded action and method from form components

* refactor: move server setup to main.go and add prometheus metrics

* refactor: move index handlers to render handlers

* refactor: improve user identification logic in gateway and vault handlers

* refactor: rename TitleDescription to TitleDesc for consistency

* feat: integrate go-useragent library for enhanced user agent parsing

* feat: enhance initial view rendering based on device type

* feat: Add support for PostgreSQL database

* fix: Use formatPsqlDSN() to properly set PostgreSQL DSN from command flags

* feat: Add PostgreSQL support with fallback to SQLite in NewGormDB

* feat: Add PostgreSQL connection validation with SQLite fallback

* chore: update golang.org/x/crypto dependency to v0.31.0

* feat: add PKL-based configuration initialization

* refactor: improve file naming consistency in cmd/sonrd

* refactor: Improve init-pkl command with safer config file generation and error handling

* fix: add logging for pkl evaluation results

* refactor: Move credential handling to gateway context

* refactor: Migrate session models to gateway package

* refactor: rename models and update User model

* chore: initial commit for address and pubkey functionality

* refactor: move pubkey package to keys package

* refactor: Rename models and add resolver service

* feat: add gRPC clients for bank, DID, DWN, and SVC modules

* refactor: Migrate title and description components from text package to hero package

* refactor: improve file naming conventions

* feat: add user credential validation

* refactor: rename registration handlers and routes for clarity

* <no value>

* refactor: Decouple database and IPFS interactions from server setup

* refactor: Migrate configuration from class-based to TOML-based structure

* refactor: move network configuration files to sonr.net module

* feature/1120-leverage-service-authorization

* fix: correct DID identifier creation function name

* feat: add compressed and uncompressed public keys to keyset

* refactor: move address packages to crypto/address

* feat: implement pubkey verification

* refactor: remove ECDSA-related functions from keyshare and protocol modules

* feat: Implement ECDSA signature serialization

* <no value>

* feat: add vault service for IPFS token storage

* refactor: update ucan codec to use new DID generation method

* refactor: refactor key management and move address parsers to keys package

* refactor: rename key parsers and move to parsers package

* fix: resolved import issues with the new spec

* feat: improve user onboarding experience by updating button text and functionality

* refactor: update point marshaling and unmarshaling methods to use JSON

* refactor: remove unnecessary DID method from PubKey

* refactor: Rename and refactor MPC key generation functions

* test: Add comprehensive test suite for keyshare generation and validation

* test: Fix keyshare role validation and encoding tests

* feat: Update key share role tests with enclave initialization validation

* test(mpc): refactor tests to focus on public API and remove internal role checks

* refactor: Remove unnecessary role check in initKeyEnclave function

* fix: Enforce strict order for validator and user keyshares in enclave initialization

* fix: Update codec_test to match latest codec implementation

* refactor: Update KeyEnclave to use string-based key shares and improve error handling

* fix: Refactor MPC enclave to use string-based encoding and simplify key management

* refactor: Remove redundant keyshare decoding tests in codec_test.go

* fix: Resolve type conversion issues in MPC crypto enclave initialization

* fix: Convert CID to byte slice in addEnclaveIPFS function

* fix: Resolve type conversion and constant definition errors in MPC crypto utils

* refactor: Simplify KeyShare encoding and role handling in MPC codec

* fix: Resolve JSON unmarshaling type mismatch in KeyShare.Message()

* fix: Refactor KeyEnclave to use struct and Enclave interface

* fix: Resolve type and naming conflicts in MPC crypto package

* refactor: Update codec_test.go to use new KeyEnclave struct fields

* refactor: remove keyshare encoding and decoding logic

* refactor: Remove unused JSON marshaling functions for curve points

* fix: Improve signature serialization and deserialization in MPC crypto

This commit addresses several issues with signature handling:
- Fixed signature length to 65 bytes
- Added proper padding for R and S values
- Added nil and zero value checks
- Improved error messages for signature parsing

The changes ensure more robust signature encoding and decoding, preventing potential nil pointer and invalid signature issues.

* fix: Update signature serialization to match protocol test approach

* refactor: Simplify KeyEnclave struct and improve message handling

* fix: Improve signature serialization and verification in MPC crypto module

* refactor: Simplify enclave validation using IsValid method in test

* refactor: Add marshaling and comprehensive tests for KeyEnclave

* feat: Add JSON marshaling support for Point in KeyEnclave

* refactor: Rename KeyEnclave to Enclave and update related functions

* refactor: Update PubKey verification to use SHA3-256 hashing

* test: Add comprehensive tests for DID and PubKey implementations

* refactor: simplify DID key retrieval

* test: refactor CI workflow and remove unused DIDAuth middleware

* The changes look good! The updated workflows will now:

1. Run tests on push to master
2. Bump the version if the commit doesn't already start with 'bump:'
3. Trigger a release workflow automatically with the new version tag
4. Create and publish the release

A few things to note:
- Make sure you have the `peter-evans/repository-dispatch` action installed/available
- The `commitizen-tools/commitizen-action` should output the new tag for this to work
- Ensure your release workflow can handle the repository dispatch event

Would you like me to review or suggest any additional modifications to the workflows?

* ci(github actions): add build stage dependency for tests

* fix(workflow): update workflow to trigger on PR edits

* test: Update unit test dependencies

* ci: Add GoReleaser dry-run check for merge group events

* test: remove unnecessary dependencies between test jobs

* ci: Make race and coverage tests depend on build tests

internal/gateway/context/context.go

@@ -1,33 +1,30 @@
 package context
 
 import (
-	"regexp"
-	"strings"
-
-	"github.com/labstack/echo/v4"
+	"github.com/onsonr/sonr/internal/gateway/models"
 	"github.com/onsonr/sonr/pkg/common"
-	"github.com/onsonr/sonr/pkg/database/sessions"
 	"github.com/segmentio/ksuid"
 )
 
-// InitSession initializes or loads an existing session
-func (s *HTTPContext) InitSession() error {
+// initSession initializes or loads an existing session
+func (s *HTTPContext) initSession() error {
 	sessionID := s.getOrCreateSessionID()
 
 	// Try to load existing session
-	var sess sessions.Session
+	var sess models.Session
 	result := s.db.Where("id = ?", sessionID).First(&sess)
 	if result.Error != nil {
 		// Create new session if not found
-		bn, bv, arch, plat, platVer, model := extractBrowserInfo(s.Context)
-		sess = sessions.Session{
-			ID:               sessionID,
-			BrowserName:      bn,
-			BrowserVersion:   bv,
-			UserArchitecture: arch,
-			Platform:         plat,
-			PlatformVersion:  platVer,
-			DeviceModel:      model,
+		sess = models.Session{
+			ID:             sessionID,
+			BrowserName:    s.GetBrowser(),
+			BrowserVersion: s.GetMajorVersion(),
+			Platform:       s.GetOS(),
+			IsMobile:       s.IsMobile(),
+			IsTablet:       s.IsTablet(),
+			IsDesktop:      s.IsDesktop(),
+			IsBot:          s.IsBot(),
+			IsTV:           s.IsTV(),
 		}
 		if err := s.db.Create(&sess).Error; err != nil {
 			return err
@@ -51,52 +48,3 @@ func (s *HTTPContext) getOrCreateSessionID() string {
 	}
 	return sessionID
 }
-
-func extractBrowserInfo(c echo.Context) (string, string, string, string, string, string) {
-	// Extract all relevant headers
-	browserName := common.HeaderRead(c, common.UserAgent)
-	arch := common.HeaderRead(c, common.Architecture)
-	platform := common.HeaderRead(c, common.Platform)
-	platformVer := common.HeaderRead(c, common.PlatformVersion)
-	model := common.HeaderRead(c, common.Model)
-	fullVersionList := common.HeaderRead(c, common.FullVersionList)
-
-	// Default values if headers are empty
-	if browserName == "" {
-		browserName = "N/A"
-	}
-	if arch == "" {
-		arch = "unknown"
-	}
-	if platform == "" {
-		platform = "unknown"
-	}
-	if platformVer == "" {
-		platformVer = "unknown"
-	}
-	if model == "" {
-		model = "unknown"
-	}
-
-	// Extract browser version from full version list
-	version := "-1"
-	if fullVersionList != "" {
-		entries := strings.Split(strings.TrimSpace(fullVersionList), ",")
-		for _, entry := range entries {
-			entry = strings.TrimSpace(entry)
-			re := regexp.MustCompile(`"([^"]+)";v="([^"]+)"`)
-			matches := re.FindStringSubmatch(entry)
-
-			if len(matches) == 3 {
-				browserName = matches[1]
-				version = matches[2]
-				if browserName != "Not.A/Brand" &&
-					browserName != "Chromium" {
-					break
-				}
-			}
-		}
-	}
-
-	return browserName, version, arch, platform, platformVer, model
-}

internal/gateway/context/middleware.go

@@ -4,17 +4,21 @@ import (
 	"net/http"
 
 	"github.com/labstack/echo/v4"
+	"github.com/medama-io/go-useragent"
+	"github.com/onsonr/sonr/internal/gateway/models"
+	"github.com/onsonr/sonr/internal/gateway/services"
 	config "github.com/onsonr/sonr/pkg/config/hway"
-	"github.com/onsonr/sonr/pkg/database/sessions"
 	"gorm.io/gorm"
 )
 
 // Middleware creates a new session middleware
 func Middleware(db *gorm.DB, env config.Hway) echo.MiddlewareFunc {
+	ua := useragent.NewParser()
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
-			cc := NewHTTPContext(c, db)
-			if err := cc.InitSession(); err != nil {
+			agent := ua.Parse(c.Request().UserAgent())
+			cc := NewHTTPContext(c, db, agent, env.GetSonrGrpcUrl())
+			if err := cc.initSession(); err != nil {
 				return err
 			}
 			return next(cc)
@@ -25,9 +29,12 @@ func Middleware(db *gorm.DB, env config.Hway) echo.MiddlewareFunc {
 // HTTPContext is the context for HTTP endpoints.
 type HTTPContext struct {
 	echo.Context
+	*services.ResolverService
 	db   *gorm.DB
-	sess *sessions.Session
+	sess *models.Session
+	user *models.User
 	env  config.Hway
+	useragent.UserAgent
 }
 
 // Get returns the HTTPContext from the echo context
@@ -40,14 +47,17 @@ func Get(c echo.Context) (*HTTPContext, error) {
 }
 
 // NewHTTPContext creates a new session context
-func NewHTTPContext(c echo.Context, db *gorm.DB) *HTTPContext {
+func NewHTTPContext(c echo.Context, db *gorm.DB, a useragent.UserAgent, grpcAddr string) *HTTPContext {
+	rsv := services.NewResolverService(grpcAddr)
 	return &HTTPContext{
-		Context: c,
-		db:      db,
+		Context:         c,
+		db:              db,
+		ResolverService: rsv,
+		UserAgent:       a,
 	}
 }
 
 // Session returns the current session
-func (s *HTTPContext) Session() *sessions.Session {
+func (s *HTTPContext) Session() *models.Session {
 	return s.sess
 }

internal/gateway/context/session.go

@@ -1,168 +0,0 @@
-package context
-
-import (
-	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/pkg/database/sessions"
-)
-
-// ╭───────────────────────────────────────────────────────╮
-// │                  DB Setter Functions                  │
-// ╰───────────────────────────────────────────────────────╯
-
-// SetUserHandle sets the user handle in the session
-func SetUserHandle(c echo.Context, handle string) error {
-	sess, err := Get(c)
-	if err != nil {
-		return err
-	}
-	sess.Session().UserHandle = handle
-	return sess.db.Save(sess.Session()).Error
-}
-
-// SetFirstName sets the first name in the session
-func SetFirstName(c echo.Context, name string) error {
-	sess, err := Get(c)
-	if err != nil {
-		return err
-	}
-	sess.Session().FirstName = name
-	return sess.db.Save(sess.Session()).Error
-}
-
-// SetLastInitial sets the last initial in the session
-func SetLastInitial(c echo.Context, initial string) error {
-	sess, err := Get(c)
-	if err != nil {
-		return err
-	}
-	sess.Session().LastInitial = initial
-	return sess.db.Save(sess.Session()).Error
-}
-
-// SetVaultAddress sets the vault address in the session
-func SetVaultAddress(c echo.Context, address string) error {
-	sess, err := Get(c)
-	if err != nil {
-		return err
-	}
-	sess.Session().VaultAddress = address
-	return sess.db.Save(sess.Session()).Error
-}
-
-// ╭───────────────────────────────────────────────────────╮
-// │                  DB Getter Functions                  │
-// ╰───────────────────────────────────────────────────────╯
-
-// GetID returns the session ID
-func GetID(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().ID, nil
-}
-
-// GetBrowserName returns the browser name
-func GetBrowserName(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().BrowserName, nil
-}
-
-// GetBrowserVersion returns the browser version
-func GetBrowserVersion(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().BrowserVersion, nil
-}
-
-// GetUserArchitecture returns the user architecture
-func GetUserArchitecture(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().UserArchitecture, nil
-}
-
-// GetPlatform returns the platform
-func GetPlatform(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().Platform, nil
-}
-
-// GetPlatformVersion returns the platform version
-func GetPlatformVersion(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().PlatformVersion, nil
-}
-
-// GetDeviceModel returns the device model
-func GetDeviceModel(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().DeviceModel, nil
-}
-
-// GetUserHandle returns the user handle
-func GetUserHandle(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().UserHandle, nil
-}
-
-// GetFirstName returns the first name
-func GetFirstName(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().FirstName, nil
-}
-
-// GetLastInitial returns the last initial
-func GetLastInitial(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().LastInitial, nil
-}
-
-// GetVaultAddress returns the vault address
-func GetVaultAddress(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().VaultAddress, nil
-}
-
-// HandleExists checks if a handle already exists in any session
-func HandleExists(c echo.Context, handle string) (bool, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return false, err
-	}
-
-	var count int64
-	if err := sess.db.Model(&sessions.Session{}).Where("user_handle = ?", handle).Count(&count).Error; err != nil {
-		return false, err
-	}
-
-	return count > 0, nil
-}

internal/gateway/context/store.go

@@ -0,0 +1,58 @@
+package context
+
+import (
+	"fmt"
+
+	"github.com/labstack/echo/v4"
+	"github.com/onsonr/sonr/internal/gateway/models"
+)
+
+func InsertCredential(c echo.Context, handle string, cred *models.CredentialDescriptor) error {
+	sess, err := Get(c)
+	if err != nil {
+		return err
+	}
+	return sess.db.Save(cred.ToDBModel(handle, c.Request().Host)).Error
+}
+
+func InsertProfile(c echo.Context) error {
+	sess, err := Get(c)
+	if err != nil {
+		return err
+	}
+	handle := c.FormValue("handle")
+	firstName := c.FormValue("first_name")
+	lastName := c.FormValue("last_name")
+	return sess.db.Save(&models.User{
+		Handle: handle,
+		Name:   fmt.Sprintf("%s %s", firstName, lastName),
+	}).Error
+}
+
+// ╭───────────────────────────────────────────────────────╮
+// │                  DB Getter Functions                  │
+// ╰───────────────────────────────────────────────────────╯
+
+// SessionID returns the session ID
+func SessionID(c echo.Context) (string, error) {
+	sess, err := Get(c)
+	if err != nil {
+		return "", err
+	}
+	return sess.Session().ID, nil
+}
+
+// HandleExists checks if a handle already exists in any session
+func HandleExists(c echo.Context, handle string) (bool, error) {
+	sess, err := Get(c)
+	if err != nil {
+		return false, err
+	}
+
+	var count int64
+	if err := sess.db.Model(&models.User{}).Where("handle = ?", handle).Count(&count).Error; err != nil {
+		return false, err
+	}
+
+	return count > 0, nil
+}