8798611509

Committed 23 Apr 2024 10:08AM UTC coverage: 32.032% (+0.04%) from 31.988%

Build # 8798611509

Build Type

Pull #8981

github

Committed by

oetherington

Commit Message

Hide people directory menu item for non-beta users

Pull Request Pull Request #8981: [EA] People directory

Run Details

4696 of 38271 branches covered (12.27%)

Branch coverage included in aggregate %.

256 of 610 new or added lines in 54 files covered. (41.97%)

12 existing lines in 7 files now uncovered.

27407 of 61950 relevant lines covered (44.24%)

180.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

17.62

/packages/lesswrong/server/search/elastic/ElasticQuery.ts

import type {
  QueryDslQueryContainer,
  SearchRequest as SearchRequestInfo,
  Sort,
} from "@elastic/elasticsearch/lib/api/types";
import type {
  SearchRequest as SearchRequestBody,
} from "@elastic/elasticsearch/lib/api/typesWithBodyKey";
import {
  IndexConfig,
  Ranking,
  isFullTextField,
  indexToCollectionName,
  collectionNameToConfig,
} from "./ElasticConfig";
import { parseQuery, QueryToken } from "./parseQuery";
import { searchOriginDate } from "./elasticSettings";
import { SearchIndexCollectionName } from "../../../lib/search/searchUtil";

/**
 * There a couple of places where we need a rough origin date
 * for scaling/faceting/etc. which is defined here. This needn't
 * be exact - just a date a little older than the oldest searchable
 * records.
 */
export const SEARCH_ORIGIN_DATE = new Date(searchOriginDate.get());

export type QueryFilterOperator = "gt" | "gte" | "lt" | "lte" | "eq";

export type QueryFilter = {
  field: string,
} & ({
  type: "facet",
  value: boolean | string,
  negated: boolean,
} | {
  type: "numeric",
  value: number,
  op: QueryFilterOperator,
} | {
  type: "exists"
});

export type QueryData = {
  index: string,
  sorting?: string,
  search: string
  offset?: number,
  limit?: number,
  preTag?: string,
  postTag?: string,
  filters: QueryFilter[],
  // Providing coordinates will trigger a special case, which sorts results by distance and ignores relevance
  coordinates?: number[],
}

export type Fuzziness = "AUTO" | number;

type CompiledQuery = {
  searchQuery: QueryDslQueryContainer,
  snippetName: string,
  snippetQuery?: QueryDslQueryContainer,
  highlightName?: string,
  highlightQuery?: QueryDslQueryContainer,
}

class ElasticQuery {
  private collectionName: SearchIndexCollectionName;
  private config: IndexConfig;

  constructor(
    private queryData: QueryData,
    private fuzziness: Fuzziness = 1,
  ) {
    this.collectionName = indexToCollectionName(queryData.index);
    this.config = collectionNameToConfig(this.collectionName);
  }

  compileRanking({field, order, weight, scoring}: Ranking): string {
    let expr: string;
    switch (scoring.type) {
    case "numeric":
      const min = scoring.min ?? 1;
      expr = `saturation(Math.max(${min}, doc['${field}'].value), ${scoring.pivot}L)`;
      break;
    case "date":
      const start = SEARCH_ORIGIN_DATE;
      const delta = Date.now() - start.getTime();
      const dayRange = Math.ceil(delta / (1000 * 60 * 60 * 24));
      expr = `1 - decayDateLinear('${start.toISOString()}', '${dayRange}d', '0', 0.5, doc['${field}'].value)`;
      break;
    case "bool":
      expr = `doc['${field}'].value == true ? 0.75 : 0.25`;
      break;
    }
    if (weight) {
      expr = `((${expr}) * ${weight})`;
    }
    expr = `(doc['${field}'].size() == 0 ? 0 : (${expr}))`;
    return order === "asc" ? `(1 - ${expr})` : expr;
  }

  private compileScoreExpression(): string {
    let expr = "_score";
    for (const ranking of this.config.ranking ?? []) {
      expr += " * " + this.compileRanking(ranking);
    }
    return expr;
  }

