chore: cleanup

urangel · urangel · commit a965703ecf07 · 2026-06-16T09:28:08.000-05:00
diff --git a/cmd/api/src/api/v2/azure.go b/cmd/api/src/api/v2/azure.go
diff --git a/cmd/api/src/api/v2/azure_test.go b/cmd/api/src/api/v2/azure_test.go
@@ -180,7 +180,7 @@ func TestResources_GetAZRelatedEntities(t *testing.T) {
 			},
 			expected: expected{
 				responseCode:   http.StatusInternalServerError,
-				responseBody:   `{"errors":[{"context":"","message":"error fetching primary display kinds: database error"}],"http_status":500,"request_id":"","timestamp":"0001-01-01T00:00:00Z"}`,
+				responseBody:   `{"errors":[{"context":"","message":"an internal error has occurred that is preventing the service from servicing this request"}],"http_status":500,"request_id":"","timestamp":"0001-01-01T00:00:00Z"}`,
 				responseHeader: http.Header{"Content-Type": []string{"application/json"}},
 			},
 		},
diff --git a/cmd/api/src/queries/graph.go b/cmd/api/src/queries/graph.go
@@ -1013,7 +1013,6 @@ func (s *GraphQuery) runListQuery(ctx context.Context, primaryDisplayKinds graph
 }
 
 func (s *GraphQuery) runCountQuery(ctx context.Context, node *graph.Node, params EntityQueryParameters, cacheEnabled bool) (any, int, error) {
-	params.RequestedType = model.DataTypeList 
 	result, err := s.runMaybeCachedEntityQuery(ctx, node, params, cacheEnabled)
 	return nil, result.Len(), err
 }
diff --git a/packages/go/analysis/azure/azure_integration_test.go b/packages/go/analysis/azure/azure_integration_test.go
@@ -1022,39 +1022,6 @@ func TestFetchEntityDescendentPaths_MultiHopPathToRoot(t *testing.T) {
 	require.NoError(t, err)
 }
 
-// TestFetchEntityDescendentPaths_DifferentTenantExcluded verifies that nodes sharing the same kind
-// but belonging to a different Azure tenant are not included in the path set.
-func TestFetchEntityDescendentPaths_DifferentTenantExcluded(t *testing.T) {
-	t.Parallel()
-
-	suite := setupIntegrationTestSuite(t)
-	defer teardownIntegrationTestSuite(t, &suite)
-
-	var (
-		tenantID      = integration.RandomObjectID(t)
-		otherTenantID = integration.RandomObjectID(t)
-		tenantNode    = NewAzureTenant(t, &suite, tenantID)
-		ownApp        = NewAzureApplication(t, &suite, "OwnApp", integration.RandomObjectID(t), tenantID)
-		foreignApp    = NewAzureApplication(t, &suite, "ForeignApp", integration.RandomObjectID(t), otherTenantID)
-	)
-
-	NewRelationship(t, &suite, tenantNode, ownApp, graphAzure.Contains)
-	// foreignApp is deliberately not connected; it belongs to a different tenant.
-
-	err := suite.GraphDB.ReadTransaction(suite.Context, func(tx graph.Transaction) error {
-		paths, err := azure.FetchEntityDescendentPaths(tx, tenantNode, graphAzure.App)
-		require.NoError(t, err)
-
-		nodeIDs := paths.AllNodes().IDs()
-		require.Contains(t, nodeIDs, tenantNode.ID)
-		require.Contains(t, nodeIDs, ownApp.ID)
-		require.NotContains(t, nodeIDs, foreignApp.ID)
-
-		return nil
-	})
-	require.NoError(t, err)
-}
-
 // TestFetchEntityDescendentPaths_NoTerminalsReturnsEmpty verifies that an empty path set is
 // returned when no nodes of the requested kind exist within the tenant.
 func TestFetchEntityDescendentPaths_NoTerminalsReturnsEmpty(t *testing.T) {
diff --git a/packages/go/analysis/azure/db_ops.go b/packages/go/analysis/azure/db_ops.go
@@ -73,14 +73,12 @@ func ListEntityDescendentPaths(ctx context.Context, db graph.Database, relatedEn
 				return ErrInvalidRelatedEntityType
 			}
 
-			if validEndKinds, ok := containsValidEndKinds[sourceKind]; ok && validEndKinds.ContainsOneOf(targetKind) {
+			if isDirectDescendent(sourceKind, targetKind) {
 				paths, err = FetchDirectDescendentPaths(tx, node, targetKind)
-				return err
 			} else {
 				paths, err = FetchEntityDescendentPaths(tx, node, targetKind)
-				return err
 			}
-
+			return err
 		}
 	})
 }
