@lde/search-typesense 0.29.0 → 0.29.2

package/dist/collection-definition.js

@@ -145,7 +145,11 @@ function typesenseFields(searchType, field, defaultLocale, defaultSortingField,
     const nested = nestedTypeOf(searchType, field, schema);
     if (nested !== undefined) {
         return [
-            ...nestedFields(field.name, field, nested, schema, defaultLocale),
+            ...nestedFields(field.name, field, nested, schema, defaultLocale, false, 
+            // The declaring type is already on the path, exactly as the frame and
+            // the extraction seed theirs, so a lookup back to it is cut at the
+            // same depth here as it is there.
+            new Set([searchType.name])),
             ...identityCompanionFields(field, schema),
         ];
     }
@@ -287,10 +291,30 @@ function nestedFields(prefix, reference, nestedType, schema, defaultLocale, with
         }
         const deeper = nestedTypeOfNestedField(field, schema);
         if (deeper !== undefined && walked.has(deeper.name)) {
-            // The cycle stops here, and so does the frame – nothing will ever be
-            // stored under this field, so nothing is declared for it. Falling
-            // through would declare it as a LEAF, whose scalar type is not what a
-            // nested object would be stored as.
+            // The cycle stops here, and so does the frame – but a value is still
+            // stored: the extraction falls back to the target's key hop, and the
+            // projection writes the referent as an `{id}` object beside its identity
+            // leaf. So the BOUNDARY is declared and only the descent stops. Falling
+            // through instead would declare the field as a LEAF, whose scalar type
+            // is not what a nested object is stored as.
+            const boundary = nestedFieldName(prefix, field.name);
+            const boundaryArray = flattensToArray || field.array === true;
+            children.push({
+                name: boundary,
+                type: boundaryArray ? 'object[]' : 'object',
+                // Nothing under it is indexed – the key is a stored value, and the
+                // leaf a filter welds on sits beside the object, not inside it.
+                index: false,
+                optional: true,
+            }, {
+                // Always a Root Type, so always identified: `searchSchema` rejects
+                // inline cycles, so the only way to arrive at a type already on the
+                // path is a `local` lookup, whose target declares a class.
+                name: nestedFieldName(boundary, 'id'),
+                type: boundaryArray ? 'string[]' : 'string',
+                index: false,
+                optional: true,
+            }, ...nestedIdentityFields(prefix, field, schema));
             continue;
         }
         if (deeper !== undefined) {

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,YAAY,EACjB,KAAK,UAAU,EAIhB,MAAM,aAAa,CAAC;AAmBrB;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,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;;;;;;;;;;;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,CAkCtB;AAwfD;;;;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,YAAY,EACjB,KAAK,UAAU,EAIhB,MAAM,aAAa,CAAC;AAmBrB;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,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;;;;;;;;;;;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,CAkCtB;AA4fD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/query-compiler.js

@@ -99,12 +99,11 @@ function queryFields(searchType, locale, schema) {
  * contribute its own companions. A set shared across the walk would let the
  * first field claim the type and leave the second's companions indexed but
  * unqueried. What it does guard is a type reached from ITSELF, which a
- * {@link ReferenceStrategy.local local} lookup can do.
+ * {@link ReferenceStrategy.local local} lookup can do – cut at the same
+ * boundary the collection's own walk cuts at, so no field is declared indexed
+ * that this walk does not ask for.
  */
 function collectSearchable(searchType, locale, schema, prefix, onPath, names, weights) {
-    if (onPath.has(searchType.name)) {
-        return;
-    }
     const walked = new Set(onPath).add(searchType.name);
     for (const field of searchableFields(searchType)) {
         const search = physicalFields(field).search;
@@ -139,7 +138,12 @@ function collectSearchable(searchType, locale, schema, prefix, onPath, names, we
             continue;
         }
         const nested = nestedReferenceType(schema, field) ?? localLookupTypeOf(field, schema);
-        if (nested !== undefined) {
+        // Cut on the CHILD, not on entry, and against the set this level was
+        // reached with – the same boundary the collection's own walk cuts at
+        // (`nestedFields`). Returning on entry instead skipped the companions of
+        // the level the collection HAD declared, leaving them indexed and absent
+        // from `query_by` wherever a type reached itself.
+        if (nested !== undefined && !onPath.has(nested.name)) {
             collectSearchable(nested, locale, schema, qualify(prefix, field.name), walked, names, weights);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "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.24.0",
+    "@lde/search": "^0.24.2",
     "@lde/text-normalization": "^0.1.2",
     "tslib": "^2.3.0",
     "typesense": "^3.0.6"