ES Querying API changes

desci-server/src/controllers/search/multiQuery.ts

@@ -10,88 +10,95 @@ import {
   VALID_ENTITIES,
 } from '../../services/ElasticSearchService.js';
 
-import { QueryDebuggingResponse, SingleQueryErrorResponse, SingleQuerySuccessResponse } from './query.js';
-
-type Entity = string;
-type Query = string;
+import { Entity, Filter, Query, QueryDebuggingResponse, QueryErrorResponse, QuerySuccessResponse } from './types.js';
 
 type QueryObject = Record<Entity, Query>;
 
 interface MultiQuerySearchParams {
   queries: QueryObject[];
+  filters?: Filter[];
   fuzzy?: number;
-  sortType?: string;
-  sortOrder?: 'asc' | 'desc';
-  page?: number;
-  perPage?: number;
+  sort?: {
+    field: string;
+    order: 'asc' | 'desc';
+  };
+  pagination?: {
+    page: number;
+    perPage: number;
+  };
 }
 
 export const multiQuery = async (
   req: Request<any, any, MultiQuerySearchParams>,
-  res: Response<(SingleQuerySuccessResponse & QueryDebuggingResponse) | SingleQueryErrorResponse>,
+  res: Response<(QuerySuccessResponse & QueryDebuggingResponse) | QueryErrorResponse>,
 ) => {
   const {
     queries,
     fuzzy,
-    sortType = 'relevance',
-    sortOrder,
-    page = 1,
-    perPage = 10,
+    filters,
+    sort = { field: '_score', order: 'desc' },
+    pagination = { page: 1, perPage: 10 },
   }: MultiQuerySearchParams = req.body;
   const logger = parentLogger.child({
     module: 'SEARCH::MultiQuery',
     queries,
+    filters,
     fuzzy,
-    sortType,
-    sortOrder,
-    page,
-    perPage,
+    sort,
+    pagination,
   });
 
   logger.trace({ fn: 'Executing elastic search query' });
 
   const validEntityQueries = queries.filter((q) => VALID_ENTITIES.includes(Object.keys(q)[0]));
-
   if (!validEntityQueries) {
     return res.status(400).json({
       ok: false,
       error: `Invalid queries, the following entities are supported: ${VALID_ENTITIES.join(' ')}`,
     });
   }
 
+  const primaryEntity = Object.keys(validEntityQueries[0])[0];
+
   const esQueries = validEntityQueries.map((q) => {
     const [entity, query] = Object.entries(q)[0];
-    return buildMultiMatchQuery(query, entity);
+    let fullEntity = entity;
+    if (entity !== primaryEntity) fullEntity = `${primaryEntity}_${entity}`; // e.g. if we're searching for authors in the works table, entity should be 'works_authors'
+    return buildMultiMatchQuery(query, fullEntity, fuzzy);
   });
-  const primaryEntity = Object.keys(validEntityQueries[0])[0];
-  const esSort = buildSortQuery(DENORMALIZED_WORKS_INDEX, sortType, sortOrder);
-  const esBoolQuery = buildBoolQuery(esQueries);
+
+  const esSort = buildSortQuery(DENORMALIZED_WORKS_INDEX, sort.field, sort.order);
+  const esBoolQuery = buildBoolQuery(esQueries, filters);
 
   try {
-    logger.debug({ esQueries, esSort }, 'Executing query');
+    logger.debug({ esQueries, esSort, esBoolQuery }, 'Executing query');
     const { hits } = await elasticClient.search({
       index: DENORMALIZED_WORKS_INDEX,
       body: {
         ...esBoolQuery,
         sort: esSort,
-        from: (page - 1) * perPage,
-        size: perPage,
+        from: (pagination.page - 1) * pagination.perPage,
+        size: pagination.perPage,
       },
     });
 
     logger.info({ fn: 'Elastic search multi query executed successfully' });
-
     return res.json({
-      // esQueries,
+      esQueries,
+      esBoolQuery,
+      esSort,
       ok: true,
       total: hits.total,
-      page,
-      perPage,
+      page: pagination.page,
+      perPage: pagination.perPage,
       data: hits.hits,
     });
   } catch (error) {
     logger.error({ error }, 'Elastic search multi query failed');
     return res.status(500).json({
+      esQueries,
+      esBoolQuery,
+      esSort,
       ok: false,
       error: 'An error occurred while searching',
     });

desci-server/src/controllers/search/query.ts

@@ -1,69 +1,55 @@
-import { SearchTotalHits } from '@elastic/elasticsearch/lib/api/types.js';
 import { Request, Response } from 'express';
 
 import { elasticClient } from '../../elasticSearchClient.js';
 import { logger as parentLogger } from '../../logger.js';
 import {
   buildBoolQuery,
   buildMultiMatchQuery,
-  buildSimpleStringQuery,
   buildSortQuery,
   DENORMALIZED_WORKS_INDEX,
   VALID_ENTITIES,
 } from '../../services/ElasticSearchService.js';
 
-export interface SingleQuerySuccessResponse extends QueryDebuggingResponse {
-  ok: true;
-  page: number;
-  perPage: number;
-  total: number | SearchTotalHits;
-  data: any[];
-}
-
-export interface QueryDebuggingResponse {
-  esQuery?: any;
-  esQueries?: any;
-  esSort?: any;
-}
+import { Filter, QueryErrorResponse, QuerySuccessResponse } from './types.js';
 
-export interface SingleQueryErrorResponse extends QueryDebuggingResponse {
-  ok: false;
-  error: string;
-}
-
-interface QuerySearchBodyParams {
+interface SingleQuerySearchBodyParams {
   query: string;
   entity: string;
+  filters?: Filter[];
   fuzzy?: number;
-  sortType?: string;
-  sortOrder?: 'asc' | 'desc';
-  page?: number;
-  perPage?: number;
+  sort?: {
+    field: string;
+    order: 'asc' | 'desc';
+  };
+  pagination?: {
+    page: number;
+    perPage: number;
+  };
 }
 
 export const singleQuery = async (
-  req: Request<any, any, QuerySearchBodyParams>,
-  res: Response<SingleQuerySuccessResponse | SingleQueryErrorResponse>,
+  req: Request<any, any, SingleQuerySearchBodyParams>,
+  res: Response<QuerySuccessResponse | QueryErrorResponse>,
 ) => {
-  const { query, fuzzy, sortType = 'relevance', sortOrder, page = 1, perPage = 10 }: QuerySearchBodyParams = req.body;
-
-  let { entity } = req.body;
+  const {
+    query,
+    filters = [],
+    entity,
+    fuzzy,
+    sort = { field: '_score', order: 'desc' },
+    pagination = { page: 1, perPage: 10 },
+  }: SingleQuerySearchBodyParams = req.body;
 
   const logger = parentLogger.child({
-    module: 'SEARCH::Query',
+    module: 'SEARCH::SingleQuery',
     query,
     entity,
+    filters,
     fuzzy,
-    sortType,
-    sortOrder,
-    page,
-    perPage,
+    sort,
+    pagination,
   });
-  if (entity === 'works') {
-    logger.info({ entity }, `Entity is 'works', changing to denormalized works index: ${DENORMALIZED_WORKS_INDEX}`);
-    entity = DENORMALIZED_WORKS_INDEX;
-  }
-  //
+
   logger.trace({ fn: 'Executing elastic search query' });
 
   if (!VALID_ENTITIES.includes(entity)) {
@@ -74,30 +60,37 @@ export const singleQuery = async (
   }
 
   // const esQuery = buildSimpleStringQuery(query, entity, fuzzy);
-  const esQuery = buildMultiMatchQuery(query, 'works_single', fuzzy);
-  const esSort = buildSortQuery(entity, sortType, sortOrder);
+  const tempEntity = entity === 'works' ? 'works_single' : entity; // Temp to apply boosting algo to default search
+  const esQuery = buildMultiMatchQuery(query, tempEntity, fuzzy);
+  const esBoolQuery = buildBoolQuery([esQuery], filters);
+  const esSort = buildSortQuery(entity, sort.field, sort.order);
 
   try {
-    logger.debug({ esQuery, esSort }, 'Executing query');
+    logger.debug({ esQuery, esSort, esBoolQuery }, 'Executing query');
+    const searchEntity = entity === 'works' ? DENORMALIZED_WORKS_INDEX : entity; // Temp overwrite with denormalized works index
+    if (entity === 'works')
+      logger.info({ entity }, `Entity is 'works', changing to denormalized works index: ${DENORMALIZED_WORKS_INDEX}`);
+
     const results = await elasticClient.search({
-      index: entity,
+      index: searchEntity,
       body: {
-        query: esQuery,
+        ...esBoolQuery,
         sort: esSort,
-        from: (page - 1) * perPage,
-        size: perPage,
+        from: (pagination.page - 1) * pagination.perPage,
+        size: pagination.perPage,
       },
     });
     const hits = results.hits;
-    logger.info({ fn: 'Elastic search query executed successfully' });
+    logger.info({ hitsReturned: hits.total }, 'Elastic search query executed successfully');
 
     return res.json({
       esQuery,
       esSort,
+      esBoolQuery,
       ok: true,
       total: hits.total,
-      page,
-      perPage,
+      page: pagination.page,
+      perPage: pagination.perPage,
       data: hits.hits,
     });
   } catch (error) {
@@ -107,6 +100,7 @@ export const singleQuery = async (
       error: 'An error occurred while searching',
       esQuery,
       esSort,
+      esBoolQuery,
     });
   }
 };

desci-server/src/controllers/search/types.ts

@@ -0,0 +1,37 @@
+import { SearchTotalHits } from '@elastic/elasticsearch/lib/api/types.js';
+export type Entity = string;
+export type Query = string;
+
+export type ComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
+export type FilterType = 'range' | 'term' | 'match' | 'exists';
+
+export type Filter = {
+  entity: Entity;
+  field: string;
+  type: FilterType;
+} & (
+  | { type: 'range'; operator: ComparisonOperator; value: number | string }
+  | { type: 'term'; value: string | number | boolean }
+  | { type: 'match'; value: string }
+  | { type: 'exists' }
+);
+
+export interface QuerySuccessResponse extends QueryDebuggingResponse {
+  ok: true;
+  page: number;
+  perPage: number;
+  total: number | SearchTotalHits;
+  data: any[];
+}
+
+export interface QueryDebuggingResponse {
+  esQuery?: any;
+  esQueries?: any;
+  esBoolQuery?: any;
+  esSort?: any;
+}
+
+export interface QueryErrorResponse extends QueryDebuggingResponse {
+  ok: false;
+  error: string;
+}