feat(ui/backend/openapi/docs) : Add support for Business Attributes

buildSrc/src/main/java/io/datahubproject/OpenApiEntities.java

@@ -60,6 +60,7 @@ public class OpenApiEntities {
                 .add("dataProductProperties")
                 .add("institutionalMemory")
                 .add("forms").add("formInfo").add("dynamicFormAssignment")
+                .add("businessAttributeInfo")
                 .build();
 
     private final static ImmutableSet<String> ENTITY_EXCLUSIONS = ImmutableSet.<String>builder()

datahub-graphql-core/src/main/java/com/linkedin/datahub/graphql/GmsGraphQLEngine.java

@@ -33,6 +33,8 @@
 import com.linkedin.datahub.graphql.generated.BrowsePathEntry;
 import com.linkedin.datahub.graphql.generated.BrowseResultGroupV2;
 import com.linkedin.datahub.graphql.generated.BrowseResults;
+import com.linkedin.datahub.graphql.generated.BusinessAttribute;
+import com.linkedin.datahub.graphql.generated.BusinessAttributeAssociation;
 import com.linkedin.datahub.graphql.generated.Chart;
 import com.linkedin.datahub.graphql.generated.ChartInfo;
 import com.linkedin.datahub.graphql.generated.Container;
@@ -68,6 +70,7 @@
 import com.linkedin.datahub.graphql.generated.InstitutionalMemoryMetadata;
 import com.linkedin.datahub.graphql.generated.LineageRelationship;
 import com.linkedin.datahub.graphql.generated.ListAccessTokenResult;
+import com.linkedin.datahub.graphql.generated.ListBusinessAttributesResult;
 import com.linkedin.datahub.graphql.generated.ListDomainsResult;
 import com.linkedin.datahub.graphql.generated.ListGroupsResult;
 import com.linkedin.datahub.graphql.generated.ListOwnershipTypesResult;
@@ -115,6 +118,12 @@
 import com.linkedin.datahub.graphql.resolvers.browse.BrowsePathsResolver;
 import com.linkedin.datahub.graphql.resolvers.browse.BrowseResolver;
 import com.linkedin.datahub.graphql.resolvers.browse.EntityBrowsePathsResolver;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.AddBusinessAttributeResolver;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.CreateBusinessAttributeResolver;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.DeleteBusinessAttributeResolver;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.ListBusinessAttributesResolver;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.RemoveBusinessAttributeResolver;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.UpdateBusinessAttributeResolver;
 import com.linkedin.datahub.graphql.resolvers.chart.BrowseV2Resolver;
 import com.linkedin.datahub.graphql.resolvers.chart.ChartStatsSummaryResolver;
 import com.linkedin.datahub.graphql.resolvers.config.AppConfigResolver;
@@ -289,6 +298,7 @@
 import com.linkedin.datahub.graphql.types.aspect.AspectType;
 import com.linkedin.datahub.graphql.types.assertion.AssertionType;
 import com.linkedin.datahub.graphql.types.auth.AccessTokenMetadataType;
+import com.linkedin.datahub.graphql.types.businessattribute.BusinessAttributeType;
 import com.linkedin.datahub.graphql.types.chart.ChartType;
 import com.linkedin.datahub.graphql.types.common.mappers.OperationMapper;
 import com.linkedin.datahub.graphql.types.common.mappers.UrnToEntityMapper;
@@ -345,6 +355,7 @@
 import com.linkedin.metadata.query.filter.SortOrder;
 import com.linkedin.metadata.recommendation.RecommendationsService;
 import com.linkedin.metadata.secret.SecretService;
+import com.linkedin.metadata.service.BusinessAttributeService;
 import com.linkedin.metadata.service.DataProductService;
 import com.linkedin.metadata.service.FormService;
 import com.linkedin.metadata.service.LineageService;
@@ -420,6 +431,7 @@ public class GmsGraphQLEngine {
   private final FormService formService;
   private final RestrictedService restrictedService;
 
+  private final BusinessAttributeService businessAttributeService;
   private final FeatureFlags featureFlags;
 
   private final IngestionConfiguration ingestionConfiguration;
@@ -476,6 +488,8 @@ public class GmsGraphQLEngine {
   private final int graphQLQueryComplexityLimit;
   private final int graphQLQueryDepthLimit;
 
+  private final BusinessAttributeType businessAttributeType;
+
   /** A list of GraphQL Plugins that extend the core engine */
   private final List<GmsGraphQLPlugin> graphQLPlugins;
 
@@ -533,6 +547,7 @@ public GmsGraphQLEngine(final GmsGraphQLEngineArgs args) {
     this.formService = args.formService;
     this.restrictedService = args.restrictedService;
 
+    this.businessAttributeService = args.businessAttributeService;
     this.ingestionConfiguration = Objects.requireNonNull(args.ingestionConfiguration);
     this.authenticationConfiguration = Objects.requireNonNull(args.authenticationConfiguration);
     this.authorizationConfiguration = Objects.requireNonNull(args.authorizationConfiguration);
@@ -586,6 +601,7 @@ public GmsGraphQLEngine(final GmsGraphQLEngineArgs args) {
     this.graphQLQueryComplexityLimit = args.graphQLQueryComplexityLimit;
     this.graphQLQueryDepthLimit = args.graphQLQueryDepthLimit;
 
+    this.businessAttributeType = new BusinessAttributeType(entityClient);
     // Init Lists
     this.entityTypes =
         ImmutableList.of(
@@ -626,7 +642,8 @@ public GmsGraphQLEngine(final GmsGraphQLEngineArgs args) {
             entityTypeType,
             formType,
             incidentType,
-            restrictedType);
+            restrictedType,
+            businessAttributeType);
     this.loadableTypes = new ArrayList<>(entityTypes);
     // Extend loadable types with types from the plugins
     // This allows us to offer search and browse capabilities out of the box for those types
@@ -717,6 +734,8 @@ public void configureRuntimeWiring(final RuntimeWiring.Builder builder) {
     configureFormResolvers(builder);
     configureIncidentResolvers(builder);
     configureRestrictedResolvers(builder);
+    configureBusinessAttributeResolver(builder);
+    configureBusinessAttributeAssociationResolver(builder);
   }
 
   private void configureOrganisationRoleResolvers(RuntimeWiring.Builder builder) {
@@ -1002,7 +1021,11 @@ private void configureQueryResolvers(final RuntimeWiring.Builder builder) {
                     "listOwnershipTypes", new ListOwnershipTypesResolver(this.entityClient))
                 .dataFetcher(
                     "browseV2",
-                    new BrowseV2Resolver(this.entityClient, this.viewService, this.formService)));
+                    new BrowseV2Resolver(this.entityClient, this.viewService, this.formService))
+                .dataFetcher("businessAttribute", getResolver(businessAttributeType))
+                .dataFetcher(
+                    "listBusinessAttributes",
+                    new ListBusinessAttributesResolver(this.entityClient)));
   }
 
   private DataFetcher getEntitiesResolver() {
@@ -1227,7 +1250,24 @@ private void configureMutationResolvers(final RuntimeWiring.Builder builder) {
                 .dataFetcher("raiseIncident", new RaiseIncidentResolver(this.entityClient))
                 .dataFetcher(
                     "updateIncidentStatus",
-                    new UpdateIncidentStatusResolver(this.entityClient, this.entityService)));
+                    new UpdateIncidentStatusResolver(this.entityClient, this.entityService))
+                .dataFetcher(
+                    "createBusinessAttribute",
+                    new CreateBusinessAttributeResolver(
+                        this.entityClient, this.entityService, this.businessAttributeService))
+                .dataFetcher(
+                    "updateBusinessAttribute",
+                    new UpdateBusinessAttributeResolver(
+                        this.entityClient, this.businessAttributeService))
+                .dataFetcher(
+                    "deleteBusinessAttribute",
+                    new DeleteBusinessAttributeResolver(this.entityClient))
+                .dataFetcher(
+                    "addBusinessAttribute",
+                    new AddBusinessAttributeResolver(this.entityClient, this.entityService))
+                .dataFetcher(
+                    "removeBusinessAttribute",
+                    new RemoveBusinessAttributeResolver(this.entityClient, this.entityService)));
   }
 
   private void configureGenericEntityResolvers(final RuntimeWiring.Builder builder) {
@@ -2826,4 +2866,40 @@ private void configureRestrictedResolvers(final RuntimeWiring.Builder builder) {
                         siblingGraphService, restrictedService, this.authorizationConfiguration))
                 .dataFetcher("relationships", new EntityRelationshipsResultResolver(graphClient)));
   }
