SqliteAtNotificationKeystore class

SQLite-backed AtNotificationKeystore (notifications table). A KeyValueStore<String, AtNotification> — no commit log, no metadata triplet — plus the notification-specific init / iterate surface.

Implemented types

Properties

changes → Stream<KeyStoreChange>
Broadcast stream of KeyStoreChange events — one per successful mutation that affects the key set or stored value. Late subscribers do not receive earlier events.
no setteroverride
hashCode → int
The hash code for this object.
no setterinherited
postRemoveHooks → List<Future<void> Function(String key, {required bool skipCommit})>
Hooks invoked synchronously after a single-key remove. Each hook is awaited in order. Hook exceptions are propagated to the caller after the remove has already happened.
final
preRemoveHooks → List<Future<void> Function(String key, {required bool skipCommit})>
Hooks invoked synchronously before a single-key remove. Each hook is awaited in order; if a hook throws, the remove is aborted and the exception propagates.
final
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
supportsSnapshots → bool
true when this keystore can produce real isolated snapshots (snapshot returns a handle whose reads observe the keystore's state at snapshot-creation time, ignoring concurrent writes). false when the handle delegates to live state (Hive backends).
no setteroverride

Methods

clear() → Future<void>
Drops all rows (keeping the connection open) for test isolation.
close() → Future<void>
Close the underlying storage handle.
override
compact(bool dryRun) → Stream<String>
Compact the notification queue. If dryRun is true, yields each notification key that WOULD be removed without performing the deletion. If false, performs the compaction and yields each key as it is removed.
override
create(String key, AtNotification value, {bool skipCommit = false}) → Future<int?>
If no mapping exists for key, associates it with value and returns the commit-log sequence number; otherwise behaviour is implementation-defined (typically throws).
override
deleteExpiredKeys() → Future<bool>
Removes all expired keys. Deletes are local-only — they are NOT appended to the commit log, so an expiry sweep never advances the local commitId and never propagates to other secondaries via sync. Expiry is treated as backend maintenance, not a sync-worthy mutation; clients drop expired keys independently using their own TTL bookkeeping.
override
entriesCount() → int
Total entry count. Used by operators / metrics.
override
exists(String key) → Future<bool>
Returns true if the keystore currently contains key, else false. The backend-agnostic existence check — the same call site works against every backend.
override
get(String key) → Future<AtNotification?>
Retrieves the value mapped to key, or null if no mapping exists. Implementations may also throw a backend-specific not-found exception (e.g. KeyNotFoundException) instead of returning null — consult the concrete impl.
override
getExpiredKeys() → Future<Stream<String>>
Streams all keys that have expired. The returned Future completes once the backend has accepted the request (surfacing any setup failure eagerly); the Stream then yields the keys.
override
getKeys({String? regex}) → Future<Stream<String>>
Streams the keys, optionally filtered by regex. The returned Future completes once the backend has accepted the request — setup failures (store not open, invalid regex) reject the Future eagerly rather than surfacing mid-stream; the Stream then yields the matching keys.
override
getMany(List<String> keys) → Future<Map<String, AtNotification>>
Bulk fetch — returns the values for every key in keys that is currently present. Keys that are absent are NOT included in the returned map.
override
getSize() → int
Approximate on-disk size in bytes.
override
init(String path) → Future<void>
Initialize the underlying storage rooted at path. Called once at bootstrap; implementation-defined what path means (directory for Hive, connection string for SQL backends, ...).
override
initialize() → Future<void>
Subclasses should put any necessary post-construction async initialization in this method.
override
iterate() → Stream<AtNotification>
Iterate every notification entry. Used by the persistence migrator to copy notification content from one backend to another.
override
nextExpiresAt() → Future<DateTime?>
Smallest non-null expiry instant across all entries, or null if no entry has one set. Drives expiry-cron wake-up: a caller can sleep until the returned time, then call peekExpired or deleteExpiredKeys to drain.
override
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
peekExpired({DateTime? asOf, int? limit}) → Future<Stream<String>>
Up to limit keys whose expiry instant is at-or-before asOf (default: now), in ascending-expiry order. limit: 1 answers "which key is next to expire". limit: null means no limit — the same set as getExpiredKeys, but with guaranteed ascending-expiry ordering. Ties (same expiry instant) are yielded in implementation-defined order.
override
put(String key, AtNotification value, {bool skipCommit = false}) → Future<int?>
Associates value with key. If a mapping already exists, the old value is replaced.
override
remove(String key, {bool skipCommit = false}) → Future<int?>
Removes the mapping for key if present.
override
removeMany(List<String> keys, {bool skipCommit = false}) → Future<int>
Bulk delete — removes every key in keys. Returns the count of keys actually removed (race-tolerant: input keys may already have been deleted).
override
snapshot() → Future<KeyStoreSnapshot<String, AtNotification, dynamic>>
Take a snapshot of the keystore's current state. Always release the handle when done.
override
stats() → Future<KeyStoreStats>
Diagnostic snapshot of the keystore's state — total counts, TTL/TTB key counts, approximate size, oldest/newest timestamps. Intended for operator dashboards, not for runtime decisions on a hot path.
override
toString() → String
A string representation of this object.
inherited
transaction<R>(Future<R> body(KeyStoreTxn<String, AtNotification, dynamic> txn)) → Future<R>
Run body as a transaction. Mutations performed via the supplied handle are buffered in memory and applied in body order on successful completion; if the body throws, the buffer is dropped and the exception propagates.
override

Operators

operator ==(Object other) → bool
The equality operator.
inherited