fix: resolve four DataHub 1.4.x write method bugs (#108)

* fix: resolve four DataHub 1.4.x write method bugs (#107)

- Rename propertyUrn to structuredPropertyUrn in UpsertStructuredProperties
  GraphQL mutation input (REST field name was used in GraphQL context)
- Change UpdateIncidentStatusInput to IncidentStatusInput in ResolveIncident
  mutation (1.4.x schema change)
- Route tag/glossaryTerm/description writes for domain, glossaryTerm, and
  glossaryNode entities through GraphQL mutations instead of REST, because
  the REST API does not register globalTags, glossaryTerms, or editable
  description aspects for these entity types

* refactor: eliminate redundant LookupDescriptionAspect call in UpdateDescription

Resolve aspectInfo once in the public method and pass it to
updateDescriptionREST, avoiding a duplicate map lookup.

* fix: remove unnecessary leading newline flagged by whitespace linter

Author: cjimti

pkg/client/incidents.go

@@ -68,7 +68,7 @@ mutation raiseIncident($input: RaiseIncidentInput!) {
 
 	// UpdateIncidentStatusMutation resolves or reactivates an incident.
 	UpdateIncidentStatusMutation = `
-mutation updateIncidentStatus($urn: String!, $input: UpdateIncidentStatusInput!) {
+mutation updateIncidentStatus($urn: String!, $input: IncidentStatusInput!) {
   updateIncidentStatus(urn: $urn, input: $input)
 }
 `

pkg/client/structured_properties.go

@@ -233,8 +233,8 @@ func (c *Client) UpsertStructuredProperties(ctx context.Context, urn string, pro
 	propInputs := make([]map[string]any, 0, len(properties))
 	for _, p := range properties {
 		propInputs = append(propInputs, map[string]any{
-			"propertyUrn": p.PropertyURN,
-			"values":      p.Values,
+			"structuredPropertyUrn": p.PropertyURN,
+			"values":                p.Values,
 		})
 	}
 

pkg/client/write.go

@@ -137,19 +137,33 @@ func (a *descriptionAspect) setDescription(fieldName, value string) error {
 	return nil
 }
 
-// UpdateDescription sets the editable description for any entity using read-modify-write.
-// Resolves the correct aspect name and field name based on the entity type in the URN.
+// UpdateDescription sets the editable description for any entity.
+// Uses GraphQL for domain, glossaryTerm, and glossaryNode entities because the REST
+// API does not support their description aspects. Uses REST read-modify-write for all
+// other entity types.
 func (c *Client) UpdateDescription(ctx context.Context, urn, description string) error {
 	entityType, err := entityTypeFromURN(urn)
 	if err != nil {
 		return fmt.Errorf("UpdateDescription: %w", err)
 	}
 
+	// Validate the entity type is supported before choosing a path.
 	aspectInfo, err := LookupDescriptionAspect(entityType)
 	if err != nil {
 		return fmt.Errorf("UpdateDescription: %w", err)
 	}
 
+	// Domain, glossaryTerm, and glossaryNode do not support REST aspect writes
+	// for descriptions. Use the GraphQL updateDescription mutation instead.
+	if graphQLWriteTypes[entityType] {
+		return c.updateDescriptionGraphQL(ctx, urn, description)
+	}
+
+	return c.updateDescriptionREST(ctx, urn, description, entityType, aspectInfo)
+}
+
+// updateDescriptionREST updates a description via REST read-modify-write.
+func (c *Client) updateDescriptionREST(ctx context.Context, urn, description, entityType string, aspectInfo DescriptionAspectInfo) error {
 	props, err := c.readEditableProperties(ctx, entityType, urn, aspectInfo.AspectName)
 	if err != nil {
 		return fmt.Errorf("UpdateDescription: %w", err)
@@ -226,7 +240,10 @@ type tagAssociation struct {
 	Tag string `json:"tag"`
 }
 
-// AddTag adds a tag to an entity using read-modify-write on the globalTags aspect.
+// AddTag adds a tag to an entity.
+// Uses GraphQL for domain, glossaryTerm, and glossaryNode entities because
+// the REST API does not register globalTags as an aspect for these types.
+// Uses REST read-modify-write for all other entity types.
 func (c *Client) AddTag(ctx context.Context, urn, tagURN string) error {
 	entityType, err := entityTypeFromURN(urn)
 	if err != nil {
@@ -237,6 +254,10 @@ func (c *Client) AddTag(ctx context.Context, urn, tagURN string) error {
 		return fmt.Errorf("AddTag: %w: %s", ErrUnsupportedTagEntity, entityType)
 	}
 
+	if graphQLWriteTypes[entityType] {
+		return c.addTagGraphQL(ctx, urn, tagURN)
+	}
+
 	// Read current tags
 	tags, err := c.readGlobalTags(ctx, entityType, urn)
 	if err != nil {
@@ -261,7 +282,10 @@ func (c *Client) AddTag(ctx context.Context, urn, tagURN string) error {
 	})
 }
 
-// RemoveTag removes a tag from an entity using read-modify-write on the globalTags aspect.
+// RemoveTag removes a tag from an entity.
+// Uses GraphQL for domain, glossaryTerm, and glossaryNode entities because
+// the REST API does not register globalTags as an aspect for these types.
+// Uses REST read-modify-write for all other entity types.
 func (c *Client) RemoveTag(ctx context.Context, urn, tagURN string) error {
 	entityType, err := entityTypeFromURN(urn)
 	if err != nil {
@@ -272,6 +296,10 @@ func (c *Client) RemoveTag(ctx context.Context, urn, tagURN string) error {
 		return fmt.Errorf("RemoveTag: %w: %s", ErrUnsupportedTagEntity, entityType)
 	}
 
+	if graphQLWriteTypes[entityType] {
+		return c.removeTagGraphQL(ctx, urn, tagURN)
+	}
+
 	// Read current tags
 	tags, err := c.readGlobalTags(ctx, entityType, urn)
 	if err != nil {
@@ -326,7 +354,10 @@ type termAssociation struct {
 	URN string `json:"urn"`
 }
 
-// AddGlossaryTerm adds a glossary term to an entity using read-modify-write.
+// AddGlossaryTerm adds a glossary term to an entity.
+// Uses GraphQL for domain, glossaryTerm, and glossaryNode entities because
+// the REST API does not register glossaryTerms as an aspect for these types.
+// Uses REST read-modify-write for all other entity types.
 func (c *Client) AddGlossaryTerm(ctx context.Context, urn, termURN string) error {
 	entityType, err := entityTypeFromURN(urn)
 	if err != nil {
@@ -337,6 +368,10 @@ func (c *Client) AddGlossaryTerm(ctx context.Context, urn, termURN string) error
 		return fmt.Errorf("AddGlossaryTerm: %w: %s", ErrUnsupportedGlossaryTermEntity, entityType)
 	}
 
+	if graphQLWriteTypes[entityType] {
+		return c.addTermGraphQL(ctx, urn, termURN)
+	}
+
 	terms, err := c.readGlossaryTerms(ctx, entityType, urn)
 	if err != nil {
 		return fmt.Errorf("AddGlossaryTerm: %w", err)
@@ -360,7 +395,10 @@ func (c *Client) AddGlossaryTerm(ctx context.Context, urn, termURN string) error
 	})
 }
 
-// RemoveGlossaryTerm removes a glossary term from an entity using read-modify-write.
+// RemoveGlossaryTerm removes a glossary term from an entity.
+// Uses GraphQL for domain, glossaryTerm, and glossaryNode entities because
+// the REST API does not register glossaryTerms as an aspect for these types.
+// Uses REST read-modify-write for all other entity types.
 func (c *Client) RemoveGlossaryTerm(ctx context.Context, urn, termURN string) error {
 	entityType, err := entityTypeFromURN(urn)
 	if err != nil {
@@ -371,6 +409,10 @@ func (c *Client) RemoveGlossaryTerm(ctx context.Context, urn, termURN string) er
 		return fmt.Errorf("RemoveGlossaryTerm: %w: %s", ErrUnsupportedGlossaryTermEntity, entityType)
 	}
 
+	if graphQLWriteTypes[entityType] {
+		return c.removeTermGraphQL(ctx, urn, termURN)
+	}
+
 	terms, err := c.readGlossaryTerms(ctx, entityType, urn)
 	if err != nil {
 		return fmt.Errorf("RemoveGlossaryTerm: %w", err)

pkg/client/write_graphql.go

@@ -0,0 +1,162 @@
+package client
+
+import (
+	"context"
+	"fmt"
+)
+
+// GraphQL mutations for entity types where REST aspect writes are not supported.
+// Domain, glossaryTerm, and glossaryNode do not register globalTags, glossaryTerms,
+// or editable description aspects in the REST API. DataHub's GraphQL mutations
+// handle the entity-type routing internally.
+
+const (
+	// AddTagMutation adds a tag to any entity via GraphQL.
+	// Signature: addTag(input: TagAssociationInput!): Boolean.
+	AddTagMutation = `
+mutation addTag($input: TagAssociationInput!) {
+  addTag(input: $input)
+}
+`
+
+	// RemoveTagMutation removes a tag from any entity via GraphQL.
+	// Signature: removeTag(input: TagAssociationInput!): Boolean.
+	RemoveTagMutation = `
+mutation removeTag($input: TagAssociationInput!) {
+  removeTag(input: $input)
+}
+`
+
+	// AddTermMutation adds a glossary term to any entity via GraphQL.
+	// Signature: addTerm(input: TermAssociationInput!): Boolean.
+	AddTermMutation = `
+mutation addTerm($input: TermAssociationInput!) {
+  addTerm(input: $input)
+}
+`
+
+	// RemoveTermMutation removes a glossary term from any entity via GraphQL.
+	// Signature: removeTerm(input: TermAssociationInput!): Boolean.
+	RemoveTermMutation = `
+mutation removeTerm($input: TermAssociationInput!) {
+  removeTerm(input: $input)
+}
+`
+
+	// UpdateDescriptionMutation updates the description of any entity via GraphQL.
+	// Signature: updateDescription(input: DescriptionUpdateInput!): Boolean.
+	UpdateDescriptionMutation = `
+mutation updateDescription($input: DescriptionUpdateInput!) {
+  updateDescription(input: $input)
+}
+`
+)
+
+// graphQLWriteTypes lists entity types that require GraphQL mutations for write
+// operations because the REST API does not support their aspects (globalTags,
+// glossaryTerms, editable description).
+var graphQLWriteTypes = map[string]bool{
+	entityTypeDomain:       true,
+	entityTypeGlossaryTerm: true,
+	entityTypeGlossaryNode: true,
+}
+
+// addTagGraphQL adds a tag to an entity using the GraphQL addTag mutation.
+func (c *Client) addTagGraphQL(ctx context.Context, urn, tagURN string) error {
+	variables := map[string]any{
+		"input": map[string]any{
+			"tagUrn":      tagURN,
+			"resourceUrn": urn,
+		},
+	}
+
+	var response struct {
+		AddTag bool `json:"addTag"`
+	}
+
+	if err := c.Execute(ctx, AddTagMutation, variables, &response); err != nil {
+		return fmt.Errorf("addTagGraphQL: %w", err)
+	}
+
+	return nil
+}
+
+// removeTagGraphQL removes a tag from an entity using the GraphQL removeTag mutation.
+func (c *Client) removeTagGraphQL(ctx context.Context, urn, tagURN string) error {
+	variables := map[string]any{
+		"input": map[string]any{
+			"tagUrn":      tagURN,
+			"resourceUrn": urn,
+		},
+	}
+
+	var response struct {
+		RemoveTag bool `json:"removeTag"`
+	}
+
+	if err := c.Execute(ctx, RemoveTagMutation, variables, &response); err != nil {
+		return fmt.Errorf("removeTagGraphQL: %w", err)
+	}
+
+	return nil
+}
+
+// addTermGraphQL adds a glossary term to an entity using the GraphQL addTerm mutation.
+func (c *Client) addTermGraphQL(ctx context.Context, urn, termURN string) error {
+	variables := map[string]any{
+		"input": map[string]any{
+			"termUrn":     termURN,
+			"resourceUrn": urn,
+		},
+	}
+
+	var response struct {
+		AddTerm bool `json:"addTerm"`
+	}
+
+	if err := c.Execute(ctx, AddTermMutation, variables, &response); err != nil {
+		return fmt.Errorf("addTermGraphQL: %w", err)
+	}
+
+	return nil
+}
+
+// removeTermGraphQL removes a glossary term from an entity using the GraphQL removeTerm mutation.
+func (c *Client) removeTermGraphQL(ctx context.Context, urn, termURN string) error {
+	variables := map[string]any{
+		"input": map[string]any{
+			"termUrn":     termURN,
+			"resourceUrn": urn,
+		},
+	}
+
+	var response struct {
+		RemoveTerm bool `json:"removeTerm"`
+	}
+
+	if err := c.Execute(ctx, RemoveTermMutation, variables, &response); err != nil {
+		return fmt.Errorf("removeTermGraphQL: %w", err)
+	}
+
+	return nil
+}
+
+// updateDescriptionGraphQL updates an entity's description using the GraphQL mutation.
+func (c *Client) updateDescriptionGraphQL(ctx context.Context, urn, description string) error {
+	variables := map[string]any{
+		"input": map[string]any{
+			"description": description,
+			"resourceUrn": urn,
+		},
+	}
+
+	var response struct {
+		UpdateDescription bool `json:"updateDescription"`
+	}
+
+	if err := c.Execute(ctx, UpdateDescriptionMutation, variables, &response); err != nil {
+		return fmt.Errorf("updateDescriptionGraphQL: %w", err)
+	}
+
+	return nil
+}