this repo has no description
Polish sharing: useInbox hook, cancelled guard, share cache, permanent doc errors
- Extract web-local useInbox hook (apps/web/src/hooks/use-inbox.ts) using
getOpake() singleton; bootstraps InboxKeeper exactly once across concurrent
mounts; wires into shared.lazy.tsx replacing inline subscription logic (#15/#18)
- Add per-effect-invocation cancelled flag to shared.lazy.tsx async batch
resolver, preventing setState on stale/unmounted invocations (#17)
- Cache getActiveFileManager().listShares() in ShareManagementDialog with a
30s TTL; invalidated on revoke so repeated dialog opens skip the round-trip (#12)
- Track permanent document errors (NotFound/InvalidRecord/Decryption/Serialization)
across a retry_pending_shares pass; subsequent pending shares for the same
broken document skip the PDS round-trip (#13)
- Rename ShareDialog local `handle` variable to `recipient`; resolved identity
renamed to `resolved` to eliminate the shadow (#16)
+158
-31
+62
apps/web/src/hooks/use-inbox.ts
+62
apps/web/src/hooks/use-inbox.ts
···
1
+
// useInbox — subscription-based inbox hook for the web app.
2
+
//
3
+
// Mirrors `@opake/react`'s useInbox but uses the module-level `getOpake()`
4
+
// singleton rather than the `OpakeProvider` context (which isn't wired up
5
+
// in this app yet).
6
+
//
7
+
// Behaviour:
8
+
// - Installs a watcher on mount; closes it on unmount
9
+
// - Bootstraps via `opake.listInbox()` exactly once across concurrent mounts
10
+
// - Subsequent SSE `grant:upsert` / `grant:delete` events patch the keeper
11
+
// - First watcher fire with `loaded = true` (warm restart) is fast-path —
12
+
// no bootstrap needed
13
+
14
+
import { useEffect, useState } from "react";
15
+
import type { InboxGrant, InboxSnapshot } from "@opake/sdk";
16
+
import { getOpake } from "@/stores/auth";
17
+
18
+
// Wrapped in a const object because functional/no-let prohibits module-level `let`.
19
+
const _bootstrap = { promise: null as Promise<unknown> | null };
20
+
21
+
interface UseInboxResult {
22
+
/** Current inbox entries. Empty array before bootstrap completes. */
23
+
readonly grants: readonly InboxGrant[];
24
+
/**
25
+
* `true` until the keeper has been bootstrapped at least once.
26
+
* After bootstrap, `grants` is authoritative even when empty.
27
+
*/
28
+
readonly isLoading: boolean;
29
+
}
30
+
31
+
export function useInbox(): UseInboxResult {
32
+
const [snapshot, setSnapshot] = useState<InboxSnapshot | null>(null);
33
+
34
+
useEffect(() => {
35
+
const watcher = getOpake().watchInbox((snap) => {
36
+
setSnapshot(snap);
37
+
38
+
// Bootstrap exactly once: only needed when the keeper hasn't loaded yet
39
+
// and no bootstrap is already in flight. Once `snap.loaded` flips to
40
+
// true (after the first listInbox completes), this guard never fires again.
41
+
if (!snap.loaded && !_bootstrap.promise) {
42
+
// eslint-disable-next-line functional/immutable-data -- module-level dedup flag for bootstrap
43
+
_bootstrap.promise = getOpake()
44
+
.listInbox()
45
+
.catch((err: unknown) => {
46
+
console.warn("[shared] listInbox bootstrap failed:", err);
47
+
})
48
+
.finally(() => {
49
+
// eslint-disable-next-line functional/immutable-data -- clear after bootstrap
50
+
_bootstrap.promise = null;
51
+
});
52
+
}
53
+
});
54
+
55
+
return () => watcher.close();
56
+
}, []);
57
+
58
+
return {
59
+
grants: snapshot?.entries ?? [],
60
+
isLoading: !snapshot?.loaded,
61
+
};
62
+
}
+33
-4
crates/opake-core/src/sharing/pending.rs
+33
-4
crates/opake-core/src/sharing/pending.rs
···
5
5
// retries periodically. On success, a grant is created and the pending
6
6
// record is deleted.
7
7
8
-
use std::collections::HashMap;
8
+
use std::collections::{HashMap, HashSet};
9
9
10
10
use log::{info, trace, warn};
11
11
···
150
150
// crypto unwrap when multiple pending shares reference the same document.
151
151
let mut content_key_cache: HashMap<String, ContentKey> = HashMap::new();
152
152
153
+
// Track document URIs where the content-key fetch failed with a permanent
154
+
// error (document deleted, record corrupted, or decryption failure).
155
+
// Unlike transient errors, these won't heal on retry — skip subsequent
156
+
// pending shares that reference the same broken document in this pass.
157
+
let mut permanent_document_errors: HashSet<String> = HashSet::new();
158
+
153
159
for entry in &entries {
154
160
let at_uri = match atproto::parse_at_uri(&entry.uri) {
155
161
Ok(u) => u,
···
222
228
entry.uri, entry.recipient
223
229
);
224
230
225
-
// Fetch content key (cached per document)
231
+
// Fetch content key (cached per document).
232
+
// Skip immediately for documents that already failed with a permanent
233
+
// error earlier in this pass — no point hammering the PDS again.
234
+
if permanent_document_errors.contains(&entry.document) {
235
+
result.failed += 1;
236
+
continue;
237
+
}
238
+
226
239
let content_key = match content_key_cache.get(&entry.document) {
227
240
Some(key) => key.clone(),
228
241
None => {
···
239
252
key
240
253
}
241
254
Err(e) => {
255
+
// Permanent failures: document was deleted, the record is
256
+
// corrupt, or the content-key ciphertext won't unwrap.
257
+
// Mark the document URI so sibling pending shares for the
258
+
// same document skip the round-trip.
259
+
let permanent = matches!(
260
+
e,
261
+
Error::NotFound(_)
262
+
| Error::InvalidRecord(_)
263
+
| Error::Decryption(_)
264
+
| Error::Serialization(_)
265
+
);
242
266
warn!(
243
-
"pending share {}: failed to fetch content key for {}: {e}",
244
-
entry.uri, entry.document
267
+
"pending share {}: failed to fetch content key for {} ({}): {e}",
268
+
entry.uri,
269
+
entry.document,
270
+
if permanent { "permanent" } else { "transient" },
245
271
);
272
+
if permanent {
273
+
permanent_document_errors.insert(entry.document.clone());
274
+
}
246
275
result.failed += 1;
247
276
continue;
248
277
}