fixup: drop dead Array-kind branch, add import-from-mapping fallback tests

Address review feedback on the import-mapping single-vs-list fallback.

M1 — drop the `Kind == "Array"` branch from both fallback sites.
parseImportMappingElement only ever produces `Kind: "Object"` or
`Kind: "Value"` (any other `$Type` falls through to `default: return
nil` and the nil element is never appended). The Array branch was
unreachable from real MPR data, and the matching test asserted a state
the parser cannot produce. Repetition for the list-vs-singleton call
now comes purely from MaxOccurs ( -1 or > 1 ).

m3 — add the missing `im.Elements[0] != nil` guard before the
pre-existing entity lookup, matching the guard added two lines above.

M2 — two new tests for `addImportFromMappingAction` cover the
message-definition / XML-schema fallback path:
  - `TestAddImportFromMappingFallsBackToImportMappingRootForListResult`
    pins the Object root with MaxOccurs=-1 → list-typed result
  - `TestAddImportFromMappingFallsBackToImportMappingRootForSingleObject`
    pins the Object root with MaxOccurs=1 → singleton

The dead `TestAddRestCallAction_MappingFallsBackToArrayKindWhenJsonStructureMissing`
test is removed alongside the Array branch it exercised.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hjothamendix

mdl/executor/cmd_microflows_builder_calls.go

