Fix network agg resolution (#885)

* add Bucket gql object type

* text change, move func outside of nested func

* fix resolved aggregations overriding

* Update modules/server/src/network/aggregations/index.ts

Co-authored-by: Anders Richardsson <2107110+justincorrigible@users.noreply.github.com>

---------

Co-authored-by: Ciaran Schutte <ciaranschutte@oicr.on.ca>
Co-authored-by: Anders Richardsson <2107110+justincorrigible@users.noreply.github.com>

modules/server/src/network/aggregations/index.ts

@@ -44,21 +44,46 @@ export const resolveToNetworkAggregation = (
  * Takes an array of the same aggregation type and computes the singular type
  * eg. NumericAggregation => NetworkNumericAggregation
  *
+ * Note for operations on Buckets -  the size of the array can be large (e.g. total bucket count), complicating lookups, etc.
+ *
  * @param aggregations
  * @returns
  */
 export const resolveAggregation = (aggregations: Aggregations[]): NetworkAggregation => {
 	const emptyAggregation: NetworkAggregation = { bucket_count: 0, buckets: [] };
 
 	const resolvedAggregation = aggregations.reduce((resolvedAggregation, agg) => {
-		const computedBucketCount = resolvedAggregation.bucket_count + agg.bucket_count;
-		const computedBuckets = agg.buckets.map(({ key, doc_count }) => {
-			// potentially expensive "find" if array of buckets is very large
-			const bucket = resolvedAggregation.buckets.find((bucket) => bucket.key === key);
-			return { key, doc_count: (bucket?.doc_count || 0) + doc_count };
+		const bucketCountAccumulator = resolvedAggregation.bucket_count + agg.bucket_count;
+
+		/*
+		 * Unable to use lookup key eg. buckets[key]
+		 * "buckets": [
+		 *  {
+		 *    "doc_count": 140,
+		 *    "key": "Dog"
+		 *   },
+		 */
+		const computedBuckets = resolvedAggregation.buckets;
+
+		agg.buckets.forEach((bucket) => {
+			const { key, doc_count } = bucket;
+			const existingBucketIndex = computedBuckets.findIndex((bucket) => bucket.key === key);
+			if (existingBucketIndex !== -1) {
+				const existingBucket = computedBuckets[existingBucketIndex];
+				if (existingBucket) {
+					// update existing bucket
+					computedBuckets[existingBucketIndex] = {
+						...existingBucket,
+						doc_count: existingBucket.doc_count + doc_count,
+					};
+				}
+			} else {
+				computedBuckets.push(bucket);
+			}
 		});
-		return { bucket_count: computedBucketCount, buckets: computedBuckets };
+		return { bucket_count: bucketCountAccumulator, buckets: computedBuckets };
 	}, emptyAggregation);
+
 	return resolvedAggregation;
 };
 

modules/server/src/network/index.ts

@@ -50,7 +50,7 @@ const fetchRemoteSchema = async (
 		/**
 		 * TODO: expand on error handling for instance of Axios error for example
 		 */
-		console.error(`failed to retrieve schema from url: ${config.graphqlUrl}`);
+		console.error(`Failed to retrieve schema from url: ${config.graphqlUrl}`);
 		return;
 	}
 };

modules/server/src/network/typeDefs/aggregations.ts

@@ -2,11 +2,26 @@ import { GraphQLObjectType, GraphQLSchema } from 'graphql';
 import { SupportedNetworkFieldType } from '../types';
 import { singleToNetworkAggregationMap } from './networkAggregations';
 
+/**
+ * Converts field/types to GQLObjectType definition shape
+ *
+ * @example
+ * { name: "donor_age", type: "NumericAggregations" } => { donor_age: { type: "NetworkNumericAggregations" } }
+ */
+const convertToGQLObjectType = (networkFieldTypes) => {
+	return networkFieldTypes.reduce((allFields, currentField) => {
+		const field = {
+			[currentField.name]: { type: singleToNetworkAggregationMap.get(currentField.type) },
+		};
+		return { ...allFields, ...field };
+	}, {});
+};
+
 /**
  * Returns available aggregations by filtering duplicates, and mapping from
  * singular remote aggregation type to network aggregation types
  *
- * eg. NumericAggregation to NetworkNumericAggregation
+ * eg. NumericAggregations to NetworkNumericAggregations
  *
  * There is no distinction on which types come from which remote connections
  * This is the resolvers responsibility
@@ -17,18 +32,7 @@ import { singleToNetworkAggregationMap } from './networkAggregations';
 export const createNetworkAggregationTypeDefs = (
 	networkFieldTypes: SupportedNetworkFieldType[],
 ) => {
-	/**
-	 * Converts field/types to GQLObjectType definition shape
-	 *
-	 * @example
-	 * { name: "donor_age", type: "NumericAggregations" } => { donor_age: { type: "NetworkNumericAggregations" } }
-	 */
-	const allFields = networkFieldTypes.reduce((allFields, currentField) => {
-		const field = {
-			[currentField.name]: { type: singleToNetworkAggregationMap.get(currentField.type) },
-		};
-		return { ...allFields, ...field };
-	}, {});
+	const allFields = convertToGQLObjectType(networkFieldTypes);
 
 	const typeDefs = new GraphQLObjectType({
 		name: 'Aggregations',

modules/server/src/network/typeDefs/networkAggregations.ts

@@ -1,13 +1,28 @@
-import { GraphQLInt, GraphQLObjectType, GraphQLString } from 'graphql';
+import { GraphQLInt, GraphQLList, GraphQLObjectType, GraphQLString } from 'graphql';
 import { SupportedAggregation, SUPPORTED_AGGREGATIONS } from '../common';
 
+const bucket = new GraphQLObjectType({
+	name: 'bucket',
+	fields: {
+		doc_count: {
+			type: GraphQLInt,
+		},
+		key: {
+			type: GraphQLString,
+		},
+	},
+});
+
 // TODO: Placeholder to expand type
 const networkAggregations = new GraphQLObjectType({
 	name: 'NetworkAggregations',
 	fields: {
 		bucket_count: {
 			type: GraphQLInt,
 		},
+		buckets: {
+			type: new GraphQLList(bucket),
+		},
 	},
 });