Skip to content

The only tool you need to know what is happening and how to fix it.

tenants started - a lot of work still left to be done :/

dduxe976f8351f8e
diff --git a/CLAUDE.md b/CLAUDE.md
index ebf38bfa..9a841eb1 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -86,9 +86,30 @@ func (p *projectRepository) FindById(tx *sql.Tx, id uuid.UUID) (*models.Project,
- Tables must have an `id` column
- Always pass `*sql.Tx` from `ExecuteTransaction` to lit functions
+#### Handling "Not Found" Cases
+**IMPORTANT:** When using lit/PostgreSQL, do NOT check for `sql.ErrNoRows`. The lit library returns `nil` when no record is found, not an error. Always check for `nil` instead:
+
+```go
+// CORRECT - check for nil
+user, err := repositories.UserRepository.FindByEmail(tx, email)
+if err != nil {
+ return nil, err // actual database error
+}
+if user == nil {
+ // record not found - handle accordingly
+ return nil, errors.New("user not found")
+}
+
+// WRONG - do not use sql.ErrNoRows with lit
+user, err := repositories.UserRepository.FindByEmail(tx, email)
+if err == sql.ErrNoRows { // This won't work with lit!
+ // ...
+}
+```
+
### Environment Variables (Backend)
```
-APP_TOKEN=<dashboard auth token>
+JWT_SECRET=<min 32 char secret for JWT signing>
CLICKHOUSE_SERVER=localhost:9000
CLICKHOUSE_DATABASE=traceway
CLICKHOUSE_USERNAME=default
@@ -115,8 +136,8 @@ Dashboard ← [SvelteKit Frontend] ← JSON API ← Gin Controllers
### Authentication
Two-tier system:
-1. **Client Auth**: Project bearer tokens (SDK telemetry via `Authorization: Bearer <token>`)
-2. **App Auth**: `APP_TOKEN` env var (dashboard authentication)
+1. **Client Auth**: Project bearer tokens (SDK telemetry via `Authorization: Bearer <project_token>`)
+2. **App Auth**: JWT-based user authentication (dashboard via `Authorization: Bearer <jwt_token>`)
---
@@ -363,7 +384,20 @@ func (c *ReportController) Report(ctx *gin.Context) {
#### Tables (PostgreSQL)
| Table | Purpose |
|-------|---------|
-| `projects` | Multi-tenant project config + tokens |
+| `users` | User accounts with email/password |
+| `organizations` | Multi-tenant organizations |
+| `organization_users` | Junction table linking users to organizations with roles |
+| `projects` | Project config + tokens, linked to organizations |
+
+#### Organization Roles
+| Role | Description |
+|------|-------------|
+| `owner` | Full access, can manage organization |
+| `admin` | Full access to projects |
+| `user` | Standard access to projects |
+| `readonly` | Read-only access, cannot create projects or archive exceptions |
+
+The `RequireWriteAccess` middleware blocks write operations for users with `readonly` role.
#### Key Columns - transactions
```sql
diff --git a/backend/app/controllers/auth.controller.go b/backend/app/controllers/auth.controller.go
index a075a8ee..b7529d68 100644
--- a/backend/app/controllers/auth.controller.go
+++ b/backend/app/controllers/auth.controller.go
@@ -1,37 +1,180 @@
package controllers
import (
+ "backend/app/cache"
+ "backend/app/models"
+ "backend/app/pgdb"
+ "backend/app/repositories"
+ "backend/app/services"
+ "database/sql"
"net/http"
- "os"
"github.com/gin-gonic/gin"
)
type authController struct{}
-type LoginRequest struct {
- Token string `json:"token" binding:"required"`
+func (a authController) Login(c *gin.Context) {
+ var request models.LoginRequest
+ if err := c.ShouldBindJSON(&request); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
+ return
+ }
+
+ result, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (*models.LoginResponse, error) {
+ user, err := repositories.UserRepository.FindByEmail(tx, request.Email)
+ if err != nil {
+ return nil, err
+ }
+ if user == nil {
+ return nil, nil
+ }
+
+ if !services.CheckPassword(request.Password, user.Password) {
+ return nil, nil
+ }
+
+ token, err := services.GenerateToken(user.Id, user.Email)
+ if err != nil {
+ return nil, err
+ }
+
+ return &models.LoginResponse{
+ Token: token,
+ User: user.ToResponse(),
+ }, nil
+ })
+
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, err)
+ return
+ }
+
+ if result == nil {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid email or password"})
+ return
+ }
+
+ c.JSON(http.StatusOK, result)
}
-func (a authController) Login(c *gin.Context) {
- var request LoginRequest
+func (a authController) Register(c *gin.Context) {
+ var request models.RegisterRequest
if err := c.ShouldBindJSON(&request); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
return
}
- appToken := os.Getenv("APP_TOKEN")
- if appToken == "" {
- // this is also confirmed in main, but just an extra layer of safety
- panic("APP_TOKEN environment variable is not set")
+ result, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (*models.RegisterResponse, error) {
+ // Check if email already exists
+ exists, err := repositories.UserRepository.EmailExists(tx, request.Email)
+ if err != nil {
+ return nil, err
+ }
+ if exists {
+ return nil, &EmailExistsError{}
+ }
+
+ // Hash password
+ hashedPassword, err := services.HashPassword(request.Password)
+ if err != nil {
+ return nil, err
+ }
+
+ // Create user
+ user, err := repositories.UserRepository.Create(tx, request.Email, request.Name, hashedPassword)
+ if err != nil {
+ return nil, err
+ }
+
+ // Create organization
+ org, err := repositories.OrganizationRepository.Create(tx, request.OrganizationName)
+ if err != nil {
+ return nil, err
+ }
+
+ // Add user to organization as owner
+ _, err = repositories.OrganizationRepository.AddUser(tx, org.Id, user.Id, "owner")
+ if err != nil {
+ return nil, err
+ }
+
+ // Create project with organization
+ project, err := repositories.ProjectRepository.CreateWithOrganization(tx, request.ProjectName, request.Framework, org.Id)
+ if err != nil {
+ return nil, err
+ }
+
+ // Generate JWT token
+ token, err := services.GenerateToken(user.Id, user.Email)
+ if err != nil {
+ return nil, err
+ }
+
+ return &models.RegisterResponse{
+ Token: token,
+ User: user.ToResponse(),
+ Project: project.ToWithToken(),
+ }, nil
+ })
+
+ if err != nil {
+ if _, ok := err.(*EmailExistsError); ok {
+ c.JSON(http.StatusConflict, gin.H{"error": "Email already exists"})
+ return
+ }
+ c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal server error"})
+ return
}
- if request.Token != appToken {
- c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
+ // Add project to cache
+ cache.ProjectCache.AddProject(&models.Project{
+ Id: result.Project.Id,
+ Name: result.Project.Name,
+ Token: result.Project.Token,
+ Framework: result.Project.Framework,
+ OrganizationId: result.Project.OrganizationId,
+ })
+
+ c.JSON(http.StatusCreated, result)
+}
+
+func (a authController) Me(c *gin.Context) {
+ userId, exists := c.Get("userId")
+ if !exists {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
return
}
- c.JSON(http.StatusOK, gin.H{"status": "ok"})
+ result, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (*models.UserResponse, error) {
+ user, err := repositories.UserRepository.FindById(tx, userId.(int))
+ if err != nil {
+ return nil, err
+ }
+ if user == nil {
+ return nil, nil
+ }
+ response := user.ToResponse()
+ return &response, nil
+ })
+
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, err)
+ return
+ }
+
+ if result == nil {
+ c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
+ return
+ }
+
+ c.JSON(http.StatusOK, result)
+}
+
+type EmailExistsError struct{}
+
+func (e *EmailExistsError) Error() string {
+ return "email already exists"
}
var AuthController = authController{}
diff --git a/backend/app/controllers/project.controller.go b/backend/app/controllers/project.controller.go
index d4d3bc49..0d740329 100644
--- a/backend/app/controllers/project.controller.go
+++ b/backend/app/controllers/project.controller.go
@@ -2,6 +2,7 @@ package controllers
import (
"backend/app/cache"
+ "backend/app/middleware"
"backend/app/models"
"backend/app/pgdb"
"backend/app/repositories"
@@ -35,9 +36,17 @@ type CreateProjectRequest struct {
Framework string `json:"framework" binding:"required"`
}
-// ListProjects returns all projects without tokens
+// ListProjects returns projects accessible by the authenticated user
func (p projectController) ListProjects(c *gin.Context) {
- projects := cache.ProjectCache.GetAll()
+ userId := middleware.GetUserId(c)
+
+ projects, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) ([]*models.Project, error) {
+ return repositories.ProjectRepository.FindByUserId(tx, userId)
+ })
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("error fetching projects: %w", err))
+ return
+ }
// Convert to response format (without tokens)
response := make([]models.ProjectResponse, len(projects))
diff --git a/backend/app/controllers/routes.go b/backend/app/controllers/routes.go
index 1b45ee8d..1f022b09 100644
--- a/backend/app/controllers/routes.go
+++ b/backend/app/controllers/routes.go
@@ -29,36 +29,41 @@ func RegisterControllers(router *gin.RouterGroup) {
// Project management
router.GET("/projects", middleware.UseAppAuth, ProjectController.ListProjects)
- router.POST("/projects", middleware.UseAppAuth, ProjectController.CreateProject)
- router.GET("/projects/:id", middleware.UseAppAuth, ProjectController.GetProject)
+ router.POST("/projects", middleware.UseAppAuth, middleware.RequireWriteAccess, ProjectController.CreateProject)
+ router.GET("/projects/:id", middleware.UseAppAuth, middleware.RequireProjectAccess, ProjectController.GetProject)
- router.POST("/stats", middleware.UseAppAuth, MetricRecordController.FindHomepageStats)
- router.GET("/dashboard", middleware.UseAppAuth, DashboardController.GetDashboard)
- router.GET("/dashboard/overview", middleware.UseAppAuth, DashboardController.GetDashboardOverview)
+ // Dashboard endpoints (projectId in query param)
+ router.POST("/stats", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricRecordController.FindHomepageStats)
+ router.GET("/dashboard", middleware.UseAppAuth, middleware.RequireProjectAccess, DashboardController.GetDashboard)
+ router.GET("/dashboard/overview", middleware.UseAppAuth, middleware.RequireProjectAccess, DashboardController.GetDashboardOverview)
- // Metrics endpoints (split by category)
- router.GET("/metrics/application", middleware.UseAppAuth, MetricsController.GetApplicationMetrics)
- router.GET("/metrics/stats", middleware.UseAppAuth, MetricsController.GetStatsMetrics)
- router.GET("/metrics/server", middleware.UseAppAuth, MetricsController.GetServerMetrics)
+ // Metrics endpoints (projectId in query param)
+ router.GET("/metrics/application", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricsController.GetApplicationMetrics)
+ router.GET("/metrics/stats", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricsController.GetStatsMetrics)
+ router.GET("/metrics/server", middleware.UseAppAuth, middleware.RequireProjectAccess, MetricsController.GetServerMetrics)
- // Endpoints
- router.POST("/endpoints", middleware.UseAppAuth, EndpointController.FindAllEndpoints)
- router.POST("/endpoints/grouped", middleware.UseAppAuth, EndpointController.FindGroupedByEndpoint)
- router.POST("/endpoints/endpoint", middleware.UseAppAuth, EndpointController.FindByEndpoint)
- router.POST("/endpoints/chart", middleware.UseAppAuth, EndpointController.GetStackedChart)
- router.POST("/endpoints/:endpointId", middleware.UseAppAuth, EndpointDetailController.GetEndpointDetail)
+ // Endpoints (projectId in body)
+ router.POST("/endpoints", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointController.FindAllEndpoints)
+ router.POST("/endpoints/grouped", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointController.FindGroupedByEndpoint)
+ router.POST("/endpoints/endpoint", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointController.FindByEndpoint)
+ router.POST("/endpoints/chart", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointController.GetStackedChart)
+ router.POST("/endpoints/:endpointId", middleware.UseAppAuth, middleware.RequireProjectAccess, EndpointDetailController.GetEndpointDetail)
- // Tasks
- router.POST("/tasks", middleware.UseAppAuth, TaskController.FindAllTasks)
- router.POST("/tasks/grouped", middleware.UseAppAuth, TaskController.FindGroupedByTaskName)
- router.POST("/tasks/task", middleware.UseAppAuth, TaskController.FindByTaskName)
- router.POST("/tasks/:taskId", middleware.UseAppAuth, TaskDetailController.GetTaskDetail)
- router.POST("/exception-stack-traces", middleware.UseAppAuth, ExceptionStackTraceController.FindGrouppedExceptionStackTraces)
- router.POST("/exception-stack-traces/archive", middleware.UseAppAuth, ExceptionStackTraceController.ArchiveExceptions)
- router.POST("/exception-stack-traces/unarchive", middleware.UseAppAuth, ExceptionStackTraceController.UnarchiveExceptions)
- router.POST("/exception-stack-traces/by-id/:exceptionId", middleware.UseAppAuth, ExceptionStackTraceController.FindById)
- router.POST("/exception-stack-traces/:hash", middleware.UseAppAuth, ExceptionStackTraceController.FindByHash)
+ // Tasks (projectId in body)
+ router.POST("/tasks", middleware.UseAppAuth, middleware.RequireProjectAccess, TaskController.FindAllTasks)
+ router.POST("/tasks/grouped", middleware.UseAppAuth, middleware.RequireProjectAccess, TaskController.FindGroupedByTaskName)
+ router.POST("/tasks/task", middleware.UseAppAuth, middleware.RequireProjectAccess, TaskController.FindByTaskName)
+ router.POST("/tasks/:taskId", middleware.UseAppAuth, middleware.RequireProjectAccess, TaskDetailController.GetTaskDetail)
+
+ // Exceptions (projectId in body)
+ router.POST("/exception-stack-traces", middleware.UseAppAuth, middleware.RequireProjectAccess, ExceptionStackTraceController.FindGrouppedExceptionStackTraces)
+ router.POST("/exception-stack-traces/archive", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, ExceptionStackTraceController.ArchiveExceptions)
+ router.POST("/exception-stack-traces/unarchive", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, ExceptionStackTraceController.UnarchiveExceptions)
+ router.POST("/exception-stack-traces/by-id/:exceptionId", middleware.UseAppAuth, middleware.RequireProjectAccess, ExceptionStackTraceController.FindById)
+ router.POST("/exception-stack-traces/:hash", middleware.UseAppAuth, middleware.RequireProjectAccess, ExceptionStackTraceController.FindByHash)
// Auth
router.POST("/login", AuthController.Login)
+ router.POST("/register", AuthController.Register)
+ router.GET("/me", middleware.UseAppAuth, AuthController.Me)
}
diff --git a/backend/app/middleware/require_project_access.middleware.go b/backend/app/middleware/require_project_access.middleware.go
new file mode 100644
index 00000000..18f1facd
--- /dev/null
+++ b/backend/app/middleware/require_project_access.middleware.go
@@ -0,0 +1,60 @@
+package middleware
+
+import (
+ "backend/app/pgdb"
+ "backend/app/repositories"
+ "database/sql"
+ "net/http"
+
+ "github.com/gin-gonic/gin"
+ "github.com/google/uuid"
+)
+
+// RequireProjectAccess middleware validates that the authenticated user has access to the requested project.
+// A user can access a project if they are a member of the project's organization.
+// This middleware should be applied AFTER UseAppAuth.
+var RequireProjectAccess gin.HandlerFunc
+
+func InitRequireProjectAccess() {
+ RequireProjectAccess = func(c *gin.Context) {
+ userId := GetUserId(c)
+ if userId == 0 {
+ c.AbortWithStatus(http.StatusUnauthorized)
+ return
+ }
+
+ projectId := extractProjectId(c)
+ if projectId == uuid.Nil {
+ // you are not authorized to access a no project id, this is just a bad request
+ c.AbortWithStatus(http.StatusBadRequest)
+ return
+ }
+
+ hasAccess, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (bool, error) {
+ return repositories.ProjectRepository.UserHasAccess(tx, projectId, userId)
+ })
+
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, err)
+ return
+ }
+
+ if !hasAccess {
+ c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Access denied"})
+ return
+ }
+
+ c.Next()
+ }
+}
+
+func extractProjectId(c *gin.Context) uuid.UUID {
+ projectIdStr := c.Query("projectId")
+ if projectIdStr != "" {
+ if id, err := uuid.Parse(projectIdStr); err == nil {
+ return id
+ }
+ }
+
+ return uuid.Nil
+}
diff --git a/backend/app/middleware/require_write_access.middleware.go b/backend/app/middleware/require_write_access.middleware.go
new file mode 100644
index 00000000..e6ce2fb8
--- /dev/null
+++ b/backend/app/middleware/require_write_access.middleware.go
@@ -0,0 +1,60 @@
+package middleware
+
+import (
+ "backend/app/cache"
+ "backend/app/pgdb"
+ "backend/app/repositories"
+ "database/sql"
+ "net/http"
+
+ "github.com/gin-gonic/gin"
+ "github.com/google/uuid"
+)
+
+// RequireWriteAccess middleware checks if the user has write access to the project's organization.
+// It blocks access for users with 'readonly' role.
+// This middleware should be applied AFTER UseAppAuth.
+var RequireWriteAccess gin.HandlerFunc
+
+func InitRequireWriteAccess() {
+ RequireWriteAccess = func(c *gin.Context) {
+ userId := GetUserId(c)
+ if userId == 0 {
+ c.AbortWithStatus(http.StatusUnauthorized)
+ return
+ }
+
+ projectId := extractProjectId(c)
+ if projectId == uuid.Nil {
+ c.AbortWithStatus(http.StatusBadRequest)
+ return
+ }
+
+ project := cache.ProjectCache.GetById(projectId)
+ if project == nil {
+ c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"error": "Project not found"})
+ return
+ }
+
+ if project.OrganizationId == nil {
+ c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": "Project has no organization"})
+ return
+ }
+
+ role, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (string, error) {
+ return repositories.OrganizationRepository.GetUserRole(tx, *project.OrganizationId, userId)
+ })
+
+ if err != nil {
+ c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Access denied"})
+ return
+ }
+
+ if role == "readonly" {
+ c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Read-only access. Write operations are not permitted."})
+ return
+ }
+
+ c.Next()
+ }
+}
diff --git a/backend/app/middleware/use_app_auth.middleware copy.go b/backend/app/middleware/use_app_auth.middleware copy.go
deleted file mode 100644
index c41743a4..00000000
--- a/backend/app/middleware/use_app_auth.middleware copy.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package middleware
-
-import (
- "net/http"
- "os"
-
- "github.com/gin-gonic/gin"
-)
-
-var UseAppAuth func(c *gin.Context)
-
-func InitUseAppAuth() {
- authHeader := "Bearer " + os.Getenv("APP_TOKEN")
-
- UseAppAuth = func(c *gin.Context) {
- if authHeader != c.GetHeader("Authorization") {
- c.AbortWithStatus(http.StatusUnauthorized)
- return
- }
-
- c.Next()
- }
-}
diff --git a/backend/app/middleware/use_app_auth.middleware.go b/backend/app/middleware/use_app_auth.middleware.go
new file mode 100644
index 00000000..06a9b5f9
--- /dev/null
+++ b/backend/app/middleware/use_app_auth.middleware.go
@@ -0,0 +1,52 @@
+package middleware
+
+import (
+ "backend/app/services"
+ "net/http"
+ "strings"
+
+ "github.com/gin-gonic/gin"
+)
+
+const UserIdContextKey = "userId"
+const UserEmailContextKey = "userEmail"
+
+var UseAppAuth func(c *gin.Context)
+
+func InitUseAppAuth() {
+ UseAppAuth = func(c *gin.Context) {
+ authHeader := c.GetHeader("Authorization")
+
+ if !strings.HasPrefix(authHeader, "Bearer ") {
+ c.AbortWithStatus(http.StatusUnauthorized)
+ return
+ }
+
+ tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+
+ claims, err := services.ValidateToken(tokenString)
+ if err != nil {
+ c.AbortWithStatus(http.StatusUnauthorized)
+ return
+ }
+
+ c.Set(UserIdContextKey, claims.UserId)
+ c.Set(UserEmailContextKey, claims.Email)
+
+ c.Next()
+ }
+}
+
+func GetUserId(c *gin.Context) int {
+ if id, exists := c.Get(UserIdContextKey); exists {
+ return id.(int)
+ }
+ return 0
+}
+
+func GetUserEmail(c *gin.Context) string {
+ if email, exists := c.Get(UserEmailContextKey); exists {
+ return email.(string)
+ }
+ return ""
+}
diff --git a/backend/app/migrations/pg/0004_create_users_table.up.sql b/backend/app/migrations/pg/0004_create_users_table.up.sql
new file mode 100644
index 00000000..8682278d
--- /dev/null
+++ b/backend/app/migrations/pg/0004_create_users_table.up.sql
@@ -0,0 +1 @@
+CREATE TABLE users (id SERIAL PRIMARY KEY, email VARCHAR(255) NOT NULL UNIQUE, name VARCHAR(255) NOT NULL, password VARCHAR(255) NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW())
diff --git a/backend/app/migrations/pg/0005_create_users_email_index.up.sql b/backend/app/migrations/pg/0005_create_users_email_index.up.sql
new file mode 100644
index 00000000..bf129129
--- /dev/null
+++ b/backend/app/migrations/pg/0005_create_users_email_index.up.sql
@@ -0,0 +1 @@
+CREATE UNIQUE INDEX idx_users_email ON users(email)
diff --git a/backend/app/migrations/pg/0006_create_organizations_table.up.sql b/backend/app/migrations/pg/0006_create_organizations_table.up.sql
new file mode 100644
index 00000000..9e9217a7
--- /dev/null
+++ b/backend/app/migrations/pg/0006_create_organizations_table.up.sql
@@ -0,0 +1 @@
+CREATE TABLE organizations (id SERIAL PRIMARY KEY, name VARCHAR(255) NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW())
diff --git a/backend/app/migrations/pg/0007_create_organization_users_table.up.sql b/backend/app/migrations/pg/0007_create_organization_users_table.up.sql
new file mode 100644
index 00000000..2232e8d4
--- /dev/null
+++ b/backend/app/migrations/pg/0007_create_organization_users_table.up.sql
@@ -0,0 +1 @@
+CREATE TABLE organization_users (id SERIAL PRIMARY KEY, user_id INT NOT NULL REFERENCES users(id), organization_id INT NOT NULL REFERENCES organizations(id), role TEXT NOT NULL CHECK (role IN ('owner','admin','user','readonly')), created_at TIMESTAMPTZ DEFAULT NOW(), UNIQUE(user_id, organization_id))
diff --git a/backend/app/migrations/pg/0008_add_organization_id_to_projects.up.sql b/backend/app/migrations/pg/0008_add_organization_id_to_projects.up.sql
new file mode 100644
index 00000000..45f1ed28
--- /dev/null
+++ b/backend/app/migrations/pg/0008_add_organization_id_to_projects.up.sql
@@ -0,0 +1 @@
+ALTER TABLE projects ADD COLUMN organization_id INT REFERENCES organizations(id)
diff --git a/backend/app/migrations/pg/0009_create_projects_org_index.up.sql b/backend/app/migrations/pg/0009_create_projects_org_index.up.sql
new file mode 100644
index 00000000..332226fa
--- /dev/null
+++ b/backend/app/migrations/pg/0009_create_projects_org_index.up.sql
@@ -0,0 +1 @@
+CREATE INDEX idx_projects_organization_id ON projects(organization_id)
diff --git a/backend/app/models/auth.model.go b/backend/app/models/auth.model.go
new file mode 100644
index 00000000..b32ac0e3
--- /dev/null
+++ b/backend/app/models/auth.model.go
@@ -0,0 +1,26 @@
+package models
+
+type LoginRequest struct {
+ Email string `json:"email" binding:"required,email"`
+ Password string `json:"password" binding:"required"`
+}
+
+type LoginResponse struct {
+ Token string `json:"token"`
+ User UserResponse `json:"user"`
+}
+
+type RegisterRequest struct {
+ Email string `json:"email" binding:"required,email"`
+ Name string `json:"name" binding:"required"`
+ Password string `json:"password" binding:"required,min=8"`
+ OrganizationName string `json:"organizationName" binding:"required"`
+ ProjectName string `json:"projectName" binding:"required"`
+ Framework string `json:"framework" binding:"required"`
+}
+
+type RegisterResponse struct {
+ Token string `json:"token"`
+ User UserResponse `json:"user"`
+ Project ProjectWithToken `json:"project"`
+}
diff --git a/backend/app/models/models.go b/backend/app/models/models.go
index a6f4fbfb..8cdaf957 100644
--- a/backend/app/models/models.go
+++ b/backend/app/models/models.go
@@ -6,4 +6,7 @@ import (
func Init() {
lit.RegisterModel[Project](lit.PostgreSQL)
+ lit.RegisterModel[User](lit.PostgreSQL)
+ lit.RegisterModel[Organization](lit.PostgreSQL)
+ lit.RegisterModel[OrganizationUser](lit.PostgreSQL)
}
diff --git a/backend/app/models/organization.model.go b/backend/app/models/organization.model.go
new file mode 100644
index 00000000..86c9a102
--- /dev/null
+++ b/backend/app/models/organization.model.go
@@ -0,0 +1,19 @@
+package models
+
+import (
+ "time"
+)
+
+type Organization struct {
+ Id int `json:"id"`
+ Name string `json:"name"`
+ CreatedAt time.Time `json:"createdAt"`
+}
+
+type OrganizationUser struct {
+ Id int `json:"id"`
+ UserId int `json:"userId"`
+ OrganizationId int `json:"organizationId"`
+ Role string `json:"role"` // owner, admin, user
+ CreatedAt time.Time `json:"createdAt"`
+}
diff --git a/backend/app/models/project.model.go b/backend/app/models/project.model.go
index f907b422..78d5f033 100644
--- a/backend/app/models/project.model.go
+++ b/backend/app/models/project.model.go
@@ -15,47 +15,52 @@ func getBackendUrl() string {
}
type Project struct {
- Id uuid.UUID `json:"id"`
- Name string `json:"name"`
- Token string `json:"token"`
- Framework string `json:"framework"`
- CreatedAt time.Time `json:"createdAt"`
+ Id uuid.UUID `json:"id"`
+ Name string `json:"name"`
+ Token string `json:"token"`
+ Framework string `json:"framework"`
+ OrganizationId *int `json:"organizationId"`
+ CreatedAt time.Time `json:"createdAt"`
}
type ProjectResponse struct {
- Id uuid.UUID `json:"id"`
- Name string `json:"name"`
- Framework string `json:"framework"`
- CreatedAt time.Time `json:"createdAt"`
- BackendUrl string `json:"backendUrl"`
+ Id uuid.UUID `json:"id"`
+ Name string `json:"name"`
+ Framework string `json:"framework"`
+ OrganizationId *int `json:"organizationId"`
+ CreatedAt time.Time `json:"createdAt"`
+ BackendUrl string `json:"backendUrl"`
}
type ProjectWithToken struct {
- Id uuid.UUID `json:"id"`
- Name string `json:"name"`
- Token string `json:"token"`
- Framework string `json:"framework"`
- CreatedAt time.Time `json:"createdAt"`
- BackendUrl string `json:"backendUrl"`
+ Id uuid.UUID `json:"id"`
+ Name string `json:"name"`
+ Token string `json:"token"`
+ Framework string `json:"framework"`
+ OrganizationId *int `json:"organizationId"`
+ CreatedAt time.Time `json:"createdAt"`
+ BackendUrl string `json:"backendUrl"`
}
func (p *Project) ToResponse() ProjectResponse {
return ProjectResponse{
- Id: p.Id,
- Name: p.Name,
- Framework: p.Framework,
- CreatedAt: p.CreatedAt,
- BackendUrl: getBackendUrl(),
+ Id: p.Id,
+ Name: p.Name,
+ Framework: p.Framework,
+ OrganizationId: p.OrganizationId,
+ CreatedAt: p.CreatedAt,
+ BackendUrl: getBackendUrl(),
}
}
func (p *Project) ToWithToken() ProjectWithToken {
return ProjectWithToken{
- Id: p.Id,
- Name: p.Name,
- Token: p.Token,
- Framework: p.Framework,
- CreatedAt: p.CreatedAt,
- BackendUrl: getBackendUrl(),
+ Id: p.Id,
+ Name: p.Name,
+ Token: p.Token,
+ Framework: p.Framework,
+ OrganizationId: p.OrganizationId,
+ CreatedAt: p.CreatedAt,
+ BackendUrl: getBackendUrl(),
}
}
diff --git a/backend/app/models/user.model.go b/backend/app/models/user.model.go
new file mode 100644
index 00000000..e7666c4e
--- /dev/null
+++ b/backend/app/models/user.model.go
@@ -0,0 +1,29 @@
+package models
+
+import (
+ "time"
+)
+
+type User struct {
+ Id int `json:"id"`
+ Email string `json:"email"`
+ Name string `json:"name"`
+ Password string `json:"-"` // Never serialize
+ CreatedAt time.Time `json:"createdAt"`
+}
+
+type UserResponse struct {
+ Id int `json:"id"`
+ Email string `json:"email"`
+ Name string `json:"name"`
+ CreatedAt time.Time `json:"createdAt"`
+}
+
+func (u *User) ToResponse() UserResponse {
+ return UserResponse{
+ Id: u.Id,
+ Email: u.Email,
+ Name: u.Name,
+ CreatedAt: u.CreatedAt,
+ }
+}
diff --git a/backend/app/repositories/organization.repository.go b/backend/app/repositories/organization.repository.go
new file mode 100644
index 00000000..792a9971
--- /dev/null
+++ b/backend/app/repositories/organization.repository.go
@@ -0,0 +1,78 @@
+package repositories
+
+import (
+ "backend/app/models"
+ "database/sql"
+
+ "github.com/tracewayapp/go-lightning/lit"
+)
+
+type organizationRepository struct{}
+
+func (r *organizationRepository) Create(tx *sql.Tx, name string) (*models.Organization, error) {
+ org := &models.Organization{
+ Name: name,
+ }
+
+ id, err := lit.Insert(tx, org)
+ if err != nil {
+ return nil, err
+ }
+ org.Id = id
+
+ return org, nil
+}
+
+func (r *organizationRepository) FindById(tx *sql.Tx, id int) (*models.Organization, error) {
+ return lit.SelectSingle[models.Organization](
+ tx,
+ "SELECT id, name, created_at FROM organizations WHERE id = $1",
+ id,
+ )
+}
+
+func (r *organizationRepository) FindByUserId(tx *sql.Tx, userId int) ([]*models.Organization, error) {
+ return lit.Select[models.Organization](
+ tx,
+ `SELECT o.id, o.name, o.created_at
+ FROM organizations o
+ INNER JOIN organization_users ou ON o.id = ou.organization_id
+ WHERE ou.user_id = $1
+ ORDER BY o.created_at ASC`,
+ userId,
+ )
+}
+
+func (r *organizationRepository) AddUser(tx *sql.Tx, organizationId int, userId int, role string) (*models.OrganizationUser, error) {
+ orgUser := &models.OrganizationUser{
+ UserId: userId,
+ OrganizationId: organizationId,
+ Role: role,
+ }
+
+ id, err := lit.Insert(tx, orgUser)
+ if err != nil {
+ return nil, err
+ }
+ orgUser.Id = id
+
+ return orgUser, nil
+}
+
+func (r *organizationRepository) GetUserRole(tx *sql.Tx, organizationId int, userId int) (string, error) {
+ orgUser, err := lit.SelectSingle[models.OrganizationUser](
+ tx,
+ "SELECT id, user_id, organization_id, role, created_at FROM organization_users WHERE organization_id = $1 AND user_id = $2",
+ organizationId,
+ userId,
+ )
+ if err != nil {
+ return "", err
+ }
+ if orgUser == nil {
+ return "", nil // User not in organization
+ }
+ return orgUser.Role, nil
+}
+
+var OrganizationRepository = organizationRepository{}
diff --git a/backend/app/repositories/project.repository.go b/backend/app/repositories/project.repository.go
index e9410adb..26d74704 100644
--- a/backend/app/repositories/project.repository.go
+++ b/backend/app/repositories/project.repository.go
@@ -14,14 +14,14 @@ type projectRepository struct{}
func (p *projectRepository) FindAll(tx *sql.Tx) ([]*models.Project, error) {
return lit.Select[models.Project](
tx,
- "SELECT id, name, token, framework, created_at FROM projects ORDER BY created_at ASC",
+ "SELECT id, name, token, framework, organization_id, created_at FROM projects ORDER BY created_at ASC",
)
}
func (p *projectRepository) FindByToken(tx *sql.Tx, token string) (*models.Project, error) {
return lit.SelectSingle[models.Project](
tx,
- "SELECT id, name, token, framework, created_at FROM projects WHERE token = $1",
+ "SELECT id, name, token, framework, organization_id, created_at FROM projects WHERE token = $1",
token,
)
}
@@ -29,7 +29,7 @@ func (p *projectRepository) FindByToken(tx *sql.Tx, token string) (*models.Proje
func (p *projectRepository) FindById(tx *sql.Tx, id uuid.UUID) (*models.Project, error) {
return lit.SelectSingle[models.Project](
tx,
- "SELECT id, name, token, framework, created_at FROM projects WHERE id = $1",
+ "SELECT id, name, token, framework, organization_id, created_at FROM projects WHERE id = $1",
id,
)
}
@@ -50,6 +50,72 @@ func (p *projectRepository) Create(tx *sql.Tx, name string, framework string) (*
return project, nil
}
+func (p *projectRepository) CreateWithOrganization(tx *sql.Tx, name string, framework string, organizationId int) (*models.Project, error) {
+ project := &models.Project{
+ Id: uuid.New(),
+ Name: name,
+ Token: generateSecureToken(),
+ Framework: framework,
+ OrganizationId: &organizationId,
+ }
+
+ err := lit.InsertExistingUuid(tx, project)
+ if err != nil {
+ return nil, err
+ }
+
+ return project, nil
+}
+
+func (p *projectRepository) FindByOrganizationId(tx *sql.Tx, organizationId int) ([]*models.Project, error) {
+ return lit.Select[models.Project](
+ tx,
+ "SELECT id, name, token, framework, organization_id, created_at FROM projects WHERE organization_id = $1 ORDER BY created_at ASC",
+ organizationId,
+ )
+}
+
+// FindByUserId returns all projects belonging to organizations the user is a member of
+func (p *projectRepository) FindByUserId(tx *sql.Tx, userId int) ([]*models.Project, error) {
+ return lit.Select[models.Project](
+ tx,
+ `SELECT DISTINCT p.id, p.name, p.token, p.framework, p.organization_id, p.created_at
+ FROM projects p
+ INNER JOIN organization_users ou ON p.organization_id = ou.organization_id
+ WHERE ou.user_id = $1
+ ORDER BY p.created_at ASC`,
+ userId,
+ )
+}
+
+type CountResult struct {
+ Count int `lit:"count"`
+}
+
+func init() {
+ lit.RegisterModel[CountResult](lit.PostgreSQL)
+}
+
+func (p *projectRepository) UserHasAccess(tx *sql.Tx, projectId uuid.UUID, userId int) (bool, error) {
+ result, err := lit.SelectSingle[CountResult](
+ tx,
+ `SELECT COUNT(*) as count
+ FROM projects p
+ INNER JOIN organization_users ou ON p.organization_id = ou.organization_id
+ WHERE p.id = $1 AND ou.user_id = $2`,
+ projectId,
+ userId,
+ )
+ if err != nil {
+ return false, err
+ }
+ if result == nil {
+ return false, nil
+ }
+
+ return result.Count > 0, nil
+}
+
func generateSecureToken() string {
id := uuid.New()
return strings.ReplaceAll(id.String(), "-", "")
diff --git a/backend/app/repositories/user.repository.go b/backend/app/repositories/user.repository.go
new file mode 100644
index 00000000..dbc6b65b
--- /dev/null
+++ b/backend/app/repositories/user.repository.go
@@ -0,0 +1,52 @@
+package repositories
+
+import (
+ "backend/app/models"
+ "database/sql"
+
+ "github.com/tracewayapp/go-lightning/lit"
+)
+
+type userRepository struct{}
+
+func (r *userRepository) FindByEmail(tx *sql.Tx, email string) (*models.User, error) {
+ return lit.SelectSingle[models.User](
+ tx,
+ "SELECT id, email, name, password, created_at FROM users WHERE email = $1",
+ email,
+ )
+}
+
+func (r *userRepository) FindById(tx *sql.Tx, id int) (*models.User, error) {
+ return lit.SelectSingle[models.User](
+ tx,
+ "SELECT id, email, name, password, created_at FROM users WHERE id = $1",
+ id,
+ )
+}
+
+func (r *userRepository) Create(tx *sql.Tx, email string, name string, hashedPassword string) (*models.User, error) {
+ user := &models.User{
+ Email: email,
+ Name: name,
+ Password: hashedPassword,
+ }
+
+ id, err := lit.Insert(tx, user)
+ if err != nil {
+ return nil, err
+ }
+ user.Id = id
+
+ return user, nil
+}
+
+func (r *userRepository) EmailExists(tx *sql.Tx, email string) (bool, error) {
+ user, err := r.FindByEmail(tx, email)
+ if err != nil {
+ return false, err
+ }
+ return user != nil, nil
+}
+
+var UserRepository = userRepository{}
diff --git a/backend/app/services/jwt.service.go b/backend/app/services/jwt.service.go
new file mode 100644
index 00000000..9084a716
--- /dev/null
+++ b/backend/app/services/jwt.service.go
@@ -0,0 +1,64 @@
+package services
+
+import (
+ "errors"
+ "fmt"
+ "os"
+ "time"
+
+ "github.com/golang-jwt/jwt/v5"
+)
+
+var jwtSecret []byte
+
+type JWTClaims struct {
+ UserId int `json:"userId"`
+ Email string `json:"email"`
+ jwt.RegisteredClaims
+}
+
+func InitJWT() error {
+ secret := os.Getenv("JWT_SECRET")
+ if secret == "" {
+ return errors.New("JWT_SECRET environment variable is not set")
+ }
+ if len(secret) < 32 {
+ return errors.New("JWT_SECRET must be at least 32 characters")
+ }
+ jwtSecret = []byte(secret)
+ return nil
+}
+
+func GenerateToken(userId int, email string) (string, error) {
+ claims := JWTClaims{
+ UserId: userId,
+ Email: email,
+ RegisteredClaims: jwt.RegisteredClaims{
+ ExpiresAt: jwt.NewNumericDate(time.Now().Add(7 * 24 * time.Hour)), // 7 days
+ IssuedAt: jwt.NewNumericDate(time.Now()),
+ NotBefore: jwt.NewNumericDate(time.Now()),
+ },
+ }
+
+ token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+ return token.SignedString(jwtSecret)
+}
+
+func ValidateToken(tokenString string) (*JWTClaims, error) {
+ token, err := jwt.ParseWithClaims(tokenString, &JWTClaims{}, func(token *jwt.Token) (interface{}, error) {
+ if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+ return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+ }
+ return jwtSecret, nil
+ })
+
+ if err != nil {
+ return nil, err
+ }
+
+ if claims, ok := token.Claims.(*JWTClaims); ok && token.Valid {
+ return claims, nil
+ }
+
+ return nil, errors.New("invalid token")
+}
diff --git a/backend/app/services/password.service.go b/backend/app/services/password.service.go
new file mode 100644
index 00000000..6adac7ab
--- /dev/null
+++ b/backend/app/services/password.service.go
@@ -0,0 +1,20 @@
+package services
+
+import (
+ "golang.org/x/crypto/bcrypt"
+)
+
+const bcryptCost = 12
+
+func HashPassword(password string) (string, error) {
+ bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcryptCost)
+ if err != nil {
+ return "", err
+ }
+ return string(bytes), nil
+}
+
+func CheckPassword(password, hash string) bool {
+ err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
+ return err == nil
+}
diff --git a/backend/backend b/backend/backend
index 5cba1996..1a05a389 100755
Binary files a/backend/backend and b/backend/backend differ
diff --git a/backend/go.mod b/backend/go.mod
index 6f36e0c1..79cc8296 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -25,6 +25,7 @@ require (
github.com/go-playground/validator/v10 v10.27.0 // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
+ github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/compress v1.18.0 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
diff --git a/backend/go.sum b/backend/go.sum
index 47560246..13922695 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -72,6 +72,8 @@ github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MG
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/golang-migrate/migrate/v4 v4.19.1 h1:OCyb44lFuQfYXYLx1SCxPZQGU7mcaZ7gH9yH4jSFbBA=
github.com/golang-migrate/migrate/v4 v4.19.1/go.mod h1:CTcgfjxhaUtsLipnLoQRWCrjYXycRz/g5+RWDuYgPrE=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
diff --git a/backend/main.go b/backend/main.go
index 4971416f..1ed9da4f 100644
--- a/backend/main.go
+++ b/backend/main.go
@@ -8,6 +8,7 @@ import (
"backend/app/migrations"
"backend/app/models"
"backend/app/pgdb"
+ "backend/app/services"
"backend/static"
"context"
"fmt"
@@ -29,11 +30,9 @@ func main() {
// so the error is ignored
godotenv.Load()
- appToken := os.Getenv("APP_TOKEN")
- if appToken == "" {
- // without the api token we must not start
- // this will be addressed when we add users
- panic("APP_TOKEN environment variable is not set")
+ // Initialize JWT service
+ if err := services.InitJWT(); err != nil {
+ panic(fmt.Errorf("failed to initialize JWT: %w", err))
}
// Initialize PostgreSQL first (before migrations)
@@ -67,6 +66,9 @@ func main() {
}
middleware.InitUseClientAuth()
+ middleware.InitUseAppAuth()
+ middleware.InitRequireWriteAccess()
+ middleware.InitRequireProjectAccess()
router := gin.Default()
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 7d355f92..9cc01c6b 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -14,7 +14,7 @@ async function request(method: string, endpoint: string, data?: unknown, options
};
if (currentToken) {
- headers['Authorization'] = `${currentToken}`;
+ headers['Authorization'] = `Bearer ${currentToken}`;
}
const config: RequestInit = {
@@ -22,18 +22,13 @@ async function request(method: string, endpoint: string, data?: unknown, options
headers,
};
- // For POST/PUT requests, add projectId to the body if provided
- if (data && options?.projectId && !options?.skipProjectId) {
- data = { ...data as object, projectId: options.projectId };
- }
-
if (data) {
config.body = JSON.stringify(data);
}
- // For GET requests, add projectId as query parameter if provided
+ // Add projectId as query parameter if provided
let url = `${BASE_URL}${endpoint}`;
- if (method === 'GET' && options?.projectId && !options?.skipProjectId) {
+ if (options?.projectId && !options?.skipProjectId) {
const separator = endpoint.includes('?') ? '&' : '?';
url = `${url}${separator}projectId=${options.projectId}`;
}
diff --git a/frontend/src/lib/state/auth.svelte.ts b/frontend/src/lib/state/auth.svelte.ts
index 805c27c5..394df9ff 100644
--- a/frontend/src/lib/state/auth.svelte.ts
+++ b/frontend/src/lib/state/auth.svelte.ts
@@ -1,7 +1,8 @@
import { clearNavDepth } from '$lib/utils/back-navigation';
+import { userState } from './user.svelte';
class AuthState {
- token = $state<string | null>(localStorage.getItem('APP_TOKEN'));
+ token = $state<string | null>(localStorage.getItem('AUTH_TOKEN'));
isAuthenticated = $derived(!!this.token);
@@ -9,9 +10,9 @@ class AuthState {
$effect.root(() => {
$effect(() => {
if (this.token) {
- localStorage.setItem('APP_TOKEN', this.token);
+ localStorage.setItem('AUTH_TOKEN', this.token);
} else {
- localStorage.removeItem('APP_TOKEN');
+ localStorage.removeItem('AUTH_TOKEN');
}
});
});
@@ -23,6 +24,7 @@ class AuthState {
logout() {
this.token = null;
+ userState.clear();
clearNavDepth();
}
}
diff --git a/frontend/src/lib/state/user.svelte.ts b/frontend/src/lib/state/user.svelte.ts
new file mode 100644
index 00000000..e7eadf4a
--- /dev/null
+++ b/frontend/src/lib/state/user.svelte.ts
@@ -0,0 +1,60 @@
+export interface User {
+ id: number;
+ email: string;
+ name: string;
+ createdAt: string;
+}
+
+const USER_STORAGE_KEY = 'AUTH_USER';
+
+class UserState {
+ user = $state<User | null>(null);
+
+ constructor() {
+ // Load from localStorage on init
+ const stored = localStorage.getItem(USER_STORAGE_KEY);
+ if (stored) {
+ try {
+ this.user = JSON.parse(stored);
+ } catch {
+ this.user = null;
+ }
+ }
+
+ $effect.root(() => {
+ $effect(() => {
+ if (this.user) {
+ localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(this.user));
+ } else {
+ localStorage.removeItem(USER_STORAGE_KEY);
+ }
+ });
+ });
+ }
+
+ setUser(user: User) {
+ this.user = user;
+ }
+
+ clear() {
+ this.user = null;
+ }
+
+ async loadUser() {
+ try {
+ const response = await fetch('/api/me', {
+ headers: {
+ 'Authorization': `Bearer ${localStorage.getItem('AUTH_TOKEN')}`
+ }
+ });
+ if (response.ok) {
+ const user = await response.json();
+ this.setUser(user);
+ }
+ } catch {
+ // Ignore errors
+ }
+ }
+}
+
+export const userState = new UserState();
diff --git a/frontend/src/routes/login/+page.svelte b/frontend/src/routes/login/+page.svelte
index b150e986..9dbd8d91 100644
--- a/frontend/src/routes/login/+page.svelte
+++ b/frontend/src/routes/login/+page.svelte
@@ -3,14 +3,16 @@
import { Button } from "$lib/components/ui/button";
import { Input } from "$lib/components/ui/input";
import { Label } from "$lib/components/ui/label";
- import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "$lib/components/ui/card";
+ import { Card, CardContent, CardFooter, CardHeader, CardTitle } from "$lib/components/ui/card";
import { Alert, AlertDescription, AlertTitle } from "$lib/components/ui/alert";
import { CircleAlert } from "@lucide/svelte";
import { authState } from '$lib/state/auth.svelte';
+ import { userState } from '$lib/state/user.svelte';
import { projectsState } from '$lib/state/projects.svelte';
import { themeState } from '$lib/state/theme.svelte';
- let appToken = $state('');
+ let email = $state('');
+ let password = $state('');
let error = $state('');
let loading = $state(false);
@@ -18,28 +20,31 @@
loading = true;
error = '';
try {
- // Validate against backend
const response = await fetch('/api/login', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
- body: JSON.stringify({ token: appToken })
+ body: JSON.stringify({ email, password })
});
if (!response.ok) {
- throw new Error('Invalid token');
+ const data = await response.json();
+ throw new Error(data.error || 'Invalid credentials');
}
- // If successful, store token (store handles localStorage)
- authState.setToken(appToken);
+ const data = await response.json();
+
+ // Store token and user
+ authState.setToken(data.token);
+ userState.setUser(data.user);
// Load projects after successful login
await projectsState.loadProjects();
goto('/');
} catch (e) {
- error = 'Invalid APP_TOKEN';
+ error = e instanceof Error ? e.message : 'Invalid email or password';
} finally {
loading = false;
}
@@ -69,21 +74,28 @@
</AlertDescription>
</Alert>
{/if}
- <div class="grid w-full items-center gap-4">
+ <form onsubmit={(e) => { e.preventDefault(); handleLogin(); }} class="grid w-full items-center gap-4">
<div class="flex flex-col space-y-1.5">
- <Label for="token">Token</Label>
- <Input id="token" bind:value={appToken} placeholder="APP_TOKEN" />
+ <Label for="email">Email</Label>
+ <Input id="email" type="email" bind:value={email} placeholder="[email protected]" required />
</div>
- </div>
+ <div class="flex flex-col space-y-1.5">
+ <Label for="password">Password</Label>
+ <Input id="password" type="password" bind:value={password} placeholder="Password" required />
+ </div>
+ <Button type="submit" disabled={loading} class="w-full">
+ {#if loading}
+ Logging in...
+ {:else}
+ Login
+ {/if}
+ </Button>
+ </form>
</CardContent>
- <CardFooter class="flex flex-col justify-between gap-2">
- <Button onclick={handleLogin} disabled={loading} class="w-full">
- {#if loading}
- Logging in...
- {:else}
- Login
- {/if}
- </Button>
+ <CardFooter class="flex flex-col justify-center">
+ <p class="text-sm text-muted-foreground">
+ Don't have an account? <a href="/register" class="text-primary hover:underline">Create account</a>
+ </p>
</CardFooter>
</Card>
</div>
diff --git a/frontend/src/routes/register/+page.svelte b/frontend/src/routes/register/+page.svelte
new file mode 100644
index 00000000..4f6ca258
--- /dev/null
+++ b/frontend/src/routes/register/+page.svelte
@@ -0,0 +1,176 @@
+<script lang="ts">
+ import { goto } from '$app/navigation';
+ import { Button } from "$lib/components/ui/button";
+ import { Input } from "$lib/components/ui/input";
+ import { Label } from "$lib/components/ui/label";
+ import { Card, CardContent, CardFooter, CardHeader, CardTitle, CardDescription } from "$lib/components/ui/card";
+ import { Alert, AlertDescription, AlertTitle } from "$lib/components/ui/alert";
+ import * as Select from "$lib/components/ui/select";
+ import { CircleAlert } from "@lucide/svelte";
+ import { authState } from '$lib/state/auth.svelte';
+ import { userState } from '$lib/state/user.svelte';
+ import { projectsState } from '$lib/state/projects.svelte';
+ import { themeState } from '$lib/state/theme.svelte';
+
+ let email = $state('');
+ let name = $state('');
+ let password = $state('');
+ let confirmPassword = $state('');
+ let organizationName = $state('');
+ let projectName = $state('');
+ let framework = $state('gin');
+ let error = $state('');
+ let loading = $state(false);
+
+ const frameworks = [
+ { value: 'gin', label: 'Gin (Go)' },
+ { value: 'echo', label: 'Echo (Go)' },
+ { value: 'fiber', label: 'Fiber (Go)' },
+ { value: 'other', label: 'Other' }
+ ];
+
+ async function handleRegister() {
+ // Validate passwords match
+ if (password !== confirmPassword) {
+ error = 'Passwords do not match';
+ return;
+ }
+
+ if (password.length < 8) {
+ error = 'Password must be at least 8 characters';
+ return;
+ }
+
+ loading = true;
+ error = '';
+
+ try {
+ const response = await fetch('/api/register', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ email,
+ name,
+ password,
+ organizationName,
+ projectName,
+ framework
+ })
+ });
+
+ if (!response.ok) {
+ const data = await response.json();
+ throw new Error(data.error || 'Registration failed');
+ }
+
+ const data = await response.json();
+
+ // Store token and user
+ authState.setToken(data.token);
+ userState.setUser(data.user);
+
+ // Load projects (will include the newly created project)
+ await projectsState.loadProjects();
+
+ // Redirect to connection page to show SDK setup
+ goto('/connection');
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Registration failed';
+ } finally {
+ loading = false;
+ }
+ }
+</script>
+
+<div class="flex min-h-screen w-full items-center justify-center px-4 py-8">
+ <Card class="w-[400px]">
+ <CardHeader>
+ <CardTitle class="text-2xl">
+ <div class="flex flex-row items-center justify-center gap-2">
+ {#if themeState.isDark}
+ <img src="/traceway-logo-white.svg" alt="Traceway Logo" class="h-8 w-auto" />
+ {:else}
+ <img src="/traceway-logo.png" alt="Traceway Logo" class="h-8 w-auto" />
+ {/if}
+ </div>
+ </CardTitle>
+ <CardDescription class="text-center">
+ Create your account
+ </CardDescription>
+ </CardHeader>
+ <CardContent>
+ {#if error}
+ <Alert variant="destructive" class="mb-4 bg-red-50 border-red-200">
+ <CircleAlert class="h-4 w-4 text-red-700" />
+ <AlertTitle class="text-red-800">Error</AlertTitle>
+ <AlertDescription class="text-red-700">
+ {error}
+ </AlertDescription>
+ </Alert>
+ {/if}
+ <form onsubmit={(e) => { e.preventDefault(); handleRegister(); }} class="grid w-full items-center gap-4">
+ <div class="flex flex-col space-y-1.5">
+ <Label for="email">Email</Label>
+ <Input id="email" type="email" bind:value={email} placeholder="[email protected]" required />
+ </div>
+ <div class="flex flex-col space-y-1.5">
+ <Label for="name">Name</Label>
+ <Input id="name" type="text" bind:value={name} placeholder="Your name" required />
+ </div>
+ <div class="flex flex-col space-y-1.5">
+ <Label for="password">Password</Label>
+ <Input id="password" type="password" bind:value={password} placeholder="Password (min 8 characters)" required />
+ </div>
+ <div class="flex flex-col space-y-1.5">
+ <Label for="confirmPassword">Confirm Password</Label>
+ <Input id="confirmPassword" type="password" bind:value={confirmPassword} placeholder="Confirm password" required />
+ </div>
+
+ <div class="flex items-center gap-3 mt-2">
+ <div class="flex-1 border-t"></div>
+ <p class="text-sm text-muted-foreground">Organization & Project</p>
+ <div class="flex-1 border-t"></div>
+ </div>
+
+ <div class="flex flex-col space-y-1.5">
+ <Label for="organizationName">Organization Name</Label>
+ <Input id="organizationName" type="text" bind:value={organizationName} placeholder="Your company or team" required />
+ </div>
+ <div class="flex flex-col space-y-1.5">
+ <Label for="projectName">Project Name</Label>
+ <Input id="projectName" type="text" bind:value={projectName} placeholder="My App" required />
+ </div>
+ <div class="flex flex-col space-y-1.5">
+ <Label for="framework">Framework</Label>
+ <Select.Root type="single" bind:value={framework}>
+ <Select.Trigger class="w-full">
+ {frameworks.find(f => f.value === framework)?.label || 'Select framework'}
+ </Select.Trigger>
+ <Select.Content>
+ {#each frameworks as fw}
+ <Select.Item value={fw.value}>
+ {fw.label}
+ </Select.Item>
+ {/each}
+ </Select.Content>
+ </Select.Root>
+ </div>
+
+ <Button type="submit" disabled={loading} class="w-full mt-2">
+ {#if loading}
+ Creating account...
+ {:else}
+ Create Account
+ {/if}
+ </Button>
+ </form>
+ </CardContent>
+ <CardFooter class="flex flex-col justify-center">
+ <p class="text-sm text-muted-foreground">
+ Already have an account? <a href="/login" class="text-primary hover:underline">Login</a>
+ </p>
+ </CardFooter>
+ </Card>
+</div>
diff --git a/frontend/src/routes/register/+page.ts b/frontend/src/routes/register/+page.ts
new file mode 100644
index 00000000..47889b84
--- /dev/null
+++ b/frontend/src/routes/register/+page.ts
@@ -0,0 +1,11 @@
+import { redirect } from '@sveltejs/kit';
+import type { PageLoad } from './$types';
+
+export const load: PageLoad = () => {
+ // Check if user is already authenticated
+ const token = localStorage.getItem('AUTH_TOKEN');
+ if (token) {
+ throw redirect(302, '/');
+ }
+ return {};
+};