@@ -1047,13 +1047,17 @@ func (fb *flowBuilder) addRestCallAction(s *ast.RestCallStmt) model.ID {
 				}
 				if !resolved && len(im.Elements) > 0 && im.Elements[0] != nil {
 					// XML schema / message-definition mappings carry the
-					// single-vs-list shape on the root mapping element itself.
-					// MaxOccurs > 1 or unbounded (-1) signals a list even
-					// when the kind is Object — Studio Pro models a
-					// repeating Object element as a list, distinct from a
-					// singleton.
+					// single-vs-list shape on the root mapping element
+					// itself. MaxOccurs > 1 or unbounded (-1) signals a
+					// list — Studio Pro models a repeating Object element
+					// as a list, distinct from a singleton. Mendix's
+					// import-mapping element BSON only ever uses
+					// `ImportMappings$ObjectMappingElement` or
+					// `ImportMappings$ValueMappingElement`; there is no
+					// `Array` element kind from real MPR data, so
+					// repetition has to come from MaxOccurs.
 					root := im.Elements[0]
-					if root.Kind == "Array" || root.MaxOccurs == -1 || root.MaxOccurs > 1 {
+					if root.MaxOccurs == -1 || root.MaxOccurs > 1 {
 						singleObject = false
 					} else {
 						singleObject = root.Kind == "Object"
@@ -1362,11 +1366,11 @@ func (fb *flowBuilder) addImportFromMappingAction(s *ast.ImportFromMappingStmt)
 				// MaxOccurs > 1 or unbounded (-1) signals a list even when
 				// the kind is Object.
 				root := im.Elements[0]
-				if root.Kind == "Array" || root.MaxOccurs == -1 || root.MaxOccurs > 1 {
+				if root.MaxOccurs == -1 || root.MaxOccurs > 1 {
 					resultHandling.SingleObject = false
 				}
 			}
-			if len(im.Elements) > 0 && im.Elements[0].Entity != "" {
+			if len(im.Elements) > 0 && im.Elements[0] != nil && im.Elements[0].Entity != "" {
 				resultEntityQN = im.Elements[0].Entity
 				resultHandling.ResultEntityID = model.ID(resultEntityQN)
 			}

mdl/executor/cmd_microflows_builder_import_mapping_test.go

@@ -40,6 +40,65 @@ func TestAddImportFromMappingRegistersListResultType(t *testing.T) {
 	}
 }
 
+// XML-schema and message-definition mappings have no JsonStructure;
+// addImportFromMappingAction must then read the single-vs-list shape
+// from the import mapping's own root element. MaxOccurs > 1 or
+// unbounded (-1) signals a list — Studio Pro models a repeating Object
+// root that way for these mappings.
+func TestAddImportFromMappingFallsBackToImportMappingRootForListResult(t *testing.T) {
+	fb := &flowBuilder{
+		varTypes: map[string]string{},
+		backend: &mock.MockBackend{
+			GetImportMappingByQualifiedNameFunc: func(moduleName, name string) (*model.ImportMapping, error) {
+				return &model.ImportMapping{
+					JsonStructure: "",
+					Elements: []*model.ImportMappingElement{
+						{Kind: "Object", Entity: "Sales.Order", MaxOccurs: -1},
+					},
+				}, nil
+			},
+		},
+	}
+
+	fb.addImportFromMappingAction(&ast.ImportFromMappingStmt{
+		OutputVariable: "ImportedOrders",
+		SourceVariable: "Payload",
+		Mapping:        ast.QualifiedName{Module: "Integration", Name: "ImportOrders"},
+	})
+
+	if got := fb.varTypes["ImportedOrders"]; got != "List of Sales.Order" {
+		t.Fatalf("ImportedOrders type = %q, want list of Sales.Order (Object root with MaxOccurs=-1 must yield list)", got)
+	}
+}
+
+// A non-repeating Object root (MaxOccurs ≤ 1) keeps the singleton type
+// when the JSON structure is absent.
+func TestAddImportFromMappingFallsBackToImportMappingRootForSingleObject(t *testing.T) {
+	fb := &flowBuilder{
+		varTypes: map[string]string{},
+		backend: &mock.MockBackend{
+			GetImportMappingByQualifiedNameFunc: func(moduleName, name string) (*model.ImportMapping, error) {
+				return &model.ImportMapping{
+					JsonStructure: "",
+					Elements: []*model.ImportMappingElement{
+						{Kind: "Object", Entity: "Sales.Order", MaxOccurs: 1, MinOccurs: 1},
+					},
+				}, nil
+			},
+		},
+	}
+
+	fb.addImportFromMappingAction(&ast.ImportFromMappingStmt{
+		OutputVariable: "ImportedOrder",
+		SourceVariable: "Payload",
+		Mapping:        ast.QualifiedName{Module: "Integration", Name: "ImportOrder"},
+	})
+
+	if got := fb.varTypes["ImportedOrder"]; got != "Sales.Order" {
+		t.Fatalf("ImportedOrder type = %q, want Sales.Order (Object root with MaxOccurs=1 must stay singleton)", got)
+	}
+}
+
 func importMappingFlowBuilder(t *testing.T, rootElementType string) *flowBuilder {
 	t.Helper()
 

mdl/executor/cmd_microflows_builder_rest_response_test.go

@@ -112,47 +112,6 @@ func TestAddRestCallAction_MappingFallsBackToImportMappingRootKindWhenJsonStruct
 
 // And the inverse: an Array root on the mapping element must yield a
 // list-typed result handling.
-func TestAddRestCallAction_MappingFallsBackToArrayKindWhenJsonStructureMissing(t *testing.T) {
-	fb := &flowBuilder{
-		posX:         100,
-		posY:         100,
-		spacing:      HorizontalSpacing,
-		varTypes:     map[string]string{},
-		declaredVars: map[string]string{},
-		measurer:     &layoutMeasurer{},
-		backend: &mock.MockBackend{
-			GetImportMappingByQualifiedNameFunc: func(moduleName, name string) (*model.ImportMapping, error) {
-				return &model.ImportMapping{
-					Name:          "ArrMapping",
-					JsonStructure: "",
-					Elements: []*model.ImportMappingElement{
-						{Kind: "Array", Entity: "Synthetic.Item"},
-					},
-				}, nil
-			},
-		},
-	}
-
-	stmt := &ast.RestCallStmt{
-		OutputVariable: "Items",
-		Method:         ast.HttpMethodGet,
-		URL:            &ast.LiteralExpr{Kind: ast.LiteralString, Value: "https://example.com"},
-		Result: ast.RestResult{
-			Type:         ast.RestResultMapping,
-			MappingName:  ast.QualifiedName{Module: "Synthetic", Name: "ArrMapping"},
-			ResultEntity: ast.QualifiedName{Module: "Synthetic", Name: "Item"},
-		},
-	}
-	fb.addRestCallAction(stmt)
-
-	activity := fb.objects[0].(*microflows.ActionActivity)
-	action := activity.Action.(*microflows.RestCallAction)
-	mapping := action.ResultHandling.(*microflows.ResultHandlingMapping)
-	if mapping.SingleObject {
-		t.Errorf("SingleObject = true, want false (root mapping element Kind=Array)")
-	}
-}
-
 // A repeating Object element (MaxOccurs > 1 or unbounded) is a list, even
 // though the BSON Kind is "Object". Studio Pro models a list of objects
 // this way for XML schema and message-definition mappings; treating it as