+
+  private void configureBusinessAttributeResolver(final RuntimeWiring.Builder builder) {
+    builder
+        .type(
+            "BusinessAttribute",
+            typeWiring ->
+                typeWiring
+                    .dataFetcher("exists", new EntityExistsResolver(entityService))
+                    .dataFetcher("privileges", new EntityPrivilegesResolver(entityClient)))
+        .type(
+            "ListBusinessAttributesResult",
+            typeWiring ->
+                typeWiring.dataFetcher(
+                    "businessAttributes",
+                    new LoadableTypeBatchResolver<>(
+                        businessAttributeType,
+                        (env) ->
+                            ((ListBusinessAttributesResult) env.getSource())
+                                .getBusinessAttributes().stream()
+                                    .map(BusinessAttribute::getUrn)
+                                    .collect(Collectors.toList()))));
+  }
+
+  private void configureBusinessAttributeAssociationResolver(final RuntimeWiring.Builder builder) {
+    builder.type(
+        "BusinessAttributeAssociation",
+        typeWiring ->
+            typeWiring.dataFetcher(
+                "businessAttribute",
+                new LoadableTypeResolver<>(
+                    businessAttributeType,
+                    (env) ->
+                        ((BusinessAttributeAssociation) env.getSource())
+                            .getBusinessAttribute()
+                            .getUrn())));
+  }
 }

