@open-mercato/core 0.5.1-develop.2691.d8a0934b37 → 0.5.1-develop.2694.732417c5ec

package/src/modules/attachments/api/partitions/route.ts

@@ -104,7 +104,7 @@ export async function POST(req: Request) {
         : resolveDefaultAttachmentOcrEnabled(),
     ocrModel: parsed.data.ocrModel?.trim() || null,
   })
-  await em.persistAndFlush(entry)
+  await em.persist(entry).flush()
   return NextResponse.json({ item: serializePartition(entry) }, { status: 201 })
 }
 
@@ -146,7 +146,7 @@ export async function PUT(req: Request) {
   if (parsed.data.ocrModel !== undefined) {
     entry.ocrModel = parsed.data.ocrModel?.trim() || null
   }
-  await em.persistAndFlush(entry)
+  await em.persist(entry).flush()
   return NextResponse.json({ item: serializePartition(entry) })
 }
 
@@ -179,7 +179,7 @@ export async function DELETE(req: Request) {
   if (usage > 0) {
     return NextResponse.json({ error: 'Partition is in use and cannot be removed.' }, { status: 409 })
   }
-  await em.removeAndFlush(entry)
+  await em.remove(entry).flush()
   return NextResponse.json({ ok: true })
 }
 

package/src/modules/attachments/api/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { z } from 'zod'
+import { sql } from 'kysely'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { buildAttachmentFileUrl, buildAttachmentImageUrl, slugifyAttachmentFileName } from '../lib/imageUrls'
 import { ensureDefaultPartitions, resolveDefaultPartitionCode, sanitizePartitionCode } from '../lib/partitions'
@@ -429,7 +430,7 @@ export async function POST(req: Request) {
     content: extractedContent,
     storageMetadata: metadata,
   })
