diff --git a/src/features/enterprise/EntrySheet.tsx b/src/features/enterprise/EntrySheet.tsx
index 9fe11d3..da7c8b4 100644
--- a/src/features/enterprise/EntrySheet.tsx
+++ b/src/features/enterprise/EntrySheet.tsx
@@ -1,6 +1,7 @@
import { useState } from 'react'
+import { useQueryClient } from '@tanstack/react-query'
import type { LedgerKind } from '../../lib/api'
-import { CATEGORIES, addEntry } from '../../lib/ledgerStore'
+import { CATEGORIES, addEntry, syncPending } from '../../lib/ledgerStore'
import { useLang } from '../../lib/i18n'
import { inr } from '../../lib/demo/seed'
@@ -32,14 +33,23 @@ export function EntrySheet({
const [amount, setAmount] = useState('')
const [category, setCategory] = useState(CATEGORIES[kind][0].code)
const [done, setDone] = useState(false)
+ const queryClient = useQueryClient()
const hi = lang === 'hi'
const meta = KIND_META[kind]
const value = Number(amount) || 0
function save() {
if (value <= 0) return
+ // Local first, always. The entry is the owner's the moment they tap save;
+ // reaching the lender is our problem, not theirs.
addEntry({ enterpriseId, kind, amount: value, category })
setDone(true)
+ // Then try to send. A failure is silent by design — the entry stays PENDING
+ // and the next pass picks it up.
+ void syncPending(enterpriseId).then(() => {
+ void queryClient.invalidateQueries({ queryKey: ['app-ledger'] })
+ void queryClient.invalidateQueries({ queryKey: ['app-home'] })
+ })
setTimeout(onClose, 900)
}
diff --git a/src/lib/ledgerStore.ts b/src/lib/ledgerStore.ts
index e36ba3a..2d34d2d 100644
--- a/src/lib/ledgerStore.ts
+++ b/src/lib/ledgerStore.ts
@@ -1,5 +1,6 @@
import { useCallback, useEffect, useState } from 'react'
import type { LedgerEntry, LedgerKind } from './api'
+import { syncAppLedger } from './api'
import { dayOffsetIso, pickInt, pickOne, rng, seedOf, todayIso } from './demo/seed'
/*
@@ -110,24 +111,38 @@ export function pendingCount(enterpriseId: string): number {
}
/**
- * Drain the queue. The backend endpoint lands in a later pass — until then this
- * flips PENDING → SYNCED locally so the UI's sync states are exercisable.
+ * Drain the offline queue to the server.
+ *
+ * This was the missing half of the offline promise. Entries were written to
+ * localStorage and marked PENDING, and this function flipped them to SYNCED
+ * without anything leaving the phone — so an owner could record a sale with no
+ * signal, which was the point, but it never reached the lender and the officer's
+ * screen never saw it.
+ *
+ *
Safe to call whenever. The server dedupes on `clientId`, which the phone
+ * minted, so a retry after a half-failed sync writes nothing twice. Entries that
+ * fail to send stay PENDING and go again on the next pass rather than being
+ * dropped — losing an owner's tap is the one failure this app cannot have, so a
+ * network error is deliberately silent from their side.
*/
-export function syncPending(enterpriseId: string): number {
- const all = read()
- let n = 0
- const next = all.map((e) => {
- if (e.enterpriseId === enterpriseId && e.syncState === 'PENDING') {
- n++
- return { ...e, syncState: 'SYNCED' as const }
- }
- return e
- })
- if (n) {
- write(next)
- localStorage.setItem(SYNC_KEY, new Date().toISOString())
+export async function syncPending(enterpriseId: string): Promise {
+ const pending = read().filter(
+ (e) => e.enterpriseId === enterpriseId && e.syncState === 'PENDING',
+ )
+ if (pending.length === 0) return 0
+
+ try {
+ await syncAppLedger(pending)
+ } catch {
+ return 0
}
- return n
+
+ // Re-read rather than reusing the snapshot: the owner may have tapped save
+ // again while the request was in flight, and that entry must stay PENDING.
+ const sent = new Set(pending.map((e) => e.id))
+ write(read().map((e) => (sent.has(e.id) ? { ...e, syncState: 'SYNCED' as const } : e)))
+ localStorage.setItem(SYNC_KEY, new Date().toISOString())
+ return pending.length
}
export function lastSyncedAt(): string | null {
@@ -144,16 +159,53 @@ export function dayTotals(entries: LedgerEntry[], date = todayIso()) {
}
/** Live ledger for a given enterprise, re-reading whenever an entry is written. */
-export function useLedger(enterpriseId: string) {
- const [entries, setEntries] = useState(() => loadLedger(enterpriseId))
+/**
+ * The borrower.s ledger: what the server holds, plus anything typed on this
+ * device that has not synced yet.
+ *
+ * Local entries come first and win on `clientId`, which is minted on the
+ * phone. That is what makes the offline path honest — an entry recorded with no
+ * signal is visible immediately, and when it syncs the server copy replaces it
+ * without ever appearing twice.
+ */
+export function useLedger(enterpriseId: string, server: LedgerEntry[] = []) {
+ const [local, setLocal] = useState(() => loadLedger(enterpriseId))
- const refresh = useCallback(() => setEntries(loadLedger(enterpriseId)), [enterpriseId])
+ const refresh = useCallback(() => setLocal(loadLedger(enterpriseId)), [enterpriseId])
useEffect(() => {
refresh()
- window.addEventListener('ul-ledger-changed', refresh)
- return () => window.removeEventListener('ul-ledger-changed', refresh)
+ window.addEventListener("ul-ledger-changed", refresh)
+ return () => window.removeEventListener("ul-ledger-changed", refresh)
}, [refresh])
+ const seen = new Set(local.map((e) => e.id))
+ const entries = [...local, ...server.filter((e) => !seen.has(e.id))]
+ .sort((a, b) => b.entryDate.localeCompare(a.entryDate))
+
return { entries, refresh }
}
+
+/**
+ * Drain the queue whenever the network comes back.
+ *
+ * Without this the offline promise was only half kept: an entry recorded with
+ * no signal reached the lender on the owner's next save or manual tap,
+ * and an owner who recorded a sale and put the phone away never synced at all.
+ * The browser tells us when the radio returns; that is the moment to try.
+ *
+ *
Also runs once on mount, because the app is commonly opened after
+ * connectivity is restored rather than while it is being restored — in that
+ * case no `online` event ever fires.
+ */
+export function useAutoSync(enterpriseId: string | undefined) {
+ useEffect(() => {
+ if (!enterpriseId) return
+ const drain = () => {
+ void syncPending(enterpriseId)
+ }
+ drain()
+ window.addEventListener('online', drain)
+ return () => window.removeEventListener('online', drain)
+ }, [enterpriseId])
+}