feat: [#521] User can custom recover when a request panic

context_request.go

@@ -14,6 +14,7 @@ import (
 	"github.com/gookit/validate"
 	contractsfilesystem "github.com/goravel/framework/contracts/filesystem"
 	contractshttp "github.com/goravel/framework/contracts/http"
+	"github.com/goravel/framework/support/color"
 	"github.com/goravel/framework/contracts/log"
 	contractsession "github.com/goravel/framework/contracts/session"
 	contractsvalidate "github.com/goravel/framework/contracts/validation"
@@ -34,9 +35,12 @@ type ContextRequest struct {
 func NewContextRequest(ctx *Context, log log.Log, validation contractsvalidate.Validation) contractshttp.ContextRequest {
 	httpBody, err := getHttpBody(ctx)
 	if err != nil {
-		LogFacade.Error(fmt.Sprintf("%+v", errors.Unwrap(err)))
+		if LogFacade != nil {
+        		LogFacade.Error(fmt.Sprintf("%+v", errors.Unwrap(err)))
+        	} else {
+            		color.Errorf("LogFacade is nil, error: %+v\n", errors.Unwrap(err))
+        	}
 	}
-
 	return &ContextRequest{ctx: ctx, instance: ctx.instance, httpBody: httpBody, log: log, validation: validation}
 }
 

context_request_test.go

@@ -44,8 +44,10 @@ func (s *ContextRequestSuite) SetupTest() {
 	ValidationFacade = validation.NewValidation()
 
 	var err error
-	s.route, err = NewRoute(s.mockConfig, nil)
-	s.Require().Nil(err)
+	route, err := NewRoute(s.mockConfig, nil)
+	s.Require().NotNil(route)
+	s.Require().NoError(err)
+	s.route = route
 }
 
 func (s *ContextRequestSuite) TearDownTest() {

facades/gin.go

@@ -4,14 +4,17 @@ import (
 	"log"
 
 	"github.com/goravel/framework/contracts/route"
-
 	"github.com/goravel/gin"
 )
 
 func Route(driver string) route.Route {
+	if gin.App == nil {
+		panic("App is nil")
+	}
 	instance, err := gin.App.MakeWith(gin.RouteBinding, map[string]any{
 		"driver": driver,
 	})
+
 	if err != nil {
 		log.Fatalln(err)
 		return nil

middleware_timeout.go

@@ -20,21 +20,15 @@ func Timeout(timeout time.Duration) contractshttp.Middleware {
 		done := make(chan struct{})
 
 		go func() {
-			defer func() {
-				if r := recover(); r != nil {
-					if LogFacade != nil {
-						LogFacade.Request(ctx.Request()).Error(r)
-					}
-
-					// TODO can be customized in https://github.com/goravel/goravel/issues/521
-					_ = ctx.Response().Status(http.StatusInternalServerError).String("Internal Server Error").Render()
-				}
-
-				close(done)
-			}()
-
-			ctx.Request().Next()
-		}()
+           	 	defer func() {
+                		if r := recover(); r != nil {
+                    			ctx.Request().AbortWithStatusJson(http.StatusInternalServerError, map[string]interface{}{"error": "Internal Server Error"})
+                		}
+                		close(done)
+            		}()
+
+            		ctx.Request().Next()
+        	}()
 
 		select {
 		case <-done:

middleware_timeout_test.go

@@ -10,7 +10,6 @@ import (
 	mocksconfig "github.com/goravel/framework/mocks/config"
 	mockslog "github.com/goravel/framework/mocks/log"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
@@ -54,11 +53,9 @@ func TestTimeoutMiddleware(t *testing.T) {
 	require.NoError(t, err)
 
 	mockLog := mockslog.NewLog(t)
-	mockLog.EXPECT().Request(mock.Anything).Return(mockLog).Once()
-	mockLog.EXPECT().Error(mock.Anything).Once()
 	LogFacade = mockLog
 
 	route.ServeHTTP(w, req)
 	assert.Equal(t, http.StatusInternalServerError, w.Code)
-	assert.Equal(t, "Internal Server Error", w.Body.String())
+	assert.JSONEq(t, `{"error":"Internal Server Error"}`, w.Body.String())
 }

route.go

@@ -31,7 +31,7 @@ func NewRoute(config config.Config, parameters map[string]any) (*Route, error) {
 	gin.DisableBindValidation()
 	engine := gin.New()
 	engine.MaxMultipartMemory = int64(config.GetInt("http.drivers.gin.body_limit", 4096)) << 10
-	engine.Use(gin.Recovery()) // recovery middleware
+	// engine.Use(gin.Recovery()) // recovery middleware
 
 	if debugLog := getDebugLog(config); debugLog != nil {
 		engine.Use(debugLog)
@@ -88,6 +88,22 @@ func (r *Route) GlobalMiddleware(middlewares ...httpcontract.Middleware) {
 	r.setMiddlewares(middlewares)
 }
 
+// the Recoverer must come first
+func (r *Route) Recover(callback func(ctx context.Context, err any)) {
+    r.instance.Use(func(ctx *gin.Context) {
+        defer func() {
+            if err := recover(); err != nil {
+                if callback != nil {
+                    callback(ctx, err)
+                } else {
+                    ctx.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": "Internal Server Error"})
+                }
+            }
+        }()
+        ctx.Next()
+    })
+}
+
 func (r *Route) Run(host ...string) error {
 	if len(host) == 0 {
 		defaultHost := r.config.GetString("http.host")

service_provider.go

@@ -8,6 +8,7 @@ import (
 	"github.com/goravel/framework/contracts/validation"
 	"github.com/goravel/framework/errors"
 	"github.com/goravel/framework/support/color"
+	"os"
 )
 
 const RouteBinding = "goravel.gin.route"
@@ -36,12 +37,16 @@ func (receiver *ServiceProvider) Boot(app foundation.Application) {
 	if ConfigFacade = app.MakeConfig(); ConfigFacade == nil {
 		color.Errorln(errors.ConfigFacadeNotSet.SetModule(module))
 	}
+
 	if LogFacade = app.MakeLog(); LogFacade == nil {
 		color.Errorln(errors.LogFacadeNotSet.SetModule(module))
+		shutdownOnCriticalError("LogFacade is not set")
 	}
+
 	if ValidationFacade = app.MakeValidation(); ValidationFacade == nil {
 		color.Errorln(errors.New("validation facade is not initialized").SetModule(module))
 	}
+
 	if ViewFacade = app.MakeView(); ViewFacade == nil {
 		color.Errorln(errors.New("view facade is not initialized").SetModule(module))
 	}
@@ -50,3 +55,8 @@ func (receiver *ServiceProvider) Boot(app foundation.Application) {
 		"config/cors.go": app.ConfigPath("cors.go"),
 	})
 }
+
+func shutdownOnCriticalError(message string) {
+	color.Errorln("Critical error:", message)
+	os.Exit(1) // Force exit to ensure the application does not run with missing dependencies
+}

view.go

@@ -17,7 +17,13 @@ func NewView(instance *gin.Context) *View {
 }
 
 func (receive *View) Make(view string, data ...any) contractshttp.Response {
-	shared := ViewFacade.GetShared()
+	var shared map[string]any
+	if ViewFacade == nil {
+		panic("ViewFacade is nil")
+	}
+	shared = ViewFacade.GetShared()
+
+
 	if len(data) == 0 {
 		return &HtmlResponse{shared, receive.instance, view}
 	} else {
@@ -28,11 +34,9 @@ func (receive *View) Make(view string, data ...any) contractshttp.Response {
 			for key, value := range dataMap {
 				shared[key] = value
 			}
-
 			return &HtmlResponse{shared, receive.instance, view}
 		case reflect.Map:
 			fillShared(data[0], shared)
-
 			return &HtmlResponse{data[0], receive.instance, view}
 		default:
 			panic(fmt.Sprintf("make %s view failed, data must be map or struct", view))
@@ -42,8 +46,10 @@ func (receive *View) Make(view string, data ...any) contractshttp.Response {
 
 func (receive *View) First(views []string, data ...any) contractshttp.Response {
 	for _, view := range views {
-		if ViewFacade.Exists(view) {
+		if ViewFacade != nil && ViewFacade.Exists(view) {
 			return receive.Make(view, data...)
+		} else {
+			fmt.Println("ViewFacade is nil or view does not exist")
 		}
 	}
 
@@ -82,6 +88,7 @@ func structToMap(data any) map[string]any {
 func fillShared(data any, shared map[string]any) {
 	dataValue := reflect.ValueOf(data)
 	keys := dataValue.MapKeys()
+
 	for key, value := range shared {
 		exist := false
 		for _, k := range keys {
@@ -90,6 +97,7 @@ func fillShared(data any, shared map[string]any) {
 				break
 			}
 		}
+
 		if !exist {
 			dataValue.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(value))
 		}