Make body field byte array instead of any type.

Author: mehmettokgoz

README.md

@@ -95,12 +95,7 @@ Start a new workflow run with provided options.
 ```go
 runID, err := client.Trigger(workflow.TriggerOptions{
     Url: "https://your-workflow-endpoint.com/api/process"
-    Body: map[string]interface{}{
-        "user_id":    12345,
-        "action":     "purchase",
-        "items":      []string{"item1", "item2", "item3"},
-        "total_cost": 99.99,
-    },
+    Body: []byte("request payload"),
 })
 if err != nil {
     // handle err
@@ -113,9 +108,7 @@ Send a notify message to workflows waiting for a specific event.
 
 ```go
 
-messages, err := client.Notify("event-id", map[string]string{
-		"userId": "testUser",
-})
+messages, err := client.Notify("event-id", []byte("notify data"))
 if err != nil {
     // handle err
 }

cancel.go

@@ -61,7 +61,7 @@ func (c *Client) cancel(req cancelRequest) (int, error) {
 	resp, _, err := c.do(requestOptions{
 		method: http.MethodDelete,
 		path:   []string{"v2", "workflows", "runs"},
-		body:   string(data),
+		body:   data,
 		header: http.Header{
 			"Content-Type": []string{"application/json"},
 		},

client.go

@@ -1,6 +1,7 @@
 package workflow
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -76,13 +77,13 @@ func NewClientWithEnv() (*Client, error) {
 type requestOptions struct {
 	method string
 	path   []string
-	body   string
+	body   []byte
 	header http.Header
 	params url.Values
 }
 
 func (c *Client) do(opts requestOptions) ([]byte, int, error) {
-	request, err := http.NewRequest(opts.method, fmt.Sprintf("%s%s", c.url, strings.Join(opts.path, "/")), strings.NewReader(opts.body))
+	request, err := http.NewRequest(opts.method, fmt.Sprintf("%s%s", c.url, strings.Join(opts.path, "/")), bytes.NewReader(opts.body))
 	if err != nil {
 		return nil, -1, err
 	}

const.go

@@ -10,6 +10,7 @@ const (
 	forwardPrefix = "Upstash-Forward-"
 
 	authorizationHeader = "Authorization"
+	contentTypeHeader   = "Content-Type"
 
 	initHeader             = "Upstash-Workflow-Init"
 	runIdHeader            = "Upstash-Workflow-Runid"

examples/notify/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	workflow "workflow-go"
 )
@@ -12,9 +13,14 @@ func main() {
 		return
 	}
 
-	notifiedWaiters, err := client.Notify("event-id", map[string]string{
+	eventData, err := json.Marshal(map[string]string{
 		"userId": "testUser",
 	})
+	if err != nil {
+		fmt.Printf("failed to marshal request payload: %v\n", err)
+		return
+	}
+	notifiedWaiters, err := client.Notify("event-id", eventData)
 	if err != nil {
 		fmt.Printf("failed to notify event: %v\n", err)
 		return

examples/trigger/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	workflow "workflow-go"
 )
@@ -12,19 +13,23 @@ func main() {
 		return
 	}
 
+	requestPayload, err := json.Marshal(map[string]interface{}{
+		"user_id":    12345,
+		"action":     "purchase",
+		"items":      []string{"item1", "item2", "item3"},
+		"total_cost": 99.99,
+		"timestamp":  "2025-04-16T18:05:24+03:00",
+	})
+	if err != nil {
+		return
+	}
 	runID, err := client.Trigger(workflow.TriggerOptions{
-		Url: "https://your-workflow-endpoint.com/api/process",
-		Body: map[string]interface{}{
-			"user_id":    12345,
-			"action":     "purchase",
-			"items":      []string{"item1", "item2", "item3"},
-			"total_cost": 99.99,
-			"timestamp":  "2025-04-16T18:05:24+03:00",
-		},
+		Url:            "https://your-workflow-endpoint.com/api/process",
+		Body:           requestPayload,
 		Retries:        workflow.Retry(2),
 		FlowControlKey: "my-flow-control-key",
-		Rate:           workflow.Rate(100),
-		Parallelism:    workflow.Parallelism(100),
+		Rate:           100,
+		Parallelism:    100,
 	})
 	if err != nil {
 		fmt.Printf("failed to trigger workflow run: %v\n", err)

logs_test.go

@@ -14,10 +14,10 @@ func TestLogs(t *testing.T) {
 	for i := 0; i < 3; i++ {
 		runId, err := client.Trigger(workflow.TriggerOptions{
 			Url: simpleWorkflowUrl,
-			Body: map[string]string{
+			Body: jsonMarshall(t, map[string]string{
 				"name": "Run Test User",
 				"id":   string(rune(65 + i)),
-			},
+			}),
 		})
 		assert.NoError(t, err)
 		assert.NotEmpty(t, runId)
@@ -26,9 +26,9 @@ func TestLogs(t *testing.T) {
 
 	longRunId, err := client.Trigger(workflow.TriggerOptions{
 		Url: longRunningWorkflow,
-		Body: map[string]string{
+		Body: jsonMarshall(t, map[string]string{
 			"name": "Long Running Test",
-		},
+		}),
 	})
 	assert.NoError(t, err)
 	assert.NotEmpty(t, longRunId)

notify.go

@@ -1,30 +1,17 @@
 package workflow
 
 import (
-	"encoding/json"
-	"fmt"
 	"net/http"
-	"reflect"
 )
 
 // Notify notifies waiters waiting for the given event ID.
-// Event data is expected to be either a string or a JSON serializable object.
+// Event data is sent to the waiters as is.
 // It returns the list of waiters that were notified.
-func (c *Client) Notify(eventId string, eventData any) ([]NotifyMessage, error) {
-	body := ""
-	if reflect.ValueOf(eventData).Kind() != reflect.String {
-		data, err := json.Marshal(eventData)
-		if err != nil {
-			return nil, fmt.Errorf("failed to marshall event data: %w", err)
-		}
-		body = string(data)
-	} else {
-		body = eventData.(string)
-	}
+func (c *Client) Notify(eventId string, eventData []byte) ([]NotifyMessage, error) {
 	req := requestOptions{
 		method: http.MethodPost,
 		path:   []string{"v2", "notify", eventId},
-		body:   body,
+		body:   eventData,
 	}
 	resp, _, err := c.do(req)
 	if err != nil {

notify_test.go

@@ -12,7 +12,7 @@ func TestNotify_WithoutWaiter(t *testing.T) {
 	client, err := workflow.NewClientWithEnv()
 	assert.NoError(t, err)
 
-	messages, err := client.Notify(uuid.NewString(), uuid.NewString())
+	messages, err := client.Notify(uuid.NewString(), []byte(uuid.NewString()))
 	assert.NoError(t, err)
 	assert.Len(t, messages, 0)
 }
@@ -26,15 +26,15 @@ func TestNotify(t *testing.T) {
 	})
 
 	eventId := uuid.NewString()
-	expectedEventData := map[string]string{
+	expectedEventData := jsonMarshall(t, map[string]string{
 		"uuid": uuid.NewString(),
-	}
+	})
 	runId, err := client.Trigger(workflow.TriggerOptions{
 		Url: waitForEvent,
-		Body: map[string]any{
+		Body: jsonMarshall(t, map[string]any{
 			"eventId":           eventId,
 			"expectedEventData": expectedEventData,
-		},
+		}),
 	})
 	assert.NoError(t, err)
 	assert.NotEmpty(t, runId)

trigger.go

@@ -10,15 +10,17 @@ type TriggerOptions struct {
 	// Url of the workflow
 	Url string
 	// Body is the request payload of the new workflow run.
-	// It is expected to be either a string or JSON serializable object.
-	Body any
+	Body []byte
 	// RunId is the id of the new workflow run. If not provided, a random id will be generated
 	RunId string
 	// Retries is the number of retries if a step fails.
-	Retries        *int
+	Retries *int
+	// FlowControlKey is the key used to control the flow of new steps.
 	FlowControlKey string
-	Rate           *int
-	Parallelism    *int
+	// Rate is the number of new starting steps per period.
+	Rate int
+	// Parallelism defines the maximum number of active steps associated with this FlowControlKey.
+	Parallelism int
 	// Header is the custom headers that will be forwarded to the workflow.
 	Header http.Header
 }
@@ -42,20 +44,25 @@ func (o *TriggerOptions) header() http.Header {
 	header.Add(featureSetHeader, featureInitialBody)
 	if o.FlowControlKey != "" {
 		value := ""
-		if o.Rate != nil {
-			value += "rate=" + strconv.Itoa(*o.Rate)
+		givenRate := o.Rate != 0
+		if givenRate {
+			value += fmt.Sprintf("rate=%d", o.Rate)
 		}
-		if len(value) != 0 {
-			value += ","
-		}
-		if o.Parallelism != nil {
-			value += "parallelism=" + strconv.Itoa(*o.Parallelism)
+		if o.Parallelism != 0 {
+			if givenRate {
+				value += ","
+			}
+			value += fmt.Sprintf("parallelism=%d", o.Parallelism)
 		}
 		if len(value) > 0 {
 			header.Set(flowControlKeyHeader, o.FlowControlKey)
 			header.Set(flowControlValueHeader, value)
 		}
 	}
+	if contentType := o.Header.Get(contentTypeHeader); contentType != "" {
+		header.Set(contentTypeHeader, contentType)
+		o.Header.Del(contentTypeHeader)
+	}
 	header.Set(fmt.Sprintf("%s%s", forwardPrefix, sdkVersionHeader), sdkVersion)
 	for k, v := range o.Header {
 		for _, vv := range v {
@@ -77,15 +84,11 @@ func (c *Client) Trigger(opts TriggerOptions) (runId string, err error) {
 	if err = opts.validate(); err != nil {
 		return "", fmt.Errorf("failed to validate options: %w", err)
 	}
-	body, _, err := serializeToStr(opts.Body)
-	if err != nil {
-		return "", fmt.Errorf("failed to serialize body: %w", err)
-	}
 	header := opts.header()
 	req := requestOptions{
 		method: http.MethodPost,
 		path:   []string{"v2", "publish", opts.Url},
-		body:   body,
+		body:   opts.Body,
 		header: header,
 	}
 	resp, _, err := c.do(req)