Search User Implemented also test added

Author: mrsumanbiswas

server/controllers/users.go

@@ -1,8 +1,44 @@
 package controllers
 
-import "net/http"
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"github.com/commandlinecoding/elephant/server/models"
+	"github.com/commandlinecoding/elephant/server/services"
+)
 
 func HandleUsers(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	_, _ = w.Write([]byte(`{"status": "users stub active"}`))
-}
+}
+
+func HandleUserSearch(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+
+	// Extract parameters
+	q := r.URL.Query().Get("q")
+	pageStr := r.URL.Query().Get("page")
+	limitStr := r.URL.Query().Get("limit")
+
+	page, _ := strconv.Atoi(pageStr)
+	limit, _ := strconv.Atoi(limitStr)
+
+	svc := services.NewUserService()
+	users, err := svc.Search(r.Context(), q, page, limit)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		_ = json.NewEncoder(w).Encode(models.JSONResponse{
+			Success: false,
+			Error:   "Failed to execute user directory search operations",
+		})
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	_ = json.NewEncoder(w).Encode(models.JSONResponse{
+		Success: true,
+		Data:    users,
+	})
+}

server/env/env.go

@@ -1,42 +1,45 @@
 package env
 
 import (
-	"log"
 	"os"
+	"path/filepath"
 
 	"github.com/joho/godotenv"
 )
 
 // global variables
 var (
-	// Server configurations
 	HOST string
 	PORT string
 
-	// PostgreSQL database coordinates
 	POSTGRES_USER     string
 	POSTGRES_PASSWORD string
 	POSTGRES_DB       string
 	POSTGRES_PORT     string
 	POSTGRES_HOST     string
 
-	// Security & Token configurations
 	JWT_SECRET string
 
-	// Cryptography parameters (Argon2id tuning)
 	ARGON_MEMORY      string
 	ARGON_ITERATIONS  string
 	ARGON_PARALLELISM string
 )
 
 func init() {
-	// load the file into the environment
-	if _, err := os.Stat("../.env"); err == nil {
-		if err := godotenv.Load("../.env"); err != nil {
-			log.Printf("Warning: Found .env but failed to parse it: %v", err)
+	cwd, err := os.Getwd()
+	if err == nil {
+		for {
+			target := filepath.Join(cwd, ".env")
+			if _, err := os.Stat(target); err == nil {
+				_ = godotenv.Load(target)
+				break
+			}
+			parent := filepath.Dir(cwd)
+			if parent == cwd {
+				break
+			}
+			cwd = parent
 		}
-	} else if _, err := os.Stat(".env"); err == nil {
-		_ = godotenv.Load(".env")
 	}
 
 	// assign the values with fallbacks
@@ -56,10 +59,9 @@ func init() {
 	ARGON_PARALLELISM = getEnv("ARGON_PARALLELISM", "2")
 }
 
-// Smart fallback defaults if an env variable is missing locally
 func getEnv(key, fallback string) string {
 	if value, exists := os.LookupEnv(key); exists {
 		return value
 	}
 	return fallback
-}
+}

server/migrations/003_add_search_indexes_up.sql

@@ -0,0 +1,2 @@
+CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
+CREATE INDEX IF NOT EXISTS idx_users_display_name ON users(display_name);

server/repository/user.go

@@ -68,4 +68,38 @@ func (r *UserRepository) FindByUsername(ctx context.Context, username string) (*
 		return nil, err
 	}
 	return &user, nil
-}
+}
+
+func (r *UserRepository) SearchUsers(ctx context.Context, searchTerm string, limit, offset int) ([]models.User, error) {
+	pattern := "%" + searchTerm + "%"
+
+	query := `
+		SELECT id, username, display_name, created_at
+		FROM users
+		WHERE username ILIKE $1 OR display_name ILIKE $2
+		ORDER BY username ASC
+		LIMIT $3 OFFSET $4;
+	`
+
+	rows, err := config.DB.Query(ctx, query, pattern, pattern, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var users []models.User = []models.User{}
+	for rows.Next() {
+		var u models.User
+		err := rows.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
+		if err != nil {
+			return nil, err
+		}
+		users = append(users, u)
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return users, nil
+}

server/repository/user_bench_test.go

@@ -0,0 +1,31 @@
+package repository
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/commandlinecoding/elephant/server/config"
+)
+
+func TestMain(m *testing.M) {	
+	config.InitDatabase()
+	code := m.Run()
+	if config.DB != nil {
+		config.DB.Close()
+	}
+	os.Exit(code)
+}
+
+func BenchmarkSearchUsers(b *testing.B) {
+	repo := NewUserRepository()
+	ctx := context.Background()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := repo.SearchUsers(ctx, "testuser", 20, 0)
+		if err != nil {
+			b.Fatalf("Benchmark error: %v", err)
+		}
+	}
+}

server/routes/users.go

@@ -7,4 +7,5 @@ import (
 
 func UserRoute(router chi.Router) {
 	router.Get("/", controllers.HandleUsers) // resolves to /api/users
+	router.Get("/search", controllers.HandleUserSearch) // resolves to /api/users/search
 }

server/services/users.go

@@ -24,11 +24,11 @@ func NewUserService() *UserService {
 func (s *UserService) Register(ctx context.Context, requestedName, dn, passwd string) (*models.User, error) {
 	requestedName = strings.ToLower(strings.TrimSpace(requestedName))
 	dn = strings.TrimSpace(dn)
-	
+
 	if len(requestedName) < 3 || len(requestedName) > 25 {
 		return nil, errors.New("username prefix must be between 3 and 25 characters")
 	}
-	
+
 	isAlphanumeric := regexp.MustCompile(`^[a-z0-9]+$`).MatchString
 	if !isAlphanumeric(requestedName) {
 		return nil, errors.New("username prefix must contain only alphanumeric characters")
@@ -52,9 +52,9 @@ func (s *UserService) Register(ctx context.Context, requestedName, dn, passwd st
 			return nil, errors.New("failed to generate secure user discriminator")
 		}
 		discriminator := nBig.Int64() + 1000 // forces range [1000, 9999]
-		
+
 		candidate := fmt.Sprintf("%s.%d", requestedName, discriminator)
-		
+
 		exists, err := s.repo.UsernameExists(ctx, candidate)
 		if err != nil {
 			return nil, err
@@ -76,4 +76,18 @@ func (s *UserService) Register(ctx context.Context, requestedName, dn, passwd st
 	}
 
 	return s.repo.CreateUser(ctx, finalUsername, dn, hash)
-}
+}
+
+func (s *UserService) Search(ctx context.Context, query string, page, limit int) ([]models.User, error) {
+	query = strings.TrimSpace(query)
+
+	if limit <= 0 || limit > 100 {
+		limit = 20
+	}
+	if page <= 0 {
+		page = 1
+	}
+	offset := (page - 1) * limit
+
+	return s.repo.SearchUsers(ctx, query, limit, offset)
+}