  private compileFilterTermForField(filter: QueryFilter): QueryDslQueryContainer {
    switch (filter.type) {
    case "facet":
      const term: QueryDslQueryContainer =
        isFullTextField(this.collectionName, filter.field)
          ? {
            match: {
              [`${filter.field}.exact`]: {
                query: filter.value,
                analyzer: "fm_exact_analyzer",
                operator: "AND",
                fuzziness: 0,
              },
            },
          }
          : {
            term: {
              [filter.field]: filter.value,
            },
          };
      return filter.negated
        ? {
          bool: {
            should: [],
            must_not: [term],
          },
        }
        : term;

    case "numeric":
      return {
        range: {
          [filter.field]: {
            [filter.op]: filter.value,
          },
        },
      };

    case "exists":
      return {
        bool: {
          should: [],
          must: [{
            exists: {
              field: filter.field
            }
          }]
        }
      };

    default:
      return {};
    }
  }

  private compileFilters() {
    const filtersByField: Record<string, QueryFilter[]> = {};
    for (const filter of this.queryData.filters) {
      filtersByField[filter.field] ??= [];
      filtersByField[filter.field].push(filter);
    }

    const terms = [...(this.config.filters ?? [])];

    for (const filterField in filtersByField) {
      const filters = filtersByField[filterField];
      if (!filters.length) {
        continue;
      }
      const fieldTerms = filters.map(
        (filter) => this.compileFilterTermForField(filter),
      );
      if (fieldTerms.length > 1) {
        terms.push({
          bool: {
            should: fieldTerms,
          },
        });
      } else {
        terms.push(fieldTerms[0]);
      }
    }

    return terms.length ? terms : undefined;
  }

  private getDefaultQuery(
    search: string,
    fields: string[],
  ): QueryDslQueryContainer {
    return {
      multi_match: {
        query: search,
        fields,
        fuzziness: this.fuzziness,
        max_expansions: 10,
        prefix_length: 3,
        minimum_should_match: "75%",
        operator: "or",
      },
    };
  }

  private compileSimpleQuery(): CompiledQuery {
    const {fields, snippet, highlight} = this.config;
    const {search} = this.queryData;
    const mainField = this.textFieldToExactField(fields[0], false);
    return {
      searchQuery: {
        bool: {
          should: [
            {
              term: {
                objectID: {
                  value: search,
                },
              },
            },
            this.getDefaultQuery(search, fields),
            {
              multi_match: {
                query: search,
                fields,
                type: "phrase",
                slop: 2,
                boost: 100,
              },
            },
            {
              match_phrase_prefix: {
                [mainField]: {
                  query: search,
                  boost: 1000,
                },
              },
            },
          ],
        },
      },
      snippetName: snippet,
      highlightName: highlight,
    };
  }

  private textFieldToExactField(
    textField: string,
    keepRelevance = true,
  ): string {
    const [fieldName, relevance] = textField.split("^");
    const exactField = `${fieldName}.exact`;
    return relevance && keepRelevance
      ? `${exactField}^${relevance}`
      : exactField;
  }

  private getAdvancedHighlightQuery(
    mustToken: string,
  ): Omit<CompiledQuery, "searchQuery"> {
    const {snippet, highlight} = this.config;
    const snippetName = `${snippet}.exact`;
    const highlightName = `${highlight}.exact`;
    const buildQuery = (fieldName: string) => ({
      match_phrase: {
        [fieldName]: {
          query: mustToken,
          analyzer: "simple",
        },
      },
    });
    return {
      snippetName,
      snippetQuery: buildQuery(snippetName),
      ...(highlight && {
        highlightName,
        highlightQuery: buildQuery(highlightName),
      }),
    };
  }

