@lde/search-typesense 0.44.2 → 0.46.0

package/dist/collection-definition.js

@@ -196,6 +196,9 @@ function typesenseFields(searchType, field, defaultLocale, defaultSortingField,
             })),
         ];
     }
+    if (field.kind === 'period') {
+        return periodFields(field, names);
+    }
     const valueType = typesenseValueType(field);
     const fields = [
         {
@@ -245,6 +248,32 @@ function typesenseFields(searchType, field, defaultLocale, defaultSortingField,
     }
     return fields;
 }
+/**
+ * A `period` field: its values verbatim, stored for output but never indexed –
+ * nothing filters or sorts on the text – and the two int64 bound companions
+ * ({@link physicalFields}) that filters and sorts read instead. The bounds are
+ * indexed for sorting whatever the field declares: a deployment may sort on a
+ * field it does not expose as sortable, and one more sort index on a numeric
+ * field costs little next to a collection rebuilt the day it becomes so.
+ */
+function periodFields(field, names) {
+    // Every period has bounds; `physicalFields` names them for no other kind.
+    const { start, end } = names.period;
+    return [
+        {
+            name: field.name,
+            type: typesenseValueType(field),
+            index: false,
+            optional: field.required !== true,
+        },
+        ...[start, end].map((name) => ({
+            name,
+            type: 'int64',
+            sort: true,
+            optional: true,
+        })),
+    ];
+}
 /** A `date` field’s precision companion ({@link physicalFields}): read back
  *  with the hit to format the value, never queried, so stored but not
  *  indexed – it costs disk, not RAM. */
@@ -524,6 +553,16 @@ function nestedLeafFields(prefix, field, defaultLocale, flattensToArray) {
         }));
         return fields;
     }
+    if (names.period !== undefined) {
+        // No filter reaches a nested period, so its value and its bounds are
+        // stored for output and never indexed.
+        return periodFields(field, names).map(({ name, type }) => ({
+            name: nestedFieldName(prefix, name),
+            type,
+            index: false,
+            optional: true,
+        }));
+    }
     // A nested field can be `filterable` or `searchable`, never `facetable` or
     // `sortable` (`searchSchema`), so `filterable` is what indexes the value
     // itself – its search companion below indexes on its own account.
@@ -601,6 +640,7 @@ function typesenseValueType(field) {
         case 'keyword':
         case 'reference':
         case 'text':
+        case 'period':
             return field.array === true ? 'string[]' : 'string';
     }
 }

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;AAsBrB;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;AAkhBD;;;;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;AAqBrB;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;AAwhBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/query-compiler.js

@@ -1,5 +1,5 @@
 import { fold } from '@lde/text-normalization';
