add users

internal/service/user_processor.go

@@ -29,4 +29,7 @@ type UserProcessor interface {
 
 	// Get active users for mention purposes
 	GetActiveUsersForMention(ctx context.Context, search *string, limit int) ([]contract.UserResponse, error)
+
+	// Bulk create users with transaction
+	BulkCreateUsersWithTransaction(ctx context.Context, users []contract.BulkUserRequest) ([]contract.UserResponse, []contract.BulkUserErrorResult, error)
 }

internal/service/user_service.go

@@ -41,29 +41,62 @@ func (s *UserServiceImpl) BulkCreateUsers(ctx context.Context, req *contract.Bul
 		},
 	}
 
-	for _, userReq := range req.Users {
-		createReq := &contract.CreateUserRequest{
-			Name:     userReq.Name,
-			Email:    userReq.Email,
-			Password: userReq.Password,
+	// Process in batches to avoid memory and database issues
+	batchSize := 50
+	for i := 0; i < len(req.Users); i += batchSize {
+		end := i + batchSize
+		if end > len(req.Users) {
+			end = len(req.Users)
 		}
-
-		userResponse, err := s.userProcessor.CreateUser(ctx, createReq)
+		
+		batch := req.Users[i:end]
+		batchResults, err := s.processBulkUserBatch(ctx, batch)
 		if err != nil {
-			response.Failed = append(response.Failed, contract.BulkUserErrorResult{
-				User:  userReq,
-				Error: err.Error(),
-			})
-			response.Summary.Failed++
-		} else {
-			response.Created = append(response.Created, *userResponse)
-			response.Summary.Succeeded++
+			// Log batch error but continue with other batches
+			for _, userReq := range batch {
+				response.Failed = append(response.Failed, contract.BulkUserErrorResult{
+					User:  userReq,
+					Error: "Batch processing error: " + err.Error(),
+				})
+				response.Summary.Failed++
+			}
+			continue
 		}
+		
+		response.Created = append(response.Created, batchResults.Created...)
+		response.Failed = append(response.Failed, batchResults.Failed...)
+		response.Summary.Succeeded += batchResults.Summary.Succeeded
+		response.Summary.Failed += batchResults.Summary.Failed
 	}
 
 	return response, nil
 }
 
+func (s *UserServiceImpl) processBulkUserBatch(ctx context.Context, batch []contract.BulkUserRequest) (*contract.BulkCreateUsersResponse, error) {
+	response := &contract.BulkCreateUsersResponse{
+		Created: []contract.UserResponse{},
+		Failed:  []contract.BulkUserErrorResult{},
+		Summary: contract.BulkCreationSummary{
+			Total:     len(batch),
+			Succeeded: 0,
+			Failed:    0,
+		},
+	}
+
+	// Use transaction for batch processing
+	created, failed, err := s.userProcessor.BulkCreateUsersWithTransaction(ctx, batch)
+	if err != nil {
+		return response, err
+	}
+
+	response.Created = created
+	response.Failed = failed
+	response.Summary.Succeeded = len(created)
+	response.Summary.Failed = len(failed)
+
+	return response, nil
+}
+
 func (s *UserServiceImpl) UpdateUser(ctx context.Context, id uuid.UUID, req *contract.UpdateUserRequest) (*contract.UserResponse, error) {
 	return s.userProcessor.UpdateUser(ctx, id, req)
 }