  private compileAdvancedQuery(tokens: QueryToken[]): CompiledQuery {
    const {fields, snippet, highlight} = this.config;

    const must: QueryDslQueryContainer[] = [];
    const must_not: QueryDslQueryContainer[] = [];
    const should: QueryDslQueryContainer[] = [];

    for (const {type, token} of tokens) {
      switch (type) {
      case "must":
        must.push({
          multi_match: {
            query: token,
            fields: fields.map((field) => this.textFieldToExactField(field)),
            type: "phrase",
          },
        });
        break;
      case "not":
        must_not.push({
          multi_match: {
            query: token,
            fields,
          },
        });
        break;
      case "should":
        should.push(this.getDefaultQuery(token, fields));
        break;
      }
    }

    const searchQuery: QueryDslQueryContainer = {
      bool: {
        must,
        must_not,
        should,
      },
    };

    if (must.length) {
      return {
        searchQuery,
        ...this.getAdvancedHighlightQuery(must[0].multi_match!.query),
      };
    }

    return {
      searchQuery,
      snippetName: snippet,
      snippetQuery: this.getDefaultQuery(
        this.queryData.search,
        this.config.fields,
      ),
      highlightName: highlight,
      highlightQuery: this.getDefaultQuery(
        this.queryData.search,
        this.config.fields,
      ),
    };
  }

  private compileEmptyQuery(): CompiledQuery {
    return {
      searchQuery: {
        match_all: {},
      },
      snippetName: "",
    };
  }

  private compileQuery(): CompiledQuery {
    const {search} = this.queryData;
    if (!search) {
      return this.compileEmptyQuery();
    }
    const {tokens, isAdvanced} = parseQuery(search);
    return isAdvanced
      ? this.compileAdvancedQuery(tokens)
      : this.compileSimpleQuery();
  }

  private compileSort(sorting?: string, coordinates?: number[]): Sort {
    // Special case:
    // When providing coordinates in the format [lng, lat], we sort by distance
    // and ignore the relevance score. See also parseLatLng()
    if (coordinates) {
      if (!this.config.locationField) {
        throw new Error("Index cannot be sorted by location");
      }
      return [
        {
          _geo_distance : {
            [this.config.locationField]: coordinates,
            order : "asc",
          },
        },
        {[this.config.tiebreaker]: {order: "desc"}},
      ];
    }

    const sort: Sort = [
      {[this.config.tiebreaker]: {order: "desc"}},
    ];

    // If we specify a custom sort (such as from the people directory) then
    // we should ignore the search _score completely when sorting
    if (sorting && sorting.indexOf(":") > 0) {
      const [field, order] = sorting.split(":");
      if (order !== "asc" && order !== "desc") {
        throw new Error("Invalid sorting order");
      }
      sort.unshift({[field]: {order}});
      return sort;
    } else {
      sort.unshift({_score: {order: "desc"}});
    }

    // There are several special sortings builtin to the main search page.
    // Note that these are used in conjunction with the search _score
    switch (sorting) {
    case "karma":
      const field = this.config.karmaField ?? "baseScore";
      sort.unshift({[field]: {order: "desc"}});
      break;
    case "newest_first":
      sort.unshift({publicDateMs: {order: "desc"}});
      break;
    case "oldest_first":
      sort.unshift({publicDateMs: {order: "asc"}});
      break;
    case "relevance":
      break;
    default:
      if (sorting) {
        throw new Error("Invalid sorting: " + sorting);
      }
    }

    return sort;
  }

