Update from https://github.com/cloudimpl/next-coder/commit/6babb4a2a56b78053179367bce9a3ea44ac843bc

Author: CloudimplBot

polycode/apiserver.go

@@ -29,25 +29,52 @@ func invokeHealthCheck(c *gin.Context) {
 func invokeApiHandler(c *gin.Context) {
 	log.Println("client: api request received")
 	var input ApiStartEvent
+
 	if err := c.ShouldBindJSON(&input); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"})
-		return
-	}
+		errorOutput := ErrorEvent{
+			Error: ErrInternal.Wrap(err),
+		}
 
-	output := runApi(c, input)
-	log.Println("client: api request completed")
-	c.JSON(http.StatusOK, output)
+		c.JSON(http.StatusInternalServerError, errorOutput)
+		log.Println("client: api request error")
+	} else {
+		output, err := runApi(c, input)
+		if err != nil {
+			errorOutput := ErrorEvent{
+				Error: ErrInternal.Wrap(err),
+			}
+
+			c.JSON(http.StatusInternalServerError, errorOutput)
+			log.Println("client: api request error")
+		} else {
+			c.JSON(http.StatusOK, output)
+			log.Println("client: api request completed")
+		}
+	}
 }
 
 func invokeServiceHandler(c *gin.Context) {
 	log.Println("client: service request received")
-	var input TaskStartEvent
+	var input ServiceStartEvent
 	if err := c.ShouldBindJSON(&input); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"})
-		return
-	}
+		errorOutput := ErrorEvent{
+			Error: ErrInternal.Wrap(err),
+		}
+
+		c.JSON(http.StatusInternalServerError, errorOutput)
+		log.Println("client: service request error")
+	} else {
+		output, err := runService(c, input)
+		if err != nil {
+			errorOutput := ErrorEvent{
+				Error: ErrInternal.Wrap(err),
+			}
 
-	output := runTask(c, input)
-	log.Println("client: service request completed")
-	c.JSON(http.StatusOK, output)
+			c.JSON(http.StatusInternalServerError, errorOutput)
+			log.Println("client: service request error")
+		} else {
+			c.JSON(http.StatusOK, output)
+			log.Println("client: service request completed")
+		}
+	}
 }

polycode/client.go

@@ -31,7 +31,14 @@ type ExecServiceRequest struct {
 	Service string      `json:"service"`
 	Method  string      `json:"method"`
 	Options TaskOptions `json:"options"`
-	Input   TaskInput   `json:"input"`
+	Input   any         `json:"input"`
+}
+
+type ExecServiceResponse struct {
+	IsAsync bool  `json:"isAsync"`
+	Output  any   `json:"output"`
+	IsError bool  `json:"isError"`
+	Error   Error `json:"error"`
 }
 
 // PutRequest represents the JSON structure for put operations
@@ -89,11 +96,11 @@ func (sc *ServiceClient) StartApp(req StartAppRequest) error {
 }
 
 // ExecService executes a service with the given request
