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

package/src/lib/indexers/status-log.ts

@@ -1,5 +1,5 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
-import type { Knex } from 'knex'
+import { type Kysely, sql } from 'kysely'
 import type { IndexerErrorSource } from './error-log'
 
 export type IndexerLogLevel = 'info' | 'warn'
@@ -18,7 +18,7 @@ export type RecordIndexerLogInput = {
 
 type RecordIndexerLogDeps = {
   em?: EntityManager
-  knex?: Knex
+  db?: Kysely<any>
 }
 
 const MAX_MESSAGE_LENGTH = 4_096
@@ -43,14 +43,11 @@ function safeJson(value: unknown): unknown {
   }
 }
 
-function pickKnex(deps: RecordIndexerLogDeps): Knex | null {
-  if (deps.knex) return deps.knex
+function pickDb(deps: RecordIndexerLogDeps): Kysely<any> | null {
+  if (deps.db) return deps.db
   if (deps.em) {
     try {
-      const connection = deps.em.getConnection()
-      if (connection && typeof connection.getKnex === 'function') {
-        return connection.getKnex()
-      }
+      return deps.em.getKysely<any>()
     } catch {
       return null
     }
@@ -58,30 +55,33 @@ function pickKnex(deps: RecordIndexerLogDeps): Knex | null {
   return null
 }
 
-async function pruneExcessLogs(knex: Knex, source: IndexerErrorSource): Promise<void> {
-  const rows = await knex('indexer_status_logs')
-    .select('id')
-    .where('source', source)
-    .orderBy('occurred_at', 'desc')
-    .orderBy('id', 'desc')
+async function pruneExcessLogs(db: Kysely<any>, source: IndexerErrorSource): Promise<void> {
+  const rows = await db
+    .selectFrom('indexer_status_logs' as any)
+    .select('id' as any)
+    .where('source' as any, '=', source)
+    .orderBy('occurred_at' as any, 'desc')
+    .orderBy('id' as any, 'desc')
     .offset(MAX_LOGS_PER_SOURCE)
     .limit(MAX_DELETE_BATCH)
+    .execute()
 
   if (!rows.length) return
   const ids = rows.map((row: any) => row.id).filter(Boolean)
   if (!ids.length) return
-  await knex('indexer_status_logs')
-    .whereIn('id', ids)
-    .del()
+  await db
+    .deleteFrom('indexer_status_logs' as any)
+    .where('id' as any, 'in', ids)
+    .execute()
 }
 
 export async function recordIndexerLog(
   deps: RecordIndexerLogDeps,
   input: RecordIndexerLogInput,
 ): Promise<void> {
-  const knex = pickKnex(deps)
-  if (!knex) {
-    console.warn('[indexers] Unable to record indexer log (missing knex connection)', {
+  const db = pickDb(deps)
+  if (!db) {
+    console.warn('[indexers] Unable to record indexer log (missing db connection)', {
       source: input.source,
       handler: input.handler,
     })
@@ -94,25 +94,28 @@ export async function recordIndexerLog(
   const occurredAt = new Date()
 
   try {
-    await knex('indexer_status_logs').insert({
-      source: input.source,
-      handler: input.handler,
-      level,
-      entity_type: input.entityType ?? null,
-      record_id: input.recordId ?? null,
-      tenant_id: input.tenantId ?? null,
-      organization_id: input.organizationId ?? null,
-      message,
-      details,
-      occurred_at: occurredAt,
-    })
+    await db
+      .insertInto('indexer_status_logs' as any)
+      .values({
+        source: input.source,
+        handler: input.handler,
+        level,
+        entity_type: input.entityType ?? null,
+        record_id: input.recordId ?? null,
+        tenant_id: input.tenantId ?? null,
+        organization_id: input.organizationId ?? null,
+        message,
+        details: details === null ? null : sql`${JSON.stringify(details)}::jsonb`,
+        occurred_at: occurredAt,
+      } as any)
+      .execute()
   } catch (error) {
     console.error('[indexers] Failed to persist indexer log', error)
     return
   }
 
   try {
-    await pruneExcessLogs(knex, input.source)
+    await pruneExcessLogs(db, input.source)
   } catch (pruneError) {
     console.warn('[indexers] Failed to prune indexer logs', pruneError)
   }

package/src/lib/query/__tests__/engine.scope-and-or.test.ts

@@ -8,88 +8,182 @@ function cloneRows(rows: any[] | undefined): any[] {
   return rows.map((row) => ({ ...row }))
 }
 
-function createFakeKnex(overrides?: FakeData) {
+function createFakeKysely(overrides?: FakeData) {
   const calls: any[] = []
   const defaultData: FakeData = { custom_field_defs: [], custom_field_values: [] }
   const sourceData = { ...defaultData, ...(overrides || {}) }
   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 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 makeBuilder(table: string) {
-    const ops: any = {
-      table,
-      wheres: [] as any[],
-      joins: [] as any[],
-      selects: [] as any[],
-      orderBys: [] as any[],
-      groups: [] as any[],
-      limits: 0,
-      offsets: 0,
-      isCountDistinct: false,
+
+  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 === 'and') return ['and', 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]
+    }
+    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.onRef = (left: any, op: any, right: any) => {
+      entry.conditions.push({ method: 'on', args: [left, op, right] })
+      return ctx
+    }
+    fn(ctx)
+    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[]) {
-        if (args.length === 1 && typeof args[0] === 'function') {
-          const nested = makeBuilder(`${table}::where-fn`)
-          args[0].call(nested, nested)
-          ops.wheres.push(['whereFn', nested._ops])
-          return this
-        }
-        ops.wheres.push(args)
+      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
       },
-      andWhere: function (...args: any[]) { ops.wheres.push(['and', ...args]); return this },
-      orWhere: function (...args: any[]) {
-        if (args.length === 1 && typeof args[0] === 'function') {
-          const nested = makeBuilder(`${table}::orWhere-fn`)
-          args[0].call(nested, nested)
-          ops.wheres.push(['orWhereFn', nested._ops])
-          return this
-        }
-        ops.wheres.push(['orWhere', ...args])
+      distinct(this: any) { return this },
+      where(this: any, ...args: any[]) {
+        this._ops.wheres.push(normalizeWhereArgs(args))
+        return this
+      },
+      whereRef(this: any, left: any, op: any, right: any) {
+        this._ops.wheres.push(['ref', left, op, right])
+        return this
+      },
+      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
       },
-      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(['orIsNull', col]); return this },
-      leftJoin: function () { return this },
-      join: function () { 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 () { return ops.isCountDistinct ? { count: '0' } : (data[table] || [])[0] },
-      modify: function () { return this },
-      then: function (resolve: any) { return Promise.resolve(resolve(data[table] || [])) },
+      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 = (tableArg: any) => {
-    const t = typeof tableArg === 'string' ? tableArg : String(Object.values(tableArg || {})[0] || '')
-    return makeBuilder(t)
+
+  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) },
   }
-  fn.raw = raw
-  fn._calls = calls
-  return fn
+  db._calls = calls
+  return db
 }
 
-function collectAllWheres(calls: any[]): any[] {
-  const out: any[] = []
-  for (const c of calls) out.push(...c._ops.wheres)
+type Cmp = { kind: 'cmp'; column: string; op: string; value: unknown }
+type And = { kind: 'and'; parts: Node[] }
+type Or = { kind: 'or'; parts: Node[] }
+type Node = Cmp | And | Or | { kind: string; [k: string]: any }
+
+function flattenCmps(node: Node | unknown, out: Cmp[] = []): Cmp[] {
+  if (!node || typeof node !== 'object') return out
+  const n = node as Node
+  if (n.kind === 'cmp') out.push(n as Cmp)
+  else if (n.kind === 'and' || n.kind === 'or') {
+    for (const p of (n as And | Or).parts) flattenCmps(p, out)
+  }
   return out
 }
 
@@ -135,63 +229,68 @@ describe('normalizeFilters $or clause grouping', () => {
 })
 
 describe('BasicQueryEngine — null equality', () => {
-  test('$eq null compiles to whereNull', async () => {
-    const fakeKnex = createFakeKnex({
+  test('$eq null compiles to where(col, "is", null)', async () => {
+    const fakeDb = createFakeKysely({
       scheduled_jobs: [],
       'information_schema.columns': [
         { table_name: 'scheduled_jobs', column_name: 'organization_id' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('scheduler:scheduled_job', {
       tenantId: 't1',
       fields: ['id'],
       omitAutomaticTenantOrgScope: true,
       filters: { organization_id: { $eq: null } },
     })
-    const wheres = collectAllWheres(fakeKnex._calls)
-    const hasWhereNullOrgId = wheres.some(
-      (w: any) => Array.isArray(w) && w[0] === 'isNull' && String(w[1]).endsWith('organization_id'),
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    expect(baseCall).toBeTruthy()
+    const wheres: any[] = baseCall._ops.wheres
+    const hasIsNullOrgId = wheres.some(
+      (w: any) => Array.isArray(w) && String(w[0]).endsWith('organization_id') && w[1] === 'is' && w[2] === null,
     )
-    expect(hasWhereNullOrgId).toBe(true)
+    expect(hasIsNullOrgId).toBe(true)
     const hasEqualsLiteralNull = wheres.some(
-      (w: any) => Array.isArray(w) && w.length >= 2 && String(w[0]).endsWith('organization_id') && w[1] === null,
+      (w: any) => Array.isArray(w) && String(w[0]).endsWith('organization_id') && w[1] === '=' && w[2] === null,
     )
     expect(hasEqualsLiteralNull).toBe(false)
   })
 
-  test('$ne null compiles to whereNotNull', async () => {
-    const fakeKnex = createFakeKnex({
+  test('$ne null compiles to where(col, "is not", null)', async () => {
+    const fakeDb = createFakeKysely({
       scheduled_jobs: [],
       'information_schema.columns': [
         { table_name: 'scheduled_jobs', column_name: 'organization_id' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('scheduler:scheduled_job', {
       tenantId: 't1',
       fields: ['id'],
       omitAutomaticTenantOrgScope: true,
       filters: { organization_id: { $ne: null } },
     })
-    const wheres = collectAllWheres(fakeKnex._calls)
-    const hasWhereNotNullOrgId = wheres.some(
-      (w: any) => Array.isArray(w) && w[0] === 'notNull' && String(w[1]).endsWith('organization_id'),
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    expect(baseCall).toBeTruthy()
+    const wheres: any[] = baseCall._ops.wheres
+    const hasIsNotNullOrgId = wheres.some(
+      (w: any) => Array.isArray(w) && String(w[0]).endsWith('organization_id') && w[1] === 'is not' && w[2] === null,
     )
-    expect(hasWhereNotNullOrgId).toBe(true)
+    expect(hasIsNotNullOrgId).toBe(true)
   })
 })
 
 describe('BasicQueryEngine — omitAutomaticTenantOrgScope', () => {
   test('skips automatic tenant and organization guards when flag is set', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       scheduled_jobs: [],
       'information_schema.columns': [
+        { table_name: 'scheduled_jobs', column_name: 'id' },
         { table_name: 'scheduled_jobs', column_name: 'organization_id' },
         { table_name: 'scheduled_jobs', 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('scheduler:scheduled_job', {
       tenantId: 't1',
       organizationId: 'org-1',
@@ -199,35 +298,62 @@ describe('BasicQueryEngine — omitAutomaticTenantOrgScope', () => {
       omitAutomaticTenantOrgScope: true,
       filters: { id: { $eq: '11111111-1111-1111-1111-111111111111' } },
     })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
     expect(baseCall).toBeTruthy()
-    const serialized = JSON.stringify(baseCall._ops.wheres)
-    expect(serialized).not.toMatch(/organization_id.*org-1/)
-    expect(serialized).not.toMatch(/\["scheduled_jobs\.tenant_id","t1"\]/)
+    const wheres: any[] = baseCall._ops.wheres
+
+    const hasTenantGuard = wheres.some(
+      (w: any) => Array.isArray(w) && w[0] === 'scheduled_jobs.tenant_id' && w[1] === '=' && w[2] === 't1',
+    )
+    expect(hasTenantGuard).toBe(false)
+
+    const allCmps = wheres.flatMap((w: any) => {
+      if (!Array.isArray(w)) return []
+      if (w[0] === 'expr' || w[0] === 'and' || w[0] === 'or') {
+        const payload = w[0] === 'expr' ? w[1] : { kind: w[0], parts: w[1] }
+        return flattenCmps(payload)
+      }
+      if (w.length >= 3 && typeof w[0] === 'string' && typeof w[1] === 'string') {
+        return [{ kind: 'cmp', column: w[0], op: w[1], value: w[2] } as Cmp]
+      }
+      return []
+    })
+    const hasOrgGuard = allCmps.some(
+      (c) => String(c.column).endsWith('organization_id') && c.op === 'in' && Array.isArray(c.value) && (c.value as any[]).includes('org-1'),
+    )
+    expect(hasOrgGuard).toBe(false)
+
+    const hasIdFilter = wheres.some(
+      (w: any) => Array.isArray(w) && w[0] === 'scheduled_jobs.id' && w[1] === '=' && w[2] === '11111111-1111-1111-1111-111111111111',
+    )
+    expect(hasIdFilter).toBe(true)
   })
 
   test('applies automatic tenant guard when flag is absent (baseline)', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       scheduled_jobs: [],
       'information_schema.columns': [
         { table_name: 'scheduled_jobs', 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('scheduler:scheduled_job', {
       tenantId: 't1',
       fields: ['id'],
     })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
-    const serialized = JSON.stringify(baseCall._ops.wheres)
-    expect(serialized).toMatch(/tenant_id/)
-    expect(serialized).toMatch(/t1/)
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    expect(baseCall).toBeTruthy()
+    const wheres: any[] = baseCall._ops.wheres
+    const hasTenantGuard = wheres.some(
+      (w: any) => Array.isArray(w) && w[0] === 'scheduled_jobs.tenant_id' && w[1] === '=' && w[2] === 't1',
+    )
+    expect(hasTenantGuard).toBe(true)
   })
 })
 
 describe('BasicQueryEngine — multi-field $or grouping', () => {
   test('AND within each $or clause, OR between clauses', async () => {
-    const fakeKnex = createFakeKnex({
+    const fakeDb = createFakeKysely({
       scheduled_jobs: [],
       'information_schema.columns': [
         { table_name: 'scheduled_jobs', column_name: 'organization_id' },
@@ -235,7 +361,7 @@ describe('BasicQueryEngine — multi-field $or grouping', () => {
         { table_name: 'scheduled_jobs', column_name: 'scope_type' },
       ],
     })
-    const engine = new BasicQueryEngine({} as any, () => fakeKnex as any)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
     await engine.query('scheduler:scheduled_job', {
       tenantId: 't1',
       fields: ['id'],
@@ -247,32 +373,45 @@ describe('BasicQueryEngine — multi-field $or grouping', () => {
         ],
       },
     })
-    const baseCall = fakeKnex._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
     expect(baseCall).toBeTruthy()
-    const whereFn = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'whereFn')
-    expect(whereFn).toBeTruthy()
-    const nestedOps = whereFn[1]
-    const nestedWheres = nestedOps.wheres
-    const orWhereFn = nestedWheres.find((w: any) => Array.isArray(w) && w[0] === 'orWhereFn')
-    expect(orWhereFn).toBeTruthy()
-    const firstGroupWheres = nestedWheres.filter((w: any) => !Array.isArray(w) || w[0] !== 'orWhereFn')
-    const firstGroupColumns = firstGroupWheres
-      .map((w: any) => (Array.isArray(w) ? String(w[0]) : ''))
-      .filter((col: string) => col.endsWith('organization_id') || col.endsWith('tenant_id'))
-    expect(firstGroupColumns.length).toBeGreaterThanOrEqual(2)
-    const secondGroupOps = orWhereFn[1]
-    const secondGroupWheres = secondGroupOps.wheres
-    const hasSystemScopeFilter = secondGroupWheres.some(
-      (w: any) => Array.isArray(w) && String(w[0]).endsWith('scope_type') && w[1] === 'system',
+
+    const orEntry = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'or')
+    expect(orEntry).toBeTruthy()
+    const orParts: Node[] = orEntry[1]
+    expect(Array.isArray(orParts)).toBe(true)
+    expect(orParts.length).toBe(2)
+
+    const groupOne = orParts[0] as And
+    expect(groupOne.kind).toBe('and')
+    const groupOneCmps = flattenCmps(groupOne)
+    const groupOneCols = groupOneCmps
+      .map((c) => String(c.column))
+      .filter((col) => col.endsWith('organization_id') || col.endsWith('tenant_id'))
+    expect(groupOneCols.length).toBeGreaterThanOrEqual(2)
+    const groupOneHasOrgEq = groupOneCmps.some(
+      (c) => String(c.column).endsWith('organization_id') && c.op === '=' && c.value === 'org-1',
+    )
+    const groupOneHasTenantEq = groupOneCmps.some(
+      (c) => String(c.column).endsWith('tenant_id') && c.op === '=' && c.value === 't1',
+    )
+    expect(groupOneHasOrgEq).toBe(true)
+    expect(groupOneHasTenantEq).toBe(true)
+
+    const groupTwo = orParts[1] as And
+    expect(groupTwo.kind).toBe('and')
+    const groupTwoCmps = flattenCmps(groupTwo)
+    const hasSystemScope = groupTwoCmps.some(
+      (c) => String(c.column).endsWith('scope_type') && c.op === '=' && c.value === 'system',
     )
-    const hasNullOrgInSecondGroup = secondGroupWheres.some(
-      (w: any) => Array.isArray(w) && w[0] === 'isNull' && String(w[1]).endsWith('organization_id'),
+    const hasNullOrg = groupTwoCmps.some(
+      (c) => String(c.column).endsWith('organization_id') && c.op === 'is' && c.value === null,
     )
-    const hasNullTenantInSecondGroup = secondGroupWheres.some(
-      (w: any) => Array.isArray(w) && w[0] === 'isNull' && String(w[1]).endsWith('tenant_id'),
+    const hasNullTenant = groupTwoCmps.some(
+      (c) => String(c.column).endsWith('tenant_id') && c.op === 'is' && c.value === null,
     )
-    expect(hasSystemScopeFilter).toBe(true)
-    expect(hasNullOrgInSecondGroup).toBe(true)
-    expect(hasNullTenantInSecondGroup).toBe(true)
+    expect(hasSystemScope).toBe(true)
+    expect(hasNullOrg).toBe(true)
+    expect(hasNullTenant).toBe(true)
   })
 })