update for latest micro

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

.github/workflows/build.yml

@@ -34,7 +34,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v3
       - name: lint
-        uses: golangci/golangci-lint-action@v3.3.1
+        uses: golangci/golangci-lint-action@v3.4.0
         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.5
+        uses: dependabot/fetch-metadata@v1.3.6
         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.3.1
+        uses: golangci/golangci-lint-action@v3.4.0
         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,4 +2,9 @@ module go.unistack.org/micro-wrapper-recovery/v3
 
 go 1.16
 
-require go.unistack.org/micro/v3 v3.9.13
+require (
+	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,29 +1,63 @@
-package recovery // import "go.unistack.org/micro-wrapper-recovery/v3"
+package recovery
 
 import (
 	"context"
 	"fmt"
 
+	"go.unistack.org/micro/v3/errors"
 	"go.unistack.org/micro/v3/server"
 )
 
-type wrapper struct {
-	serverHandlerFunc    func(context.Context, server.Request, interface{}, error) error
-	serverSubscriberFunc func(context.Context, server.Message, error) error
-	/*
-		clientCallFunc       func(context.Context, string, client.Request, interface{}, client.CallOptions, error) error
-		clientClient         func(client.Client, error) error
-	*/
-}
-
-func NewHandlerWrapper(fn func(context.Context, server.Request, interface{}, error) error) server.HandlerWrapper {
-	handler := &wrapper{
-		serverHandlerFunc: fn,
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		ServerHandlerFn:    DefaultServerHandlerFn,
+		ServerSubscriberFn: DefaultServerSubscriberFn,
 	}
-	return handler.HandlerFunc
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
 }
 
-func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
+type Options struct {
+	ServerHandlerFn    func(context.Context, server.Request, interface{}, error) error
+	ServerSubscriberFn func(context.Context, server.Message, error) error
+}
+
+type Option func(*Options)
+
+func ServerHandlerFunc(fn func(context.Context, server.Request, interface{}, error) error) Option {
+	return func(o *Options) {
+		o.ServerHandlerFn = fn
+	}
+}
+
+func ServerSubscriberFunc(fn func(context.Context, server.Message, error) error) Option {
+	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()
@@ -31,24 +65,17 @@ func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
 			case nil:
 				return
 			case error:
-				err = w.serverHandlerFunc(ctx, req, rsp, verr)
+				err = w.opts.ServerHandlerFn(ctx, req, rsp, verr)
 			default:
-				err = w.serverHandlerFunc(ctx, req, rsp, fmt.Errorf("%v", r))
+				err = w.opts.ServerHandlerFn(ctx, req, rsp, fmt.Errorf("%v", r))
 			}
 		}()
-		err = fn(ctx, req, rsp)
+		err = next(ctx, req, rsp)
 		return err
 	}
 }
 
-func NewSubscriberWrapper(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 {
+func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandler {
 	return func(ctx context.Context, msg server.Message) (err error) {
 		defer func() {
 			r := recover()
@@ -56,79 +83,12 @@ func (w *wrapper) SubscriberFunc(fn server.SubscriberFunc) server.SubscriberFunc
 			case nil:
 				return
 			case error:
-				err = w.serverSubscriberFunc(ctx, msg, verr)
+				err = w.opts.ServerSubscriberFn(ctx, msg, verr)
 			default:
-				err = w.serverSubscriberFunc(ctx, msg, fmt.Errorf("%v", r))
+				err = w.opts.ServerSubscriberFn(ctx, msg, fmt.Errorf("%v", r))
 			}
 		}()
-		err = fn(ctx, msg)
+		err = next(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
-}
-*/