datahub-graphql-core/src/main/java/com/linkedin/datahub/graphql/GmsGraphQLEngineArgs.java

@@ -24,6 +24,7 @@
 import com.linkedin.metadata.models.registry.EntityRegistry;
 import com.linkedin.metadata.recommendation.RecommendationsService;
 import com.linkedin.metadata.secret.SecretService;
+import com.linkedin.metadata.service.BusinessAttributeService;
 import com.linkedin.metadata.service.DataProductService;
 import com.linkedin.metadata.service.FormService;
 import com.linkedin.metadata.service.LineageService;
@@ -79,6 +80,7 @@ public class GmsGraphQLEngineArgs {
   RestrictedService restrictedService;
   int graphQLQueryComplexityLimit;
   int graphQLQueryDepthLimit;
+  BusinessAttributeService businessAttributeService;
 
   // any fork specific args should go below this line
 }

datahub-graphql-core/src/main/java/com/linkedin/datahub/graphql/resolvers/MeResolver.java

@@ -13,6 +13,7 @@
 import com.linkedin.datahub.graphql.generated.AuthenticatedUser;
 import com.linkedin.datahub.graphql.generated.CorpUser;
 import com.linkedin.datahub.graphql.generated.PlatformPrivileges;
+import com.linkedin.datahub.graphql.resolvers.businessattribute.BusinessAttributeAuthorizationUtils;
 import com.linkedin.datahub.graphql.types.corpuser.mappers.CorpUserMapper;
 import com.linkedin.entity.EntityResponse;
 import com.linkedin.entity.client.EntityClient;
@@ -84,7 +85,10 @@ public CompletableFuture<AuthenticatedUser> get(DataFetchingEnvironment environm
                 AuthorizationUtils.canManageOwnershipTypes(context));
             platformPrivileges.setManageGlobalAnnouncements(
                 AuthorizationUtils.canManageGlobalAnnouncements(context));
-
+            platformPrivileges.setCreateBusinessAttributes(
+                BusinessAttributeAuthorizationUtils.canCreateBusinessAttribute(context));
+            platformPrivileges.setManageBusinessAttributes(
+                BusinessAttributeAuthorizationUtils.canManageBusinessAttribute(context));
             // Construct and return authenticated user object.
             final AuthenticatedUser authUser = new AuthenticatedUser();
             authUser.setCorpUser(corpUser);

datahub-graphql-core/src/main/java/com/linkedin/datahub/graphql/resolvers/businessattribute/AddBusinessAttributeResolver.java

