@lde/search-typesense 0.54.0 → 0.55.0

package/dist/collection-definition.d.ts

@@ -91,9 +91,10 @@ export interface CollectionDefinitionOptions {
  * the display labels; one that opts into `filterable` or `searchable` is
  * indexed, and its parent object with it (see {@link nestedFields}).
  *
- * An inline reference declaring `filterable` or `facetable` also emits its
- * {@link ReferenceStrategy.identity identity companion} – a flat id field the
- * engine can filter and facet, which a nested object is not
+ * An inline reference naming an {@link ReferenceStrategy.identity identity}
+ * filters and facets that identity’s leaf inside each entry, which a nested
+ * object is not; a `local` lookup that is `filterable` or `facetable` emits a
+ * flat id companion beside its endpoints instead
  * ({@link identityCompanionFields}).
  */
 export declare function buildCollectionDefinition(searchType: SearchType, options?: CollectionDefinitionOptions): CollectionCreateSchema;

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;AAiBrB,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,CAwCxB"}
+{"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;AAiBrB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,2BAAgC,GACxC,sBAAsB,CAuCxB"}

package/dist/collection-definition.js

@@ -45,9 +45,10 @@ import { deriveCollectionName } from './collection-name.js';
  * the display labels; one that opts into `filterable` or `searchable` is
  * indexed, and its parent object with it (see {@link nestedFields}).
  *
- * An inline reference declaring `filterable` or `facetable` also emits its
- * {@link ReferenceStrategy.identity identity companion} – a flat id field the
- * engine can filter and facet, which a nested object is not
+ * An inline reference naming an {@link ReferenceStrategy.identity identity}
+ * filters and facets that identity’s leaf inside each entry, which a nested
+ * object is not; a `local` lookup that is `filterable` or `facetable` emits a
+ * flat id companion beside its endpoints instead
  * ({@link identityCompanionFields}).
  */
 export function buildCollectionDefinition(searchType, options = {}) {
@@ -56,11 +57,10 @@ export function buildCollectionDefinition(searchType, options = {}) {
         name: collectionNameFor(searchType),
         fields: searchType.fields.flatMap((field) => typesenseFields(searchType, field, defaultLocale, options.defaultSortingField, options.schema, collectionNameFor)),
     };
-    // A faceted leaf is faceted on its nested path, which Typesense flattens
-    // into one list per document – so a bucket counts documents, not entries.
-    const facetedPaths = new Set(facetsOf(searchType, options.schema)
-        .filter((facet) => facet.reference !== undefined)
-        .map((facet) => facet.engineField));
+    // A faceted leaf, and an inline reference’s identity, are faceted on a
+    // nested path, which Typesense flattens into one list per document – so a
+    // bucket counts documents, not entries.
+    const facetedPaths = new Set(facetsOf(searchType, options.schema).map((facet) => facet.engineField));
     for (const field of collection.fields) {
         if (facetedPaths.has(field.name)) {
             field.facet = true;
@@ -459,30 +459,29 @@ function nestedFields(prefix, reference, nestedType, schema, defaultLocale, with
     ];
 }
 /**
- * The **identity companion** of an inline reference: the flat field holding the
- * ids its entries reference, which the engine filters and facets in place of
- * the nested object it cannot. Empty for an inline reference declaring no
- * `identity` – a display-only nesting keeps costing no RAM.
+ * The top-level companions of a field storing nested objects: a `local`
+ * lookup’s **identity companion**, the flat field holding the ids of its
+ * endpoints, which the engine filters and facets in place of the nested object
+ * it cannot. An inline reference needs none – it reads its identity’s leaf
+ * inside each entry – and a display-only nesting keeps costing no RAM.
  *
- * A second, narrowed field joins it where the target declares a facet policy,
+ * A narrowed field joins them where the target declares a facet policy,
  * exactly as it does for a top-level facetable reference: the facet then reads
  * the admitted subset, so an excluded id is never seen by the engine rather
  * than merely unlabelled.
  */
 function identityCompanionFields(field, schema) {
     const names = physicalFields(field, schema);
-    if (names.identity === undefined) {
-        return [];
-    }
-    const fields = [
-        {
+    const fields = [];
+    if (names.identity !== undefined) {
+        fields.push({
             name: names.identity,
             type: 'string[]',
             facet: names.facet === names.identity,
             optional: true,
-        },
-    ];
-    if (names.facet !== undefined && names.facet !== names.identity) {
+        });
+    }
+    if (names.facet !== undefined && names.facet !== names.filter) {
         fields.push({
             name: names.facet,
             type: 'string[]',

package/dist/documents.js

@@ -159,7 +159,7 @@ export function assertWritableType(searchType, options) {
     }
     else if (options.requireFacetable &&
         physicalFields(declared, options.schema).facet !== declared.name) {
-        problems.push('the engine facets a companion in its place – one narrowed by a facet policy inherited from the type it names, or the identity companion of a nested object – while the membership sweep enumerates the indexed datasets by faceting the field itself');
+        problems.push('the engine facets a companion in its place – one narrowed by a facet policy inherited from the type it names, or the id leaf of a nested object – while the membership sweep enumerates the indexed datasets by faceting the field itself');
     }
     if (problems.length > 0) {
         throw new Error(`SearchType “${searchType.name}” declares “${declared.name}” over the indexed dataset, which this writer keeps its provenance bookkeeping on, but ${problems.join('; and ')}.`);

package/dist/in-place-rebuild.js

@@ -176,7 +176,7 @@ function assertReferencesAndFacetCompanionsPresent(name, fields, facetCompanions
     if (missingCompanions.length > 0) {
         throw new Error(`Typesense collection “${name}” exists without the facet field(s) ${missingCompanions
             .map((companion) => `“${companion}”`)
-            .join(', ')} its search type facets on in place of the field itself – an identity companion, one narrowed by a facet policy (“facetKeys”), or the nested path of a faceted leaf. A facet field cannot be added to a live collection here: drop “${name}” (and the collections that join to it) and let the next run rebuild them.`);
+            .join(', ')} its search type facets on in place of the field itself – the id leaf of a nested object, one narrowed by a facet policy (“facetKeys”), or the nested path of a faceted leaf. A facet field cannot be added to a live collection here: drop “${name}” (and the collections that join to it) and let the next run rebuild them.`);
     }
 }
 /** The fields a type’s facets read instead of the fields themselves – one per

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;AAuBrB;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;AAikBD;;;;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;AAuBrB;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;AAgkBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/query-compiler.js

@@ -433,11 +433,10 @@ function compileWelded(criterion, searchType, schema, prefix) {
 function compileMembership(field, values, schema, prefix = '') {
     const list = `[${values.map(escapeFilterValue).join(',')}]`;
     const names = physicalFields(field, schema);
-    // An inline reference stores a nested object, which an engine cannot filter.
-    // Its identity companion is the flat id field standing in for it – so the
-    // logical name a consumer writes and the physical name the engine reads
-    // differ here, and only here.
-    const name = qualify(prefix, names.identity ?? field.name);
+    // A field storing a nested object, which an engine cannot filter, is read
+    // through an id leaf standing in for it – so the logical name a consumer
+    // writes and the physical name the engine reads differ here, and only here.
+    const name = qualify(prefix, names.filter);
     return names.facet === name ? `${name}:${list}` : `${name}:=${list}`;
 }
 /** An inclusive Typesense range clause; `UNUSABLE` for a range that ends

package/dist/search.js

@@ -79,8 +79,8 @@ export function createTypesenseSearchEngine(client, schema, options = {}) {
             ...facetsOf(searchType, schema).filter((facet) => facet.reference !== undefined),
         ]
             // An INLINE reference names its label target one level in, through
-            // its identity companion: the companion holds that field's ids, so
-            // that field's target is what can label them.
+            // its identity: the facet counts that field's ids, so that field's
+            // target is what can label them.
             .filter(({ field }) => labelTargetNamesOf(field, schema).length > 0)
             .map(({ name, field }) => [
             name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.54.0",
+  "version": "0.55.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.41.3",
+    "@lde/search": "^0.42.0",
     "@lde/text-normalization": "^0.3.0",
     "tslib": "^2.3.0",
     "typesense": "^3.2.0"