feat: lucene between now has the option to include the upper limit.

thisisagile · Nov 14, 2024 · eb5dd63 · eb5dd63
1 parent a48486e
commit eb5dd63
Show file tree

Hide file tree

Showing 2 changed files with 35 additions and 11 deletions.
diff --git a/packages/easy-mongo/src/Lucene.ts b/packages/easy-mongo/src/Lucene.ts
@@ -37,7 +37,14 @@ export type SearchDefinition = Record<
   (
     v: string | number,
     q?: Record<string, string | number>
-  ) => RequireAtLeastOne<{ should?: Clauses; filter?: Clauses; must?: Clauses; mustNot?: Clauses; sort?: Record<string, 1 | -1>; facet?: Facet }>
+  ) => RequireAtLeastOne<{
+    should?: Clauses;
+    filter?: Clauses;
+    must?: Clauses;
+    mustNot?: Clauses;
+    sort?: Record<string, 1 | -1>;
+    facet?: Facet;
+  }>
 >;
 
 type Compound = {
@@ -65,7 +72,11 @@ export const lucene = {
         must: must(query, def),
       }).filter(([_, v]) => v.length > 0),
       e => e.reduce((res, [k, v]) => on(res, r => (r[k] = lucene.clauses(v))), should(query, def).length > 0 ? { minimumShouldMatch: 1 } : ({} as any)),
-      () => ifTrue(wildcard, () => ({ should: lucene.clauses([{ wildcard: lucene.wildcard() }]), minimumShouldMatch: 0 }))
+      () =>
+        ifTrue(wildcard, () => ({
+          should: lucene.clauses([{ wildcard: lucene.wildcard() }]),
+          minimumShouldMatch: 0,
+        }))
     ),
   search: (c: Partial<Compound>, index?: string) => ({
     $search: {
@@ -78,7 +89,12 @@ export const lucene = {
       .mapDefined(([k, v]) => options[k]?.(v, query)?.sort)
       .first();
     return {
-      $search: { ...ifDefined(index, { index }), compound: lucene.compound(query, options), ...ifDefined(sort, { sort }), count: { type: count } },
+      $search: {
+        ...ifDefined(index, { index }),
+        compound: lucene.compound(query, options),
+        ...ifDefined(sort, { sort }),
+        count: { type: count },
+      },
     };
   },
   searchMeta: (query: Record<string, string | number>, def: SearchDefinition, count: 'total' | 'lowerBound' = 'total', index?: string) => ({
@@ -138,14 +154,17 @@ export const lucene = {
   after: (date: unknown): Operator => lucene.gte(toMongoType(date)),
   before: (date: unknown): Operator => lucene.lt(toMongoType(date)),
   between:
-    (after: unknown, before: unknown): Operator =>
-    (path: string) => ({
-      range: {
-        path,
-        gte: toMongoType(after),
-        lt: toMongoType(before),
-      },
-    }),
+    (after: unknown, before: unknown, includeLimit?: boolean): Operator =>
+    (path: string) => {
+      const upperLimit = includeLimit ? { lte: toMongoType(before) } : { lt: toMongoType(before) };
+      return {
+        range: {
+          path,
+          gte: toMongoType(after),
+          ...upperLimit,
+        },
+      };
+    },
   facets: (def: SearchDefinition) =>
     entries(def)
       .filter(([k, v]) => isDefined(v(k)?.facet))

diff --git a/packages/easy-mongo/test/Lucene.test.ts b/packages/easy-mongo/test/Lucene.test.ts
@@ -95,6 +95,11 @@ describe('Lucene', () => {
     expect(d).toStrictEqual({ range: { path: 'size', gte: 41, lt: 52 } });
   });
 
+  test('between with inclusion of upper limit', () => {
+    const d = between(41, 52, true)('size');
+    expect(d).toStrictEqual({ range: { path: 'size', gte: 41, lte: 52 } });
+  });
+
   test('between with dates', () => {
     const d = between(date, date2)('start');
     expect(d).toStrictEqual({ range: { path: 'start', gte: new Date(date), lt: new Date(date2) } });