.github/workflows/build.yml

@@ -34,7 +34,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v3
       - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
+        uses: golangci/golangci-lint-action@v3.3.1
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.

.github/workflows/dependabot-automerge.yml

@@ -15,7 +15,7 @@ jobs:
     steps:
       - name: metadata
         id: metadata
-        uses: dependabot/fetch-metadata@v1.3.6
+        uses: dependabot/fetch-metadata@v1.3.5
         with:
           github-token: "${{ secrets.TOKEN }}"
       - name: merge

.github/workflows/pr.yml

@@ -34,7 +34,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v3
       - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
+        uses: golangci/golangci-lint-action@v3.3.1
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.

go.mod

@@ -2,9 +2,4 @@ module go.unistack.org/micro-wrapper-recovery/v3
 
 go 1.16
 
-require (
+require go.unistack.org/micro/v3 v3.9.13
-	go.unistack.org/micro/v3 v3.10.66
-	golang.org/x/sys v0.19.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240415180920-8c6c420018be // indirect
-	google.golang.org/grpc v1.63.2 // indirect
-)

wrapper.go

@@ -1,63 +1,29 @@
-package recovery
+package recovery // import "go.unistack.org/micro-wrapper-recovery/v3"
 
 import (
 	"context"
 	"fmt"
 
-	"go.unistack.org/micro/v3/errors"
 	"go.unistack.org/micro/v3/server"
 )
 
-func NewOptions(opts ...Option) Options {
+type wrapper struct {
-	options := Options{
+	serverHandlerFunc    func(context.Context, server.Request, interface{}, error) error
-		ServerHandlerFn:    DefaultServerHandlerFn,
+	serverSubscriberFunc func(context.Context, server.Message, error) error
-		ServerSubscriberFn: DefaultServerSubscriberFn,
+	/*
-	}
+		clientCallFunc       func(context.Context, string, client.Request, interface{}, client.CallOptions, error) error
-	for _, o := range opts {
+		clientClient         func(client.Client, error) error
-		o(&options)
+	*/
-	}
-	return options
 }
 
-type Options struct {
+func NewServerHandlerWrapper(fn func(context.Context, server.Request, interface{}, error) error) server.HandlerWrapper {
-	ServerHandlerFn    func(context.Context, server.Request, interface{}, error) error
+	handler := &wrapper{
-	ServerSubscriberFn func(context.Context, server.Message, error) error
+		serverHandlerFunc: fn,
-}
-
-type Option func(*Options)
-
-func ServerHandlerFunc(fn func(context.Context, server.Request, interface{}, error) error) Option {
-	return func(o *Options) {
-		o.ServerHandlerFn = fn
 	}
+	return handler.HandlerFunc
 }
 
-func ServerSubscriberFunc(fn func(context.Context, server.Message, error) error) Option {
+func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
-	return func(o *Options) {
-		o.ServerSubscriberFn = fn
-	}
-}
-
-var (
-	DefaultServerHandlerFn = func(ctx context.Context, req server.Request, rsp interface{}, err error) error {
-		return errors.BadRequest("", "%v", err)
-	}
-	DefaultServerSubscriberFn = func(ctx context.Context, req server.Message, err error) error {
-		return errors.BadRequest("", "%v", err)
-	}
-)
-
-var Hook = NewHook()
-
-type hook struct {
-	opts Options
-}
-
-func NewHook(opts ...Option) *hook {
-	return &hook{opts: NewOptions(opts...)}
-}
-
-func (w *hook) ServerHandler(next server.FuncHandler) server.FuncHandler {
 	return func(ctx context.Context, req server.Request, rsp interface{}) (err error) {
 		defer func() {
 			r := recover()
@@ -65,17 +31,24 @@ func (w *hook) ServerHandler(next server.FuncHandler) server.FuncHandler {
 			case nil:
 				return
 			case error:
-				err = w.opts.ServerHandlerFn(ctx, req, rsp, verr)
+				err = w.serverHandlerFunc(ctx, req, rsp, verr)
 			default:
-				err = w.opts.ServerHandlerFn(ctx, req, rsp, fmt.Errorf("%v", r))
+				err = w.serverHandlerFunc(ctx, req, rsp, fmt.Errorf("%v", r))
 			}
 		}()
-		err = next(ctx, req, rsp)
+		err = fn(ctx, req, rsp)
 		return err
 	}
 }
 
-func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandler {
+func NewServerSubscriberWrapper(fn func(context.Context, server.Message, error) error) server.SubscriberWrapper {
+	handler := &wrapper{
+		serverSubscriberFunc: fn,
+	}
+	return handler.SubscriberFunc
+}
+
+func (w *wrapper) SubscriberFunc(fn server.SubscriberFunc) server.SubscriberFunc {
 	return func(ctx context.Context, msg server.Message) (err error) {
 		defer func() {
 			r := recover()
@@ -83,12 +56,79 @@ func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandle
 			case nil:
 				return
 			case error:
-				err = w.opts.ServerSubscriberFn(ctx, msg, verr)
+				err = w.serverSubscriberFunc(ctx, msg, verr)
 			default:
-				err = w.opts.ServerSubscriberFn(ctx, msg, fmt.Errorf("%v", r))
+				err = w.serverSubscriberFunc(ctx, msg, fmt.Errorf("%v", r))
 			}
 		}()
-		err = next(ctx, msg)
+		err = fn(ctx, msg)
 		return err
 	}
 }
+
+/*
+func NewClientWrapper() client.Wrapper {
+	return func(c client.Client) client.Client {
+		handler := &wrapper{
+			clientClient: c,
+		}
+		return handler
+	}
+}
+
+func NewCallWrapper() client.CallWrapper {
+	return func(fn client.CallFunc) client.CallFunc {
+		handler := &wrapper{
+			clientCallFunc: fn,
+		}
+		return handler.CallFunc
+	}
+}
+
+func (w *wrapper) CallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) (err error) {
+	defer func() {
+		r := recover()
+		switch verr := r.(type) {
+		case nil:
+			return
+		case error:
+			err = w.clientCallFunc(ctx, addr, req, rsp, opts, verr)
+		default:
+			err = w.clientCallFunc(ctx, addr, req, rsp, opts, fmt.Errorf("%v", r))
+		}
+	}()
+	err = w.CallFunc(ctx, addr, req, rsp, opts)
+	return err
+}
+
+func (w *wrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	defer func() {
+		r := recover()
+		switch verr := r.(type) {
+		case nil:
+			return
+		case error:
+			err = w.clientClient.Call(ctx, addr, req, rsp, opts, verr)
+		default:
+			err = w.clientClient.Call(ctx, addr, req, rsp, opts, fmt.Errorf("%v", r))
+		}
+	}()
+	err = w.clientClient.Call(ctx, req, rsp, opts...)
+	return err
+}
+
+func (w *wrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+
+	stream, err := w.Client.Stream(ctx, req, opts...)
+
+	return stream, err
+}
+
+func (w *wrapper) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
+
+	err := w.Client.Publish(ctx, p, opts...)
+
+
+	return err
+}
+*/