@lde/search-typesense 0.29.2 → 0.29.4

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,
                     },
@@ -426,10 +429,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,
             });

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;
@@ -694,31 +698,33 @@ function nestedValue(raw, field, referenceType, labels, schema, children) {
 }
 /**
  * Rebuild a {@link ReferenceStrategy.local local} lookup: the endpoint’s own
- * document as this document stated it, with the **resolved** document overlaid
+ * document as this document stated it, **replaced** by the resolved document
  * where the lookup found one.
  *
- * Both sides are the target type’s flat physical shape, so the merge is a plain
- * override and the authoritative value wins field by field. Three cases fall
- * out of one expression, which is the point of storing local fields
- * unconditionally:
+ * Replaced rather than merged, because both sides are the target type’s flat
+ * physical shape and a logical field fans out into several physical ones: a
+ * name this document stated in one language would survive beside the target’s
+ * name in another, and a field the target’s record does not carry would
+ * survive after the target dropped it. The resolved document carries what the
+ * projection asked for, and a resolved entry says exactly that – what a plain
+ * lookup says too. Three cases fall out of one expression, which is the point
+ * of storing local fields unconditionally:
  *
- * - identified and indexed → the target’s own record, over what was stated here;
+ * - identified and indexed → the target’s own record;
  * - identified but not indexed → what was stated here, plus the `id`, rather
  *   than a bare IRI;
  * - not identified → what was stated here, with no `id` at all.
  */
 function localLookupValue(raw, field, target, resolved, labels, schema) {
     const fetched = resolved?.via === 'lookup' ? resolved.documents : new Map();
-    const merged = (Array.isArray(raw) ? raw : [raw])
+    const entries = (Array.isArray(raw) ? raw : [raw])
         .filter((entry) => typeof entry === 'object' && entry !== null)
         .map((entry) => {
         const id = typeof entry.id === 'string' ? entry.id : undefined;
         const authoritative = id === undefined ? undefined : fetched.get(id);
-        return authoritative === undefined
-            ? entry
-            : { ...entry, ...authoritative };
+        return authoritative ?? entry;
     });
-    return nestedValue(merged, field, target, labels, schema, resolved?.children);
+    return nestedValue(entries, field, target, labels, schema, resolved?.children);
 }
 /**
  * Rebuild a resolved `lookup` reference: each stored IRI becomes the referent’s

package/package.json

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