@lde/search-typesense 0.29.3 → 0.30.0

package/dist/collection-definition.d.ts

@@ -73,7 +73,8 @@ export interface CollectionDefinitionOptions {
  * size of the fields you search, facet or sort on – not the whole document.
  * This builder keeps that surface minimal: the `output` display labels land in
  * a single `index: false` regex field (`${name}_<lang>`, one value per present
- * language), kept on disk and read back only for a hit, so they cost no RAM;
+ * language, or every value of it as a `string[]` for an `array` field), kept
+ * on disk and read back only for a hit, so they cost no RAM;
  * only the folded `*_search_${locale}`, facet/reference and `*_sort_${locale}`
  * companions are indexed. Keeping retrieval-only fields un-indexed is the lever
  * for holding a large index’s RAM down.

package/dist/collection-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection-definition.d.ts","sourceRoot":"","sources":["../src/collection-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAcrB,0EAA0E;AAC1E,MAAM,WAAW,2BAA2B;IAC1C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC;IAChE;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;;;4BAGwB;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,2BAAgC,GACxC,sBAAsB,CA2BxB"}
+{"version":3,"file":"collection-definition.d.ts","sourceRoot":"","sources":["../src/collection-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAcrB,0EAA0E;AAC1E,MAAM,WAAW,2BAA2B;IAC1C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC;IAChE;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;;;4BAGwB;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,2BAAgC,GACxC,sBAAsB,CA2BxB"}

package/dist/collection-definition.js

@@ -27,7 +27,8 @@ import { deriveCollectionName } from './collection-name.js';
  * size of the fields you search, facet or sort on – not the whole document.
  * This builder keeps that surface minimal: the `output` display labels land in
  * a single `index: false` regex field (`${name}_<lang>`, one value per present
- * language), kept on disk and read back only for a hit, so they cost no RAM;
+ * language, or every value of it as a `string[]` for an `array` field), kept
+ * on disk and read back only for a hit, so they cost no RAM;
  * only the folded `*_search_${locale}`, facet/reference and `*_sort_${locale}`
  * companions are indexed. Keeping retrieval-only fields un-indexed is the lever
  * for holding a large index’s RAM down.
@@ -163,12 +164,14 @@ function typesenseFields(searchType, field, defaultLocale, defaultSortingField,
             // the folded `*_search` companions, so the display copies stay on disk and
             // off RAM (fetched only for a hit), accents preserved, and a language
             // outside `locales` still renders. This is the memory lever: RAM tracks
-            // the search surface, not the display text. Absent for a non-output field.
+            // the search surface, not the display text. Absent for a non-output
+            // field. An `array` field stores every value of a language, so its
+            // pattern is typed a list – `array` decides the shape for every kind.
             ...(displayPattern !== undefined
                 ? [
                     {
                         name: displayPattern,
-                        type: 'string',
+                        type: typesenseValueType(field),
                         index: false,
                         optional: true,
                     },
@@ -314,7 +317,7 @@ function nestedFields(prefix, reference, nestedType, schema, defaultLocale, with
                 type: boundaryArray ? 'string[]' : 'string',
                 index: false,
                 optional: true,
-            }, ...nestedIdentityFields(prefix, field, schema));
+            }, ...nestedIdentityFields(prefix, field, schema, flattensToArray));
             continue;
         }
         if (deeper !== undefined) {
@@ -324,7 +327,7 @@ function nestedFields(prefix, reference, nestedType, schema, defaultLocale, with
             // an engine welds conditions on an entry's LEAF fields only. Its
             // identity companion is that leaf, so it sits beside the object rather
             // than inside it.
-            ...nestedIdentityFields(prefix, field, schema));
+            ...nestedIdentityFields(prefix, field, schema, flattensToArray));
             continue;
         }
         children.push(...nestedLeafFields(prefix, field, defaultLocale, flattensToArray));
