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

Author: CloudimplBot

polycode/context.go

@@ -2,14 +2,18 @@ package polycode
 
 import (
 	"context"
-	"fmt"
 	"time"
 )
 
+type AuthContext struct {
+	claims map[string]interface{}
+}
+
 type BaseContext interface {
 	context.Context
 	Meta() ContextMeta
 	AppConfig() AppConfig
+	AuthContext() AuthContext
 	Logger() Logger
 }
 
@@ -30,10 +34,8 @@ type WorkflowContext interface {
 	ControllerEx(envId string, controller string) RemoteController
 	UnsafeDb() *UnsafeDataStoreBuilder
 	Memo(getter func() (any, error)) Response
-	SignalAwait(signalName string) Response
-	SignalResumeSuccess(taskId string, signalName string, data any) error
-	SignalResumeError(taskId string, signalName string, err Error) error
-	EmitRealtimeEvent(channel string, data any) error
+	Signal(signalName string) Signal
+	RealtimeChannel(channelName string) RealtimeChannel
 }
 
 type ApiContext interface {
@@ -54,12 +56,17 @@ type ContextImpl struct {
 	serviceClient *ServiceClient
 	logger        Logger
 	meta          ContextMeta
+	authCtx       AuthContext
 }
 
 func (s ContextImpl) Meta() ContextMeta {
 	return s.meta
 }
 
+func (s ContextImpl) AuthContext() AuthContext {
+	return s.authCtx
+}
+
 func (s ContextImpl) AppConfig() AppConfig {
 	return s.config
 }
@@ -135,62 +142,20 @@ func (s ContextImpl) Logger() Logger {
 	return s.logger
 }
 
-func (s ContextImpl) Acknowledge() error {
-	return s.serviceClient.Acknowledge(s.sessionId)
-}
-
-func (s ContextImpl) SignalAwait(signalName string) Response {
-	req := SignalWaitRequest{
-		SignalName: signalName,
-	}
-
-	output, err := s.serviceClient.WaitForSignal(s.sessionId, req)
-	if err != nil {
-		fmt.Printf("client: signal await error: %v\n", err)
-		return Response{
-			output:  nil,
-			isError: true,
-			error:   ErrTaskExecError.Wrap(err),
-		}
-	}
-
-	fmt.Printf("client: signal await output: %v\n", output)
-	return Response{
-		output:  output.Output,
-		isError: output.IsError,
-		error:   output.Error,
+func (s ContextImpl) Signal(signalName string) Signal {
+	return Signal{
+		name:          signalName,
+		sessionId:     s.sessionId,
+		serviceClient: s.serviceClient,
 	}
 }
 
-func (s ContextImpl) SignalResumeSuccess(taskId string, signalName string, data any) error {
-	req := SignalEmitRequest{
-		TaskId:     taskId,
-		SignalName: signalName,
-		Output:     data,
-		IsError:    false,
+func (s ContextImpl) RealtimeChannel(channelName string) RealtimeChannel {
+	return RealtimeChannel{
+		name:          channelName,
+		sessionId:     s.sessionId,
+		serviceClient: s.serviceClient,
 	}
-
-	return s.serviceClient.EmitSignal(s.sessionId, req)
-}
-
-func (s ContextImpl) SignalResumeError(taskId string, signalName string, err Error) error {
-	req := SignalEmitRequest{
-		TaskId:     taskId,
-		SignalName: signalName,
-		IsError:    true,
-		Error:      err,
-	}
-
-	return s.serviceClient.EmitSignal(s.sessionId, req)
-}
-
-func (s ContextImpl) EmitRealtimeEvent(channel string, data any) error {
-	req := RealtimeEventEmitRequest{
-		Channel: channel,
-		Input:   data,
-	}
-
-	return s.serviceClient.EmitRealtimeEvent(s.sessionId, req)
 }
 
 func (s ContextImpl) Counter(group string, name string, ttl int64) Counter {

polycode/model.go

@@ -23,18 +23,20 @@ func (t TaskOptions) WithTimeout(timeout time.Duration) TaskOptions {
 }
 
 type MethodStartEvent struct {
-	SessionId string      `json:"sessionId"`
-	Method    string      `json:"method"`
-	Meta      ContextMeta `json:"meta"`
-	Input     any         `json:"input"`
+	SessionId   string      `json:"sessionId"`
+	Method      string      `json:"method"`
+	Meta        ContextMeta `json:"meta"`
+	AuthContext AuthContext `json:"authContext"`
+	Input       any         `json:"input"`
 }
 
 type ServiceStartEvent struct {
-	SessionId string      `json:"sessionId"`
-	Service   string      `json:"service"`
-	Method    string      `json:"method"`
-	Meta      ContextMeta `json:"meta"`
-	Input     any         `json:"input"`
+	SessionId   string      `json:"sessionId"`
+	Service     string      `json:"service"`
+	Method      string      `json:"method"`
+	Meta        ContextMeta `json:"meta"`
+	AuthContext AuthContext `json:"authContext"`
+	Input       any         `json:"input"`
 }
 
 type ServiceMeta struct {
@@ -51,9 +53,10 @@ type ServiceCompleteEvent struct {
 }
 
 type ApiStartEvent struct {
-	SessionId string      `json:"sessionId"`
-	Meta      ContextMeta `json:"meta"`
-	Request   ApiRequest  `json:"request"`
+	SessionId   string      `json:"sessionId"`
+	Meta        ContextMeta `json:"meta"`
+	AuthContext AuthContext `json:"authContext"`
+	Request     ApiRequest  `json:"request"`
 }
 
 type ApiCompleteEvent struct {

polycode/realtimechannel.go

@@ -0,0 +1,16 @@
+package polycode
+
+type RealtimeChannel struct {
+	name          string
+	sessionId     string
+	serviceClient *ServiceClient
+}
+
+func (r RealtimeChannel) Emit(data any) error {
+	req := RealtimeEventEmitRequest{
+		Channel: r.name,
+		Input:   data,
+	}
+
+	return r.serviceClient.EmitRealtimeEvent(r.sessionId, req)
+}

polycode/runtime.go

@@ -211,6 +211,7 @@ func runService(ctx context.Context, taskLogger Logger, event ServiceStartEvent)
 		serviceClient: serviceClient,
 		logger:        taskLogger,
 		meta:          event.Meta,
+		authCtx:       event.AuthContext,
 	}
 
 	var ret any
@@ -305,6 +306,7 @@ func runApi(ctx context.Context, taskLogger Logger, event ApiStartEvent) (evt Ap
 		serviceClient: serviceClient,
 		logger:        taskLogger,
 		meta:          event.Meta,
+		authCtx:       event.AuthContext,
 	}
 
 	newCtx := context.WithValue(ctx, "polycode.context", ctxImpl)

polycode/signal.go

@@ -0,0 +1,54 @@
+package polycode
+
+import "fmt"
+
+type Signal struct {
+	name          string
+	sessionId     string
+	serviceClient *ServiceClient
+}
+
+func (s *Signal) Await() Response {
+	req := SignalWaitRequest{
+		SignalName: s.name,
+	}
+
+	output, err := s.serviceClient.WaitForSignal(s.sessionId, req)
+	if err != nil {
+		fmt.Printf("client: signal await error: %v\n", err)
+		return Response{
+			output:  nil,
+			isError: true,
+			error:   ErrTaskExecError.Wrap(err),
+		}
+	}
+
+	fmt.Printf("client: signal await output: %v\n", output)
+	return Response{
+		output:  output.Output,
+		isError: output.IsError,
+		error:   output.Error,
+	}
+}
+
+func (s *Signal) EmitValue(taskId string, data any) error {
+	req := SignalEmitRequest{
+		TaskId:     taskId,
+		SignalName: s.name,
+		Output:     data,
+		IsError:    false,
+	}
+
+	return s.serviceClient.EmitSignal(s.sessionId, req)
+}
+
+func (s *Signal) EmitError(taskId string, err Error) error {
+	req := SignalEmitRequest{
+		TaskId:     taskId,
+		SignalName: s.name,
+		IsError:    true,
+		Error:      err,
+	}
+
+	return s.serviceClient.EmitSignal(s.sessionId, req)
+}