-import { fieldNamed, filterOperator, filterOperatorFor, ID_FIELD, isoToUnixSeconds, lastSecondOf, storedFacetRanges, isInternalField, isBinnedRangeFacet, isWelded, joinGraph, localLookupTargetsOf, matchLanguage, pageForOffset, physicalFields, nestedReferenceType, resolvePath, searchableFields, } from '@lde/search/adapter';
+import { fieldNamed, filterOperator, filterOperatorFor, ID_FIELD, storedFacetRanges, storedRangeBound, isInternalField, isBinnedRangeFacet, isWelded, joinGraph, localLookupTargetsOf, matchLanguage, pageForOffset, physicalFields, nestedReferenceType, resolvePath, searchableFields, } from '@lde/search/adapter';
 /**
  * Compile the engine-neutral {@link SearchQuery} into Typesense search
  * parameters – the query half of the engine adapter. Pure (no client, no env),
@@ -411,7 +411,8 @@ function compileMembership(field, values, schema, prefix = '') {
     const name = qualify(prefix, names.identity ?? field.name);
     return names.facet === name ? `${name}:${list}` : `${name}:=${list}`;
 }
-/** An inclusive Typesense range clause, or `undefined` when neither bound is
+/** An inclusive Typesense range clause; `UNUSABLE` for a range that ends
+ *  before it starts, which holds no value; or `undefined` when neither bound is
  *  usable. Which of the two readings that is – the caller set no bounds, or the
  *  codec rejected the ones they set – is deliberately NOT decided here: a
  *  criterion dropped from a clause narrows the query while a clause dropped
@@ -419,13 +420,29 @@ function compileMembership(field, values, schema, prefix = '') {
  *  positions. `validateQuery` rejects an unreadable bound outright instead,
  *  which is the only answer that neither widens nor narrows. */
 function compileRange(field, range, prefix = '') {
-    const name = qualify(prefix, field.name);
     // A bound a caller sent as `null` – a GraphQL variable left unfilled, which
     // the surface passes through – is a bound NOT SET, not a bound of `null`.
     // Read literally it reaches the engine as `datePosted:[null..…]`, which
     // Typesense rejects outright.
-    const min = storedBound(field, range.min ?? undefined, 'min');
-    const max = storedBound(field, range.max ?? undefined, 'max');
+    const min = storedRangeBound(field, range.min ?? undefined, 'min');
+    const max = storedRangeBound(field, range.max ?? undefined, 'max');
+    // A range that ends before it starts holds no value. Compiled, a period’s
+    // overlap would match everything spanning the gap instead.
+    if (min !== undefined && max !== undefined && min > max) {
+        return UNUSABLE;
+    }
+    const period = physicalFields(field).period;
+    if (period !== undefined) {
+        // Overlap: the period starts no later than the range ends, and ends no
+        // earlier than it starts – so `1935/1955` matches 1940–1950.
+        const startsBefore = max === undefined ? undefined : `${period.start}:<=${max}`;
+        const endsAfter = min === undefined ? undefined : `${period.end}:>=${min}`;
+        // Parenthesised, because the clause may stand beside others in an `||`.
+        return startsBefore !== undefined && endsAfter !== undefined
+            ? `(${startsBefore} && ${endsAfter})`
+            : (startsBefore ?? endsAfter);
+    }
+    const name = qualify(prefix, field.name);
     if (min !== undefined && max !== undefined) {
         return `${name}:[${min}..${max}]`;
     }
@@ -437,20 +454,6 @@ function compileRange(field, range, prefix = '') {
     }
     return undefined;
 }
-/** A range bound as stored: a `date` field’s ISO 8601 bound becomes the indexed
- *  Unix seconds ({@link isoToUnixSeconds}) – a `min` its period’s first second,
- *  a `max` its last ({@link lastSecondOf}), so the inclusive clause takes in the
- *  whole period each names. An unparseable bound is dropped. */
-function storedBound(field, bound, side) {
-    if (field.kind !== 'date' || typeof bound !== 'string') {
-        return bound;
-    }
-    const stored = isoToUnixSeconds(bound);
-    if (stored === undefined) {
-        return undefined;
-    }
-    return side === 'min' ? stored.seconds : lastSecondOf(stored);
-}
 /**
  * One `sort_by` term. `relevance` maps to Typesense’s `_text_match`; a localized
  * text field sorts on its active-locale folded key; any other field (including a
@@ -472,6 +475,13 @@ function compileSort(sort, searchType, locale) {
             return `${sortName}:${sort.direction}`;
         }
     }
+    const period = field === undefined ? undefined : physicalFields(field).period;
+    if (period !== undefined) {
+        // Earliest first orders on where a period begins, latest first on where it
+        // ends, so each direction ranks a period by the end of it that direction
+        // reaches first.
+        return `${sort.direction === 'asc' ? period.start : period.end}:${sort.direction}`;
+    }
     return `${sort.field}:${sort.direction}`;
 }
 /**

package/dist/search.js

@@ -846,7 +846,9 @@ function logicalValue(flat, field, labels, schema, referents) {
                 ? undefined
                 : referenceValue(flat, field, labels);
         }
-        case 'keyword': {
+        // A period is served as stated; its bound companions are for the engine.
+        case 'keyword':
+        case 'period': {
             const value = flat[field.name];
             return Array.isArray(value) || typeof value === 'string'
                 ? value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.44.2",
+  "version": "0.46.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.36.4",
+    "@lde/search": "^0.38.0",
     "@lde/text-normalization": "^0.3.0",
     "tslib": "^2.3.0",
     "typesense": "^3.2.0"
@@ -36,6 +36,6 @@
   },
   "peerDependencies": {
     "@lde/dataset": "^0.10.1",
-    "@lde/pipeline": "^0.42.1"
+    "@lde/pipeline": "^0.43.0"
   }
 }