-  await em.persistAndFlush(att)
+  await em.persist(att).flush()
 
   if (useLlmOcr) {
     requestOcrProcessing(em, att, stored.absolutePath).catch((error) => {
@@ -491,12 +492,13 @@ export async function POST(req: Request) {
 
 async function readTenantAttachmentUsageBytes(em: EntityManager, tenantId: string): Promise<number> {
   try {
-    const knex = (em as any).getConnection().getKnex()
-    const row = await knex('attachments')
-      .where({ tenant_id: tenantId })
-      .sum({ totalSize: 'file_size' })
-      .first()
-    const total = row?.totalSize
+    const db = em.getKysely<any>() as any
+    const row = await db
+      .selectFrom('attachments')
+      .select(sql<string>`sum(file_size)`.as('total_size'))
+      .where('tenant_id', '=', tenantId)
+      .executeTakeFirst() as { total_size: string | number | null } | undefined
+    const total = row?.total_size
     if (typeof total === 'number') return Number.isFinite(total) ? total : 0
     if (typeof total === 'string') {
       const parsed = Number(total)
@@ -520,7 +522,7 @@ export async function DELETE(req: Request) {
   const deleteFilter: Record<string, unknown> = { id, tenantId: auth.tenantId!, organizationId: auth.orgId }
   const record = await em.findOne(Attachment, deleteFilter)
   if (!record) return NextResponse.json({ error: 'Attachment not found' }, { status: 404 })
-  await em.removeAndFlush(record)
+  await em.remove(record).flush()
   await clearAttachmentThumbnailCache(record.partitionCode, record.id).catch((error) => {
     console.error('[attachments] failed to cleanup cached thumbnails', error)
   })

package/src/modules/attachments/api/transfer/route.ts

@@ -72,7 +72,7 @@ export async function POST(req: Request) {
       }) ?? []
     record.storageMetadata = mergeAttachmentMetadata(record.storageMetadata, { assignments: nextAssignments })
   }
-  await em.persistAndFlush(records)
+  await em.persist(records).flush()
   return NextResponse.json({ ok: true, updated: records.length })
 }
 

package/src/modules/attachments/data/entities.ts

@@ -1,4 +1,5 @@
-import { Entity, Index, OptionalProps, PrimaryKey, Property, Unique } from '@mikro-orm/core'
+import { OptionalProps } from '@mikro-orm/core'
+import { Entity, Index, PrimaryKey, Property, Unique } from '@mikro-orm/decorators/legacy'
 import { resolveDefaultAttachmentOcrEnabled } from '../lib/ocrConfig'
 
 @Entity({ tableName: 'attachment_partitions' })

package/src/modules/attachments/lib/ocrQueue.ts

@@ -49,7 +49,7 @@ export async function processAttachmentOcr(
     }
 
     attachment.content = result.content
-    await em.persistAndFlush(attachment)
+    await em.persist(attachment).flush()
 
     console.log(`[attachments.ocr] Processing completed:`, {
       attachmentId,

package/src/modules/audit_logs/api/audit-logs/actions/export/route.ts

@@ -178,12 +178,12 @@ export async function GET(req: Request) {
   const entries = entriesResult.items
 
   const displayMaps = await loadAuditLogDisplayMaps(em, {
-    userIds: entries.map((entry) => entry.actorUserId).filter((value): value is string => Boolean(value)),
-    tenantIds: entries.map((entry) => entry.tenantId).filter((value): value is string => Boolean(value)),
-    organizationIds: entries.map((entry) => entry.organizationId).filter((value): value is string => Boolean(value)),
+    userIds: entries.map((entry: any) => entry.actorUserId).filter((value: any): value is string => Boolean(value)),
+    tenantIds: entries.map((entry: any) => entry.tenantId).filter((value: any): value is string => Boolean(value)),
+    organizationIds: entries.map((entry: any) => entry.organizationId).filter((value: any): value is string => Boolean(value)),
   })
 
-  const rows = entries.flatMap((entry) => {
+  const rows = entries.flatMap((entry: any) => {
     const actionType = deriveActionLogActionType(entry)
     const actionLabel = actionType === 'system'
       ? entry.actionLabel ?? 'System'

package/src/modules/audit_logs/api/audit-logs/actions/route.ts

@@ -229,12 +229,12 @@ export async function GET(req: Request) {
   const list = await actionLogs.list(listQuery)
 
   const displayMaps = await loadAuditLogDisplayMaps(em, {
-    userIds: list.items.map((entry) => entry.actorUserId).filter((value): value is string => !!value),
-    tenantIds: list.items.map((entry) => entry.tenantId).filter((value): value is string => !!value),
-    organizationIds: list.items.map((entry) => entry.organizationId).filter((value): value is string => !!value),
+    userIds: list.items.map((entry: any) => entry.actorUserId).filter((value: any): value is string => !!value),
+    tenantIds: list.items.map((entry: any) => entry.tenantId).filter((value: any): value is string => !!value),
+    organizationIds: list.items.map((entry: any) => entry.organizationId).filter((value: any): value is string => !!value),
   })
 
-  const items = list.items.map((entry) => ({
+  const items = list.items.map((entry: any) => ({
     id: entry.id,
     commandId: entry.commandId,
     actionLabel: entry.actionLabel,

package/src/modules/audit_logs/data/entities.ts

@@ -1,4 +1,4 @@
-import { Entity, Index, PrimaryKey, Property } from '@mikro-orm/core'
+import { Entity, Index, PrimaryKey, Property } from '@mikro-orm/decorators/legacy'
 import type { ActionLogProjectionType, ActionLogSourceKey } from '@open-mercato/core/modules/audit_logs/lib/projections'
 
 export type ActionLogExecutionState = 'done' | 'undone' | 'failed' | 'redone'

package/src/modules/audit_logs/services/actionLogService.ts

@@ -1,5 +1,6 @@
 import type { FilterQuery } from '@mikro-orm/core'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
 import { ActionLog } from '@open-mercato/core/modules/audit_logs/data/entities'
 import {
   actionLogCreateSchema,
@@ -184,7 +185,7 @@ export class ActionLogService {
     const data = this.parseCreateInput(input)
     const fork = this.em.fork()
     const log = this.createLogEntity(fork, data)
-    await fork.persistAndFlush(log)
+    await fork.persist(log).flush()
     await this.decryptEntries(log)
     return log
   }
@@ -353,15 +354,15 @@ export class ActionLogService {
   }
 
   private async loadEntries(parsed: ActionLogListQuery, options?: { paginate?: boolean }) {
-    const query = this.buildListQuery(parsed).select<{ id: string }[]>('action_logs.id as id')
+    let query = (this.buildListQuery(parsed) as any).select('action_logs.id as id')
 
     if (options?.paginate !== false) {
       const { limit, offset } = this.resolvePagination(parsed)
-      query.limit(limit).offset(offset)
+      query = query.limit(limit).offset(offset)
     }
 
-    const rows = await query
-    const ids = rows.map((row) => row.id).filter(Boolean)
+    const rows = await query.execute()
+    const ids = rows.map((row: any) => row.id).filter(Boolean)
     if (ids.length === 0) return []
 
     const results = await this.em.find(ActionLog, {
@@ -370,90 +371,92 @@ export class ActionLogService {
     })
     await this.decryptEntries(results)
 
-    const byId = new Map(results.map((entry) => [entry.id, entry]))
+    const byId = new Map(results.map((entry: any) => [entry.id, entry]))
     return ids
-      .map((id) => byId.get(id))
-      .filter((entry): entry is ActionLog => Boolean(entry))
+      .map((id: any) => byId.get(id))
+      .filter((entry: any): entry is ActionLog => Boolean(entry))
   }
 
-  private buildListQuery(parsed: ActionLogListQuery) {
-    const query = this.em.getKnex()('action_logs').whereNull('action_logs.deleted_at')
+  private buildListQuery(parsed: ActionLogListQuery): any {
+    let query = (this.em.getKysely<any>() as any)
+      .selectFrom('action_logs')
+      .selectAll()
+      .where('action_logs.deleted_at', 'is', null) as any
 
-    if (parsed.tenantId) query.andWhere('action_logs.tenant_id', parsed.tenantId)
-    if (parsed.organizationId) query.andWhere('action_logs.organization_id', parsed.organizationId)
+    if (parsed.tenantId) query = query.where('action_logs.tenant_id', '=', parsed.tenantId)
+    if (parsed.organizationId) query = query.where('action_logs.organization_id', '=', parsed.organizationId)
 
     const actorUserIds = this.resolveActorUserIds(parsed)
-    if (actorUserIds.length === 1) query.andWhere('action_logs.actor_user_id', actorUserIds[0])
-    if (actorUserIds.length > 1) query.whereIn('action_logs.actor_user_id', actorUserIds)
+    if (actorUserIds.length === 1) query = query.where('action_logs.actor_user_id', '=', actorUserIds[0])
+    if (actorUserIds.length > 1) query = query.where('action_logs.actor_user_id', 'in', actorUserIds)
 
     if (parsed.includeRelated && parsed.resourceKind && parsed.resourceId) {
-      query.andWhere(function applyRelatedScope() {
-        this.where({
-          'action_logs.resource_kind': parsed.resourceKind,
-          'action_logs.resource_id': parsed.resourceId,
-        }).orWhere({
-          'action_logs.parent_resource_kind': parsed.resourceKind,
-          'action_logs.parent_resource_id': parsed.resourceId,
-        })
-      })
+      query = query.where((eb: any) =>
+        eb.or([
+          eb.and([
+            eb('action_logs.resource_kind', '=', parsed.resourceKind),
+            eb('action_logs.resource_id', '=', parsed.resourceId),
+          ]),
+          eb.and([
+            eb('action_logs.parent_resource_kind', '=', parsed.resourceKind),
+            eb('action_logs.parent_resource_id', '=', parsed.resourceId),
+          ]),
+        ])
+      )
     } else {
-      if (parsed.resourceKind) query.andWhere('action_logs.resource_kind', parsed.resourceKind)
-      if (parsed.resourceId) query.andWhere('action_logs.resource_id', parsed.resourceId)
+      if (parsed.resourceKind) query = query.where('action_logs.resource_kind', '=', parsed.resourceKind)
+      if (parsed.resourceId) query = query.where('action_logs.resource_id', '=', parsed.resourceId)
     }
 
-    if (parsed.undoableOnly) query.whereNotNull('action_logs.undo_token')
-    if (parsed.before) query.andWhere('action_logs.created_at', '<', parsed.before)
-    if (parsed.after) query.andWhere('action_logs.created_at', '>', parsed.after)
+    if (parsed.undoableOnly) query = query.where('action_logs.undo_token', 'is not', null)
+    if (parsed.before) query = query.where('action_logs.created_at', '<', parsed.before)
+    if (parsed.after) query = query.where('action_logs.created_at', '>', parsed.after)
 
     const fieldNames = this.resolveFieldNames(parsed)
-    if (fieldNames.length > 0) {
-      const placeholders = fieldNames.map(() => '?').join(', ')
-      query.andWhereRaw(
-        `coalesce(action_logs.changed_fields, ARRAY[]::text[]) && ARRAY[${placeholders}]::text[]`,
-        fieldNames,
-      )
-    }
+    if (fieldNames.length === 1) query = query.where('action_logs.primary_changed_field', '=', fieldNames[0])
+    if (fieldNames.length > 1) query = query.where('action_logs.primary_changed_field', 'in', fieldNames)
 
     const actionTypes = this.resolveActionTypes(parsed)
-    if (actionTypes.length === 1) query.andWhere('action_logs.action_type', actionTypes[0])
-    if (actionTypes.length > 1) query.whereIn('action_logs.action_type', actionTypes)
+    if (actionTypes.length === 1) query = query.where('action_logs.action_type', '=', actionTypes[0])
+    if (actionTypes.length > 1) query = query.where('action_logs.action_type', 'in', actionTypes)
 
     if (parsed.sortField === 'user') {
-      query.leftJoin('users as audit_actor', 'audit_actor.id', 'action_logs.actor_user_id')
+      query = query.leftJoin('users as audit_actor', 'audit_actor.id', 'action_logs.actor_user_id')
     }
 
     const sortDir = parsed.sortDir === 'asc' ? 'asc' : 'desc'
     switch (parsed.sortField) {
       case 'user':
-        query.orderByRaw(`coalesce(nullif(audit_actor.name, ''), audit_actor.email, '') ${sortDir}`)
+        query = query.orderBy(sql`coalesce(nullif(audit_actor.name, ''), audit_actor.email, '')`, sortDir)
         break
       case 'action':
-        query.orderByRaw(`coalesce(action_logs.action_type, '') ${sortDir}`)
+        query = query.orderBy(sql`coalesce(action_logs.action_type, '')`, sortDir)
         break
       case 'field':
-        query.orderByRaw(`coalesce(action_logs.primary_changed_field, '') ${sortDir}`)
+        query = query.orderBy(sql`coalesce(action_logs.primary_changed_field, '')`, sortDir)
         break
       case 'source':
-        query.orderByRaw(`coalesce(action_logs.source_key, '') ${sortDir}`)
+        query = query.orderBy(sql`coalesce(action_logs.source_key, '')`, sortDir)
         break
       case 'createdAt':
       default:
-        query.orderBy(SORT_FIELDS.createdAt, sortDir)
-        query.orderBy('action_logs.id', sortDir)
+        query = query.orderBy(SORT_FIELDS.createdAt, sortDir)
+        query = query.orderBy('action_logs.id', sortDir)
         return query
     }
 
-    query.orderBy('action_logs.created_at', 'desc')
-    query.orderBy('action_logs.id', 'desc')
+    query = query.orderBy('action_logs.created_at', 'desc')
+    query = query.orderBy('action_logs.id', 'desc')
     return query
   }
 
   async count(query: Partial<ActionLogListQuery>) {
     const parsed = this.parseListQuery(query)
-    const row = await this.buildListQuery(parsed)
-      .clearOrder()
-      .count<{ count: string | number }>({ count: '*' })
-      .first()
+    const row = await (this.buildListQuery(parsed) as any)
+      .clearSelect()
+      .clearOrderBy()
+      .select(sql<string>`count(*)`.as('count'))
+      .executeTakeFirst()
 
     if (!row) return 0
     const rawCount = row.count ?? 0
@@ -579,45 +582,49 @@ export class ActionLogService {
     let cursorId: string | null = null
 
     while (true) {
-      const rowsQuery = this.em.getKnex()<BackfillRow>('action_logs')
-        .select(
-          'id',
-          'tenant_id',
-          'organization_id',
-          'actor_user_id',
-          'command_id',
-          'action_label',
-          'snapshot_before',
-          'changes_json',
-          'context_json',
-          'action_type',
-          'source_key',
-          'changed_fields',
-          'primary_changed_field',
-          'created_at',
-        )
-        .whereNull('deleted_at')
-
-      if (options.tenantId) rowsQuery.andWhere('tenant_id', options.tenantId)
-      if (options.organizationId) rowsQuery.andWhere('organization_id', options.organizationId)
+      const rowsQuery = (this.em.getKysely<any>() as any)
+        .selectFrom('action_logs')
+        .select([
+          'action_logs.id',
+          'action_logs.tenant_id',
+          'action_logs.organization_id',
+          'action_logs.actor_user_id',
+          'action_logs.command_id',
+          'action_logs.action_label',
+          'action_logs.snapshot_before',
+          'action_logs.changes_json',
+          'action_logs.context_json',
+          'action_logs.action_type',
+          'action_logs.source_key',
+          'action_logs.changed_fields',
+          'action_logs.primary_changed_field',
+          'action_logs.created_at',
+        ])
+        .where('action_logs.deleted_at', 'is', null) as any
+
+      if (options.tenantId) rowsQuery.where('action_logs.tenant_id', '=', options.tenantId)
+      if (options.organizationId) rowsQuery.where('action_logs.organization_id', '=', options.organizationId)
 
       if (!options.force) {
-        rowsQuery.andWhere((builder) => {
-          builder
-            .whereNull('action_type')
-            .orWhereNull('source_key')
-            .orWhereNull('changed_fields')
-        })
+        rowsQuery.where((eb: any) =>
+          eb.or([
+            eb('action_logs.action_type', 'is', null),
+            eb('action_logs.source_key', 'is', null),
+            eb('action_logs.changed_fields', 'is', null),
+          ])
+        )
       }
 
       if (cursorCreatedAt && cursorId) {
-        rowsQuery.andWhere((builder) => {
-          builder
-            .where('created_at', '>', cursorCreatedAt)
-            .orWhere((nested) => {
-              nested.where('created_at', cursorCreatedAt).andWhere('id', '>', cursorId)
-            })
-        })
+        rowsQuery.where((eb: any) =>
+          eb.or([
+            eb('action_logs.created_at', '>', cursorCreatedAt),
+            eb.and([
+              eb('action_logs.created_at', '=', cursorCreatedAt),
+              eb('action_logs.id', '>', cursorId),
+            ]),
+          ])
+        )
       }
 
       const rows = await rowsQuery
@@ -652,14 +659,16 @@ export class ActionLogService {
             continue
           }
 
-          await this.em.getKnex()('action_logs')
-            .where({ id: row.id })
-            .update({
+          await (this.em.getKysely<any>() as any)
+            .updateTable('action_logs')
+            .set({
               action_type: projection.actionType,
               changed_fields: projection.changedFields,
               primary_changed_field: projection.primaryChangedField,
               source_key: projection.sourceKey,
             })
+            .where('id', '=', row.id)
+            .execute()
 
           result.updated += 1
         } catch (err) {

package/src/modules/auth/api/roles/acl/route.ts

@@ -170,7 +170,7 @@ export async function PUT(req: Request) {
   if (parsed.data.organizations !== undefined) acl.organizationsJson = parsed.data.organizations
   acl.isSuperAdmin = effectiveIsSuperAdmin
   acl.featuresJson = effectiveFeatures
-  await em.persistAndFlush(acl)
+  await em.persist(acl).flush()
   
   // Invalidate cache for all users in this tenant since role ACL changed
   if (targetTenantId) {

package/src/modules/auth/api/users/acl/route.ts

@@ -111,7 +111,7 @@ export async function PUT(req: Request) {
   const hasCustomAcl = effectiveIsSuperAdmin || effectiveFeatures.length > 0
 
   if (!hasCustomAcl) {
-    if (acl) await em.removeAndFlush(acl)
+    if (acl) await em.remove(acl).flush()
   } else {
     if (!acl) {
       acl = em.create(UserAcl, { user: parsed.data.userId as any, tenantId: auth.tenantId as any })
@@ -120,7 +120,7 @@ export async function PUT(req: Request) {
     aclRecord.isSuperAdmin = effectiveIsSuperAdmin
     aclRecord.featuresJson = effectiveFeatures
     aclRecord.organizationsJson = organizations
-    await em.persistAndFlush(acl)
+    await em.persist(acl).flush()
   }
 
   // Invalidate cache for this user

package/src/modules/auth/api/users/resend-invite/route.ts

@@ -129,7 +129,7 @@ export async function POST(req: Request) {
   const tokenHash = hashAuthToken(rawToken)
   const expiresAt = new Date(Date.now() + INVITE_TOKEN_TTL_MS)
   const row = em.create(PasswordReset, { user, token: tokenHash, expiresAt, createdAt: new Date() })
-  await em.persistAndFlush(row)
+  await em.persist(row).flush()
 
   const inviteUrl = `${base}/reset/${rawToken}`