@open-mercato/shared 0.7.0 → 0.7.1-develop.7102.1.b41f7e3e51

package/src/lib/query/__tests__/count-cap-plan.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Plan-level guard for the capped list COUNT (#4552 Phase 2), run against a real
+ * PostgreSQL. This is the only test that fails if a future refactor reintroduces
+ * a blocking node (Aggregate/Sort/Unique) between the probe `Limit` and the base
+ * scan — a mocked total cannot catch a bound that does not bind. It doubles as
+ * the count-parity check: with the cap disabled, the rebuilt count must equal
+ * ground truth across the cf-filter / or-group / plain matrices.
+ *
+ * Gated on OM_COUNT_CAP_PG_URL (a throwaway database — the suite creates and
+ * drops its own tables). Example:
+ *   docker run --rm -d -p 54329:5432 -e POSTGRES_PASSWORD=t postgres:16
+ *   OM_COUNT_CAP_PG_URL=postgres://postgres:t@localhost:54329/postgres yarn jest count-cap-plan
+ */
+import { Kysely, PostgresDialect, sql } from 'kysely'
+import { BasicQueryEngine } from '../engine'
+
+const PG_URL = process.env.OM_COUNT_CAP_PG_URL
+const maybe = PG_URL ? describe : describe.skip
+
+const TENANT = '11111111-1111-4111-8111-111111111111'
+const ORG = '22222222-2222-4222-8222-222222222222'
+const ENTITY = 'capcheck:om_capcheck_order'
+const TABLE = 'om_capcheck_orders'
+const ROWS = 120
+const RED_ROWS = 30
+
+maybe('capped list COUNT against PostgreSQL', () => {
+  jest.setTimeout(60_000)
+  let db: Kysely<any>
+  let sqlLog: string[] = []
+  let paramLog: unknown[][] = []
+  const originalCap = process.env.OM_LIST_COUNT_CAP
+
+  beforeAll(async () => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Pool } = require('pg')
+    db = new Kysely<any>({
+      dialect: new PostgresDialect({ pool: new Pool({ connectionString: PG_URL }) }),
+      log(event) {
+        if (event.level === 'query' || event.level === 'error') {
+          sqlLog.push(event.query.sql)
+          paramLog.push([...event.query.parameters])
+        }
+      },
+    })
+    await sql`drop table if exists om_capcheck_orders`.execute(db)
+    await sql`create table om_capcheck_orders (
+      id uuid primary key,
+      tenant_id uuid not null,
+      organization_id uuid not null,
+      deleted_at timestamptz,
+      status text not null
+    )`.execute(db)
+    await sql`create table if not exists custom_field_defs (
+      id serial primary key,
+      key text not null,
+      entity_id text not null,
+      kind text,
+      config_json jsonb,
+      is_active boolean not null default true,
+      organization_id uuid,
+      tenant_id uuid,
+      updated_at timestamptz,
+      deleted_at timestamptz
+    )`.execute(db)
+    await sql`create table if not exists custom_field_values (
+      id serial primary key,
+      entity_id text not null,
+      field_key text not null,
+      record_id text not null,
+      value_text text,
+      value_multiline text,
+      value_int int,
+      value_float float,
+      value_bool boolean,
+      organization_id uuid,
+      tenant_id uuid
+    )`.execute(db)
+    await sql`delete from custom_field_defs where entity_id = ${ENTITY}`.execute(db)
+    await sql`delete from custom_field_values where entity_id = ${ENTITY}`.execute(db)
+    await sql`insert into custom_field_defs (key, entity_id, kind, is_active, tenant_id)
+      values ('color', ${ENTITY}, 'text', true, null)`.execute(db)
+    for (let i = 0; i < ROWS; i++) {
+      const id = `33333333-3333-4333-8333-${String(i).padStart(12, '0')}`
+      await sql`insert into om_capcheck_orders (id, tenant_id, organization_id, deleted_at, status)
+        values (${id}::uuid, ${TENANT}::uuid, ${ORG}::uuid, null, ${i % 2 === 0 ? 'open' : 'closed'})`.execute(db)
+      if (i < RED_ROWS) {
+        await sql`insert into custom_field_values (entity_id, field_key, record_id, value_text, tenant_id)
+          values (${ENTITY}, 'color', ${id}, 'red', ${TENANT}::uuid)`.execute(db)
+      }
+    }
+  })
+
+  afterAll(async () => {
+    await sql`drop table if exists om_capcheck_orders`.execute(db)
+    await sql`delete from custom_field_defs where entity_id = ${ENTITY}`.execute(db)
+    await sql`delete from custom_field_values where entity_id = ${ENTITY}`.execute(db)
+    await db.destroy()
+  })
+
+  afterEach(() => {
+    if (originalCap === undefined) delete process.env.OM_LIST_COUNT_CAP
+    else process.env.OM_LIST_COUNT_CAP = originalCap
+  })
+
+  const makeEngine = () => new BasicQueryEngine({} as any, () => db as any)
+  const baseOpts = {
+    tenantId: TENANT,
+    organizationId: ORG,
+    fields: ['id'],
+    page: { page: 1, pageSize: 10 },
+  }
+
+  function lastCountSql(): { text: string; params: unknown[] } {
+    for (let i = sqlLog.length - 1; i >= 0; i--) {
+      if (/count\(\*\)/i.test(sqlLog[i])) return { text: sqlLog[i], params: paramLog[i] }
+    }
+    throw new Error('no count SQL captured')
+  }
+
+  function collectNodes(node: any, out: any[] = []): any[] {
+    if (!node) return out
+    out.push(node)
+    for (const child of node.Plans ?? []) collectNodes(child, out)
+    return out
+  }
+
+  test('probe plan: no blocking node between the Limit and the base scan (cf-filtered)', async () => {
+    process.env.OM_LIST_COUNT_CAP = '50'
+    sqlLog = []; paramLog = []
+    const result = await makeEngine().query(ENTITY, {
+      ...baseOpts,
+      filters: { status: { $eq: 'open' } },
+    })
+    expect(result.total).toBe(50)
+    expect(result.meta?.listCountCapWarning).toEqual({ entity: ENTITY, cap: 50 })
+
+    const { text, params } = lastCountSql()
+    expect(text.toLowerCase()).toContain('limit')
+    const explained = await sql
+      .raw(`explain (format json) ${text.replace(/\$(\d+)/g, (_, n) => {
+        const value = params[Number(n) - 1]
+        return typeof value === 'number' ? String(value) : `'${String(value).replace(/'/g, "''")}'`
+      })}`)
+      .execute(db)
+    const plan = (explained.rows[0] as any)['QUERY PLAN'][0].Plan
+    const all = collectNodes(plan)
+    const limitNode = all.find((n) => n['Node Type'] === 'Limit')
+    expect(limitNode).toBeTruthy()
+    // Below the Limit: only row-producing nodes down to the scan. An Aggregate,
+    // Sort, or Unique here means the bound does not bind.
+    const belowLimit = collectNodes(limitNode).slice(1)
+    const blocking = belowLimit.filter((n) => /Aggregate|Sort|Unique/.test(String(n['Node Type'])))
+    expect(blocking).toEqual([])
+    // The base scan is inside the Limit subtree.
+    expect(belowLimit.some((n) => n['Relation Name'] === TABLE)).toBe(true)
+  })
+
+  test('cf filter compiles to EXISTS and stays cappable', async () => {
+    process.env.OM_LIST_COUNT_CAP = '10'
+    sqlLog = []; paramLog = []
+    const result = await makeEngine().query(ENTITY, {
+      ...baseOpts,
+      filters: { cf_color: { $eq: 'red' } },
+    })
+    expect(result.total).toBe(10)
+    expect(result.meta?.listCountCapWarning).toEqual({ entity: ENTITY, cap: 10 })
+    const { text } = lastCountSql()
+    expect(text.toLowerCase()).toContain('exists')
+    expect(text.toLowerCase()).not.toContain('group by')
+  })
+
+  test('parity with the cap disabled: rebuilt count matches the display query across the filter matrix', async () => {
+    process.env.OM_LIST_COUNT_CAP = '0'
+    const engine = makeEngine()
+    const wide = { page: { page: 1, pageSize: 1000 } }
+
+    // Each case asserts the rebuilt count against ground truth where the filter
+    // semantics are well-defined, and always against the display query's own
+    // row set — the regression guard for "count rebuild changing a total".
+    const expectParity = async (filters: any, expectedTotal?: number) => {
+      const result = await engine.query(ENTITY, { ...baseOpts, ...wide, filters })
+      expect(result.total).toBe(result.items.length)
+      if (expectedTotal !== undefined) expect(result.total).toBe(expectedTotal)
+      expect(result.meta?.listCountCapWarning).toBeUndefined()
+      return result
+    }
+
+    await expectParity(undefined, ROWS)
+    await expectParity({ status: { $eq: 'open' } }, ROWS / 2)
+    await expectParity({ cf_color: { $eq: 'red' } }, RED_ROWS)
+    await expectParity({ $and: [{ status: { $eq: 'open' } }, { cf_color: { $eq: 'red' } }] }, RED_ROWS / 2)
+    // Base-column-only $or exercises the or-group path in the count shape.
+    await expectParity({ $or: [{ status: { $eq: 'open' } }, { status: { $eq: 'closed' } }] }, ROWS)
+    // Mixed base + cf disjunction (#5039): the count shape must compile the cf
+    // leaf to an EXISTS rather than dropping it — a dropped leaf narrows the OR
+    // and undercounts. closed (60) ∪ red (30, half of which are closed) = 75.
+    await expectParity({ $or: [{ status: { $eq: 'closed' } }, { cf_color: { $eq: 'red' } }] }, ROWS / 2 + RED_ROWS / 2)
+    // cf-only disjunction: red (30) ∪ blue (0) = 30.
+    await expectParity({ $or: [{ cf_color: { $eq: 'red' } }, { cf_color: { $eq: 'blue' } }] }, RED_ROWS)
+    await expectParity({ cf_color: { $eq: 'blue' } }, 0)
+    await expectParity({ cf_color: { $eq: null } }, ROWS - RED_ROWS)
+    await expectParity({ cf_color: { $ne: 'red' } }, 0)
+    await expectParity({ cf_color: { $in: ['red', 'blue'] } }, RED_ROWS)
+  })
+
+  test('kill switch (cap=0): the cf-filtered count still plans set-oriented, not per-row', async () => {
+    // OM_LIST_COUNT_CAP=0 restores exact totals but runs them through the
+    // rebuilt shape. The documented escape hatch must not be slower than the
+    // problem: the uncapped EXISTS should plan as a semi-join or a hashed
+    // subplan, never an un-hashed per-row subplan re-executed for every row.
+    process.env.OM_LIST_COUNT_CAP = '0'
+    sqlLog = []; paramLog = []
+    const result = await makeEngine().query(ENTITY, {
+      ...baseOpts,
+      filters: { cf_color: { $eq: 'red' } },
+    })
+    expect(result.total).toBe(RED_ROWS)
+
+    const { text, params } = lastCountSql()
+    const explained = await sql
+      .raw(`explain (format json) ${text.replace(/\$(\d+)/g, (_, n) => {
+        const value = params[Number(n) - 1]
+        return typeof value === 'number' ? String(value) : `'${String(value).replace(/'/g, "''")}'`
+      })}`)
+      .execute(db)
+    const plan = (explained.rows[0] as any)['QUERY PLAN'][0].Plan
+    const all = collectNodes(plan)
+    const semiJoin = all.some((n) => /Semi/.test(String(n['Join Type'] ?? '')))
+    const hashedSubplan = all.some((n) => /hashed/i.test(String(n['Subplan Name'] ?? '')))
+    expect(semiJoin || hashedSubplan).toBe(true)
+  })
+
+  test('sub-cap totals stay exact with the cap active', async () => {
+    process.env.OM_LIST_COUNT_CAP = '1000'
+    const result = await makeEngine().query(ENTITY, { ...baseOpts, filters: { cf_color: { $eq: 'red' } } })
+    expect(result.total).toBe(RED_ROWS)
+    expect(result.meta?.listCountCapWarning).toBeUndefined()
+  })
+})

package/src/lib/query/__tests__/count-cap.test.ts

@@ -0,0 +1,41 @@
+import { resolveListCountCap, DEFAULT_LIST_COUNT_CAP } from '../count-cap'
+
+describe('resolveListCountCap', () => {
+  const original = process.env.OM_LIST_COUNT_CAP
+  afterEach(() => {
+    if (original === undefined) delete process.env.OM_LIST_COUNT_CAP
+    else process.env.OM_LIST_COUNT_CAP = original
+  })
+
+  test('unset: the default cap — the cap is on by default', () => {
+    delete process.env.OM_LIST_COUNT_CAP
+    expect(resolveListCountCap()).toBe(DEFAULT_LIST_COUNT_CAP)
+  })
+
+  test('blank: the default cap', () => {
+    process.env.OM_LIST_COUNT_CAP = '  '
+    expect(resolveListCountCap()).toBe(DEFAULT_LIST_COUNT_CAP)
+  })
+
+  test('0 disables capping', () => {
+    process.env.OM_LIST_COUNT_CAP = '0'
+    expect(resolveListCountCap()).toBeNull()
+  })
+
+  test('negative values disable capping like 0', () => {
+    process.env.OM_LIST_COUNT_CAP = '-5'
+    expect(resolveListCountCap()).toBeNull()
+  })
+
+  test('a positive integer is used as-is; floats floor', () => {
+    process.env.OM_LIST_COUNT_CAP = '500'
+    expect(resolveListCountCap()).toBe(500)
+    process.env.OM_LIST_COUNT_CAP = '500.9'
+    expect(resolveListCountCap()).toBe(500)
+  })
+
+  test('unparseable input falls back to the default — bad input must not silently disable the cap', () => {
+    process.env.OM_LIST_COUNT_CAP = 'unbounded'
+    expect(resolveListCountCap()).toBe(DEFAULT_LIST_COUNT_CAP)
+  })
+})

package/src/lib/query/__tests__/engine.count-distinct.test.ts

@@ -1,6 +1,13 @@
-import { BasicQueryEngine } from '../engine'
+import { BasicQueryEngine, clearColumnExistsCache } from '../engine'
 import { registerModules } from '../../i18n/server'
 
+// The column-existence answer is memoized on the module, not the instance (#5605), so
+// the per-test fake schemas below would otherwise inherit whatever the first test
+// probed for the same table names.
+beforeEach(() => {
+  clearColumnExistsCache()
+})
+
 // One entity extension on auth:user so includeExtensions exercises the joined-aggregate path.
 registerModules([
   { id: 'auth', entityExtensions: [{ base: 'auth:user', extension: 'my_module:user_profile', join: { baseKey: 'id', extensionKey: 'user_id' } }] },
@@ -139,6 +146,22 @@ function createFakeKysely(selectsSink: any[], overrides?: FakeData) {
   }
 
   function builderFor(tableArg: any): any {
+    if (tableArg && typeof tableArg === 'object' && tableArg._ops) {
+      // selectFrom(subquery.as(alias)) — the capped-count probe shape.
+      const ops = {
+        table: '__subquery__',
+        alias: tableArg._ops.alias ?? null,
+        subquery: tableArg._ops,
+        wheres: [] as any[],
+        joins: [] as any[],
+        selects: [] as any[],
+        orderBys: [] as any[],
+        groups: [] as any[],
+        limits: 0,
+        offsets: 0,
+      }
+      return makeBuilder(ops, true)
+    }
     const parsed = parseTableSpec(tableArg)
     const ops = {
       table: parsed.table,
@@ -173,8 +196,28 @@ function findCountSql(selectsSink: any[]): string {
   return rawSqlText(countExprs[countExprs.length - 1]).toLowerCase()
 }
 
-describe('BasicQueryEngine — list COUNT query (issue #2227)', () => {
-  test('uses count(*) and no group-by when no joins can multiply base rows', async () => {
+// The count query is rebuilt from scope + filters only (#4552 Phase 2): cf
+// filters compile to correlated EXISTS semi-joins, projection joins are
+// dropped, so the count never needs DISTINCT or GROUP BY — completing the
+// direction #2227 started — and the LIMIT cap+1 probe actually bounds the scan.
+describe('BasicQueryEngine — rebuilt list COUNT query (#4552 Phase 2)', () => {
+  const originalCap = process.env.OM_LIST_COUNT_CAP
+  afterEach(() => {
+    if (originalCap === undefined) delete process.env.OM_LIST_COUNT_CAP
+    else process.env.OM_LIST_COUNT_CAP = originalCap
+  })
+
+  // The count-shape builder is the base-table call carrying the probe LIMIT
+  // (cap + 1); with the cap disabled it is the base call whose recorded select
+  // is the bare count aggregate.
+  function findCountShapeCall(fakeDb: any, table: string) {
+    const baseCalls = fakeDb._calls.filter((b: any) => b._ops.table === table)
+    const probed = baseCalls.find((b: any) => b._ops.limits === 10_001)
+    if (probed) return probed
+    return baseCalls.find((b: any) => b._ops.selects.some((s: any) => aliasName(s) === 'count'))
+  }
+
+  test('uses count(*) with no DISTINCT and no GROUP BY when nothing joins', async () => {
     const selects: any[] = []
     const fakeDb = createFakeKysely(selects)
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
@@ -184,11 +227,11 @@ describe('BasicQueryEngine — list COUNT query (issue #2227)', () => {
     expect(countSql).toContain('count(*)')
     expect(countSql).not.toContain('distinct')
 
-    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
-    expect(baseCall._ops.groups.length).toBe(0)
+    const countCall = findCountShapeCall(fakeDb, 'scheduled_jobs')
+    expect(countCall._ops.groups.length).toBe(0)
   })
 
-  test('keeps count(distinct base.id) with group-by when extensions are joined', async () => {
+  test('drops extension projection joins from the count: count(*) over the bare base table', async () => {
     const selects: any[] = []
     const fakeDb = createFakeKysely(selects)
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
@@ -201,14 +244,20 @@ describe('BasicQueryEngine — list COUNT query (issue #2227)', () => {
     })
 
     const countSql = findCountSql(selects)
-    expect(countSql).toContain('count(distinct')
-    expect(countSql).not.toContain('count(*)')
+    expect(countSql).toContain('count(*)')
+    expect(countSql).not.toContain('distinct')
 
-    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'users')
-    expect(baseCall._ops.groups.length).toBeGreaterThan(0)
+    // The display query keeps the extension join + GROUP BY …
+    const dataCall = fakeDb._calls.find((b: any) => b._ops.table === 'users' && b._ops.joins.length > 0)
+    expect(dataCall._ops.groups.length).toBeGreaterThan(0)
+    // … while the count shape carries neither: no join can multiply base rows,
+    // so no barrier sits between the probe LIMIT and the scan.
+    const countCall = findCountShapeCall(fakeDb, 'users')
+    expect(countCall._ops.joins.length).toBe(0)
+    expect(countCall._ops.groups.length).toBe(0)
   })
 
-  test('keeps count(distinct base.id) without group-by when an explicit relation join is configured', async () => {
+  test('explicit relation joins never reach the count: count(*), join filters stay EXISTS', async () => {
     const selects: any[] = []
     const fakeDb = createFakeKysely(selects)
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
@@ -216,14 +265,112 @@ describe('BasicQueryEngine — list COUNT query (issue #2227)', () => {
       tenantId: 't1',
       fields: ['id'],
       joins: [{ alias: 'owner', table: 'users', from: { field: 'owner_id' }, to: { field: 'id' } }],
+      filters: { 'owner.email': { $eq: 'a@b.c' } },
+      page: { page: 1, pageSize: 20 },
+    })
+
+    const countSql = findCountSql(selects)
+    expect(countSql).toContain('count(*)')
+    expect(countSql).not.toContain('distinct')
+
+    const countCall = findCountShapeCall(fakeDb, 'scheduled_jobs')
+    expect(countCall._ops.groups.length).toBe(0)
+    expect(countCall._ops.joins.length).toBe(0)
+    // The join filter is a semi-join on the count shape, not a join.
+    expect(countCall._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'exists')).toBe(true)
+  })
+
+  test('cf filters compile to EXISTS over custom_field_values on the count shape', async () => {
+    const selects: any[] = []
+    const fakeDb = createFakeKysely(selects, {
+      custom_field_defs: [
+        { key: 'color', entity_id: 'scheduler:scheduled_job', is_active: true, tenant_id: null, kind: 'text', config_json: '{}' },
+      ],
+    })
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query('scheduler:scheduled_job', {
+      tenantId: 't1',
+      fields: ['id'],
+      filters: { cf_color: { $eq: 'red' } },
+      page: { page: 1, pageSize: 20 },
+    })
+
+    const countSql = findCountSql(selects)
+    expect(countSql).toContain('count(*)')
+    expect(countSql).not.toContain('distinct')
+
+    const countCall = findCountShapeCall(fakeDb, 'scheduled_jobs')
+    expect(countCall._ops.groups.length).toBe(0)
+    // No custom_field_values join on the count shape — the filter is an EXISTS
+    // whose subquery selects from custom_field_values.
+    expect(countCall._ops.joins.length).toBe(0)
+    const existsEntries = countCall._ops.wheres.filter((w: any) => Array.isArray(w) && w[0] === 'exists')
+    expect(existsEntries.length).toBeGreaterThan(0)
+    const existsSub = existsEntries[0][1]
+    expect(existsSub._ops.table).toBe('custom_field_values')
+    // The display query still resolves the same filter through its value join.
+    const dataCall = fakeDb._calls.find((b: any) =>
+      b._ops.table === 'scheduled_jobs' &&
+      b._ops.joins.some((j: any) => Object.values(j.aliasObj).includes('custom_field_values')))
+    expect(dataCall).toBeTruthy()
+  })
+
+  test('a cf leaf inside $or compiles to EXISTS on the count shape instead of being dropped (#5039)', async () => {
+    const selects: any[] = []
+    const fakeDb = createFakeKysely(selects, {
+      custom_field_defs: [
+        { key: 'color', entity_id: 'scheduler:scheduled_job', is_active: true, tenant_id: null, kind: 'text', config_json: '{}' },
+      ],
+      'information_schema.columns': [
+        { table_name: 'scheduled_jobs', column_name: 'id' },
+        { table_name: 'scheduled_jobs', column_name: 'tenant_id' },
+        { table_name: 'scheduled_jobs', column_name: 'status' },
+      ],
+    })
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query('scheduler:scheduled_job', {
+      tenantId: 't1',
+      fields: ['id'],
+      filters: { $or: [{ status: { $eq: 'closed' } }, { cf_color: { $eq: 'red' } }] },
       page: { page: 1, pageSize: 20 },
     })
 
+    const countCall = findCountShapeCall(fakeDb, 'scheduled_jobs')
+    expect(countCall._ops.joins.length).toBe(0)
+    // The whole disjunction lands in one OR where-entry whose parts include an
+    // EXISTS (the cf leaf) — dropping it would narrow the OR and undercount.
+    const orEntries = countCall._ops.wheres.filter((w: any) => Array.isArray(w) && w[0] === 'or')
+    expect(orEntries.length).toBeGreaterThan(0)
+    const hasExistsPart = orEntries.some((entry: any) =>
+      (entry[1] ?? []).some((part: any) => part?.kind === 'exists' || (part?.kind === 'and' && part.parts?.some((p: any) => p?.kind === 'exists'))))
+    expect(hasExistsPart).toBe(true)
+  })
+
+  test('the probe LIMIT is cap + 1 on the row-producing inner query, counted by an outer aggregate', async () => {
+    process.env.OM_LIST_COUNT_CAP = '100'
+    const selects: any[] = []
+    const fakeDb = createFakeKysely(selects)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query('scheduler:scheduled_job', { tenantId: 't1', fields: ['id'], page: { page: 1, pageSize: 20 } })
+
+    const outer = fakeDb._calls.find((b: any) => b._ops.table === '__subquery__')
+    expect(outer).toBeTruthy()
+    expect(outer._ops.subquery.limits).toBe(101)
+    expect(outer._ops.subquery.groups.length).toBe(0)
     const countSql = findCountSql(selects)
-    expect(countSql).toContain('count(distinct')
-    expect(countSql).not.toContain('count(*)')
+    expect(countSql).toContain('count(*)')
+  })
 
-    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
-    expect(baseCall._ops.groups.length).toBe(0)
+  test('OM_LIST_COUNT_CAP=0 disables the probe: a direct unbounded count(*)', async () => {
+    process.env.OM_LIST_COUNT_CAP = '0'
+    const selects: any[] = []
+    const fakeDb = createFakeKysely(selects)
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    const result = await engine.query('scheduler:scheduled_job', { tenantId: 't1', fields: ['id'], page: { page: 1, pageSize: 20 } })
+
+    expect(fakeDb._calls.some((b: any) => b._ops.table === '__subquery__')).toBe(false)
+    const countSql = findCountSql(selects)
+    expect(countSql).toContain('count(*)')
+    expect(result.meta?.listCountCapWarning).toBeUndefined()
   })
 })

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

@@ -1,6 +1,16 @@
-import { BasicQueryEngine } from '../engine'
+import { BasicQueryEngine, clearColumnExistsCache } from '../engine'
 import { normalizeFilters } from '../join-utils'
 
+// The column-existence answer is memoized on the module, not the instance (#5605), and
+// the fixtures below declare mutually contradictory `information_schema.columns` shapes
+// for the same `scheduled_jobs` table. Without this clear, whichever test ran first
+// decides the scoping every later test sees — the automatic tenant/organization guard
+// would silently drop out of a query and the assertion for it would still be reading a
+// stale `false`.
+beforeEach(() => {
+  clearColumnExistsCache()
+})
+
 type FakeData = Record<string, any[]>
 
 function cloneRows(rows: any[] | undefined): any[] {