Files
accounted/lib/hooks/use-submit-with-account-activation.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

128 lines
4.3 KiB
TypeScript

'use client'
import { useCallback, useState } from 'react'
/**
* Wraps an async submit function so that responses of the form
* `{ error: { code: 'ACCOUNTS_NOT_IN_CHART', account_numbers } }` trigger a
* dialog-and-retry flow instead of surfacing as a generic error.
*
* The consumer renders <ActivateAccountsDialog> bound to `dialog.open`,
* `dialog.accountNumbers`, `confirm`, and `cancel`. On confirm the missing
* accounts are activated and the original submit runs again automatically.
*
* The submit fn should throw with a cause object containing the parsed
* response body so we can read the structured error. Convention:
* throw Object.assign(new Error(body.error.message), { body, status })
*/
interface DialogState {
open: boolean
accountNumbers: string[]
}
interface StructuredError {
code?: string
account_numbers?: string[]
message?: string
}
function extractAccountsNotInChart(err: unknown): string[] | null {
if (typeof err !== 'object' || err === null) return null
const anyErr = err as { body?: { error?: StructuredError } }
const structured = anyErr.body?.error
if (structured?.code === 'ACCOUNTS_NOT_IN_CHART' && Array.isArray(structured.account_numbers)) {
return structured.account_numbers
}
return null
}
export function useSubmitWithAccountActivation<T>(
submit: () => Promise<T>
) {
const [dialog, setDialog] = useState<DialogState>({ open: false, accountNumbers: [] })
const [pendingResolve, setPendingResolve] = useState<null | ((value: T | null) => void)>(null)
const [pendingReject, setPendingReject] = useState<null | ((err: unknown) => void)>(null)
const runSubmit = useCallback(async (): Promise<T> => {
try {
return await submit()
} catch (err) {
const missing = extractAccountsNotInChart(err)
if (!missing) throw err
// Open dialog and wait for the user to confirm or cancel.
return new Promise<T>((resolve, reject) => {
setPendingResolve(() => (value: T | null) => {
if (value === null) reject(new Error('cancelled'))
else resolve(value)
})
setPendingReject(() => reject)
setDialog({ open: true, accountNumbers: missing })
})
}
}, [submit])
const confirm = useCallback(async () => {
const numbers = dialog.accountNumbers
try {
const res = await fetch('/api/bookkeeping/accounts/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ account_numbers: numbers }),
})
const body = await res.json().catch(() => ({}))
if (!res.ok) {
throw Object.assign(new Error('Kunde inte aktivera konton'), { body, status: res.status })
}
// Retry the original submit
const result = await submit()
setDialog({ open: false, accountNumbers: [] })
pendingResolve?.(result as T | null)
setPendingResolve(null)
setPendingReject(null)
} catch (err) {
setDialog({ open: false, accountNumbers: [] })
pendingReject?.(err)
setPendingResolve(null)
setPendingReject(null)
}
}, [dialog.accountNumbers, submit, pendingResolve, pendingReject])
const cancel = useCallback(() => {
setDialog({ open: false, accountNumbers: [] })
pendingReject?.(new Error('cancelled'))
setPendingResolve(null)
setPendingReject(null)
}, [pendingReject])
return { runSubmit, dialog, confirm, cancel }
}
/**
* Small helper: parse a Response and throw a shaped error that
* useSubmitWithAccountActivation can recognize. Callers use this inside
* their submit fn so the hook can pick up ACCOUNTS_NOT_IN_CHART.
*/
export async function throwOnStructuredError(response: Response): Promise<unknown> {
const body = await response.json().catch(() => ({}))
if (!response.ok) {
throw Object.assign(new Error(extractMessage(body) || `HTTP ${response.status}`), {
body,
status: response.status,
})
}
return body
}
function extractMessage(body: unknown): string | null {
if (typeof body !== 'object' || body === null) return null
const obj = body as { error?: unknown }
if (typeof obj.error === 'string') return obj.error
if (typeof obj.error === 'object' && obj.error !== null) {
const e = obj.error as { message?: unknown }
if (typeof e.message === 'string') return e.message
}
return null
}