return input/outputs as a raw json string from list workflows and get workflow steps

Author: maxdml

dbos/client_test.go

@@ -2,6 +2,7 @@ package dbos
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"strings"
 	"sync"
@@ -373,7 +374,8 @@ func TestCancelResume(t *testing.T) {
 		require.NoError(t, err, "failed to get result from resumed workflow")
 
 		// Decode the result from any (which may be float64 after JSON decode) to int
-		result, err := decodeAnyToType[int](resultAny)
+		var result int
+		err = json.Unmarshal([]byte(resultAny.(string)), &result)
 		require.NoError(t, err, "failed to decode result to int")
 
 		// Verify the result
@@ -399,7 +401,8 @@ func TestCancelResume(t *testing.T) {
 		require.NoError(t, err, "failed to get result from second resume")
 
 		// Decode the result from any (which may be float64 after JSON decode) to int
-		resultAgain, err := decodeAnyToType[int](resultAgainAny)
+		var resultAgain int
+		err = json.Unmarshal([]byte(resultAgainAny.(string)), &resultAgain)
 		require.NoError(t, err, "failed to decode second result to int")
 
 		assert.Equal(t, input, resultAgain, "expected second resume result to match input")

dbos/queues_test.go

@@ -2,6 +2,7 @@ package dbos
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
@@ -541,7 +542,8 @@ func TestQueueRecovery(t *testing.T) {
 			resultAny, err := h.GetResult()
 			require.NoError(t, err, "failed to get result from recovered root workflow handle")
 			// Decode the result from any (which may be []interface{} after JSON decode) to []int
-			castedResult, err := decodeAnyToType[[]int](resultAny)
+			var castedResult []int
+			err = json.Unmarshal([]byte(resultAny.(string)), &castedResult)
 			require.NoError(t, err, "failed to decode result to []int")
 			expectedResult := []int{0, 1, 2, 3, 4}
 			assert.Equal(t, expectedResult, castedResult, "expected result %v, got %v", expectedResult, castedResult)

dbos/serialization_test.go

@@ -11,25 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// decodeAnyToType converts an any value (which is map[string]interface{} after JSON decode)
-// back to the expected type T by re-encoding to JSON and decoding into T.
-func decodeAnyToType[T any](value any) (T, error) {
-	var result T
-	if value == nil {
-		return result, nil
-	}
-	// Re-encode the any value to JSON
-	jsonBytes, err := json.Marshal(value)
-	if err != nil {
-		return result, fmt.Errorf("failed to marshal any value: %w", err)
-	}
-	// Decode JSON into the expected type T
-	if err := json.Unmarshal(jsonBytes, &result); err != nil {
-		return result, fmt.Errorf("failed to unmarshal into type T: %w", err)
-	}
-	return result, nil
-}
-
 // testAllSerializationPaths tests workflow recovery and verifies all read paths.
 // This is the unified test function that exercises:
 // 1. Workflow recovery: starts a workflow, blocks it, recovers it, then verifies completion
@@ -116,13 +97,17 @@ func testAllSerializationPaths[T any](
 		if len(steps) > 0 {
 			lastStep := steps[len(steps)-1]
 			if isNilExpected {
-				assert.Nil(t, lastStep.Output, "Step output should be nil")
+				// Should be an empty string
+				assert.Equal(t, "", lastStep.Output, "Step output should be an empty string")
 			} else {
 				require.NotNil(t, lastStep.Output)
-				// GetWorkflowSteps returns any (map[string]interface{} after JSON decode)
-				// We need to re-encode to JSON and decode into type T
-				decodedOutput, err := decodeAnyToType[T](lastStep.Output)
-				require.NoError(t, err, "Failed to decode step output to type T")
+				// GetWorkflowSteps returns a string (base64-decoded JSON)
+				// Unmarshal the JSON string into type T
+				strValue, ok := lastStep.Output.(string)
+				require.True(t, ok, "Step output should be a string")
+				var decodedOutput T
+				err := json.Unmarshal([]byte(strValue), &decodedOutput)
+				require.NoError(t, err, "Failed to unmarshal step output to type T")
 				assert.Equal(t, expectedOutput, decodedOutput, "Step output should match expected output")
 			}
 			assert.Nil(t, lastStep.Error)
@@ -138,18 +123,28 @@ func testAllSerializationPaths[T any](
 		require.Len(t, wfs, 1)
 		wf := wfs[0]
 		if isNilExpected {
-			assert.Nil(t, wf.Input, "Workflow input should be nil")
-			assert.Nil(t, wf.Output, "Workflow output should be nil")
+			// Should be an empty string
+			assert.Equal(t, "", wf.Input, "Workflow input should be an empty string")
+			assert.Equal(t, "", wf.Output, "Workflow output should be an empty string")
 		} else {
 			require.NotNil(t, wf.Input)
 			require.NotNil(t, wf.Output)
 
-			// ListWorkflows returns any (map[string]interface{} after JSON decode)
-			// We need to re-encode to JSON and decode into type T
-			decodedInput, err := decodeAnyToType[T](wf.Input)
-			require.NoError(t, err, "Failed to decode workflow input to type T")
-			decodedOutput, err := decodeAnyToType[T](wf.Output)
-			require.NoError(t, err, "Failed to decode workflow output to type T")
+			// ListWorkflows returns strings (base64-decoded JSON)
+			// Unmarshal the JSON strings into type T
+			inputStr, ok := wf.Input.(string)
+			require.True(t, ok, "Workflow input should be a string")
+			outputStr, ok := wf.Output.(string)
+			require.True(t, ok, "Workflow output should be a string")
+
+			var decodedInput T
+			err := json.Unmarshal([]byte(inputStr), &decodedInput)
+			require.NoError(t, err, "Failed to unmarshal workflow input to type T")
+
+			var decodedOutput T
+			err = json.Unmarshal([]byte(outputStr), &decodedOutput)
+			require.NoError(t, err, "Failed to unmarshal workflow output to type T")
+
 			assert.Equal(t, input, decodedInput, "Workflow input should match input")
 			assert.Equal(t, expectedOutput, decodedOutput, "Workflow output should match expected output")
 		}

dbos/workflow.go

@@ -2,6 +2,7 @@ package dbos
 
 import (
 	"context"
+	"encoding/base64"
 	"errors"
 	"fmt"
 	"math"
@@ -2063,29 +2064,28 @@ func (c *dbosContext) ListWorkflows(_ DBOSContext, opts ...ListWorkflowsOption)
 
 	// Deserialize Input and Output fields if they were loaded
 	if params.loadInput || params.loadOutput {
-		serializer := newJSONSerializer[any]()
 		for i := range workflows {
 			if params.loadInput && workflows[i].Input != nil {
 				encodedInput, ok := workflows[i].Input.(*string)
 				if !ok {
 					return nil, fmt.Errorf("workflow input must be encoded string, got %T", workflows[i].Input)
 				}
-				decodedInput, err := serializer.Decode(encodedInput)
+				decodedBytes, err := base64.StdEncoding.DecodeString(*encodedInput)
 				if err != nil {
-					return nil, fmt.Errorf("failed to deserialize workflow input for %s: %w", workflows[i].ID, err)
+					return nil, fmt.Errorf("failed to decode base64 workflow input for %s: %w", workflows[i].ID, err)
 				}
-				workflows[i].Input = decodedInput
+				workflows[i].Input = string(decodedBytes)
 			}
 			if params.loadOutput && workflows[i].Output != nil {
 				encodedOutput, ok := workflows[i].Output.(*string)
 				if !ok {
 					return nil, fmt.Errorf("workflow output must be encoded string, got %T", workflows[i].Output)
 				}
-				decodedOutput, err := serializer.Decode(encodedOutput)
+				decodedBytes, err := base64.StdEncoding.DecodeString(*encodedOutput)
 				if err != nil {
-					return nil, fmt.Errorf("failed to deserialize workflow output for %s: %w", workflows[i].ID, err)
+					return nil, fmt.Errorf("failed to decode base64 workflow output for %s: %w", workflows[i].ID, err)
 				}
-				workflows[i].Output = decodedOutput
+				workflows[i].Output = string(decodedBytes)
 			}
 		}
 	}
@@ -2191,14 +2191,16 @@ func (c *dbosContext) GetWorkflowSteps(_ DBOSContext, workflowID string) ([]Step
 
 	// Deserialize outputs if asked to
 	if loadOutput {
-		serializer := newJSONSerializer[any]()
 		for i := range steps {
 			encodedOutput := steps[i].Output
-			decodedOutput, err := serializer.Decode(encodedOutput)
+			if encodedOutput == nil {
+				continue
+			}
+			decodedBytes, err := base64.StdEncoding.DecodeString(*encodedOutput)
 			if err != nil {
-				return nil, fmt.Errorf("failed to deserialize step output for step %d: %w", steps[i].StepID, err)
+				return nil, fmt.Errorf("failed to decode base64 step output for step %d: %w", steps[i].StepID, err)
 			}
-			stepInfos[i].Output = decodedOutput
+			stepInfos[i].Output = string(decodedBytes)
 		}
 	}
 

dbos/workflows_test.go

@@ -2,6 +2,7 @@ package dbos
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
@@ -674,8 +675,9 @@ func TestSteps(t *testing.T) {
 		assert.Nil(t, step.Error)
 
 		// Deserialize the output from the database to verify proper encoding
-		// Use decodeAnyToType to handle JSON encode/decode round-trip
-		storedOutput, err := decodeAnyToType[StepOutput](step.Output)
+		// Use json.Unmarshal to handle JSON encode/decode round-trip
+		var storedOutput StepOutput
+		err = json.Unmarshal([]byte(step.Output.(string)), &storedOutput)
 		require.NoError(t, err, "failed to decode step output to StepOutput")
 
 		// Verify all fields were correctly serialized and deserialized
@@ -1416,7 +1418,8 @@ func TestWorkflowDeadLetterQueue(t *testing.T) {
 			resultAny, err := h.GetResult()
 			require.NoError(t, err, "failed to get result from handle %d", i)
 			// Decode the result from any (which may be float64 after JSON decode) to int
-			result, err := decodeAnyToType[int](resultAny)
+			var result int
+			err = json.Unmarshal([]byte(resultAny.(string)), &result)
 			require.NoError(t, err, "failed to decode result to int")
 			require.Equal(t, 0, result)
 		}