Merge pull request #2398 from rajithacharith/env

Add env variables to export request

Author: rajithacharith

api/WIP/export.yaml

@@ -23,6 +23,7 @@ import (
 	"bytes"
 	"fmt"
 	"net/http"
+	"strings"
 
 	serverconst "github.com/asgardeo/thunder/internal/system/constants"
 	"github.com/asgardeo/thunder/internal/system/error/apierror"
@@ -42,7 +43,7 @@ func newExportHandler(service ExportServiceInterface) *exportHandler {
 	}
 }
 
-// HandleExportRequest handles the export request and returns YAML content.
+// HandleExportJSONRequest handles the export request and returns JSON with files.
 func (eh *exportHandler) HandleExportRequest(w http.ResponseWriter, r *http.Request) {
 	logger := log.GetLogger().With(log.String(log.LoggerKeyComponentName, "ExportHandler"))
 
@@ -60,52 +61,38 @@ func (eh *exportHandler) HandleExportRequest(w http.ResponseWriter, r *http.Requ
 	// Export resources using the export service
 	exportResponse, svcErr := eh.service.ExportResources(r.Context(), exportRequest)
 	if svcErr != nil {
+		if svcErr.Type == serviceerror.ServerErrorType {
+			logger.Error("Error exporting resources", log.Any("serviceError", svcErr))
+		}
 		eh.handleError(w, svcErr)
 		return
 	}
 
-	// Combine all YAML files into a single response with separators
-	var combinedYAML string
-	for i, file := range exportResponse.Files {
-		if i > 0 {
-			combinedYAML += "\n---\n" // YAML document separator
-		}
-		combinedYAML += "# File: " + file.FileName + "\n"
-		combinedYAML += file.Content
+	jsonResponse := JSONExportResponse{
+		Resources:            buildCombinedResources(exportResponse.Files),
+		EnvironmentVariables: "",
 	}
-
-	// Return the combined YAML content
-	w.Header().Set(serverconst.ContentTypeHeaderName, "application/yaml")
-	w.WriteHeader(http.StatusOK)
-
-	if _, err := w.Write([]byte(combinedYAML)); err != nil {
-		logger.Error("Error writing YAML response", log.Error(err))
-		return
+	if exportResponse.EnvFile != nil {
+		jsonResponse.EnvironmentVariables = exportResponse.EnvFile.Content
 	}
+
+	sysutils.WriteSuccessResponse(w, http.StatusOK, jsonResponse)
 }
 
-// HandleExportJSONRequest handles the export request and returns JSON with files.
-func (eh *exportHandler) HandleExportJSONRequest(w http.ResponseWriter, r *http.Request) {
-	exportRequest, err := sysutils.DecodeJSONBody[ExportRequest](r)
-	if err != nil {
-		errResp := apierror.ErrorResponse{
-			Code:        ErrorInvalidRequest.Code,
-			Message:     ErrorInvalidRequest.Error,
-			Description: ErrorInvalidRequest.ErrorDescription,
-		}
-		sysutils.WriteErrorResponse(w, http.StatusBadRequest, errResp)
-		return
-	}
+func buildCombinedResources(files []ExportFile) string {
+	var builder strings.Builder
 
-	// Export resources using the export service
-	exportResponse, svcErr := eh.service.ExportResources(r.Context(), exportRequest)
-	if svcErr != nil {
-		eh.handleError(w, svcErr)
-		return
+	for i, file := range files {
+		if i > 0 {
+			builder.WriteString("\n---\n")
+		}
+		builder.WriteString("# File: ")
+		builder.WriteString(file.FileName)
+		builder.WriteString("\n")
+		builder.WriteString(file.Content)
 	}
 
-	// Return the JSON response with files
-	sysutils.WriteSuccessResponse(w, http.StatusOK, exportResponse)
+	return builder.String()
 }
 
 // HandleExportZipRequest handles the export request and returns a ZIP file containing all resources.
@@ -126,6 +113,9 @@ func (eh *exportHandler) HandleExportZipRequest(w http.ResponseWriter, r *http.R
 	// Export resources using the export service
 	exportResponse, svcErr := eh.service.ExportResources(r.Context(), exportRequest)
 	if svcErr != nil {
+		if svcErr.Type == serviceerror.ServerErrorType {
+			logger.Error("Error exporting resources", log.Any("serviceError", svcErr))
+		}
 		eh.handleError(w, svcErr)
 		return
 	}
@@ -170,6 +160,22 @@ func (eh *exportHandler) generateAndSendZipResponse(
 		}
 	}
 
+	if exportResponse.EnvFile != nil {
+		envWriter, err := zipWriter.Create(exportResponse.EnvFile.FileName)
+		if err != nil {
+			logger.Error("Error creating env file in ZIP", log.String("fileName", exportResponse.EnvFile.FileName),
+				log.Error(err))
+			return fmt.Errorf("failed to create env file in ZIP: %w", err)
+		}
+
+		if _, err = envWriter.Write([]byte(exportResponse.EnvFile.Content)); err != nil {
+			logger.Error("Error writing env file content to ZIP",
+				log.String("fileName", exportResponse.EnvFile.FileName),
+				log.Error(err))
+			return fmt.Errorf("failed to write env file content to ZIP: %w", err)
+		}
+	}
+
 	// Close the ZIP writer
 	if err := zipWriter.Close(); err != nil {
 		logger.Error("Error closing ZIP writer", log.Error(err))

api/export.yaml

@@ -113,6 +113,11 @@ func (suite *HandlerTestSuite) TestGenerateAndSendZipResponse_Success() {
 				Size:       42,
 			},
 		},
+		EnvFile: &EnvironmentFile{
+			FileName: ".env",
+			Content:  "TEST_APP_CLIENT_ID=\nTEST_APP_CLIENT_SECRET=\n",
+			Size:     44,
+		},
 		Summary: &ExportSummary{
 			TotalFiles: 2,
 			TotalSize:  84,
@@ -142,7 +147,7 @@ func (suite *HandlerTestSuite) TestGenerateAndSendZipResponse_Success() {
 	// Read and verify ZIP contents
 	zipReader, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))
 	assert.NoError(suite.T(), err)
-	assert.Len(suite.T(), zipReader.File, 2)
+	assert.Len(suite.T(), zipReader.File, 3)
 
 	// Verify first file
 	file1 := zipReader.File[0]
@@ -165,6 +170,17 @@ func (suite *HandlerTestSuite) TestGenerateAndSendZipResponse_Success() {
 	assert.Equal(suite.T(), "name: test-app-2\ndescription: Test Application 2", string(content2))
 	err = reader2.Close()
 	assert.NoError(suite.T(), err)
+
+	// Verify env file
+	envFile := zipReader.File[2]
+	assert.Equal(suite.T(), ".env", envFile.Name)
+	envReader, err := envFile.Open()
+	assert.NoError(suite.T(), err)
+	envContent, err := io.ReadAll(envReader)
+	assert.NoError(suite.T(), err)
+	assert.Equal(suite.T(), "TEST_APP_CLIENT_ID=\nTEST_APP_CLIENT_SECRET=\n", string(envContent))
+	err = envReader.Close()
+	assert.NoError(suite.T(), err)
 }
 
 // Helper function to test ZIP response generation
@@ -425,7 +441,7 @@ func TestNewExportHandler(t *testing.T) {
 
 // Handler Function Tests
 
-// TestHandleExportRequest_Success tests successful YAML export.
+// TestHandleExportRequest_Success tests successful JSON export on the /export endpoint.
 func (suite *HandlerTestSuite) TestHandleExportRequest_Success() {
 	// Setup mock expectations
 	suite.mockAppService.EXPECT().GetApplication(mock.Anything, "app1").Return(&model.Application{
@@ -455,12 +471,14 @@ func (suite *HandlerTestSuite) TestHandleExportRequest_Success() {
 
 	// Assert response
 	assert.Equal(suite.T(), http.StatusOK, w.Code)
-	assert.Equal(suite.T(), "application/yaml", w.Header().Get("Content-Type"))
+	assert.Equal(suite.T(), "application/json", w.Header().Get("Content-Type"))
 
-	responseBody := w.Body.String()
-	assert.NotEmpty(suite.T(), responseBody)
-	assert.Contains(suite.T(), responseBody, "# File:")
-	assert.Contains(suite.T(), responseBody, "name: Test App 1")
+	var response JSONExportResponse
+	err := json.Unmarshal(w.Body.Bytes(), &response)
+	assert.NoError(suite.T(), err)
+	assert.Contains(suite.T(), response.Resources, "# File: Test_App_1.yaml")
+	assert.Contains(suite.T(), response.Resources, "name: Test App 1")
+	assert.Equal(suite.T(), "", response.EnvironmentVariables)
 }
 
 // TestHandleExportRequest_InvalidJSON tests invalid JSON request handling.
@@ -505,8 +523,6 @@ func (suite *HandlerTestSuite) testServiceErrorResponse(
 	switch endpoint {
 	case "/export":
 		suite.handler.HandleExportRequest(w, req)
-	case "/export/json":
-		suite.handler.HandleExportJSONRequest(w, req)
 	case "/export/zip":
 		suite.handler.HandleExportZipRequest(w, req)
 	}
@@ -526,7 +542,7 @@ func (suite *HandlerTestSuite) TestHandleExportRequest_ServiceError() {
 	suite.testServiceErrorResponse("POST", "/export", "app1", &ErrorNoResourcesFound, "EXP-1002")
 }
 
-// TestHandleExportRequest_MultipleFiles tests YAML export with multiple files.
+// TestHandleExportRequest_MultipleFiles tests JSON export with multiple files.
 func (suite *HandlerTestSuite) TestHandleExportRequest_MultipleFiles() {
 	// Setup mock expectations for multiple applications
 	suite.mockAppService.EXPECT().GetApplication(mock.Anything, "app1").Return(&model.Application{
@@ -554,16 +570,17 @@ func (suite *HandlerTestSuite) TestHandleExportRequest_MultipleFiles() {
 
 	// Assert response
 	assert.Equal(suite.T(), http.StatusOK, w.Code)
-	responseBody := w.Body.String()
-
-	// Verify YAML separator between files
-	assert.Contains(suite.T(), responseBody, "---")
-	assert.Contains(suite.T(), responseBody, "name: App One")
-	assert.Contains(suite.T(), responseBody, "name: App Two")
+	assert.Equal(suite.T(), "application/json", w.Header().Get("Content-Type"))
 
-	// Count file headers
-	fileHeaders := strings.Count(responseBody, "# File:")
-	assert.Equal(suite.T(), 2, fileHeaders)
+	var response JSONExportResponse
+	err := json.Unmarshal(w.Body.Bytes(), &response)
+	assert.NoError(suite.T(), err)
+	assert.Contains(suite.T(), response.Resources, "# File: App_One.yaml")
+	assert.Contains(suite.T(), response.Resources, "# File: App_Two.yaml")
+	assert.Contains(suite.T(), response.Resources, "name: App One")
+	assert.Contains(suite.T(), response.Resources, "name: App Two")
+	assert.Contains(suite.T(), response.Resources, "---")
+	assert.Equal(suite.T(), "", response.EnvironmentVariables)
 }
 
 // TestHandleExportJSONRequest_Success tests successful JSON export.
@@ -585,37 +602,34 @@ func (suite *HandlerTestSuite) TestHandleExportJSONRequest_Success() {
 	requestJSON, _ := json.Marshal(requestBody)
 
 	// Create HTTP request
-	req := httptest.NewRequest("POST", "/export/json", bytes.NewReader(requestJSON))
+	req := httptest.NewRequest("POST", "/export", bytes.NewReader(requestJSON))
 	req.Header.Set("Content-Type", "application/json")
 	w := httptest.NewRecorder()
 
 	// Execute
-	suite.handler.HandleExportJSONRequest(w, req)
+	suite.handler.HandleExportRequest(w, req)
 
 	// Assert response
 	assert.Equal(suite.T(), http.StatusOK, w.Code)
 	assert.Equal(suite.T(), "application/json", w.Header().Get("Content-Type"))
 
-	var response ExportResponse
+	var response JSONExportResponse
 	err := json.Unmarshal(w.Body.Bytes(), &response)
 	assert.NoError(suite.T(), err)
-	assert.Len(suite.T(), response.Files, 1)
-	// Note: Service currently generates YAML files even with JSON format (fallback behavior)
-	assert.Equal(suite.T(), "Test_App_JSON.yaml", response.Files[0].FileName)
-	assert.Contains(suite.T(), response.Files[0].Content, "Test App JSON")
-	assert.NotNil(suite.T(), response.Summary)
-	assert.Equal(suite.T(), 1, response.Summary.TotalFiles)
+	assert.Contains(suite.T(), response.Resources, "# File: Test_App_JSON.yaml")
+	assert.Contains(suite.T(), response.Resources, "name: Test App JSON")
+	assert.Equal(suite.T(), "", response.EnvironmentVariables)
 }
 
 // TestHandleExportJSONRequest_InvalidJSON tests invalid JSON handling for JSON export.
 func (suite *HandlerTestSuite) TestHandleExportJSONRequest_InvalidJSON() {
 	// Create malformed JSON request
-	req := httptest.NewRequest("POST", "/export/json", strings.NewReader("invalid"))
+	req := httptest.NewRequest("POST", "/export", strings.NewReader("invalid"))
 	req.Header.Set("Content-Type", "application/json")
 	w := httptest.NewRecorder()
 
 	// Execute
-	suite.handler.HandleExportJSONRequest(w, req)
+	suite.handler.HandleExportRequest(w, req)
 
 	// Assert error response
 	assert.Equal(suite.T(), http.StatusBadRequest, w.Code)
@@ -630,7 +644,7 @@ func (suite *HandlerTestSuite) TestHandleExportJSONRequest_InvalidJSON() {
 // TestHandleExportJSONRequest_ServiceError tests service error handling for JSON export.
 func (suite *HandlerTestSuite) TestHandleExportJSONRequest_ServiceError() {
 	// Setup mock to return service error
-	suite.testServiceErrorResponse("POST", "/export/json", "app1", &serviceerror.InternalServerError, "EXP-1002")
+	suite.testServiceErrorResponse("POST", "/export", "app1", &serviceerror.InternalServerError, "EXP-1002")
 }
 
 // TestHandleExportZipRequest_Success tests successful ZIP export.
@@ -790,7 +804,7 @@ func (suite *HandlerTestSuite) TestHandleExportRequest_NilOptions() {
 
 	// Assert successful response with default behavior
 	assert.Equal(suite.T(), http.StatusOK, w.Code)
-	assert.Equal(suite.T(), "application/yaml", w.Header().Get("Content-Type"))
+	assert.Equal(suite.T(), "application/json", w.Header().Get("Content-Type"))
 }
 
 // TestHandleExportJSONRequest_EmptyFiles tests JSON export with no files.
@@ -802,12 +816,12 @@ func (suite *HandlerTestSuite) TestHandleExportJSONRequest_EmptyFiles() {
 	requestJSON, _ := json.Marshal(requestBody)
 
 	// Create HTTP request
-	req := httptest.NewRequest("POST", "/export/json", bytes.NewReader(requestJSON))
+	req := httptest.NewRequest("POST", "/export", bytes.NewReader(requestJSON))
 	req.Header.Set("Content-Type", "application/json")
 	w := httptest.NewRecorder()
 
 	// Execute
-	suite.handler.HandleExportJSONRequest(w, req)
+	suite.handler.HandleExportRequest(w, req)
 
 	// Assert error response (empty applications list returns NoResourcesFound error)
 	assert.Equal(suite.T(), http.StatusBadRequest, w.Code)
@@ -919,9 +933,9 @@ func BenchmarkHandleExportJSONRequest(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		req := httptest.NewRequest("POST", "/export/json", bytes.NewReader(requestJSON))
+		req := httptest.NewRequest("POST", "/export", bytes.NewReader(requestJSON))
 		req.Header.Set("Content-Type", "application/json")
 		w := httptest.NewRecorder()
-		handler.HandleExportJSONRequest(w, req)
+		handler.HandleExportRequest(w, req)
 	}
 }

backend/internal/system/export/handler.go

@@ -50,14 +50,10 @@ func registerRoutes(mux *http.ServeMux, exportHandler *exportHandler) {
 		AllowCredentials: true,
 	}
 
-	// YAML export endpoint - returns application/yaml
+	// JSON export endpoint
 	mux.HandleFunc(middleware.WithCORS("POST /export",
 		exportHandler.HandleExportRequest, opts))
 
-	// JSON export endpoint - returns JSON with files (for backward compatibility)
-	mux.HandleFunc(middleware.WithCORS("POST /export/json",
-		exportHandler.HandleExportJSONRequest, opts))
-
 	// ZIP export endpoint - returns application/zip with individual files
 	mux.HandleFunc(middleware.WithCORS("POST /export/zip",
 		exportHandler.HandleExportZipRequest, opts))

backend/internal/system/export/handler_test.go

@@ -139,8 +139,8 @@ func (suite *InitTestSuite) TestRegisterRoutes() {
 	})
 }
 
-// TestRegisterRoutes_YAMLEndpoint tests the YAML export endpoint registration
-func (suite *InitTestSuite) TestRegisterRoutes_YAMLEndpoint() {
+// TestRegisterRoutes_JSONEndpoint tests the JSON export endpoint registration.
+func (suite *InitTestSuite) TestRegisterRoutes_JSONEndpoint() {
 	mux := http.NewServeMux()
 	exporters := createTestExporters(suite.mockAppService, suite.mockIDPService,
 		suite.mockNotificationService, suite.mockUserSchemaService)
@@ -161,27 +161,6 @@ func (suite *InitTestSuite) TestRegisterRoutes_YAMLEndpoint() {
 	assert.NotEqual(suite.T(), http.StatusNotFound, w.Code)
 }
 
-// TestRegisterRoutes_JSONEndpoint tests the JSON export endpoint registration
-func (suite *InitTestSuite) TestRegisterRoutes_JSONEndpoint() {
-	mux := http.NewServeMux()
-	exporters := createTestExporters(suite.mockAppService, suite.mockIDPService,
-		suite.mockNotificationService, suite.mockUserSchemaService)
-	mockService := newExportService(exporters, newParameterizer(templatingRules{}))
-	exportHandler := newExportHandler(mockService)
-
-	registerRoutes(mux, exportHandler)
-
-	// Test POST /export/json endpoint
-	req := httptest.NewRequest("POST", "/export/json", strings.NewReader(`{}`))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	// Should not be 404 (route exists)
-	assert.NotEqual(suite.T(), http.StatusNotFound, w.Code)
-}
-
 // TestRegisterRoutes_ZIPEndpoint tests the ZIP export endpoint registration
 func (suite *InitTestSuite) TestRegisterRoutes_ZIPEndpoint() {
 	mux := http.NewServeMux()
@@ -446,7 +425,6 @@ func TestRouteHandling_Standalone(t *testing.T) {
 		expectNotFound bool
 	}{
 		{"POST", "/export", false},
-		{"POST", "/export/json", false},
 		{"POST", "/export/zip", false},
 		{"OPTIONS", "/export", false},
 		{"GET", "/export", true},   // Should be method not allowed, not not found