Александр Зимин
460 lines
16 KiB
TypeScript
460 lines
16 KiB
TypeScript
import { useCallback, useRef } from 'react'
|
||
import { useMutation, useQueryClient } from '@tanstack/react-query'
|
||
import {
|
||
apiClient,
|
||
type BulkCloseRequest,
|
||
type BulkCloseResponse,
|
||
type CascadeCloseResult,
|
||
type CreateDictionaryRequest,
|
||
type CreateRecordRequest,
|
||
type CreateWebhookSubscriptionRequest,
|
||
type DictionaryDetail,
|
||
type DraftResponse,
|
||
type RecordResponse,
|
||
type SubmitDraftRequest,
|
||
type WebhookDelivery,
|
||
type WebhookSubscription,
|
||
type WebhookTestPingResult,
|
||
} from './client'
|
||
|
||
/**
|
||
* Generate UUID v4 (или fallback). Раньше вызывался **per mutate** в каждой
|
||
* useCreateRecord/useUpdateRecord — двойной submit формы (Enter + click) давал
|
||
* два разных ключа → server создавал два состояния вместо идемпотентного
|
||
* deduping. Теперь caller генерирует ключ один раз на форму через
|
||
* {@link useFormIdempotencyKey} и передаёт его mutation'у.
|
||
*/
|
||
export const generateIdempotencyKey = (): string =>
|
||
typeof crypto !== 'undefined' && 'randomUUID' in crypto
|
||
? crypto.randomUUID()
|
||
: `${Date.now()}-${Math.random().toString(36).slice(2)}`
|
||
|
||
/**
|
||
* Stable idempotency key для жизненного цикла одной формы.
|
||
*
|
||
* <p>Возвращает {@code [key, reset]}. {@code key} стабилен между ререндерами;
|
||
* {@code reset()} генерирует новый — вызывается на onSuccess чтобы следующая
|
||
* форма (например, edit того же record после save) получила свежий ключ.
|
||
*
|
||
* <p>Защита от двойного submit (Enter + click за одну сессию формы): оба
|
||
* запроса несут один и тот же {@code Idempotency-Key} → backend deduplicate'ит
|
||
* на втором.
|
||
*
|
||
* <p><b>Usage:</b>
|
||
* <pre>{@code
|
||
* const [idempotencyKey, resetIdempotencyKey] = useFormIdempotencyKey()
|
||
* const createMut = useCreateRecord(name)
|
||
* // submit:
|
||
* createMut.mutate(
|
||
* { payload: req, idempotencyKey },
|
||
* { onSuccess: () => { resetIdempotencyKey(); closeModal() } },
|
||
* )
|
||
* }</pre>
|
||
*/
|
||
export const useFormIdempotencyKey = (): [string, () => void] => {
|
||
const ref = useRef<string | null>(null)
|
||
if (ref.current === null) ref.current = generateIdempotencyKey()
|
||
const reset = useCallback(() => {
|
||
ref.current = generateIdempotencyKey()
|
||
}, [])
|
||
return [ref.current, reset]
|
||
}
|
||
|
||
export const useCreateDictionary = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (req: CreateDictionaryRequest): Promise<DictionaryDetail> => {
|
||
const { data } = await apiClient.post<DictionaryDetail>('/dictionaries', req)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['dictionaries'] })
|
||
},
|
||
})
|
||
}
|
||
|
||
export const useUpdateDictionary = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
name: string
|
||
payload: CreateDictionaryRequest
|
||
}): Promise<DictionaryDetail> => {
|
||
const { data } = await apiClient.put<DictionaryDetail>(
|
||
`/dictionaries/${params.name}`,
|
||
params.payload,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: (_, params) => {
|
||
qc.invalidateQueries({ queryKey: ['dictionaries'] })
|
||
qc.invalidateQueries({ queryKey: ['dictionary', params.name] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Create-record mutation. {@code idempotencyKey} — required, передаётся caller'ом
|
||
* (один на жизнь формы; см. {@link useFormIdempotencyKey}). Это защищает от
|
||
* двойного submit (Enter + click): backend deduplicate'ит по тому же ключу.
|
||
*/
|
||
export const useCreateRecord = (dictionaryName: string) => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
payload: CreateRecordRequest
|
||
idempotencyKey: string
|
||
}): Promise<RecordResponse> => {
|
||
const { data } = await apiClient.post<RecordResponse>(
|
||
`/dictionaries/${dictionaryName}/records`,
|
||
params.payload,
|
||
{ headers: { 'Idempotency-Key': params.idempotencyKey } },
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['records', dictionaryName] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Update-record mutation. См. {@link useCreateRecord} для idempotency rationale.
|
||
*/
|
||
export const useUpdateRecord = (dictionaryName: string) => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
businessKey: string
|
||
payload: CreateRecordRequest
|
||
idempotencyKey: string
|
||
}): Promise<RecordResponse> => {
|
||
const { data } = await apiClient.put<RecordResponse>(
|
||
`/dictionaries/${dictionaryName}/records/${encodeURIComponent(params.businessKey)}`,
|
||
params.payload,
|
||
{ headers: { 'Idempotency-Key': params.idempotencyKey } },
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['records', dictionaryName] })
|
||
},
|
||
})
|
||
}
|
||
|
||
export const useCloseRecord = (dictionaryName: string) => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: { businessKey: string; reason?: string }): Promise<void> => {
|
||
await apiClient.delete(
|
||
`/dictionaries/${dictionaryName}/records/${encodeURIComponent(params.businessKey)}`,
|
||
{ params: params.reason ? { reason: params.reason } : undefined },
|
||
)
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['records', dictionaryName] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Cascade close — Phase 3 dict-relationships-v2. Атомарно закрывает target +
|
||
* все CASCADE dependents в одной transaction. UI должен сначала вызвать
|
||
* `cascade-preview` query, показать confirmation, и только потом запускать
|
||
* этот мутатор с `confirmed=true`.
|
||
*
|
||
* <p>Backend errors:
|
||
* <ul>
|
||
* <li>409 x_references_blocked_by_dependents — есть BLOCK deps. UI отображает
|
||
* список и просит resolve.</li>
|
||
* <li>409 x_references_cascade_required — confirmed=false при наличии cascade.</li>
|
||
* <li>503 x_references_cascade_timeout — tx timeout (>30s). User retry'ит.</li>
|
||
* </ul>
|
||
*/
|
||
export const useCascadeCloseRecord = (dictionaryName: string) => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
businessKey: string
|
||
reason?: string
|
||
confirmed: boolean
|
||
}): Promise<CascadeCloseResult> => {
|
||
const queryParams: Record<string, string | boolean> = {
|
||
confirmed: params.confirmed,
|
||
}
|
||
if (params.reason) queryParams.reason = params.reason
|
||
const { data } = await apiClient.post<CascadeCloseResult>(
|
||
`/dictionaries/${dictionaryName}/records/${encodeURIComponent(params.businessKey)}/cascade-close`,
|
||
null,
|
||
{ params: queryParams },
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
// Invalidate всё что может быть affected: records list + dependents
|
||
// queries (target и cascaded sources меняют состояние).
|
||
qc.invalidateQueries({ queryKey: ['records', dictionaryName] })
|
||
qc.invalidateQueries({ queryKey: ['record-dependents'] })
|
||
qc.invalidateQueries({ queryKey: ['records'] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Bulk close: закрыть N records одним запросом. Backend per-record транзакция,
|
||
* partial success возможен (already_closed / not_found попадает в skipped).
|
||
*/
|
||
export const useBulkCloseRecords = (dictionaryName: string) => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (req: BulkCloseRequest): Promise<BulkCloseResponse> => {
|
||
const { data } = await apiClient.post<BulkCloseResponse>(
|
||
`/dictionaries/${dictionaryName}/records/bulk-close`,
|
||
req,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['records', dictionaryName] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Bulk export selected: выгрузить N выбранных записей в CSV. Backend
|
||
* возвращает text/csv blob с auth header, фронтенд триггерит download
|
||
* через temporary `<a>` link.
|
||
*
|
||
* POST (не GET): >100 ключей не помещается в URL params.
|
||
*/
|
||
export const useBulkExportRecords = (dictionaryName: string) => {
|
||
return useMutation({
|
||
mutationFn: async (businessKeys: string[]): Promise<void> => {
|
||
const response = await apiClient.post(
|
||
`/dictionaries/${dictionaryName}/records/export-selected.csv`,
|
||
{ businessKeys },
|
||
{ responseType: 'blob' },
|
||
)
|
||
// Извлекаем filename из Content-Disposition если есть
|
||
const cd = response.headers['content-disposition'] as string | undefined
|
||
const match = cd?.match(/filename="?([^";]+)"?/)
|
||
const filename = match?.[1]
|
||
?? `${dictionaryName}-selected-${new Date().toISOString().slice(0, 10)}.csv`
|
||
|
||
// Trigger browser download через blob URL + temporary <a download>
|
||
const url = window.URL.createObjectURL(response.data as Blob)
|
||
const link = document.createElement('a')
|
||
link.href = url
|
||
link.download = filename
|
||
document.body.appendChild(link)
|
||
link.click()
|
||
document.body.removeChild(link)
|
||
// Через rAF чтобы download успел запуститься до revoke
|
||
requestAnimationFrame(() => window.URL.revokeObjectURL(url))
|
||
},
|
||
})
|
||
}
|
||
|
||
// === Webhooks (v2) ===
|
||
|
||
export const useCreateWebhook = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (req: CreateWebhookSubscriptionRequest): Promise<WebhookSubscription> => {
|
||
const { data } = await apiClient.post<WebhookSubscription>(
|
||
'/admin/webhooks/subscriptions',
|
||
req,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'subscriptions'] })
|
||
},
|
||
})
|
||
}
|
||
|
||
export const useUpdateWebhook = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
id: string
|
||
payload: CreateWebhookSubscriptionRequest
|
||
}): Promise<WebhookSubscription> => {
|
||
const { data } = await apiClient.put<WebhookSubscription>(
|
||
`/admin/webhooks/subscriptions/${encodeURIComponent(params.id)}`,
|
||
params.payload,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: (_data, vars) => {
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'subscriptions'] })
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'subscriptions', vars.id] })
|
||
},
|
||
})
|
||
}
|
||
|
||
export const useDeleteWebhook = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (id: string): Promise<void> => {
|
||
await apiClient.delete(`/admin/webhooks/subscriptions/${encodeURIComponent(id)}`)
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'subscriptions'] })
|
||
},
|
||
})
|
||
}
|
||
|
||
export const useRotateWebhookSecret = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (id: string): Promise<WebhookSubscription> => {
|
||
const { data } = await apiClient.post<WebhookSubscription>(
|
||
`/admin/webhooks/subscriptions/${encodeURIComponent(id)}/rotate-secret`,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: (_data, id) => {
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'subscriptions'] })
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'subscriptions', id] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Test ping — receiver получает synthetic event с тем же HMAC и headers
|
||
* что у production delivery. Возвращает result sync для inline feedback.
|
||
*
|
||
* Use case: после создания subscription / rotate secret — verify что
|
||
* receiver достижим, валидирует HMAC, не возвращает 5xx.
|
||
*/
|
||
export const useTestWebhook = () => {
|
||
return useMutation({
|
||
mutationFn: async (id: string): Promise<WebhookTestPingResult> => {
|
||
const { data } = await apiClient.post<WebhookTestPingResult>(
|
||
`/admin/webhooks/subscriptions/${encodeURIComponent(id)}/test`,
|
||
)
|
||
return data
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Replay delivery из DLQ или retrying — backend сбрасывает attemptCount=0,
|
||
* dlqAt=null, status=retrying. Dispatcher подхватит на следующем sendTick.
|
||
*
|
||
* Use case: оператор fixed receiver URL/cert, хочет replay'нуть failed
|
||
* delivery без ожидания TTL bypass'а.
|
||
*/
|
||
// === Approval Workflow v2 mutations ===
|
||
|
||
/**
|
||
* Maker submits a proposal. Backend creates draft с status=PENDING.
|
||
* 409 draft_already_pending если уже есть pending draft на этот business_key.
|
||
*/
|
||
export const useSubmitDraft = (dictionaryName: string) => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (req: SubmitDraftRequest): Promise<DraftResponse> => {
|
||
const { data } = await apiClient.post<DraftResponse>(
|
||
`/dictionaries/${encodeURIComponent(dictionaryName)}/records/drafts`,
|
||
req,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['review-queue'] })
|
||
qc.invalidateQueries({ queryKey: ['records', dictionaryName] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Reviewer approves pending draft. SERIALIZABLE tx → COPY draft → live +
|
||
* outbox event. 409 draft_not_pending / self_approve_forbidden если что-то
|
||
* не так.
|
||
*/
|
||
export const useApproveDraft = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
id: string
|
||
comment?: string
|
||
}): Promise<DraftResponse> => {
|
||
const { data } = await apiClient.post<DraftResponse>(
|
||
`/drafts/${encodeURIComponent(params.id)}/approve`,
|
||
null,
|
||
{ params: params.comment ? { comment: params.comment } : undefined },
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['review-queue'] })
|
||
qc.invalidateQueries({ queryKey: ['records'] })
|
||
qc.invalidateQueries({ queryKey: ['draft'] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Reviewer rejects pending draft. Reason required (compliance, D4=A
|
||
* soft-archive). 400 reject_reason_required если reason пустой.
|
||
*/
|
||
export const useRejectDraft = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (params: {
|
||
id: string
|
||
comment: string
|
||
}): Promise<DraftResponse> => {
|
||
const { data } = await apiClient.post<DraftResponse>(
|
||
`/drafts/${encodeURIComponent(params.id)}/reject`,
|
||
null,
|
||
{ params: { comment: params.comment } },
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['review-queue'] })
|
||
qc.invalidateQueries({ queryKey: ['draft'] })
|
||
},
|
||
})
|
||
}
|
||
|
||
/** Maker отзывает свой pending draft. 403 not_draft_maker если не maker. */
|
||
export const useWithdrawDraft = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (id: string): Promise<DraftResponse> => {
|
||
const { data } = await apiClient.delete<DraftResponse>(
|
||
`/drafts/${encodeURIComponent(id)}`,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
qc.invalidateQueries({ queryKey: ['review-queue'] })
|
||
qc.invalidateQueries({ queryKey: ['draft'] })
|
||
qc.invalidateQueries({ queryKey: ['drafts'] }) // /me + by-dict
|
||
},
|
||
})
|
||
}
|
||
|
||
export const useRetryWebhookDelivery = () => {
|
||
const qc = useQueryClient()
|
||
return useMutation({
|
||
mutationFn: async (deliveryId: number): Promise<WebhookDelivery> => {
|
||
const { data } = await apiClient.post<WebhookDelivery>(
|
||
`/admin/webhooks/deliveries/${deliveryId}/retry`,
|
||
)
|
||
return data
|
||
},
|
||
onSuccess: () => {
|
||
// Invalidate всё что показывает delivery rows: detail page deliveries,
|
||
// global DLQ list. Cheaper чем targeted invalidation т.к. delivery
|
||
// counts маленькие.
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'deliveries'] })
|
||
qc.invalidateQueries({ queryKey: ['webhooks', 'dlq'] })
|
||
},
|
||
})
|
||
}
|