  compile(): SearchRequestInfo | SearchRequestBody {
    const {
      preTag,
      postTag,
      index,
      sorting,
      offset = 0,
      limit = 10,
      coordinates,
    } = this.queryData;
    const {privateFields} = this.config;

    // When sorting by nearest-geographically we disable custom highlighting as
    // this isn't supported by elastic and causes an exception
    const hasCustomHighlight = !coordinates;

    const {
      searchQuery,
      snippetName,
      snippetQuery,
      highlightName,
      highlightQuery,
    } = this.compileQuery();
    const highlightConfig =  {
      type: "plain",
      pre_tags: [preTag ?? "<em>"],
      post_tags: [postTag ?? "</em>"],

      // This is the default value for index.highlight.max_analyzed_offset
      // which we haven't customized. If this wasn't set here or was set
      // larger than the corresponding setting on the index, then search
      // would fail entirely when results contain a poss where the
      // plain-text version of the body is larger than this.
      max_analyzed_offset: 1000000,
    };
    return {
      index,
      from: offset,
      size: limit,
      body: {
        track_scores: true,
        track_total_hits: true,
        ...(hasCustomHighlight && {
          highlight: {
            fields: {
              [snippetName]: {
                ...highlightConfig,
                highlight_query: snippetQuery,
              },
              ...(highlightName && {
                [highlightName]: {
                  ...highlightConfig,
                  highlight_query: highlightQuery,
                },
              }),
            },
            number_of_fragments: 1,
            fragment_size: 140,
            no_match_size: 140,
          },
        }),
        query: {
          script_score: {
            query: {
              bool: {
                must: searchQuery,
                should: [],
                filter: this.compileFilters(),
              },
            },
            script: {
              source: this.compileScoreExpression(),
            },
          },
        },
        sort: this.compileSort(sorting, coordinates),
        _source: {
          excludes: ["exportedAt", ...privateFields],
        },
      },
    };
  }
}

export default ElasticQuery;

