@open-mercato/ui 0.6.6-develop.6184.1.b7e55f8d61 → 0.6.6-develop.6198.1.0822f97cc6

package/src/backend/DataTable.tsx

@@ -40,6 +40,7 @@ import { PerspectiveSidebar } from './PerspectiveSidebar'
 import { Popover, PopoverTrigger, PopoverContent } from '../primitives/popover'
 import { formatWithPublicDateFormat, normalizeDateFormatPattern } from '../primitives/date-format'
 import { cn } from '@open-mercato/shared/lib/utils'
+import { readVersionedPreference, writeVersionedPreference, clearVersionedPreference } from '@open-mercato/shared/lib/browser/versionedPreference'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { flash } from './FlashMessages'
 import { useConfirmDialog } from './confirm-dialog'
@@ -484,6 +485,19 @@ type PerspectiveSnapshot = {
   updatedAt: number
 }
 
+// Versioned-envelope discriminator for the persisted perspective snapshot. Bump
+// when the snapshot shape changes incompatibly and add a read-old migration
+// branch; see `@open-mercato/shared/lib/browser/versionedPreference`.
+const PERSPECTIVE_SNAPSHOT_VERSION = 1
+
+type StoredPerspectiveSnapshot = { perspectiveId?: unknown; settings?: unknown; updatedAt?: unknown }
+
+function isStoredPerspectiveSnapshot(value: unknown): value is StoredPerspectiveSnapshot {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const settings = (value as Record<string, unknown>).settings
+  return typeof settings === 'object' && settings !== null
+}
+
 function readPerspectiveCookie(tableId: string): string | null {
   if (typeof document === 'undefined') return null
   const key = `${PERSPECTIVE_COOKIE_PREFIX}:${tableId}`
@@ -500,40 +514,31 @@ function writePerspectiveCookie(tableId: string, perspectiveId: string | null):
   document.cookie = `${key}=${value}; Path=/; ${expires}; SameSite=Lax`
 }
 