-func (sc *ServiceClient) ExecService(sessionId string, req ExecServiceRequest) (TaskOutput, error) {
-	var res TaskOutput
+func (sc *ServiceClient) ExecService(sessionId string, req ExecServiceRequest) (ExecServiceResponse, error) {
+	var res ExecServiceResponse
 	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/service/exec", req, &res)
 	if err != nil {
-		return TaskOutput{}, err
+		return ExecServiceResponse{}, err
 	}
 
 	if res.IsAsync {

polycode/model.go

@@ -29,28 +29,30 @@ func (t TaskOptions) WithTimeout(timeout time.Duration) TaskOptions {
 	return t
 }
 
-type TaskInput struct {
-	Checksum uint64 `json:"checksum"`
-	Input    any    `json:"input"`
+type ServiceStartEvent struct {
+	SessionId string `json:"sessionId"`
+	Service   string `json:"service"`
+	Method    string `json:"method"`
+	Input     any    `json:"input"`
 }
 
-type TaskOutput struct {
-	IsAsync bool  `json:"isAsync"`
+type ServiceCompleteEvent struct {
 	IsError bool  `json:"isError"`
 	Output  any   `json:"output"`
 	Error   Error `json:"error"`
 }
 
-type TaskCompleteEvent struct {
-	Output TaskOutput
+type ApiStartEvent struct {
+	SessionId string     `json:"sessionId"`
+	Request   ApiRequest `json:"request"`
+}
+
+type ApiCompleteEvent struct {
+	Response ApiResponse `json:"response"`
 }
 
-type TaskStartEvent struct {
-	SessionId   string      `json:"sessionId"`
-	ServiceName string      `json:"serviceName"`
-	EntryPoint  string      `json:"entryPoint"`
-	Input       TaskInput   `json:"input"`
-	Options     TaskOptions `json:"options"`
+type ErrorEvent struct {
+	Error Error
 }
 
 type ApiRequest struct {
@@ -70,13 +72,6 @@ type ApiResponse struct {
 	IsBase64Encoded bool              `json:"isBase64Encoded"`
 }
 
-type ApiStartEvent struct {
-	SessionId  string      `json:"sessionId"`
-	Controller string      `json:"controller"`
-	Request    ApiRequest  `json:"request"`
-	Options    TaskOptions `json:"options"`
-}
-
 type RouteData struct {
 	Method string `json:"method"`
 	Path   string `json:"path"`

polycode/runtime.go

@@ -129,57 +129,55 @@ func loadRoutes() []RouteData {
 	return routes
 }
 
-func runTask(ctx context.Context, event TaskStartEvent) (evt TaskCompleteEvent) {
+func runService(ctx context.Context, event ServiceStartEvent) (evt ServiceCompleteEvent, err error) {
 	log.Println("client: handle task start event")
 	defer func() {
 		// Recover from panic and check for a specific error
 		if r := recover(); r != nil {
-			err, ok := r.(error)
+			recovered, ok := r.(error)
 
-			if ok && errors.Is(err, ErrTaskInProgress) {
+			if ok && errors.Is(recovered, ErrTaskInProgress) {
 				log.Println("client: task in progress")
-				evt = ValueToTaskComplete(nil)
+				evt = ValueToServiceComplete(nil)
 			} else {
-				log.Printf("client: task completed with error %s\n", err.Error())
+				log.Printf("client: task error %s\n", recovered.Error())
 				stackTrace := string(debug.Stack())
 				println(stackTrace)
-				evt = ErrorToTaskComplete(err)
+				err = recovered
 			}
 		}
 	}()
 
-	service, err := getService(event.ServiceName)
+	service, err := getService(event.Service)
 	if err != nil {
-		fmt.Printf("client: task completed with error %s\n", err.Error())
-		return ErrorToTaskComplete(err)
+		fmt.Printf("client: task error %s\n", err.Error())
+		return ServiceCompleteEvent{}, err
 	}
 
-	inputObj, err := service.GetInputType(event.EntryPoint)
+	inputObj, err := service.GetInputType(event.Method)
 	if err != nil {
-		fmt.Printf("client: task completed with error %s\n", err.Error())
-		return ErrorToTaskComplete(err)
+		fmt.Printf("client: task error %s\n", err.Error())
+		return ServiceCompleteEvent{}, err
 	}
 
-	err = ConvertType(event.Input.Input, inputObj)
+	err = ConvertType(event.Input, inputObj)
 	if err != nil {
-		fmt.Printf("client: task completed with error %s\n", err.Error())
-		return ErrorToTaskComplete(err)
+		fmt.Printf("client: task error %s\n", err.Error())
+		return ServiceCompleteEvent{}, err
 	}
 
-	isWorkflow := service.IsWorkflow(event.EntryPoint)
-
 	var ret any
-	if isWorkflow {
+	if service.IsWorkflow(event.Method) {
 		workflowCtx := WorkflowContext{
 			ctx:           ctx,
 			sessionId:     event.SessionId,
 			serviceClient: serviceClient,
 			config:        appConfig,
 		}
 
-		println(fmt.Sprintf("client: service %s exec workflow %s with session id %s", event.ServiceName,
-			event.EntryPoint, event.SessionId))
-		ret, err = service.ExecuteWorkflow(workflowCtx, event.EntryPoint, inputObj)
+		println(fmt.Sprintf("client: service %s exec workflow %s with session id %s", event.Service,
+			event.Method, event.SessionId))
+		ret, err = service.ExecuteWorkflow(workflowCtx, event.Method, inputObj)
 	} else {
 		srvCtx := ServiceContext{
 			ctx:       ctx,
@@ -188,42 +186,49 @@ func runTask(ctx context.Context, event TaskStartEvent) (evt TaskCompleteEvent)
 			config:    appConfig,
 		}
 
-		println(fmt.Sprintf("client: service %s exec handler %s with session id %s", event.ServiceName,
-			event.EntryPoint, event.SessionId))
-		ret, err = service.ExecuteService(srvCtx, event.EntryPoint, inputObj)
+		println(fmt.Sprintf("client: service %s exec handler %s with session id %s", event.Service,
+			event.Method, event.SessionId))
+		ret, err = service.ExecuteService(srvCtx, event.Method, inputObj)
 	}
 
 	if err != nil {
 		fmt.Printf("client: task completed with error %s\n", err.Error())
-		return ErrorToTaskComplete(err)
+		return ErrorToServiceComplete(err), nil
 	}
 
 	println("client: task completed")
-	return ValueToTaskComplete(ret)
+	return ValueToServiceComplete(ret), nil
 }
 
-func runApi(ctx context.Context, event ApiStartEvent) (evt TaskCompleteEvent) {
+func runApi(ctx context.Context, event ApiStartEvent) (evt ApiCompleteEvent, err error) {
 	log.Println("client: handle http request")
 	defer func() {
 		// Recover from panic and check for a specific error
 		if r := recover(); r != nil {
-			err, ok := r.(error)
+			recovered, ok := r.(error)
 
-			if ok && errors.Is(err, ErrTaskInProgress) {
+			if ok && errors.Is(recovered, ErrTaskInProgress) {
 				log.Println("client: api in progress")
-				evt = ValueToTaskComplete(nil)
+				evt = ApiCompleteEvent{
+					Response: ApiResponse{
+						StatusCode:      200,
+						Header:          make(map[string]string),
+						Body:            "",
+						IsBase64Encoded: false,
+					},
+				}
 			} else {
-				log.Printf("client: api completed with error %s\n", err.Error())
+				log.Printf("client: api error %s\n", recovered.Error())
 				stackTrace := string(debug.Stack())
 				println(stackTrace)
-				evt = ErrorToTaskComplete(err)
+				err = recovered
 			}
 		}
 	}()
 
 	if httpHandler == nil {
-		log.Printf("client: task completed with error %s\n", ErrBadRequest.Error())
-		return ErrorToTaskComplete(ErrBadRequest)
+		println("client: api error, not registered")
+		return ApiCompleteEvent{}, fmt.Errorf("api not registered")
 	}
 
 	apiCtx := ApiContext{
@@ -232,38 +237,32 @@ func runApi(ctx context.Context, event ApiStartEvent) (evt TaskCompleteEvent) {
 		serviceClient: serviceClient,
 		config:        appConfig,
 	}
-	newCtx := context.WithValue(ctx, "polycode.context", apiCtx)
 
-	res, err := invokeHandler(newCtx, httpHandler, event.Request)
+	newCtx := context.WithValue(ctx, "polycode.context", apiCtx)
+	httpReq, err := convertToHttpRequest(newCtx, event.Request)
 	if err != nil {
-		fmt.Printf("client: task completed with error %s\n", err.Error())
-		return ErrorToTaskComplete(err)
+		return ApiCompleteEvent{}, err
 	}
 
-	println("client: task completed")
-	return ValueToTaskComplete(res)
+	res := invokeHandler(httpHandler, httpReq)
+	println("client: api completed")
+	return ApiCompleteEvent{
+		Response: res,
+	}, nil
 }
 
-func ValueToTaskComplete(output any) TaskCompleteEvent {
-	taskOutput := TaskOutput{
+func ValueToServiceComplete(output any) ServiceCompleteEvent {
+	return ServiceCompleteEvent{
 		Output:  output,
 		IsError: false,
 		Error:   Error{},
 	}
-
-	return TaskCompleteEvent{
-		Output: taskOutput,
-	}
 }
 
-func ErrorToTaskComplete(err error) TaskCompleteEvent {
-	taskOutput := TaskOutput{
+func ErrorToServiceComplete(err error) ServiceCompleteEvent {
+	return ServiceCompleteEvent{
 		Output:  nil,
 		IsError: true,
 		Error:   ErrTaskExecError.Wrap(err),
 	}
-
-	return TaskCompleteEvent{
-		Output: taskOutput,
-	}
 }

polycode/service.go

@@ -43,15 +43,11 @@ type RemoteService struct {
 }
 
 func (r RemoteService) RequestReply(options TaskOptions, method string, input any) Response {
-	taskInput := TaskInput{
-		Input: input,
-	}
-
 	req := ExecServiceRequest{
 		Service: r.service,
 		Method:  method,
 		Options: options,
-		Input:   taskInput,
+		Input:   input,
 	}
 
 	output, err := r.serviceClient.ExecService(r.sessionId, req)

polycode/web.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/base64"
-	"fmt"
 	"io"
 	"mime"
 	"net/http"
@@ -158,16 +157,8 @@ func convertToHttpRequest(ctx context.Context, apiReq ApiRequest) (*http.Request
 }
 
 // Manually invoke an HTTP handler
-func invokeHandler(ctx context.Context, handler http.Handler, req ApiRequest) (ApiResponse, error) {
-	fmt.Printf("client: invokeHandler request: %v\n", req)
-	httpReq, err := convertToHttpRequest(ctx, req)
-	if err != nil {
-		return ApiResponse{}, err
-	}
-
+func invokeHandler(handler http.Handler, httpReq *http.Request) ApiResponse {
 	customWriter := &ResponseWriter{}
 	handler.ServeHTTP(customWriter, httpReq)
-	res := customWriter.End()
-	fmt.Printf("client: invokeHandler response: %v\n", res)
-	return res, nil
+	return customWriter.End()
 }