From bd4ba338af12dc1160f0a93b97ba7db7f6b5ddc0 Mon Sep 17 00:00:00 2001 From: bchanot Date: Wed, 4 Nov 2026 19:58:21 +0100 Subject: [PATCH] feat(app): sign-out warns before losing editor work, local copies purged --- .../2026-11-03-v1-2-6-label-proposals.md | 11 +++ apps/app/e2e/shell/editor-signout.spec.ts | 81 +++++++++++++++++ apps/app/src/app/usePurgeForeignCopies.ts | 15 ++++ apps/app/src/components/shell/AppLayout.tsx | 2 + .../src/components/shell/SignOutButton.tsx | 54 +++++++++--- .../components/shell/SignOutLossDialog.tsx | 35 ++++++++ apps/app/src/editor/state/recovery.ts | 45 +++++++++- apps/app/src/i18n/en.ts | 5 ++ apps/app/src/i18n/fr.ts | 5 ++ .../unit/app.usePurgeForeignCopies.test.tsx | 49 +++++++++++ .../unit/components.SignOutButton.test.tsx | 87 +++++++++++++++++++ apps/app/tests/unit/editor-copy-purge.test.ts | 44 ++++++++++ 12 files changed, 417 insertions(+), 16 deletions(-) create mode 100644 apps/app/e2e/shell/editor-signout.spec.ts create mode 100644 apps/app/src/app/usePurgeForeignCopies.ts create mode 100644 apps/app/src/components/shell/SignOutLossDialog.tsx create mode 100644 apps/app/tests/unit/app.usePurgeForeignCopies.test.tsx create mode 100644 apps/app/tests/unit/components.SignOutButton.test.tsx create mode 100644 apps/app/tests/unit/editor-copy-purge.test.ts diff --git a/.claude/audits/2026-11-03-v1-2-6-label-proposals.md b/.claude/audits/2026-11-03-v1-2-6-label-proposals.md index dd5f437c..356269a2 100644 --- a/.claude/audits/2026-11-03-v1-2-6-label-proposals.md +++ b/.claude/audits/2026-11-03-v1-2-6-label-proposals.md @@ -497,3 +497,14 @@ Plural keys use `_one` / `_other` (French 0 and 1 are singular). The b | `editor.views.drawing.use_parent_body` | La vue affichera l'illustration de la vue parente à travers son recadrage. Son propre fichier d'illustration reste enregistré, et vous pouvez annuler ce changement (Annuler). Les annotations de la vue repassent « à confirmer ». | The view will show the parent view's drawing through its crop. Its own drawing file stays stored, and you can undo this change (Undo). The view's annotations go back to "to confirm". | New: names the effect (nothing deleted, undo, `reconfirm_redrawn_views`) | | `editor.views.drawing.use_parent_confirm` / `_cancel` | Utiliser l'illustration parente / Annuler | Use the parent drawing / Cancel | New: dialog buttons | | `editor.findings.new.category_in_zone` | Nouvelle catégorie dans la zone « {zone} » | New category in the zone « {zone} » | Replaces `editor.findings.new.category` (« Nouvelle catégorie de constats » / « New findings category »): the form names the zone the category lands in (C42) | + +## Lot N2 (owner decision 2026-11-04: sign-out and local copies, C43) + +Shown by a voluntary sign-out only when the editor holds unsaved changes, a recovery offer waits, or this tab holds a local copy of the account. Nothing is asked otherwise. + +| Key | FR | EN | Old wording and why | +|---|---|---|---| +| `shell.sign_out_loss_title` | Se déconnecter et perdre le travail local ? | Sign out and lose the local work? | New: dialog title | +| `shell.sign_out_loss_body` | Des modifications non enregistrées ou des copies locales de cet onglet seraient perdues. Les enregistrer sur le serveur avant de vous déconnecter les conserve. | Unsaved changes or the local copies held in this tab would be lost. Saving them to the server before signing out keeps them. | New: names what is lost and the way to keep it | +| `shell.sign_out_loss_cancel` | Annuler | Cancel | New: keeps the session and the copies | +| `shell.sign_out_loss_confirm` | Se déconnecter quand même | Sign out anyway | New: purges this account's copies, then signs out | diff --git a/apps/app/e2e/shell/editor-signout.spec.ts b/apps/app/e2e/shell/editor-signout.spec.ts new file mode 100644 index 00000000..b756ec9f --- /dev/null +++ b/apps/app/e2e/shell/editor-signout.spec.ts @@ -0,0 +1,81 @@ +import { fr } from '@/i18n/fr' +import type { Locator, Page, TestInfo } from '@playwright/test' +import { expect, test } from '../support/browser' +import { dropLateReplays, routeToSandbox } from '../support/sandbox' +import { + copyKeyOf, + editorActor, + openDraft, + openEditor, + seedDraft, + selectTab, + standardShape, + storedCopy, +} from '../support/editor' +import { stepUpAdmin } from '../support/admin' +import { signIn } from '../support/shell' + +// V1-2.6 Lot N2 (contract C43, ruling R24): a voluntary sign-out with unsaved work asks, +// purges this account's local copies on confirmation, and the next sign-in offers nothing. + +const dict = fr + +const isPhone = (info: TestInfo) => info.project.name === 'chromium-375' + +const nameFr = (page: Page) => + page.getByLabel(dict['editor.general.name_fr'], { exact: true }) + +const button = (scope: Page | Locator, name: string) => + scope.getByRole('button', { name, exact: true }) + +test.describe('sign-out with unsaved editor work', () => { + test.use({ locale: 'fr-FR', actionTimeout: 15_000 }) + test.beforeEach(async ({ context }, info) => { + test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access + await routeToSandbox(context) + }) + test.afterEach(async ({ context }) => { + await dropLateReplays(context) + }) + + test('confirming drops the copy, and signing in again offers no recovery', async ({ + page, + requests, + }) => { + const actor = await editorActor('fr') + requests.forbid(actor.account.email, actor.account.password) + const seed = await seedDraft(actor, { shape: standardShape }) + const key = copyKeyOf(actor.account.id, seed.draftId) + await openEditor(page, dict, actor, seed.sheetId) + await selectTab(page, dict, 'general') + await nameFr(page).fill('Travail non enregistré') + await nameFr(page).press('Enter') + expect(await storedCopy(page, key)).not.toBeNull() + + const signOut = button(page, dict['shell.sign_out']) + await signOut.click() + const dialog = page.getByRole('dialog', { + name: dict['shell.sign_out_loss_title'], + }) + await expect(dialog).toBeVisible() + await button(dialog, dict['shell.sign_out_loss_cancel']).click() + await expect(dialog).toBeHidden() + expect(await storedCopy(page, key)).not.toBeNull() + await expect(nameFr(page)).toHaveValue('Travail non enregistré') + + await signOut.click() + await button(dialog, dict['shell.sign_out_loss_confirm']).click() + await expect(page).toHaveURL(/\/(login)?$/) + expect(await storedCopy(page, key)).toBeNull() + + await signIn(page, actor.account, dict) + await page.goto('/app/admin') + await stepUpAdmin(page, dict, actor.secret) + await openDraft(page, dict, seed.sheetId) + await selectTab(page, dict, 'general') + await expect(nameFr(page)).toBeEditable() + await expect( + button(page, dict['editor.draft.recovery.restore']), + ).toHaveCount(0) + }) +}) diff --git a/apps/app/src/app/usePurgeForeignCopies.ts b/apps/app/src/app/usePurgeForeignCopies.ts new file mode 100644 index 00000000..67b5d83d --- /dev/null +++ b/apps/app/src/app/usePurgeForeignCopies.ts @@ -0,0 +1,15 @@ +import { useEffect } from 'react' +import { removeOtherUsersCopies } from '@/editor/state/recovery' +import { useAuthStore } from '@/state/authStore' + +/** + * Local recovery copies are only offered to their own account (ruling R24): once another + * account is signed in within this tab, the previous accounts' copies are removed, before + * any editor screen reads them. An expired session alone removes nothing. + */ +export function usePurgeForeignCopies(): void { + const userId = useAuthStore((s) => s.user?.id ?? null) + useEffect(() => { + if (userId) removeOtherUsersCopies(userId) + }, [userId]) +} diff --git a/apps/app/src/components/shell/AppLayout.tsx b/apps/app/src/components/shell/AppLayout.tsx index c079d063..c49330a3 100644 --- a/apps/app/src/components/shell/AppLayout.tsx +++ b/apps/app/src/components/shell/AppLayout.tsx @@ -9,6 +9,7 @@ import MobileDrawer from './MobileDrawer' import SidebarNav, { NAV_ITEMS } from './SidebarNav' import SignOutButton from './SignOutButton' import UserBadge, { AvatarCircle } from './UserBadge' +import { usePurgeForeignCopies } from '@/app/usePurgeForeignCopies' import { useAuthStore } from '@/state/authStore' import { useLeaveGuardStore } from '@/state/leaveGuardStore' import { useT } from '@/i18n/useT' @@ -41,6 +42,7 @@ function followedLink(event: MouseEvent): HTMLAnchorElement | null { */ export default function AppLayout() { const t = useT() + usePurgeForeignCopies() const location = useLocation() const navigate = useNavigate() const [drawerOpen, setDrawerOpen] = useState(false) diff --git a/apps/app/src/components/shell/SignOutButton.tsx b/apps/app/src/components/shell/SignOutButton.tsx index a33c6860..8eb68cd5 100644 --- a/apps/app/src/components/shell/SignOutButton.tsx +++ b/apps/app/src/components/shell/SignOutButton.tsx @@ -2,16 +2,39 @@ import { useState } from 'react' import { useNavigate } from 'react-router-dom' import Button from '@/components/ui/Button' import Icon from '@/components/ui/Icon' +import SignOutLossDialog from './SignOutLossDialog' +import { hasUserCopies, removeUserCopies } from '@/editor/state/recovery' +import { leaveGuardArmed, useEditorStore } from '@/editor/state/editorStore' import { useAuthStore } from '@/state/authStore' import { useT } from '@/i18n/useT' -export default function SignOutButton({ className = '' }: { className?: string }) { +export default function SignOutButton({ + className = '', +}: { + className?: string +}) { const t = useT() const navigate = useNavigate() const signOut = useAuthStore((s) => s.signOut) + const userId = useAuthStore((s) => s.user?.id) + const unsavedWork = useEditorStore(leaveGuardArmed) const [busy, setBusy] = useState(false) + const [confirming, setConfirming] = useState(false) - async function onClick() { + function onClick() { + const atStake = + unsavedWork || (userId !== undefined && hasUserCopies(userId)) + if (atStake) setConfirming(true) + else void leave() + } + + function onConfirm() { + setConfirming(false) + if (userId) removeUserCopies(userId) + void leave() + } + + async function leave() { setBusy(true) try { await signOut() @@ -25,15 +48,22 @@ export default function SignOutButton({ className = '' }: { className?: string } } return ( - + <> + + setConfirming(false)} + /> + ) } diff --git a/apps/app/src/components/shell/SignOutLossDialog.tsx b/apps/app/src/components/shell/SignOutLossDialog.tsx new file mode 100644 index 00000000..b276c2de --- /dev/null +++ b/apps/app/src/components/shell/SignOutLossDialog.tsx @@ -0,0 +1,35 @@ +import Button from '@/components/ui/Button' +import Dialog from '@/components/ui/Dialog' +import { useT } from '@/i18n/useT' + +export interface SignOutLossDialogProps { + open: boolean + onConfirm: () => void + onCancel: () => void +} + +/** Warns that signing out drops the unsaved changes and this tab's local copies. */ +export default function SignOutLossDialog({ + open, + onConfirm, + onCancel, +}: SignOutLossDialogProps) { + const t = useT() + return ( + +
+ + +
+
+ ) +} diff --git a/apps/app/src/editor/state/recovery.ts b/apps/app/src/editor/state/recovery.ts index a16068ff..fdcc00f4 100644 --- a/apps/app/src/editor/state/recovery.ts +++ b/apps/app/src/editor/state/recovery.ts @@ -12,7 +12,8 @@ export const COPY_PREFIX = 'osteo:sheet-draft:' export const MAX_OTHER_COPIES = 2 const DocumentObject = z.custom>( - (value) => typeof value === 'object' && value !== null && !Array.isArray(value), + (value) => + typeof value === 'object' && value !== null && !Array.isArray(value), ) const CopySchema = z.object({ @@ -55,7 +56,11 @@ function storage(): Storage | null { } } -function parseCopy(raw: string, userId: string, versionId: string): RecoveryCopy | null { +function parseCopy( + raw: string, + userId: string, + versionId: string, +): RecoveryCopy | null { try { const parsed = CopySchema.safeParse(JSON.parse(raw)) const matches = parsed.success && parsed.data.user_id === userId @@ -90,7 +95,12 @@ function keysOf(store: Storage, prefix: string): string[] { return keys.sort() } -function infoOf(store: Storage, key: string, userId: string, versionId: string) { +function infoOf( + store: Storage, + key: string, + userId: string, + versionId: string, +) { const copy = parseCopy(store.getItem(key) ?? '', userId, versionId) return { versionId, @@ -101,7 +111,10 @@ function infoOf(store: Storage, key: string, userId: string, versionId: string) } /** The account's copies of other versions; another account's keys never match the prefix. */ -export function listOtherCopies(userId: string, versionId: string): StoredCopyInfo[] { +export function listOtherCopies( + userId: string, + versionId: string, +): StoredCopyInfo[] { const store = storage() if (!store) return [] const prefix = `${COPY_PREFIX}${userId}:` @@ -124,3 +137,27 @@ export function writeCopy(copy: RecoveryCopy): WriteResult { export function removeCopy(userId: string, versionId: string): void { writeOrRemove(copyKey(userId, versionId), null) } + +/** Whether this tab holds at least one copy of the account's own. */ +export function hasUserCopies(userId: string): boolean { + const store = storage() + return store !== null && keysOf(store, `${COPY_PREFIX}${userId}:`).length > 0 +} + +function removeKeys(keys: string[]): void { + keys.forEach((key) => writeOrRemove(key, null)) +} + +/** Voluntary sign-out: every copy of the account goes, other keys stay (plan R24). */ +export function removeUserCopies(userId: string): void { + const store = storage() + if (store) removeKeys(keysOf(store, `${COPY_PREFIX}${userId}:`)) +} + +/** Another account signed in: the previous accounts' copies go, the account's own stay. */ +export function removeOtherUsersCopies(userId: string): void { + const store = storage() + if (!store) return + const own = `${COPY_PREFIX}${userId}:` + removeKeys(keysOf(store, COPY_PREFIX).filter((key) => !key.startsWith(own))) +} diff --git a/apps/app/src/i18n/en.ts b/apps/app/src/i18n/en.ts index 683455fb..8b474eda 100644 --- a/apps/app/src/i18n/en.ts +++ b/apps/app/src/i18n/en.ts @@ -369,6 +369,11 @@ export const en: Dict = { 'shell.signing_out': 'Signing out…', 'shell.sign_out_failed': 'Signed out on this device, but the server did not confirm: your other sessions may stay open.', + 'shell.sign_out_loss_title': 'Sign out and lose the local work?', + 'shell.sign_out_loss_body': + 'Unsaved changes or the local copies held in this tab would be lost. Saving them to the server before signing out keeps them.', + 'shell.sign_out_loss_cancel': 'Cancel', + 'shell.sign_out_loss_confirm': 'Sign out anyway', 'shell.loading_session': 'Checking your session…', 'shell.role.owner': 'Platform owner', 'shell.role.admin': 'Administrator', diff --git a/apps/app/src/i18n/fr.ts b/apps/app/src/i18n/fr.ts index c752306a..13ec37cd 100644 --- a/apps/app/src/i18n/fr.ts +++ b/apps/app/src/i18n/fr.ts @@ -385,6 +385,11 @@ export const fr: Dict = { 'shell.signing_out': 'Déconnexion…', 'shell.sign_out_failed': "Déconnecté sur cet appareil, mais le serveur n'a pas confirmé : vos autres sessions peuvent rester ouvertes.", + 'shell.sign_out_loss_title': 'Se déconnecter et perdre le travail local ?', + 'shell.sign_out_loss_body': + 'Des modifications non enregistrées ou des copies locales de cet onglet seraient perdues. Les enregistrer sur le serveur avant de vous déconnecter les conserve.', + 'shell.sign_out_loss_cancel': 'Annuler', + 'shell.sign_out_loss_confirm': 'Se déconnecter quand même', 'shell.loading_session': 'Vérification de la session…', 'shell.role.owner': 'Propriétaire plateforme', 'shell.role.admin': 'Administrateur', diff --git a/apps/app/tests/unit/app.usePurgeForeignCopies.test.tsx b/apps/app/tests/unit/app.usePurgeForeignCopies.test.tsx new file mode 100644 index 00000000..c7d3d040 --- /dev/null +++ b/apps/app/tests/unit/app.usePurgeForeignCopies.test.tsx @@ -0,0 +1,49 @@ +/** Lot N2: another account signing in purges the previous accounts' copies (ruling R24). */ +import { afterEach, describe, expect, it } from 'vitest' +import { act, cleanup, renderHook } from '@testing-library/react' +import { usePurgeForeignCopies } from '@/app/usePurgeForeignCopies' +import { copyKey } from '@/editor/state/recovery' +import { useAuthStore } from '@/state/authStore' +import { fakeUser } from '../helpers/fakeSupabase' + +const A = fakeUser({ id: 'aaaaaaaa-0000-0000-0000-000000000001' }) +const B = fakeUser({ id: 'bbbbbbbb-0000-0000-0000-000000000002' }) + +afterEach(() => { + cleanup() + sessionStorage.clear() + useAuthStore.setState({ status: 'signed_out', user: null }) +}) + +function seed() { + sessionStorage.setItem(copyKey(A.id, 'v1'), '{}') + sessionStorage.setItem(copyKey(B.id, 'v1'), '{}') +} + +describe('usePurgeForeignCopies', () => { + it('keeps the copies of an expired session and offers them to the same account', () => { + seed() + useAuthStore.setState({ status: 'signed_in', user: A }) + renderHook(() => usePurgeForeignCopies()) + act(() => useAuthStore.setState({ status: 'signed_out', user: null })) + act(() => useAuthStore.setState({ status: 'signed_in', user: A })) + expect(sessionStorage.getItem(copyKey(A.id, 'v1'))).toBe('{}') + }) + + it('purges the previous account copies when another account signs in', () => { + sessionStorage.setItem(copyKey(A.id, 'v1'), '{}') + useAuthStore.setState({ status: 'signed_in', user: A }) + renderHook(() => usePurgeForeignCopies()) + act(() => useAuthStore.setState({ status: 'signed_in', user: B })) + sessionStorage.setItem(copyKey(B.id, 'v1'), '{}') + expect(sessionStorage.getItem(copyKey(A.id, 'v1'))).toBeNull() + expect(sessionStorage.getItem(copyKey(B.id, 'v1'))).toBe('{}') + }) + + it('purges at mount when copies of another account are already there', () => { + seed() + useAuthStore.setState({ status: 'signed_in', user: B }) + renderHook(() => usePurgeForeignCopies()) + expect(sessionStorage.getItem(copyKey(A.id, 'v1'))).toBeNull() + }) +}) diff --git a/apps/app/tests/unit/components.SignOutButton.test.tsx b/apps/app/tests/unit/components.SignOutButton.test.tsx new file mode 100644 index 00000000..c17728a2 --- /dev/null +++ b/apps/app/tests/unit/components.SignOutButton.test.tsx @@ -0,0 +1,87 @@ +/** Lot N2: sign-out asks only when something would be lost (contract C43). */ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { cleanup, render, screen, waitFor } from '@testing-library/react' +import userEvent from '@testing-library/user-event' +import { MemoryRouter } from 'react-router-dom' +import SignOutButton from '@/components/shell/SignOutButton' +import { copyKey } from '@/editor/state/recovery' +import { useEditorStore } from '@/editor/state/editorStore' +import { useAuthStore } from '@/state/authStore' +import { useLocaleStore } from '@/state/localeStore' +import { fr } from '@/i18n/fr' +import { fakeUser } from '../helpers/fakeSupabase' + +const user = fakeUser() +const OTHER = 'bbbbbbbb-0000-0000-0000-000000000002' +const signOut = vi.fn(() => Promise.resolve()) + +beforeEach(() => { + useLocaleStore.setState({ locale: 'fr' }) + useAuthStore.setState({ status: 'signed_in', user, signOut }) + useEditorStore.setState({ unsaved: false, recovery: 'none' }) +}) +afterEach(() => { + cleanup() + sessionStorage.clear() + signOut.mockClear() +}) + +const click = () => + userEvent.click(screen.getByRole('button', { name: fr['shell.sign_out'] })) + +function mount() { + render( + + + , + ) +} + +describe('SignOutButton', () => { + it('signs out at once when nothing would be lost', async () => { + mount() + await click() + expect(screen.queryByRole('dialog')).toBeNull() + await waitFor(() => expect(signOut).toHaveBeenCalledTimes(1)) + }) + + it('asks when the editor holds unsaved changes, and cancel keeps everything', async () => { + useEditorStore.setState({ unsaved: true }) + sessionStorage.setItem(copyKey(user.id, 'v1'), '{}') + mount() + await click() + expect(screen.getByRole('dialog')).toBeTruthy() + await userEvent.click( + screen.getByRole('button', { name: fr['shell.sign_out_loss_cancel'] }), + ) + expect(signOut).not.toHaveBeenCalled() + expect(sessionStorage.getItem(copyKey(user.id, 'v1'))).toBe('{}') + }) + + it('asks when a pending recovery offer exists', async () => { + useEditorStore.setState({ recovery: 'pending' }) + mount() + await click() + expect(screen.getByRole('dialog')).toBeTruthy() + }) + + it('asks for a copy of its own, then confirming purges only that account and signs out', async () => { + sessionStorage.setItem(copyKey(user.id, 'v1'), '{}') + sessionStorage.setItem(copyKey(OTHER, 'v1'), '{}') + mount() + await click() + await userEvent.click( + screen.getByRole('button', { name: fr['shell.sign_out_loss_confirm'] }), + ) + await waitFor(() => expect(signOut).toHaveBeenCalledTimes(1)) + expect(sessionStorage.getItem(copyKey(user.id, 'v1'))).toBeNull() + expect(sessionStorage.getItem(copyKey(OTHER, 'v1'))).toBe('{}') + }) + + it('ignores the copies of another account', async () => { + sessionStorage.setItem(copyKey(OTHER, 'v1'), '{}') + mount() + await click() + expect(screen.queryByRole('dialog')).toBeNull() + }) +}) diff --git a/apps/app/tests/unit/editor-copy-purge.test.ts b/apps/app/tests/unit/editor-copy-purge.test.ts new file mode 100644 index 00000000..e918bce9 --- /dev/null +++ b/apps/app/tests/unit/editor-copy-purge.test.ts @@ -0,0 +1,44 @@ +/** Lot N2: the purge of local recovery copies by account (contract C43, ruling R24). */ +import { afterEach, describe, expect, it } from 'vitest' +import { + copyKey, + hasUserCopies, + removeOtherUsersCopies, + removeUserCopies, +} from '@/editor/state/recovery' + +const A = 'aaaaaaaa-0000-0000-0000-000000000001' +const B = 'bbbbbbbb-0000-0000-0000-000000000002' + +function seed() { + sessionStorage.setItem(copyKey(A, 'v1'), '{}') + sessionStorage.setItem(copyKey(A, 'v2'), '{}') + sessionStorage.setItem(copyKey(B, 'v1'), '{}') + sessionStorage.setItem('osteo:draft', '{}') +} +const keys = () => Object.keys(sessionStorage).sort() + +afterEach(() => sessionStorage.clear()) + +describe('copy purge', () => { + it('sees whether an account holds a copy', () => { + expect(hasUserCopies(A)).toBe(false) + seed() + expect(hasUserCopies(A)).toBe(true) + expect(hasUserCopies('cccccccc')).toBe(false) + }) + + it('removes every copy of one account and nothing else', () => { + seed() + removeUserCopies(A) + expect(keys()).toEqual([copyKey(B, 'v1'), 'osteo:draft'].sort()) + }) + + it('keeps the signed-in account copies and removes the others', () => { + seed() + removeOtherUsersCopies(A) + expect(keys()).toEqual( + [copyKey(A, 'v1'), copyKey(A, 'v2'), 'osteo:draft'].sort(), + ) + }) +})