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

package/src/modules/query_index/lib/batch.ts

@@ -1,4 +1,4 @@
-import type { Knex } from 'knex'
+import { type Kysely, sql } from 'kysely'
 import { buildIndexDocument, type IndexCustomFieldValue } from './document'
 import { replaceSearchTokensForBatch, isSearchDebugEnabled } from './search-tokens'
 
@@ -45,7 +45,7 @@ function normalizeScopedValue(value: unknown): string | null {
 }
 
 export async function upsertIndexBatch(
-  knex: Knex,
+  db: Kysely<any>,
   entityType: string,
   rows: AnyRow[],
   scope: ScopeOverrides,
@@ -68,25 +68,31 @@ export async function upsertIndexBatch(
       ),
     )
     if (entityIds.length) {
-      const entityRows = await knex<AnyRow>('customer_entities').whereIn('id', entityIds)
+      const entityRows = await db
+        .selectFrom('customer_entities' as any)
+        .selectAll()
+        .where('id' as any, 'in', entityIds)
+        .execute() as AnyRow[]
       customerEntitiesById = new Map(entityRows.map((row) => [normalizeId(row.id), row]))
     }
   }
 
-  const customFieldRows = await knex<CustomFieldRow>('custom_field_values')
+  const customFieldRows = await db
+    .selectFrom('custom_field_values' as any)
     .select([
-      'record_id',
-      'field_key',
-      'value_text',
-      'value_multiline',
-      'value_int',
-      'value_float',
-      'value_bool',
-      'organization_id',
-      'tenant_id',
+      'record_id' as any,
+      'field_key' as any,
+      'value_text' as any,
+      'value_multiline' as any,
+      'value_int' as any,
+      'value_float' as any,
+      'value_bool' as any,
+      'organization_id' as any,
+      'tenant_id' as any,
     ])
-    .where('entity_id', entityType)
-    .whereIn('record_id', recordIds)
+    .where('entity_id' as any, '=', entityType)
+    .where('record_id' as any, 'in', recordIds)
+    .execute() as CustomFieldRow[]
 
   const customFieldMap = new Map<string, CustomFieldRow[]>()
   for (const fieldRow of customFieldRows) {
@@ -207,10 +213,10 @@ export async function upsertIndexBatch(
     entity_id: payload.entity_id,
     organization_id: payload.organization_id,
     tenant_id: payload.tenant_id,
-    doc: payload.doc,
+    doc: sql`${JSON.stringify(payload.doc)}::jsonb`,
     index_version: payload.index_version,
-    created_at: knex.fn.now(),
-    updated_at: knex.fn.now(),
+    created_at: sql`now()`,
+    updated_at: sql`now()`,
     deleted_at: null,
   }))
 