@@ -133,14 +131,12 @@ func ListEntityDescendents(ctx context.Context, db graph.Database, relatedEntity
 				return ErrInvalidRelatedEntityType
 			}
 
-			if validEndKinds, ok := containsValidEndKinds[sourceKind]; ok && validEndKinds.ContainsOneOf(targetKind) {
-				nodes, err = FetchDirectEntityDescendents(tx, node, skip, limit, targetKind)
-				return err
+			if isDirectDescendent(sourceKind, targetKind) {
+				nodes, err = FetchDirectEntityDescendents(tx, node, targetKind)
 			} else {
-				nodes, err = FetchEntityDescendents(tx, node, skip, limit, targetKind)
-				return err
+				nodes, err = FetchEntityDescendents(tx, node, targetKind)
 			}
-
+			return err
 		}
 	})
 }
diff --git a/packages/go/analysis/azure/management_group.go b/packages/go/analysis/azure/management_group.go
@@ -45,7 +45,7 @@ func ManagementGroupEntityDetails(ctx context.Context, db graph.Database, primar
 func PopulateManagementGroupEntityDetailsCounts(tx graph.Transaction, node *graph.Node, details ManagementGroupDetails) (ManagementGroupDetails, error) {
 	var descendentKinds = GetDescendentKinds(azure.ManagementGroup)
 
-	if descendents, err := FetchEntityDescendentCounts(tx, node, 0, 0, descendentKinds...); err != nil {
+	if descendents, err := FetchEntityDescendentCounts(tx, node, descendentKinds...); err != nil {
 		return details, err
 	} else {
 		details.Descendents = descendents
diff --git a/packages/go/analysis/azure/queries.go b/packages/go/analysis/azure/queries.go
@@ -18,7 +18,6 @@ package azure
 
 import (
 	"context"
-	"net/url"
 
 	"log/slog"
 	"strings"
@@ -822,6 +821,13 @@ var containsValidEndKinds = map[graph.Kind]graph.Kinds{
 	},
 }
 
+func isDirectDescendent(sourceKind, targetKind graph.Kind) bool {
+	if validEndKinds, ok := containsValidEndKinds[sourceKind]; ok && validEndKinds.ContainsOneOf(targetKind) {
+		return true
+	}
+	return false
+}
+
 // nodeAzureTenantID returns the Azure tenant ID for a node. For Tenant nodes the tenant ID is
 // stored in the common.ObjectID property; for all other Azure nodes it is stored in azure.TenantID.
 func nodeAzureTenantID(node *graph.Node) (string, error) {
@@ -832,22 +838,16 @@ func nodeAzureTenantID(node *graph.Node) (string, error) {
 	return node.Properties.Get(azure.TenantID.String()).String()
 }
 
-// FetchDirectDescendentPaths fetches the direct AZContains relationships from the root node. Both
-// the valid start/end node kind pairing and the tenant-id match are enforced
+// FetchDirectDescendentPaths fetches the direct AZContains relationships from the root node
 func FetchDirectDescendentPaths(tx graph.Transaction, root *graph.Node, descendentKind ...graph.Kind) (graph.PathSet, error) {
-	if tenantID, err := nodeAzureTenantID(root); err != nil {
-		return nil, err
-	} else {
-		return ops.FetchPathSet(tx.Relationships().Filter(query.And(
-			query.Equals(query.StartID(), root.ID),
-			query.Kind(query.Relationship(), azure.Contains),
-			query.KindIn(query.End(), descendentKind...),
-			query.Equals(query.EndProperty(azure.TenantID.String()), tenantID),
-		)))
-	}
+	return ops.FetchPathSet(tx.Relationships().Filter(query.And(
+		query.Equals(query.StartID(), root.ID),
+		query.Kind(query.Relationship(), azure.Contains),
+		query.KindIn(query.End(), descendentKind...),
+	)))
 }
 
-func FetchDirectEntityDescendents(tx graph.Transaction, root *graph.Node, skip, limit int, descendentKind graph.Kind) (graph.NodeSet, error) {
+func FetchDirectEntityDescendents(tx graph.Transaction, root *graph.Node, descendentKind graph.Kind) (graph.NodeSet, error) {
 	if paths, err := FetchDirectDescendentPaths(tx, root, descendentKind); err != nil {
 		return nil, err
 	} else {
@@ -857,7 +857,7 @@ func FetchDirectEntityDescendents(tx graph.Transaction, root *graph.Node, skip,
 	}
 }
 
-func FetchDescendentKindByTenantID(tx graph.Transaction, root *graph.Node, skip, limit int, descendentKind ...graph.Kind) (graph.NodeSet, error) {
+func FetchDescendentKindByTenantID(tx graph.Transaction, root *graph.Node, descendentKind ...graph.Kind) (graph.NodeSet, error) {
 	if tenantID, err := nodeAzureTenantID(root); err != nil {
 		return nil, err
 	} else if nodes, err := ops.FetchNodeSet(tx.Nodes().Filter(query.And(
@@ -883,7 +883,7 @@ func FetchEntityDescendentPaths(tx graph.Transaction, root *graph.Node, descende
 	// Pre-populate the visited bitmap with root so that any traversal halts when it reaches it
 	visitedBitmap.Add(root.ID.Uint64())
 
-	terminalNodes, err := FetchDescendentKindByTenantID(tx, root, 0, 0, descendentKind...)
+	terminalNodes, err := FetchDescendentKindByTenantID(tx, root, descendentKind...)
 	if err != nil {
 		return nil, err
 	}
@@ -918,7 +918,7 @@ func FetchEntityDescendentPaths(tx graph.Transaction, root *graph.Node, descende
 	return pathSet, nil
 }
 
-func FetchEntityDescendents(tx graph.Transaction, root *graph.Node, skip, limit int, descendentKind graph.Kind) (graph.NodeSet, error) {
+func FetchEntityDescendents(tx graph.Transaction, root *graph.Node, descendentKind graph.Kind) (graph.NodeSet, error) {
 	if paths, err := FetchEntityDescendentPaths(tx, root, descendentKind); err != nil {
 		return nil, err
 	} else {
@@ -928,7 +928,7 @@ func FetchEntityDescendents(tx graph.Transaction, root *graph.Node, skip, limit
 	}
 }
 
-func FetchDirectDescendentCounts(tx graph.Transaction, root *graph.Node, skip, limit int, descendentKinds ...graph.Kind) (Descendents, error) {
+func FetchDirectDescendentCounts(tx graph.Transaction, root *graph.Node, descendentKinds ...graph.Kind) (Descendents, error) {
 	if paths, err := FetchDirectDescendentPaths(tx, root, descendentKinds...); err != nil {
 		return Descendents{}, err
 	} else {
@@ -946,7 +946,7 @@ func FetchDirectDescendentCounts(tx graph.Transaction, root *graph.Node, skip, l
 	}
 }
 
-func FetchEntityDescendentCounts(tx graph.Transaction, root *graph.Node, skip, limit int, descendentKinds ...graph.Kind) (Descendents, error) {
+func FetchEntityDescendentCounts(tx graph.Transaction, root *graph.Node, descendentKinds ...graph.Kind) (Descendents, error) {
 	if paths, err := FetchEntityDescendentPaths(tx, root, descendentKinds...); err != nil {
 		return Descendents{}, err
 	} else {
@@ -980,14 +980,10 @@ func fetchRolesTraversalPlan(root *graph.Node) ops.TraversalPlan {
 
 // FetchEntityByObjectID pulls a node by its ObjectID. It requires a kind to perform index lookups against.
 func FetchEntityByObjectID(tx graph.Transaction, objectID string) (*graph.Node, error) {
-	if decodedObjectID, err := url.QueryUnescape(objectID); err != nil {
-		return nil, err
-	} else {
-		return tx.Nodes().Filterf(func() graph.Criteria {
-			return query.And(
-				query.Kind(query.Node(), azure.Entity),
-				query.Equals(query.NodeProperty(common.ObjectID.String()), decodedObjectID),
-			)
-		}).First()
-	}
+	return tx.Nodes().Filterf(func() graph.Criteria {
+		return query.And(
+			query.Kind(query.Node(), azure.Entity),
+			query.Equals(query.NodeProperty(common.ObjectID.String()), objectID),
+		)
+	}).First()
 }
diff --git a/packages/go/analysis/azure/resource_group.go b/packages/go/analysis/azure/resource_group.go
@@ -43,7 +43,7 @@ func ResourceGroupEntityDetails(ctx context.Context, db graph.Database, primaryD
 func PopulateResourceGroupEntityDetailsCounts(tx graph.Transaction, node *graph.Node, details ResourceGroupDetails) (ResourceGroupDetails, error) {
 	var descendentKinds = GetDescendentKinds(azure.ResourceGroup)
 
-	if descendents, err := FetchDirectDescendentCounts(tx, node, 0, 0, descendentKinds...); err != nil {
+	if descendents, err := FetchDirectDescendentCounts(tx, node, descendentKinds...); err != nil {
 		return details, err
 	} else {
 		details.Descendents = descendents
diff --git a/packages/go/analysis/azure/subscription.go b/packages/go/analysis/azure/subscription.go
@@ -43,7 +43,7 @@ func SubscriptionEntityDetails(ctx context.Context, db graph.Database, primaryDi
 func PopulateSubscriptionEntityDetailsCounts(tx graph.Transaction, node *graph.Node, details SubscriptionDetails) (SubscriptionDetails, error) {
 	var descendentKinds = GetDescendentKinds(azure.Subscription)
 
-	if descendents, err := FetchEntityDescendentCounts(tx, node, 0, 0, descendentKinds...); err != nil {
+	if descendents, err := FetchEntityDescendentCounts(tx, node, descendentKinds...); err != nil {
 		return details, err
 	} else {
 		details.Descendents = descendents
diff --git a/packages/go/analysis/azure/tenant.go b/packages/go/analysis/azure/tenant.go
@@ -48,7 +48,7 @@ func TenantEntityDetails(ctx context.Context, db graph.Database, primaryDisplayK
 func PopulateTenantEntityDetailsCounts(tx graph.Transaction, node *graph.Node, details TenantDetails) (TenantDetails, error) {
 	descendentKinds := GetDescendentKinds(azure.Tenant)
 
-	if descendents, err := FetchEntityDescendentCounts(tx, node, 0, 0, descendentKinds...); err != nil {
+	if descendents, err := FetchEntityDescendentCounts(tx, node, descendentKinds...); err != nil {
 		return details, err
 	} else {
 		details.Descendents = descendents
diff --git a/packages/javascript/bh-shared-ui/src/components/EntityInfoDataTableGraphed/EntityInfoDataTableGraphed.test.tsx b/packages/javascript/bh-shared-ui/src/components/EntityInfoDataTableGraphed/EntityInfoDataTableGraphed.test.tsx
@@ -131,7 +131,7 @@ describe('EntityInfoDataTableGraphed', () => {
             expect(sum).not.toBeNull();
         });
 
-        it('displays ! icon when one of the Affected Object calls fail', async () => {
+        it('sums the remaining sections when one of the Affected Object calls fails', async () => {
             console.error = vi.fn();
             server.use(
                 rest.get(`api/v2/gpos/${objectId}/ous`, (req, res, ctx) => {
@@ -141,9 +141,10 @@ describe('EntityInfoDataTableGraphed', () => {
 
             render(<EntityInfoDataTableGraphed {...adGpoSections[0]} />);
 
-            const errorIcon = await screen.findByTestId('ErrorOutlineIcon');
+            const sum = await screen.findByText('5,056');
+            expect(sum).not.toBeNull();
 
-            expect(errorIcon).not.toBeNull();
+            expect(screen.queryByTestId('ErrorOutlineIcon')).toBeNull();
         });
 
         it('displays 0 when a given sections returns empty, and sums the rest of the sections correctly', async () => {
diff --git a/packages/javascript/bh-shared-ui/src/components/EntityInfoDataTableGraphed/EntityInfoDataTableGraphed.tsx b/packages/javascript/bh-shared-ui/src/components/EntityInfoDataTableGraphed/EntityInfoDataTableGraphed.tsx
@@ -13,6 +13,7 @@
 // limitations under the License.
 //
 // SPDX-License-Identifier: Apache-2.0
+import { PaginatedResponse } from 'js-client-library';
 import { useQuery } from 'react-query';
 import { NODE_GRAPH_RENDER_LIMIT } from '../../constants';
 import { useExploreParams } from '../../hooks';
@@ -21,6 +22,27 @@ import { EntityInfoDataTableProps, entityRelationshipEndpoints } from '../../uti
 import EntityInfoCollapsibleSection from '../EntityInfo/EntityInfoCollapsibleSection';
 import InfiniteScrollingTable from '../InfiniteScrollingTable';
 
+function getCount<T>(
+    queryData: Array<PromiseFulfilledResult<PaginatedResponse<T>>> | PaginatedResponse<T> | undefined,
+    countLabel: string | undefined
+): number | undefined {
+    if (Array.isArray(queryData)) {
+        const fulfilledData = queryData.filter((result) => result.status === 'fulfilled').map((result) => result.value);
+
+        if (countLabel !== undefined) {
+            const labeledSection = fulfilledData.find((sectionData: any) => sectionData?.countLabel === countLabel);
+            return labeledSection?.count;
+        } else {
+            return fulfilledData.reduce((acc, val) => {
+                const sectionCount = val?.count ?? 0;
+                return acc + sectionCount;
+            }, 0);
+        }
+    } else if (queryData) {
+        return queryData?.count ?? 0;
+    }
+}
+
 export const EntityInfoDataTableGraphed: React.FC<EntityInfoDataTableProps> = ({
     id,
     label,
@@ -35,13 +57,13 @@ export const EntityInfoDataTableGraphed: React.FC<EntityInfoDataTableProps> = ({
     const isExpandedPanelSection = (expandedPanelSections as string[]).includes(label);
 
     const countQuery = useQuery(
-        ['relatedCount', label, id],
+        ['relatedCount', label, id, sections],
         () => {
             if (endpoint) {
                 return endpoint({ id, skip: 0, limit: 128 });
             }
             if (sections)
-                return Promise.all(
+                return Promise.allSettled(
                     sections.map((section: EntityInfoDataTableProps) => {
                         const endpoint = section.queryType ? entityRelationshipEndpoints[section.queryType] : undefined;
                         return endpoint ? endpoint({ id, skip: 0, limit: 128 }) : Promise.resolve();
@@ -104,21 +126,7 @@ export const EntityInfoDataTableGraphed: React.FC<EntityInfoDataTableProps> = ({
         setNodeSearchParams(item);
     };
 
-    let count: number | undefined;
-    if (Array.isArray(countQuery.data)) {
-        if (countLabel !== undefined) {
-            countQuery.data.forEach((sectionData: any) => {
-                if (sectionData.countLabel === countLabel) count = sectionData.count;
-            });
-        } else {
-            count = countQuery.data.reduce((acc, val) => {
-                const count = val?.count ?? 0;
-                return acc + count;
-            }, 0);
-        }
-    } else if (countQuery.data) {
-        count = countQuery.data?.count ?? 0;
-    }
+    const count = getCount(countQuery.data, countLabel);
 
     return (
         <EntityInfoCollapsibleSection
diff --git a/packages/javascript/js-client-library/src/client.ts b/packages/javascript/js-client-library/src/client.ts
@@ -1235,7 +1235,7 @@ class BHEAPIClient {
             Object.assign(
                 {
                     params: {
-                        object_id: encodeURIComponent(id),
+                        object_id: id,
                         related_entity_type: relatedEntityType,
                         counts,
                         skip,

Original file line number	Diff line number	Diff line change
`@@ -1013,7 +1013,6 @@ func (s *GraphQuery) runListQuery(ctx context.Context, primaryDisplayKinds graph`
`1013`	`1013`	`}`
`1014`	`1014`
`1015`	`1015`	`func (s GraphQuery) runCountQuery(ctx context.Context, node graph.Node, params EntityQueryParameters, cacheEnabled bool) (any, int, error) {`
`1016`		`- params.RequestedType = model.DataTypeList`
`1017`	`1016`	`result, err := s.runMaybeCachedEntityQuery(ctx, node, params, cacheEnabled)`
`1018`	`1017`	`return nil, result.Len(), err`
`1019`	`1018`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,14 +73,12 @@ func ListEntityDescendentPaths(ctx context.Context, db graph.Database, relatedEn`
`73`	`73`	`return ErrInvalidRelatedEntityType`
`74`	`74`	`}`
`75`	`75`
`76`		`- if validEndKinds, ok := containsValidEndKinds[sourceKind]; ok && validEndKinds.ContainsOneOf(targetKind) {`
	`76`	`+ if isDirectDescendent(sourceKind, targetKind) {`
`77`	`77`	`paths, err = FetchDirectDescendentPaths(tx, node, targetKind)`
`78`		`- return err`
`79`	`78`	`} else {`
`80`	`79`	`paths, err = FetchEntityDescendentPaths(tx, node, targetKind)`
`81`		`- return err`
`82`	`80`	`}`
`83`		`-`
	`81`	`+ return err`
`84`	`82`	`}`
`85`	`83`	`})`
`86`	`84`	`}`
`@@ -133,14 +131,12 @@ func ListEntityDescendents(ctx context.Context, db graph.Database, relatedEntity`
`133`	`131`	`return ErrInvalidRelatedEntityType`
`134`	`132`	`}`
`135`	`133`
`136`		`- if validEndKinds, ok := containsValidEndKinds[sourceKind]; ok && validEndKinds.ContainsOneOf(targetKind) {`
`137`		`- nodes, err = FetchDirectEntityDescendents(tx, node, skip, limit, targetKind)`
`138`		`- return err`
	`134`	`+ if isDirectDescendent(sourceKind, targetKind) {`
	`135`	`+ nodes, err = FetchDirectEntityDescendents(tx, node, targetKind)`
`139`	`136`	`} else {`
`140`		`- nodes, err = FetchEntityDescendents(tx, node, skip, limit, targetKind)`
`141`		`- return err`
	`137`	`+ nodes, err = FetchEntityDescendents(tx, node, targetKind)`
`142`	`138`	`}`
`143`		`-`
	`139`	`+ return err`
`144`	`140`	`}`
`145`	`141`	`})`
`146`	`142`	`}`