Function NewUnaryHandler

handler.go:37–112

NewUnaryHandler constructs a [Handler] for a request-response procedure.

(
	procedure string,
	unary func(context.Context, *Request[Req]) (*Response[Res], error),
	options ...HandlerOption,
)

// NewUnaryHandler constructs a [Handler] for a request-response procedure.
func NewUnaryHandler[Req, Res any](
	procedure string,
	unary func(context.Context, *Request[Req]) (*Response[Res], error),
	options ...HandlerOption,
) *Handler {
	// Wrap the strongly-typed implementation so we can apply interceptors.
	untyped := UnaryFunc(func(ctx context.Context, request AnyRequest) (AnyResponse, error) {
		if err := ctx.Err(); err != nil {
			return nil, err
		}
		typed, ok := request.(*Request[Req])
		if !ok {
			return nil, errorf(CodeInternal, "unexpected handler request type %T", request)
		}
		res, err := unary(ctx, typed)
		if res == nil && err == nil {
			// This is going to panic during serialization. Debugging is much easier
			// if we panic here instead, so we can include the procedure name.
			panic(procedure + " returned nil *connect.Response and nil error") //nolint: forbidigo
		}
		if res == nil {
			// Avoid returning a typed nil (*Response[Res]) as an AnyResponse interface value.
			return nil, err
		}
		return res, err
	})
	config := newHandlerConfig(procedure, StreamTypeUnary, options)
	if interceptor := config.Interceptor; interceptor != nil {
		untyped = interceptor.WrapUnary(untyped)
	}
	// Given a stream, how should we call the unary function?
	implementation := func(ctx context.Context, conn StreamingHandlerConn) error {
		request, err := receiveUnaryRequest[Req](conn, config.Initializer)
		if err != nil {
			return err
		}
		// Add the request header to the context, and store the response header
		// and trailer to propagate back to the caller.
		info := &handlerCallInfo{
			peer:          request.Peer(),
			spec:          request.Spec(),
			method:        request.HTTPMethod(),
			requestHeader: request.Header(),
		}
		ctx = newHandlerContext(ctx, info)
		response, err := untyped(ctx, request)
		// Add response headers/trailers from the context callinfo into the conn if they exist
		if info.responseHeader != nil {
			mergeNonProtocolHeaders(conn.ResponseHeader(), info.responseHeader)
		}
		if info.responseTrailer != nil {
			mergeNonProtocolHeaders(conn.ResponseTrailer(), info.responseTrailer)
		}
		if err != nil {
			return err
		}

		// Add response headers/trailers from the response into the conn if they exist