Merge branch 'main' into shahab/versioning-metrics

Author: Shivs11

chasm/collection.go

@@ -9,8 +9,8 @@ import (
 )
 
 const (
-	chasmFieldTypePrefix      = "chasm.Field["
-	chasmCollectionTypePrefix = "chasm.Collection["
+	chasmFieldTypePrefix = "chasm.Field["
+	chasmMapTypePrefix   = "chasm.Map["
 
 	fieldNameTag = "name"
 )
@@ -21,7 +21,7 @@ const (
 	fieldKindUnspecified fieldKind = iota
 	fieldKindData
 	fieldKindSubField
-	fieldKindSubCollection
+	fieldKindSubMap
 )
 
 type fieldInfo struct {
@@ -61,10 +61,10 @@ func fieldsOf(valueV reflect.Value) iter.Seq[fieldInfo] {
 					switch prefix {
 					case chasmFieldTypePrefix:
 						fieldK = fieldKindSubField
-					case chasmCollectionTypePrefix:
-						fieldK = fieldKindSubCollection
+					case chasmMapTypePrefix:
+						fieldK = fieldKindSubMap
 					default:
-						fieldErr = serviceerror.NewInternalf("%s.%s: unsupported field type %s: must implement proto.Message, or be chasm.Field[T] or chasm.Collection[T]", valueT, fieldN, fieldT)
+						fieldErr = serviceerror.NewInternalf("%s.%s: unsupported field type %s: must implement proto.Message, or be chasm.Field[T] or chasm.Map[T]", valueT, fieldN, fieldT)
 					}
 				}
 

chasm/fields_iterator.go

@@ -52,9 +52,9 @@ func (s *fieldsIteratorSuite) TestGenericTypePrefix() {
 			expected: chasmFieldTypePrefix,
 		},
 		{
-			name:     "Collection type",
-			input:    Collection[string, int]{},
-			expected: chasmCollectionTypePrefix,
+			name:     "Map type",
+			input:    Map[string, int]{},
+			expected: chasmMapTypePrefix,
 		},
 		{
 			name:     "Non-generic type",
@@ -83,10 +83,10 @@ func (s *fieldsIteratorSuite) TestChasmFieldTypePrefix() {
 	s.True(strings.HasPrefix(fT.String(), chasmFieldTypePrefix))
 }
 
-func (s *fieldsIteratorSuite) TestChasmCollectionTypePrefix() {
-	c := Collection[string, any]{}
+func (s *fieldsIteratorSuite) TestChasmMapTypePrefix() {
+	c := Map[string, any]{}
 	cT := reflect.TypeOf(c)
-	s.True(strings.HasPrefix(cT.String(), chasmCollectionTypePrefix))
+	s.True(strings.HasPrefix(cT.String(), chasmMapTypePrefix))
 }
 
 func (s *fieldsIteratorSuite) TestFieldsOf() {
@@ -96,8 +96,8 @@ func (s *fieldsIteratorSuite) TestFieldsOf() {
 	}
 
 	type noDataField struct {
-		SubField      Field[string]
-		SubCollection Collection[string, int]
+		SubField Field[string]
+		SubMap   Map[string, int]
 	}
 
 	type twoDataFields struct {
@@ -121,21 +121,21 @@ func (s *fieldsIteratorSuite) TestFieldsOf() {
 			name: "Valid component with one data field",
 			input: &struct {
 				UnimplementedComponent
-				DataField     *protoMessageType
-				SubField      Field[string]
-				SubCollection Collection[string, int]
+				DataField *protoMessageType
+				SubField  Field[string]
+				SubMap    Map[string, int]
 			}{},
-			expectedKinds:  []fieldKind{fieldKindData, fieldKindSubField, fieldKindSubCollection},
-			expectedNames:  []string{"DataField", "SubField", "SubCollection"},
-			expectedTypes:  []string{"*persistence.WorkflowExecutionState", "chasm.Field[string]", "chasm.Collection[string,int]"},
+			expectedKinds:  []fieldKind{fieldKindData, fieldKindSubField, fieldKindSubMap},
+			expectedNames:  []string{"DataField", "SubField", "SubMap"},
+			expectedTypes:  []string{"*persistence.WorkflowExecutionState", "chasm.Field[string]", "chasm.Map[string,int]"},
 			expectedErrors: []string{"", "", ""},
 		},
 		{
 			name:           "Component with no data field",
 			input:          &noDataField{},
-			expectedKinds:  []fieldKind{fieldKindSubField, fieldKindSubCollection, fieldKindUnspecified},
-			expectedNames:  []string{"SubField", "SubCollection", ""},
-			expectedTypes:  []string{"chasm.Field[string]", "chasm.Collection[string,int]", ""},
+			expectedKinds:  []fieldKind{fieldKindSubField, fieldKindSubMap, fieldKindUnspecified},
+			expectedNames:  []string{"SubField", "SubMap", ""},
+			expectedTypes:  []string{"chasm.Field[string]", "chasm.Map[string,int]", ""},
 			expectedErrors: []string{"", "", "*chasm.noDataField: no data field (implements proto.Message) found"},
 		},
 		{

chasm/fields_iterator_test.go

@@ -0,0 +1,6 @@
+package chasm
+
+// mapKeyTypes must match actual Map key type definition.
+const mapKeyTypes = "string | int | int8 | int32 | int64 | uint | uint8 | uint32 | uint64 | bool"
+
+type Map[K string | int | int8 | int32 | int64 | uint | uint8 | uint32 | uint64 | bool, T any] map[K]Field[T]

chasm/map.go

@@ -0,0 +1,53 @@
+package chasm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// Another approach would be to code generate string const.
+func TestMapKeyTypesMatchConst(t *testing.T) {
+	_, currentFile, _, ok := runtime.Caller(0)
+	require.True(t, ok, "failed to get current file path")
+	srcFile := filepath.Join(filepath.Dir(currentFile), "map.go")
+
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, srcFile, nil, parser.AllErrors)
+	require.NoError(t, err)
+
+	var found string
+	// Walk the top‐level declarations looking for:
+	//   type Map[K ... , T any] map[K]T
+	for _, decl := range file.Decls {
+		gd, ok := decl.(*ast.GenDecl)
+		if !ok || gd.Tok != token.TYPE {
+			continue
+		}
+		for _, spec := range gd.Specs {
+			ts, ok := spec.(*ast.TypeSpec)
+			if !ok || ts.Name.Name != "Map" {
+				continue
+			}
+			// ts.TypeParams.List[0] is the field for K
+			if ts.TypeParams != nil && len(ts.TypeParams.List) > 0 {
+				field := ts.TypeParams.List[0]
+				var buf strings.Builder
+				// pretty‐print the AST node for the constraint
+				err = printer.Fprint(&buf, fset, field.Type)
+				require.NoError(t, err)
+				found = buf.String()
+			}
+		}
+	}
+
+	require.NotEmpty(t, found, "could not locate Map[K …] in AST")
+	require.Equal(t, mapKeyTypes, found)
+}

chasm/map_test.go

@@ -24,8 +24,8 @@ type (
 		SubComponent1     Field[*TestSubComponent1]
 		SubComponent2     Field[*TestSubComponent2]
 		SubData1          Field[*protoMessageType]
-		SubComponents     Collection[string, *TestSubComponent1]
-		PendingActivities Collection[int, *TestSubComponent1]
+		SubComponents     Map[string, *TestSubComponent1]
+		PendingActivities Map[int, *TestSubComponent1]
 	}
 
 	TestSubComponent1 struct {

chasm/test_component_test.go

@@ -65,7 +65,7 @@ type (
 
 		// Type of attributes controls the type of the node.
 		serializedNode *persistencespb.ChasmNode // serialized component | data | collection with metadata
-		value          any                       // deserialized component | data | collection
+		value          any                       // deserialized component | data | map
 
 		// valueState indicates if the value field and the persistence field serializedNode are in sync.
 		// If new value might be changed since it was deserialized and serialize method wasn't called yet, then valueState is valueStateNeedSerialize.
@@ -556,9 +556,9 @@ func (n *Node) syncSubComponentsInternal(
 			if keepChild {
 				childrenToKeep[field.name] = struct{}{}
 			}
-		case fieldKindSubCollection:
+		case fieldKindSubMap:
 			if field.val.IsNil() {
-				// If Collection field is nil then delete all collection items nodes and collection node itself.
+				// If Map field is nil then delete all collection items nodes and collection node itself.
 				continue
 			}
 
@@ -570,38 +570,42 @@ func (n *Node) syncSubComponentsInternal(
 				n.children[field.name] = collectionNode
 			}
 
-			// Validate collection type
+			// Validate map type.
 			if field.val.Kind() != reflect.Map {
-				return serviceerror.NewInternalf("CHASM collection must be of map[comparable]Field[T] type: value of %s is not of a map type", n.nodeName)
+				errMsg := fmt.Sprintf("CHASM map must be of map type: value of %s is not of a map type", n.nodeName)
+				softassert.Fail(n.logger, errMsg)
+				return serviceerror.NewInternal(errMsg)
 			}
 
 			if len(field.val.MapKeys()) == 0 {
-				// If Collection field is empty then delete all collection items nodes and collection node itself.
+				// If Map field is empty then delete all collection items nodes and collection node itself.
 				continue
 			}
 
-			collectionValT := field.typ.Elem()
-			if collectionValT.Kind() != reflect.Struct || genericTypePrefix(collectionValT) != chasmFieldTypePrefix {
-				return serviceerror.NewInternalf("CHASM collection must be of map[comparable]Field[T] type: %s map value type is not Field[T] but %s", n.nodeName, collectionValT)
+			mapValT := field.typ.Elem()
+			if mapValT.Kind() != reflect.Struct || genericTypePrefix(mapValT) != chasmFieldTypePrefix {
+				errMsg := fmt.Sprintf("CHASM map value must be of Field[T] type: %s collection value type is not Field[T] but %s", n.nodeName, mapValT)
+				softassert.Fail(n.logger, errMsg)
+				return serviceerror.NewInternal(errMsg)
 			}
 
 			collectionItemsToKeep := make(map[string]struct{})
-			for _, collectionKeyV := range field.val.MapKeys() {
-				collectionItemV := field.val.MapIndex(collectionKeyV)
-				collectionKeyStr, err := comparableKeyToString(n.nodeName, collectionKeyV)
+			for _, mapKeyV := range field.val.MapKeys() {
+				mapItemV := field.val.MapIndex(mapKeyV)
+				collectionKey, err := n.mapKeyToString(mapKeyV)
 				if err != nil {
 					return err
 				}
-				keepItem, updatedCollectionItemV, err := collectionNode.syncSubField(collectionItemV, collectionKeyStr, append(nodePath, field.name))
+				keepItem, updatedMapItemV, err := collectionNode.syncSubField(mapItemV, collectionKey, append(nodePath, field.name))
 				if err != nil {
 					return err
 				}
-				if updatedCollectionItemV.IsValid() {
+				if updatedMapItemV.IsValid() {
 					// The only way to update item in the map is to set it back.
-					field.val.SetMapIndex(collectionKeyV, updatedCollectionItemV)
+					field.val.SetMapIndex(mapKeyV, updatedMapItemV)
 				}
 				if keepItem {
-					collectionItemsToKeep[collectionKeyStr] = struct{}{}
+					collectionItemsToKeep[collectionKey] = struct{}{}
 				}
 			}
 			if err := collectionNode.deleteChildren(collectionItemsToKeep, append(nodePath, field.name)); err != nil {
@@ -615,7 +619,7 @@ func (n *Node) syncSubComponentsInternal(
 	return err
 }
 
-func comparableKeyToString(nodeName string, keyV reflect.Value) (string, error) {
+func (n *Node) mapKeyToString(keyV reflect.Value) (string, error) {
 	switch keyV.Kind() {
 	case reflect.String:
 		return keyV.String(), nil
@@ -626,11 +630,13 @@ func comparableKeyToString(nodeName string, keyV reflect.Value) (string, error)
 	case reflect.Bool:
 		return strconv.FormatBool(keyV.Bool()), nil
 	default:
-		return "", serviceerror.NewInternalf("CHASM collection must be of map[comparable|string]Field[T] type: %s map key type not comparable but %s", nodeName, keyV.Type().String())
+		errMsg := fmt.Sprintf("CHASM map key type for node %s must be one of [%s], got %s", n.nodeName, mapKeyTypes, keyV.Type().String())
+		softassert.Fail(n.logger, errMsg)
+		return "", serviceerror.NewInternal(errMsg)
 	}
 }
 
-func stringToComparableKey(nodeName string, key string, keyT reflect.Type) (reflect.Value, error) {
+func (n *Node) stringToMapKey(nodeName string, key string, keyT reflect.Type) (reflect.Value, error) {
 	var (
 		keyV reflect.Value
 		err  error
@@ -683,15 +689,18 @@ func stringToComparableKey(nodeName string, key string, keyT reflect.Type) (refl
 		b, err = strconv.ParseBool(key)
 		keyV = reflect.ValueOf(b)
 	default:
-		err = fmt.Errorf("unsupported type %s of kind %s", keyT.String(), keyT.Kind().String())
+		err = fmt.Errorf("unsupported type %s of kind %s: supported key types: %s", keyT.String(), keyT.Kind().String(), mapKeyTypes)
+		softassert.Fail(n.logger, err.Error())
+		// Use softassert only here because this is the only case that indicates "compile" time error.
+		// The other errors below can come from data type mismatch between a component and persisted data.
 	}
 
 	if err == nil && !keyV.IsValid() {
 		err = fmt.Errorf("value %s is not valid of type %s of kind %s", key, keyT.String(), keyT.Kind().String())
 	}
 
 	if err != nil {
-		err = serviceerror.NewInternalf("serialized collection %s key value %s can't be parsed to CHASM collection key type %s: %s", nodeName, key, keyT.String(), err.Error())
+		err = serviceerror.NewInternalf("serialized map %s key value %s can't be parsed to CHASM map key type %s: %s", nodeName, key, keyT.String(), err.Error())
 	}
 
 	return keyV, err
@@ -852,24 +861,24 @@ func (n *Node) deserializeComponentNode(
 				chasmFieldV.FieldByName(internalFieldName).Set(internalValue)
 				field.val.Set(chasmFieldV)
 			}
-		case fieldKindSubCollection:
+		case fieldKindSubMap:
 			if collectionNode, found := n.children[field.name]; found {
-				collectionFieldV := field.val
-				if collectionFieldV.IsNil() {
-					collectionFieldV = reflect.MakeMapWithSize(field.typ, field.val.Len())
-					field.val.Set(collectionFieldV)
+				mapFieldV := field.val
+				if mapFieldV.IsNil() {
+					mapFieldV = reflect.MakeMapWithSize(field.typ, field.val.Len())
+					field.val.Set(mapFieldV)
 				}
 
 				for collectionItemName, collectionItemNode := range collectionNode.children {
 					// field.typ.Elem() is a go type of map item: Field[T]
 					chasmFieldV := reflect.New(field.typ.Elem()).Elem()
 					internalValue := reflect.ValueOf(newFieldInternalWithNode(collectionItemNode))
 					chasmFieldV.FieldByName(internalFieldName).Set(internalValue)
-					collectionKeyV, err := stringToComparableKey(field.name, collectionItemName, collectionFieldV.Type().Key())
+					mapKeyV, err := n.stringToMapKey(field.name, collectionItemName, mapFieldV.Type().Key())
 					if err != nil {
 						return err
 					}
-					collectionFieldV.SetMapIndex(collectionKeyV, chasmFieldV)
+					mapFieldV.SetMapIndex(mapKeyV, chasmFieldV)
 				}
 			}
 		}