aaplying @ribeiromiranda's patch

Signed-off-by: Spolti <filippespolti@gmail.com>

Author: spolti

model/workflow.go

@@ -15,8 +15,9 @@
 package model
 
 import (
+	"bytes"
 	"encoding/json"
-	"regexp"
+	"errors"
 
 	"github.com/serverlessworkflow/sdk-go/v2/util"
 )
@@ -522,33 +523,41 @@ type dataInputSchemaUnmarshal DataInputSchema
 // UnmarshalJSON implements json.Unmarshaler
 func (d *DataInputSchema) UnmarshalJSON(data []byte) error {
 	d.ApplyDefault()
-	err := util.UnmarshalObject("dataInputSchema", data, (*dataInputSchemaUnmarshal)(d))
+
+	// expected: data = "{\"key\": \"value\"}"
+	//           data = {"key": "value"}
+	//	         data = "file://..."
+	//           data = { "schema": "{\"key\": \"value\"}", "failOnValidationErrors": true }
+	//           data = { "schema": {"key": "value"}, "failOnValidationErrors": true }
+	//           data = { "schema": "file://...", "failOnValidationErrors": true }
+
+	schemaString := ""
+	err := util.UnmarshalPrimitiveOrObject("dataInputSchema", data, &schemaString, (*dataInputSchemaUnmarshal)(d))
 	if err != nil {
 		return err
 	}
 
-	if d.Schema != nil && d.Schema.Type == String {
-		// Define the regex pattern to match the prefixes
-		pattern := `^(http|https|file)`
-		regex := regexp.MustCompile(pattern)
-		// if it is not external, treat as JSON object
-		if !regex.MatchString(d.Schema.StringValue) {
-			point := FromString(d.Schema.StringValue)
-			d.Schema = &point
+	if d.Schema != nil {
+		if d.Schema.Type == Map {
 			return nil
-		}
 
-		data, err := util.LoadExternalResource(d.Schema.StringValue)
-		if err != nil {
-			return err
+		} else if d.Schema.Type == String {
+			schemaString = d.Schema.StringValue
+
+		} else {
+			return errors.New("invalid dataInputSchema must be a string or object")
 		}
+	}
 
-		er := util.UnmarshalObject("schema", data, &d.Schema)
-		// clean the string value to avoid the json URI being appended
-		d.Schema.StringValue = ""
-		return er
+	if schemaString != "" {
+		data = []byte(schemaString)
+		if bytes.TrimSpace(data)[0] != '{' {
+			data = []byte("\"" + schemaString + "\"")
+		}
 	}
-	return nil
+
+	d.Schema = new(Object)
+	return util.UnmarshalObjectOrFile("schema", data, &d.Schema)
 }
 
 // ApplyDefault set the default values for Data Input Schema

model/workflow_test.go

@@ -499,7 +499,11 @@ func TestTransitionUnmarshalJSON(t *testing.T) {
 
 func TestDataInputSchemaUnmarshalJSON(t *testing.T) {
 
-	schemaName := FromString("schema name")
+	var schemaName Object
+	err := json.Unmarshal([]byte("{\"key\": \"value\"}"), &schemaName)
+	if !assert.NoError(t, err) {
+		return
+	}
 
 	type testCase struct {
 		desp   string
@@ -511,53 +515,73 @@ func TestDataInputSchemaUnmarshalJSON(t *testing.T) {
 	testCases := []testCase{
 		{
 			desp: "string success",
-			data: `"schema name"`,
+			data: "{\"key\": \"value\"}",
 			expect: DataInputSchema{
 				Schema:                 &schemaName,
 				FailOnValidationErrors: true,
 			},
-			err: `dataInputSchema must be string or object`,
+			err: ``,
 		},
 		{
-			desp: `object success`,
-			data: `{"schema": "schema name"}`,
+			desp: "string fail",
+			data: "{\"key\": }",
+			expect: DataInputSchema{
+				Schema:                 &schemaName,
+				FailOnValidationErrors: true,
+			},
+			err: `invalid character '}' looking for beginning of value`,
+		},
+		{
+			desp: `object success (without quotes)`,
+			data: `{"key": "value"}`,
 			expect: DataInputSchema{
 				Schema:                 &schemaName,
 				FailOnValidationErrors: true,
 			},
 			err: ``,
 		},
 		{
-			desp: `object fail`,
-			data: `{"schema": "schema name}`,
+			desp: `schema object success`,
+			data: `{"schema": "{\"key\": \"value\"}"}`,
 			expect: DataInputSchema{
 				Schema:                 &schemaName,
 				FailOnValidationErrors: true,
 			},
-			err: `unexpected end of JSON input`,
+			err: ``,
 		},
 		{
-			desp: `object key invalid`,
-			data: `{"schema_invalid": "schema name"}`,
+			desp: `schema object success (without quotes)`,
+			data: `{"schema": {"key": "value"}}`,
 			expect: DataInputSchema{
+				Schema:                 &schemaName,
 				FailOnValidationErrors: true,
 			},
 			err: ``,
 		},
+		{
+			desp: `schema object fail`,
+			data: `{"schema": "schema name}`,
+			expect: DataInputSchema{
+				Schema:                 &schemaName,
+				FailOnValidationErrors: true,
+			},
+			err: `unexpected end of JSON input`,
+		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.desp, func(t *testing.T) {
 			var v DataInputSchema
 			err := json.Unmarshal([]byte(tc.data), &v)
 
 			if tc.err != "" {
-				assert.Error(t, err)
-				assert.Regexp(t, tc.err, err)
+				assert.Error(t, err, tc.desp)
+				assert.Regexp(t, tc.err, err, tc.desp)
 				return
 			}
 
-			assert.NoError(t, err)
-			assert.Equal(t, tc.expect, v)
+			assert.NoError(t, err, tc.desp)
+			assert.Equal(t, tc.expect.Schema, v.Schema, tc.desp)
+			assert.Equal(t, tc.expect.FailOnValidationErrors, v.FailOnValidationErrors, tc.desp)
 		})
 	}
 }

util/unmarshal.go

@@ -221,7 +221,7 @@ func UnmarshalObjectOrFile[U any](parameterName string, data []byte, valObject *
 	}
 
 	data = bytes.TrimSpace(data)
-	if data[0] == '{' && parameterName != "constants" && parameterName != "timeouts" {
+	if data[0] == '{' && parameterName != "constants" && parameterName != "timeouts" && parameterName != "schema" {
 		extractData := map[string]json.RawMessage{}
 		err = json.Unmarshal(data, &extractData)
 		if err != nil {