@open-mercato/shared 0.6.6-develop.5757.1.f5cc26cf92 → 0.6.6-develop.5876.1.6a45c370ac

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

@@ -158,7 +158,7 @@ function createFakeKysely(overrides?: FakeData) {
           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' }
+          return { count: String((data[localOps.table] || []).length) }
         }
         const rows = data[localOps.table] || []
         if (rows.length === 0) return { count: '0' }
@@ -642,9 +642,164 @@ describe('BasicQueryEngine (Kysely)', () => {
     })
 
     expect(result.items.map((item: any) => item.display_name)).toEqual(['Charlie', 'Dave'])
-    const baseCall = fakeDb._calls.find((call: any) => call._ops.table === 'customer_entities')
-    expect(baseCall._ops.orderBys).toEqual([])
-    expect(baseCall._ops.limits).toBe(0)
+    const baseCalls = fakeDb._calls.filter((call: any) => call._ops.table === 'customer_entities')
+    expect(baseCalls.length).toBe(2)
+    // qFull ('full' projection) is built first (used for count + phase 2);
+    // qSort ('sortKeys' projection) is built second (phase 1).
+    const [phase2Call, phase1Call] = baseCalls
+    // Phase 1 (slim id+sort-column scan): no SQL order/limit — the full candidate
+    // set is fetched, decrypted, and sorted in memory.
+    expect(phase1Call._ops.orderBys).toEqual([])
+    expect(phase1Call._ops.limits).toBe(0)
+    // Phase 2 (full-row fetch for the page's ids): filtered by `id in [...]`, no
+    // SQL order/limit needed since the id list already bounds it to the page.
+    expect(phase2Call._ops.orderBys).toEqual([])
+    expect(phase2Call._ops.limits).toBe(0)
+    expect(phase2Call._ops.wheres.some((w: any) => Array.isArray(w) && w[0] === 'customer_entities.id' && w[1] === 'in')).toBe(true)
+  })
+
+  test('paginates encrypted-sorted results correctly on page 1 and the tail page', async () => {
+    const fakeDb = createFakeKysely({
+      customer_entities: [
+        { id: '3', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-c' },
+        { id: '1', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-a' },
+        { id: '5', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-e' },
+        { id: '2', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-b' },
+        { id: '4', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-d' },
+      ],
+      'information_schema.columns': [
+        { table_name: 'customer_entities', column_name: 'id' },
+        { table_name: 'customer_entities', column_name: 'tenant_id' },
+        { table_name: 'customer_entities', column_name: 'organization_id' },
+        { table_name: 'customer_entities', column_name: 'deleted_at' },
+        { table_name: 'customer_entities', column_name: 'display_name' },
+      ],
+    })
+    const namesById: Record<string, string> = {
+      '1': 'Alice', '2': 'Bob', '3': 'Charlie', '4': 'Dave', '5': 'Eve',
+    }
+    const engine = new BasicQueryEngine(
+      {} as any,
+      () => fakeDb as any,
+      () => ({
+        isEnabled: () => true,
+        getEncryptedFieldNames: async () => ['display_name'],
+        decryptEntityPayload: async (_entityId, payload) => ({
+          display_name: namesById[String(payload.id)],
+        }),
+      }),
+    )
+
+    const page1 = await engine.query('customers:customer_entity', {
+      tenantId: 't1',
+      organizationId: 'org1',
+      fields: ['id', 'display_name'],
+      sort: [{ field: 'display_name', dir: SortDir.Asc }],
+      page: { page: 1, pageSize: 2 },
+    })
+    expect(page1.items.map((item: any) => item.display_name)).toEqual(['Alice', 'Bob'])
+
+    const page3 = await engine.query('customers:customer_entity', {
+      tenantId: 't1',
+      organizationId: 'org1',
+      fields: ['id', 'display_name'],
+      sort: [{ field: 'display_name', dir: SortDir.Asc }],
+      page: { page: 3, pageSize: 2 },
+    })
+    expect(page3.items.map((item: any) => item.display_name)).toEqual(['Eve'])
+  })
+
+  describe('OM_ENCRYPTED_SORT_MAX_ROWS cap', () => {
+    const originalEnv = process.env.OM_ENCRYPTED_SORT_MAX_ROWS
+
+    afterEach(() => {
+      if (originalEnv === undefined) delete process.env.OM_ENCRYPTED_SORT_MAX_ROWS
+      else process.env.OM_ENCRYPTED_SORT_MAX_ROWS = originalEnv
+    })
+
+    function buildFixture() {
+      const fakeDb = createFakeKysely({
+        customer_entities: [
+          { id: '3', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-c' },
+          { id: '1', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-a' },
+          { id: '5', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-e' },
+          { id: '2', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-b' },
+          { id: '4', tenant_id: 't1', organization_id: 'org1', display_name: 'cipher-d' },
+        ],
+        'information_schema.columns': [
+          { table_name: 'customer_entities', column_name: 'id' },
+          { table_name: 'customer_entities', column_name: 'tenant_id' },
+          { table_name: 'customer_entities', column_name: 'organization_id' },
+          { table_name: 'customer_entities', column_name: 'deleted_at' },
+          { table_name: 'customer_entities', column_name: 'display_name' },
+        ],
+      })
+      const namesById: Record<string, string> = {
+        '1': 'Alice', '2': 'Bob', '3': 'Charlie', '4': 'Dave', '5': 'Eve',
+      }
+      const engine = new BasicQueryEngine(
+        {} as any,
+        () => fakeDb as any,
+        () => ({
+          isEnabled: () => true,
+          getEncryptedFieldNames: async () => ['display_name'],
+          decryptEntityPayload: async (_entityId, payload) => ({
+            display_name: namesById[String(payload.id)],
+          }),
+        }),
+      )
+      return { fakeDb, engine }
+    }
+
+    test('unset: no limit on the phase-1 scan, no warning', async () => {
+      delete process.env.OM_ENCRYPTED_SORT_MAX_ROWS
+      const { fakeDb, engine } = buildFixture()
+      const result = await engine.query('customers:customer_entity', {
+        tenantId: 't1',
+        organizationId: 'org1',
+        fields: ['id', 'display_name'],
+        sort: [{ field: 'display_name', dir: SortDir.Asc }],
+        page: { page: 1, pageSize: 2 },
+      })
+      expect(result.meta?.encryptedSortRowCapWarning).toBeUndefined()
+      const [, phase1Call] = fakeDb._calls.filter((call: any) => call._ops.table === 'customer_entities')
+      expect(phase1Call._ops.limits).toBe(0)
+    })
+
+    test('set but not exceeded: no warning, identical results to uncapped', async () => {
+      process.env.OM_ENCRYPTED_SORT_MAX_ROWS = '10'
+      const { fakeDb, engine } = buildFixture()
+      const result = await engine.query('customers:customer_entity', {
+        tenantId: 't1',
+        organizationId: 'org1',
+        fields: ['id', 'display_name'],
+        sort: [{ field: 'display_name', dir: SortDir.Asc }],
+        page: { page: 1, pageSize: 2 },
+      })
+      expect(result.meta?.encryptedSortRowCapWarning).toBeUndefined()
+      expect(result.items.map((item: any) => item.display_name)).toEqual(['Alice', 'Bob'])
+    })
+
+    test('set and exceeded: caps + orders the phase-1 scan and attaches a warning', async () => {
+      process.env.OM_ENCRYPTED_SORT_MAX_ROWS = '3'
+      const { fakeDb, engine } = buildFixture()
+      const result = await engine.query('customers:customer_entity', {
+        tenantId: 't1',
+        organizationId: 'org1',
+        fields: ['id', 'display_name'],
+        sort: [{ field: 'display_name', dir: SortDir.Asc }],
+        page: { page: 1, pageSize: 2 },
+      })
+      expect(result.meta?.encryptedSortRowCapWarning).toEqual({
+        entity: 'customers:customer_entity',
+        sortFields: ['display_name'],
+        maxRows: 3,
+        totalMatched: 5,
+      })
+      const [, phase1Call] = fakeDb._calls.filter((call: any) => call._ops.table === 'customer_entities')
+      expect(phase1Call._ops.limits).toBe(3)
+      expect(phase1Call._ops.orderBys).toEqual([['customer_entities.id', 'asc']])
+    })
   })
 
   test('keeps SQL ordering and pagination for unencrypted base fields', async () => {

package/src/lib/query/bounded-decrypt.ts

@@ -0,0 +1,26 @@
+/**
+ * Maps `items` through `mapper` with at most `concurrency` calls in flight at
+ * once, preserving input order in the output. Chunks are processed
+ * sequentially; within a chunk, calls run in parallel via `Promise.all`.
+ *
+ * When `concurrency` is non-positive or `>= items.length`, this is
+ * equivalent to a plain `Promise.all(items.map(mapper))`.
+ */
+export async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  mapper: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  if (concurrency <= 0 || items.length <= concurrency) {
+    return Promise.all(items.map((item, index) => mapper(item, index)))
+  }
+  const results: R[] = new Array(items.length)
+  for (let start = 0; start < items.length; start += concurrency) {
+    const chunk = items.slice(start, start + concurrency)
+    const chunkResults = await Promise.all(
+      chunk.map((item, offset) => mapper(item, start + offset)),
+    )
+    for (let i = 0; i < chunkResults.length; i++) results[start + i] = chunkResults[i]
+  }
+  return results
+}

package/src/lib/query/encrypted-sort.ts

@@ -24,6 +24,19 @@ export function fieldNameCandidates(field: string): string[] {
   return Array.from(new Set(candidates))
 }
 
+/**
+ * Opt-in cap on how many candidate rows the plaintext-sort path may fetch
+ * for sort-column decryption. Unset or invalid input means uncapped — the
+ * default must stay byte-identical to the pre-cap behavior.
+ */
+export function resolveEncryptedSortMaxRows(): number | null {
+  const raw = process.env.OM_ENCRYPTED_SORT_MAX_ROWS
+  if (raw === undefined || raw === '') return null
+  const parsed = Number(raw)
+  if (!Number.isFinite(parsed) || parsed <= 0) return null
+  return Math.floor(parsed)
+}
+
 export async function resolveEncryptedSortFields(
   service: QueryEncryptionService | null | undefined,
   entity: EntityId,