feat(api): enhance /search filtering and aggregations

Add support for filter operations (include/exclude), OR logic via array
values, dynamic aggregation fields and sub-aggregations in the search API.
Allow switching between default and coredev indices. This consolidates
search functionality across products by making the Bitcoin Search API
more flexible while maintaining backward compatibility.

src/components/sidebarFacet/Facet.tsx

@@ -40,9 +40,7 @@ const Facet = ({ field, isFilterable, label, view, callback }: FacetProps) => {
   } = useSearchQuery();
   // temporary conditional
   const fieldAggregate: FacetAggregateBucket =
-    field === "domain"
-      ? data?.aggregations?.["domains"]?.["buckets"] ?? []
-      : data?.aggregations?.[field]?.["buckets"] ?? [];
+    data?.aggregations?.[field]?.["buckets"] ?? [];
   const { getFilter, addFilter, removeFilter } = useURLManager();
 
   const selectedList = getFilter(field);

src/components/sidebarFacet/FilterMenu.tsx

@@ -1,4 +1,4 @@
-import { Facet } from "@/types";
+import { Facet, FacetKeys } from "@/types";
 import Image from "next/image";
 import React from "react";
 import SidebarSection from "./SidebarSection";
@@ -70,13 +70,13 @@ const AppliedFilters = ({ filters }: { filters: Facet[] }) => {
                 role="button"
                 onClick={() =>
                   removeFilter({
-                    filterType: filter.field,
-                    filterValue: filter.value,
+                    filterType: filter.field as FacetKeys,
+                    filterValue: filter.value as string,
                   })
                 }
               >
                 <span className="capitalize text-sm font-semibold 2xl:text-sm">
-                  {getFilterValueDisplay(filter.value, filter.field)}
+                  {getFilterValueDisplay(filter.value as string, filter.field)}
                 </span>
                 <Image
                   src={isDark ? DarkCrossIcon : CrossIcon}

src/pages/api/elasticSearchProxy/search.ts

@@ -1,7 +1,6 @@
 import type { NextApiRequest, NextApiResponse } from "next";
 import { client } from "@/config/elasticsearch";
 import { buildQuery } from "@/utils/server/apiFunctions";
-// import ElasticsearchAPIConnector from "@elastic/search-ui-elasticsearch-connector";
 
 export default async function handler(
   req: NextApiRequest,
@@ -14,11 +13,19 @@ export default async function handler(
     });
   }
 
