Respond to PR comments

Author: Quinn-With-Two-Ns

nexus/operation.go

@@ -15,14 +15,14 @@ import (
 //	)}
 type NoValue *struct{}
 
-// OperationOptions contains the general options for an operation, across different handlers.
+// HandlerInfo contains the general information for an operation invocation, across different handlers.
 //
 // NOTE: Experimental
-type OperationOptions struct {
-	// ServiceName is the name of the service that contains the operation.
-	ServiceName string
-	// OperationName is the name of the operation.
-	OperationName string
+type HandlerInfo struct {
+	// Service is the name of the service that contains the operation.
+	Service string
+	// Operation is the name of the operation.
+	Operation string
 	// Header contains the request header fields either received by the server or to be sent by the client.
 	//
 	// Header will always be non empty in server methods and can be optionally set in the client API.
@@ -34,11 +34,11 @@ type OperationOptions struct {
 	Header Header
 }
 
-// MiddlewareFunc is a function which receives an OperationInvoker and returns another OperationInvoker.
+// MiddlewareFunc is a function which receives an OperationHandler and returns another OperationHandler.
 // If the middleware wants to stop the chain before any handler is called, it can return an error.
 //
 // NOTE: Experimental
-type MiddlewareFunc func(OperationOptions, OperationInvoker[any, any]) (OperationInvoker[any, any], error)
+type MiddlewareFunc func(HandlerInfo, OperationHandler[any, any]) (OperationHandler[any, any], error)
 
 // OperationReference provides a typed interface for invoking operations. Every [Operation] is also an
 // [OperationReference]. Callers may create references using [NewOperationReference] when the implementation is not
@@ -95,10 +95,11 @@ type RegisterableOperation interface {
 type Operation[I, O any] interface {
 	RegisterableOperation
 	OperationReference[I, O]
-	OperationInvoker[I, O]
+	OperationHandler[I, O]
 }
 
-type OperationInvoker[I, O any] interface {
+// OperationHandler is the interface for the core operation methods.
+type OperationHandler[I, O any] interface {
 	// Start handles requests for starting an operation. Return [HandlerStartOperationResultSync] to respond
 	// successfully - inline, or [HandlerStartOperationResultAsync] to indicate that an asynchronous operation was
 	// started. Return an [OperationError] to indicate that an operation completed as failed or
@@ -274,17 +275,17 @@ type registryHandler struct {
 	middlewares []MiddlewareFunc
 }
 
-func (r *registryHandler) getOperation(options OperationOptions) (OperationInvoker[any, any], error) {
-	s, ok := r.services[options.ServiceName]
+func (r *registryHandler) operationHandler(options HandlerInfo) (OperationHandler[any, any], error) {
+	s, ok := r.services[options.Service]
 	if !ok {
-		return nil, HandlerErrorf(HandlerErrorTypeNotFound, "service %q not found", options.ServiceName)
+		return nil, HandlerErrorf(HandlerErrorTypeNotFound, "service %q not found", options.Service)
 	}
-	h, ok := s.operations[options.OperationName]
+	h, ok := s.operations[options.Operation]
 	if !ok {
-		return nil, HandlerErrorf(HandlerErrorTypeNotFound, "operation %q not found", options.OperationName)
+		return nil, HandlerErrorf(HandlerErrorTypeNotFound, "operation %q not found", options.Operation)
 	}
 
-	var handler OperationInvoker[any, any]
+	var handler OperationHandler[any, any]
 	handler = &rootOperationHandler{h: h}
 	if h != nil && len(r.middlewares) > 0 {
 		for i := len(r.middlewares) - 1; i >= 0; i-- {
@@ -345,40 +346,40 @@ func (r *rootOperationHandler) Start(ctx context.Context, input interface{}, opt
 	return ret.(HandlerStartOperationResult[any]), nil
 }
 
-var _ OperationInvoker[any, any] = &rootOperationHandler{}
+var _ OperationHandler[any, any] = &rootOperationHandler{}
 
 // CancelOperation implements Handler.
 func (r *registryHandler) CancelOperation(ctx context.Context, service, operation string, operationID string, options CancelOperationOptions) error {
-	h, err := r.getOperation(OperationOptions{
-		ServiceName:   service,
-		OperationName: operation,
-		Header:        options.Header,
+	h, err := r.operationHandler(HandlerInfo{
+		Service:   service,
+		Operation: operation,
+		Header:    options.Header,
 	})
 	if err != nil {
 		return err
 	}
 	return h.Cancel(ctx, operationID, options)
 }
 
-// GetOperationInfo implements Handler.
+// operationHandlerInfo implements Handler.
 func (r *registryHandler) GetOperationInfo(ctx context.Context, service, operation string, operationID string, options GetOperationInfoOptions) (*OperationInfo, error) {
-	h, err := r.getOperation(OperationOptions{
-		ServiceName:   service,
-		OperationName: operation,
-		Header:        options.Header,
+	h, err := r.operationHandler(HandlerInfo{
+		Service:   service,
+		Operation: operation,
+		Header:    options.Header,
 	})
 	if err != nil {
 		return nil, err
 	}
 	return h.GetInfo(ctx, operationID, options)
 }
 
-// GetOperationResult implements Handler.
+// operationHandlerResult implements Handler.
 func (r *registryHandler) GetOperationResult(ctx context.Context, service, operation string, operationID string, options GetOperationResultOptions) (any, error) {
-	h, err := r.getOperation(OperationOptions{
-		ServiceName:   service,
-		OperationName: operation,
-		Header:        options.Header,
+	h, err := r.operationHandler(HandlerInfo{
+		Service:   service,
+		Operation: operation,
+		Header:    options.Header,
 	})
 	if err != nil {
 		return nil, err
@@ -397,10 +398,10 @@ func (r *registryHandler) StartOperation(ctx context.Context, service, operation
 		return nil, HandlerErrorf(HandlerErrorTypeNotFound, "operation %q not found", operation)
 	}
 
-	h, err := r.getOperation(OperationOptions{
-		ServiceName:   service,
-		OperationName: operation,
-		Header:        options.Header,
+	h, err := r.operationHandler(HandlerInfo{
+		Service:   service,
+		Operation: operation,
+		Header:    options.Header,
 	})
 	if err != nil {
 		return nil, err

nexus/operation_test.go

@@ -306,16 +306,16 @@ func TestOperationInterceptor(t *testing.T) {
 }
 
 func newAuthMiddleware(authKey string) MiddlewareFunc {
-	return func(oo OperationOptions, uo OperationInvoker[any, any]) (OperationInvoker[any, any], error) {
-		if oo.Header.Get("authorization") != authKey {
+	return func(hi HandlerInfo, uo OperationHandler[any, any]) (OperationHandler[any, any], error) {
+		if hi.Header.Get("authorization") != authKey {
 			return nil, HandlerErrorf(HandlerErrorTypeUnauthorized, "unauthorized")
 		}
 		return uo, nil
 	}
 }
 
 type loggingOperation struct {
-	Operation OperationInvoker[any, any]
+	Operation OperationHandler[any, any]
 	name      string
 	output    func(string)
 }
@@ -341,10 +341,10 @@ func (lo *loggingOperation) GetInfo(ctx context.Context, id string, options GetO
 }
 
 func newLoggingMiddleware(output func(string)) MiddlewareFunc {
-	return func(oo OperationOptions, uo OperationInvoker[any, any]) (OperationInvoker[any, any], error) {
+	return func(hi HandlerInfo, uo OperationHandler[any, any]) (OperationHandler[any, any], error) {
 		return &loggingOperation{
 			uo,
-			oo.OperationName,
+			hi.Operation,
 			output,
 		}, nil
 	}