@lde/search-typesense 0.25.1 → 0.27.0

package/dist/query-compiler.d.ts

@@ -39,13 +39,16 @@ export interface BuildSearchParamsOptions {
      */
     readonly maxFacetValues?: number;
     /**
-     * Called for each `where` clause that compiles to nothing and is therefore
-     * skipped: an unknown field, an operator that does not match the field’s
-     * kind ({@link filterOperatorFor}), an empty `in` list, or a `range` with no
-     * usable bound. Skipping keeps a malformed clause from reaching the engine
-     * as garbage; supply this to log it instead of losing it silently. Through
-     * the engine, a structurally invalid query throws up front
-     * (`assertValidQuery`), so there only the vacuous clauses reach this.
+     * Called for each `where` clause that does not compile as the caller wrote
+     * it – either because it states no constraint (an empty `in` list, a `range`
+     * with no usable bound, no criteria at all) and is skipped, or because every
+     * criterion is malformed (an unknown field, an operator that does not match
+     * the field’s kind – {@link filterOperatorFor}) or unsatisfiable, leaving a
+     * clause no document can match. Supply this to log the clause instead of
+     * losing it silently; the compiled query itself is faithful either way.
+     * Through the engine, a structurally invalid query throws up front
+     * (`assertValidQuery`), so there only the clauses that state no constraint
+     * reach this.
      */
     readonly onIgnoredFilter?: (filter: Filter) => void;
 }

package/dist/query-compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-compiler.d.ts","sourceRoot":"","sources":["../src/query-compiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEzE,OAAO,EAGL,KAAK,MAAM,EACX,KAAK,QAAQ,EAEb,KAAK,WAAW,EAChB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAarB;mDACmD;AACnD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CACvB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,SAAS,MAAM,EAAE,KACpB,UAAU,GAAG,SAAS,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,wBAA6B,GACrC,YAAY,CAAC,MAAM,CAAC,CA8BtB;AAsSD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD"}
+{"version":3,"file":"query-compiler.d.ts","sourceRoot":"","sources":["../src/query-compiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEzE,OAAO,EAGL,KAAK,MAAM,EACX,KAAK,QAAQ,EAEb,KAAK,WAAW,EAChB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAarB;mDACmD;AACnD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CACvB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,SAAS,MAAM,EAAE,KACpB,UAAU,GAAG,SAAS,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,wBAA6B,GACrC,YAAY,CAAC,MAAM,CAAC,CA8BtB;AA+UD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/query-compiler.js

@@ -100,13 +100,15 @@ function queryFields(searchType, locale) {
     }
     return { names, weights };
 }
-/** AND-join the compiled `where` clauses; a clause that compiles to nothing is
- *  skipped and reported to `onIgnoredFilter`. */
+/** AND-join the compiled `where` clauses. A clause that states no constraint is
+ *  skipped; one that can match nothing compiles to {@link MATCHES_NOTHING}
+ *  rather than being skipped ({@link compileFilter}). Either way it did not
+ *  compile as written, so it is reported to `onIgnoredFilter`. */
 function compileFilterBy(where, searchType, options) {
     return where
         .map((filter) => {
         const clause = compileFilter(filter, searchType, options);
-        if (clause === undefined) {
+        if (clause === undefined || clause === MATCHES_NOTHING) {
             options.onIgnoredFilter?.(filter);
         }
         return clause;
@@ -134,8 +136,16 @@ function compileFilterBy(where, searchType, options) {
  *   unknown field, an operator that mismatches the field’s kind) is *false*, and
  *   `false || X` is X, so it drops out and its siblings still stand.
  *
- * A clause left with no terms either way is skipped and reported to
- * `onIgnoredFilter`.
+ * Which reading applies decides what a clause left with **no terms** compiles
+ * to, and the two are opposites: a vacuous clause states no constraint, so it
+ * is skipped; an all-false clause states the query can have no answer, so it
+ * compiles to {@link MATCHES_NOTHING}. Skipping that one instead would drop a
+ * conjunct and widen the query – `false` compiled as `true`. Both are reported
+ * to `onIgnoredFilter`, because neither compiles to what the caller wrote.
+ *
+ * The engine never meets either: `assertValidQuery` rejects every malformed
+ * criterion, and `isUnsatisfiable` short-circuits the empty `id` membership
+ * before a query is dispatched.
  */
 function compileFilter(filter, searchType, options) {
     const terms = [];
@@ -149,10 +159,30 @@ function compileFilter(filter, searchType, options) {
         }
     }
     if (terms.length === 0) {
-        return undefined;
+        // Every criterion was unusable, so the clause is FALSE – and `false && X`
+        // is false, however many clauses stand beside it. Leaving it out would drop
+        // a conjunct, and a conjunct missing from `filter_by` constrains nothing:
+        // the query would come back WIDER than the caller wrote, which is how a
+        // misspelled field name used to return the whole collection.
+        //
+        // A clause carrying no criteria at all says nothing rather than saying
+        // false, so it stays the vacuous no-op it reads as.
+        return filter.or.length === 0 ? undefined : MATCHES_NOTHING;
     }
     return terms.length === 1 ? terms[0] : `(${terms.join(' || ')})`;
 }
+/**
+ * The term for a clause that can match no document: an **empty identity
+ * membership** – “the document is one of no documents”. Not a sentinel value
+ * but the literal reading, and the same one {@link isUnsatisfiable} gives an
+ * empty `id` membership in the IR; Typesense answers it with zero hits.
+ *
+ * A filter language has no keyword for `false`, so this stands in for one. It
+ * must be a term the engine *applies* rather than ignores – an empty string
+ * (``id:=` ` ``) is rejected outright as a filter value, and an omitted clause
+ * is read as true.
+ */
+const MATCHES_NOTHING = `${ID_FIELD}:=[]`;
 /** A criterion that states **no constraint** – true for every document. */
 const VACUOUS = Symbol('vacuous');
 /** A criterion that matches nothing, or cannot be compiled at all – false. */
@@ -237,11 +267,21 @@ function compileMembership(field, values) {
         ? `${field.name}:=${list}`
         : `${field.name}:${list}`;
 }
-/** An inclusive Typesense range clause, or `undefined` when neither bound is set. */
+/** An inclusive Typesense range clause, or `undefined` when neither bound is
+ *  usable. Which of the two readings that is – the caller set no bounds, or the
+ *  codec rejected the ones they set – is deliberately NOT decided here: a
+ *  criterion dropped from a clause narrows the query while a clause dropped
+ *  from the conjunction widens it, so the same reading cannot be right in both
+ *  positions. `validateQuery` rejects an unreadable bound outright instead,
+ *  which is the only answer that neither widens nor narrows. */
 function compileRange(field, range) {
     const name = field.name;
-    const min = storedBound(field, range.min);
-    const max = storedBound(field, range.max);
+    // A bound a caller sent as `null` – a GraphQL variable left unfilled, which
+    // the surface passes through – is a bound NOT SET, not a bound of `null`.
+    // Read literally it reaches the engine as `datePosted:[null..…]`, which
+    // Typesense rejects outright.
+    const min = storedBound(field, range.min ?? undefined);
+    const max = storedBound(field, range.max ?? undefined);
     if (min !== undefined && max !== undefined) {
         return `${name}:[${min}..${max}]`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.25.1",
+  "version": "0.27.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.22.1",
+    "@lde/search": "^0.23.0",
     "@lde/text-normalization": "^0.1.2",
     "tslib": "^2.3.0",
     "typesense": "^3.0.6"