@@ -381,7 +384,7 @@ function identityCompanionFields(field, schema) {
 /** The identity companion of a nested field that stores an object: a flat leaf
  *  beside it, holding the ids a filter welds on. Empty for a nested field that
  *  declares no query Role, which needs none. */
-function nestedIdentityFields(prefix, field, schema) {
+function nestedIdentityFields(prefix, field, schema, flattensToArray) {
     const names = physicalFields(field, schema);
     if (names.identity === undefined) {
         return [];
@@ -389,11 +392,23 @@ function nestedIdentityFields(prefix, field, schema) {
     return [
         {
             name: nestedFieldName(prefix, names.identity),
-            // Always a list, whatever the enclosing reference's arity: the projection
-            // writes it with `setArray`, and an indexed field's declared type is
-            // checked against what is stored – a `string` here rejects every
-            // document carrying such an edge, at import.
-            type: 'string[]',
+            // Typed by what the PATH yields across the document, exactly as the `id`
+            // beside it is, and by the same two routes every other declaration here
+            // uses: an `object[]` ancestor multiplying the entries, or the field's
+            // own `array` making each entry hold a list. A weldable leaf is
+            // single-valued (ADR 26), so a companion that a weld names contributes
+            // one id per entry – but a multi-valued reference reached through a
+            // locally-nested Root Type is not weldable and still harvests a list.
+            // Getting either route wrong rejects the document at import: Typesense
+            // enforces the declared arity wherever nothing widens the path.
+            // `filterable` is the condition because it is what the projection writes
+            // a single id under, not because it decides the split: `tuplesOf` splits
+            // the identity field whatever Role earned it. A `facetable`-only
+            // companion is declared a list, which is what a facet reads and what the
+            // projection writes for it.
+            type: flattensToArray || field.array === true || field.filterable !== true
+                ? 'string[]'
+                : 'string',
             index: true,
             optional: true,
         },
@@ -426,10 +441,11 @@ function nestedLeafFields(prefix, field, defaultLocale, flattensToArray) {
         if (pattern !== undefined) {
             // Display values are never indexed, whatever Roles the field declares:
             // search hits the folded companions below, so the display copies stay on
-            // disk with every language they carry.
+            // disk with every language they carry – every value of it for an
+            // `array` field.
             fields.push({
                 name: nestedFieldName(prefix, pattern),
-                type: 'string',
+                type: typesenseValueType(field),
                 index: false,
                 optional: true,
             });
@@ -454,6 +470,10 @@ function nestedLeafFields(prefix, field, defaultLocale, flattensToArray) {
     // `object[]` flattens it into one. `typesenseValueType` honours `array` only
     // for the string-shaped kinds, so a multi-valued nested `integer` would
     // otherwise be declared scalar and rejected at import.
+    //
+    // A weldable leaf of a Reference Type is single-valued (ADR 26), but that
+    // narrows nothing here: this same path declares the fields of the Root Type a
+    // `local` lookup nests, where `array` and `filterable` may legitimately meet.
     const storesAList = flattensToArray || field.array === true;
     fields.push({
         name: nestedFieldName(prefix, field.name),
@@ -494,8 +514,11 @@ function arrayValueType(type) {
             return 'float[]';
         case 'bool':
             return 'bool[]';
-        // Already a list: a multi-valued declaration under a multi-valued ancestor
-        // flattens no further.
+        // Already a list, and reachable even though a weldable leaf of a Reference
+        // Type is single-valued (ADR 26): this path also declares the fields of the
+        // Root Type a `local` lookup nests, and `searchSchema` constrains only
+        // Reference Types. A root keyword may be `array` and `filterable` at once –
+        // an ordinary facet – so flattening it must widen no further.
         case 'string[]':
             return 'string[]';
     }

package/dist/search.js

@@ -656,16 +656,20 @@ function logicalValue(flat, field, labels, schema, referents) {
  * recovers languages outside the declared `locales` too – a value tagged in an
  * undeclared language, or untagged (`und`), still reconstructs rather than being
  * dropped.
+ *
+ * A display field holds one string for a plain field, or a list of them for an
+ * `array` field.
  */
 function localizedValue(flat, field) {
     const map = {};
     for (const [key, value] of Object.entries(flat)) {
-        if (typeof value !== 'string') {
+        const lang = displayLangOf(field, key);
+        if (lang === undefined) {
             continue;
         }
-        const lang = displayLangOf(field, key);
-        if (lang !== undefined) {
-            map[lang] = [value];
+        const values = (Array.isArray(value) ? value : [value]).filter((entry) => typeof entry === 'string');
+        if (values.length > 0) {
+            map[lang] = values;
         }
     }
     return Object.keys(map).length > 0 ? map : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.29.3",
+  "version": "0.30.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.24.3",
+    "@lde/search": "^0.25.0",
     "@lde/text-normalization": "^0.1.2",
     "tslib": "^2.3.0",
     "typesense": "^3.0.6"