@open-mercato/core 0.9.1-develop.7473.1.de5b22888f → 0.9.1-develop.7475.1.28ca93ed97

package/dist/modules/query_index/lib/engine.js

@@ -1,6 +1,13 @@
 import { SortDir } from "@open-mercato/shared/lib/query/types";
 import { resolveEntityTableName, resolveRegisteredEntityTableName } from "@open-mercato/shared/lib/query/engine";
 import { isOrmBackedSystemEntityId } from "@open-mercato/shared/lib/data/engine";
+import {
+  buildArrayColumnNoOverlapPredicate,
+  buildArrayColumnOverlapPredicate,
+  buildJsonbNoOverlapPredicate,
+  buildJsonbOverlapPredicate,
+  normalizeOverlapValues
+} from "@open-mercato/shared/lib/query/overlap";
 import { sql } from "kysely";
 import { readCoverageSnapshot, refreshCoverageSnapshot } from "./coverage.js";
 import { createProfiler, shouldEnableProfiler } from "@open-mercato/shared/lib/profiler";
@@ -49,7 +56,9 @@ const CF_FILTER_SUPPORTED_OPS = /* @__PURE__ */ new Set([
   "gt",
   "gte",
   "lt",
-  "lte"
+  "lte",
+  "overlap",
+  "noverlap"
 ]);
 const NUMERIC_CF_SORT_KINDS = /* @__PURE__ */ new Set(["integer", "float"]);
 const DECRYPT_CONCURRENCY = 8;
@@ -784,6 +793,10 @@ class HybridQueryEngine {
             return target.where(column, "ilike", value);
           case "exists":
             return value ? target.where(column, "is not", null) : target.where(column, "is", null);
+          case "overlap":
+            return target.where(buildArrayColumnOverlapPredicate(column, value));
+          case "noverlap":
+            return target.where(buildArrayColumnNoOverlapPredicate(column, value));
           default:
             return target;
         }
@@ -1339,6 +1352,18 @@ class HybridQueryEngine {
           ])
         );
       }
+      case "noverlap":
+        return sql`false`;
+      case "overlap": {
+        const values = normalizeOverlapValues(value);
+        if (!values.length) return sql`false`;
+        return eb.or(
+          values.flatMap((val) => [
+            sql`${textExpr} = ${val}`,
+            arrContains(val)
+          ])
+        );
+      }
       case "nin": {
         const values = this.toArray(value);
         return sql`${textExpr} not in (${sql.join(values.map((v) => sql`${v}`), sql`, `)})`;
@@ -1465,6 +1490,18 @@ class HybridQueryEngine {
           ])
         ));
       }
+      case "noverlap":
+        return q.where(sql`false`);
+      case "overlap": {
+        const vals = normalizeOverlapValues(value);
+        if (!vals.length) return q.where(sql`false`);
+        return q.where((eb) => eb.or(
+          vals.flatMap((val) => [
+            sql`${textExpr} = ${val}`,
+            arrContains(val)
+          ])
+        ));
+      }
       case "nin": {
         const vals = this.toArray(value);
         return q.where(sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
@@ -1525,6 +1562,10 @@ class HybridQueryEngine {
         const vals = this.toArray(value);
         return q.where(sql`${textExpr} in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
       }
+      case "overlap":
+        return q.where(buildJsonbOverlapPredicate(`${alias}.doc`, key, value));
+      case "noverlap":
+        return q.where(buildJsonbNoOverlapPredicate(`${alias}.doc`, key, value));
       case "nin": {
         const vals = this.toArray(value);
         return q.where(sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
@@ -1610,6 +1651,10 @@ class HybridQueryEngine {
         return eb(column, "ilike", value);
       case "exists":
         return eb(column, value ? "is not" : "is", null);
+      case "overlap":
+        return buildArrayColumnOverlapPredicate(column, value);
+      case "noverlap":
+        return buildArrayColumnNoOverlapPredicate(column, value);
       default:
         return sql`true`;
     }
@@ -1636,6 +1681,10 @@ class HybridQueryEngine {
         const vals = this.toArray(value);
         return sql`${textExpr} in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`;
       }
+      case "overlap":
+        return buildJsonbOverlapPredicate(`${alias}.doc`, key, value);
+      case "noverlap":
+        return buildJsonbNoOverlapPredicate(`${alias}.doc`, key, value);
       case "nin": {
         const vals = this.toArray(value);
         return sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`;
@@ -1683,6 +1732,14 @@ class HybridQueryEngine {
           });
           continue;
         }
+        if (filter.op === "overlap") {
+          next = next.where(buildJsonbOverlapPredicate(`${alias}.doc`, String(filter.field), filter.value));
+          continue;
+        }
+        if (filter.op === "noverlap") {
+          next = next.where(buildJsonbNoOverlapPredicate(`${alias}.doc`, String(filter.field), filter.value));
+          continue;
+        }
         const docExpr = sql`(${sql.ref(alias + ".doc")} ->> ${String(filter.field)})`;
         next = this.applyColumnFilter(next, docExpr, filter, {
           ...searchRuntime,
@@ -2186,6 +2243,12 @@ class HybridQueryEngine {
             case "$exists":
               add(field, "exists", opVal);
               break;
+            case "$overlap":
+              add(field, "overlap", opVal);
+              break;
+            case "$noverlap":
+              add(field, "noverlap", opVal);
+              break;
           }
         }
       } else {
@@ -2298,6 +2361,10 @@ class HybridQueryEngine {
         return q.where(col, "ilike", filter.value);
       case "exists":
         return filter.value ? q.where(col, "is not", null) : q.where(col, "is", null);
+      case "overlap":
+        return q.where(buildArrayColumnOverlapPredicate(col, filter.value));
+      case "noverlap":
+        return q.where(buildArrayColumnNoOverlapPredicate(col, filter.value));
       default:
         return q;
     }