@@ -223,19 +229,22 @@ export async function upsertIndexBatch(
   }))
 
   try {
-    await knex('entity_indexes')
-      .insert(insertRows)
-      .onConflict(['entity_type', 'entity_id', 'organization_id_coalesced'])
-      .merge({
-        doc: knex.raw('excluded.doc'),
-        index_version: knex.raw('excluded.index_version'),
-        organization_id: knex.raw('excluded.organization_id'),
-        tenant_id: knex.raw('excluded.tenant_id'),
-        deleted_at: knex.raw('excluded.deleted_at'),
-        updated_at: knex.fn.now(),
-      })
+    await db
+      .insertInto('entity_indexes' as any)
+      .values(insertRows as any)
+      .onConflict((oc: any) => oc
+        .columns(['entity_type', 'entity_id', 'organization_id_coalesced'])
+        .doUpdateSet({
+          doc: sql`excluded.doc`,
+          index_version: sql`excluded.index_version`,
+          organization_id: sql`excluded.organization_id`,
+          tenant_id: sql`excluded.tenant_id`,
+          deleted_at: sql`excluded.deleted_at`,
+          updated_at: sql`now()`,
+        } as any))
+      .execute()
     try {
-      await replaceSearchTokensForBatch(knex, tokenPayloads)
+      await replaceSearchTokensForBatch(db, tokenPayloads)
     } catch {}
     if (debugEnabled) {
       console.info('[reindex:batch:tokens]', {
@@ -247,36 +256,40 @@ export async function upsertIndexBatch(
     }
     return
   } catch {
-    await knex.transaction(async (trx) => {
-      const now = trx.fn.now()
+    await db.transaction().execute(async (trx) => {
       for (const payload of basePayloads) {
-        const updated = await trx('entity_indexes')
-          .where({
-            entity_type: payload.entity_type,
-            entity_id: payload.entity_id,
-            organization_id: payload.organization_id ?? null,
-          })
-          .update({
-            doc: payload.doc,
+        let updateQuery = trx
+          .updateTable('entity_indexes' as any)
+          .set({
+            doc: sql`${JSON.stringify(payload.doc)}::jsonb`,
             index_version: payload.index_version,
             organization_id: payload.organization_id ?? null,
             tenant_id: payload.tenant_id ?? null,
-            updated_at: now,
+            updated_at: sql`now()`,
             deleted_at: null,
-          })
-        if (updated) continue
+          } as any)
+          .where('entity_type' as any, '=', payload.entity_type)
+          .where('entity_id' as any, '=', payload.entity_id)
+        updateQuery = payload.organization_id == null
+          ? updateQuery.where('organization_id' as any, 'is', null as any)
+          : updateQuery.where('organization_id' as any, '=', payload.organization_id)
+        const result = await updateQuery.executeTakeFirst() as { numUpdatedRows?: bigint | number } | undefined
+        if (result && Number(result.numUpdatedRows ?? 0) > 0) continue
         try {
-          await trx('entity_indexes').insert({
-            entity_type: payload.entity_type,
-            entity_id: payload.entity_id,
-            organization_id: payload.organization_id,
-            tenant_id: payload.tenant_id,
-            doc: payload.doc,
-            index_version: payload.index_version,
-            created_at: now,
-            updated_at: now,
-            deleted_at: null,
-          })
+          await trx
+            .insertInto('entity_indexes' as any)
+            .values({
+              entity_type: payload.entity_type,
+              entity_id: payload.entity_id,
+              organization_id: payload.organization_id,
+              tenant_id: payload.tenant_id,
+              doc: sql`${JSON.stringify(payload.doc)}::jsonb`,
+              index_version: payload.index_version,
+              created_at: sql`now()`,
+              updated_at: sql`now()`,
+              deleted_at: null,
+            } as any)
+            .execute()
         } catch {
           // ignore duplicate insert race; another concurrent worker updated the row
         }
@@ -284,6 +297,6 @@ export async function upsertIndexBatch(
     })
   }
   try {
-    await replaceSearchTokensForBatch(knex, tokenPayloads)
+    await replaceSearchTokensForBatch(db, tokenPayloads)
   } catch {}
 }

package/src/modules/query_index/lib/coverage.ts

@@ -1,5 +1,5 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
-import type { Knex } from 'knex'
+import { type Kysely, sql } from 'kysely'
 import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
 
 export type CoverageScope = {
@@ -57,71 +57,86 @@ function normalizeOrganizationForStore(orgId: string | null | undefined): string
   return orgId ?? GLOBAL_ORGANIZATION_PLACEHOLDER
 }
 
-function applyOrganizationCondition(
-  qb: Knex.QueryBuilder<any, any>,
+function applyOrganizationCondition<QB extends { where: (...args: any[]) => QB }>(
+  qb: QB,
   column: string,
-  organizationId: string | null | undefined
-) {
+  organizationId: string | null | undefined,
+): QB {
   const stored = normalizeOrganizationForStore(organizationId ?? null)
   if (stored === GLOBAL_ORGANIZATION_PLACEHOLDER) {
-    qb.andWhere((sub) => {
-      sub.whereNull(column).orWhere(column, GLOBAL_ORGANIZATION_PLACEHOLDER)
-    })
-  } else {
-    qb.andWhere(column, stored)
+    return qb.where((eb: any) => eb.or([
+      eb(column as any, 'is', null),
+      eb(column as any, '=', GLOBAL_ORGANIZATION_PLACEHOLDER),
+    ]))
   }
+  return qb.where(column as any, '=', stored)
 }
 
 async function fetchCoverageRow(
-  knex: Knex,
+  db: Kysely<any>,
   scope: CoverageScope
 ): Promise<(CoverageRow & { organization_id: string | null }) | null> {
   const { entityType, tenantId, organizationId, withDeleted } = scope
-  const row = await knex('entity_index_coverage')
-    .select(['base_count', 'indexed_count', 'vector_indexed_count', 'refreshed_at', 'organization_id'])
-    .where('entity_type', entityType)
-    .where('tenant_id', tenantId ?? null)
-    .where('with_deleted', withDeleted === true)
-    .modify((qb) => applyOrganizationCondition(qb, 'organization_id', organizationId ?? null))
-    .orderBy('refreshed_at', 'desc')
-    .first<CoverageRow & { organization_id: string | null }>()
+  let query = db
+    .selectFrom('entity_index_coverage' as any)
+    .select([
+      'base_count' as any,
+      'indexed_count' as any,
+      'vector_indexed_count' as any,
+      'refreshed_at' as any,
+      'organization_id' as any,
+    ])
+    .where('entity_type' as any, '=', entityType)
+    .where('with_deleted' as any, '=', withDeleted === true)
+    .orderBy('refreshed_at' as any, 'desc')
+  query = tenantId == null
+    ? query.where('tenant_id' as any, 'is', null as any)
+    : query.where('tenant_id' as any, '=', tenantId)
+  query = applyOrganizationCondition(query as any, 'organization_id', organizationId ?? null)
+  const row = await query.executeTakeFirst() as (CoverageRow & { organization_id: string | null }) | undefined
   return row ?? null
 }
 
 async function pruneDuplicateCoverageRows(
-  knex: Knex,
+  db: Kysely<any>,
   scope: CoverageScope,
   keepId: string | null
-) {
-  const query = knex('entity_index_coverage')
-    .where('entity_type', scope.entityType)
-    .where('tenant_id', scope.tenantId ?? null)
-    .where('with_deleted', scope.withDeleted === true)
-    .modify((qb) => applyOrganizationCondition(qb, 'organization_id', scope.organizationId ?? null))
+): Promise<void> {
+  let query = db
+    .deleteFrom('entity_index_coverage' as any)
+    .where('entity_type' as any, '=', scope.entityType)
+    .where('with_deleted' as any, '=', scope.withDeleted === true)
+  query = scope.tenantId == null
+    ? query.where('tenant_id' as any, 'is', null as any)
+    : query.where('tenant_id' as any, '=', scope.tenantId)
+  query = applyOrganizationCondition(query as any, 'organization_id', scope.organizationId ?? null)
   if (keepId) {
-    await query.andWhereNot('id', keepId).del()
-  } else {
-    await query.del()
+    query = query.where('id' as any, '!=', keepId)
   }
+  await query.execute()
 }
 
 async function upsertCoverageRow(
-  knex: Knex,
+  db: Kysely<any>,
   scope: CoverageScope,
   counts: { baseCount: number; indexedCount: number; vectorIndexedCount: number }
-) {
+): Promise<void> {
   const storedOrgId = normalizeOrganizationForStore(scope.organizationId ?? null)
   if (scope.organizationId == null) {
-    await knex('entity_index_coverage')
-      .where('entity_type', scope.entityType)
-      .where('tenant_id', scope.tenantId ?? null)
-      .where('with_deleted', scope.withDeleted === true)
-      .whereNull('organization_id')
-      .del()
+    let purge = db
+      .deleteFrom('entity_index_coverage' as any)
+      .where('entity_type' as any, '=', scope.entityType)
+      .where('with_deleted' as any, '=', scope.withDeleted === true)
+      .where('organization_id' as any, 'is', null as any)
+    purge = scope.tenantId == null
+      ? purge.where('tenant_id' as any, 'is', null as any)
+      : purge.where('tenant_id' as any, '=', scope.tenantId)
+    await purge.execute()
   }
 
-  const rows = await knex('entity_index_coverage')
-    .insert({
+  const rows = await db
+    .insertInto('entity_index_coverage' as any)
+    .values({
       entity_type: scope.entityType,
       tenant_id: scope.tenantId ?? null,
       organization_id: storedOrgId,
@@ -129,28 +144,30 @@ async function upsertCoverageRow(
       base_count: counts.baseCount,
       indexed_count: counts.indexedCount,
       vector_indexed_count: counts.vectorIndexedCount,
-      refreshed_at: knex.fn.now(),
-    })
-    .onConflict(['entity_type', 'tenant_id', 'organization_id', 'with_deleted'])
-    .merge({
-      base_count: counts.baseCount,
-      indexed_count: counts.indexedCount,
-      vector_indexed_count: counts.vectorIndexedCount,
-      refreshed_at: knex.fn.now(),
-    })
-    .returning<{ id: string }[]>('id')
+      refreshed_at: sql`now()`,
+    } as any)
+    .onConflict((oc: any) => oc
+      .columns(['entity_type', 'tenant_id', 'organization_id', 'with_deleted'])
+      .doUpdateSet({
+        base_count: counts.baseCount,
+        indexed_count: counts.indexedCount,
+        vector_indexed_count: counts.vectorIndexedCount,
+        refreshed_at: sql`now()`,
+      } as any))
+    .returning(['id' as any])
+    .execute() as Array<{ id: string }>
 
   const keepId = rows?.[0]?.id ?? null
-  await pruneDuplicateCoverageRows(knex, scope, keepId)
+  await pruneDuplicateCoverageRows(db, scope, keepId)
 }
 
 export async function readCoverageSnapshot(
-  knex: Knex,
+  db: Kysely<any>,
   scope: CoverageScope
 ): Promise<(CoverageRow & { baseCount: number; indexedCount: number; vectorIndexedCount: number }) | null> {
   const entityType = String(scope.entityType || '')
   if (!entityType) return null
-  const row = await fetchCoverageRow(knex, {
+  const row = await fetchCoverageRow(db, {
     entityType,
     tenantId: scope.tenantId ?? null,
     organizationId: scope.organizationId ?? null,
@@ -174,11 +191,11 @@ export async function applyCoverageAdjustments(
   adjustments: CoverageAdjustment[]
 ): Promise<void> {
   if (!adjustments.length) return
-  const knex = (em as any).getConnection().getKnex() as Knex
+  const db = (em as any).getKysely() as Kysely<any>
   const aggregated = aggregateAdjustments(adjustments)
   for (const entry of aggregated) {
     const scope = entry.scope
-    const existing = await fetchCoverageRow(knex, scope)
+    const existing = await fetchCoverageRow(db, scope)
     const currentBase = existing ? toCount(existing.base_count) : 0
     const currentIndex = existing ? toCount(existing.indexed_count) : 0
     const currentVector = existing ? toCount(existing.vector_indexed_count) : 0
@@ -186,7 +203,7 @@ export async function applyCoverageAdjustments(
     const nextIndex = Math.max(currentIndex + entry.deltaIndex, 0)
     const nextVector = Math.max(currentVector + entry.deltaVector, 0)
 
-    await upsertCoverageRow(knex, scope, {
+    await upsertCoverageRow(db, scope, {
       baseCount: nextBase,
       indexedCount: nextIndex,
       vectorIndexedCount: nextVector,
@@ -194,18 +211,24 @@ export async function applyCoverageAdjustments(
   }
 }
 
-export async function deleteCoverageForEntity(knex: Knex, entityType: string): Promise<void> {
+export async function deleteCoverageForEntity(db: Kysely<any>, entityType: string): Promise<void> {
   if (!entityType) return
-  await knex('entity_index_coverage').where({ entity_type: entityType }).del()
+  await db
+    .deleteFrom('entity_index_coverage' as any)
+    .where('entity_type' as any, '=', entityType)
+    .execute()
 }
 
-async function tableHasColumn(knex: Knex, table: string, column: string): Promise<boolean> {
+async function tableHasColumn(db: Kysely<any>, table: string, column: string): Promise<boolean> {
   const key = `${table}.${column}`
   if (COLUMN_CACHE.has(key)) return COLUMN_CACHE.get(key)!
-  const exists = await knex('information_schema.columns')
-    .whereRaw('table_schema = current_schema()')
-    .where({ table_name: table, column_name: column })
-    .first()
+  const exists = await db
+    .selectFrom('information_schema.columns' as any)
+    .select(sql<number>`1`.as('present'))
+    .where(sql<boolean>`table_schema = current_schema()`)
+    .where('table_name' as any, '=', table)
+    .where('column_name' as any, '=', column)
+    .executeTakeFirst()
   const present = !!exists
   COLUMN_CACHE.set(key, present)
   return present
@@ -221,47 +244,51 @@ export async function refreshCoverageSnapshot(
   const organizationId = scope.organizationId ?? null
   const withDeleted = scope.withDeleted === true
 
-  const knex = (em as any).getConnection().getKnex() as Knex
+  const db = (em as any).getKysely() as Kysely<any>
   const baseTable = resolveEntityTableName(em, entityType)
 
-  const hasOrg = await tableHasColumn(knex, baseTable, 'organization_id')
-  const hasTenant = await tableHasColumn(knex, baseTable, 'tenant_id')
-  const hasDeleted = await tableHasColumn(knex, baseTable, 'deleted_at')
+  const hasOrg = await tableHasColumn(db, baseTable, 'organization_id')
+  const hasTenant = await tableHasColumn(db, baseTable, 'tenant_id')
+  const hasDeleted = await tableHasColumn(db, baseTable, 'deleted_at')
 
   if (organizationId !== null && !hasOrg) return
   if (tenantId !== null && !hasTenant) return
 
-  let baseQuery = knex({ b: baseTable }).count({ count: '*' })
-  if (organizationId !== null && hasOrg) baseQuery = baseQuery.where('b.organization_id', organizationId)
-  if (tenantId !== null && hasTenant) baseQuery = baseQuery.where('b.tenant_id', tenantId)
-  if (!withDeleted && hasDeleted) baseQuery = baseQuery.whereNull('b.deleted_at')
+  let baseQuery = db
+    .selectFrom(`${baseTable} as b` as any)
+    .select(sql`count(*)`.as('count'))
+  if (organizationId !== null && hasOrg) baseQuery = baseQuery.where('b.organization_id' as any, '=', organizationId)
+  if (tenantId !== null && hasTenant) baseQuery = baseQuery.where('b.tenant_id' as any, '=', tenantId)
+  if (!withDeleted && hasDeleted) baseQuery = baseQuery.where('b.deleted_at' as any, 'is', null as any)
 
-  const baseRow = await baseQuery.first()
+  const baseRow = await baseQuery.executeTakeFirst() as { count: unknown } | undefined
   const baseCount = toCount(baseRow?.count)
 
-  let indexQuery = knex({ ei: 'entity_indexes' })
-    .count({ count: '*' })
-    .where('ei.entity_type', entityType)
-  if (organizationId !== null) indexQuery = indexQuery.where('ei.organization_id', organizationId)
-  if (tenantId !== null) indexQuery = indexQuery.where('ei.tenant_id', tenantId)
-  if (!withDeleted) indexQuery = indexQuery.whereNull('ei.deleted_at')
+  let indexQuery = db
+    .selectFrom('entity_indexes as ei' as any)
+    .select(sql`count(*)`.as('count'))
+    .where('ei.entity_type' as any, '=', entityType)
+  if (organizationId !== null) indexQuery = indexQuery.where('ei.organization_id' as any, '=', organizationId)
+  if (tenantId !== null) indexQuery = indexQuery.where('ei.tenant_id' as any, '=', tenantId)
+  if (!withDeleted) indexQuery = indexQuery.where('ei.deleted_at' as any, 'is', null as any)
 
-  const indexRow = await indexQuery.first()
+  const indexRow = await indexQuery.executeTakeFirst() as { count: unknown } | undefined
   const indexCount = toCount(indexRow?.count)
 
   // Count vector entries directly from database
   let vectorCount: number | undefined
-  const hasVectorTable = await tableHasColumn(knex, 'vector_search', 'entity_id')
+  const hasVectorTable = await tableHasColumn(db, 'vector_search', 'entity_id')
   if (hasVectorTable && typeof tenantId === 'string' && tenantId.length > 0) {
     try {
-      let vectorQuery = knex('vector_search')
-        .count({ count: 1 })
-        .where('entity_id', entityType)
-        .where('tenant_id', tenantId)
+      let vectorQuery = db
+        .selectFrom('vector_search' as any)
+        .select(sql`count(*)`.as('count'))
+        .where('entity_id' as any, '=', entityType)
+        .where('tenant_id' as any, '=', tenantId)
       if (organizationId !== null) {
-        vectorQuery = vectorQuery.where('organization_id', organizationId)
+        vectorQuery = vectorQuery.where('organization_id' as any, '=', organizationId)
       }
-      const vectorRow = await vectorQuery.first()
+      const vectorRow = await vectorQuery.executeTakeFirst() as { count: unknown } | undefined
       vectorCount = toCount(vectorRow?.count)
     } catch (err) {
       console.warn('[query_index] Failed to resolve vector count for coverage snapshot', {
@@ -288,11 +315,11 @@ export async function writeCoverageCounts(
 ): Promise<void> {
   const entityType = String(scope.entityType || '')
   if (!entityType) return
-  const knex = (em as any).getConnection().getKnex() as Knex
+  const db = (em as any).getKysely() as Kysely<any>
   const tenantId = scope.tenantId ?? null
   const organizationId = scope.organizationId ?? null
   const withDeleted = scope.withDeleted === true
-  const existing = await fetchCoverageRow(knex, {
+  const existing = await fetchCoverageRow(db, {
     entityType,
     tenantId,
     organizationId,
@@ -307,7 +334,7 @@ export async function writeCoverageCounts(
   const vectorCount = counts.vectorCount !== undefined
     ? Math.max(0, Math.trunc(toCount(counts.vectorCount)))
     : Math.max(0, Math.trunc(toCount(existing?.vector_indexed_count)))
-  await upsertCoverageRow(knex, { entityType, tenantId, organizationId, withDeleted }, {
+  await upsertCoverageRow(db, { entityType, tenantId, organizationId, withDeleted }, {
     baseCount,
     indexedCount: indexCount,
     vectorIndexedCount: vectorCount,