fix: resolve three DataHub 1.4.x write method bugs (#106)

* fix: resolve three DataHub 1.4.x write method bugs

- Add GraphQL selection set to upsertStructuredProperties and
  removeStructuredProperties mutations (fixes SubselectionRequired error)
- Change raiseIncident to use singular resourceUrn field instead of
  resourceUrns array (fixes "at least 1 resource urn" error)
- Expand entity-type support in write methods to include domain,
  glossaryTerm, and glossaryNode for tags, glossary terms, and
  descriptions (fixes "unsupported entity type" errors)

* fix: use "definition" field for glossaryTermInfo description aspect

GlossaryTermInfo PDL schema uses "definition" not "description" for
the term text, matching the existing glossaryNodeInfo mapping.

Author: cjimti

pkg/client/incidents.go

@@ -105,15 +105,14 @@ func (c *Client) GetIncidents(ctx context.Context, urn string) (*types.IncidentR
 
 // RaiseIncident creates a new incident on entities.
 func (c *Client) RaiseIncident(ctx context.Context, input types.RaiseIncidentInput) (string, error) {
-	resourceURNs := make([]map[string]string, 0, len(input.ResourceURNs))
-	for _, urn := range input.ResourceURNs {
-		resourceURNs = append(resourceURNs, map[string]string{"urn": urn})
+	if len(input.ResourceURNs) == 0 {
+		return "", fmt.Errorf("RaiseIncident: at least one resource URN is required")
 	}
 
 	gqlInput := map[string]any{
-		"type":         input.Type,
-		"title":        input.Title,
-		"resourceUrns": resourceURNs,
+		"type":        input.Type,
+		"title":       input.Title,
+		"resourceUrn": input.ResourceURNs[0],
 	}
 	if input.CustomType != "" {
 		gqlInput["customType"] = input.CustomType

pkg/client/incidents_test.go

@@ -286,10 +286,35 @@ func TestRaiseIncident(t *testing.T) {
 			if !tt.wantErr && urn != tt.wantURN {
 				t.Errorf("URN = %q, want %q", urn, tt.wantURN)
 			}
+
+			// Verify resourceUrn is sent as a singular string field
+			if !tt.wantErr && receivedBody != nil {
+				vars, _ := receivedBody["variables"].(map[string]any)
+				input, _ := vars["input"].(map[string]any)
+				resourceUrn, ok := input["resourceUrn"].(string)
+				if !ok {
+					t.Fatal("expected resourceUrn to be a string")
+				}
+				if resourceUrn != tt.input.ResourceURNs[0] {
+					t.Errorf("resourceUrn = %q, want %q", resourceUrn, tt.input.ResourceURNs[0])
+				}
+			}
 		})
 	}
 }
 
+func TestRaiseIncident_EmptyResourceURNs(t *testing.T) {
+	c := &Client{logger: NopLogger{}}
+	_, err := c.RaiseIncident(context.Background(), types.RaiseIncidentInput{
+		Type:         "OPERATIONAL",
+		Title:        "Test",
+		ResourceURNs: []string{},
+	})
+	if err == nil {
+		t.Fatal("expected error for empty resource URNs")
+	}
+}
+
 func TestResolveIncident(t *testing.T) {
 	tests := []struct {
 		name     string

pkg/client/structured_properties.go

@@ -126,16 +126,30 @@ query listStructuredPropertyDefinitions($input: SearchInput!) {
 `
 
 	// UpsertStructuredPropertiesMutation sets or updates structured property values on an entity.
+	// The mutation returns StructuredProperties! which requires a selection set.
 	UpsertStructuredPropertiesMutation = `
 mutation upsertStructuredProperties($input: UpsertStructuredPropertiesInput!) {
-  upsertStructuredProperties(input: $input)
+  upsertStructuredProperties(input: $input) {
+    properties {
+      structuredProperty {
+        urn
+      }
+    }
+  }
 }
 `
 
 	// RemoveStructuredPropertiesMutation removes structured property values from an entity.
+	// The mutation returns StructuredProperties! which requires a selection set.
 	RemoveStructuredPropertiesMutation = `
 mutation removeStructuredProperties($input: RemoveStructuredPropertiesInput!) {
-  removeStructuredProperties(input: $input)
+  removeStructuredProperties(input: $input) {
+    properties {
+      structuredProperty {
+        urn
+      }
+    }
+  }
 }
 `
 )
@@ -232,7 +246,13 @@ func (c *Client) UpsertStructuredProperties(ctx context.Context, urn string, pro
 	}
 
 	var response struct {
-		UpsertStructuredProperties bool `json:"upsertStructuredProperties"`
+		UpsertStructuredProperties struct {
+			Properties []struct {
+				StructuredProperty struct {
+					URN string `json:"urn"`
+				} `json:"structuredProperty"`
+			} `json:"properties"`
+		} `json:"upsertStructuredProperties"`
 	}
 
 	if err := c.Execute(ctx, UpsertStructuredPropertiesMutation, variables, &response); err != nil {
@@ -252,7 +272,13 @@ func (c *Client) RemoveStructuredProperties(ctx context.Context, urn string, pro
 	}
 
 	var response struct {
-		RemoveStructuredProperties bool `json:"removeStructuredProperties"`
+		RemoveStructuredProperties struct {
+			Properties []struct {
+				StructuredProperty struct {
+					URN string `json:"urn"`
+				} `json:"structuredProperty"`
+			} `json:"properties"`
+		} `json:"removeStructuredProperties"`
 	}
 
 	if err := c.Execute(ctx, RemoveStructuredPropertiesMutation, variables, &response); err != nil {

pkg/client/structured_properties_test.go

@@ -500,7 +500,7 @@ func TestUpsertStructuredProperties(t *testing.T) {
 					Values:      []any{float64(30)},
 				},
 			},
-			response: `{"data": {"upsertStructuredProperties": true}}`,
+			response: `{"data":{"upsertStructuredProperties":{"properties":[{"structuredProperty":{"urn":"urn:li:structuredProperty:t"}}]}}}`,
 		},
 		{
 			name: "multiple properties",
@@ -515,7 +515,7 @@ func TestUpsertStructuredProperties(t *testing.T) {
 					Values:      []any{"PII", "SENSITIVE"},
 				},
 			},
-			response: `{"data": {"upsertStructuredProperties": true}}`,
+			response: `{"data":{"upsertStructuredProperties":{"properties":[{"structuredProperty":{"urn":"urn:li:structuredProperty:t"}}]}}}`,
 		},
 		{
 			name: "graphql error",
@@ -580,7 +580,7 @@ func TestRemoveStructuredProperties(t *testing.T) {
 			name:         "single property",
 			urn:          "urn:li:dataset:test",
 			propertyURNs: []string{"urn:li:structuredProperty:retentionTime"},
-			response:     `{"data": {"removeStructuredProperties": true}}`,
+			response:     `{"data": {"removeStructuredProperties": {"properties": []}}}`,
 		},
 		{
 			name: "multiple properties",
@@ -589,7 +589,7 @@ func TestRemoveStructuredProperties(t *testing.T) {
 				"urn:li:structuredProperty:retentionTime",
 				"urn:li:structuredProperty:classification",
 			},
-			response: `{"data": {"removeStructuredProperties": true}}`,
+			response: `{"data": {"removeStructuredProperties": {"properties": []}}}`,
 		},
 		{
 			name:         "graphql error",

pkg/client/write.go

@@ -48,8 +48,7 @@ type DescriptionAspectInfo struct {
 // descriptionAspectMap maps DataHub entity types to their description aspect.
 // glossaryNode uses "definition" instead of "description".
 // dataProduct uses its non-editable property aspect (dataProductProperties).
-// domain and glossaryTerm are intentionally excluded: their aspects
-// (domainProperties, glossaryTermInfo) are not writable via the REST ingest proposal API.
+// domain uses domainProperties and glossaryTerm uses glossaryTermInfo.
 var descriptionAspectMap = map[string]DescriptionAspectInfo{
 	entityTypeDataset:      {AspectName: "editableDatasetProperties", FieldName: "description"},
 	entityTypeDashboard:    {AspectName: "editableDashboardProperties", FieldName: "description"},
@@ -59,6 +58,8 @@ var descriptionAspectMap = map[string]DescriptionAspectInfo{
 	entityTypeContainer:    {AspectName: "editableContainerProperties", FieldName: "description"},
 	entityTypeDataProduct:  {AspectName: "dataProductProperties", FieldName: "description"},
 	entityTypeGlossaryNode: {AspectName: "glossaryNodeInfo", FieldName: "definition"},
+	entityTypeDomain:       {AspectName: "domainProperties", FieldName: "description"},
+	entityTypeGlossaryTerm: {AspectName: "glossaryTermInfo", FieldName: "definition"},
 }
 
 // globalTagsSupportedTypes lists entity types that support the globalTags aspect.
@@ -67,6 +68,7 @@ var descriptionAspectMap = map[string]DescriptionAspectInfo{
 var globalTagsSupportedTypes = map[string]bool{
 	entityTypeDataset: true, entityTypeDashboard: true, entityTypeChart: true,
 	entityTypeDataFlow: true, entityTypeDataJob: true, entityTypeContainer: true, entityTypeDataProduct: true,
+	entityTypeDomain: true, entityTypeGlossaryTerm: true, entityTypeGlossaryNode: true,
 }
 
 // glossaryTermsSupportedTypes lists entity types that support glossaryTerms associations.
@@ -75,6 +77,7 @@ var globalTagsSupportedTypes = map[string]bool{
 var glossaryTermsSupportedTypes = map[string]bool{
 	entityTypeDataset: true, entityTypeDashboard: true, entityTypeChart: true,
 	entityTypeDataFlow: true, entityTypeDataJob: true, entityTypeContainer: true, entityTypeDataProduct: true,
+	entityTypeDomain: true, entityTypeGlossaryTerm: true, entityTypeGlossaryNode: true,
 }
 
 // institutionalMemorySupportedTypes lists entity types that support institutional memory (links).

pkg/client/write_test.go

@@ -304,6 +304,43 @@ func TestAddTag_NoExistingTags(t *testing.T) {
 	}
 }
 
+func TestAddTag_DomainEntity(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodGet {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		proposal, aspectJSON := extractProposalWireFormat(t, r.Body)
+		if proposal["entityType"] != "domain" {
+			t.Errorf("entityType = %v, want domain", proposal["entityType"])
+		}
+		if proposal["aspectName"] != "globalTags" {
+			t.Errorf("aspectName = %v, want globalTags", proposal["aspectName"])
+		}
+		var tags globalTagsAspect
+		if err := json.Unmarshal([]byte(aspectJSON), &tags); err != nil {
+			t.Fatalf("failed to unmarshal inner aspect: %v", err)
+		}
+		if len(tags.Tags) != 1 {
+			t.Errorf("expected 1 tag, got %d", len(tags.Tags))
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	c := &Client{
+		endpoint:   server.URL + "/api/graphql",
+		token:      "test-token",
+		httpClient: server.Client(),
+		logger:     NopLogger{},
+	}
+
+	err := c.AddTag(context.Background(), "urn:li:domain:engineering", "urn:li:tag:PII")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
 func TestRemoveTag(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Method == http.MethodGet {
@@ -1234,9 +1271,9 @@ func TestLookupDescriptionAspect(t *testing.T) {
 		{"container", "editableContainerProperties", "description", false},
 		{"dataProduct", "dataProductProperties", "description", false},
 		{"glossaryNode", "glossaryNodeInfo", "definition", false},
+		{"domain", "domainProperties", "description", false},
+		{"glossaryTerm", "glossaryTermInfo", "definition", false},
 		// Unsupported types return errors
-		{"domain", "", "", true},
-		{"glossaryTerm", "", "", true},
 		{"tag", "", "", true},
 		{"corpuser", "", "", true},
 	}
@@ -1287,6 +1324,20 @@ func TestUpdateDescription_EntityTypes(t *testing.T) {
 			wantAspect: "editableContainerProperties",
 			wantField:  "description",
 		},
+		{
+			name:       "domain",
+			urn:        "urn:li:domain:engineering",
+			wantEntity: "domain",
+			wantAspect: "domainProperties",
+			wantField:  "description",
+		},
+		{
+			name:       "glossaryTerm",
+			urn:        "urn:li:glossaryTerm:Classification",
+			wantEntity: "glossaryTerm",
+			wantAspect: "glossaryTermInfo",
+			wantField:  "definition",
+		},
 	}
 
 	for _, tt := range tests {
@@ -1356,36 +1407,14 @@ func TestUpdateDescription_UnsupportedEntityType(t *testing.T) {
 	}
 }
 
-func TestUpdateDescription_DomainReturnsError(t *testing.T) {
-	c := &Client{logger: NopLogger{}}
-	err := c.UpdateDescription(context.Background(), "urn:li:domain:engineering", "desc")
-	if err == nil {
-		t.Fatal("expected error for domain entity")
-	}
-	if !errors.Is(err, ErrUnsupportedEntityType) {
-		t.Errorf("expected ErrUnsupportedEntityType, got: %v", err)
-	}
-}
-
-func TestUpdateDescription_GlossaryTermReturnsError(t *testing.T) {
-	c := &Client{logger: NopLogger{}}
-	err := c.UpdateDescription(context.Background(), "urn:li:glossaryTerm:Classification", "desc")
-	if err == nil {
-		t.Fatal("expected error for glossaryTerm entity")
-	}
-	if !errors.Is(err, ErrUnsupportedEntityType) {
-		t.Errorf("expected ErrUnsupportedEntityType, got: %v", err)
-	}
-}
-
 func TestAddTag_UnsupportedEntityType(t *testing.T) {
 	c := &Client{logger: NopLogger{}}
 	tests := []struct {
 		name string
 		urn  string
 	}{
-		{"domain", "urn:li:domain:engineering"},
-		{"glossaryTerm", "urn:li:glossaryTerm:Classification"},
+		{"tag", "urn:li:tag:PII"},
+		{"corpuser", "urn:li:corpuser:johndoe"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1406,8 +1435,8 @@ func TestRemoveTag_UnsupportedEntityType(t *testing.T) {
 		name string
 		urn  string
 	}{
-		{"domain", "urn:li:domain:engineering"},
-		{"glossaryTerm", "urn:li:glossaryTerm:Classification"},
+		{"tag", "urn:li:tag:PII"},
+		{"corpuser", "urn:li:corpuser:johndoe"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1428,8 +1457,8 @@ func TestAddGlossaryTerm_UnsupportedEntityType(t *testing.T) {
 		name string
 		urn  string
 	}{
-		{"domain", "urn:li:domain:engineering"},
-		{"glossaryTerm", "urn:li:glossaryTerm:Classification"},
+		{"tag", "urn:li:tag:PII"},
+		{"corpuser", "urn:li:corpuser:johndoe"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1450,8 +1479,8 @@ func TestRemoveGlossaryTerm_UnsupportedEntityType(t *testing.T) {
 		name string
 		urn  string
 	}{
-		{"domain", "urn:li:domain:engineering"},
-		{"glossaryTerm", "urn:li:glossaryTerm:Classification"},
+		{"tag", "urn:li:tag:PII"},
+		{"corpuser", "urn:li:corpuser:johndoe"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

pkg/types/incidents.go

@@ -60,5 +60,6 @@ type RaiseIncidentInput struct {
 	Description string `json:"description,omitempty"`
 
 	// ResourceURNs are the entity URNs affected by this incident.
+	// Only the first element is sent to the DataHub API (resourceUrn field).
 	ResourceURNs []string `json:"resource_urns"`
 }