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

package/src/modules/customers/api/interactions/conflicts/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { z } from 'zod'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
@@ -93,47 +94,49 @@ export async function GET(req: Request) {
 
     const checkUserId = query.userId ?? auth.userId
     const em = (container.resolve('em') as EntityManager).fork()
-    const knex = em.getKnex()
+    const kysely = em.getKysely<any>()
 
-    const baseQuery = knex('customer_interactions')
-      .where('tenant_id', auth.tenantId)
-      .where('status', 'planned')
-      .whereNotNull('scheduled_at')
-      .whereNull('deleted_at')
+    let baseQuery = (kysely as any)
+      .selectFrom('customer_interactions')
+      .select(['id', 'scheduled_at', 'duration_minutes', 'interaction_type'])
+      .where('tenant_id', '=', auth.tenantId)
+      .where('status', '=', 'planned')
+      .where('scheduled_at', 'is not', null)
+      .where('deleted_at', 'is', null)
 
     if (organizationIds.length === 1) {
-      baseQuery.where('organization_id', organizationIds[0])
+      baseQuery = baseQuery.where('organization_id', '=', organizationIds[0])
     } else if (organizationIds.length > 1) {
-      baseQuery.whereIn('organization_id', organizationIds)
+      baseQuery = baseQuery.where('organization_id', 'in', organizationIds)
     }
 
     if (checkUserId) {
-      baseQuery.where(function () {
-        this.where('author_user_id', checkUserId).orWhere('owner_user_id', checkUserId)
-      })
+      baseQuery = baseQuery.where((eb: any) =>
+        eb.or([
+          eb('author_user_id', '=', checkUserId),
+          eb('owner_user_id', '=', checkUserId),
+        ])
+      )
     }
 
     if (query.excludeId) {
-      baseQuery.whereNot('id', query.excludeId)
+      baseQuery = baseQuery.where('id', '!=', query.excludeId)
     }
 
     // Overlap condition: existing.start < windowEnd AND existing.end > windowStart
     // end = scheduled_at + duration_minutes (default 30 if null)
-    baseQuery.where(function () {
-      this.where('scheduled_at', '<', windowEnd.toISOString())
-        .andWhere(
-          knex.raw(
-            '(scheduled_at + make_interval(mins => COALESCE(duration_minutes, 30))) > ?',
-            [windowStart.toISOString()],
-          ),
-        )
-    })
+    baseQuery = baseQuery.where((eb: any) =>
+      eb.and([
+        eb('scheduled_at', '<', windowEnd.toISOString()),
+        eb(sql`(scheduled_at + make_interval(mins => COALESCE(duration_minutes, 30)))`, '>', windowStart.toISOString()),
+      ])
+    )
 
     // Raw SELECT: reads only unencrypted columns (id, scheduled_at, duration_minutes, interaction_type); title is excluded to avoid ciphertext leakage and is resolved below via findWithDecryption.
     const rows = await baseQuery
-      .select('id', 'scheduled_at', 'duration_minutes', 'interaction_type')
       .orderBy('scheduled_at', 'asc')
-      .limit(10) as Array<{
+      .limit(10)
+      .execute() as Array<{
         id: string
         scheduled_at: string | Date
         duration_minutes: number | null

package/src/modules/customers/api/interactions/counts/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { z } from 'zod'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
@@ -67,28 +68,29 @@ export async function GET(req: Request) {
         ? [auth.orgId]
         : []
     const em = (container.resolve('em') as EntityManager).fork()
-    const knex = em.getKnex()
+    const kysely = em.getKysely<any>()
 
-    const baseQuery = knex('customer_interactions')
-      .where('entity_id', query.entityId)
-      .where('tenant_id', auth.tenantId)
-      .whereNull('deleted_at')
+    let baseQuery = (kysely as any)
+      .selectFrom('customer_interactions')
+      .where('entity_id', '=', query.entityId)
+      .where('tenant_id', '=', auth.tenantId)
+      .where('deleted_at', 'is', null)
 
     if (organizationIds.length === 1) {
-      baseQuery.where('organization_id', organizationIds[0])
+      baseQuery = baseQuery.where('organization_id', '=', organizationIds[0])
     } else if (organizationIds.length > 1) {
-      baseQuery.whereIn('organization_id', organizationIds)
+      baseQuery = baseQuery.where('organization_id', 'in', organizationIds)
     }
 
     if (query.status) {
-      baseQuery.where('status', query.status)
+      baseQuery = baseQuery.where('status', '=', query.status)
     }
 
     // Raw SELECT: reads only unencrypted columns (id, interaction_type); title/notes are excluded to avoid ciphertext leakage.
     const rows = await baseQuery
-      .select('interaction_type')
-      .count('* as count')
-      .groupBy('interaction_type') as Array<{ interaction_type: string; count: string | number }>
+      .select(['interaction_type', sql<string>`count(*)`.as('count')])
+      .groupBy('interaction_type')
+      .execute() as Array<{ interaction_type: string; count: string | number }>
 
     const counts: Record<string, number> = { call: 0, email: 0, meeting: 0, note: 0 }
     let total = 0

package/src/modules/customers/api/interactions/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { z } from 'zod'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
 import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { loadCustomFieldValues } from '@open-mercato/shared/lib/crud/custom-fields'
@@ -314,7 +315,7 @@ export async function GET(req: Request) {
         : []
     const selectedOrganizationId = scope?.selectedId ?? auth.orgId ?? organizationIds[0] ?? null
     const em = (container.resolve('em') as EntityManager).fork()
-    const knex = em.getKnex()
+    const db = em.getKysely<any>() as any
 
     const requestedSortField = query.sortField ?? 'scheduledAt'
     const sortConfig = interactionSortConfig[requestedSortField]
@@ -327,8 +328,9 @@ export async function GET(req: Request) {
       })
     }
 
-    const rowsQuery = knex('customer_interactions')
-      .select<InteractionListRow[]>([
+    let rowsQuery = db
+      .selectFrom('customer_interactions')
+      .select([
         'id',
         'entity_id',
         'deal_id',
@@ -359,72 +361,58 @@ export async function GET(req: Request) {
         'tenant_id',
         'created_at',
         'updated_at',
-        knex.raw(`${sortSql} as __sort_value`),
+        sql`${sql.raw(sortSql)}`.as('__sort_value'),
       ])
-      .whereNull('deleted_at')
-      .andWhere('tenant_id', auth.tenantId)
+      .where('deleted_at', 'is', null)
+      .where('tenant_id', '=', auth.tenantId)
       .limit(query.limit + 1)
 
     if (organizationIds.length > 0) {
-      rowsQuery.whereIn('organization_id', organizationIds)
-    }
-    if (query.entityId) {
-      rowsQuery.andWhere('entity_id', query.entityId)
-    }
-    if (query.dealId) {
-      rowsQuery.andWhere('deal_id', query.dealId)
-    }
-    if (query.status) {
-      rowsQuery.andWhere('status', query.status)
-    }
-    if (query.interactionType) {
-      rowsQuery.andWhere('interaction_type', query.interactionType)
+      rowsQuery = rowsQuery.where('organization_id', 'in', organizationIds)
     }
+    if (query.entityId) rowsQuery = rowsQuery.where('entity_id', '=', query.entityId)
+    if (query.dealId) rowsQuery = rowsQuery.where('deal_id', '=', query.dealId)
+    if (query.status) rowsQuery = rowsQuery.where('status', '=', query.status)
+    if (query.interactionType) rowsQuery = rowsQuery.where('interaction_type', '=', query.interactionType)
     if (query.type) {
       const types = query.type.split(',').map((t) => t.trim()).filter(Boolean)
       if (types.length > 0) {
-        rowsQuery.whereIn('interaction_type', types)
+        rowsQuery = rowsQuery.where('interaction_type', 'in', types)
       }
     }
     if (query.pinned === 'true') {
-      rowsQuery.andWhere('pinned', true)
+      rowsQuery = rowsQuery.where('pinned', '=', true)
     } else if (query.pinned === 'false') {
-      rowsQuery.andWhere('pinned', false)
-    }
-    if (query.excludeInteractionType) {
-      rowsQuery.andWhereNot('interaction_type', query.excludeInteractionType)
+      rowsQuery = rowsQuery.where('pinned', '=', false)
     }
+    if (query.excludeInteractionType) rowsQuery = rowsQuery.where('interaction_type', '!=', query.excludeInteractionType)
     if (query.search) {
       const searchTerm = `%${query.search}%`
-      rowsQuery.andWhere(function applySearch() {
-        this.whereRaw("coalesce(title, '') ilike ?", [searchTerm]).orWhereRaw("coalesce(body, '') ilike ?", [searchTerm])
-      })
+      rowsQuery = rowsQuery.where(sql<boolean>`coalesce(title, '') ilike ${searchTerm} or coalesce(body, '') ilike ${searchTerm}`)
     }
     if (query.from) {
-      rowsQuery.andWhereRaw(
-        "coalesce(occurred_at, scheduled_at, created_at) >= ?",
-        [new Date(query.from)],
-      )
+      rowsQuery = rowsQuery.where(sql<boolean>`coalesce(occurred_at, scheduled_at, created_at) >= ${new Date(query.from)}`)
     }
     if (query.to) {
-      rowsQuery.andWhereRaw(
-        "coalesce(occurred_at, scheduled_at, created_at) <= ?",
-        [new Date(query.to)],
-      )
+      rowsQuery = rowsQuery.where(sql<boolean>`coalesce(occurred_at, scheduled_at, created_at) <= ${new Date(query.to)}`)
     }
+
     if (cursor) {
       const op = sortDir === 'asc' ? '>' : '<'
-      rowsQuery.andWhere(function applyCursor() {
-        this.whereRaw(`${sortSql} ${op} ?`, [cursor.sortValue]).orWhere(function applyTieBreaker() {
-          this.whereRaw(`${sortSql} = ?`, [cursor.sortValue]).andWhere('id', op, cursor.id)
-        })
-      })
+      const opRaw = sql.raw(op)
+      const sortRaw = sql.raw(sortSql)
+      rowsQuery = rowsQuery.where((eb: any) => eb.or([
+        sql<boolean>`${sortRaw} ${opRaw} ${cursor.sortValue}`,
+        eb.and([
+          sql<boolean>`${sortRaw} = ${cursor.sortValue}`,
+          eb('id', op, cursor.id),
+        ]),
+      ]))
     }
 
-    rowsQuery.orderByRaw(`${sortSql} ${sortDir}`)
-    rowsQuery.orderBy('id', sortDir)
+    rowsQuery = rowsQuery.orderBy(sql`${sql.raw(sortSql)} ${sql.raw(sortDir)}`).orderBy('id', sortDir)
 
-    const rows = await rowsQuery
+    const rows = await rowsQuery.execute() as InteractionListRow[]
     const pageRows = rows.slice(0, query.limit)
     const hasMore = rows.length > query.limit
 

package/src/modules/customers/api/utils.ts

@@ -1,5 +1,6 @@
 import { createScopedApiHelpers } from '@open-mercato/shared/lib/api/scoped'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
 import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
 import type { EntityId } from '@open-mercato/shared/modules/entities'
 import type { QueryCustomFieldSource, QueryJoinEdge, QueryEngine } from '@open-mercato/shared/lib/query/types'
@@ -50,28 +51,33 @@ async function enrichSearchSourcesWithCustomFieldTokens(
   if (!entityTypes.length) return sources
 
   const em = ctx.container.resolve('em') as EntityManager
-  const knex = (em as any).getConnection().getKnex()
-  let defsQuery = knex('custom_field_defs')
-    .select('entity_id', 'key', 'kind')
-    .whereIn('entity_id', entityTypes)
-    .andWhere('is_active', true)
-
-  defsQuery = defsQuery.andWhere((builder: any) => {
-    builder.where({ tenant_id: ctx.auth?.tenantId ?? null }).orWhereNull('tenant_id')
-  })
+  const db = em.getKysely<any>() as any
+  let defsQuery = db
+    .selectFrom('custom_field_defs')
+    .select(['entity_id', 'key', 'kind'])
+    .where('entity_id', 'in', entityTypes)
+    .where('is_active', '=', true)
+
+  const tenantScope = ctx.auth?.tenantId ?? null
+  defsQuery = defsQuery.where((eb: any) => eb.or([
+    eb('tenant_id', '=', tenantScope),
+    eb('tenant_id', 'is', null),
+  ]))
 
   if (ctx.selectedOrganizationId) {
-    defsQuery = defsQuery.andWhere((builder: any) => {
-      builder.where({ organization_id: ctx.selectedOrganizationId }).orWhereNull('organization_id')
-    })
+    defsQuery = defsQuery.where((eb: any) => eb.or([
+      eb('organization_id', '=', ctx.selectedOrganizationId),
+      eb('organization_id', 'is', null),
+    ]))
   } else if (Array.isArray(ctx.organizationIds) && ctx.organizationIds.length > 0) {
-    defsQuery = defsQuery.andWhere((builder: any) => {
-      builder.whereIn('organization_id', ctx.organizationIds).orWhereNull('organization_id')
-    })
+    defsQuery = defsQuery.where((eb: any) => eb.or([
+      eb('organization_id', 'in', ctx.organizationIds),
+      eb('organization_id', 'is', null),
+    ]))
   }
 
   const customFieldKeysByEntity = new Map<string, Set<string>>()
-  const rows = await defsQuery
+  const rows = await defsQuery.execute()
   for (const row of rows as Array<{ entity_id?: unknown; key?: unknown; kind?: unknown }>) {
     if (row.kind === 'attachment') continue
     const entityType = typeof row.entity_id === 'string' ? row.entity_id : null
@@ -108,28 +114,29 @@ async function findSearchTokenEntityIds({
   if (!tokens.hashes.length) return []
 
   const em = ctx.container.resolve('em') as EntityManager
-  const knex = (em as any).getConnection().getKnex()
-  let searchQuery = knex('search_tokens')
+  const db = em.getKysely<any>() as any
+  let searchQuery = db
+    .selectFrom('search_tokens')
     .select('entity_id')
-    .where('entity_type', entityType)
-    .whereIn('field', fields)
-    .whereIn('token_hash', tokens.hashes)
+    .where('entity_type', '=', entityType)
+    .where('field', 'in', fields)
+    .where('token_hash', 'in', tokens.hashes)
     .groupBy('entity_id')
-    .havingRaw('count(distinct token_hash) >= ?', [tokens.hashes.length])
+    .having(sql<boolean>`count(distinct token_hash) >= ${tokens.hashes.length}`)
 
   if (ctx.auth?.tenantId !== undefined) {
-    searchQuery = searchQuery.whereRaw('tenant_id is not distinct from ?', [ctx.auth?.tenantId ?? null])
+    searchQuery = searchQuery.where(sql<boolean>`tenant_id is not distinct from ${ctx.auth?.tenantId ?? null}`)
   }
   if (ctx.selectedOrganizationId) {
-    searchQuery = searchQuery.where('organization_id', ctx.selectedOrganizationId)
+    searchQuery = searchQuery.where('organization_id', '=', ctx.selectedOrganizationId)
   } else if (Array.isArray(ctx.organizationIds) && ctx.organizationIds.length > 0) {
-    searchQuery = searchQuery.whereIn('organization_id', ctx.organizationIds)
+    searchQuery = searchQuery.where('organization_id', 'in', ctx.organizationIds)
   }
 
-  const rows = await searchQuery
+  const rows = await searchQuery.execute() as Array<{ entity_id?: unknown }>
   return rows
-    .map((row: { entity_id?: unknown }) => (typeof row.entity_id === 'string' ? row.entity_id : null))
-    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+    .map((row) => (typeof row.entity_id === 'string' ? row.entity_id : null))
+    .filter((id): id is string => typeof id === 'string' && id.length > 0)
 }
 
 async function mapScopedEntityIds({
@@ -144,31 +151,32 @@ async function mapScopedEntityIds({
   if (!ids.length) return []
 
   const em = ctx.container.resolve('em') as EntityManager
-  const knex = (em as any).getConnection().getKnex()
+  const db = em.getKysely<any>() as any
   const sourceColumn = config.sourceColumn ?? 'id'
   const tenantColumn = config.tenantColumn ?? 'tenant_id'
   const organizationColumn = config.organizationColumn ?? 'organization_id'
 
-  let mapQuery = knex(config.table)
+  let mapQuery = db
+    .selectFrom(config.table)
     .select(config.targetColumn)
-    .whereIn(sourceColumn, ids)
+    .where(sourceColumn, 'in', ids)
 
   if (ctx.auth?.tenantId !== undefined) {
-    mapQuery = mapQuery.whereRaw('?? is not distinct from ?', [tenantColumn, ctx.auth?.tenantId ?? null])
+    mapQuery = mapQuery.where(sql<boolean>`${sql.ref(tenantColumn)} is not distinct from ${ctx.auth?.tenantId ?? null}`)
   }
   if (ctx.selectedOrganizationId) {
-    mapQuery = mapQuery.where(organizationColumn, ctx.selectedOrganizationId)
+    mapQuery = mapQuery.where(organizationColumn, '=', ctx.selectedOrganizationId)
   } else if (Array.isArray(ctx.organizationIds) && ctx.organizationIds.length > 0) {
-    mapQuery = mapQuery.whereIn(organizationColumn, ctx.organizationIds)
+    mapQuery = mapQuery.where(organizationColumn, 'in', ctx.organizationIds)
   }
 
-  const rows = await mapQuery
+  const rows = await mapQuery.execute() as Array<Record<string, unknown>>
   return rows
-    .map((row: Record<string, unknown>) => {
+    .map((row) => {
       const value = row[config.targetColumn]
       return typeof value === 'string' ? value : null
     })
-    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+    .filter((id): id is string => typeof id === 'string' && id.length > 0)
 }
 
 export async function findMatchingEntityIdsBySearchTokensAcrossSources({