@open-mercato/core 0.6.2-develop.3461.1.605f31c2c9 → 0.6.2

package/src/modules/sync_excel/api/import/route.ts

@@ -46,137 +46,147 @@ export const openApi = {
 }
 
 export async function POST(request: Request) {
-  const auth = await getAuthFromRequest(request)
-  if (!auth?.tenantId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const payload = await readJsonSafe(request)
-  const parsedPayload = syncExcelImportRequestSchema.safeParse(payload)
-  if (!parsedPayload.success) {
-    return NextResponse.json({ error: 'Invalid import payload.' }, { status: 422 })
-  }
-
-  const container = await createRequestContainer()
-  const em = container.resolve('em') as EntityManager
-  const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
-  const progressService = container.resolve('progressService') as ProgressService
-  const credentialsService = container.resolve('integrationCredentialsService') as CredentialsService
-  const integrationStateService = container.resolve('integrationStateService') as IntegrationStateService
-  const scopeResult = await resolveSyncExcelConcreteScope({ auth, container, request })
-  if (!scopeResult.ok) {
-    return NextResponse.json({ error: scopeResult.error }, { status: scopeResult.status })
-  }
-  const { scope } = scopeResult
-
-  const upload = await findOneWithDecryption(
-    em,
-    SyncExcelUpload,
-    {
-      id: parsedPayload.data.uploadId,
-      organizationId: scope.organizationId,
-      tenantId: scope.tenantId,
-    },
-    undefined,
-    scope,
-  )
-
-  if (!upload) {
-    return NextResponse.json({ error: 'Upload preview not found.' }, { status: 404 })
-  }
-
-  const attachment = await findOneWithDecryption(
-    em,
-    Attachment,
-    {
-      id: upload.attachmentId,
-      organizationId: scope.organizationId,
-      tenantId: scope.tenantId,
-    },
-    undefined,
-    scope,
-  )
-
-  if (!attachment) {
-    return NextResponse.json({ error: 'Upload attachment not found.' }, { status: 404 })
-  }
-
-  if (upload.entityType !== parsedPayload.data.entityType) {
-    return NextResponse.json({ error: 'Upload entity type does not match requested import target.' }, { status: 422 })
-  }
-
-  if (parsedPayload.data.mapping.entityType !== parsedPayload.data.entityType) {
-    return NextResponse.json({ error: 'Mapping entity type does not match requested import target.' }, { status: 422 })
-  }
-
-  const overlap = await syncRunService.findRunningOverlap('sync_excel', parsedPayload.data.entityType, 'import', scope)
-  if (overlap) {
-    return NextResponse.json({ error: 'A sync_excel import is already in progress for this entity type.' }, { status: 409 })
-  }
-
-  const existingMapping = await findOneWithDecryption(
-    em,
-    SyncMapping,
-    {
-      integrationId: 'sync_excel',
-      entityType: parsedPayload.data.entityType,
-      organizationId: scope.organizationId,
-      tenantId: scope.tenantId,
-    },
-    undefined,
-    scope,
-  )
-
-  if (existingMapping) {
-    existingMapping.mapping = parsedPayload.data.mapping
-  } else {
-    em.persist(em.create(SyncMapping, {
-      integrationId: 'sync_excel',
-      entityType: parsedPayload.data.entityType,
-      mapping: parsedPayload.data.mapping,
-      organizationId: scope.organizationId,
-      tenantId: scope.tenantId,
-    }))
-  }
-
-  await credentialsService.save('sync_excel', {}, scope)
-  await integrationStateService.upsert('sync_excel', { isEnabled: true }, scope)
-  await em.flush()
-
-  const { run, progressJob } = await startDataSyncRun({
-    syncRunService,
-    progressService,
-    scope: {
-      ...scope,
-      userId: auth.sub,
-    },
-    input: {
-      integrationId: 'sync_excel',
-      entityType: parsedPayload.data.entityType,
-      direction: 'import',
-      cursor: createCursor(upload.id, 0),
-      triggeredBy: auth.sub,
-      batchSize: parsedPayload.data.batchSize ?? 100,
-      progressJob: {
-        jobType: 'sync_excel:import',
-        name: `CSV import — ${parsedPayload.data.entityType}`,
-        description: upload.filename,
-        meta: {
-          integrationId: 'sync_excel',
-          uploadId: upload.id,
-          hiddenFromTopBar: false,
+  try {
+    const auth = await getAuthFromRequest(request)
+    if (!auth?.tenantId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const payload = await readJsonSafe(request)
+    const parsedPayload = syncExcelImportRequestSchema.safeParse(payload)
+    if (!parsedPayload.success) {
+      return NextResponse.json({ error: 'Invalid import payload.' }, { status: 422 })
+    }
+
+    const container = await createRequestContainer()
+    const em = container.resolve('em') as EntityManager
+    const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
+    const progressService = container.resolve('progressService') as ProgressService
+    const credentialsService = container.resolve('integrationCredentialsService') as CredentialsService
+    const integrationStateService = container.resolve('integrationStateService') as IntegrationStateService
+    const scopeResult = await resolveSyncExcelConcreteScope({ auth, container, request })
+    if (!scopeResult.ok) {
+      return NextResponse.json({ error: scopeResult.error }, { status: scopeResult.status })
+    }
+    const { scope } = scopeResult
+
+    const upload = await findOneWithDecryption(
+      em,
+      SyncExcelUpload,
+      {
+        id: parsedPayload.data.uploadId,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      },
+      undefined,
+      scope,
+    )
+
+    if (!upload) {
+      return NextResponse.json({ error: 'Upload preview not found.' }, { status: 404 })
+    }
+
+    const attachment = await findOneWithDecryption(
+      em,
+      Attachment,
+      {
+        id: upload.attachmentId,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      },
+      undefined,
+      scope,
+    )
+
+    if (!attachment) {
+      return NextResponse.json({ error: 'Upload attachment not found.' }, { status: 404 })
+    }
+
+    if (upload.entityType !== parsedPayload.data.entityType) {
+      return NextResponse.json({ error: 'Upload entity type does not match requested import target.' }, { status: 422 })
+    }
+
+    if (parsedPayload.data.mapping.entityType !== parsedPayload.data.entityType) {
+      return NextResponse.json({ error: 'Mapping entity type does not match requested import target.' }, { status: 422 })
+    }
+
+    const overlap = await syncRunService.findRunningOverlap('sync_excel', parsedPayload.data.entityType, 'import', scope)
+    if (overlap) {
+      return NextResponse.json({ error: 'A sync_excel import is already in progress for this entity type.' }, { status: 409 })
+    }
+
+    const existingMapping = await findOneWithDecryption(
+      em,
+      SyncMapping,
+      {
+        integrationId: 'sync_excel',
+        entityType: parsedPayload.data.entityType,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      },
+      undefined,
+      scope,
+    )
+
+    if (existingMapping) {
+      existingMapping.mapping = parsedPayload.data.mapping
+    } else {
+      em.persist(em.create(SyncMapping, {
+        integrationId: 'sync_excel',
+        entityType: parsedPayload.data.entityType,
+        mapping: parsedPayload.data.mapping,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      }))
+    }
+
+    await credentialsService.save('sync_excel', {}, scope)
+    await integrationStateService.upsert('sync_excel', { isEnabled: true }, scope)
+    await em.flush()
+
+    const { run, progressJob } = await startDataSyncRun({
+      syncRunService,
+      progressService,
+      scope: {
+        ...scope,
+        userId: auth.sub,
+      },
+      input: {
+        integrationId: 'sync_excel',
+        entityType: parsedPayload.data.entityType,
+        direction: 'import',
+        cursor: createCursor(upload.id, 0),
+        triggeredBy: auth.sub,
+        batchSize: parsedPayload.data.batchSize ?? 100,
+        progressJob: {
+          jobType: 'sync_excel:import',
+          name: `CSV import — ${parsedPayload.data.entityType}`,
+          description: upload.filename,
+          meta: {
+            integrationId: 'sync_excel',
+            uploadId: upload.id,
+            hiddenFromTopBar: false,
+          },
         },
       },
-    },
-  })
-
-  upload.syncRunId = run.id
-  upload.status = 'importing'
-  await em.flush()
-
-  return NextResponse.json(syncExcelImportResponseSchema.parse({
-    runId: run.id,
-    progressJobId: progressJob?.id ?? null,
-    status: run.status,
-  }), { status: 201 })
+    })
+
+    upload.syncRunId = run.id
+    upload.status = 'importing'
+    await em.flush()
+
+    return NextResponse.json(syncExcelImportResponseSchema.parse({
+      runId: run.id,
+      progressJobId: progressJob?.id ?? null,
+      status: run.status,
+    }), { status: 201 })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    const stack = error instanceof Error ? error.stack : undefined
+    console.error('[sync_excel.import] unhandled error', { message, stack })
+    return NextResponse.json(
+      { error: 'Failed to start sync_excel import.', message, stack },
+      { status: 500 },
+    )
+  }
 }

package/src/modules/sync_excel/lib/adapters/customers.ts

@@ -993,6 +993,7 @@ async function processRow(params: {
 
 export const syncExcelCustomersAdapter: DataSyncAdapter = {
   providerKey: 'excel',
+  runMode: 'provider',
   operationalTelemetry: true,
   direction: 'import',
   supportedEntities: ['customers.person'],

package/src/modules/translations/components/TranslationManager.tsx

@@ -69,6 +69,7 @@ export function TranslationManager({
   const [editedTranslations, setEditedTranslations] = React.useState<Record<string, Record<string, string>>>({})
   const editedTranslationsRef = React.useRef<Record<string, Record<string, string>>>({})
   const [hasUserEdited, setHasUserEdited] = React.useState(false)
+  const hasUserEditedRef = React.useRef(false)
 
   const entityType = isEmbedded ? (propEntityType ?? '') : selectedEntityType
   const recordId = isEmbedded ? (propRecordId ?? '') : selectedRecordId
@@ -191,11 +192,11 @@ export function TranslationManager({
 
   React.useEffect(() => {
     const sig = translationSignature
-    if (sig === lastTranslationSignatureRef.current && hasUserEdited) return
+    if (sig === lastTranslationSignatureRef.current && hasUserEditedRef.current) return
     lastTranslationSignatureRef.current = sig
 
     if (!translationData?.translations) {
-      if (!hasUserEdited) {
+      if (!hasUserEditedRef.current) {
         editedTranslationsRef.current = {}
         setEditedTranslations({})
       }
@@ -210,11 +211,11 @@ export function TranslationManager({
         parsed[locale][key] = typeof val === 'string' ? val : ''
       }
     }
-    if (!hasUserEdited) {
+    if (!hasUserEditedRef.current) {
       editedTranslationsRef.current = parsed
       setEditedTranslations(parsed)
     }
-  }, [translationSignature, translationData, hasUserEdited])
+  }, [translationSignature, translationData])
 
   const mutation = useMutation({
     mutationFn: async () => {
@@ -252,6 +253,7 @@ export function TranslationManager({
     },
     onSuccess: () => {
       flash(t('translations.manager.flash.saved', 'Translations saved'), 'success')
+      hasUserEditedRef.current = false
       setHasUserEdited(false)
       void refetchTranslation()
     },
@@ -262,6 +264,7 @@ export function TranslationManager({
   })
 
   const updateFieldValue = (locale: string, fieldKey: string, value: string) => {
+    hasUserEditedRef.current = true
     setHasUserEdited(true)
     const next = {
       ...editedTranslationsRef.current,
@@ -288,6 +291,7 @@ export function TranslationManager({
           value={selectedRecordId}
           onChange={(next) => {
             setSelectedRecordId(next)
+            hasUserEditedRef.current = false
             setHasUserEdited(false)
           }}
           placeholder={t('translations.manager.searchRecords', 'Search records...')}
@@ -482,6 +486,7 @@ export function TranslationManager({
                     onChange={(next) => {
                       setSelectedEntityType(next)
                       setSelectedRecordId('')
+                      hasUserEditedRef.current = false
                       setHasUserEdited(false)
                     }}
                     placeholder={t('translations.manager.placeholder', 'Select an entity')}

package/src/modules/workflows/lib/activity-executor.ts

@@ -11,6 +11,7 @@
  */
 
 import { EntityManager } from '@mikro-orm/core'
+import type { EntityManager as PostgreSqlEntityManager } from '@mikro-orm/postgresql'
 import type { AwilixContainer } from 'awilix'
 import { WorkflowInstance } from '../data/entities'
 import { createModuleQueue, Queue } from '@open-mercato/queue'
@@ -406,7 +407,7 @@ export async function executeSendEmail(
 
   // Check if email service is available in container
   try {
-    const emailService = container.resolve('emailService')
+    const emailService = container.resolve<{ send: (input: unknown) => Promise<unknown> | unknown }>('emailService')
     if (emailService && typeof emailService.send === 'function') {
       await emailService.send({
         to,
@@ -441,7 +442,7 @@ export async function executeEmitEvent(
   }
 
   // Get event bus from container
-  const eventBus = container.resolve('eventBus')
+  const eventBus = container.resolve<{ emitEvent: (event: string, payload: unknown, options?: unknown) => Promise<unknown> | unknown }>('eventBus')
 
   if (!eventBus || typeof eventBus.emitEvent !== 'function') {
     throw new Error('Event bus not available in container')
@@ -789,7 +790,7 @@ export async function executeCallApi(
   const { withOnetimeApiKey } = await import('../../api_keys/services/apiKeyService')
 
   // 4. Get EntityManager from container (for correct type)
-  const apiKeyEm = container.resolve('em')
+  const apiKeyEm = container.resolve<PostgreSqlEntityManager>('em')
 
   // 5. Resolve the roles that the one-time API key will inherit.
   //

package/src/modules/workflows/lib/event-trigger-service.ts

@@ -6,9 +6,12 @@
  */
 
 import type { EntityManager } from '@mikro-orm/core'
+import type { EntityManager as PostgreSqlEntityManager } from '@mikro-orm/postgresql'
 import type { AwilixContainer } from 'awilix'
 import type { CacheService } from '@open-mercato/cache'
 import { matchEventPattern } from '@open-mercato/shared/lib/events/patterns'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { testLinearRegex } from '@open-mercato/shared/lib/regex/linear'
 import {
   WorkflowEventTrigger,
   WorkflowDefinition,
@@ -257,11 +260,12 @@ function evaluateCondition(condition: TriggerFilterCondition, payload: Record<st
       if (typeof value !== 'string' || typeof expected !== 'string') return false
       if (value.length > MAX_WORKFLOW_REGEX_INPUT_LENGTH) return false
       if (!isSafeWorkflowRegexPattern(expected)) return false
-      try {
-        const regex = new RegExp(expected)
-        return regex.test(value)
-      } catch {
-        return false
+      {
+        const result = testLinearRegex(expected, value, {
+          maxPatternLength: MAX_WORKFLOW_REGEX_PATTERN_LENGTH,
+          maxInputLength: MAX_WORKFLOW_REGEX_INPUT_LENGTH,
+        })
+        return result.ok ? result.matched : false
       }
 
     default:
@@ -325,7 +329,9 @@ async function loadLegacyTriggers(
   tenantId: string,
   organizationId: string
 ): Promise<UnifiedTrigger[]> {
-  const legacyTriggers = await em.find(
+  const postgresEm = em as unknown as PostgreSqlEntityManager
+  const legacyTriggers = await findWithDecryption(
+    postgresEm,
     WorkflowEventTrigger,
     {
       tenantId,
@@ -335,16 +341,19 @@ async function loadLegacyTriggers(
     },
     {
       orderBy: { priority: 'DESC', createdAt: 'ASC' },
-    }
+    },
+    { tenantId, organizationId },
   )
 
   // Get definitions for these triggers to get workflowId
   const definitionIds = [...new Set(legacyTriggers.map(t => t.workflowDefinitionId))]
-  const definitions = definitionIds.length > 0 ? await em.find(WorkflowDefinition, {
+  const definitions = definitionIds.length > 0 ? await findWithDecryption(postgresEm, WorkflowDefinition, {
     id: { $in: definitionIds },
+    tenantId,
+    organizationId,
     enabled: true,
     deletedAt: null,
-  }) : []
+  }, {}, { tenantId, organizationId }) : []
   const definitionMap = new Map(definitions.map(d => [d.id, d]))
 
   return legacyTriggers
@@ -379,15 +388,19 @@ async function loadEmbeddedTriggers(
   tenantId: string,
   organizationId: string
 ): Promise<UnifiedTrigger[]> {
+  const postgresEm = em as unknown as PostgreSqlEntityManager
   // Load all enabled definitions that may have triggers
-  const definitions = await em.find(
+  const definitions = await findWithDecryption(
+    postgresEm,
     WorkflowDefinition,
     {
       tenantId,
       organizationId,
       enabled: true,
       deletedAt: null,
-    }
+    },
+    {},
+    { tenantId, organizationId },
   )
 
   const triggers: UnifiedTrigger[] = []

package/tsconfig.json

@@ -4,6 +4,7 @@
   "compilerOptions": {
     "noEmit": true,
     "baseUrl": ".",
+    "ignoreDeprecations": "6.0",
     "paths": {
       "@open-mercato/core/modules/core/__integration__/helpers/*": [
         "./src/modules/core/__integration__/helpers/*"