Update from https://github.com/CloudImpl-Inc/next-coder/commit/d35b7065df6d85e017bc31c6afe1bf22625f3165

Author: CloudimplBot

client/client.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"github.com/CloudImpl-Inc/next-coder-sdk/client/db"
 	"github.com/CloudImpl-Inc/next-coder-sdk/polycode"
 	"net/http"
 	"time"
@@ -20,32 +19,54 @@ const (
 
 type TaskStatus int8
 
-type Request struct {
-	Context RemoteTaskContext
-	Input   polycode.TaskInput
+type StartAppRequest struct {
+	ClientPort int `json:"clientPort"`
 }
 
-type Output struct {
-	SessionId string `json:"sessionId"`
+type ExecRequest struct {
+	ServiceId  string               `json:"serviceId"`
+	EntryPoint string               `json:"entryPoint"`
+	Options    polycode.TaskOptions `json:"options"`
+	Input      polycode.TaskInput   `json:"input"`
 }
 
-type UrlCache struct {
-	serviceIdUrl string
-	//callTaskUrl  string
+// PutRequest represents the JSON structure for put operations
+type PutRequest struct {
+	Action     string                 `json:"action"`
+	Collection string                 `json:"collection"`
+	Key        string                 `json:"key"`
+	Item       map[string]interface{} `json:"item"`
+}
+
+// QueryRequest represents the JSON structure for query operations
+type QueryRequest struct {
+	Collection string        `json:"collection"`
+	Key        string        `json:"key"`
+	Filter     string        `json:"filter"`
+	Args       []interface{} `json:"args"`
+	Limit      int           `json:"limit"`
+}
+
+// GetFileRequest represents the JSON structure for get file operations
+type GetFileRequest struct {
+	Key string `json:"key"`
+}
+
+// GetFileResponse represents the JSON structure for get file response
+type GetFileResponse struct {
+	Content string `json:"content"`
+}
+
+// PutFileRequest represents the JSON structure for put file operations
+type PutFileRequest struct {
+	Key     string `json:"key"`
+	Content string `json:"content"`
 }
 
 // ServiceClient is a reusable client for calling the service API
 type ServiceClient struct {
 	httpClient *http.Client
 	baseURL    string
-	urlCache   UrlCache
-}
-
-func CreateTaskCompleteEvent(output polycode.TaskOutput, tx *db.Tx) *TaskCompleteEvent {
-	return &TaskCompleteEvent{
-		Tx:     tx,
-		Output: output,
-	}
 }
 
 // NewServiceClient creates a new ServiceClient with a reusable HTTP client
@@ -55,154 +76,123 @@ func NewServiceClient(baseURL string) *ServiceClient {
 			Timeout: time.Second * 30, // Set a reasonable timeout for HTTP requests
 		},
 		baseURL: baseURL,
-		urlCache: UrlCache{
-			serviceIdUrl: fmt.Sprintf("%s/system/service/id", baseURL),
-			//callTaskUrl:  fmt.Sprintf("%s/system/task/%s/%s/call", baseURL),
-		},
 	}
 }
 
-//func (sc *ServiceClient) startTask(context *TaskContext, input *polycode.TaskInput) (string, error) {
-//
-//	req := Request{
-//		Context: context,
-//		Input:   input,
-//	}
-//	b, err := json.Marshal(req)
-//	if err != nil {
-//		return "", fmt.Errorf("failed to marshal JSON: %w", err)
-//	}
-//	resp, err := sc.httpClient.Post(fmt.Sprintf("%s/system/task/init", sc.baseURL), "application/json", bytes.NewBuffer(b))
-//	if err != nil {
-//		return "", fmt.Errorf("failed to make HTTP request: %w", err)
-//	}
-//	defer resp.Body.Close()
-//
-//	// Check if the response status code is 200 OK
-//	if resp.StatusCode != http.StatusOK {
-//		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
-//	}
-//
-//	output := &Output{}
-//	if err := json.NewDecoder(resp.Body).Decode(output); err != nil {
-//		return "", fmt.Errorf("failed to decode JSON response: %w", err)
-//	}
-//	return output.SessionId, nil
-//}
-
+// StartApp starts the app
 func (sc *ServiceClient) StartApp(req StartAppRequest) error {
+	return executeApiWithoutResponse(sc.httpClient, sc.baseURL, "", "v1/context/app/start", req)
+}
 
-	b, err := json.Marshal(req)
+// ExecService executes a service with the given request
+func (sc *ServiceClient) ExecService(sessionId string, req ExecRequest) (polycode.TaskOutput, error) {
+	var res polycode.TaskOutput
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/service/exec", req, &res)
 	if err != nil {
-		return fmt.Errorf("failed to marshal JSON: %w", err)
+		return polycode.TaskOutput{}, err
+	}
+
+	if res.IsAsync {
+		panic(ErrTaskInProgress)
 	}
-	resp, err := sc.httpClient.Post(fmt.Sprintf("%s/v1/system/app/start", sc.baseURL), "application/json", bytes.NewBuffer(b))
+	return res, nil
+}
+
+// GetItem gets an item from the database
+func (sc *ServiceClient) GetItem(sessionId string, req QueryRequest) (map[string]interface{}, error) {
+	var res map[string]interface{}
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/db/get", req, &res)
 	if err != nil {
-		return fmt.Errorf("failed to make HTTP request: %w", err)
+		return nil, err
 	}
-	defer resp.Body.Close()
+	return res, nil
+}
 
-	// Check if the response status code is 200 OK
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+// QueryItems queries items from the database
+func (sc *ServiceClient) QueryItems(sessionId string, req QueryRequest) ([]map[string]interface{}, error) {
+	var res []map[string]interface{}
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/db/query", req, &res)
+	if err != nil {
+		return nil, err
 	}
-	return nil
+	return res, nil
+}
+
+// PutItem puts an item into the database
+func (sc *ServiceClient) PutItem(sessionId string, req PutRequest) error {
+	return executeApiWithoutResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/db/put", req)
 }
 
-func (sc *ServiceClient) completeTask(sessionId string, completeEvent *TaskCompleteEvent) error {
-	b, err := json.Marshal(completeEvent)
+// GetFile gets a file from the file store
+func (sc *ServiceClient) GetFile(sessionId string, req GetFileRequest) (GetFileResponse, error) {
+	var res GetFileResponse
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/file/get", req, &res)
 	if err != nil {
-		return fmt.Errorf("failed to marshal JSON: %w", err)
+		return GetFileResponse{}, err
 	}
-	resp, err := sc.httpClient.Post(fmt.Sprintf("%s/system/tasks/%s/complete", sc.baseURL, sessionId), "application/json", bytes.NewBuffer(b))
+	return res, nil
+}
+
+// PutFile puts a file into the file store
+func (sc *ServiceClient) PutFile(sessionId string, req PutFileRequest) error {
+	return executeApiWithoutResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/file/put", req)
+}
+
+func executeApiWithoutResponse(httpClient *http.Client, baseUrl string, sessionId string, path string, req any) error {
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+
+	httpReq, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/%s", baseUrl, path), bytes.NewBuffer(reqBody))
 	if err != nil {
-		return fmt.Errorf("failed to make HTTP request: %w", err)
+		return err
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("x-polycode-session-id", sessionId)
+
+	resp, err := httpClient.Do(httpReq)
+	if err != nil {
+		return err
 	}
 	defer resp.Body.Close()
 
-	// Check if the response status code is 200 OK
 	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+		return fmt.Errorf("failed to put file, status: %v", resp.Status)
 	}
+
 	return nil
 }
 
-func (sc *ServiceClient) ExecTask(ctx RemoteTaskContext, method string, input polycode.TaskInput) (*polycode.TaskOutput, error) {
-
-	req := Request{
-		Context: ctx,
-		Input:   input,
+func executeApiWithResponse[T any](httpClient *http.Client, baseUrl string, sessionId string, path string, req any, res *T) error {
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return err
 	}
 
-	b, err := json.Marshal(req)
+	httpReq, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/%s", baseUrl, path), bytes.NewBuffer(reqBody))
 	if err != nil {
-		return nil, fmt.Errorf("failed to marshal JSON: %w", err)
+		return err
 	}
-	// Make the HTTP POST request
-	resp, err := sc.httpClient.Post(fmt.Sprintf("%s/v1/system/tasks/%s/exec", sc.baseURL, ctx.SessionId), "application/json", bytes.NewBuffer(b))
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("x-polycode-session-id", sessionId)
+
+	resp, err := httpClient.Do(httpReq)
 	if err != nil {
-		return nil, fmt.Errorf("failed to make HTTP request: %w", err)
+		return err
 	}
 	defer resp.Body.Close()
 
-	// Check if the response status code is 200 OK
 	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+		return fmt.Errorf("failed to put file, status: %v", resp.Status)
 	}
 
-	output := &polycode.TaskOutput{}
-	if err := json.NewDecoder(resp.Body).Decode(output); err != nil {
-		return nil, fmt.Errorf("failed to decode JSON response: %w", err)
+	if res != nil {
+		err = json.NewDecoder(resp.Body).Decode(res)
+		if err != nil {
+			return err
+		}
 	}
 
-	if output.IsAsync {
-		panic(ErrTaskInProgress) //task in progress panic
-	}
-	// Return the taskId from the response
-	return output, nil
-}
-
-//func (sc *ServiceClient) dbCommit(sessionId string, request *TxRequest) error {
-//
-//	b, err := json.Marshal(request)
-//	if err != nil {
-//		return fmt.Errorf("failed to marshal JSON: %w", err)
-//	}
-//	resp, err := sc.httpClient.Post(fmt.Sprintf("%s/system/%s/db/commit", sc.baseURL, sessionId), "application/json", bytes.NewBuffer(b))
-//	if err != nil {
-//		return fmt.Errorf("failed to make HTTP request: %w", err)
-//	}
-//	defer resp.Body.Close()
-//
-//	// Check if the response status code is 200 OK
-//	if resp.StatusCode != http.StatusOK {
-//		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
-//	}
-//	return nil
-//}
-
-//func (sc *ServiceClient) dbGet(sessionId string, request DBAction) (string, error) {
-//
-//	b, err := json.Marshal(request)
-//	if err != nil {
-//		return "", fmt.Errorf("failed to marshal JSON: %w", err)
-//	}
-//	resp, err := sc.httpClient.Post(fmt.Sprintf("%s/v1/system/%s/db/get", sc.baseURL, sessionId), "application/json", bytes.NewBuffer(b))
-//	if err != nil {
-//		return "", fmt.Errorf("failed to make HTTP request: %w", err)
-//	}
-//	defer resp.Body.Close()
-//
-//	// Check if the response status code is 200 OK
-//	if resp.StatusCode != http.StatusOK {
-//		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
-//	}
-//
-//	//return the response body as a string
-//	respBody := &bytes.Buffer{}
-//	_, err = respBody.ReadFrom(resp.Body)
-//	if err != nil {
-//		return "", fmt.Errorf("failed to read response body: %w", err)
-//	}
-//	return respBody.String(), nil
-//}
+	return nil
+}