@open-mercato/shared 0.6.8-develop.7099.1.7ba2771d06 → 0.7.0

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

@@ -1,13 +1,6 @@
-import { BasicQueryEngine, clearColumnExistsCache } from '../engine'
+import { BasicQueryEngine } 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' } }] },
@@ -146,22 +139,6 @@ 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,
@@ -196,28 +173,8 @@ function findCountSql(selectsSink: any[]): string {
   return rawSqlText(countExprs[countExprs.length - 1]).toLowerCase()
 }
 
-// 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 () => {
+describe('BasicQueryEngine — list COUNT query (issue #2227)', () => {
+  test('uses count(*) and no group-by when no joins can multiply base rows', async () => {
     const selects: any[] = []
     const fakeDb = createFakeKysely(selects)
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
@@ -227,11 +184,11 @@ describe('BasicQueryEngine — rebuilt list COUNT query (#4552 Phase 2)', () =>
     expect(countSql).toContain('count(*)')
     expect(countSql).not.toContain('distinct')
 
-    const countCall = findCountShapeCall(fakeDb, 'scheduled_jobs')
-    expect(countCall._ops.groups.length).toBe(0)
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    expect(baseCall._ops.groups.length).toBe(0)
   })
 
-  test('drops extension projection joins from the count: count(*) over the bare base table', async () => {
+  test('keeps count(distinct base.id) with group-by when extensions are joined', async () => {
     const selects: any[] = []
     const fakeDb = createFakeKysely(selects)
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
@@ -244,20 +201,14 @@ describe('BasicQueryEngine — rebuilt list COUNT query (#4552 Phase 2)', () =>
     })
 
     const countSql = findCountSql(selects)
-    expect(countSql).toContain('count(*)')
-    expect(countSql).not.toContain('distinct')
+    expect(countSql).toContain('count(distinct')
+    expect(countSql).not.toContain('count(*)')
 
-    // 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)
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'users')
+    expect(baseCall._ops.groups.length).toBeGreaterThan(0)
   })
 
-  test('explicit relation joins never reach the count: count(*), join filters stay EXISTS', async () => {
+  test('keeps count(distinct base.id) without group-by when an explicit relation join is configured', async () => {
     const selects: any[] = []
     const fakeDb = createFakeKysely(selects)
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
@@ -265,112 +216,14 @@ describe('BasicQueryEngine — rebuilt list COUNT query (#4552 Phase 2)', () =>
       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(*)')
-  })
+    expect(countSql).toContain('count(distinct')
+    expect(countSql).not.toContain('count(*)')
 
-  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()
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    expect(baseCall._ops.groups.length).toBe(0)
   })
 })

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

@@ -1,16 +1,6 @@
-import { BasicQueryEngine, clearColumnExistsCache } from '../engine'
+import { BasicQueryEngine } 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[] {