@open-mercato/shared 0.5.1-develop.2691.d8a0934b37 → 0.5.1-develop.2694.732417c5ec

package/dist/lib/query/engine.js

@@ -1,3 +1,4 @@
+import { sql } from "kysely";
 import {
   applyJoinFilters,
   normalizeFilters,
@@ -84,7 +85,7 @@ function buildFilterableCustomFieldJoins(sources) {
     }];
   });
 }
-const computeScore = (cfg, kind, entityIndex) => {
+function computeCustomFieldScore(cfg, kind, entityIndex) {
   const listVisibleScore = cfg.listVisible === false ? 0 : 1;
   const formEditableScore = cfg.formEditable === false ? 0 : 1;
   const filterableScore = cfg.filterable ? 1 : 0;
@@ -111,11 +112,11 @@ const computeScore = (cfg, kind, entityIndex) => {
   const base = listVisibleScore * 16 + formEditableScore * 8 + filterableScore * 4 + kindScore + optionsBonus + dictionaryBonus;
   const penalty = typeof cfg.priority === "number" ? cfg.priority : 0;
   return { base, penalty, entityIndex };
-};
+}
 class BasicQueryEngine {
-  constructor(em, getKnexFn, resolveEncryptionService) {
+  constructor(em, getDbFn, resolveEncryptionService) {
     this.em = em;
-    this.getKnexFn = getKnexFn;
+    this.getDbFn = getDbFn;
     this.resolveEncryptionService = resolveEncryptionService;
     this.columnCache = /* @__PURE__ */ new Map();
     this.tableCache = /* @__PURE__ */ new Map();
@@ -128,6 +129,12 @@ class BasicQueryEngine {
       return null;
     }
   }
+  getDb() {
+    if (this.getDbFn) return this.getDbFn();
+    const emAny = this.em;
+    if (typeof emAny?.getKysely === "function") return emAny.getKysely();
+    throw new Error("BasicQueryEngine requires an EntityManager exposing getKysely() (MikroORM v7)");
+  }
   async query(entity, opts = {}) {
     const ext = opts.extensions;
     let effectiveOpts = opts;
@@ -156,8 +163,8 @@ class BasicQueryEngine {
     const { extensions: _ext, ...coreOpts } = effectiveOpts;
     opts = coreOpts;
     const table = resolveEntityTableName(this.em, entity);
-    const knex = this.getKnexFn ? this.getKnexFn() : this.em.getConnection().getKnex();
-    let q = knex(table);
+    const db = this.getDb();
+    let q = db.selectFrom(table);
     const qualify = (col) => `${table}.${col}`;
     const orgScope = this.resolveOrganizationScope(opts);
     this.searchAliasSeq = 0;
@@ -171,10 +178,10 @@ class BasicQueryEngine {
       q = this.applyOrganizationScope(q, qualify("organization_id"), orgScope);
     }
     if (!skipAutoScope && await this.columnExists(table, "tenant_id")) {
-      q = q.where(qualify("tenant_id"), opts.tenantId);
+      q = q.where(qualify("tenant_id"), "=", opts.tenantId);
     }
     if (!opts.withDeleted && await this.columnExists(table, "deleted_at")) {
-      q = q.whereNull(qualify("deleted_at"));
+      q = q.where(qualify("deleted_at"), "is", null);
     }
     const normalizedFilters = normalizeFilters(opts.filters);
     const resolvedJoins = resolveJoins(
@@ -230,11 +237,11 @@ class BasicQueryEngine {
     }
     const recordIdColumn = qualify("id");
     const applyFilterOp = (builder, column, op, value, fieldName) => {
-      if ((op === "like" || op === "ilike") && searchActive && typeof value === "string" && fieldName) {
+      if ((op === "like" || op === "ilike") && searchActive && typeof value === "string" && fieldName && typeof column === "string") {
         const tokens = tokenizeText(String(value), searchConfig);
         const hashes = tokens.hashes;
         if (hashes.length) {
-          const applied = this.applySearchTokens(builder, {
+          const result = this.applySearchTokens(builder, {
             entity: String(entity),
             field: fieldName,
             hashes,
@@ -248,11 +255,11 @@ class BasicQueryEngine {
             field: fieldName,
             tokens: tokens.tokens,
             hashes,
-            applied,
+            applied: result.applied,
             tenantId: opts.tenantId ?? null,
             organizationScope: orgScope
           });
-          if (applied) return builder;
+          if (result.applied) return result.builder;
         } else {
           this.logSearchDebug("search:skip-empty-hashes", {
             entity: String(entity),
@@ -261,60 +268,21 @@ class BasicQueryEngine {
           });
         }
       }
-      switch (op) {
-        case "eq":
-          if (value === null) builder.whereNull(column);
-          else builder.where(column, value);
-          break;
-        case "ne":
-          if (value === null) builder.whereNotNull(column);
-          else builder.whereNot(column, value);
-          break;
-        case "gt":
-          builder.where(column, ">", value);
-          break;
-        case "gte":
-          builder.where(column, ">=", value);
-          break;
-        case "lt":
-          builder.where(column, "<", value);
-          break;
-        case "lte":
-          builder.where(column, "<=", value);
-          break;
-        case "in":
-          builder.whereIn(column, Array.isArray(value) ? value : [value]);
-          break;
-        case "nin":
-          builder.whereNotIn(column, Array.isArray(value) ? value : [value]);
-          break;
-        case "like":
-          builder.where(column, "like", value);
-          break;
-        case "ilike":
-          builder.where(column, "ilike", value);
-          break;
-        case "exists":
-          value ? builder.whereNotNull(column) : builder.whereNull(column);
-          break;
-        default:
-          break;
-      }
-      return builder;
+      return this.applyColumnOp(builder, column, op, value);
     };
     const applyJoinFilterOp = async (builder, filter, _qualified, join) => {
-      if (!searchEnabled || !join.entityId) return false;
-      if (!["eq", "like", "ilike"].includes(filter.op)) return false;
-      if (typeof filter.value !== "string" || filter.value.trim().length === 0) return false;
+      if (!searchEnabled || !join.entityId) return { applied: false, builder };
+      if (!["like", "ilike"].includes(filter.op)) return { applied: false, builder };
+      if (typeof filter.value !== "string" || filter.value.trim().length === 0) return { applied: false, builder };
       let searchAvailable = joinSearchAvailability.get(join.entityId);
       if (searchAvailable === void 0) {
         searchAvailable = await this.hasSearchTokens(join.entityId, opts.tenantId ?? null, orgScope);
         joinSearchAvailability.set(join.entityId, searchAvailable);
       }
-      if (!searchAvailable) return false;
+      if (!searchAvailable) return { applied: false, builder };
       const tokens = tokenizeText(String(filter.value), searchConfig);
-      if (!tokens.hashes.length) return false;
-      return this.applySearchTokens(builder, {
+      if (!tokens.hashes.length) return { applied: false, builder };
+      const result = this.applySearchTokens(builder, {
         entity: join.entityId,
         field: filter.column,
         hashes: tokens.hashes,
@@ -323,6 +291,7 @@ class BasicQueryEngine {
         organizationScope: orgScope,
         tokens: tokens.tokens
       });
+      return { applied: result.applied, builder: result.builder };
     };
     const regularBaseFilters = baseFilters.filter((f) => !f.orGroup);
     const orGroupFilters = baseFilters.filter((f) => f.orGroup);
@@ -348,7 +317,7 @@ class BasicQueryEngine {
         }
         qualified = qualify(column);
       }
-      applyFilterOp(q, qualified, filter.op, filter.value, fieldName);
+      q = applyFilterOp(q, qualified, filter.op, filter.value, fieldName);
     }
     if (orGroupFilters.length > 0) {
       const groups = /* @__PURE__ */ new Map();
@@ -374,33 +343,27 @@ class BasicQueryEngine {
         if (resolved.length > 0) resolvedGroupFilters.push(resolved);
       }
       if (resolvedGroupFilters.length > 0) {
-        q = q.where(function() {
-          const applyConjunctiveGroup = (builder, conjuncts) => {
-            for (const rf of conjuncts) {
-              applyFilterOp(builder, rf.qualified, rf.op, rf.value, rf.fieldName);
-            }
-          };
-          applyConjunctiveGroup(this, resolvedGroupFilters[0]);
-          for (let gi = 1; gi < resolvedGroupFilters.length; gi++) {
-            this.orWhere(function(nested) {
-              applyConjunctiveGroup(nested, resolvedGroupFilters[gi]);
-            });
-          }
-        });
+        q = q.where((eb) => eb.or(
+          resolvedGroupFilters.map((group) => eb.and(
+            group.map((rf) => this.buildColumnOpExpression(eb, rf.qualified, rf.op, rf.value))
+          ))
+        ));
       }
     }
     const applyAliasScopes = async (builder, aliasName) => {
       const targetTable = aliasTables.get(aliasName);
-      if (!targetTable) return;
+      if (!targetTable) return builder;
+      let next = builder;
       if (!skipAutoScope && orgScope && await this.columnExists(targetTable, "organization_id")) {
-        this.applyOrganizationScope(builder, `${aliasName}.organization_id`, orgScope);
+        next = this.applyOrganizationScope(next, `${aliasName}.organization_id`, orgScope);
       }
       if (!skipAutoScope && opts.tenantId && await this.columnExists(targetTable, "tenant_id")) {
-        builder.where(`${aliasName}.tenant_id`, opts.tenantId);
+        next = next.where(`${aliasName}.tenant_id`, "=", opts.tenantId);
       }
+      return next;
     };
-    await applyJoinFilters({
-      knex,
+    q = await applyJoinFilters({
+      db,
       baseTable: table,
       builder: q,
       joinMap,
@@ -408,22 +371,23 @@ class BasicQueryEngine {
       aliasTables,
       qualifyBase: (column) => qualify(column),
       applyAliasScope: (builder, alias) => applyAliasScopes(builder, alias),
-      applyFilterOp,
+      applyFilterOp: (builder, column, op, value) => applyFilterOp(builder, column, op, value),
       applyJoinFilterOp,
       columnExists: (tbl, column) => this.columnExists(tbl, column)
     });
     if (opts.fields && opts.fields.length) {
       const cols = opts.fields.filter((f) => !f.startsWith("cf:"));
-      if (cols.length) {
-        const baseSelects = cols.map((c) => knex.raw("?? as ??", [qualify(c), c]));
-        q = q.select(baseSelects);
+      for (const c of cols) {
+        q = q.select(sql.ref(qualify(c)).as(c));
       }
     } else {
-      q = q.select(knex.raw("??.*", [table]));
+      q = q.select(sql`${sql.ref(table)}.*`.as("__all"));
     }
     const tenantId = opts.tenantId;
     const sanitize = (s) => s.replace(/[^a-zA-Z0-9_]/g, "_");
-    const cfSources = this.configureCustomFieldSources(q, table, entity, knex, opts, qualify);
+    const cfSourcesResult = this.configureCustomFieldSources(q, table, entity, db, opts, qualify);
+    q = cfSourcesResult.builder;
+    const cfSources = cfSourcesResult.sources;
     const entityIdToSource = /* @__PURE__ */ new Map();
     for (const source of cfSources) {
       entityIdToSource.set(String(source.entityId), source);
@@ -442,11 +406,10 @@ class BasicQueryEngine {
         const entityIdList = Array.from(entityIdToSource.keys());
         const entityOrder = /* @__PURE__ */ new Map();
         entityIdList.forEach((id, idx) => entityOrder.set(id, idx));
-        const rows = await knex("custom_field_defs").select("key", "entity_id", "config_json", "kind").whereIn("entity_id", entityIdList).andWhere("is_active", true).modify((qb) => {
-          qb.andWhere((inner) => {
-            inner.where({ tenant_id: tenantId }).orWhereNull("tenant_id");
-          });
-        });
+        const rows = await db.selectFrom("custom_field_defs").select(["key", "entity_id", "config_json", "kind"]).where("entity_id", "in", entityIdList).where("is_active", "=", true).where((eb) => eb.or([
+          eb("tenant_id", "=", tenantId),
+          eb("tenant_id", "is", null)
+        ])).execute();
         const sorted = rows.map((row) => {
           const raw = row.config_json;
           let cfg = {};
@@ -478,7 +441,7 @@ class BasicQueryEngine {
           if (!source) continue;
           const cfg = row.config || {};
           const entityIndex = entityOrder.get(row.entityId) ?? Number.MAX_SAFE_INTEGER;
-          const scores = computeScore(cfg, row.kind, entityIndex);
+          const scores = computeCustomFieldScore(cfg, row.kind, entityIndex);
           const existing = selectedSources.get(row.key);
           if (!existing || scores.base > existing.score || scores.base === existing.score && (scores.penalty < existing.penalty || scores.penalty === existing.penalty && scores.entityIndex < existing.entityIndex)) {
             selectedSources.set(row.key, { source, score: scores.base, penalty: scores.penalty, entityIndex: scores.entityIndex });
@@ -494,11 +457,10 @@ class BasicQueryEngine {
     }
     const unresolvedKeys = Array.from(cfKeys).filter((key) => !keySource.has(key));
     if (unresolvedKeys.length > 0 && entityIdToSource.size > 0) {
-      const rows = await knex("custom_field_defs").select("key", "entity_id").whereIn("entity_id", Array.from(entityIdToSource.keys())).whereIn("key", unresolvedKeys).andWhere("is_active", true).modify((qb) => {
-        qb.andWhere((inner) => {
-          inner.where({ tenant_id: tenantId }).orWhereNull("tenant_id");
-        });
-      });
+      const rows = await db.selectFrom("custom_field_defs").select(["key", "entity_id"]).where("entity_id", "in", Array.from(entityIdToSource.keys())).where("key", "in", unresolvedKeys).where("is_active", "=", true).where((eb) => eb.or([
+        eb("tenant_id", "=", tenantId),
+        eb("tenant_id", "is", null)
+      ])).execute();
       for (const row of rows) {
         const source = entityIdToSource.get(String(row.entity_id));
         if (!source) continue;
@@ -518,33 +480,39 @@ class BasicQueryEngine {
       const keyAliasSafe = sanitize(key);
       const defAlias = `cfd_${sourceAliasSafe}_${keyAliasSafe}`;
       const valAlias = `cfv_${sourceAliasSafe}_${keyAliasSafe}`;
-      q = q.leftJoin({ [defAlias]: "custom_field_defs" }, function() {
-        this.on(`${defAlias}.entity_id`, "=", knex.raw("?", [entityIdForKey])).andOn(`${defAlias}.key`, "=", knex.raw("?", [key])).andOn(`${defAlias}.is_active`, "=", knex.raw("true")).andOn(knex.raw(`(${defAlias}.tenant_id = ? OR ${defAlias}.tenant_id IS NULL)`, [tenantId]));
-      });
-      q = q.leftJoin({ [valAlias]: "custom_field_values" }, function() {
-        this.on(`${valAlias}.entity_id`, "=", knex.raw("?", [entityIdForKey])).andOn(`${valAlias}.field_key`, "=", knex.raw("?", [key])).andOn(`${valAlias}.record_id`, "=", recordIdExpr).andOn(knex.raw(`(${valAlias}.tenant_id = ? OR ${valAlias}.tenant_id IS NULL)`, [tenantId]));
-      });
-      const caseExpr = knex.raw(
-        `CASE ${defAlias}.kind
-           WHEN 'integer' THEN (${valAlias}.value_int)::text
-           WHEN 'float' THEN (${valAlias}.value_float)::text
-           WHEN 'boolean' THEN (${valAlias}.value_bool)::text
-           WHEN 'multiline' THEN (${valAlias}.value_multiline)::text
-           ELSE (${valAlias}.value_text)::text
-         END`
+      q = q.leftJoin(
+        `custom_field_defs as ${defAlias}`,
+        (jb) => jb.on(`${defAlias}.entity_id`, "=", String(entityIdForKey)).on(`${defAlias}.key`, "=", key).on(`${defAlias}.is_active`, "=", true).on((eb) => eb.or([
+          eb(`${defAlias}.tenant_id`, "=", tenantId),
+          eb(`${defAlias}.tenant_id`, "is", null)
+        ]))
+      );
+      q = q.leftJoin(
+        `custom_field_values as ${valAlias}`,
+        (jb) => jb.on(`${valAlias}.entity_id`, "=", String(entityIdForKey)).on(`${valAlias}.field_key`, "=", key).onRef(`${valAlias}.record_id`, "=", recordIdExpr).on((eb) => eb.or([
+          eb(`${valAlias}.tenant_id`, "=", tenantId),
+          eb(`${valAlias}.tenant_id`, "is", null)
+        ]))
       );
+      const caseExpr = sql`CASE ${sql.ref(`${defAlias}.kind`)}
+           WHEN 'integer' THEN (${sql.ref(`${valAlias}.value_int`)})::text
+           WHEN 'float' THEN (${sql.ref(`${valAlias}.value_float`)})::text
+           WHEN 'boolean' THEN (${sql.ref(`${valAlias}.value_bool`)})::text
+           WHEN 'multiline' THEN (${sql.ref(`${valAlias}.value_multiline`)})::text
+           ELSE (${sql.ref(`${valAlias}.value_text`)})::text
+         END`;
       cfValueExprByKey[key] = caseExpr;
       const alias = sanitize(`cf:${key}`);
       if ((opts.fields || []).includes(`cf:${key}`) || opts.includeCustomFields === true || requestedCustomFieldKeys.length > 0 && requestedCustomFieldKeys.includes(key)) {
-        const isMulti = knex.raw(`bool_or(coalesce((${defAlias}.config_json->>'multi')::boolean, false))`);
-        const aggregatedArray = `array_remove(array_agg(DISTINCT ${caseExpr.toString()}), NULL)`;
-        const expr = `CASE WHEN ${isMulti.toString()}
+        const multiAlias = `${alias}__is_multi`;
+        const isMultiExpr = sql`bool_or(coalesce((${sql.ref(`${defAlias}.config_json`)}->>'multi')::boolean, false))`;
+        const aggregatedArray = sql`array_remove(array_agg(DISTINCT ${caseExpr}), NULL)`;
+        const projExpr = sql`CASE WHEN ${isMultiExpr}
                 THEN to_jsonb(${aggregatedArray})
-                ELSE to_jsonb(max(${caseExpr.toString()}))
+                ELSE to_jsonb(max(${caseExpr}))
            END`;
-        const multiAlias = `${alias}__is_multi`;
-        q = q.select(knex.raw(`${expr} as ??`, [alias]));
-        q = q.select(knex.raw(`${isMulti.toString()} as ??`, [multiAlias]));
+        q = q.select(projExpr.as(alias));
+        q = q.select(isMultiExpr.as(multiAlias));
         cfSelectedAliases.push(alias);
         cfJsonAliases.add(alias);
         cfMultiAliasByAlias.set(alias, multiAlias);
@@ -559,7 +527,7 @@ class BasicQueryEngine {
         const tokens = tokenizeText(String(f.value), searchConfig);
         const hashes = tokens.hashes;
         if (hashes.length) {
-          const applied = this.applySearchTokens(q, {
+          const result = this.applySearchTokens(q, {
             entity: String(entity),
             field: f.field,
             hashes,
@@ -573,11 +541,14 @@ class BasicQueryEngine {
             field: f.field,
             tokens: tokens.tokens,
             hashes,
-            applied,
+            applied: result.applied,
             tenantId: opts.tenantId ?? null,
             organizationScope: orgScope
           });
-          if (applied) continue;
+          if (result.applied) {
+            q = result.builder;
+            continue;
+          }
         } else {
           this.logSearchDebug("search:cf-skip-empty-hashes", {
             entity: String(entity),
@@ -586,41 +557,7 @@ class BasicQueryEngine {
           });
         }
       }
-      switch (f.op) {
-        case "eq":
-          q = q.where(expr, "=", f.value);
-          break;
-        case "ne":
-          q = q.where(expr, "!=", f.value);
-          break;
-        case "gt":
-          q = q.where(expr, ">", f.value);
-          break;
-        case "gte":
-          q = q.where(expr, ">=", f.value);
-          break;
-        case "lt":
-          q = q.where(expr, "<", f.value);
-          break;
-        case "lte":
-          q = q.where(expr, "<=", f.value);
-          break;
-        case "in":
-          q = q.whereIn(expr, f.value ?? []);
-          break;
-        case "nin":
-          q = q.whereNotIn(expr, f.value ?? []);
-          break;
-        case "like":
-          q = q.where(expr, "like", f.value);
-          break;
-        case "ilike":
-          q = q.where(expr, "ilike", f.value);
-          break;
-        case "exists":
-          f.value ? q = q.whereNotNull(expr) : q = q.whereNull(expr);
-          break;
-      }
+      q = this.applyColumnOp(q, expr, f.op, f.value);
     }
     if (opts.includeExtensions) {
       const { getModules } = await import("@open-mercato/shared/lib/i18n/server");
@@ -632,9 +569,10 @@ class BasicQueryEngine {
         const [, extName] = e.extension.split(":");
         const extTable = extName.endsWith("s") ? extName : `${extName}s`;
         const alias = `ext_${sanitize(extName)}`;
-        q = q.leftJoin({ [alias]: extTable }, function() {
-          this.on(`${alias}.${e.join.extensionKey}`, "=", knex.raw("??", [`${table}.${e.join.baseKey}`]));
-        });
+        q = q.leftJoin(
+          `${extTable} as ${alias}`,
+          (jb) => jb.onRef(`${alias}.${e.join.extensionKey}`, "=", `${table}.${e.join.baseKey}`)
+        );
       }
     }
     for (const s of opts.sort || []) {
@@ -644,7 +582,7 @@ class BasicQueryEngine {
         if (!cfSelectedAliases.includes(alias)) {
           const expr = cfValueExprByKey[key];
           if (expr) {
-            q = q.select(knex.raw(`max(${expr.toString()}) as ??`, [alias]));
+            q = q.select(sql`max(${expr})`.as(alias));
             cfSelectedAliases.push(alias);
           }
         }
@@ -657,16 +595,14 @@ class BasicQueryEngine {
     }
     const page = opts.page?.page ?? 1;
     const pageSize = opts.page?.pageSize ?? 20;
-    if (opts.includeExtensions && (Array.isArray(opts.includeExtensions) ? opts.includeExtensions.length > 0 : true) || Object.keys(cfValueExprByKey).length > 0) {
+    const hasJoinedAggregates = opts.includeExtensions && (Array.isArray(opts.includeExtensions) ? opts.includeExtensions.length > 0 : true) || Object.keys(cfValueExprByKey).length > 0;
+    if (hasJoinedAggregates) {
       q = q.groupBy(`${table}.id`);
     }
-    const countClone = q.clone();
-    if (typeof countClone.clearSelect === "function") countClone.clearSelect();
-    if (typeof countClone.clearOrder === "function") countClone.clearOrder();
-    if (typeof countClone.clearGroup === "function") countClone.clearGroup();
-    const countRow = await countClone.countDistinct(`${table}.id as count`).first();
+    const countBuilder = hasJoinedAggregates ? q.clearSelect().clearOrderBy().clearGroupBy().select(sql`count(distinct ${sql.ref(`${table}.id`)})`.as("count")) : q.clearSelect().clearOrderBy().select(sql`count(distinct ${sql.ref(`${table}.id`)})`.as("count"));
+    const countRow = await countBuilder.executeTakeFirst();
     const total = Number(countRow?.count ?? 0);
-    const items = await q.limit(pageSize).offset((page - 1) * pageSize);
+    const items = await q.limit(pageSize).offset((page - 1) * pageSize).execute();
     if (cfJsonAliases.size > 0) {
       for (const row of items) {
         for (const alias of cfJsonAliases) {
@@ -725,6 +661,62 @@ class BasicQueryEngine {
     }
     return queryResult;
   }
+  applyColumnOp(builder, column, op, value) {
+    switch (op) {
+      case "eq":
+        return value === null ? builder.where(column, "is", null) : builder.where(column, "=", value);
+      case "ne":
+        return value === null ? builder.where(column, "is not", null) : builder.where(column, "!=", value);
+      case "gt":
+        return builder.where(column, ">", value);
+      case "gte":
+        return builder.where(column, ">=", value);
+      case "lt":
+        return builder.where(column, "<", value);
+      case "lte":
+        return builder.where(column, "<=", value);
+      case "in":
+        return builder.where(column, "in", Array.isArray(value) ? value : [value]);
+      case "nin":
+        return builder.where(column, "not in", Array.isArray(value) ? value : [value]);
+      case "like":
+        return builder.where(column, "like", value);
+      case "ilike":
+        return builder.where(column, "ilike", value);
+      case "exists":
+        return value ? builder.where(column, "is not", null) : builder.where(column, "is", null);
+      default:
+        return builder;
+    }
+  }
+  buildColumnOpExpression(eb, column, op, value) {
+    switch (op) {
+      case "eq":
+        return value === null ? eb(column, "is", null) : eb(column, "=", value);
+      case "ne":
+        return value === null ? eb(column, "is not", null) : eb(column, "!=", value);
+      case "gt":
+        return eb(column, ">", value);
+      case "gte":
+        return eb(column, ">=", value);
+      case "lt":
+        return eb(column, "<", value);
+      case "lte":
+        return eb(column, "<=", value);
+      case "in":
+        return eb(column, "in", Array.isArray(value) ? value : [value]);
+      case "nin":
+        return eb(column, "not in", Array.isArray(value) ? value : [value]);
+      case "like":
+        return eb(column, "like", value);
+      case "ilike":
+        return eb(column, "ilike", value);
+      case "exists":
+        return value ? eb(column, "is not", null) : eb(column, "is", null);
+      default:
+        return eb.val(true);
+    }
+  }
   async resolveBaseColumn(table, field) {
     if (await this.columnExists(table, field)) return field;
     if (field === "organization_id" && await this.columnExists(table, "id")) return "id";
@@ -737,8 +729,8 @@ class BasicQueryEngine {
       if (cached === true) return true;
       this.columnCache.delete(key);
     }
-    const knex = this.getKnexFn ? this.getKnexFn() : this.em.getConnection().getKnex();
-    const exists = await knex("information_schema.columns").where({ table_name: table, column_name: column }).first();
+    const db = this.getDb();
+    const exists = await db.selectFrom("information_schema.columns").select(sql`1`.as("one")).where("table_name", "=", table).where("column_name", "=", column).limit(1).executeTakeFirst();
     const present = !!exists;
     if (present) this.columnCache.set(key, true);
     else this.columnCache.delete(key);
@@ -746,23 +738,23 @@ class BasicQueryEngine {
   }
   async tableExists(table) {
     if (this.tableCache.has(table)) return this.tableCache.get(table) ?? false;
-    const knex = this.getKnexFn ? this.getKnexFn() : this.em.getConnection().getKnex();
-    const exists = await knex("information_schema.tables").where({ table_name: table }).first();
+    const db = this.getDb();
+    const exists = await db.selectFrom("information_schema.tables").select(sql`1`.as("one")).where("table_name", "=", table).limit(1).executeTakeFirst();
     const present = !!exists;
     this.tableCache.set(table, present);
     return present;
   }
   async hasSearchTokens(entity, tenantId, orgScope) {
     try {
-      const knex = this.getKnexFn ? this.getKnexFn() : this.em.getConnection().getKnex();
-      const query = knex("search_tokens").select(1).where("entity_type", entity).limit(1);
+      const db = this.getDb();
+      let query = db.selectFrom("search_tokens").select(sql`1`.as("one")).where("entity_type", "=", entity).limit(1);
       if (tenantId !== void 0) {
-        query.andWhereRaw("tenant_id is not distinct from ?", [tenantId]);
+        query = query.where(sql`tenant_id is not distinct from ${tenantId}`);
       }
       if (orgScope) {
-        this.applyOrganizationScope(query, "search_tokens.organization_id", orgScope);
+        query = this.applyOrganizationScope(query, "search_tokens.organization_id", orgScope);
       }
-      const row = await query.first();
+      const row = await query.executeTakeFirst();
       return !!row;
     } catch (err) {
       this.logSearchDebug("search:has-tokens-error", {
@@ -782,10 +774,9 @@ class BasicQueryEngine {
         tenantId: opts.tenantId ?? null,
         organizationScope: opts.organizationScope
       });
-      return false;
+      return { applied: false, builder: q };
     }
     const alias = `st_${this.searchAliasSeq++}`;
-    const combineWith = opts.combineWith === "or" ? "orWhereExists" : "whereExists";
     const engine = this;
     this.logSearchDebug("search:apply-search-tokens", {
       entity: opts.entity,
@@ -797,23 +788,30 @@ class BasicQueryEngine {
       organizationScope: opts.organizationScope,
       combineWith: opts.combineWith ?? "and"
     });
-    q[combineWith](function() {
-      this.select(1).from({ [alias]: "search_tokens" }).where(`${alias}.entity_type`, opts.entity).andWhere(`${alias}.field`, opts.field).andWhereRaw("?? = ??::text", [`${alias}.entity_id`, opts.recordIdColumn]).whereIn(`${alias}.token_hash`, opts.hashes).groupBy(`${alias}.entity_id`, `${alias}.field`).havingRaw(`count(distinct ${alias}.token_hash) >= ?`, [opts.hashes.length]);
+    const buildSub = (eb) => {
+      let sub = eb.selectFrom(`search_tokens as ${alias}`).select(sql`1`.as("one")).where(`${alias}.entity_type`, "=", opts.entity).where(`${alias}.field`, "=", opts.field).where(sql`${sql.ref(`${alias}.entity_id`)} = ${sql.ref(opts.recordIdColumn)}::text`).where(`${alias}.token_hash`, "in", opts.hashes).groupBy([`${alias}.entity_id`, `${alias}.field`]).having(sql`count(distinct ${sql.ref(`${alias}.token_hash`)}) >= ${opts.hashes.length}`);
       if (opts.tenantId !== void 0) {
-        this.andWhereRaw(`${alias}.tenant_id is not distinct from ?`, [opts.tenantId ?? null]);
+        sub = sub.where(sql`${sql.ref(`${alias}.tenant_id`)} is not distinct from ${opts.tenantId ?? null}`);
       }
       if (opts.organizationScope) {
-        engine.applyOrganizationScope(this, `${alias}.organization_id`, opts.organizationScope);
+        sub = engine.applyOrganizationScope(sub, `${alias}.organization_id`, opts.organizationScope);
       }
-    });
-    return true;
+      return sub;
+    };
+    const combiner = opts.combineWith === "or" ? "or" : "and";
+    if (combiner === "or") {
+      const next2 = q.where((eb) => eb.or([eb.exists(buildSub(eb))]));
+      return { applied: true, builder: next2 };
+    }
+    const next = q.where((eb) => eb.exists(buildSub(eb)));
+    return { applied: true, builder: next };
   }
   applyIndexDocFilter(q, opts) {
     if ((opts.op === "like" || opts.op === "ilike") && opts.searchActive && typeof opts.value === "string") {
       const tokens = tokenizeText(String(opts.value), opts.searchConfig);
       const hashes = tokens.hashes;
       if (hashes.length) {
-        const applied = this.applySearchTokens(q, {
+        const result = this.applySearchTokens(q, {
           entity: opts.entity,
           field: opts.field,
           hashes,
@@ -827,11 +825,11 @@ class BasicQueryEngine {
           field: opts.field,
           tokens: tokens.tokens,
           hashes,
-          applied,
+          applied: result.applied,
           tenantId: opts.tenantId ?? null,
           organizationScope: opts.organizationScope
         });
-        if (applied) return q;
+        if (result.applied) return result.builder;
       } else {
         this.logSearchDebug("search:index-doc-skip-empty-hashes", {
           entity: opts.entity,
@@ -841,66 +839,71 @@ class BasicQueryEngine {
       }
       return q;
     }
-    const knex = this.getKnexFn ? this.getKnexFn() : this.em.getConnection().getKnex();
     const alias = `ei_${this.searchAliasSeq++}`;
     const engine = this;
-    return q.whereExists(function() {
-      this.select(1).from({ [alias]: "entity_indexes" }).where(`${alias}.entity_type`, opts.entity).andWhereRaw("?? = ??::text", [`${alias}.entity_id`, opts.recordIdColumn]);
+    return q.where((eb) => eb.exists((() => {
+      let sub = eb.selectFrom(`entity_indexes as ${alias}`).select(sql`1`.as("one")).where(`${alias}.entity_type`, "=", opts.entity).where(sql`${sql.ref(`${alias}.entity_id`)} = ${sql.ref(opts.recordIdColumn)}::text`);
       if (opts.tenantId !== void 0) {
-        this.andWhereRaw(`${alias}.tenant_id is not distinct from ?`, [opts.tenantId ?? null]);
+        sub = sub.where(sql`${sql.ref(`${alias}.tenant_id`)} is not distinct from ${opts.tenantId ?? null}`);
       }
       if (opts.organizationScope) {
-        engine.applyOrganizationScope(this, `${alias}.organization_id`, opts.organizationScope);
+        sub = engine.applyOrganizationScope(sub, `${alias}.organization_id`, opts.organizationScope);
       }
       if (!opts.withDeleted) {
-        this.whereNull(`${alias}.deleted_at`);
+        sub = sub.where(`${alias}.deleted_at`, "is", null);
       }
-      const text = knex.raw(`(${alias}.doc ->> ?)`, [opts.field]);
+      const textExpr = sql`(${sql.ref(`${alias}.doc`)} ->> ${opts.field})`;
       switch (opts.op) {
         case "eq":
-          this.where(text, "=", opts.value);
+          sub = sub.where(sql`${textExpr} = ${opts.value}`);
           break;
         case "ne":
-          this.where(text, "!=", opts.value);
+          sub = sub.where(sql`${textExpr} <> ${opts.value}`);
           break;
         case "gt":
         case "gte":
         case "lt":
         case "lte": {
-          const operator = opts.op === "gt" ? ">" : opts.op === "gte" ? ">=" : opts.op === "lt" ? "<" : "<=";
-          this.where(text, operator, opts.value);
+          const operator = sql.raw(opts.op === "gt" ? ">" : opts.op === "gte" ? ">=" : opts.op === "lt" ? "<" : "<=");
+          sub = sub.where(sql`${textExpr} ${operator} ${opts.value}`);
           break;
         }
-        case "in":
-          this.whereIn(text, Array.isArray(opts.value) ? opts.value : [opts.value]);
+        case "in": {
+          const vals = Array.isArray(opts.value) ? opts.value : [opts.value];
+          sub = sub.where(sql`${textExpr} in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
           break;
-        case "nin":
-          this.whereNotIn(text, Array.isArray(opts.value) ? opts.value : [opts.value]);
+        }
+        case "nin": {
+          const vals = Array.isArray(opts.value) ? opts.value : [opts.value];
+          sub = sub.where(sql`${textExpr} not in (${sql.join(vals.map((v) => sql`${v}`), sql`, `)})`);
           break;
+        }
         case "like":
-          this.where(text, "like", opts.value);
+          sub = sub.where(sql`${textExpr} like ${opts.value}`);
           break;
         case "ilike":
-          this.where(text, "ilike", opts.value);
+          sub = sub.where(sql`${textExpr} ilike ${opts.value}`);
           break;
         case "exists":
-          opts.value ? this.whereNotNull(text) : this.whereNull(text);
+          sub = opts.value ? sub.where(sql`${textExpr} is not null`) : sub.where(sql`${textExpr} is null`);
           break;
         default:
           break;
       }
-    });
+      return sub;
+    })()));
   }
-  configureCustomFieldSources(q, baseTable, baseEntity, knex, opts, qualify) {
+  configureCustomFieldSources(q, baseTable, baseEntity, db, opts, qualify) {
     const sources = [
       {
         entityId: baseEntity,
         alias: "base",
         table: baseTable,
-        recordIdExpr: knex.raw("??::text", [`${baseTable}.id`])
+        recordIdExpr: sql`${sql.ref(`${baseTable}.id`)}::text`
       }
     ];
     const extras = opts.customFieldSources ?? [];
+    let next = q;
     extras.forEach((srcOpt, index) => {
       const joinTable = srcOpt.table ?? resolveEntityTableName(this.em, srcOpt.entityId);
       const alias = srcOpt.alias ?? `cfs_${index}`;
@@ -908,22 +911,17 @@ class BasicQueryEngine {
       if (!join) {
         throw new Error(`QueryEngine: customFieldSources entry for ${String(srcOpt.entityId)} requires a join configuration`);
       }
-      const joinArgs = { [alias]: joinTable };
-      const joinCallback = function() {
-        this.on(`${alias}.${join.toField}`, "=", qualify(join.fromField));
-      };
-      const joinType = join.type ?? "left";
-      if (joinType === "inner") q.join(joinArgs, joinCallback);
-      else q.leftJoin(joinArgs, joinCallback);
+      const joinFn = (join.type ?? "left") === "inner" ? "innerJoin" : "leftJoin";
+      next = next[joinFn](`${joinTable} as ${alias}`, (jb) => jb.onRef(`${alias}.${join.toField}`, "=", qualify(join.fromField)));
       const recordColumn = srcOpt.recordIdColumn ?? "id";
       sources.push({
         entityId: srcOpt.entityId,
         alias,
         table: joinTable,
-        recordIdExpr: knex.raw("??::text", [`${alias}.${recordColumn}`])
+        recordIdExpr: sql`${sql.ref(`${alias}.${recordColumn}`)}::text`
       });
     });
-    return sources;
+    return { builder: next, sources };
   }
   logSearchDebug(event, payload) {
     try {
@@ -947,20 +945,14 @@ class BasicQueryEngine {
   applyOrganizationScope(q, column, scope) {
     if (!scope) return q;
     if (scope.ids.length === 0 && !scope.includeNull) {
-      return q.whereRaw("1 = 0");
-    }
-    return q.where((builder) => {
-      let applied = false;
-      if (scope.ids.length > 0) {
-        builder.whereIn(column, scope.ids);
-        applied = true;
-      }
-      if (scope.includeNull) {
-        if (applied) builder.orWhereNull(column);
-        else builder.whereNull(column);
-        applied = true;
-      }
-      if (!applied) builder.whereRaw("1 = 0");
+      return q.where(sql`1 = 0`);
+    }
+    return q.where((eb) => {
+      const parts = [];
+      if (scope.ids.length > 0) parts.push(eb(column, "in", scope.ids));
+      if (scope.includeNull) parts.push(eb(column, "is", null));
+      if (parts.length === 1) return parts[0];
+      return eb.or(parts);
     });
   }
 }