aaplying @ribeiromiranda's patch

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

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 {