@@ -0,0 +1,129 @@
+package com.linkedin.datahub.graphql.resolvers.businessattribute;
+
+import static com.linkedin.datahub.graphql.resolvers.ResolverUtils.bindArgument;
+import static com.linkedin.datahub.graphql.resolvers.businessattribute.BusinessAttributeAuthorizationUtils.isAuthorizeToUpdateDataset;
+import static com.linkedin.datahub.graphql.resolvers.mutate.MutationUtils.buildMetadataChangeProposalWithUrn;
+import static com.linkedin.datahub.graphql.resolvers.mutate.MutationUtils.getFieldInfoFromSchema;
+
+import com.linkedin.businessattribute.BusinessAttributeAssociation;
+import com.linkedin.common.AuditStamp;
+import com.linkedin.common.urn.Urn;
+import com.linkedin.common.urn.UrnUtils;
+import com.linkedin.datahub.graphql.QueryContext;
+import com.linkedin.datahub.graphql.exception.AuthorizationException;
+import com.linkedin.datahub.graphql.generated.AddBusinessAttributeInput;
+import com.linkedin.datahub.graphql.generated.ResourceRefInput;
+import com.linkedin.datahub.graphql.resolvers.mutate.util.LabelUtils;
+import com.linkedin.entity.client.EntityClient;
+import com.linkedin.metadata.Constants;
+import com.linkedin.metadata.entity.EntityService;
+import com.linkedin.metadata.entity.EntityUtils;
+import com.linkedin.mxe.MetadataChangeProposal;
+import com.linkedin.r2.RemoteInvocationException;
+import com.linkedin.schema.EditableSchemaFieldInfo;
+import com.linkedin.schema.EditableSchemaMetadata;
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import java.util.concurrent.CompletableFuture;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor
+public class AddBusinessAttributeResolver implements DataFetcher<CompletableFuture<Boolean>> {
+  private final EntityClient _entityClient;
+  private final EntityService _entityService;
+
+  @Override
+  public CompletableFuture<Boolean> get(DataFetchingEnvironment environment) throws Exception {
+    final QueryContext context = environment.getContext();
+    AddBusinessAttributeInput input =
+        bindArgument(environment.getArgument("input"), AddBusinessAttributeInput.class);
+    Urn businessAttributeUrn = UrnUtils.getUrn(input.getBusinessAttributeUrn());
+    ResourceRefInput resourceRefInput = input.getResourceUrn();
+    if (!isAuthorizeToUpdateDataset(
+        context, Urn.createFromString(resourceRefInput.getResourceUrn()))) {
+      throw new AuthorizationException(
+          "Unauthorized to perform this action. Please contact your DataHub administrator.");
+    }
+    if (!_entityClient.exists(businessAttributeUrn, context.getAuthentication())) {
+      throw new RuntimeException(
+          String.format("This urn does not exist: %s", businessAttributeUrn));
+    }
+    return CompletableFuture.supplyAsync(
+        () -> {
+          try {
+            validateInputResource(resourceRefInput);
+            addBusinessAttribute(businessAttributeUrn, resourceRefInput, context);
+            return true;
+          } catch (Exception e) {
+            throw new RuntimeException(
+                String.format(
+                    "Failed to add Business Attribute with urn %s to dataset with urn %s",
+                    businessAttributeUrn, resourceRefInput.getResourceUrn()),
+                e);
+          }
+        });
+  }
+
+  private void validateInputResource(ResourceRefInput resource) {
+    final Urn resourceUrn = UrnUtils.getUrn(resource.getResourceUrn());
+    LabelUtils.validateResource(
+        resourceUrn, resource.getSubResource(), resource.getSubResourceType(), _entityService);
+  }
+
+  private void addBusinessAttribute(
+      Urn businessAttributeUrn, ResourceRefInput resourceRefInput, QueryContext context)
+      throws RemoteInvocationException {
+    _entityClient.ingestProposal(
+        buildAddBusinessAttributeToSubresourceProposal(
+            businessAttributeUrn, resourceRefInput, context),
+        context.getAuthentication());
+  }
+
+  private MetadataChangeProposal buildAddBusinessAttributeToSubresourceProposal(
+      Urn businessAttributeUrn, ResourceRefInput resource, QueryContext context) {
+    com.linkedin.schema.EditableSchemaMetadata editableSchemaMetadata =
+        (com.linkedin.schema.EditableSchemaMetadata)
+            EntityUtils.getAspectFromEntity(
+                resource.getResourceUrn(),
+                Constants.EDITABLE_SCHEMA_METADATA_ASPECT_NAME,
+                _entityService,
+                new EditableSchemaMetadata());
+
+    EditableSchemaFieldInfo editableFieldInfo =
+        getFieldInfoFromSchema(editableSchemaMetadata, resource.getSubResource());
+
+    if (editableFieldInfo == null) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Subresource %s does not exist in dataset %s",
+              resource.getSubResource(), resource.getResourceUrn()));
+    }
+
+    if (editableFieldInfo.hasBusinessAttribute()) {
+      throw new RuntimeException(
+          String.format("Schema field has already attached with business attribute"));
+    }
+    editableFieldInfo.setBusinessAttribute(new BusinessAttributeAssociation());
+    addBusinessAttribute(
+        editableFieldInfo.getBusinessAttribute(),
+        businessAttributeUrn,
+        UrnUtils.getUrn(context.getActorUrn()));
+    return buildMetadataChangeProposalWithUrn(
+        UrnUtils.getUrn(resource.getResourceUrn()),
+        Constants.EDITABLE_SCHEMA_METADATA_ASPECT_NAME,
+        editableSchemaMetadata);
+  }
+
+  private void addBusinessAttribute(
+      BusinessAttributeAssociation businessAttributeAssociation,
+      Urn businessAttributeUrn,
+      Urn actorUrn) {
+    businessAttributeAssociation.setDestinationUrn(businessAttributeUrn);
+    AuditStamp nowAuditStamp =
+        new AuditStamp().setTime(System.currentTimeMillis()).setActor(actorUrn);
+    businessAttributeAssociation.setCreated(nowAuditStamp);
+    businessAttributeAssociation.setLastModified(nowAuditStamp);
+  }
+}