diff --git a/formulus-formplayer/src/App.tsx b/formulus-formplayer/src/App.tsx index bdff7e82b..c8b3a4f8d 100644 --- a/formulus-formplayer/src/App.tsx +++ b/formulus-formplayer/src/App.tsx @@ -137,6 +137,29 @@ import { formDataJsonEqual } from './renderers/subObservationHelpers'; import { mergeIncomingFormData } from './jsonforms/clearHiddenControlData'; /** Embedded sub-observation session (also accepts legacy `returnOnly` from older hosts). */ +function removeExpiredDrafts(init: FormInitData): void { + if (isSubObservationSession(init)) return; + try { + draftService.cleanupExpiredDrafts({ + keep: draft => + init.observationId != null && + draft.formType === init.formType && + draft.observationId === init.observationId, + }); + } catch (error) { + console.warn('[App.tsx] Draft cleanup skipped:', error); + } +} + +function listDraftsWithoutBlocking(formType: string, formVersion: string) { + try { + return draftService.getDraftsForForm(formType, formVersion); + } catch (error) { + console.warn('[App.tsx] Could not read drafts:', error); + return []; + } +} + function isSubObservationSession(init: FormInitData): boolean { const i = init as FormInitData & { returnOnly?: boolean }; return Boolean(i.subObservationMode || i.returnOnly); @@ -911,6 +934,8 @@ function App() { return; // Exit early } + removeExpiredDrafts(initData); + // Check if this is a new form (no savedData) and if drafts exist if ( shouldOfferDraftSelector( @@ -923,7 +948,7 @@ function App() { savedData, ) ) { - const availableDrafts = draftService.getDraftsForForm( + const availableDrafts = listDraftsWithoutBlocking( receivedFormType, resolveFormSchemaVersion(formSchema), ); @@ -1528,15 +1553,23 @@ function App() { draftFlushQueue.current.retire(); } await draftFlushQueue.current.settled(); - if (payloadFormInit.observationId != null) { - draftService.deleteDraftsForFormInstance( - payloadFormInit.formType, - payloadFormInit.observationId, - ); - } else if (draftSessionKey) { - draftService.deleteDraftForNewObservationSession( - payloadFormInit.formType, - draftSessionKey, + // Already saved natively: cleanup failing must not fail the submit. + try { + if (payloadFormInit.observationId != null) { + draftService.deleteDraftsForFormInstance( + payloadFormInit.formType, + payloadFormInit.observationId, + ); + } else if (draftSessionKey) { + draftService.deleteDraftForNewObservationSession( + payloadFormInit.formType, + draftSessionKey, + ); + } + } catch (cleanupError) { + console.warn( + '[App.tsx] Draft cleanup after submit failed:', + cleanupError, ); } // Persist sticky field values for next new observation of this form. diff --git a/formulus-formplayer/src/components/DraftSelector.tsx b/formulus-formplayer/src/components/DraftSelector.tsx index c8137494e..942abae5a 100644 --- a/formulus-formplayer/src/components/DraftSelector.tsx +++ b/formulus-formplayer/src/components/DraftSelector.tsx @@ -41,6 +41,7 @@ interface DraftSelectorProps { // Container style – matched with other confirm UIs (no semi-transparent overlay) const CONFIRM_CARD_RADIUS = 0.7; const CONFIRM_BORDER_WIDTH = 1; +const DAY_MS = 24 * 60 * 60 * 1000; export const DraftSelector: React.FC = ({ formType, @@ -53,12 +54,14 @@ export const DraftSelector: React.FC = ({ const theme = useTheme(); const t = useOdeT(); const [drafts, setDrafts] = useState([]); + const [loadedAt, setLoadedAt] = useState(0); const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false); const [draftToDelete, setDraftToDelete] = useState(null); // Load drafts on component mount and when formType changes const loadDrafts = useCallback(() => { const formDrafts = draftService.getDraftsForForm(formType, formVersion); + setLoadedAt(Date.now()); setDrafts(formDrafts); }, [formType, formVersion]); @@ -83,6 +86,14 @@ export const DraftSelector: React.FC = ({ setDraftToDelete(null); }; + const expiryText = (expiresAt: Date): string => { + const days = Math.ceil((expiresAt.getTime() - loadedAt) / DAY_MS); + if (days <= 1) return t('draft.expiresToday', 'Deleted within a day'); + return t('draft.expiresInDays', 'Deleted in {{count}} days', { + count: days, + }); + }; + const formatDate = (date: Date): string => date.toLocaleString(undefined, { year: 'numeric', @@ -136,6 +147,20 @@ export const DraftSelector: React.FC = ({ date: formatDate(draft.updatedAt), })} + + {[ + draft.isOtherVersion + ? t('draft.otherVersion', 'Different form version') + : null, + expiryText(draft.expiresAt), + ] + .filter(Boolean) + .join(' · ')} + , + draftSessionKey: string | null | undefined, + reason: string, +): void { + try { + draftService.saveDraft( + formInitData.formType, + data, + formInitData, + draftSessionKey, + ); + } catch (error) { + console.warn(`[SwipeLayout] Draft not saved on ${reason}:`, error); + } +} + // --------------------------------------------------------------------------- // Wrapper – manages page state and draft persistence // --------------------------------------------------------------------------- @@ -848,12 +868,11 @@ const SwipeLayoutWrapper = (props: ControlProps) => { (page: number) => { // Save the current form data before changing the page if (data && formInitData && !skipDraftPersistence) { - console.log('Saving draft data on page change:', data); - draftService.saveDraft( - formInitData.formType, - data, + saveDraftWithoutBlocking( formInitData, + data, draftSessionKey, + 'page change', ); } setCurrentPage(page); @@ -865,12 +884,11 @@ const SwipeLayoutWrapper = (props: ControlProps) => { const handleNavigateToPage = (event: CustomEvent) => { // Save the current form data before navigating to a specific page if (data && formInitData && !skipDraftPersistence) { - console.log('Saving draft data before navigation event:', data); - draftService.saveDraft( - formInitData.formType, - data, + saveDraftWithoutBlocking( formInitData, + data, draftSessionKey, + 'navigation event', ); } setCurrentPage(event.detail.page); diff --git a/formulus-formplayer/src/services/DraftService.cleanup.test.ts b/formulus-formplayer/src/services/DraftService.cleanup.test.ts new file mode 100644 index 000000000..aabc3f6b8 --- /dev/null +++ b/formulus-formplayer/src/services/DraftService.cleanup.test.ts @@ -0,0 +1,134 @@ +// @vitest-environment jsdom +import { beforeEach, expect, it, vi } from 'vitest'; + +const DAY = 24 * 60 * 60 * 1000; +const NOW = new Date('2026-11-20T12:00:00.000Z'); +const scoped = (key: string) => `ode:profile-a:formplayer:${key}`; + +beforeEach(() => { + localStorage.clear(); + vi.restoreAllMocks(); + vi.resetModules(); +}); + +async function draftService() { + const { formplayerStorage } = await import('./ProfileStorage'); + formplayerStorage.initialize({ __odeProfileId: 'profile-a' }, localStorage); + return (await import('./DraftService')).draftService; +} + +function legacyBlob(rows: Array<{ id: string; updatedAt: string }>) { + localStorage.setItem( + scoped('formulus_drafts'), + JSON.stringify( + rows.map(row => ({ + id: row.id, + formType: 'household', + data: { name: row.id }, + createdAt: row.updatedAt, + updatedAt: row.updatedAt, + observationId: null, + draftSessionKey: `session-${row.id}`, + })), + ), + ); +} + +const daysAgo = (days: number) => + new Date(NOW.getTime() - days * DAY).toISOString(); + +it('migrates the single drafts blob into one entry per draft', async () => { + legacyBlob([ + { id: 'a', updatedAt: daysAgo(1) }, + { id: 'b', updatedAt: daysAgo(2) }, + ]); + const drafts = await draftService(); + expect(drafts.getTotalDraftCount()).toBe(2); + expect(localStorage.getItem(scoped('formulus_drafts'))).toBeNull(); + expect(localStorage.getItem(scoped('draft_v2:a'))).toContain('"name":"a"'); + expect(drafts.getDraft('b')?.data).toEqual({ name: 'b' }); +}); + +it('rolls a failed migration back so it can retry later', async () => { + legacyBlob([{ id: 'a', updatedAt: daysAgo(1) }]); + const drafts = await draftService(); + const setItem = Storage.prototype.setItem; + const spy = vi + .spyOn(Storage.prototype, 'setItem') + .mockImplementation(function (this: Storage, key, value) { + if (key === scoped('drafts_index_v2')) throw new Error('quota'); + setItem.call(this, key, value); + }); + expect(() => drafts.getTotalDraftCount()).toThrow('quota'); + expect(localStorage.getItem(scoped('formulus_drafts'))).toContain('"a"'); + expect(localStorage.getItem(scoped('draft_v2:a'))).toBeNull(); + spy.mockRestore(); + expect(drafts.getTotalDraftCount()).toBe(1); +}); + +it('removes drafts not edited within the max age, keeping recent ones', async () => { + legacyBlob([ + { id: 'fresh', updatedAt: daysAgo(6) }, + { id: 'stale', updatedAt: daysAgo(8) }, + ]); + const drafts = await draftService(); + expect(drafts.cleanupExpiredDrafts({ now: NOW })).toBe(1); + expect(drafts.getDraft('fresh')).not.toBeNull(); + expect(drafts.getDraft('stale')).toBeNull(); + expect(localStorage.getItem(scoped('draft_v2:stale'))).toBeNull(); +}); + +it('keeps drafts with future or invalid dates and drafts selected by keep', async () => { + legacyBlob([ + { id: 'future', updatedAt: new Date(NOW.getTime() + DAY).toISOString() }, + { id: 'corrupt', updatedAt: 'not a date' }, + { id: 'opening', updatedAt: daysAgo(30) }, + ]); + const drafts = await draftService(); + expect( + drafts.cleanupExpiredDrafts({ + now: NOW, + keep: draft => draft.id === 'opening', + }), + ).toBe(0); + expect(drafts.getTotalDraftCount()).toBe(3); +}); + +it('honours a custom max age and treats non-positive values as disabled', async () => { + legacyBlob([{ id: 'a', updatedAt: daysAgo(3) }]); + const drafts = await draftService(); + expect(drafts.cleanupExpiredDrafts({ now: NOW, maxAgeDays: 0 })).toBe(0); + expect(drafts.cleanupExpiredDrafts({ now: NOW, maxAgeDays: 2 })).toBe(1); +}); + +it('reports when each draft expires, counted from its last edit', async () => { + const drafts = await draftService(); + vi.useFakeTimers(); + vi.setSystemTime(NOW); + drafts.saveDraft('household', { name: 'x' }, undefined, 'session-x'); + vi.useRealTimers(); + const [summary] = drafts.getDraftsForForm('household'); + expect(summary.expiresAt.getTime()).toBe(NOW.getTime() + 7 * DAY); +}); + +it('a draft that cannot be stored does not affect other drafts', async () => { + const drafts = await draftService(); + drafts.saveDraft('household', { name: 'small' }, undefined, 'small'); + const setItem = Storage.prototype.setItem; + vi.spyOn(Storage.prototype, 'setItem').mockImplementation(function ( + this: Storage, + key, + value, + ) { + if (String(value).includes('huge')) throw new Error('quota'); + setItem.call(this, key, value); + }); + expect(() => + drafts.saveDraft('household', { name: 'huge' }, undefined, 'big'), + ).toThrow('quota'); + vi.restoreAllMocks(); + expect(drafts.getTotalDraftCount()).toBe(1); + expect(drafts.getDraftsForForm('household')[0].dataPreview).toContain( + 'small', + ); +}); diff --git a/formulus-formplayer/src/services/DraftService.profileStorage.test.ts b/formulus-formplayer/src/services/DraftService.profileStorage.test.ts index 187de921f..2e2b7b975 100644 --- a/formulus-formplayer/src/services/DraftService.profileStorage.test.ts +++ b/formulus-formplayer/src/services/DraftService.profileStorage.test.ts @@ -136,12 +136,15 @@ it('keeps legacy unversioned drafts discoverable without relabeling on update', expect( draft .getDraftsForForm('household', '2') + .filter(item => !item.isOtherVersion) .map(item => item.id) .sort(), ).toEqual(['legacy', matching].sort()); - expect( - draft.getDraftsForForm('household', '2').map(item => item.id), - ).not.toContain(mismatched); + const listed = draft.getDraftsForForm('household', '2'); + expect(listed.find(item => item.id === mismatched)?.isOtherVersion).toBe( + true, + ); + expect(listed.find(item => item.id === matching)?.isOtherVersion).toBe(false); draft.saveDraft( 'household', { name: 'Resumed' }, diff --git a/formulus-formplayer/src/services/DraftService.ts b/formulus-formplayer/src/services/DraftService.ts index 5549ea8e6..fa230e42e 100644 --- a/formulus-formplayer/src/services/DraftService.ts +++ b/formulus-formplayer/src/services/DraftService.ts @@ -1,14 +1,17 @@ /** - * DraftService.ts - * - * Service for managing form drafts in localStorage. - * Drafts survive profile inactivity until explicitly deleted or successfully submitted. + * Form drafts in profile-scoped localStorage: an index (`drafts_index_v2`) plus + * one entry per draft (`draft_v2:`). The old single `formulus_drafts` array + * is migrated on first access. */ import { FormInitData } from '../types/FormulusInterfaceDefinition'; -import { formplayerStorage } from './ProfileStorage'; +import { formplayerStorage, isQuotaError } from './ProfileStorage'; import { resolveFormSchemaVersion } from '../utils/formSchemaVersion'; +export const DEFAULT_DRAFT_MAX_AGE_DAYS = 7; + +const DAY_MS = 24 * 60 * 60 * 1000; + /** * Interface for a saved draft */ @@ -49,14 +52,66 @@ export interface DraftSummary { /** Preview of form data for display */ dataPreview: string; draftSessionKey?: string | null; + /** Saved with a different form version than the one being opened. */ + isOtherVersion: boolean; + expiresAt: Date; } +export interface DraftCleanupOptions { + maxAgeDays?: number; + now?: Date; + keep?: (draft: DraftMeta) => boolean; +} + +export type DraftMeta = Omit; + +interface StoredMeta { + id: string; + formType: string; + formVersion?: string; + createdAt: string; + updatedAt: string; + observationId?: string | null; + draftSessionKey?: string | null; +} + +interface StoredPayload { + data: Record; + params?: Record; +} + +const toMeta = (stored: StoredMeta): DraftMeta => ({ + ...stored, + createdAt: new Date(stored.createdAt), + updatedAt: new Date(stored.updatedAt), +}); + +const isoOrEmpty = (date: Date): string => + Number.isFinite(date.getTime()) ? date.toISOString() : ''; + +const toStoredMeta = (meta: DraftMeta): StoredMeta => ({ + id: meta.id, + formType: meta.formType, + formVersion: meta.formVersion, + createdAt: isoOrEmpty(meta.createdAt), + updatedAt: isoOrEmpty(meta.updatedAt), + observationId: meta.observationId, + draftSessionKey: meta.draftSessionKey, +}); + +const timeOf = (date: Date): number | null => { + const time = date.getTime(); + return Number.isFinite(time) ? time : null; +}; + /** * Service for managing form drafts */ export class DraftService { private static instance: DraftService; - private readonly STORAGE_KEY = 'formulus_drafts'; + private readonly LEGACY_STORAGE_KEY = 'formulus_drafts'; + private readonly INDEX_KEY = 'drafts_index_v2'; + private readonly ITEM_PREFIX = 'draft_v2:'; private constructor() {} @@ -75,64 +130,126 @@ export class DraftService { */ private generateDraftId( formType: string, - observationId?: string | null, + observationId: string | null | undefined, + existing: DraftMeta[], ): string { const base = observationId ? `${formType}_${observationId}` : formType; - return `draft_${base}_${Date.now()}`; + const id = `draft_${base}_${Date.now()}`; + let unique = id; + for (let n = 1; existing.some(meta => meta.id === unique); n++) { + unique = `${id}_${n}`; + } + return unique; + } + + private itemKey(id: string): string { + return `${this.ITEM_PREFIX}${id}`; + } + + private normalize(meta: DraftMeta): DraftMeta { + if (meta.observationId != null || meta.draftSessionKey) return meta; + return { ...meta, draftSessionKey: `legacy_${meta.id}` }; } /** - * Get all drafts from localStorage + * Migrate the old `formulus_drafts` array. On a quota error the array is + * removed first so two copies never need to fit; any failure restores it. */ - private getAllDrafts(): Draft[] { - try { - const stored = formplayerStorage.getItem(this.STORAGE_KEY); - if (!stored) return []; - - const drafts = JSON.parse(stored) as Draft[]; - const withDates = drafts.map(draft => ({ - ...draft, - createdAt: new Date(draft.createdAt), - updatedAt: new Date(draft.updatedAt), - })); - let migrated = false; - const normalized = withDates.map(draft => { - if (draft.observationId != null) return draft; - if (draft.draftSessionKey) return draft; - migrated = true; - return { ...draft, draftSessionKey: `legacy_${draft.id}` }; - }); - if (migrated) { - try { + private migrateLegacyBlob(): DraftMeta[] | null { + const raw = formplayerStorage.getItem(this.LEGACY_STORAGE_KEY); + if (raw === null) return null; + + const parsed = JSON.parse(raw) as Array; + const rows = Array.isArray(parsed) ? parsed : []; + const metas = rows.map(row => + this.normalize( + toMeta({ + id: row.id, + formType: row.formType, + formVersion: row.formVersion, + createdAt: row.createdAt, + updatedAt: row.updatedAt, + observationId: row.observationId, + draftSessionKey: row.draftSessionKey, + }), + ), + ); + + const writeAll = () => { + const written: string[] = []; + try { + rows.forEach(row => { + const payload: StoredPayload = { data: row.data ?? {} }; + if (row.params !== undefined) payload.params = row.params; formplayerStorage.setItem( - this.STORAGE_KEY, - JSON.stringify(normalized), + this.itemKey(row.id), + JSON.stringify(payload), ); - } catch { - /* ignore */ - } + written.push(row.id); + }); + this.writeIndex(metas); + } catch (error) { + formplayerStorage.removeItem(this.INDEX_KEY); + written.forEach(id => formplayerStorage.removeItem(this.itemKey(id))); + throw error; } - return normalized; + }; + + try { + writeAll(); } catch (error) { - console.error('Error loading drafts from localStorage:', error); - throw error; + if (!isQuotaError(error)) throw error; + formplayerStorage.removeItem(this.LEGACY_STORAGE_KEY); + try { + writeAll(); + } catch (retryError) { + formplayerStorage.setItem(this.LEGACY_STORAGE_KEY, raw); + throw retryError; + } } + formplayerStorage.removeItem(this.LEGACY_STORAGE_KEY); + console.log( + `DraftService: Migrated ${metas.length} draft(s) to v2 storage`, + ); + return metas; } - /** - * Save all drafts to localStorage - */ - private saveAllDrafts(drafts: Draft[]): void { + /** Throws on unreadable storage so a failed read is never taken as "no drafts". */ + private readIndex(): DraftMeta[] { try { - formplayerStorage.setItem(this.STORAGE_KEY, JSON.stringify(drafts)); + const raw = formplayerStorage.getItem(this.INDEX_KEY); + if (raw === null) return this.migrateLegacyBlob() ?? []; + const stored = JSON.parse(raw) as StoredMeta[]; + return (Array.isArray(stored) ? stored : []).map(toMeta); } catch (error) { - console.error('Error saving drafts to localStorage:', error); + console.error('Error loading drafts from localStorage:', error); throw error; } } + private writeIndex(metas: DraftMeta[]): void { + formplayerStorage.setItem( + this.INDEX_KEY, + JSON.stringify(metas.map(toStoredMeta)), + ); + } + + private readPayload(id: string): StoredPayload | null { + const raw = formplayerStorage.getItem(this.itemKey(id)); + if (raw === null) return null; + const parsed = JSON.parse(raw) as StoredPayload; + return { data: parsed?.data ?? {}, params: parsed?.params }; + } + + private removeDrafts(ids: string[]): void { + if (ids.length === 0) return; + const remove = new Set(ids); + this.writeIndex(this.readIndex().filter(meta => !remove.has(meta.id))); + ids.forEach(id => formplayerStorage.removeItem(this.itemKey(id))); + } + private draftMatches( - draft: Draft, + draft: DraftMeta, formType: string, observationId: string | null, draftSessionKey: string | null, @@ -150,7 +267,7 @@ export class DraftService { } /** - * Save or update a draft. + * Save or update a draft. Throws if storage rejects the write. * @param draftSessionKey — Formplayer-only; required when `observationId` is null (pass from App / FormContext). */ public saveDraft( @@ -159,7 +276,7 @@ export class DraftService { formInitData?: FormInitData, draftSessionKey?: string | null, ): string { - const drafts = this.getAllDrafts(); + const metas = this.readIndex(); const now = new Date(); const observationId = formInitData?.observationId ?? null; @@ -173,85 +290,92 @@ export class DraftService { return ''; } - const existingIndex = drafts.findIndex(draft => - this.draftMatches(draft, formType, observationId, sessionKey), + const payload: StoredPayload = { data, params: formInitData?.params }; + const existingIndex = metas.findIndex(meta => + this.draftMatches( + this.normalize(meta), + formType, + observationId, + sessionKey, + ), ); - let draftId: string; - if (existingIndex >= 0) { - const existingDraft = drafts[existingIndex]; - draftId = existingDraft.id; - drafts[existingIndex] = { - ...existingDraft, - data, + const existing = this.normalize(metas[existingIndex]); + formplayerStorage.setItem( + this.itemKey(existing.id), + JSON.stringify(payload), + ); + metas[existingIndex] = { + ...metas[existingIndex], updatedAt: now, - params: formInitData?.params, draftSessionKey: observationId === null - ? (sessionKey ?? existingDraft.draftSessionKey) - : existingDraft.draftSessionKey, + ? (sessionKey ?? existing.draftSessionKey) + : metas[existingIndex].draftSessionKey, }; + this.writeIndex(metas); console.log( - `DraftService: Updated existing draft ${draftId} for ${formType}`, + `DraftService: Updated existing draft ${existing.id} for ${formType}`, ); - } else { - draftId = this.generateDraftId(formType, formInitData?.observationId); - const newDraft: Draft = { - id: draftId, - formType, - formVersion: resolveFormSchemaVersion(formInitData?.formSchema), - data, - createdAt: now, - updatedAt: now, - observationId, - draftSessionKey: observationId === null ? sessionKey : null, - params: formInitData?.params, - }; - drafts.push(newDraft); - console.log(`DraftService: Created new draft ${draftId} for ${formType}`); + return existing.id; } - this.saveAllDrafts(drafts); - + const draftId = this.generateDraftId( + formType, + formInitData?.observationId, + metas, + ); + formplayerStorage.setItem(this.itemKey(draftId), JSON.stringify(payload)); + try { + this.writeIndex([ + ...metas, + { + id: draftId, + formType, + formVersion: resolveFormSchemaVersion(formInitData?.formSchema), + createdAt: now, + updatedAt: now, + observationId, + draftSessionKey: observationId === null ? sessionKey : null, + }, + ]); + } catch (error) { + formplayerStorage.removeItem(this.itemKey(draftId)); + throw error; + } + console.log(`DraftService: Created new draft ${draftId} for ${formType}`); return draftId; } /** - * Get drafts for a specific form type + * Get drafts for a specific form type, most recent first. */ public getDraftsForForm( formType: string, formVersion?: string, + maxAgeDays: number = DEFAULT_DRAFT_MAX_AGE_DAYS, ): DraftSummary[] { - const drafts = this.getAllDrafts(); - const formDrafts = drafts.filter(draft => { - if (draft.formType !== formType) return false; - - // If formVersion is specified, only return drafts with matching version - if ( - formVersion && - draft.formVersion && - draft.formVersion !== formVersion - ) { - return false; - } - - return true; - }); - - // Convert to summaries and sort by most recent first - return formDrafts - .map(draft => ({ - id: draft.id, - formType: draft.formType, - formVersion: draft.formVersion, - createdAt: draft.createdAt, - updatedAt: draft.updatedAt, - observationId: draft.observationId, - dataPreview: this.generateDataPreview(draft.data), - draftSessionKey: draft.draftSessionKey, - })) + return this.readIndex() + .filter(meta => meta.formType === formType) + .map(raw => { + const meta = this.normalize(raw); + const payload = this.readPayload(meta.id); + return { + id: meta.id, + formType: meta.formType, + formVersion: meta.formVersion, + createdAt: meta.createdAt, + updatedAt: meta.updatedAt, + observationId: meta.observationId, + dataPreview: this.generateDataPreview(payload?.data ?? {}), + draftSessionKey: meta.draftSessionKey, + isOtherVersion: Boolean( + formVersion && meta.formVersion && meta.formVersion !== formVersion, + ), + expiresAt: new Date(meta.updatedAt.getTime() + maxAgeDays * DAY_MS), + }; + }) .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()); } @@ -259,25 +383,24 @@ export class DraftService { * Get a specific draft by ID */ public getDraft(draftId: string): Draft | null { - const drafts = this.getAllDrafts(); - return drafts.find(draft => draft.id === draftId) || null; + const meta = this.readIndex().find(draft => draft.id === draftId); + if (!meta) return null; + const payload = this.readPayload(draftId); + return { + ...this.normalize(meta), + data: payload?.data ?? {}, + params: payload?.params, + }; } /** * Delete a specific draft */ public deleteDraft(draftId: string): boolean { - const drafts = this.getAllDrafts(); - const initialLength = drafts.length; - const filteredDrafts = drafts.filter(draft => draft.id !== draftId); - - if (filteredDrafts.length < initialLength) { - this.saveAllDrafts(filteredDrafts); - console.log(`DraftService: Deleted draft ${draftId}`); - return true; - } - - return false; + if (!this.readIndex().some(draft => draft.id === draftId)) return false; + this.removeDrafts([draftId]); + console.log(`DraftService: Deleted draft ${draftId}`); + return true; } /** @@ -287,24 +410,19 @@ export class DraftService { formType: string, observationId: string, ): number { - const drafts = this.getAllDrafts(); - const initialLength = drafts.length; - - const filteredDrafts = drafts.filter( - draft => - !(draft.formType === formType && draft.observationId === observationId), - ); - - const deletedCount = initialLength - filteredDrafts.length; - - if (deletedCount > 0) { - this.saveAllDrafts(filteredDrafts); + const ids = this.readIndex() + .filter( + draft => + draft.formType === formType && draft.observationId === observationId, + ) + .map(draft => draft.id); + this.removeDrafts(ids); + if (ids.length > 0) { console.log( - `DraftService: Deleted ${deletedCount} draft(s) for ${formType} (observationId: ${observationId})`, + `DraftService: Deleted ${ids.length} draft(s) for ${formType} (observationId: ${observationId})`, ); } - - return deletedCount; + return ids.length; } /** @@ -314,24 +432,47 @@ export class DraftService { formType: string, draftSessionKey: string, ): number { - const drafts = this.getAllDrafts(); - const initialLength = drafts.length; - const filteredDrafts = drafts.filter( - draft => - !( + const ids = this.readIndex() + .map(meta => this.normalize(meta)) + .filter( + draft => draft.formType === formType && (draft.observationId === null || draft.observationId === undefined) && - draft.draftSessionKey === draftSessionKey - ), - ); - const deletedCount = initialLength - filteredDrafts.length; - if (deletedCount > 0) { - this.saveAllDrafts(filteredDrafts); + draft.draftSessionKey === draftSessionKey, + ) + .map(draft => draft.id); + this.removeDrafts(ids); + if (ids.length > 0) { console.log( - `DraftService: Deleted ${deletedCount} draft(s) for ${formType} (new observation session)`, + `DraftService: Deleted ${ids.length} draft(s) for ${formType} (new observation session)`, ); } - return deletedCount; + return ids.length; + } + + /** + * Remove drafts not edited for `maxAgeDays`. Drafts with an invalid or future + * date (wrong device clock) are kept. + */ + public cleanupExpiredDrafts(options: DraftCleanupOptions = {}): number { + const maxAgeDays = options.maxAgeDays ?? DEFAULT_DRAFT_MAX_AGE_DAYS; + if (!(maxAgeDays > 0)) return 0; + const now = (options.now ?? new Date()).getTime(); + const cutoff = now - maxAgeDays * DAY_MS; + + const ids = this.readIndex() + .filter(meta => { + const updated = timeOf(meta.updatedAt); + if (updated === null || updated > now) return false; + if (options.keep?.(meta)) return false; + return updated <= cutoff; + }) + .map(meta => meta.id); + this.removeDrafts(ids); + if (ids.length > 0) { + console.log(`DraftService: Removed ${ids.length} expired draft(s)`); + } + return ids.length; } /** @@ -374,14 +515,17 @@ export class DraftService { * Get total number of drafts */ public getTotalDraftCount(): number { - return this.getAllDrafts().length; + return this.readIndex().length; } /** * Clear all drafts (for testing/debugging) */ public clearAllDrafts(): void { - formplayerStorage.removeItem(this.STORAGE_KEY); + const ids = this.readIndex().map(meta => meta.id); + formplayerStorage.removeItem(this.INDEX_KEY); + ids.forEach(id => formplayerStorage.removeItem(this.itemKey(id))); + formplayerStorage.removeItem(this.LEGACY_STORAGE_KEY); console.log('DraftService: Cleared all drafts'); } } diff --git a/formulus-formplayer/src/services/ProfileStorage.test.ts b/formulus-formplayer/src/services/ProfileStorage.test.ts index e1a38ef83..e1d7dc4ab 100644 --- a/formulus-formplayer/src/services/ProfileStorage.test.ts +++ b/formulus-formplayer/src/services/ProfileStorage.test.ts @@ -52,6 +52,8 @@ describe('Formplayer profile storage', () => { expect(a.getItem(drafts)).toBe('["legacy draft"]'); expect(a.getItem(sticky)).toBe('{"legacy":"sticky"}'); expect(a.getItem('legacy-migration-v1')).toBe('1'); + expect(localStorage.getItem(drafts)).toBeNull(); + expect(localStorage.getItem(sticky)).toBeNull(); a.removeItem(drafts); expect(initialize(owner).getItem(drafts)).toBeNull(); }); @@ -104,11 +106,13 @@ describe('Formplayer profile storage', () => { if (key === scoped(owner, sticky)) throw new Error('quota'); setItem.call(this, key, value); }); - expect(() => initialize(owner)).toThrow('quota'); + expect(() => initialize(owner)).not.toThrow(); expect( localStorage.getItem(scoped(owner, 'legacy-migration-v1')), ).toBeNull(); - expect(localStorage.getItem(drafts)).toBe('legacy'); + expect(localStorage.getItem(drafts)).toBeNull(); + expect(localStorage.getItem(scoped(owner, drafts))).toBe('legacy'); + expect(localStorage.getItem(sticky)).toBe('sticky'); vi.restoreAllMocks(); localStorage.setItem(scoped(owner, drafts), 'newer scoped draft'); const a = initialize(owner); @@ -117,6 +121,34 @@ describe('Formplayer profile storage', () => { expect(a.getItem('legacy-migration-v1')).toBe('1'); }); + it('never needs room for two copies of legacy data while moving it', () => { + localStorage.setItem(drafts, 'x'.repeat(10)); + const setItem = Storage.prototype.setItem; + vi.spyOn(Storage.prototype, 'setItem').mockImplementation(function ( + this: Storage, + key, + value, + ) { + if (key === scoped(owner, drafts) && localStorage.getItem(drafts)) { + throw new Error('quota'); + } + setItem.call(this, key, value); + }); + const a = initialize(owner); + expect(a.getItem(drafts)).toBe('x'.repeat(10)); + expect(localStorage.getItem(drafts)).toBeNull(); + }); + + it('still propagates non-quota errors during migration', () => { + localStorage.setItem(drafts, 'legacy'); + vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { + throw new Error('blocked'); + }); + expect(() => initialize(owner)).toThrow('blocked'); + vi.restoreAllMocks(); + expect(localStorage.getItem(drafts)).toBe('legacy'); + }); + it('propagates blocked storage/deletion errors instead of copying legacy data', () => { localStorage.setItem(scoped(owner, drafts), 'deleted'); const remove = vi diff --git a/formulus-formplayer/src/services/ProfileStorage.ts b/formulus-formplayer/src/services/ProfileStorage.ts index 324b506ee..b0bae9133 100644 --- a/formulus-formplayer/src/services/ProfileStorage.ts +++ b/formulus-formplayer/src/services/ProfileStorage.ts @@ -23,6 +23,47 @@ function removePrefix(storage: Storage, prefix: string): void { } } +export function isQuotaError(error: unknown): boolean { + if (!(error instanceof Error)) return false; + const code = (error as { code?: unknown }).code; + return ( + error.name === 'QuotaExceededError' || + error.name === 'NS_ERROR_DOM_QUOTA_REACHED' || + code === 22 || + code === 1014 || + /quota/i.test(error.message) + ); +} + +/** + * Move a legacy key into profile storage. On a quota error the legacy key is + * removed first so two copies never need to fit; it is restored on failure. + */ +function moveLegacyKey( + storage: Storage, + scoped: ProfileLocalStorage, + key: string, +): void { + const legacy = storage.getItem(key); + if (legacy === null) return; + if (scoped.getItem(key) === null) { + try { + scoped.setItem(key, legacy); + } catch (error) { + if (!isQuotaError(error)) throw error; + storage.removeItem(key); + try { + scoped.setItem(key, legacy); + } catch (retryError) { + storage.setItem(key, legacy); + throw retryError; + } + return; + } + } + storage.removeItem(key); +} + export function createNamespacedStorage( profileId: string, namespace: 'app' | 'formplayer', @@ -65,15 +106,16 @@ export class FormplayerProfileStorage implements ProfileLocalStorage { throw new Error('Active profile has been deleted'); const scoped = createNamespacedStorage(id, 'formplayer', storage); if (owner === id && scoped.getItem(migrationMarker) !== '1') { - for (const key of legacyKeys) { - const legacy = storage.getItem(key); - if (legacy !== null && scoped.getItem(key) === null) { - scoped.setItem(key, legacy); - } + try { + for (const key of legacyKeys) moveLegacyKey(storage, scoped, key); + // Last write: interrupted/quota-failed migrations can retry without + // overwriting already scoped data. + scoped.setItem(migrationMarker, '1'); + } catch (error) { + // A full storage must not block opening forms; retried on next open. + if (!isQuotaError(error)) throw error; + console.warn('[ProfileStorage] Legacy migration deferred:', error); } - // Last write: interrupted/quota-failed migrations can retry without overwriting - // already scoped data. Legacy sources remain for designated-owner deletion. - scoped.setItem(migrationMarker, '1'); } this.profileId = id; this.storage = scoped; diff --git a/formulus/src/components/FormplayerModal.tsx b/formulus/src/components/FormplayerModal.tsx index 1f71568be..f64b332a4 100644 --- a/formulus/src/components/FormplayerModal.tsx +++ b/formulus/src/components/FormplayerModal.tsx @@ -238,34 +238,7 @@ const FormplayerModal = forwardRef( ? `file://${commonAncestor(RNFS.MainBundlePath, RNFS.DocumentDirectoryPath)}` : undefined; - // Create a debounced close handler to prevent multiple rapid close attempts - const performClose = useCallback(async () => { - // Prevent multiple close attempts - if (isClosing || isSubmitting) return; - - setIsClosing(true); - // Keep the document mounted until a root draft is durably saved. Nested - // sessions return data only, and successful submits must not recreate drafts. - if (!formSubmitted && currentFormType && !subObservationModeRef.current) { - try { - await flushDraftAsync(); - } catch (error) { - console.error( - 'Cannot close Formplayer before saving its draft:', - error, - ); - setIsClosing(false); - showConfirm({ - title: t('common.error'), - message: t('formplayer.saveFailed'), - buttons: [ - { text: t('common.ok'), variant: 'primary', onPress: () => {} }, - ], - }); - return; - } - } - + const completeClose = useCallback(() => { // Clear any existing timeout if (closeTimeoutRef.current) { clearTimeout(closeTimeoutRef.current); @@ -299,14 +272,56 @@ const FormplayerModal = forwardRef( closeTimeoutRef.current = setTimeout(() => { setIsClosing(false); }, 500); + }, [onClose, currentOperationId, currentFormType, formSubmitted]); + + // Create a debounced close handler to prevent multiple rapid close attempts + const performClose = useCallback(async () => { + // Prevent multiple close attempts + if (isClosing || isSubmitting) return; + + setIsClosing(true); + // Keep the document mounted until a root draft is durably saved. Nested + // sessions return data only, and successful submits must not recreate drafts. + if (!formSubmitted && currentFormType && !subObservationModeRef.current) { + try { + await flushDraftAsync(); + } catch (error) { + console.error( + 'Cannot close Formplayer before saving its draft:', + error, + ); + setIsClosing(false); + showConfirm({ + title: t('formplayer.draftNotSavedTitle'), + message: t('formplayer.draftNotSavedMessage'), + buttons: [ + { + text: t('formplayer.stayInForm'), + variant: 'tertiary', + onPress: () => {}, + }, + { + text: t('formplayer.closeAnyway'), + variant: 'danger', + onPress: () => { + setIsClosing(true); + completeClose(); + }, + }, + ], + }); + return; + } + } + + completeClose(); }, [ isClosing, isSubmitting, - onClose, - currentOperationId, currentFormType, formSubmitted, flushDraftAsync, + completeClose, showConfirm, t, ]); diff --git a/formulus/src/locales/en.json b/formulus/src/locales/en.json index d12013c7c..ee01c33d7 100644 --- a/formulus/src/locales/en.json +++ b/formulus/src/locales/en.json @@ -278,6 +278,10 @@ "formplayer.submitSuccessUpdated": "Observation updated successfully!", "formplayer.submitSuccessSubmitted": "Form submitted successfully!", "formplayer.saveFailed": "Failed to save your form. Please try again.", + "formplayer.draftNotSavedTitle": "Draft not saved", + "formplayer.draftNotSavedMessage": "This form's changes could not be saved as a draft, usually because the device storage is full. If you close now, they will be lost.", + "formplayer.stayInForm": "Stay in form", + "formplayer.closeAnyway": "Close anyway", "observations.notFound": "Observation not found", "observations.loadFailed": "Failed to load observation", "observations.updateSuccess": "Observation updated successfully", diff --git a/formulus/src/locales/fr.json b/formulus/src/locales/fr.json index 6a3e1f37b..52fc8fb34 100644 --- a/formulus/src/locales/fr.json +++ b/formulus/src/locales/fr.json @@ -278,6 +278,10 @@ "formplayer.submitSuccessUpdated": "Observation mise à jour avec succès !", "formplayer.submitSuccessSubmitted": "Formulaire envoyé avec succès !", "formplayer.saveFailed": "Impossible d'enregistrer le formulaire. Veuillez réessayer.", + "formplayer.draftNotSavedTitle": "Brouillon non enregistré", + "formplayer.draftNotSavedMessage": "Les modifications de ce formulaire n'ont pas pu être enregistrées comme brouillon, généralement parce que le stockage de l'appareil est plein. Si vous fermez maintenant, elles seront perdues.", + "formplayer.stayInForm": "Rester dans le formulaire", + "formplayer.closeAnyway": "Fermer quand même", "observations.notFound": "Observation introuvable", "observations.loadFailed": "Impossible de charger l'observation", "observations.updateSuccess": "Observation mise à jour avec succès", diff --git a/formulus/src/locales/pt.json b/formulus/src/locales/pt.json index a64ca54cb..6851d658b 100644 --- a/formulus/src/locales/pt.json +++ b/formulus/src/locales/pt.json @@ -278,6 +278,10 @@ "formplayer.submitSuccessUpdated": "Observação atualizada com sucesso!", "formplayer.submitSuccessSubmitted": "Formulário enviado com sucesso!", "formplayer.saveFailed": "Não foi possível guardar o formulário. Tente novamente.", + "formplayer.draftNotSavedTitle": "Rascunho não guardado", + "formplayer.draftNotSavedMessage": "Não foi possível guardar as alterações deste formulário como rascunho, normalmente porque o armazenamento do dispositivo está cheio. Se fechar agora, serão perdidas.", + "formplayer.stayInForm": "Permanecer no formulário", + "formplayer.closeAnyway": "Fechar mesmo assim", "observations.notFound": "Observação não encontrada", "observations.loadFailed": "Não foi possível carregar a observação", "observations.updateSuccess": "Observação atualizada com sucesso", diff --git a/formulus/src/locales/sw.json b/formulus/src/locales/sw.json index 7fd2228dd..d969c9006 100644 --- a/formulus/src/locales/sw.json +++ b/formulus/src/locales/sw.json @@ -277,6 +277,10 @@ "formplayer.submitSuccessUpdated": "Rekodi imesasishwa!", "formplayer.submitSuccessSubmitted": "Fomu imewasilishwa!", "formplayer.saveFailed": "Imeshindwa kuhifadhi fomu yako. Tafadhali jaribu tena.", + "formplayer.draftNotSavedTitle": "Rasimu haijahifadhiwa", + "formplayer.draftNotSavedMessage": "Mabadiliko ya fomu hii hayakuweza kuhifadhiwa kama rasimu, kwa kawaida kwa sababu hifadhi ya kifaa imejaa. Ukifunga sasa, yatapotea.", + "formplayer.stayInForm": "Baki kwenye fomu", + "formplayer.closeAnyway": "Funga hata hivyo", "observations.notFound": "Rekodi haijapatikana", "observations.loadFailed": "Imeshindwa kupakia rekodi", "observations.updateSuccess": "Rekodi imesasishwa",