@lde/search-typesense 0.26.0 → 0.27.1

package/dist/query-compiler.d.ts

@@ -39,12 +39,14 @@ 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
+     * 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.
      */

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;;;;;;;;;OASG;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;AAuTD;;;;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,15 +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.
  *
- * Both readings hold **within** a clause. Neither survives a clause left with
- * no terms: it is skipped and reported to `onIgnoredFilter`, and a clause
- * missing from the conjunction constrains nothing – so a *false* criterion
- * alone in its clause still WIDENS the query. `filter_by` has no term meaning
- * “matches nothing” to compile it to instead. The engine never meets this
- * (`assertValidQuery` rejects every malformed criterion, and `isUnsatisfiable`
- * short-circuits the empty `id` membership before a query is dispatched); a
- * direct caller should read `onIgnoredFilter` firing as “this query no longer
- * asks what you asked”.
+ * 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 = [];
@@ -156,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. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "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",
@@ -31,10 +31,10 @@
     "typesense": "^3.0.6"
   },
   "devDependencies": {
-    "testcontainers": "^12.0.4"
+    "testcontainers": "^12.1.0"
   },
   "peerDependencies": {
     "@lde/dataset": "^0.7.9",
-    "@lde/pipeline": "^0.36.0"
+    "@lde/pipeline": "^0.36.1"
   }
 }