@open-mercato/core 0.6.4-develop.4210.1.d412061cfe → 0.6.4-develop.4236.1.9fa6806b34

package/src/modules/staff/widgets/dashboard/timesheets-time-reporting/widget.client.tsx

@@ -0,0 +1,297 @@
+"use client"
+
+import * as React from 'react'
+import type { DashboardWidgetComponentProps } from '@open-mercato/shared/modules/dashboard/widgets'
+import { apiCall, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { DEFAULT_SETTINGS, hydrateSettings, type TimeReportingSettings } from './config'
+
+type ProjectOption = { id: string; name: string; code: string | null }
+
+type TimerState = {
+  entryId: string | null
+  running: boolean
+  startedAt: string | null
+  projectId: string | null
+}
+
+function formatElapsed(startedAt: string): string {
+  const elapsed = Math.max(0, Date.now() - new Date(startedAt).getTime())
+  const totalSeconds = Math.floor(elapsed / 1000)
+  const hours = Math.floor(totalSeconds / 3600)
+  const minutes = Math.floor((totalSeconds % 3600) / 60)
+  const seconds = totalSeconds % 60
+  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`
+}
+
+const TimeReportingWidget: React.FC<DashboardWidgetComponentProps<TimeReportingSettings>> = ({
+  mode,
+  settings = DEFAULT_SETTINGS,
+  onSettingsChange,
+  refreshToken,
+  onRefreshStateChange,
+}) => {
+  const t = useT()
+  const hydrated = React.useMemo(() => hydrateSettings(settings), [settings])
+
+  const [projects, setProjects] = React.useState<ProjectOption[]>([])
+  const [selectedProjectId, setSelectedProjectId] = React.useState<string | null>(hydrated.lastProjectId)
+  const [notes, setNotes] = React.useState('')
+  const [timer, setTimer] = React.useState<TimerState>({ entryId: null, running: false, startedAt: null, projectId: null })
+  const [elapsed, setElapsed] = React.useState('00:00:00')
+  const [staffMemberId, setStaffMemberId] = React.useState<string | null>(null)
+  const [loading, setLoading] = React.useState(true)
+  const [actionLoading, setActionLoading] = React.useState(false)
+  const [error, setError] = React.useState<string | null>(null)
+
+  const loadState = React.useCallback(async () => {
+    onRefreshStateChange?.(true)
+    setLoading(true)
+    setError(null)
+    try {
+      // Load assigned projects
+      const assignmentsRes = await readApiResultOrThrow<{ items?: Array<Record<string, unknown>> }>(
+        '/api/staff/timesheets/my-projects?pageSize=100',
+        undefined,
+        { errorMessage: '', fallback: { items: [] } },
+      )
+      const assignmentItems = Array.isArray(assignmentsRes.items) ? assignmentsRes.items : []
+      const projectIds = assignmentItems
+        .map((item) => String(item.time_project_id ?? item.timeProjectId ?? ''))
+        .filter((id) => id.length > 0)
+
+      if (projectIds.length > 0) {
+        const projectsRes = await readApiResultOrThrow<{ items?: Array<Record<string, unknown>> }>(
+          `/api/staff/timesheets/time-projects?ids=${projectIds.join(',')}&pageSize=100`,
+          undefined,
+          { errorMessage: '', fallback: { items: [] } },
+        )
+        const items = Array.isArray(projectsRes.items) ? projectsRes.items : []
+        setProjects(items.map((item) => ({
+          id: String(item.id ?? ''),
+          name: String(item.name ?? ''),
+          code: typeof item.code === 'string' ? item.code : null,
+        })))
+      } else {
+        setProjects([])
+      }
+
+      // Check for active timer — look for today's entries with startedAt set and endedAt null
+      const selfRes = await readApiResultOrThrow<{ member?: { id: string } | null }>(
+        '/api/staff/team-members/self',
+        undefined,
+        { errorMessage: '', fallback: { member: null } },
+      )
+      const memberId = selfRes.member?.id ?? null
+      setStaffMemberId(memberId)
+      if (memberId) {
+        const today = new Date().toISOString().slice(0, 10)
+        const entriesRes = await readApiResultOrThrow<{ items?: Array<Record<string, unknown>> }>(
+          `/api/staff/timesheets/time-entries?staffMemberId=${memberId}&from=${today}&to=${today}&pageSize=100`,
+          undefined,
+          { errorMessage: '', fallback: { items: [] } },
+        )
+        const entries = Array.isArray(entriesRes.items) ? entriesRes.items : []
+        const running = entries.find((e) => {
+          const startedAt = e.started_at ?? e.startedAt
+          const endedAt = e.ended_at ?? e.endedAt
+          return startedAt != null && endedAt == null
+        })
+        if (running) {
+          setTimer({
+            entryId: String(running.id ?? ''),
+            running: true,
+            startedAt: String(running.started_at ?? running.startedAt ?? ''),
+            projectId: String(running.time_project_id ?? running.timeProjectId ?? ''),
+          })
+        } else {
+          setTimer({ entryId: null, running: false, startedAt: null, projectId: null })
+        }
+      }
+    } catch (err) {
+      console.error('staff.timesheets.timeReporting.load', err)
+      setError(t('staff.timesheets.widgets.timeReporting.error', 'Failed to load timer state'))
+    } finally {
+      setLoading(false)
+      onRefreshStateChange?.(false)
+    }
+  }, [onRefreshStateChange, t])
+
+  React.useEffect(() => {
+    void loadState()
+  }, [loadState, refreshToken])
+
+  // Tick elapsed time
+  React.useEffect(() => {
+    if (!timer.running || !timer.startedAt) return
+    const tick = () => setElapsed(formatElapsed(timer.startedAt!))
+    tick()
+    const interval = setInterval(tick, 1000)
+    return () => clearInterval(interval)
+  }, [timer.running, timer.startedAt])
+
+  const handleStart = React.useCallback(async () => {
+    if (!selectedProjectId || !staffMemberId) return
+    if (timer.running) return
+    setActionLoading(true)
+    try {
+      const today = new Date().toISOString().slice(0, 10)
+      // Create entry + start timer
+      const createRes = await apiCall<Record<string, unknown>>('/api/staff/timesheets/time-entries', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          staffMemberId,
+          date: today,
+          timeProjectId: selectedProjectId,
+          durationMinutes: 0,
+          notes: notes.trim() || null,
+          source: 'timer',
+        }),
+      })
+      if (!createRes.ok) throw new Error('Failed to create entry')
+      const body = createRes.result as Record<string, unknown> | null
+      const entryId = String(body?.id ?? (body?.item as Record<string, unknown> | undefined)?.id ?? '')
+      if (!entryId) throw new Error('Failed to extract entry ID')
+
+      await apiCall(`/api/staff/timesheets/time-entries/${entryId}/timer-start`, { method: 'POST' })
+
+      onSettingsChange({ ...hydrated, lastProjectId: selectedProjectId })
+      await loadState()
+    } catch (err) {
+      console.error('staff.timesheets.timeReporting.start', err)
+      setError(t('staff.timesheets.widgets.timeReporting.startError', 'Failed to start timer'))
+    } finally {
+      setActionLoading(false)
+    }
+  }, [selectedProjectId, staffMemberId, timer.running, notes, hydrated, onSettingsChange, loadState, t])
+
+  const handleStop = React.useCallback(async () => {
+    if (!timer.entryId) return
+    setActionLoading(true)
+    try {
+      await apiCall(`/api/staff/timesheets/time-entries/${timer.entryId}/timer-stop`, { method: 'POST' })
+      await loadState()
+    } catch (err) {
+      console.error('staff.timesheets.timeReporting.stop', err)
+      setError(t('staff.timesheets.widgets.timeReporting.stopError', 'Failed to stop timer'))
+    } finally {
+      setActionLoading(false)
+    }
+  }, [timer.entryId, loadState, t])
+
+  if (mode === 'settings') {
+    return (
+      <div className="space-y-2 text-sm">
+        <p className="text-muted-foreground">
+          {t('staff.timesheets.widgets.timeReporting.settings.description', 'No additional settings. Select a project and start tracking from the widget.')}
+        </p>
+      </div>
+    )
+  }
+
+  if (loading) {
+    return (
+      <div className="flex h-full items-center justify-center py-8">
+        <p className="text-sm text-muted-foreground">{t('staff.timesheets.widgets.timeReporting.loading', 'Loading...')}</p>
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <div className="flex h-full items-center justify-center py-8">
+        <p className="text-sm text-destructive">{error}</p>
+      </div>
+    )
+  }
+
+  if (projects.length === 0) {
+    return (
+      <div className="flex h-full items-center justify-center py-8">
+        <p className="text-sm text-muted-foreground">
+          {t('staff.timesheets.widgets.timeReporting.noProjects', 'No projects assigned.')}
+        </p>
+      </div>
+    )
+  }
+
+  // Timer is running
+  if (timer.running) {
+    const runningProject = projects.find((p) => p.id === timer.projectId)
+    return (
+      <div className="space-y-3">
+        <div className="text-sm text-muted-foreground">
+          {runningProject?.name ?? t('staff.timesheets.widgets.timeReporting.unknownProject', 'Unknown project')}
+        </div>
+        <div className="text-center">
+          <p className="font-mono text-3xl font-bold tabular-nums">{elapsed}</p>
+          <p className="mt-1 text-xs text-muted-foreground">
+            {t('staff.timesheets.widgets.timeReporting.running', 'Timer running')}
+          </p>
+        </div>
+        <Button
+          type="button"
+          variant="destructive"
+          className="w-full"
+          onClick={handleStop}
+          disabled={actionLoading}
+        >
+          {t('staff.timesheets.widgets.timeReporting.stop', 'Stop Timer')}
+        </Button>
+      </div>
+    )
+  }
+
+  // Timer not running — show start form
+  return (
+    <div className="space-y-3">
+      <div className="space-y-1.5">
+        <label className="text-xs font-medium text-muted-foreground" htmlFor="timer-project">
+          {t('staff.timesheets.widgets.timeReporting.project', 'Project')}
+        </label>
+        <select
+          id="timer-project"
+          className="w-full rounded-md border bg-background px-3 py-2 text-sm"
+          value={selectedProjectId ?? ''}
+          onChange={(e) => setSelectedProjectId(e.target.value || null)}
+        >
+          <option value="">{t('staff.timesheets.widgets.timeReporting.selectProject', 'Select project...')}</option>
+          {projects.map((project) => (
+            <option key={project.id} value={project.id}>
+              {project.name}{project.code ? ` (${project.code})` : ''}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div className="space-y-1.5">
+        <label className="text-xs font-medium text-muted-foreground" htmlFor="timer-notes">
+          {t('staff.timesheets.widgets.timeReporting.taskNote', 'Task / Note')}
+        </label>
+        <Input
+          id="timer-notes"
+          value={notes}
+          onChange={(e) => setNotes(e.target.value)}
+          placeholder={t('staff.timesheets.widgets.timeReporting.notesPlaceholder', 'What are you working on?')}
+        />
+      </div>
+      <div className="text-center">
+        <p className="text-sm text-muted-foreground">
+          {t('staff.timesheets.widgets.timeReporting.notRunning', 'Not running')}
+        </p>
+      </div>
+      <Button
+        type="button"
+        className="w-full"
+        onClick={handleStart}
+        disabled={actionLoading || !selectedProjectId}
+      >
+        {t('staff.timesheets.widgets.timeReporting.start', 'Start Timer')}
+      </Button>
+    </div>
+  )
+}
+
+export default TimeReportingWidget

package/src/modules/staff/widgets/dashboard/timesheets-time-reporting/widget.ts

@@ -0,0 +1,25 @@
+import { lazyDashboardWidget, type DashboardWidgetModule } from '@open-mercato/shared/modules/dashboard/widgets'
+import { DEFAULT_SETTINGS, hydrateSettings, type TimeReportingSettings } from './config'
+
+const TimeReportingWidget = lazyDashboardWidget(() => import('./widget.client'))
+
+const widget: DashboardWidgetModule<TimeReportingSettings> = {
+  metadata: {
+    id: 'staff.timesheets.timeReporting',
+    title: 'Time Reporting',
+    description: 'Quick start/stop timer for the current work item',
+    features: ['dashboards.view', 'staff.timesheets.manage_own'],
+    defaultSize: 'sm',
+    defaultEnabled: false,
+    defaultSettings: DEFAULT_SETTINGS,
+    tags: ['staff', 'timesheets', 'timer'],
+    category: 'productivity',
+    icon: 'timer',
+    supportsRefresh: true,
+  },
+  Widget: TimeReportingWidget,
+  hydrateSettings,
+  dehydrateSettings: (s) => ({ lastProjectId: s.lastProjectId }),
+}
+
+export default widget

package/src/modules/staff/widgets/injection/timer-sidebar-indicator/widget.tsx

@@ -0,0 +1,161 @@
+"use client"
+
+import * as React from 'react'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'
+import { ProjectColorDot } from '../../../lib/timesheets-ui/ProjectColorDot'
+
+type TimerState = {
+  entryId: string
+  projectName: string
+  projectColor: string | null
+  startedAt: string
+}
+
+const STORAGE_KEY = 'om:timesheets:activeTimer'
+
+function saveToSession(state: TimerState | null) {
+  try {
+    if (state) sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state))
+    else sessionStorage.removeItem(STORAGE_KEY)
+  } catch { /* private browsing */ }
+}
+
+function loadFromSession(): TimerState | null {
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY)
+    if (!raw) return null
+    const parsed = JSON.parse(raw)
+    if (parsed?.startedAt && parsed?.entryId) return parsed as TimerState
+  } catch { /* corrupt or private browsing */ }
+  return null
+}
+
+function formatElapsed(seconds: number): string {
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = seconds % 60
+  return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`
+}
+
+function getToday(): string {
+  const now = new Date()
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`
+}
+
+function TimerSidebarIndicator() {
+  const t = useT()
+  // Initialise from sessionStorage so the indicator doesn't flash away on navigation
+  const [timer, setTimer] = React.useState<TimerState | null>(loadFromSession)
+  const [elapsed, setElapsed] = React.useState(0)
+  const intervalRef = React.useRef<ReturnType<typeof setInterval> | null>(null)
+
+  // Wrap setTimer to also persist to sessionStorage
+  const updateTimer = React.useCallback((next: TimerState | null) => {
+    setTimer(next)
+    saveToSession(next)
+  }, [])
+
+  const pollTimer = React.useCallback(async () => {
+    try {
+      const selfRes = await apiCall<{ member?: { id: string } | null }>('/api/staff/team-members/self')
+      const memberId = selfRes.result?.member?.id
+      if (!memberId) { updateTimer(null); return }
+
+      const today = getToday()
+      const res = await apiCall<{ items?: Array<Record<string, unknown>> }>(
+        `/api/staff/timesheets/time-entries?staffMemberId=${memberId}&from=${today}&to=${today}&pageSize=50`,
+      )
+      const items = (res.result?.items ?? []) as Array<Record<string, unknown>>
+      const active = items.find((e) => e.started_at && !e.ended_at)
+
+      if (!active) {
+        updateTimer(null)
+        return
+      }
+
+      const projectId = String(active.time_project_id ?? '')
+      let projectName = ''
+      let projectColor: string | null = null
+      if (projectId) {
+        const projRes = await apiCall<{ items?: Array<Record<string, unknown>> }>(
+          `/api/staff/timesheets/time-projects?ids=${projectId}&pageSize=1`,
+        )
+        const proj = (projRes.result?.items ?? [])[0]
+        if (proj) {
+          projectName = String(proj.name ?? '')
+          projectColor = typeof proj.color === 'string' ? proj.color : null
+        }
+      }
+
+      updateTimer({
+        entryId: String(active.id ?? ''),
+        projectName,
+        projectColor,
+        startedAt: String(active.started_at ?? ''),
+      })
+    } catch {
+      // Silent — don't crash the sidebar
+    }
+  }, [updateTimer])
+
+  // Poll for active timer on mount + every 30s
+  React.useEffect(() => {
+    void pollTimer()
+    const poll = setInterval(() => { void pollTimer() }, 30000)
+    return () => clearInterval(poll)
+  }, [pollTimer])
+
+  // Tick the elapsed counter locally every second
+  React.useEffect(() => {
+    if (!timer) {
+      if (intervalRef.current) { clearInterval(intervalRef.current); intervalRef.current = null }
+      setElapsed(0)
+      return
+    }
+
+    const startTime = new Date(timer.startedAt).getTime()
+    const calcElapsed = () => Math.max(0, Math.floor((Date.now() - startTime) / 1000))
+    setElapsed(calcElapsed())
+
+    intervalRef.current = setInterval(() => setElapsed(calcElapsed()), 1000)
+    return () => {
+      if (intervalRef.current) { clearInterval(intervalRef.current); intervalRef.current = null }
+    }
+  }, [timer])
+
+  if (!timer) return null
+
+  return (
+    <a
+      href="/backend/staff/timesheets"
+      className="flex items-center gap-2 rounded-md px-2 py-1.5 text-xs hover:bg-muted transition-colors cursor-pointer"
+      title={t('staff.timesheets.sidebar.timerRunning', 'Timer running — click to view')}
+    >
+      <span className="relative flex h-2.5 w-2.5 shrink-0">
+        <span className="absolute inline-flex h-full w-full animate-ping rounded-full bg-red-400 opacity-75" />
+        <span className="relative inline-flex h-2.5 w-2.5 rounded-full bg-red-500" />
+      </span>
+      {timer.projectName ? (
+        <span className="inline-flex items-center gap-1 truncate">
+          <ProjectColorDot colorKey={timer.projectColor} projectName={timer.projectName} size="xs" />
+          <span className="truncate">{timer.projectName}</span>
+        </span>
+      ) : null}
+      <span className="ml-auto font-mono tabular-nums shrink-0">{formatElapsed(elapsed)}</span>
+    </a>
+  )
+}
+
+const widget: InjectionWidgetModule = {
+  metadata: {
+    id: 'staff.injection.timer-sidebar-indicator',
+    title: 'Active timer indicator',
+    description: 'Shows a pulsing indicator in the sidebar when a timesheet timer is running.',
+    features: ['staff.timesheets.manage_own'],
+  },
+  Widget: TimerSidebarIndicator,
+}
+
+export default widget

package/src/modules/staff/widgets/injection-table.ts

@@ -0,0 +1,10 @@
+import type { ModuleInjectionTable } from '@open-mercato/shared/modules/widgets/injection'
+
+export const injectionTable: ModuleInjectionTable = {
+  'backend:sidebar:nav:footer': {
+    widgetId: 'staff.injection.timer-sidebar-indicator',
+    priority: 90,
+  },
+}
+
+export default injectionTable

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

@@ -128,21 +128,25 @@ export async function POST(request: Request) {
       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()
+    // Persist the mapping, credentials, and integration-state config atomically.
+    // credentialsService / integrationStateService are request-scoped and share
+    // this request `em`, so a single transaction covers all of their writes.
+    await em.transactional(async () => {
+      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)
+    })
 
     const { run, progressJob } = await startDataSyncRun({
       syncRunService,
@@ -171,9 +175,10 @@ export async function POST(request: Request) {
       },
     })
 
-    upload.syncRunId = run.id
-    upload.status = 'importing'
-    await em.flush()
+    await em.transactional(async () => {
+      upload.syncRunId = run.id
+      upload.status = 'importing'
+    })
 
     return NextResponse.json(syncExcelImportResponseSchema.parse({
       runId: run.id,

package/src/modules/translations/commands/translations.ts

@@ -80,39 +80,56 @@ const saveTranslationCommand: CommandHandler<SaveInput, { rowId: string }> = {
 
   async execute(input, ctx) {
     const db = resolveDb(ctx) as any
-    const existing = await db
-      .selectFrom('entity_translations')
-      .select(['id'])
-      .where('entity_type', '=', input.entityType)
-      .where('entity_id', '=', input.entityId)
-      .where(sql<boolean>`tenant_id is not distinct from ${input.tenantId}`)
-      .where(sql<boolean>`organization_id is not distinct from ${input.organizationId}`)
-      .executeTakeFirst() as { id: string } | undefined
 
-    if (existing) {
-      await db
-        .updateTable('entity_translations')
-        .set({
-          translations: sql`${JSON.stringify(input.translations)}::jsonb`,
-          updated_at: sql`now()`,
-        } as any)
-        .where('id', '=', existing.id)
-        .execute()
-    } else {
-      await db
-        .insertInto('entity_translations')
-        .values({
-          entity_type: input.entityType,
-          entity_id: input.entityId,
-          organization_id: input.organizationId,
-          tenant_id: input.tenantId,
-          translations: sql`${JSON.stringify(input.translations)}::jsonb`,
-          created_at: sql`now()`,
-          updated_at: sql`now()`,
-        } as any)
-        .execute()
-    }
+    // Run the lookup + upsert + id read in one transaction so a concurrent
+    // writer cannot slip between the existence check and the insert/update.
+    const rowId = await db.transaction().execute(async (trx: any) => {
+      const existing = await trx
+        .selectFrom('entity_translations')
+        .select(['id'])
+        .where('entity_type', '=', input.entityType)
+        .where('entity_id', '=', input.entityId)
+        .where(sql<boolean>`tenant_id is not distinct from ${input.tenantId}`)
+        .where(sql<boolean>`organization_id is not distinct from ${input.organizationId}`)
+        .executeTakeFirst() as { id: string } | undefined
 
+      if (existing) {
+        await trx
+          .updateTable('entity_translations')
+          .set({
+            translations: sql`${JSON.stringify(input.translations)}::jsonb`,
+            updated_at: sql`now()`,
+          } as any)
+          .where('id', '=', existing.id)
+          .execute()
+      } else {
+        await trx
+          .insertInto('entity_translations')
+          .values({
+            entity_type: input.entityType,
+            entity_id: input.entityId,
+            organization_id: input.organizationId,
+            tenant_id: input.tenantId,
+            translations: sql`${JSON.stringify(input.translations)}::jsonb`,
+            created_at: sql`now()`,
+            updated_at: sql`now()`,
+          } as any)
+          .execute()
+      }
+
+      const saved = await trx
+        .selectFrom('entity_translations')
+        .select(['id'])
+        .where('entity_type', '=', input.entityType)
+        .where('entity_id', '=', input.entityId)
+        .where(sql<boolean>`tenant_id is not distinct from ${input.tenantId}`)
+        .where(sql<boolean>`organization_id is not distinct from ${input.organizationId}`)
+        .executeTakeFirst() as { id: string } | undefined
+
+      return saved?.id ?? ''
+    })
+
+    // Emit AFTER the write commits — never announce a change that rolled back.
     await emitTranslationsEvent('translations.translation.updated', {
       entityType: input.entityType,
       entityId: input.entityId,
@@ -120,16 +137,7 @@ const saveTranslationCommand: CommandHandler<SaveInput, { rowId: string }> = {
       tenantId: input.tenantId,
     }, { persistent: true }).catch(() => undefined)
 
-    const saved = await db
-      .selectFrom('entity_translations')
-      .select(['id'])
-      .where('entity_type', '=', input.entityType)
-      .where('entity_id', '=', input.entityId)
-      .where(sql<boolean>`tenant_id is not distinct from ${input.tenantId}`)
-      .where(sql<boolean>`organization_id is not distinct from ${input.organizationId}`)
-      .executeTakeFirst() as { id: string } | undefined
-
-    return { rowId: saved?.id ?? '' }
+    return { rowId }
   },
 
   async captureAfter(input, _result, ctx) {