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

Author: CloudimplBot

Diff for: apicontext/context.go

@@ -8,7 +8,7 @@ import (
 func FromContext(ctx context.Context) (polycode.ApiContext, error) {
 	value := ctx.Value("polycode.context")
 	if value == nil {
-		return polycode.ApiContext{}, polycode.ErrContextNotFound
+		return nil, polycode.ErrContextNotFound
 	}
 
 	return value.(polycode.ApiContext), nil

Diff for: polycode/client.go

@@ -34,6 +34,11 @@ type ExecServiceRequest struct {
 	Input   any         `json:"input"`
 }
 
+type ExecServiceExtendedRequest struct {
+	EnvId              string             `json:"envId"`
+	ExecServiceRequest ExecServiceRequest `json:"execServiceRequest"`
+}
+
 type ExecServiceResponse struct {
 	IsAsync bool  `json:"isAsync"`
 	Output  any   `json:"output"`
@@ -48,6 +53,11 @@ type ExecApiRequest struct {
 	Request    ApiRequest  `json:"request"`
 }
 
+type ExecApiExtendedRequest struct {
+	EnvId          string         `json:"envId"`
+	ExecApiRequest ExecApiRequest `json:"execApiRequest"`
+}
+
 type ExecApiResponse struct {
 	IsAsync  bool        `json:"isAsync"`
 	Response ApiResponse `json:"response"`
@@ -72,11 +82,28 @@ type QueryRequest struct {
 	Limit      int           `json:"limit"`
 }
 
+// QueryExtendedRequest represents the JSON structure for query operations
+type QueryExtendedRequest struct {
+	EnvId        string       `json:"envId"`
+	TenantId     string       `json:"tenantId"`
+	PartitionKey string       `json:"partitionKey"`
+	ServiceName  string       `json:"serviceName"`
+	QueryRequest QueryRequest `json:"queryRequest"`
+}
+
 // GetFileRequest represents the JSON structure for get file operations
 type GetFileRequest struct {
 	Key string `json:"key"`
 }
 
+type GetFileExtendedRequest struct {
+	EnvId          string         `json:"envId"`
+	TenantId       string         `json:"tenantId"`
+	PartitionKey   string         `json:"partitionKey"`
+	ServiceName    string         `json:"serviceName"`
+	GetFileRequest GetFileRequest `json:"getFileRequest"`
+}
+
 // GetFileResponse represents the JSON structure for get file response
 type GetFileResponse struct {
 	Content string `json:"content"`
@@ -123,6 +150,20 @@ func (sc *ServiceClient) ExecService(sessionId string, req ExecServiceRequest) (
 	return res, nil
 }
 
+// ExecServiceExtended executes a service with the given request
+func (sc *ServiceClient) ExecServiceExtended(sessionId string, req ExecServiceExtendedRequest) (ExecServiceResponse, error) {
+	var res ExecServiceResponse
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/extended/context/service/exec", req, &res)
+	if err != nil {
+		return ExecServiceResponse{}, err
+	}
+
+	if res.IsAsync {
+		panic(ErrTaskInProgress)
+	}
+	return res, nil
+}
+
 func (sc *ServiceClient) ExecApi(sessionId string, req ExecApiRequest) (ExecApiResponse, error) {
 	var res ExecApiResponse
 	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/context/api/exec", req, &res)
@@ -136,6 +177,19 @@ func (sc *ServiceClient) ExecApi(sessionId string, req ExecApiRequest) (ExecApiR
 	return res, nil
 }
 
+func (sc *ServiceClient) ExecApiExtended(sessionId string, req ExecApiExtendedRequest) (ExecApiResponse, error) {
+	var res ExecApiResponse
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/extended/context/api/exec", req, &res)
+	if err != nil {
+		return ExecApiResponse{}, err
+	}
+
+	if res.IsAsync {
+		panic(ErrTaskInProgress)
+	}
+	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{}
@@ -146,6 +200,16 @@ func (sc *ServiceClient) GetItem(sessionId string, req QueryRequest) (map[string
 	return res, nil
 }
 
+// GetItemExtended gets an item from the database
+func (sc *ServiceClient) GetItemExtended(sessionId string, req QueryExtendedRequest) (map[string]interface{}, error) {
+	var res map[string]interface{}
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/extended/context/db/get", req, &res)
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
 // QueryItems queries items from the database
 func (sc *ServiceClient) QueryItems(sessionId string, req QueryRequest) ([]map[string]interface{}, error) {
 	var res []map[string]interface{}
@@ -156,6 +220,16 @@ func (sc *ServiceClient) QueryItems(sessionId string, req QueryRequest) ([]map[s
 	return res, nil
 }
 
+// QueryItemsExtended queries items from the database
+func (sc *ServiceClient) QueryItemsExtended(sessionId string, req QueryExtendedRequest) ([]map[string]interface{}, error) {
+	var res []map[string]interface{}
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/extended/context/db/query", req, &res)
+	if err != nil {
+		return nil, err
+	}
+	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)
@@ -171,6 +245,16 @@ func (sc *ServiceClient) GetFile(sessionId string, req GetFileRequest) (GetFileR
 	return res, nil
 }
 
+// GetFileExtended gets a file from the file store
+func (sc *ServiceClient) GetFileExtended(sessionId string, req GetFileExtendedRequest) (GetFileResponse, error) {
+	var res GetFileResponse
+	err := executeApiWithResponse(sc.httpClient, sc.baseURL, sessionId, "v1/extended/context/file/get", req, &res)
+	if err != nil {
+		return GetFileResponse{}, err
+	}
+	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)

Diff for: polycode/context.go

@@ -5,109 +5,93 @@ import (
 	"time"
 )
 
-type ServiceContext struct {
-	ctx       context.Context
-	sessionId string
-	dataStore DataStore
-	fileStore FileStore
-	option    TaskOptions
-	config    AppConfig
+type ServiceContext interface {
+	AppConfig() AppConfig
+	Db() DataStore
+	FileStore() FileStore
 }
 
-func (s ServiceContext) AppConfig() AppConfig {
-	return s.config
-}
-
-func (s ServiceContext) Option() TaskOptions {
-	return s.option
-}
-
-func (s ServiceContext) Deadline() (deadline time.Time, ok bool) {
-	return s.ctx.Deadline()
-}
-
-func (s ServiceContext) Done() <-chan struct{} {
-	return s.ctx.Done()
-}
-
-func (s ServiceContext) Err() error {
-	return s.ctx.Err()
-}
-
-func (s ServiceContext) Value(key any) any {
-	return s.ctx.Value(key)
+type WorkflowContext interface {
+	AppConfig() AppConfig
+	Service(service string) (RemoteService, error)
+	Controller(controller string) (RemoteController, error)
 }
 
-func (s ServiceContext) Db() DataStore {
-	return s.dataStore
+type ApiContext interface {
+	AppConfig() AppConfig
+	Service(service string) (RemoteService, error)
+	Controller(controller string) (RemoteController, error)
 }
 
-func (s ServiceContext) FileStore() FileStore {
-	return s.fileStore
+type RawContext interface {
+	ServiceExec(req ExecServiceExtendedRequest) (ExecServiceResponse, error)
+	ApiExec(req ExecApiExtendedRequest) (ExecApiResponse, error)
+	DbGet(req QueryExtendedRequest) (map[string]interface{}, error)
+	DbQuery(req QueryExtendedRequest) ([]map[string]interface{}, error)
+	FileGet(req GetFileExtendedRequest) (GetFileResponse, error)
 }
 
-type WorkflowContext struct {
+type ContextImpl struct {
 	ctx           context.Context
 	sessionId     string
-	serviceClient *ServiceClient
+	dataStore     DataStore
+	fileStore     FileStore
 	config        AppConfig
+	serviceClient *ServiceClient
 }
 
-func (wc WorkflowContext) AppConfig() AppConfig {
-	return wc.config
+func (s ContextImpl) AppConfig() AppConfig {
+	return s.config
 }
 
-func (wc WorkflowContext) Deadline() (deadline time.Time, ok bool) {
-	return wc.ctx.Deadline()
+func (s ContextImpl) Deadline() (deadline time.Time, ok bool) {
+	return s.ctx.Deadline()
 }
 
-func (wc WorkflowContext) Done() <-chan struct{} {
-	return wc.ctx.Done()
+func (s ContextImpl) Done() <-chan struct{} {
+	return s.ctx.Done()
 }
 
-func (wc WorkflowContext) Err() error {
-	return wc.ctx.Err()
+func (s ContextImpl) Err() error {
+	return s.ctx.Err()
 }
 
-func (wc WorkflowContext) Value(key any) any {
-	return wc.ctx.Value(key)
+func (s ContextImpl) Value(key any) any {
+	return s.ctx.Value(key)
 }
 
-func (wc WorkflowContext) Service(service string) (RemoteService, error) {
-	return RemoteService{ctx: wc.ctx, sessionId: wc.sessionId, service: service, serviceClient: wc.serviceClient}, nil
+func (s ContextImpl) Db() DataStore {
+	return s.dataStore
 }
 
-type ApiContext struct {
-	ctx           context.Context
-	sessionId     string
-	serviceClient *ServiceClient
-	config        AppConfig
+func (s ContextImpl) FileStore() FileStore {
+	return s.fileStore
 }
 
-func (wc ApiContext) AppConfig() AppConfig {
-	return wc.config
+func (s ContextImpl) Service(service string) (RemoteService, error) {
+	return RemoteService{ctx: s.ctx, sessionId: s.sessionId, service: service, serviceClient: s.serviceClient}, nil
 }
 
-func (wc ApiContext) Deadline() (deadline time.Time, ok bool) {
-	return wc.ctx.Deadline()
+func (s ContextImpl) Controller(controller string) (RemoteController, error) {
+	return RemoteController{ctx: s.ctx, sessionId: s.sessionId, controller: controller, serviceClient: s.serviceClient}, nil
 }
 
-func (wc ApiContext) Done() <-chan struct{} {
-	return wc.ctx.Done()
+func (s ContextImpl) ServiceExec(req ExecServiceExtendedRequest) (ExecServiceResponse, error) {
+	return s.serviceClient.ExecServiceExtended(s.sessionId, req)
 }
 
-func (wc ApiContext) Err() error {
-	return wc.ctx.Err()
+func (s ContextImpl) ApiExec(req ExecApiExtendedRequest) (ExecApiResponse, error) {
+	return s.serviceClient.ExecApiExtended(s.sessionId, req)
 }
 
-func (wc ApiContext) Value(key any) any {
-	return wc.ctx.Value(key)
+func (s ContextImpl) DbGet(req QueryExtendedRequest) (map[string]interface{}, error) {
+	return s.serviceClient.GetItemExtended(s.sessionId, req)
 }
 
-func (wc ApiContext) Service(service string) (RemoteService, error) {
-	return RemoteService{ctx: wc.ctx, sessionId: wc.sessionId, service: service, serviceClient: wc.serviceClient}, nil
+func (s ContextImpl) DbQuery(req QueryExtendedRequest) ([]map[string]interface{}, error) {
+	return s.serviceClient.QueryItemsExtended(s.sessionId, req)
 }
 
-func (wc ApiContext) Controller(controller string) (RemoteController, error) {
-	return RemoteController{ctx: wc.ctx, sessionId: wc.sessionId, controller: controller, serviceClient: wc.serviceClient}, nil
+func (s ContextImpl) FileGet(req GetFileExtendedRequest) (GetFileResponse, error) {
+	return s.serviceClient.GetFileExtended(s.sessionId, req)
 }

Diff for: polycode/runtime.go

@@ -170,29 +170,24 @@ func runService(ctx context.Context, event ServiceStartEvent) (evt ServiceComple
 		return ErrorToServiceComplete(ErrBadRequest.Wrap(err)), nil
 	}
 
+	ctxImpl := &ContextImpl{
+		ctx:           ctx,
+		sessionId:     event.SessionId,
+		dataStore:     NewDatabase(serviceClient, event.SessionId),
+		fileStore:     NewFileStore(serviceClient, event.SessionId),
+		config:        appConfig,
+		serviceClient: serviceClient,
+	}
+
 	var ret any
 	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.Service,
 			event.Method, event.SessionId))
-		ret, err = service.ExecuteWorkflow(workflowCtx, event.Method, inputObj)
+		ret, err = service.ExecuteWorkflow(ctxImpl, event.Method, inputObj)
 	} else {
-		srvCtx := ServiceContext{
-			ctx:       ctx,
-			sessionId: event.SessionId,
-			dataStore: NewDatabase(serviceClient, event.SessionId),
-			config:    appConfig,
-		}
-
 		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)
+		ret, err = service.ExecuteService(ctxImpl, event.Method, inputObj)
 	}
 
 	if err != nil {
@@ -235,14 +230,16 @@ func runApi(ctx context.Context, event ApiStartEvent) (evt ApiCompleteEvent, err
 		return ErrorToApiComplete(ErrApiExecError.Wrap(fmt.Errorf("api not registered"))), nil
 	}
 
-	apiCtx := ApiContext{
+	ctxImpl := &ContextImpl{
 		ctx:           ctx,
 		sessionId:     event.SessionId,
-		serviceClient: serviceClient,
+		dataStore:     NewDatabase(serviceClient, event.SessionId),
+		fileStore:     NewFileStore(serviceClient, event.SessionId),
 		config:        appConfig,
+		serviceClient: serviceClient,
 	}
 
-	newCtx := context.WithValue(ctx, "polycode.context", apiCtx)
+	newCtx := context.WithValue(ctx, "polycode.context", ctxImpl)
 	httpReq, err := ConvertToHttpRequest(newCtx, event.Request)
 	if err != nil {
 		println("client: api error, bad request")

Diff for: rawcontext/context.go

@@ -0,0 +1,15 @@
+package apicontext
+
+import (
+	"context"
+	"github.com/cloudimpl/next-coder-sdk/polycode"
+)
+
+func FromContext(ctx context.Context) (polycode.RawContext, error) {
+	rawContext, ok := ctx.(polycode.RawContext)
+	if !ok {
+		return nil, polycode.ErrContextNotFound
+	}
+
+	return rawContext, nil
+}