Files
accounted/lib/transactions/bank-sync-store.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

126 lines
4.1 KiB
TypeScript

/**
* Module-level store for on-demand bank sync state, shared by every
* `useBankSync()` instance via `useSyncExternalStore`.
*
* Two surfaces on the transactions page trigger syncs independently: the
* "Synka bank nu" row in the Importera split button (TransactionStatusBar)
* and the footer "Synka nu" button (BankSyncNowButton). With hook-local
* state, a sync started from one surface left the other enabled and
* spinner-less, so a second concurrent sync of the same connection could be
* started (#1162). Hoisting the state here makes busy/connections identical
* across all instances, and lets the first mounted instance's fetch serve
* the rest (no duplicate `bank_connections` query per surface).
*
* Pure state + pub/sub only: the Supabase fetch stays in the hook so this
* module is trivially unit-testable.
*/
export interface BankConn {
id: string
bank_name: string
status: string
provider: string
last_synced_at: string | null
}
export interface BankSyncState {
/** null until the first load for `companyId` has completed */
connections: BankConn[] | null
/** company the loaded connections belong to */
companyId: string | null
/** id of the connection currently syncing or reconnecting */
busyId: string | null
/** true across a whole "sync everything" run, including between connections */
syncingAll: boolean
}
const INITIAL_STATE: BankSyncState = {
connections: null,
companyId: null,
busyId: null,
syncingAll: false,
}
let state: BankSyncState = INITIAL_STATE
let loadingCompanyId: string | null = null
const listeners = new Set<() => void>()
function emit(next: BankSyncState): void {
state = next
for (const listener of listeners) listener()
}
export function subscribeBankSync(listener: () => void): () => void {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
}
/** Stable-identity snapshot: only replaced when something actually changed. */
export function getBankSyncSnapshot(): BankSyncState {
return state
}
/**
* Claim the connections fetch for a company. Returns true when the caller
* should run the query (first instance to mount, or a retry after a failed
* load); false when the list is already loaded for that company or another
* instance's fetch is in flight.
*/
export function claimConnectionsLoad(companyId: string): boolean {
if (state.companyId === companyId && state.connections !== null) return false
if (loadingCompanyId === companyId) return false
loadingCompanyId = companyId
return true
}
export function publishConnections(companyId: string, connections: BankConn[]): void {
// Only the fetch that still owns the load claim may publish. A resolve
// arriving after the active company switched (and re-claimed the slot)
// would otherwise clobber the newer company's list with stale data.
if (loadingCompanyId !== companyId) return
loadingCompanyId = null
emit({ ...state, companyId, connections })
}
/** Fetch failed: release the claim so a later mount can retry. */
export function releaseConnectionsLoad(companyId: string): void {
if (loadingCompanyId === companyId) loadingCompanyId = null
}
export function setBusyConnection(connectionId: string | null): void {
if (state.busyId === connectionId) return
emit({ ...state, busyId: connectionId })
}
/** Clear busy only if this connection still owns it (mirrors the old
* `setBusyId(prev => prev === id ? null : prev)` guard). */
export function clearBusyConnection(connectionId: string): void {
if (state.busyId !== connectionId) return
emit({ ...state, busyId: null })
}
export function setSyncingAll(syncingAll: boolean): void {
if (state.syncingAll === syncingAll) return
emit({ ...state, syncingAll })
}
/** Reflect a status change (e.g. a sync hit a dead PSD2 session) on every
* surface at once. */
export function markConnectionStatus(connectionId: string, status: string): void {
if (!state.connections) return
emit({
...state,
connections: state.connections.map((c) =>
c.id === connectionId ? { ...c, status } : c,
),
})
}
/** Reset to the initial state (tests, sign-out). */
export function resetBankSyncStore(): void {
loadingCompanyId = null
emit(INITIAL_STATE)
}