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

context_request.go

@@ -34,9 +34,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 {
+            		fmt.Println("LogFacade is nil, error:", fmt.Sprintf("%+v", errors.Unwrap(err)))
+        	}
 	}
-
 	return &ContextRequest{ctx: ctx, instance: ctx.instance, httpBody: httpBody, log: log, validation: validation}
 }
 

context_request_test.go

@@ -45,6 +45,9 @@
 
 	var err error
 	s.route, err = NewRoute(s.mockConfig, nil)
+	if s.route == nil {
+    		fmt.Println("NewRoute returned nil")
+	}
 	s.Require().Nil(err)
 }
 
@@ -53,7 +56,7 @@
 }
 
 func (s *ContextRequestSuite) TestAll() {
 	s.route.Get("/all", func(ctx contractshttp.Context) contractshttp.Response {
 		return ctx.Response().Success().Json(contractshttp.Json{
 			"all": ctx.Request().All(),
 		})

facades/gin.go

@@ -1,21 +1,27 @@
 package facades
 
 import (
+	"fmt"
 	"log"
 
 	"github.com/goravel/framework/contracts/route"
-
 	"github.com/goravel/gin"
 )
 
 func Route(driver string) route.Route {
-	instance, err := gin.App.MakeWith(gin.RouteBinding, map[string]any{
-		"driver": driver,
-	})
-	if err != nil {
-		log.Fatalln(err)
+	if gin.App != nil {
+		instance, err := gin.App.MakeWith(gin.RouteBinding, map[string]any{
+			"driver": driver,
+		})
+
+		if err != nil {
+			log.Fatalln(err)
+			return nil
+		}
+
+		return instance.(*gin.Route)
+	} else {
+		fmt.Println("App is nil")
 		return nil
 	}
-
-	return instance.(*gin.Route)
 }

middleware_timeout.go

@@ -10,7 +10,7 @@ import (
 )
 
 // Timeout creates middleware to set a timeout for a request
-func Timeout(timeout time.Duration) contractshttp.Middleware {
+func Timeout(timeout time.Duration, recoverFunc func(ctx contractshttp.Context, err interface{})) contractshttp.Middleware {
 	return func(ctx contractshttp.Context) {
 		timeoutCtx, cancel := context.WithTimeout(ctx.Context(), timeout)
 		defer cancel()
@@ -22,12 +22,15 @@ func Timeout(timeout time.Duration) contractshttp.Middleware {
 		go func() {
 			defer func() {
 				if r := recover(); r != nil {
-					if LogFacade != nil {
-						LogFacade.Request(ctx.Request()).Error(r)
+					// Use the custom recoverFunc if provided, otherwise fallback to default behavior
+					if recoverFunc != nil {
+						recoverFunc(ctx, r)
+					} else {
+						if LogFacade != nil {
+							LogFacade.Request(ctx.Request()).Error(r)
+						}
+						_ = ctx.Response().Status(http.StatusInternalServerError).String("Internal Server Error").Render()
 					}
-
-					// TODO can be customized in https://github.com/goravel/goravel/issues/521
-					_ = ctx.Response().Status(http.StatusInternalServerError).String("Internal Server Error").Render()
 				}
 
 				close(done)

middleware_timeout_test.go

@@ -14,23 +14,23 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestTimeoutMiddleware(t *testing.T) {
+func TestTmeoutMiddleware(t *testing.T) {
 	mockConfig := mocksconfig.NewConfig(t)
 	mockConfig.EXPECT().GetBool("app.debug").Return(true).Once()
 	mockConfig.EXPECT().GetInt("http.drivers.gin.body_limit", 4096).Return(4096).Once()
 
 	route, err := NewRoute(mockConfig, nil)
 	require.NoError(t, err)
 
-	route.Middleware(Timeout(1*time.Second)).Get("/timeout", func(ctx contractshttp.Context) contractshttp.Response {
+	route.Middleware(Timeout(1*time.Second, nil)).Get("/timeout", func(ctx contractshttp.Context) contractshttp.Response {
 		time.Sleep(2 * time.Second)
 
 		return ctx.Response().Success().String("timeout")
 	})
-	route.Middleware(Timeout(1*time.Second)).Get("/normal", func(ctx contractshttp.Context) contractshttp.Response {
+	route.Middleware(Timeout(1*time.Second, nil)).Get("/normal", func(ctx contractshttp.Context) contractshttp.Response {
 		return ctx.Response().Success().String("normal")
 	})
-	route.Middleware(Timeout(1*time.Second)).Get("/panic", func(ctx contractshttp.Context) contractshttp.Response {
+	route.Middleware(Timeout(1*time.Second, nil)).Get("/panic", func(ctx contractshttp.Context) contractshttp.Response {
 		panic(1)
 	})
 

route.go

@@ -82,12 +82,27 @@ func (r *Route) Fallback(handler httpcontract.HandlerFunc) {
 func (r *Route) GlobalMiddleware(middlewares ...httpcontract.Middleware) {
 	timeout := time.Duration(r.config.GetInt("http.request_timeout", 3)) * time.Second
 	defaultMiddlewares := []httpcontract.Middleware{
-		Cors(), Tls(), Timeout(timeout),
+		Cors(), Tls(), Timeout(timeout, nil),
 	}
 	middlewares = append(defaultMiddlewares, middlewares...)
 	r.setMiddlewares(middlewares)
 }
 
+func (r *Route) Recover(recoverFunc func(ctx *gin.Context, err interface{})) {
+    r.instance.Use(func(ctx *gin.Context) {
+        defer func() {
+            if err := recover(); err != nil {
+                if recoverFunc != nil {
+                    recoverFunc(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"
@@ -35,13 +36,18 @@ func (receiver *ServiceProvider) Boot(app foundation.Application) {
 
 	if ConfigFacade = app.MakeConfig(); ConfigFacade == nil {
 		color.Errorln(errors.ConfigFacadeNotSet.SetModule(module))
+		shutdownOnCriticalError("ConfigFacade is not set")
 	}
+
 	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 +56,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 (receive *View) Make(view string, data ...any) contractshttp.Response {
-	shared := ViewFacade.GetShared()
+	var shared map[string]any
+	if ViewFacade != nil {
+		shared = ViewFacade.GetShared()
+	} else {
+		fmt.Println("ViewFacade is nil")
+	}
+
 	if len(data) == 0 {
 		return &HtmlResponse{shared, receive.instance, view}
 	} else {
@@ -26,13 +32,11 @@
 		case reflect.Struct:
 			dataMap := structToMap(data[0])
 			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) 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")
 		}
 	}
 
@@ -66,6 +72,7 @@
 		}
 		dbColumn := modelType.Field(i).Name
 		if modelValue.Field(i).Kind() == reflect.Pointer {
+			// Если поле - указатель, проверяем, не является ли оно nil
 			if modelValue.Field(i).IsNil() {
 				res[dbColumn] = nil
 			} else {
@@ -82,6 +89,7 @@
 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 +98,7 @@
 				break
 			}
 		}
+
 		if !exist {
 			dataValue.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(value))
 		}