func NewHandler()

in fc/handler.go [82:147]
47 lines of code
14 McCabe index (conditional complexity)

func NewHandler(handlerFunc interface{}) Handler {
	if handlerFunc == nil {
		return errorHandler(fmt.Errorf("handler is nil"))
	}
	handler := reflect.ValueOf(handlerFunc)
	handlerType := reflect.TypeOf(handlerFunc)
	if handlerType.Kind() != reflect.Func {
		return errorHandler(fmt.Errorf("handler kind %s is not %s", handlerType.Kind(), reflect.Func))
	}

	takesContext, err := validateArguments(handlerType)
	if err != nil {
		return errorHandler(err)
	}

	if err := validateReturns(handlerType); err != nil {
		return errorHandler(err)
	}

	return fcHandler(func(ctx context.Context, payload []byte) (interface{}, error) {

		// trace := handlertrace.FromContext(ctx)

		// construct arguments
		var args []reflect.Value
		if takesContext {
			args = append(args, reflect.ValueOf(ctx))
		}
		if (handlerType.NumIn() == 1 && !takesContext) || handlerType.NumIn() == 2 {
			eventType := handlerType.In(handlerType.NumIn() - 1)
			if eventType == reflect.TypeOf([]byte{}) {
				args = append(args, reflect.ValueOf(payload))
			} else {
				event := reflect.New(eventType)

				if err := json.Unmarshal(payload, event.Interface()); err != nil {
					return nil, err
				}
				// if nil != trace.RequestEvent {
				// 	trace.RequestEvent(ctx, event.Elem().Interface())
				// }
				args = append(args, event.Elem())
			}
		}

		response := handler.Call(args)

		// convert return values into (interface{}, error)
		var err error
		if len(response) > 0 {
			if errVal, ok := response[len(response)-1].Interface().(error); ok {
				err = errVal
			}
		}
		var val interface{}
		if len(response) > 1 {
			val = response[0].Interface()

			// if nil != trace.ResponseEvent {
			// 	trace.ResponseEvent(ctx, val)
			// }
		}

		return val, err
	})
}