Implement options ApplyOptions helper

internal/handler/cache/middleware.go

@@ -21,11 +21,7 @@ type Middleware struct {
 }
 
 func NewMiddleware(options ...MiddlewareOption) *Middleware {
-	middleware := &Middleware{}
-
-	for _, option := range options {
-		option(middleware)
-	}
+	middleware := helpers.ApplyOptions(&Middleware{}, options)
 
 	helpers.AssertIsDefined(middleware.logger, "Logger is not configured")
 	helpers.AssertIsDefined(middleware.storage, "Cache storage is not configured")

internal/handler/mock/handler.go

@@ -1,6 +1,7 @@
 package mock
 
 import (
+	"github.com/evg4b/uncors/internal/helpers"
 	"net/http"
 	"time"
 
@@ -18,13 +19,7 @@ type Handler struct {
 }
 
 func NewMockHandler(options ...HandlerOption) *Handler {
-	handler := &Handler{}
-
-	for _, option := range options {
-		option(handler)
-	}
-
-	return handler
+	return helpers.ApplyOptions(&Handler{}, options)
 }
 
 func (h *Handler) ServeHTTP(writer contracts.ResponseWriter, request *contracts.Request) {

internal/handler/proxy/handler.go

@@ -18,11 +18,7 @@ type Handler struct {
 }
 
 func NewProxyHandler(options ...HandlerOption) *Handler {
-	middleware := &Handler{}
-
-	for _, option := range options {
-		option(middleware)
-	}
+	middleware := helpers.ApplyOptions(&Handler{}, options)
 
 	helpers.AssertIsDefined(middleware.replacers, "ProxyHandler: ReplacerFactory is not configured")
 	helpers.AssertIsDefined(middleware.logger, "ProxyHandler: Logger is not configured")

internal/handler/static/middleware.go

@@ -19,6 +19,10 @@ type Middleware struct {
 	prefix string
 }
 
+func NewStaticMiddleware(options ...MiddlewareOption) *Middleware {
+	return helpers.ApplyOptions(&Middleware{}, options)
+}
+
 func (h *Middleware) Wrap(next contracts.Handler) contracts.Handler {
 	return contracts.HandlerFunc(func(writer contracts.ResponseWriter, request *contracts.Request) {
 		response := contracts.WrapResponseWriter(writer)
@@ -42,16 +46,6 @@ func (h *Middleware) Wrap(next contracts.Handler) contracts.Handler {
 	})
 }
 
-func NewStaticMiddleware(options ...MiddlewareOption) *Middleware {
-	handler := &Middleware{}
-
-	for _, option := range options {
-		option(handler)
-	}
-
-	return handler
-}
-
 func (h *Middleware) extractFilePath(request *http.Request) string {
 	filePath := strings.TrimPrefix(request.URL.Path, h.prefix)
 	if !strings.HasPrefix(filePath, "/") {

internal/handler/uncors_handler.go

@@ -35,14 +35,7 @@ type RequestHandler struct {
 var errHostNotMapped = errors.New("host not mapped")
 
 func NewUncorsRequestHandler(options ...RequestHandlerOption) *RequestHandler {
-	handler := &RequestHandler{
-		Router:   mux.NewRouter(),
-		mappings: config.Mappings{},
-	}
-
-	for _, option := range options {
-		option(handler)
-	}
+	handler := helpers.ApplyOptions(&RequestHandler{Router: mux.NewRouter(), mappings: config.Mappings{}}, options)
 
 	helpers.AssertIsDefined(handler.cacheMiddlewareFactory, "Cache middleware is not set")
 

internal/helpers/structures.go

@@ -0,0 +1,9 @@
+package helpers
+
+func ApplyOptions[T any](service *T, options []func(*T)) *T {
+	for _, option := range options {
+		option(service)
+	}
+
+	return service
+}

internal/helpers/structures_test.go

@@ -0,0 +1,38 @@
+package helpers_test
+
+import (
+	"github.com/evg4b/uncors/internal/helpers"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+type myService struct {
+	service string
+}
+
+func TestApplyOptions(t *testing.T) {
+	t.Run("ApplyOptions sets service value", func(t *testing.T) {
+		const testValue = "TestValue"
+
+		service := &myService{}
+		options := []func(*myService){
+			func(s *myService) {
+				s.service = testValue
+			},
+		}
+
+		result := helpers.ApplyOptions(service, options)
+
+		assert.Equal(t, service, result, "The same service should be returned")
+		assert.Equal(t, testValue, result.service, "Service option should be applied")
+	})
+
+	t.Run("ApplyOptions handles empty options", func(t *testing.T) {
+		service := &myService{}
+
+		result := helpers.ApplyOptions(service, nil)
+
+		assert.Equal(t, service, result, "The same service should be returned")
+		assert.Equal(t, "", result.service, "Service value should not be applied")
+	})
+}

internal/log/logger.go

@@ -2,6 +2,7 @@ package log
 
 import (
 	"github.com/evg4b/uncors/internal/contracts"
+	"github.com/evg4b/uncors/internal/helpers"
 	"github.com/pterm/pterm"
 )
 
@@ -29,11 +30,7 @@ func NewLogger(name string, options ...LoggerOption) *PrefixedLogger {
 		},
 	}
 
-	for _, option := range options {
-		option(logger)
-	}
-
-	return logger
+	return helpers.ApplyOptions(logger, options)
 }
 
 func (logger *PrefixedLogger) Error(v ...any) {