@open-mercato/shared 0.5.1-develop.2691.d8a0934b37 → 0.5.1-develop.2699.f8b50c8046

package/src/lib/query/__tests__/engine.test.ts

@@ -17,7 +17,18 @@ function cloneRows(rows: any[] | undefined): any[] {
   return rows.map((row) => ({ ...row }))
 }
 
-function createFakeKnex(overrides?: FakeData) {
+/**
+ * Build a fake Kysely that mimics the fluent API used by BasicQueryEngine.
+ * Records operations on each SelectQueryBuilder so tests can inspect:
+ *  - _ops.table / _ops.alias    — starting table (selectFrom target)
+ *  - _ops.wheres                — `[type, ...args]` tuples
+ *  - _ops.joins                 — `[{ type, aliasObj, conditions }]`
+ *  - _ops.orderBys              — `[[column, dir]]`
+ *  - _ops.groups                — grouped columns
+ *  - _ops.selects               — select arguments
+ *  - _ops.limits / _ops.offsets — pagination knobs
+ */
+function createFakeKysely(overrides?: FakeData) {
   const calls: any[] = []
   const defaultData: FakeData = {
     custom_field_defs: [
@@ -30,115 +41,177 @@ function createFakeKnex(overrides?: FakeData) {
   const data: FakeData = Object.fromEntries(
     Object.entries(sourceData).map(([table, rows]) => [table, cloneRows(rows)])
   )
-  function raw(sql: string, params?: any[]) { return { toString: () => sql, sql, params } }
-  function builderFor(tableArg: any) {
-    let table = ''
-    let alias: string | null = null
-    if (typeof tableArg === 'string') {
-      table = tableArg
-    } else if (tableArg && typeof tableArg === 'object') {
-      const first = Object.entries(tableArg)[0]
-      if (first) {
-        alias = String(first[0])
-        table = String(first[1])
-      }
-    } else {
-      table = String(tableArg || '')
+
+  function parseTableSpec(spec: unknown): { table: string; alias: string | null } {
+    if (typeof spec !== 'string') return { table: String(spec || ''), alias: null }
+    const asMatch = /^(.+?)\s+as\s+(.+)$/i.exec(spec)
+    if (asMatch) return { table: asMatch[1].trim(), alias: asMatch[2].trim() }
+    return { table: spec, alias: null }
+  }
+
+  function createExpressionBuilder() {
+    const eb: any = (column: any, op: any, value: any) => ({ kind: 'cmp', column, op, value })
+    eb.and = (parts: any[]) => ({ kind: 'and', parts })
+    eb.or = (parts: any[]) => ({ kind: 'or', parts })
+    eb.not = (part: any) => ({ kind: 'not', part })
+    eb.exists = (sub: any) => ({ kind: 'exists', sub })
+    eb.val = (value: any) => ({ kind: 'val', value })
+    eb.ref = (name: string) => ({ kind: 'ref', name })
+    eb.selectFrom = (spec: any) => builderFor(spec)
+    return eb
+  }
+
+  function normalizeWhereArgs(args: any[]): any[] {
+    if (args.length === 1 && typeof args[0] === 'function') {
+      const produced = args[0](createExpressionBuilder())
+      if (produced && produced.kind === 'or') return ['or', produced.parts]
+      if (produced && produced.kind === 'exists') return ['exists', produced.sub]
+      if (produced && produced.kind === 'not' && produced.part?.kind === 'exists') return ['notExists', produced.part.sub]
+      return ['expr', produced]
     }
-    const ops = { table, alias, wheres: [] as any[], joins: [] as any[], selects: [] as any[], orderBys: [] as any[], groups: [] as any[], limits: 0, offsets: 0, isCountDistinct: false }
-    function recordJoin(type: 'left' | 'inner', aliasObj: any, fn: Function, ctxBuilder: () => any) {
-      const entry: any = { type, aliasObj, conditions: [] as any[] }
-      const ctx = ctxBuilder()
-      ctx.on = (left: any, op: any, right: any) => {
+    // (col, op, value) or sql template
+    return args
+  }
+
+  function recordJoin(ops: any, type: 'left' | 'inner', spec: any, fn: Function) {
+    const parsed = parseTableSpec(spec)
+    const aliasObj = parsed.alias ? { [parsed.alias]: parsed.table } : { [parsed.table]: parsed.table }
+    const entry: any = { type, aliasObj, conditions: [] as any[] }
+    const ctx: any = {}
+    ctx.on = (left: any, op?: any, right?: any) => {
+      if (typeof left === 'function') {
+        const expr = left(createExpressionBuilder())
+        entry.conditions.push({ method: 'on', expr })
+      } else {
         entry.conditions.push({ method: 'on', args: [left, op, right] })
-        return ctx
       }
-      ctx.andOn = (left: any, op: any, right: any) => {
-        entry.conditions.push({ method: 'andOn', args: [left, op, right] })
-        return ctx
-      }
-      fn.call(ctx)
-      ops.joins.push(entry)
+      return ctx
+    }
+    ctx.onRef = (left: any, op: any, right: any) => {
+      entry.conditions.push({ method: 'on', args: [left, op, right] })
+      return ctx
     }
+    const result = fn(ctx)
+    // onRef/on chain returns ctx; nothing else to do
+    void result
+    ops.joins.push(entry)
+  }
+
+  function makeBuilder(ops: any, record: boolean): any {
     const b: any = {
       _ops: ops,
-      select: function (...cols: any[]) { ops.selects.push(cols); return this },
-      where: function (...args: any[]) { ops.wheres.push(args); return this },
-      andWhere: function (...args: any[]) { ops.wheres.push(args); return this },
-      whereIn: function (...args: any[]) { ops.wheres.push(['in', ...args]); return this },
-      whereNotIn: function (...args: any[]) { ops.wheres.push(['notIn', ...args]); return this },
-      whereNull: function (col: any) { ops.wheres.push(['isNull', col]); return this },
-      whereNotNull: function (col: any) { ops.wheres.push(['notNull', col]); return this },
-      whereExists: function (sub: any) { ops.wheres.push(['exists', sub]); return this },
-      whereNotExists: function (sub: any) { ops.wheres.push(['notExists', sub]); return this },
-      whereRaw: function (...args: any[]) { ops.wheres.push(['raw', ...args]); return this },
-      orWhereNull: function (col: any) { ops.wheres.push(['orWhereNull', col]); return this },
-      leftJoin: function (aliasObj: any, fn: Function) {
-        recordJoin('left', aliasObj, fn, () => ({}))
+      select(this: any, ...cols: any[]) {
+        if (cols.length === 1 && Array.isArray(cols[0])) this._ops.selects.push(...cols[0])
+        else this._ops.selects.push(...cols)
         return this
       },
-      join: function (aliasObj: any, fn: Function) {
-        recordJoin('inner', aliasObj, fn, () => ({}))
+      distinct(this: any) { return this },
+      where(this: any, ...args: any[]) {
+        this._ops.wheres.push(normalizeWhereArgs(args))
         return this
       },
-      orderBy: function (col: any, dir?: any) { ops.orderBys.push([col, dir]); return this },
-      groupBy: function (col: any) { ops.groups.push(col); return this },
-      limit: function (n: number) { ops.limits = n; return this },
-      offset: function (n: number) { ops.offsets = n; return this },
-      clone: function () { return this },
-      countDistinct: function () { ops.isCountDistinct = true; return this },
-      count: async function () { return [{ count: '0' }] },
-      first: async function () { 
-        // If this is called after countDistinct, return count data
-        if (ops.isCountDistinct) {
-          return { count: '0' }
-        }
-        const rows = data[table] || []; 
-        return rows[0] 
+      whereRef(this: any, left: any, op: any, right: any) {
+        this._ops.wheres.push(['ref', left, op, right])
+        return this
       },
-      modify: function (fn: Function) {
-        const qb: any = {
-          andWhere: (arg: any) => {
-            if (typeof arg === 'function') {
-              const inner: any = {
-                where: (obj: any) => ({
-                  orWhereNull: (col: any) => { ops.wheres.push(['andWhereFn', obj, ['orWhereNull', col]]); return inner },
-                }),
-              }
-              arg(inner)
-            } else {
-              ops.wheres.push(['andWhere', arg])
-            }
-            return qb
-          },
-          whereNull: (col: any) => { ops.wheres.push(['isNull', col]); return qb },
-        }
-        fn(qb)
+      leftJoin(this: any, spec: any, fn: Function) { recordJoin(this._ops, 'left', spec, fn); return this },
+      innerJoin(this: any, spec: any, fn: Function) { recordJoin(this._ops, 'inner', spec, fn); return this },
+      groupBy(this: any, arg: any) {
+        if (Array.isArray(arg)) this._ops.groups.push(...arg)
+        else this._ops.groups.push(arg)
         return this
       },
-      then: function (resolve: any) { const res = data[table] || []; return Promise.resolve(resolve(res)) },
+      having(this: any) { return this },
+      orderBy(this: any, col: any, dir?: any) { this._ops.orderBys.push([col, dir]); return this },
+      limit(this: any, n: number) { this._ops.limits = n; return this },
+      offset(this: any, n: number) { this._ops.offsets = n; return this },
+      clearSelect(this: any) {
+        const nextOps = { ...this._ops, selects: [] }
+        return makeBuilder(nextOps, false)
+      },
+      clearOrderBy(this: any) {
+        const nextOps = { ...this._ops, orderBys: [] }
+        return makeBuilder(nextOps, false)
+      },
+      clearGroupBy(this: any) {
+        const nextOps = { ...this._ops, groups: [] }
+        return makeBuilder(nextOps, false)
+      },
+      as(this: any, alias: string) { this._ops.alias = alias; return this },
+      async execute(this: any) { return cloneRows(data[this._ops.table]) },
+      async executeTakeFirst(this: any) {
+        const localOps = this._ops
+        if (localOps.table === 'information_schema.columns') {
+          const infoRows = data['information_schema.columns']
+          if (!Array.isArray(infoRows)) return undefined
+          const targetTable = extractEqValue(localOps.wheres, 'table_name')
+          const targetColumn = extractEqValue(localOps.wheres, 'column_name')
+          return infoRows.find((row: any) =>
+            (!targetTable || row.table_name === targetTable) &&
+            (!targetColumn || row.column_name === targetColumn)
+          )
+        }
+        if (localOps.table === 'information_schema.tables') {
+          const infoRows = data['information_schema.tables']
+          if (!Array.isArray(infoRows)) return undefined
+          const targetTable = extractEqValue(localOps.wheres, 'table_name')
+          return infoRows.find((row: any) => !targetTable || row.table_name === targetTable)
+        }
+        if (localOps.selects.some((s: any) => s && typeof s === 'object' && (s.__isCount || String(s?.alias || '') === 'count'))) {
+          return { count: '0' }
+        }
+        const rows = data[localOps.table] || []
+        if (rows.length === 0) return { count: '0' }
+        return rows[0]
+      },
     }
-    calls.push(b)
+    if (record) calls.push(b)
     return b
   }
-  const fn: any = (table: any) => builderFor(table)
-  fn.raw = raw
-  fn._calls = calls
-  return fn
+
+  function builderFor(tableArg: any): any {
+    const parsed = parseTableSpec(tableArg)
+    const ops = {
+      table: parsed.table,
+      alias: parsed.alias,
+      wheres: [] as any[],
+      joins: [] as any[],
+      selects: [] as any[],
+      orderBys: [] as any[],
+      groups: [] as any[],
+      limits: 0,
+      offsets: 0,
+    }
+    return makeBuilder(ops, true)
+  }
+
+  function extractEqValue(wheres: any[], column: string): any {
+    for (const entry of wheres) {
+      if (!Array.isArray(entry)) continue
+      if (entry[0] === column && entry[1] === '=') return entry[2]
+    }
+    return undefined
+  }
+
+  const db: any = {
+    selectFrom(spec: any) { return builderFor(spec) },
+  }
+  db._calls = calls
+  return db
 }
 
-describe('BasicQueryEngine', () => {
+describe('BasicQueryEngine (Kysely)', () => {
   test('pluralizes entity names ending with y correctly', async () => {
-    const fakeKnex = createFakeKnex()
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const fakeDb = createFakeKysely()
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('customers:customer_entity', { tenantId: 't1' })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'customer_entities')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'customer_entities')
     expect(baseCall).toBeTruthy()
   })
 
   test('includeCustomFields true discovers keys and allows sort on cf:*; joins extensions', async () => {
-    const fakeKnex = createFakeKnex()
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const fakeDb = createFakeKysely()
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     const res = await engine.query('auth:user', {
       includeCustomFields: true,
       fields: ['id','email','cf:vip'],
@@ -149,25 +222,29 @@ describe('BasicQueryEngine', () => {
       page: { page: 1, pageSize: 10 },
     })
     expect(res).toMatchObject({ page: 1, pageSize: 10, total: 0, items: [] })
-    // Assert that custom_field_defs was queried for this entity and org
-    const defsCall = fakeKnex._calls.find((b: any) => b._ops.table === 'custom_field_defs')
+    const defsCall = fakeDb._calls.find((b: any) => b._ops.table === 'custom_field_defs')
     expect(defsCall).toBeTruthy()
-    const hasEntityFilter = defsCall._ops.wheres.some((w: any) => JSON.stringify(w).includes('entity_id'))
+    // Tenant filter (OR tenant_id is null) is expressed as an OR expression in Kysely
+    const hasEntityFilter = defsCall._ops.wheres.some((w: any) =>
+      Array.isArray(w) && w[0] === 'entity_id' && w[1] === 'in'
+    )
     expect(hasEntityFilter).toBe(true)
-    // Organization-level scoping is intentionally disabled for custom field definitions; ensure tenant filter is present
-    const hasTenantFilter = defsCall._ops.wheres.some((w: any) => JSON.stringify(w).includes('tenant_id'))
+    const hasTenantFilter = defsCall._ops.wheres.some((w: any) => {
+      if (!Array.isArray(w)) return false
+      const [kind, parts] = w
+      if (kind !== 'or' || !Array.isArray(parts)) return false
+      return parts.some((part: any) => part?.column === 'tenant_id' && part?.op === '=')
+    })
     expect(hasTenantFilter).toBe(true)
-    // Assert base ordering by cf alias was recorded
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'users')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'users')
     const hasCfOrder = baseCall._ops.orderBys.some((o: any) => o[0] === 'cf_vip')
     expect(hasCfOrder).toBe(true)
-    // Assert an extension leftJoin was attempted
     const hasExtJoin = baseCall._ops.joins.length > 0
     expect(hasExtJoin).toBe(true)
   })
 
   test('customFieldSources join additional profiles for custom fields', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       custom_field_defs: [
         { key: 'birthday', entity_id: 'customers:customer_person_profile', is_active: true, config_json: JSON.stringify({ listVisible: true }), kind: 'text' },
         { key: 'sector', entity_id: 'customers:customer_company_profile', is_active: true, config_json: JSON.stringify({ listVisible: true }), kind: 'select' },
@@ -177,7 +254,7 @@ describe('BasicQueryEngine', () => {
       customer_people: [],
       customer_companies: [],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('customers:customer_entity', {
       tenantId: 't1',
       includeCustomFields: ['birthday', 'sector'],
@@ -200,7 +277,7 @@ describe('BasicQueryEngine', () => {
       ],
       page: { page: 1, pageSize: 10 },
     })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'customer_entities')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'customer_entities')
     expect(baseCall).toBeTruthy()
     const joinAliases = baseCall._ops.joins.map((j: any) => Object.keys(j.aliasObj)[0])
     expect(joinAliases).toEqual(expect.arrayContaining([
@@ -212,19 +289,22 @@ describe('BasicQueryEngine', () => {
       'cfv_company_profile_sector',
     ]))
     const personProfileJoin = baseCall._ops.joins.find((j: any) => j.aliasObj.person_profile)
-    expect(personProfileJoin?.conditions.some((c: any) => c.args[0] === 'person_profile.entity_id' && c.args[2] === 'customer_entities.id')).toBe(true)
+    expect(personProfileJoin?.conditions.some((c: any) => c.args?.[0] === 'person_profile.entity_id' && c.args?.[2] === 'customer_entities.id')).toBe(true)
     const companyProfileJoin = baseCall._ops.joins.find((j: any) => j.aliasObj.company_profile)
-    expect(companyProfileJoin?.conditions.some((c: any) => c.args[0] === 'company_profile.entity_id' && c.args[2] === 'customer_entities.id')).toBe(true)
+    expect(companyProfileJoin?.conditions.some((c: any) => c.args?.[0] === 'company_profile.entity_id' && c.args?.[2] === 'customer_entities.id')).toBe(true)
+    // cfv joins use onRef(`${valAlias}.record_id`, '=', recordIdExpr) where recordIdExpr is a sql template referencing person_profile.id
     const cfvPersonJoin = baseCall._ops.joins.find((j: any) => j.aliasObj.cfv_person_profile_birthday)
-    expect(cfvPersonJoin?.conditions.some((c: any) => c.args[0] === 'cfv_person_profile_birthday.record_id' && c.args[2]?.params?.[0] === 'person_profile.id')).toBe(true)
+    expect(cfvPersonJoin).toBeTruthy()
+    expect(cfvPersonJoin.conditions.some((c: any) => c.args?.[0] === 'cfv_person_profile_birthday.record_id')).toBe(true)
     const cfvCompanyJoin = baseCall._ops.joins.find((j: any) => j.aliasObj.cfv_company_profile_sector)
-    expect(cfvCompanyJoin?.conditions.some((c: any) => c.args[0] === 'cfv_company_profile_sector.record_id' && c.args[2]?.params?.[0] === 'company_profile.id')).toBe(true)
-    const defsEntityWhere = fakeKnex._calls
+    expect(cfvCompanyJoin).toBeTruthy()
+    expect(cfvCompanyJoin.conditions.some((c: any) => c.args?.[0] === 'cfv_company_profile_sector.record_id')).toBe(true)
+    const defsInFilter = fakeDb._calls
       .filter((b: any) => b._ops.table === 'custom_field_defs')
       .flatMap((b: any) => b._ops.wheres)
-      .find((w: any) => Array.isArray(w) && w[0] === 'in' && w[1] === 'entity_id')
-    expect(defsEntityWhere).toBeTruthy()
-    const entityTargets = defsEntityWhere?.[2] || []
+      .find((w: any) => Array.isArray(w) && w[0] === 'entity_id' && w[1] === 'in')
+    expect(defsInFilter).toBeTruthy()
+    const entityTargets = defsInFilter?.[2] || []
     expect(entityTargets).toEqual(expect.arrayContaining([
       'customers:customer_entity',
       'customers:customer_person_profile',
@@ -233,7 +313,7 @@ describe('BasicQueryEngine', () => {
   })
 
   test('customFieldSources aliases support object equality filters', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       customer_entities: [],
       customer_people: [],
       'information_schema.columns': [
@@ -242,7 +322,7 @@ describe('BasicQueryEngine', () => {
         { table_name: 'customer_people', column_name: 'tenant_id' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('customers:customer_entity', {
       tenantId: 't1',
       fields: ['id'],
@@ -259,20 +339,20 @@ describe('BasicQueryEngine', () => {
       },
       page: { page: 1, pageSize: 10 },
     })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'customer_entities')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'customer_entities')
     expect(baseCall).toBeTruthy()
     const existsFilter = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'exists')
     expect(existsFilter).toBeTruthy()
     const subQuery = existsFilter[1]
     expect(subQuery?._ops?.table).toBe('customer_people')
     const hasEqualityFilter = Array.isArray(subQuery?._ops?.wheres)
-      ? subQuery._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'person_profile.id' && w[1] === 'profile-1')
+      ? subQuery._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'person_profile.id' && w[1] === '=' && w[2] === 'profile-1')
       : false
     expect(hasEqualityFilter).toBe(true)
   })
 
-  test('customFieldSources equality filters use search tokens when available', async () => {
-    const fakeKnex = createFakeKnex({
+  test('customFieldSources equality filters stay exact when search tokens are available', async () => {
+    const fakeDb = createFakeKysely({
       customer_entities: [],
       customer_people: [],
       'information_schema.columns': [
@@ -281,7 +361,7 @@ describe('BasicQueryEngine', () => {
         { table_name: 'customer_people', column_name: 'tenant_id' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     jest.spyOn(engine as any, 'tableExists').mockResolvedValue(true)
     jest.spyOn(engine as any, 'hasSearchTokens').mockResolvedValue(true)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
@@ -303,23 +383,10 @@ describe('BasicQueryEngine', () => {
       page: { page: 1, pageSize: 10 },
     })
 
-    expect(applySearchTokensSpy).toHaveBeenCalledTimes(1)
-    // Assert the search-tokens adapter was invoked with the expected join-scoped options
-    expect(applySearchTokensSpy).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        entity: 'customers:customer_person_profile',
-        field: 'id',
-        recordIdColumn: 'person_profile.id',
-        tenantId: 't1',
-        tokens: expect.arrayContaining(['profile']),
-        hashes: expect.any(Array),
-      }),
-    )
-    const callArgs = applySearchTokensSpy.mock.calls[0][1]
-    expect(callArgs.tokens.length).toBeGreaterThan(0)
-    expect(callArgs.hashes.length).toBe(callArgs.tokens.length)
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'customer_entities')
+    // When search tokens are available, equality filters on joined fields should stay exact
+    // (not use tokenized matching) and route through EXISTS subquery
+    expect(applySearchTokensSpy).not.toHaveBeenCalled()
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'customer_entities')
     expect(baseCall).toBeTruthy()
     // The join subquery that the parent whereExists wraps MUST still target customer_people
     const existsFilter = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'exists')
@@ -332,7 +399,7 @@ describe('BasicQueryEngine', () => {
     // absent (searchEnabled=false), $eq must route through the exact EXISTS
     // subquery path, producing the pre-change `person_profile.id = 'profile-1'`
     // filter — not the tokenized OR across search-tokens columns.
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       customer_entities: [],
       customer_people: [],
       'information_schema.columns': [
@@ -341,7 +408,7 @@ describe('BasicQueryEngine', () => {
         { table_name: 'customer_people', column_name: 'tenant_id' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     jest.spyOn(engine as any, 'tableExists').mockResolvedValue(false)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
 
@@ -363,23 +430,23 @@ describe('BasicQueryEngine', () => {
     })
 
     expect(applySearchTokensSpy).not.toHaveBeenCalled()
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'customer_entities')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'customer_entities')
     expect(baseCall).toBeTruthy()
     const existsFilter = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'exists')
     expect(existsFilter).toBeTruthy()
     const subQuery = existsFilter[1]
     expect(subQuery?._ops?.table).toBe('customer_people')
     const hasEqualityFilter = Array.isArray(subQuery?._ops?.wheres)
-      ? subQuery._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'person_profile.id' && w[1] === 'profile-1')
+      ? subQuery._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'person_profile.id' && w[1] === '=' && w[2] === 'profile-1')
       : false
     expect(hasEqualityFilter).toBe(true)
   })
 
   test('uses search tokens for index document fields on base entities', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       todos: [],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     const tableExistsSpy = jest.spyOn(engine as any, 'tableExists').mockResolvedValue(true)
     const hasSearchTokensSpy = jest.spyOn(engine as any, 'hasSearchTokens').mockResolvedValue(true)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
@@ -411,7 +478,7 @@ describe('BasicQueryEngine', () => {
   })
 
   test('join filters use whereExists with configured alias', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       customer_entities: [],
       customer_tag_assignments: [],
       'information_schema.columns': [
@@ -420,7 +487,7 @@ describe('BasicQueryEngine', () => {
         { table_name: 'customer_entities', column_name: 'tenant_id' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('customers:customer_entity', {
       tenantId: 't1',
       fields: ['id'],
@@ -438,14 +505,14 @@ describe('BasicQueryEngine', () => {
       },
       page: { page: 1, pageSize: 10 },
     })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'customer_entities')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'customer_entities')
     expect(baseCall).toBeTruthy()
     const existsFilter = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'exists')
     expect(existsFilter).toBeTruthy()
     const subQuery = existsFilter[1]
     expect(subQuery?._ops?.table).toBe('customer_tag_assignments')
     const hasInFilter = Array.isArray(subQuery?._ops?.wheres)
-      ? subQuery._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'in' && w[1] === 'tag_assignments.tag_id')
+      ? subQuery._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'tag_assignments.tag_id' && w[1] === 'in')
       : false
     expect(hasInFilter).toBe(true)
   })