@open-mercato/core 0.8.1-develop.7294.1.0ef99fc518 → 0.8.1-develop.7295.1.d0e0e33014

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

@@ -27,10 +27,12 @@ import {
   hasSearchFilter
 } from "@open-mercato/shared/lib/search/availability";
 import { tokenizeText } from "@open-mercato/shared/lib/search/tokenize";
+import { buildContainmentPatterns } from "@open-mercato/shared/lib/search/containment";
 import { runBeforeQueryPipeline, runAfterQueryPipeline } from "@open-mercato/shared/lib/query/query-extension-runner";
 import { warnOnCiphertextLikeFallback } from "@open-mercato/shared/lib/query/ciphertext-search-warning";
 import { resolveEncryptedSortFields, resolveEncryptedSortMaxRows, sortRowsInMemory } from "@open-mercato/shared/lib/query/encrypted-sort";
 import { resolveListCountCap } from "@open-mercato/shared/lib/query/count-cap";
+import { resolveCfDefIndexOrgCandidates } from "@open-mercato/shared/lib/crud/custom-field-definition-index";
 import { mapWithConcurrency } from "@open-mercato/shared/lib/query/bounded-decrypt";
 import { createLogger } from "@open-mercato/shared/lib/logger";
 import { parseNumberWithDefault } from "@open-mercato/shared/lib/number";
@@ -49,6 +51,7 @@ const CF_FILTER_SUPPORTED_OPS = /* @__PURE__ */ new Set([
   "lt",
   "lte"
 ]);
+const NUMERIC_CF_SORT_KINDS = /* @__PURE__ */ new Set(["integer", "float"]);
 const DECRYPT_CONCURRENCY = 8;
 const AUTO_REINDEX_DEBOUNCE_DEFAULT_MS = 3e4;
 const AUTO_REINDEX_DEBOUNCE_MAX_SCOPES = 1e4;
@@ -145,6 +148,7 @@ class HybridQueryEngine {
     this.vectorServiceResolver = vectorServiceResolver;
     this.encryptionResolver = encryptionResolver;
     this.customFieldDefsCache = /* @__PURE__ */ new Map();
+    this.customFieldKindCache = /* @__PURE__ */ new Map();
     this.columnCache = /* @__PURE__ */ new Map();
     this.customEntityCache = /* @__PURE__ */ new Map();
     this.debugVerbosity = null;
@@ -590,6 +594,15 @@ class HybridQueryEngine {
         fallbackOrgId
       );
       const requiresPlaintextSort = encryptedSortFields.size > 0;
+      const cfSortKeys = Array.from(new Set(
+        resolvedSorts.filter((sort) => sort.field.startsWith("cf:")).map((sort) => sort.field.slice(3))
+      ));
+      const cfSortKinds = cfSortKeys.length ? await this.resolveCustomFieldSortKinds(
+        indexSources.map((source) => String(source.entityId)),
+        opts.tenantId ?? null,
+        resolveCfDefIndexOrgCandidates(opts.organizationIds, fallbackOrgId),
+        cfSortKeys
+      ) : /* @__PURE__ */ new Map();
       const applyBaseScope = (q) => {
         let next = q;
         if (orgScope && hasOrganizationColumn) {
@@ -935,7 +948,13 @@ class HybridQueryEngine {
             const textExpr = this.buildCfTextExprSql(fieldName, indexSources);
             if (textExpr) {
               const direction = sql.raw(coerceSortDirection(s.dir));
-              next = next.orderBy(sql`${textExpr} ${direction}`);
+              const kind = cfSortKinds.get(fieldName.slice(3));
+              let sortExpr = textExpr;
+              if (kind && NUMERIC_CF_SORT_KINDS.has(kind)) {
+                const jsonExpr = this.buildCfJsonExprSql(fieldName, indexSources);
+                sortExpr = jsonExpr ? sql`CASE WHEN jsonb_typeof(${jsonExpr}) = 'number' THEN (${textExpr})::numeric END` : textExpr;
+              }
+              next = next.orderBy(sql`${sortExpr} ${direction} NULLS LAST`);
             }
           } else {
             const baseField = resolveBaseColumn(fieldName);
@@ -943,6 +962,10 @@ class HybridQueryEngine {
             next = next.orderBy(qualify(baseField), s.dir ?? SortDir.Asc);
           }
         }
+        const lastSortField = resolvedSorts.length ? String(resolvedSorts[resolvedSorts.length - 1].field) : null;
+        if (resolvedSorts.length && lastSortField !== "id") {
+          next = next.orderBy(qualify("id"), SortDir.Asc);
+        }
         return next;
       };
       const page = opts.page?.page ?? 1;
@@ -1554,6 +1577,12 @@ class HybridQueryEngine {
       }
       return searchRuntime?.encryptedFields != null && isEncryptedLikeField(searchRuntime.encryptedFields, fieldName) ? sql`false` : sql`true`;
     }
+    if ((filter.op === "like" || filter.op === "ilike") && typeof filter.value === "string" && searchRuntime?.enabled && searchRuntime.encryptedFields != null) {
+      const patterns = buildContainmentPatterns(filter.value);
+      if (patterns.length > 1) {
+        return eb.and(patterns.map((pattern) => eb(qualify(baseField), filter.op, pattern)));
+      }
+    }
     return this.buildColumnFilterExpression(eb, qualify(baseField), filter.op, filter.value);
   }
   buildColumnFilterExpression(eb, column, op, value) {
@@ -1789,6 +1818,44 @@ class HybridQueryEngine {
     }
     return result.slice();
   }