1	import type {	72✔
2	QueryDslQueryContainer,
3	SearchRequest as SearchRequestInfo,
4	Sort,
5	} from "@elastic/elasticsearch/lib/api/types";
6	import type {
7	SearchRequest as SearchRequestBody,
8	} from "@elastic/elasticsearch/lib/api/typesWithBodyKey";
9	import {
10	IndexConfig,
11	Ranking,
12	isFullTextField,
13	indexToCollectionName,
14	collectionNameToConfig,
15	} from "./ElasticConfig";	21✔
16	import { parseQuery, QueryToken } from "./parseQuery";	21✔
17	import { searchOriginDate } from "./elasticSettings";	21✔
18	import { SearchIndexCollectionName } from "../../../lib/search/searchUtil";
19
20	/**
21	* There a couple of places where we need a rough origin date
22	* for scaling/faceting/etc. which is defined here. This needn't
23	* be exact - just a date a little older than the oldest searchable
24	* records.
25	*/
26	export const SEARCH_ORIGIN_DATE = new Date(searchOriginDate.get());	21✔
27
28	export type QueryFilterOperator = "gt" \| "gte" \| "lt" \| "lte" \| "eq";
29
30	export type QueryFilter = {
31	field: string,
32	} & ({
33	type: "facet",
34	value: boolean \| string,
35	negated: boolean,
36	} \| {
37	type: "numeric",
38	value: number,
39	op: QueryFilterOperator,
40	} \| {
41	type: "exists"
42	});
43
44	export type QueryData = {
45	index: string,
46	sorting?: string,
47	search: string
48	offset?: number,
49	limit?: number,
50	preTag?: string,
51	postTag?: string,
52	filters: QueryFilter[],
53	// Providing coordinates will trigger a special case, which sorts results by distance and ignores relevance
54	coordinates?: number[],
55	}
56
57	export type Fuzziness = "AUTO" \| number;
58
59	type CompiledQuery = {
60	searchQuery: QueryDslQueryContainer,
61	snippetName: string,
62	snippetQuery?: QueryDslQueryContainer,
63	highlightName?: string,
64	highlightQuery?: QueryDslQueryContainer,
65	}
66
67	class ElasticQuery {
68	private collectionName: SearchIndexCollectionName;
69	private config: IndexConfig;
70
71	constructor(
72	private queryData: QueryData,	7✔
73	private fuzziness: Fuzziness = 1,	7✔
74	) {
75	this.collectionName = indexToCollectionName(queryData.index);	7✔
76	this.config = collectionNameToConfig(this.collectionName);	7✔
77	}
78
79	compileRanking({field, order, weight, scoring}: Ranking): string {
80	let expr: string;
81	switch (scoring.type) {	7✔
82	case "numeric":
83	const min = scoring.min ?? 1;	3!
84	expr = `saturation(Math.max(${min}, doc['${field}'].value), ${scoring.pivot}L)`;	3✔
85	break;	3✔
86	case "date":
87	const start = SEARCH_ORIGIN_DATE;	2✔
88	const delta = Date.now() - start.getTime();	2✔
89	const dayRange = Math.ceil(delta / (1000 * 60 * 60 * 24));	2✔
90	expr = `1 - decayDateLinear('${start.toISOString()}', '${dayRange}d', '0', 0.5, doc['${field}'].value)`;	2✔
91	break;	2✔
92	case "bool":
93	expr = `doc['${field}'].value == true ? 0.75 : 0.25`;	2✔
94	break;	2✔
95	}
96	if (weight) {	7✔
97	expr = `((${expr}) * ${weight})`;	1✔
98	}
99	expr = `(doc['${field}'].size() == 0 ? 0 : (${expr}))`;	7✔
100	return order === "asc" ? `(1 - ${expr})` : expr;	7✔
101	}
102
103	private compileScoreExpression(): string {
104	let expr = "_score";	×
105	for (const ranking of this.config.ranking ?? []) {	×
106	expr += " * " + this.compileRanking(ranking);	×
107	}
108	return expr;	×
109	}
110
111	private compileFilterTermForField(filter: QueryFilter): QueryDslQueryContainer {
NEW 112	switch (filter.type) {	×
113	case "facet":
NEW 114	const term: QueryDslQueryContainer =	×
115	isFullTextField(this.collectionName, filter.field)
116	? {	×
117	match: {
118	[`${filter.field}.exact`]: {
119	query: filter.value,
120	analyzer: "fm_exact_analyzer",
121	operator: "AND",
122	fuzziness: 0,
123	},
124	},
125	}
126	: {
127	term: {
128	[filter.field]: filter.value,
129	},
130	};
NEW 131	return filter.negated	×
132	? {	×
133	bool: {
134	should: [],
135	must_not: [term],
136	},
137	}
138	: term;
139
140	case "numeric":
NEW 141	return {	×
142	range: {
143	[filter.field]: {
144	[filter.op]: filter.value,
145	},
146	},
147	};
148
149	case "exists":
NEW 150	return {	×
151	bool: {
152	should: [],
153	must: [{
154	exists: {
155	field: filter.field
156	}
157	}]
158	}
159	};
160
161	default:
NEW 162	return {};	×
163	}
164	}
165
166	private compileFilters() {
NEW 167	const filtersByField: Record<string, QueryFilter[]> = {};	×
NEW 168	for (const filter of this.queryData.filters) {	×
NEW 169	filtersByField[filter.field] ??= [];	×
NEW 170	filtersByField[filter.field].push(filter);	×
171	}
172
NEW 173	const terms = [...(this.config.filters ?? [])];	×
174
NEW 175	for (const filterField in filtersByField) {	×
NEW 176	const filters = filtersByField[filterField];	×
NEW 177	if (!filters.length) {	×
NEW 178	continue;	×
179	}
NEW 180	const fieldTerms = filters.map(	×
NEW 181	(filter) => this.compileFilterTermForField(filter),	×
182	);
NEW 183	if (fieldTerms.length > 1) {	×
UNCOV 184	terms.push({	×
185	bool: {
186	should: fieldTerms,
187	},
188	});
189	} else {
NEW 190	terms.push(fieldTerms[0]);	×
191	}
192	}
193
UNCOV 194	return terms.length ? terms : undefined;	×
195	}
196
197	private getDefaultQuery(
198	search: string,
199	fields: string[],
200	): QueryDslQueryContainer {
201	return {	×
202	multi_match: {
203	query: search,
204	fields,
205	fuzziness: this.fuzziness,
206	max_expansions: 10,
207	prefix_length: 3,
208	minimum_should_match: "75%",
209	operator: "or",
210	},
211	};
212	}
213
214	private compileSimpleQuery(): CompiledQuery {
215	const {fields, snippet, highlight} = this.config;	×
216	const {search} = this.queryData;	×
217	const mainField = this.textFieldToExactField(fields[0], false);	×
218	return {	×
219	searchQuery: {
220	bool: {
221	should: [
222	{
223	term: {
224	objectID: {
225	value: search,
226	},
227	},
228	},
229	this.getDefaultQuery(search, fields),
230	{
231	multi_match: {
232	query: search,
233	fields,
234	type: "phrase",
235	slop: 2,
236	boost: 100,
237	},
238	},
239	{
240	match_phrase_prefix: {
241	[mainField]: {
242	query: search,
243	boost: 1000,
244	},
245	},
246	},
247	],
248	},
249	},
250	snippetName: snippet,
251	highlightName: highlight,
252	};
253	}
254
255	private textFieldToExactField(
256	textField: string,
257	keepRelevance = true,	×
258	): string {
259	const [fieldName, relevance] = textField.split("^");	×
260	const exactField = `${fieldName}.exact`;	×
261	return relevance && keepRelevance	×
262	? `${exactField}^${relevance}`	×
263	: exactField;
264	}
265
266	private getAdvancedHighlightQuery(
267	mustToken: string,
268	): Omit<CompiledQuery, "searchQuery"> {
269	const {snippet, highlight} = this.config;	×
270	const snippetName = `${snippet}.exact`;	×
271	const highlightName = `${highlight}.exact`;	×
272	const buildQuery = (fieldName: string) => ({	×
273	match_phrase: {
274	[fieldName]: {
275	query: mustToken,
276	analyzer: "simple",
277	},
278	},
279	});
280	return {	×
281	snippetName,
282	snippetQuery: buildQuery(snippetName),
283	...(highlight && {	×
284	highlightName,
285	highlightQuery: buildQuery(highlightName),
286	}),
287	};
288	}
289
290	private compileAdvancedQuery(tokens: QueryToken[]): CompiledQuery {
291	const {fields, snippet, highlight} = this.config;	×
292
293	const must: QueryDslQueryContainer[] = [];	×
294	const must_not: QueryDslQueryContainer[] = [];	×
295	const should: QueryDslQueryContainer[] = [];	×
296
297	for (const {type, token} of tokens) {	×
298	switch (type) {	×
299	case "must":
300	must.push({	×
301	multi_match: {
302	query: token,
303	fields: fields.map((field) => this.textFieldToExactField(field)),	×
304	type: "phrase",
305	},
306	});
307	break;	×
308	case "not":
309	must_not.push({	×
310	multi_match: {
311	query: token,
312	fields,
313	},
314	});
315	break;	×
316	case "should":
317	should.push(this.getDefaultQuery(token, fields));	×
318	break;	×
319	}
320	}
321
322	const searchQuery: QueryDslQueryContainer = {	×
323	bool: {
324	must,
325	must_not,
326	should,
327	},
328	};
329
330	if (must.length) {	×
331	return {	×
332	searchQuery,
333	...this.getAdvancedHighlightQuery(must[0].multi_match!.query),
334	};
335	}
336
337	return {	×
338	searchQuery,
339	snippetName: snippet,
340	snippetQuery: this.getDefaultQuery(
341	this.queryData.search,
342	this.config.fields,
343	),
344	highlightName: highlight,
345	highlightQuery: this.getDefaultQuery(
346	this.queryData.search,
347	this.config.fields,
348	),
349	};
350	}
351
352	private compileEmptyQuery(): CompiledQuery {
353	return {	×
354	searchQuery: {
355	match_all: {},
356	},
357	snippetName: "",
358	};
359	}
360
361	private compileQuery(): CompiledQuery {
362	const {search} = this.queryData;	×
363	if (!search) {	×
364	return this.compileEmptyQuery();	×
365	}
366	const {tokens, isAdvanced} = parseQuery(search);	×
367	return isAdvanced	×
368	? this.compileAdvancedQuery(tokens)	×
369	: this.compileSimpleQuery();
370	}
371
372	private compileSort(sorting?: string, coordinates?: number[]): Sort {
373	// Special case:
374	// When providing coordinates in the format [lng, lat], we sort by distance
375	// and ignore the relevance score. See also parseLatLng()
376	if (coordinates) {	×
377	if (!this.config.locationField) {	×
378	throw new Error("Index cannot be sorted by location");	×
379	}
380	return [	×
381	{
382	_geo_distance : {
383	[this.config.locationField]: coordinates,
384	order : "asc",
385	},
386	},
387	{[this.config.tiebreaker]: {order: "desc"}},
388	];
389	}
390
UNCOV 391	const sort: Sort = [	×
392	{[this.config.tiebreaker]: {order: "desc"}},
393	];
394
395	// If we specify a custom sort (such as from the people directory) then
396	// we should ignore the search _score completely when sorting
NEW 397	if (sorting && sorting.indexOf(":") > 0) {	×
NEW 398	const [field, order] = sorting.split(":");	×
NEW 399	if (order !== "asc" && order !== "desc") {	×
NEW 400	throw new Error("Invalid sorting order");	×
401	}
NEW 402	sort.unshift({[field]: {order}});	×
NEW 403	return sort;	×
404	} else {
NEW 405	sort.unshift({_score: {order: "desc"}});	×
406	}
407
408	// There are several special sortings builtin to the main search page.
409	// Note that these are used in conjunction with the search _score
UNCOV 410	switch (sorting) {	×
411	case "karma":
412	const field = this.config.karmaField ?? "baseScore";	×
413	sort.unshift({[field]: {order: "desc"}});	×
414	break;	×
415	case "newest_first":
416	sort.unshift({publicDateMs: {order: "desc"}});	×
417	break;	×
418	case "oldest_first":
419	sort.unshift({publicDateMs: {order: "asc"}});	×
420	break;	×
421	case "relevance":
422	break;	×
423	default:
424	if (sorting) {	×
425	throw new Error("Invalid sorting: " + sorting);	×
426	}
427	}
428
UNCOV 429	return sort;	×
430	}
431
432	compile(): SearchRequestInfo \| SearchRequestBody {
433	const {
434	preTag,
435	postTag,
436	index,
437	sorting,
438	offset = 0,	×
439	limit = 10,	×
440	coordinates,
441	} = this.queryData;	×
442	const {privateFields} = this.config;	×
443
444	// When sorting by nearest-geographically we disable custom highlighting as
445	// this isn't supported by elastic and causes an exception
446	const hasCustomHighlight = !coordinates;	×
447
448	const {
449	searchQuery,
450	snippetName,
451	snippetQuery,
452	highlightName,
453	highlightQuery,
454	} = this.compileQuery();	×
455	const highlightConfig = {	×
456	type: "plain",
457	pre_tags: [preTag ?? "<em>"],	×
458	post_tags: [postTag ?? "</em>"],	×
459
460	// This is the default value for index.highlight.max_analyzed_offset
461	// which we haven't customized. If this wasn't set here or was set
462	// larger than the corresponding setting on the index, then search
463	// would fail entirely when results contain a poss where the
464	// plain-text version of the body is larger than this.
465	max_analyzed_offset: 1000000,
466	};
467	return {	×
468	index,
469	from: offset,
470	size: limit,
471	body: {
472	track_scores: true,
473	track_total_hits: true,
474	...(hasCustomHighlight && {	×
475	highlight: {
476	fields: {
477	[snippetName]: {
478	...highlightConfig,
479	highlight_query: snippetQuery,
480	},
481	...(highlightName && {	×
482	[highlightName]: {
483	...highlightConfig,
484	highlight_query: highlightQuery,
485	},
486	}),
487	},
488	number_of_fragments: 1,
489	fragment_size: 140,
490	no_match_size: 140,
491	},
492	}),
493	query: {
494	script_score: {
495	query: {
496	bool: {
497	must: searchQuery,
498	should: [],
499	filter: this.compileFilters(),
500	},
501	},
502	script: {
503	source: this.compileScoreExpression(),
504	},
505	},
506	},
507	sort: this.compileSort(sorting, coordinates),
508	_source: {
509	excludes: ["exportedAt", ...privateFields],
510	},
511	},
512	};
513	}
514	}
515
516	export default ElasticQuery;	21✔

ForumMagnum / ForumMagnum / 8798611509

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous