@lde/search-typesense 0.36.1 → 0.37.0

package/dist/search.d.ts

@@ -69,8 +69,8 @@ export interface LabelSource {
  * reference field from its own label source’s collection, all sources bundled
  * into one lookup – and reconstructs the engine-neutral
  * {@link SearchResult} ({@link parseSearchResponse}). `searchFacets` answers
- * a whole facet batch (e.g. a faceted listing’s skip-own-filter query variants) as a
- * single `multi_search` round-trip with one shared label lookup; a failed
+ * a whole facet batch (e.g. a faceted listing’s skip-own-filter query variants) in
+ * one `multi_search` round-trip with one shared label lookup; a failed
  * entry is reported in place as a per-query outcome, so it never discards
  * its siblings’ facets. Every engine specific stays here; consumers see only
  * logical documents.

package/dist/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"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"}

package/dist/search.js

@@ -1,5 +1,5 @@
 import { NESTED_DOCUMENT_TYPE, } from '@lde/search';
-import { assertTypeInSchema, assertValidQuery, displayLangOf, facetableFields, fieldNamed, isInlineReference, isBinnedRangeFacet, isUnsatisfiable, joinGraph, labelFieldOf, labelSourceNamesOf, labelTargetNamesOf, localLookupTargetsOf, nestedReferenceType, outputFields, physicalFields, referencedTargetsOf, referenceFields, storedTargetOf, } from '@lde/search/adapter';
+import { assertTypeInSchema, assertValidQuery, displayLangOf, facetableFields, facetSearches, fieldNamed, filterOn, inheritedFacetPolicies, isInlineReference, isBinnedRangeFacet, isUnsatisfiable, joinGraph, labelFieldOf, labelSourceNamesOf, labelTargetNamesOf, localLookupTargetsOf, nestedReferenceType, outputFields, physicalFields, referencedTargetsOf, referenceFields, storedTargetOf, } from '@lde/search/adapter';
 import { buildSearchParams, escapeFilterValue, } from './query-compiler.js';
 import { deriveCollectionName } from './collection-name.js';
 import { resolveProjection, } from './lookup.js';
@@ -13,8 +13,8 @@ import { resolveProjection, } from './lookup.js';
  * reference field from its own label source’s collection, all sources bundled
  * into one lookup – and reconstructs the engine-neutral
  * {@link SearchResult} ({@link parseSearchResponse}). `searchFacets` answers
- * a whole facet batch (e.g. a faceted listing’s skip-own-filter query variants) as a
- * single `multi_search` round-trip with one shared label lookup; a failed
+ * a whole facet batch (e.g. a faceted listing’s skip-own-filter query variants) in
+ * one `multi_search` round-trip with one shared label lookup; a failed
  * entry is reported in place as a per-query outcome, so it never discards
  * its siblings’ facets. Every engine specific stays here; consumers see only
  * logical documents.
@@ -220,6 +220,63 @@ export function createTypesenseSearchEngine(client, schema, options = {}) {
             return new Map();
         }
     }
+    /**
+     * Answer the searches each caller’s query needs and fold them back into one
+     * response per caller: the hits and total of its first search, the facets
+     * of all. The searches travel together in one `multi_search` round-trip
+     * (split into requests of {@link MULTI_SEARCH_LIMIT}) – a POST, so a long
+     * `filter_by` (a batch `id` lookup, any membership over many IRIs) is
+     * bounded by the caller’s request, not by Typesense’s 4000-char
+     * query-string limit. A search asking for no document is answered empty
+     * without being sent: its only filter would compile away and hand back the
+     * whole collection ({@link isUnsatisfiable}). Each facet then reports the
+     * values its search selected ({@link withSelectedValues}).
+     *
+     * A failed search fails exactly its caller, which gets an `Error` in its
+     * place; only the transport failing rejects.
+     */
+    async function answer(searchType, callers) {
+        const collection = collections.get(searchType.class);
+        const planned = callers.flat();
+        const dispatched = planned.filter(({ query }) => !isUnsatisfiable(query));
+        const results = await performInChunks(client, dispatched.map(({ query }) => ({
+            collection,
+            ...buildSearchParams(query, searchType, searchParamsOptions),
+        })));
+        const transportFailure = results.find((result) => result instanceof Error);
+        if (transportFailure !== undefined) {
+            throw transportFailure;
+        }
+        const declaredNames = declaredFacetNames.get(searchType.class);
+        let entry = 0;
+        const responses = planned.map((search) => {
+            if (isUnsatisfiable(search.query)) {
+                return EMPTY_RESPONSE;
+            }
+            const result = results[entry++];
+            return result === undefined || 'error' in result
+                ? searchError(collection, search, result)
+                : withDeclaredFacetNames(result, declaredNames);
+        });
+        const completed = await withSelectedValues(client, collection, searchType, planned.map((search, index) => ({
+            ...search,
+            response: responses[index],
+        })), searchParamsOptions);
+        let next = 0;
+        return callers.map((searches) => {
+            const own = completed.slice(next, (next += searches.length));
+            const failed = own.find((response) => response instanceof Error);
+            if (failed !== undefined) {
+                return failed;
+            }
+            const answered = own;
+            const [first = EMPTY_RESPONSE] = answered;
+            return {
+                ...first,
+                facet_counts: answered.flatMap((response) => response.facet_counts ?? []),
+            };
+        });
+    }
     const engine = {
         schema,
         collectionNameFor(searchType) {
@@ -232,21 +289,27 @@ export function createTypesenseSearchEngine(client, schema, options = {}) {
             // rejected up front, for EVERY caller.
             assertTypeInSchema(schema, searchType);
             assertValidQuery(query, searchType, schema, joins);
-            // Asks for no document (an empty `id` membership): answer it without a
-            // round-trip rather than dispatching a query whose only filter compiles
-            // away, which would hand back the whole collection.
-            if (isUnsatisfiable(query)) {
-                return { total: 0, hits: [], facets: {} };
-            }
-            const params = buildSearchParams(query, searchType, searchParamsOptions);
             const cachedLabelsPromise = startCachedLabels(searchType);
-            // ONE search, but through `multi_search` (POST) like the facet batch and
-            // the label lookup: `documents().search()` is a GET, so a long
-            // `filter_by` – a batch `id` lookup, or any membership over many IRIs –
-            // would overflow Typesense's 4000-char query-string limit. POST puts it
-            // in the body, so the filter is bounded by the caller's request, not by
-            // the URL.
-            const response = withDeclaredFacetNames(await performSingleSearch(client, collections.get(searchType.class), params), declaredFacetNames.get(searchType.class));
+            // The hits come from the query as asked, carrying the facets that share
+            // its `where`; each own-filtered facet is counted by a search of its own
+            // (`facetSearches`), in the same round-trip.
+            const searches = facetSearches(query);
+            const shared = searches.find((search) => search.own === undefined);
+            const [response] = await answer(searchType, [
+                [
+                    {
+                        query: { ...query, facets: shared?.query.facets ?? [] },
+                        selected: {},
+                        facetOnly: false,
+                    },
+                    ...searches
+                        .filter((search) => search !== shared)
+                        .map(facetOnlySearch),
+                ],
+            ]);
+            if (response instanceof Error) {
+                throw response;
+            }
             const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups([response], labelSources.get(searchType.class), outputReferenceSources.get(searchType.class) ?? [], distinctLabelSources.get(searchType.class) ?? []));
             // What the caller asked to resolve, level by level. Independent of the
             // label lookup above: that one serves facet buckets and unprojected
@@ -262,56 +325,22 @@ export function createTypesenseSearchEngine(client, schema, options = {}) {
             if (queries.length === 0) {
                 return [];
             }
-            const collection = collections.get(searchType.class);
             const cachedLabelsPromise = startCachedLabels(searchType);
-            // A query asking for no document faces the same inversion as in
-            // `search()`: its only filter would compile away and it would count
-            // facets over the whole collection. Such a query is answered with empty
-            // facets and kept OUT of the batch, so `dispatched` maps each sent search
-            // back to its caller position.
-            const dispatched = queries
-                .map((query, index) => ({ query, index }))
-                .filter(({ query }) => !isUnsatisfiable(query));
-            if (dispatched.length === 0) {
-                return queries.map(() => ({ facets: {} }));
-            }
-            // The whole batch travels as ONE multi_search round-trip. Each query
-            // compiles as facet-only regardless of what it carries: no hits
+            // Every search of every query travels in one multi_search round-trip,
+            // each facet-only regardless of what its query carries: no hits
             // (per_page 0) and no ordering – nothing is transferred or sorted that
             // this method cannot return.
-            const { results: rawResults } = (await client.multiSearch.perform({
-                searches: dispatched.map(({ query }) => ({
-                    collection,
-                    ...buildSearchParams({ ...query, orderBy: [], limit: 0, offset: 0 }, searchType, searchParamsOptions),
-                })),
-            }));
-            const declaredNames = declaredFacetNames.get(searchType.class);
-            const results = rawResults.map((result) => 'error' in result
-                ? result
-                : withDeclaredFacetNames(result, declaredNames));
+            const responses = await answer(searchType, queries.map((query) => facetSearches(query).map(facetOnlySearch)));
             // One label lookup serves every successful facet result in the batch.
-            const responses = results.filter((result) => !('error' in result));
-            const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups(responses, labelSources.get(searchType.class), outputReferenceSources.get(searchType.class) ?? [], distinctLabelSources.get(searchType.class) ?? []));
-            // multi_search reports a failed entry inline instead of rejecting the
-            // call; pass that through as a per-query outcome – naming the facets,
-            // not the position, since the batch order is the caller's internal –
-            // so one failed query never discards its siblings' facets. Every caller
-            // position is answered: a dispatched query by its entry, an
-            // unsatisfiable one by empty facets.
-            const outcomes = queries.map(() => ({ facets: {} }));
-            dispatched.forEach(({ index }, entry) => {
-                const result = results[entry];
-                outcomes[index] =
-                    result === undefined || 'error' in result
-                        ? {
-                            error: new Error(`Typesense facet search for “${queries[index].facets.join('”, “')}” failed${result?.code !== undefined ? ` (${result.code})` : ''}: ${result?.error ?? 'no result entry'}`),
-                        }
-                        : {
-                            facets: parseSearchResponse(result, searchType, labels, schema)
-                                .facets,
-                        };
-            });
-            return outcomes;
+            const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups(responses.filter((response) => !(response instanceof Error)), labelSources.get(searchType.class), outputReferenceSources.get(searchType.class) ?? [], distinctLabelSources.get(searchType.class) ?? []));
+            // A failed query is reported in place, so it never discards its
+            // siblings’ facets.
+            return responses.map((response) => response instanceof Error
+                ? { error: response }
+                : {
+                    facets: parseSearchResponse(response, searchType, labels, schema)
+                        .facets,
+                });
         },
     };
     // The runtime object is string-keyed; the literal-schema typing narrows it.
@@ -449,24 +478,179 @@ function withDeclaredFacetNames(response, declaredNames) {
         })),
     };
 }
+/** A planned facet search as sent: no hits, and with no hits no ordering. */
+function facetOnlySearch(search) {
+    return {
+        query: { ...search.query, orderBy: [], limit: 0, offset: 0 },
+        selected: search.selected,
+        facetOnly: true,
+    };
+}
+/** The error a failed or missing `multi_search` entry stands for, naming a
+ *  facet search by its facets – the batch position is the adapter’s own. */
+function searchError(collection, search, result) {
+    return entryError(search.facetOnly
+        ? `facet search for “${search.query.facets.join('”, “')}”`
+        : `search of “${collection}”`, result);
+}
+/** The error a failed or missing `multi_search` entry stands for. */
+function entryError(subject, result) {
+    return new Error(result === undefined
+        ? `Typesense ${subject} returned no result entry.`
+        : `Typesense ${subject} failed${result.code !== undefined ? ` (${result.code})` : ''}: ${result.error}`);
+}
 /**
- * Dispatch one search as a single-entry `multi_search` (POST). `multi_search`
- * reports a failed entry inline instead of rejecting the call, so the entry is
- * translated back into a throw: `search()` rejects on engine failure, and that
- * contract must not weaken just because the transport moved off GET.
+ * Send searches as `multi_search` requests of at most {@link
+ * MULTI_SEARCH_LIMIT} each, concurrently, and return their entries in order.
+ * A request that rejects rejects the whole call: the transport failed.
  */
-async function performSingleSearch(client, collection, params) {
-    const { results } = (await client.multiSearch.perform({
-        searches: [{ collection, ...params }],
-    }));
-    const [result] = results;
-    if (result === undefined) {
-        throw new Error(`Typesense search of “${collection}” returned no result entry.`);
-    }
-    if ('error' in result) {
-        throw new Error(`Typesense search of “${collection}” failed${result.code !== undefined ? ` (${result.code})` : ''}: ${result.error}`);
+async function performInChunks(client, searches) {
+    const chunks = [];
+    for (let start = 0; start < searches.length; start += MULTI_SEARCH_LIMIT) {
+        chunks.push(searches.slice(start, start + MULTI_SEARCH_LIMIT));
     }
-    return result;
+    const answered = await Promise.all(chunks.map(async (chunk) => {
+        try {
+            return (await client.multiSearch.perform({ searches: [...chunk] })).results;
+        }
+        catch (error) {
+            // The request as a whole failed: so did every search it carried, and
+            // nothing else. The Typesense client rejects with an Error.
+            return chunk.map(() => error);
+        }
+    }));
+    return answered.flat();
+}
+/** A response with nothing in it: the answer to a search that asks for no
+ *  document, which is never dispatched. */
+const EMPTY_RESPONSE = { found: 0, hits: [] };
+/** The bucket cap Typesense applies when `max_facet_values` is unset. */
+const TYPESENSE_DEFAULT_MAX_FACET_VALUES = 10;
+/** The searches Typesense accepts in one `multi_search` request by default
+ *  (`limit_multi_searches`). */
+const MULTI_SEARCH_LIMIT = 50;
+/**
+ * Each response with the values its search selected among the facet buckets,
+ * merged with the engine’s own in descending count order. A response that is
+ * already an `Error` passes through unchanged.
+ *
+ * A value missing from a facet the engine reported in full matches no
+ * document, so it gets count 0 without another search. A value missing from a
+ * facet cut off at the bucket cap, or narrowed by a facet policy, may still
+ * match documents, so it is counted by a search of its own: the search’s
+ * `where` plus that value. One search per value, because a facet search
+ * filtered on several values of a multi-valued field could cut off the very
+ * values it was asked to count. These searches travel together, in as few
+ * `multi_search` requests as Typesense accepts. The common cases (no
+ * selection, a selection with hits, a facet under the cap) cost nothing.
+ *
+ * A failed count fails exactly the response it was for, which becomes an
+ * `Error` in its place.
+ */
+async function withSelectedValues(client, collection, searchType, entries, options) {
+    const cap = options.maxFacetValues ?? TYPESENSE_DEFAULT_MAX_FACET_VALUES;
+    const missing = entries.map(({ query, selected, response }) => response instanceof Error
+        ? []
+        : Object.entries(selected).flatMap(([field, values]) => {
+            const counts = response.facet_counts?.find((facet) => facet.field_name === field)
+                ?.counts ?? [];
+            const present = new Set(counts.map((bucket) => bucket.value));
+            // A facet narrowed by a facet policy never reports a value the
+            // policy excludes, though a filter on the field still matches it:
+            // absent is no proof of 0 there either, so count it. A search that
+            // asks for no document has nothing to count.
+            const uncertain = !isUnsatisfiable(query) &&
+                (counts.length >= cap ||
+                    narrowedByPolicy(searchType, field, options));
+            return values
+                .filter((value) => !present.has(value))
+                .map((value) => ({ field, value, uncertain }));
+        }));
+    const toCount = missing.flatMap((values, entry) => values
+        .filter(({ uncertain }) => uncertain)
+        .map(({ field, value }) => ({ entry, field, value })));
+    const found = new Map();
+    const key = (entry, field, value) => JSON.stringify([entry, field, value]);
+    const results = await performInChunks(client, toCount.map(({ entry, field, value }) => {
+        const { query } = entries[entry];
+        return {
+            collection,
+            ...buildSearchParams({
+                ...query,
+                where: [...query.where, selecting(searchType, field, value)],
+                facets: [],
+                orderBy: [],
+                limit: 0,
+                offset: 0,
+            }, searchType, options),
+        };
+    }));
+    toCount.forEach(({ entry, field, value }, index) => {
+        const result = results[index];
+        found.set(key(entry, field, value), result instanceof Error
+            ? result
+            : result === undefined || 'error' in result
+                ? entryError(`count of facet value “${value}” on “${field}”`, result)
+                : result.found);
+    });
+    return entries.map(({ response }, entry) => {
+        const values = missing[entry];
+        if (response instanceof Error || values.length === 0) {
+            return response;
+        }
+        const added = new Map();
+        for (const { field, value, uncertain } of values) {
+            // Every uncertain value was counted above.
+            const count = uncertain
+                ? found.get(key(entry, field, value))
+                : 0;
+            if (count instanceof Error) {
+                return count;
+            }
+            added.set(field, [...(added.get(field) ?? []), { value, count }]);
+        }
+        const facetCounts = response.facet_counts ?? [];
+        return {
+            ...response,
+            facet_counts: [
+                ...facetCounts.map((facet) => ({
+                    ...facet,
+                    // Merged by count: a value a policy hid can outnumber every bucket.
+                    counts: added.has(facet.field_name)
+                        ? [
+                            ...facet.counts,
+                            ...added.get(facet.field_name),
+                        ].sort(byCount)
+                        : facet.counts,
+                })),
+                // A facet the response does not carry at all: an unanswered search’s.
+                ...[...added]
+                    .filter(([field]) => !facetCounts.some((facet) => facet.field_name === field))
+                    .map(([field, counts]) => ({
+                    field_name: field,
+                    counts: counts.sort(byCount),
+                })),
+            ],
+        };
+    });
+}
+/** The clause that selects one facet value: `is` on a boolean, `in` on
+ *  anything else. */
+function selecting(searchType, field, value) {
+    return filterOn(fieldNamed(searchType, field)?.kind === 'boolean'
+        ? { field, is: value === 'true' }
+        : { field, in: [value] });
+}
+/** Orders buckets by descending count, as the engine orders its own. */
+function byCount(first, second) {
+    return second.count - first.count;
+}
+/** Whether a facet policy narrows the facet on `name` ({@link
+ *  inheritedFacetPolicies}), so its buckets leave out values its field holds. */
+function narrowedByPolicy(searchType, name, options) {
+    const field = fieldNamed(searchType, name);
+    return (field !== undefined &&
+        inheritedFacetPolicies(field, options.schema).size > 0);
 }
 /**
  * Resolve labels from each group’s label-source collection. Labels are

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.36.1",
+  "version": "0.37.0",
   "description": "Typesense implementation of the @lde/search SearchEngine port: collection-schema builder, query compiler, label-resolving result reconstruction, and blue/green index lifecycle. Engine-specific (Typesense) but domain-agnostic.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -25,7 +25,7 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/search": "^0.30.0",
+    "@lde/search": "^0.31.0",
     "@lde/text-normalization": "^0.2.0",
     "tslib": "^2.3.0",
     "typesense": "^3.1.1"