+  /**
+   * Resolve the declared `kind` for a set of `cf:` sort keys so `applySort` can
+   * cast numeric kinds instead of ordering by jsonb text (#5674). A same-org
+   * definition wins over a tenant-wide one, which wins over a global one, for
+   * the same key — a same-key definition scoped to a *different* organization
+   * in the tenant never gets to decide the kind (#5674 review).
+   */
+  async resolveCustomFieldSortKinds(entityIds, tenantId, organizationIds, keys) {
+    if (!entityIds.length || !keys.length) return /* @__PURE__ */ new Map();
+    const sortedOrgIds = organizationIds.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const cacheKey = `${this.customFieldKeysCacheKey(entityIds, tenantId)}|org:${sortedOrgIds.join(",")}|${keys.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0).join(",")}`;
+    const now = Date.now();
+    const cached = this.customFieldKindCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) return new Map(cached.value);
+    const db = this.getDb();
+    const rows = await db.selectFrom("custom_field_defs").select(["key", "kind", "organization_id", "tenant_id"]).where("entity_id", "in", entityIds).where("key", "in", keys).where("is_active", "=", true).where((eb) => eb.or([
+      eb("tenant_id", "=", tenantId),
+      eb("tenant_id", "is", null)
+    ])).where((eb) => sortedOrgIds.length ? eb.or([
+      eb("organization_id", "is", null),
+      eb("organization_id", "in", sortedOrgIds)
+    ]) : eb("organization_id", "is", null)).execute();
+    const winners = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = typeof row.key === "string" ? row.key : String(row.key);
+      const kind = typeof row.kind === "string" ? row.kind : null;
+      if (!kind) continue;
+      const specificity = row.organization_id != null ? 2 : row.tenant_id != null ? 1 : 0;
+      const existing = winners.get(key);
+      if (!existing || specificity >= existing.specificity) winners.set(key, { kind, specificity });
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, entry] of winners) result.set(key, entry.kind);
+    if (this.customFieldKeysTtlMs > 0) {
+      this.customFieldKindCache.set(cacheKey, { expiresAt: now + this.customFieldKeysTtlMs, value: new Map(result) });
+    }
+    return result;
+  }
   async resolveAvailableCustomFieldKeys(entityIds, tenantId) {
     const defs = await this.resolveCustomFieldDefs(entityIds, tenantId);
     return Array.from(new Set(defs.map((def) => def.key)));
@@ -2200,6 +2267,14 @@ class HybridQueryEngine {
       return q;
     }
     const col = column;
+    if ((filter.op === "like" || filter.op === "ilike") && typeof filter.value === "string" && search?.enabled && search.encryptedFields != null) {
+      const patterns = buildContainmentPatterns(filter.value);
+      if (patterns.length > 1) {
+        let next = q;
+        for (const pattern of patterns) next = next.where(col, filter.op, pattern);
+        return next;
+      }
+    }
     switch (filter.op) {
       case "eq":
         return filter.value === null ? q.where(col, "is", null) : q.where(col, "=", filter.value);