-function readPerspectiveSnapshot(tableId: string): PerspectiveSnapshot | null {
-  if (typeof window === 'undefined') return null
-  try {
-    const raw = window.localStorage.getItem(`${PERSPECTIVE_STORAGE_PREFIX}:${tableId}`)
-    if (!raw) return null
-    const parsed = JSON.parse(raw)
-    if (!parsed || typeof parsed !== 'object') return null
-    const perspectiveId =
-      typeof parsed.perspectiveId === 'string' && parsed.perspectiveId.trim().length > 0
-        ? parsed.perspectiveId
-        : null
-    const settings = typeof parsed.settings === 'object' && parsed.settings !== null
-      ? parsed.settings as PerspectiveSettings
+export function readPerspectiveSnapshot(tableId: string): PerspectiveSnapshot | null {
+  const parsed = readVersionedPreference<StoredPerspectiveSnapshot | null>(
+    `${PERSPECTIVE_STORAGE_PREFIX}:${tableId}`,
+    PERSPECTIVE_SNAPSHOT_VERSION,
+    (value): value is StoredPerspectiveSnapshot | null => isStoredPerspectiveSnapshot(value),
+    null,
+    { legacyIsValid: (value): value is StoredPerspectiveSnapshot | null => isStoredPerspectiveSnapshot(value) },
+  )
+  if (!parsed) return null
+  const perspectiveId =
+    typeof parsed.perspectiveId === 'string' && parsed.perspectiveId.trim().length > 0
+      ? parsed.perspectiveId
       : null
-    const updatedAt = typeof parsed.updatedAt === 'number' ? parsed.updatedAt : Date.now()
-    if (!settings) return null
-    return { perspectiveId, settings, updatedAt }
-  } catch {
-    return null
-  }
+  const settings = parsed.settings as PerspectiveSettings
+  const updatedAt = typeof parsed.updatedAt === 'number' ? parsed.updatedAt : Date.now()
+  return { perspectiveId, settings, updatedAt }
 }
 
-function writePerspectiveSnapshot(tableId: string, snapshot: PerspectiveSnapshot | null) {
-  if (typeof window === 'undefined') return
+export function writePerspectiveSnapshot(tableId: string, snapshot: PerspectiveSnapshot | null) {
   const key = `${PERSPECTIVE_STORAGE_PREFIX}:${tableId}`
-  try {
-    if (!snapshot) {
-      window.localStorage.removeItem(key)
-      return
-    }
-    window.localStorage.setItem(key, JSON.stringify(snapshot))
-  } catch {
-    // ignore storage errors
+  if (!snapshot) {
+    clearVersionedPreference(key)
+    return
   }
+  writeVersionedPreference(key, PERSPECTIVE_SNAPSHOT_VERSION, snapshot)
 }
 
 function sanitizePerspectiveSettings(source?: PerspectiveSettings | null): PerspectiveSettings | null {

package/src/backend/__tests__/DataTable.perspectiveStorage.test.ts

@@ -0,0 +1,44 @@
+/** @jest-environment jsdom */
+import { readPerspectiveSnapshot, writePerspectiveSnapshot } from '../DataTable'
+
+const PREFIX = 'om_table_perspective_snapshot'
+
+describe('DataTable perspective snapshot storage (versioned envelope)', () => {
+  beforeEach(() => {
+    localStorage.clear()
+  })
+
+  it('writes a versioned envelope and reads it back', () => {
+    const snapshot = { perspectiveId: 'p1', settings: { columnOrder: ['a', 'b'] }, updatedAt: 123 }
+    writePerspectiveSnapshot('tbl', snapshot)
+    const stored = JSON.parse(localStorage.getItem(`${PREFIX}:tbl`)!)
+    expect(stored.v).toBe(1)
+    expect(stored.data).toEqual(snapshot)
+    expect(readPerspectiveSnapshot('tbl')).toEqual(snapshot)
+  })
+
+  it('migrates a legacy bare (pre-envelope) snapshot on read', () => {
+    const legacy = { perspectiveId: 'p2', settings: { columnOrder: ['x'] }, updatedAt: 7 }
+    localStorage.setItem(`${PREFIX}:tbl2`, JSON.stringify(legacy))
+    expect(readPerspectiveSnapshot('tbl2')).toEqual(legacy)
+  })
+
+  it('discards a version-mismatched envelope', () => {
+    localStorage.setItem(
+      `${PREFIX}:tbl3`,
+      JSON.stringify({ v: 99, data: { perspectiveId: null, settings: {}, updatedAt: 1 } }),
+    )
+    expect(readPerspectiveSnapshot('tbl3')).toBeNull()
+  })
+
+  it('returns null for a malformed value (no settings object)', () => {
+    localStorage.setItem(`${PREFIX}:tbl4`, JSON.stringify({ foo: 'bar' }))
+    expect(readPerspectiveSnapshot('tbl4')).toBeNull()
+  })
+
+  it('clears the slot when writing null', () => {
+    writePerspectiveSnapshot('tbl5', { perspectiveId: null, settings: { columnOrder: ['z'] }, updatedAt: 1 })
+    writePerspectiveSnapshot('tbl5', null)
+    expect(localStorage.getItem(`${PREFIX}:tbl5`)).toBeNull()
+  })
+})

package/src/backend/notifications/__tests__/useNotificationActions.failedWrites.test.tsx

@@ -0,0 +1,119 @@
+jest.mock('../../utils/api', () => ({
+  apiFetch: jest.fn(),
+}))
+
+import { act, renderHook } from '@testing-library/react'
+import * as React from 'react'
+import type { NotificationDto } from '@open-mercato/shared/modules/notifications/types'
+import { apiFetch } from '../../utils/api'
+import { useNotificationActions } from '../useNotificationActions'
+
+function makeNotification(id: string): NotificationDto {
+  return {
+    id,
+    type: 'example.test',
+    title: `title-${id}`,
+    severity: 'info',
+    status: 'unread',
+    actions: [],
+    createdAt: new Date('2026-01-01T00:00:00.000Z').toISOString(),
+  }
+}
+
+function mockResponse(status: number): Response {
+  const ok = status >= 200 && status < 300
+  const body = ok ? '{}' : JSON.stringify({ error: 'boom' })
+  return {
+    ok,
+    status,
+    headers: new Map<string, string>(),
+    text: jest.fn(async () => body),
+    clone: () => mockResponse(status),
+  } as unknown as Response
+}
+
+function setFetchResult(status: number) {
+  ;(apiFetch as jest.Mock).mockResolvedValue(mockResponse(status))
+}
+
+function renderActions(notifications: NotificationDto[]) {
+  const setNotifications = jest.fn()
+  const setUnreadCount = jest.fn()
+  const hook = renderHook(() =>
+    useNotificationActions(notifications, setNotifications, setUnreadCount),
+  )
+  return { hook, setNotifications, setUnreadCount }
+}
+
+async function callAndCaptureRejection(run: () => Promise<unknown>): Promise<boolean> {
+  let rejected = false
+  await act(async () => {
+    try {
+      await run()
+    } catch {
+      rejected = true
+    }
+  })
+  return rejected
+}
+
+describe('useNotificationActions — failed API writes leave local state unchanged', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('markAsRead surfaces the error and does not mutate state when the write fails', async () => {
+    setFetchResult(500)
+    const { hook, setNotifications, setUnreadCount } = renderActions([makeNotification('n1')])
+
+    const rejected = await callAndCaptureRejection(() => hook.result.current.markAsRead('n1'))
+
+    expect(rejected).toBe(true)
+    expect(setNotifications).not.toHaveBeenCalled()
+    expect(setUnreadCount).not.toHaveBeenCalled()
+  })
+
+  it('dismiss surfaces the error and does not mutate state when the write fails', async () => {
+    setFetchResult(500)
+    const { hook, setNotifications, setUnreadCount } = renderActions([makeNotification('n1')])
+
+    const rejected = await callAndCaptureRejection(() => hook.result.current.dismiss('n1'))
+
+    expect(rejected).toBe(true)
+    expect(setNotifications).not.toHaveBeenCalled()
+    expect(setUnreadCount).not.toHaveBeenCalled()
+    expect(hook.result.current.dismissUndo).toBeNull()
+  })
+
+  it('undoDismiss (restore) surfaces the error and preserves the undo banner when the write fails', async () => {
+    const { hook, setNotifications, setUnreadCount } = renderActions([makeNotification('n1')])
+
+    setFetchResult(200)
+    await act(async () => {
+      await hook.result.current.dismiss('n1')
+    })
+    expect(hook.result.current.dismissUndo).not.toBeNull()
+
+    setNotifications.mockClear()
+    setUnreadCount.mockClear()
+    setFetchResult(500)
+
+    const rejected = await callAndCaptureRejection(() => hook.result.current.undoDismiss())
+
+    expect(rejected).toBe(true)
+    expect(setNotifications).not.toHaveBeenCalled()
+    expect(setUnreadCount).not.toHaveBeenCalled()
+    expect(hook.result.current.dismissUndo).not.toBeNull()
+  })
+
+  it('markAllRead surfaces the error and does not mutate state when the write fails', async () => {
+    setFetchResult(500)
+    const { hook, setNotifications, setUnreadCount } = renderActions([makeNotification('n1')])
+
+    const rejected = await callAndCaptureRejection(() => hook.result.current.markAllRead())
+
+    expect(rejected).toBe(true)
+    expect(setNotifications).not.toHaveBeenCalled()
+    expect(setUnreadCount).not.toHaveBeenCalled()
+  })
+})

package/src/backend/notifications/useNotificationActions.ts

@@ -1,6 +1,6 @@
 "use client"
 import * as React from 'react'
-import { apiCall } from '../utils/apiCall'
+import { apiCall, apiCallOrThrow } from '../utils/apiCall'
 import type { NotificationDto } from '@open-mercato/shared/modules/notifications/types'
 
 export type NotificationDismissUndoState = {
@@ -32,7 +32,7 @@ export function useNotificationActions(
   const dismissUndoTimerRef = React.useRef<number | null>(null)
 
   const markAsRead = React.useCallback(async (id: string) => {
-    await apiCall(`/api/notifications/${id}/read`, { method: 'PUT' })
+    await apiCallOrThrow(`/api/notifications/${id}/read`, { method: 'PUT' })
     setNotifications((prev) =>
       prev.map((n) =>
         n.id === id ? { ...n, status: 'read', readAt: new Date().toISOString() } : n,
@@ -69,7 +69,7 @@ export function useNotificationActions(
 
   const dismiss = React.useCallback(
     async (id: string) => {
-      await apiCall(`/api/notifications/${id}/dismiss`, { method: 'PUT' })
+      await apiCallOrThrow(`/api/notifications/${id}/dismiss`, { method: 'PUT' })
       const notification = notifications.find((n) => n.id === id)
       setNotifications((prev) => prev.filter((n) => n.id !== id))
       if (notification?.status === 'unread') {
@@ -95,7 +95,7 @@ export function useNotificationActions(
 
   const undoDismiss = React.useCallback(async () => {
     if (!dismissUndo) return
-    await apiCall(`/api/notifications/${dismissUndo.notification.id}/restore`, {
+    await apiCallOrThrow(`/api/notifications/${dismissUndo.notification.id}/restore`, {
       method: 'PUT',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ status: dismissUndo.previousStatus }),
@@ -129,7 +129,7 @@ export function useNotificationActions(
   }, [dismissUndo, setNotifications, setUnreadCount])
 
   const markAllRead = React.useCallback(async () => {
-    await apiCall('/api/notifications/mark-all-read', { method: 'PUT' })
+    await apiCallOrThrow('/api/notifications/mark-all-read', { method: 'PUT' })
     setNotifications((prev) =>
       prev.map((n) =>
         n.status === 'unread'

package/src/backend/progress/ProgressTopBar.tsx

@@ -26,6 +26,10 @@ export function ProgressTopBar({ className, t, completedAutoHideMs }: ProgressTo
   const visibleCompleted = useAutoHideCompletedJobs(recentlyCompleted, completedAutoHideMs)
   const [expanded, setExpanded] = React.useState(false)
 
+  // `om:progress:expanded` is a trivial scalar flag ('true' | 'false') with no
+  // schema to evolve, so it is intentionally kept raw rather than wrapped in a
+  // versioned envelope (the versioning threshold for structured persisted state
+  // lives in `@open-mercato/shared/lib/browser/versionedPreference`).
   React.useEffect(() => {
     const saved = localStorage.getItem('om:progress:expanded')
     if (saved === 'true') setExpanded(true)