feat(app): editor store, undo, recovery copy and geometry accept rules
This commit is contained in:
1 parent
f7e7bf4ee1
commit
7f1d44065b
20 files changed
+2538
-5
No files matched your search
@@ -0,0 +1,184 @@
|
||||
import {
|
||||
SheetFailure,
|
||||
classifySheetError,
|
||||
getOfficialSheetAdmin,
|
||||
parseSaveAnswer,
|
||||
saveSheetDraft,
|
||||
submitSheetReview,
|
||||
type FaunosteoClient,
|
||||
type OfficialSheetAdmin,
|
||||
type SheetFailureKind,
|
||||
} from '@faunosteo/supabase'
|
||||
import { getSupabaseClient } from '@/lib/supabase'
|
||||
import { sameDocument } from '../core/sameDocument'
|
||||
import { blockKind } from './editorBase'
|
||||
import type {
|
||||
BlockKind,
|
||||
Blocked,
|
||||
ConfirmOption,
|
||||
ConflictState,
|
||||
EditorState,
|
||||
SaveOutcome,
|
||||
ServerRefusal,
|
||||
StoreApi,
|
||||
SubmitOutcome,
|
||||
} from './editorTypes'
|
||||
import { removeCopy } from './recovery'
|
||||
|
||||
function blocked(kind: BlockKind): Blocked {
|
||||
return { ok: false, reason: 'blocked', kind }
|
||||
}
|
||||
|
||||
function requireClient(): FaunosteoClient {
|
||||
const client = getSupabaseClient()
|
||||
if (!client) throw new SheetFailure('unavailable')
|
||||
return client
|
||||
}
|
||||
|
||||
function server(error: unknown): ServerRefusal {
|
||||
return { ok: false, reason: 'server', kind: classifySheetError(error) }
|
||||
}
|
||||
|
||||
/** The page's view of the server draft after a `draft_conflict` (plan, C29). */
|
||||
function conflictFrom(admin: OfficialSheetAdmin, state: EditorState): ConflictState {
|
||||
const draft = admin.draft_version
|
||||
if (!draft || draft.version_id !== state.versionId) return { status: 'unknown' }
|
||||
const last = admin.draft_last_save
|
||||
if (!last || last.revision !== draft.revision) {
|
||||
return { status: 'known', revision: draft.revision, lastSave: null }
|
||||
}
|
||||
const byCaller = last.saved_by !== null && last.saved_by.user_id === state.userId
|
||||
const lastSave = { savedAt: last.saved_at, savedBy: last.saved_by, byCaller }
|
||||
return { status: 'known', revision: draft.revision, lastSave }
|
||||
}
|
||||
|
||||
/** Reads the conflict; a failed read or an unparsable answer is the `unknown` variant. */
|
||||
export async function readConflict(api: StoreApi, session: number): Promise<void> {
|
||||
const state = api.get()
|
||||
api.set({ conflict: { status: 'reading' } })
|
||||
let next: ConflictState
|
||||
try {
|
||||
const admin = await getOfficialSheetAdmin(requireClient(), state.sheetId ?? '')
|
||||
next = conflictFrom(admin, state)
|
||||
} catch {
|
||||
next = { status: 'unknown' }
|
||||
}
|
||||
if (api.get().session === session) api.set({ conflict: next })
|
||||
}
|
||||
|
||||
interface Attempt {
|
||||
session: number
|
||||
sentText: string
|
||||
expected: number
|
||||
}
|
||||
|
||||
function applySaved(api: StoreApi, attempt: Attempt, revision: number): SaveOutcome {
|
||||
const state = api.get()
|
||||
if (state.session !== attempt.session) return blocked('session_changed')
|
||||
const unsaved = !sameDocument(state.documentText, attempt.sentText)
|
||||
if (!unsaved) removeCopy(state.userId ?? '', state.versionId ?? '')
|
||||
api.set({
|
||||
saving: false,
|
||||
savedText: attempt.sentText,
|
||||
savedRevision: revision,
|
||||
staleBase: false,
|
||||
unsaved,
|
||||
conflict: null,
|
||||
saveFailure: null,
|
||||
...(unsaved ? {} : { copyWritten: false, copyIssue: null }),
|
||||
})
|
||||
return { ok: true, revision }
|
||||
}
|
||||
|
||||
async function failedSave(
|
||||
api: StoreApi,
|
||||
attempt: Attempt,
|
||||
error: unknown,
|
||||
): Promise<SaveOutcome> {
|
||||
if (api.get().session !== attempt.session) return blocked('session_changed')
|
||||
const kind: SheetFailureKind = classifySheetError(error)
|
||||
// Unchanged content: the saved pair is what was sent, at the revision it was sent against.
|
||||
if (kind === 'draft.unchanged') return applySaved(api, attempt, attempt.expected)
|
||||
api.set({ saving: false, saveFailure: kind })
|
||||
if (kind === 'draft_conflict') await readConflict(api, attempt.session)
|
||||
return { ok: false, reason: 'server', kind }
|
||||
}
|
||||
|
||||
function saveBlock(state: EditorState): BlockKind | null {
|
||||
if (state.saving || state.submitting) return 'busy'
|
||||
return blockKind(state)
|
||||
}
|
||||
|
||||
/** Sends `documentText` as of now; commits made while it is in flight stay unsaved. */
|
||||
async function saveWith(api: StoreApi, expected: number): Promise<SaveOutcome> {
|
||||
const state = api.get()
|
||||
const block = saveBlock(state)
|
||||
if (block) return blocked(block)
|
||||
const attempt = { session: state.session, sentText: state.documentText, expected }
|
||||
api.set({ saving: true, saveFailure: null })
|
||||
try {
|
||||
const args = {
|
||||
version_id: state.versionId ?? '',
|
||||
expected_revision: expected,
|
||||
document: JSON.parse(attempt.sentText),
|
||||
}
|
||||
const answer = parseSaveAnswer(await saveSheetDraft(requireClient(), args))
|
||||
return applySaved(api, attempt, answer.revision)
|
||||
} catch (error) {
|
||||
return failedSave(api, attempt, error)
|
||||
}
|
||||
}
|
||||
|
||||
export function save(api: StoreApi): Promise<SaveOutcome> {
|
||||
return saveWith(api, api.get().savedRevision)
|
||||
}
|
||||
|
||||
/** « Garder ma version » (confirmed): saves against N, the server decides at write time. */
|
||||
export async function keepMine(
|
||||
api: StoreApi,
|
||||
{ confirmed }: ConfirmOption,
|
||||
): Promise<SaveOutcome> {
|
||||
const { conflict } = api.get()
|
||||
if (conflict?.status !== 'known') return blocked('revision_unknown')
|
||||
if (!confirmed) return blocked('confirmation_required')
|
||||
return saveWith(api, conflict.revision)
|
||||
}
|
||||
|
||||
/** Never re-submits by itself: a `draft_conflict` opens the conflict read only. */
|
||||
export async function submit(api: StoreApi, note?: string): Promise<SubmitOutcome> {
|
||||
const state = api.get()
|
||||
const block = saveBlock(state)
|
||||
if (block) return blocked(block)
|
||||
if (state.staleBase) return blocked('stale_base')
|
||||
api.set({ submitting: true })
|
||||
try {
|
||||
const args = {
|
||||
version_id: state.versionId ?? '',
|
||||
expected_revision: state.savedRevision,
|
||||
...(note ? { note } : {}),
|
||||
}
|
||||
const reviewId = await submitSheetReview(requireClient(), args)
|
||||
if (api.get().session !== state.session) return blocked('session_changed')
|
||||
api.set({ submitting: false })
|
||||
return { ok: true, reviewId }
|
||||
} catch (error) {
|
||||
return failedSubmit(api, state.session, error)
|
||||
}
|
||||
}
|
||||
|
||||
async function failedSubmit(
|
||||
api: StoreApi,
|
||||
session: number,
|
||||
error: unknown,
|
||||
): Promise<SubmitOutcome> {
|
||||
if (api.get().session !== session) return blocked('session_changed')
|
||||
api.set({ submitting: false })
|
||||
const refusal = server(error)
|
||||
if (refusal.kind === 'draft_conflict') await readConflict(api, session)
|
||||
return refusal
|
||||
}
|
||||
|
||||
export async function retryConflictRead(api: StoreApi): Promise<void> {
|
||||
const { conflict, session } = api.get()
|
||||
if (conflict && conflict.status !== 'reading') await readConflict(api, session)
|
||||
}
|
||||
Reference in new issue
Block a user