-  let queryString = req.body.queryString as string;
-  let size = req.body.size;
-  let page = req.body.page;
-  let filterFields = req.body.filterFields;
-  let sortFields = req.body.sortFields;
+  const {
+    queryString,
+    size,
+    page,
+    filterFields,
+    sortFields,
+    aggregationFields,
+    index = "default",
+  } = req.body;
+
+  // Select index based on parameter
+  const selectedIndex =
+    index === "coredev" ? process.env.COREDEV_INDEX : process.env.INDEX;
 
   const from = page * size;
   let searchQuery = buildQuery({
@@ -27,12 +34,13 @@ export default async function handler(
     sortFields,
     from,
     size,
+    aggregationFields,
   });
 
   try {
     // Call the search method
     const result = await client.search({
-      index: process.env.INDEX,
+      index: selectedIndex,
       ...searchQuery,
     });
 

src/service/api/search/searchCall.ts

@@ -9,12 +9,25 @@ export const buildQueryCall: BuildQuery = async (
   { queryString, size, page, filterFields, sortFields },
   url
 ) => {
+  const appFilterFields = [
+    ...filterFields,
+    // Application-specific filters
+    { field: "type", value: "combined-summary", operation: "exclude" },
+  ];
+
+  const aggregations = [
+    { field: "authors" },
+    { field: "domain" },
+    { field: "tags" },
+  ];
+
   const body = {
     queryString,
     size,
     page,
-    filterFields,
+    filterFields: appFilterFields,
     sortFields,
+    aggregationFields: aggregations,
   };
 
   const jsonBody = JSON.stringify(body);

src/types.ts

@@ -1,16 +1,23 @@
 import {
   AggregationsAggregate,
+  AggregationsAggregationContainer,
   SearchResponse,
 } from "@elastic/elasticsearch/lib/api/types";
-const AUTHOR = "authors" as const;
-const DOMAIN = "domain" as const;
-const TAGS = "tags" as const;
 
-export type FacetKeys = typeof AUTHOR | typeof DOMAIN | typeof TAGS;
+export const FACETS = {
+  AUTHOR: "authors",
+  DOMAIN: "domain",
+  TAGS: "tags",
+} as const;
+
+export type FacetKeys = (typeof FACETS)[keyof typeof FACETS];
+
+export type FilterOperation = "include" | "exclude";
 
 export type Facet = {
-  field: FacetKeys;
-  value: string;
+  field: string;
+  value: string | string[];
+  operation?: FilterOperation;
 };
 
 const bodyType = {
@@ -20,14 +27,25 @@ const bodyType = {
   "combined-summary": "combined-summary",
 } as const;
 
-export type SortOption = "asc" | "desc";
+type SortOption = {
+  field: string;
+  value: "asc" | "desc";
+};
+
+export interface AggregationField {
+  field: string;
+  size?: number;
+  subAggregations?: Record<string, AggregationsAggregationContainer>; // Raw ES aggregation config
+}
 
 export type SearchQuery = {
   queryString: string;
   size: number;
   page: number;
   filterFields: Facet[];
-  sortFields: any[];
+  sortFields: SortOption[];
+  aggregationFields?: AggregationField[];
+  index?: string;
 };
 
 export type EsSearchResult = {

src/utils/server/apiFunctions.ts

@@ -1,5 +1,10 @@
+import type {
+  QueryDslQueryContainer,
+  SearchRequest,
+} from "@elastic/elasticsearch/lib/api/types";
+
 import { aggregatorSize } from "@/config/config";
-import type { Facet, SearchQuery } from "@/types";
+import type { AggregationField, Facet, SearchQuery } from "@/types";
 
 const FIELDS_TO_SEARCH = ["authors", "title", "body"];
 
@@ -18,75 +23,61 @@ export const buildQuery = ({
   from,
   filterFields,
   sortFields,
+  aggregationFields = [],
 }: BuildQueryForElaSticClient) => {
   // Initialize the base structure of the Elasticsearch query
-  let baseQuery = {
+  let baseQuery: SearchRequest = {
     query: {
       bool: {
         must: [],
         should: [],
         filter: [],
-        must_not: [
-          {
-            term: {
-              "type.keyword": "combined-summary",
-            },
-          },
-        ],
+        must_not: [],
       },
     },
     sort: [],
-    aggs: {
-      authors: {
-        terms: {
-          field: "authors.keyword",
-          size: aggregatorSize,
-        },
-      },
-      domains: {
-        terms: {
-          field: "domain.keyword",
-          size: aggregatorSize,
-        },
-      },
-      tags: {
-        terms: {
-          field: "tags.keyword",
-          size: aggregatorSize,
-        },
-      },
-    },
+    aggs: {},
     size, // Number of search results to return
     from, // Offset for pagination (calculated from page number)
     _source: {
       excludes: ["summary_vector_embeddings"],
     },
   };
 
-  // Construct and add the full-text search clause
-  let shouldClause = buildShouldQueryClause(queryString);
-  if (!queryString) {
-    baseQuery.query.bool.should.push(shouldClause);
-  } else {
-    baseQuery.query.bool.must.push(shouldClause);
+  // Construct and add the full-text search query if provided
+  if (queryString) {
+    (baseQuery.query.bool.must as QueryDslQueryContainer[]).push(
+      buildShouldQueryClause(queryString)
+    );
   }
 
-  // Add filter clauses for each specified filter field
-  if (filterFields && filterFields.length) {
-    for (let facet of filterFields) {
-      let mustClause = buildFilterQueryClause(facet);
-      baseQuery.query.bool.must.push(mustClause);
+  // Handle filters with exclusions and array values
+  if (filterFields?.length) {
+    for (const filter of filterFields) {
+      const filterClause = buildFilterQueryClause(filter);
+
+      if (filter.operation === "exclude") {
+        (baseQuery.query.bool.must_not as QueryDslQueryContainer[]).push(
+          filterClause
+        );
+      } else {
+        (baseQuery.query.bool.must as QueryDslQueryContainer[]).push(
+          filterClause
+        );
+      }
     }
   }
 
   // Add sorting clauses for each specified sort field
   if (sortFields && sortFields.length) {
     for (let field of sortFields) {
       const sortClause = buildSortClause(field);
-      baseQuery.sort.push(sortClause);
+      (baseQuery.sort as QueryDslQueryContainer[]).push(sortClause);
     }
   }
 
+  // Add aggregations
+  baseQuery.aggs = buildAggregations(aggregationFields);
   return baseQuery;
 };
 
@@ -103,14 +94,23 @@ const buildShouldQueryClause = (queryString: string) => {
 };
 
 // Helper to build filter query clauses based on facets
-const buildFilterQueryClause = ({ field, value }: Facet) => {
-  let filterQueryClause = {
-    term: {
-      [`${field}.keyword`]: { value },
-    },
-  };
+const buildFilterQueryClause = (filter: Facet): QueryDslQueryContainer => {
+  if (Array.isArray(filter.value)) {
+    // Handle OR logic for array values
+    return {
+      bool: {
+        should: filter.value.map((value) => ({
+          term: { [`${filter.field}.keyword`]: value },
+        })),
+        minimum_should_match: 1,
+      },
+    };
+  }
 
-  return filterQueryClause;
+  // Handle non-array values
+  return {
+    term: { [`${filter.field}.keyword`]: filter.value },
+  };
 };
 
 // Helper to build sort clauses for sorting results
@@ -119,3 +119,25 @@ const buildSortClause = ({ field, value }: { field: any; value: any }) => {
     [field]: value,
   };
 };
+
+// Helper to build aggregations
+const buildAggregations = (fields: AggregationField[]) => {
+  const aggs = {};
+
+  fields.forEach((aggregation) => {
+    // Create the base terms aggregation
+    aggs[aggregation.field] = {
+      terms: {
+        field: `${aggregation.field}.keyword`,
+        size: aggregation.size || aggregatorSize,
+      },
+    };
+
+    // If there are sub-aggregations, add them directly to the terms agg
+    if (aggregation.subAggregations) {
+      aggs[aggregation.field].aggs = aggregation.subAggregations;
+    }
+  });
+
+  return aggs;
+};